From d62fb91cc57d67156ddbfe829a580dce493c1662 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 29 Sep 2022 00:17:26 +0800 Subject: [PATCH 001/725] fix jax breaking change --- CHANGELOG.md | 4 ++++ tensorcircuit/backends/jax_backend.py | 6 +++--- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7323f4af..cf9babb1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Fixed + +- Fixed the breaking change introduced in jax 0.3.18, `jax._src` is no longer imported into the from the public jax namespace. + ## 0.4.1 ### Added diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 965a26f6..b4ae3d97 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -440,7 +440,7 @@ def implicit_randn( g = getattr(self, "g", None) try: key, subkey = libjax.random.split(g) - except libjax._src.errors.UnexpectedTracerError: + except libjax.errors.UnexpectedTracerError: self.set_random_state() g = getattr(self, "g", None) key, subkey = libjax.random.split(g) @@ -462,7 +462,7 @@ def implicit_randu( g = getattr(self, "g", None) try: key, subkey = libjax.random.split(g) - except libjax._src.errors.UnexpectedTracerError: + except libjax.errors.UnexpectedTracerError: self.set_random_state() g = getattr(self, "g", None) key, subkey = libjax.random.split(g) @@ -482,7 +482,7 @@ def implicit_randc( g = getattr(self, "g", None) try: key, subkey = libjax.random.split(g) - except libjax._src.errors.UnexpectedTracerError: + except libjax.errors.UnexpectedTracerError: self.set_random_state() g = getattr(self, "g", None) key, subkey = libjax.random.split(g) From 4f88492ab43dfa57c18d4a65296017eb337f1724 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 29 Sep 2022 16:57:31 +0800 Subject: [PATCH 002/725] delete duplicate phase gate definition --- examples/tcgates.inc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/examples/tcgates.inc b/examples/tcgates.inc index 86a971dd..163203dc 100644 --- a/examples/tcgates.inc +++ b/examples/tcgates.inc @@ -88,7 +88,8 @@ gate fredkin a, b, c {cswap a, b, c; } gate cnot a, b {cx a, b; } gate sd a, b {sdg a, b; } gate td a, b {tdg a, b; } -gate phase(λ) a { ctrl @ gphase(λ) a; } +// gate phase(λ) a { ctrl @ gphase(λ) a; } +// double check whether phase and p is consistent // Neg control gates From b8f8d3f27c95769d50a32a3c5289112dd30758c5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 8 Oct 2022 20:14:56 +0800 Subject: [PATCH 003/725] add finite shots parameter shift --- CHANGELOG.md | 10 +++ examples/sample_value_gradient.py | 106 ++++++++++++++++++++++++++++++ tensorcircuit/basecircuit.py | 32 ++++++--- tensorcircuit/experimental.py | 75 +++++++++++++++++++++ tensorcircuit/quantum.py | 3 +- tests/test_dmcircuit.py | 1 + 6 files changed, 216 insertions(+), 11 deletions(-) create mode 100644 examples/sample_value_gradient.py diff --git a/CHANGELOG.md b/CHANGELOG.md index cf9babb1..7bdef6af 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,10 +2,20 @@ ## Unreleased +### Added + +- Add new parameter shift gradient API that supports finite measurement shots and the corresponding example scripts + +### Changed + +- The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed + ### Fixed - Fixed the breaking change introduced in jax 0.3.18, `jax._src` is no longer imported into the from the public jax namespace. +- `tc.quantum.correlation_from_samples` now fix the sign error with odd number of spins + ## 0.4.1 ### Added diff --git a/examples/sample_value_gradient.py b/examples/sample_value_gradient.py new file mode 100644 index 00000000..52c489fb --- /dev/null +++ b/examples/sample_value_gradient.py @@ -0,0 +1,106 @@ +""" +Evaluate expectation and gradient on Pauli string sum with finite measurement shots +""" +from functools import partial +import numpy as np +import tensorcircuit as tc +from tensorcircuit import experimental as E + +K = tc.set_backend("jax") + +n = 5 +nlayers = 4 +ps = [] +for i in range(n): + l = [0 for _ in range(n)] + l[i] = 1 + ps.append(l) +for i in range(n - 1): + l = [0 for _ in range(n)] + l[i] = 3 + l[i + 1] = 3 + ps.append(l) + + +w = [-1.0 for _ in range(n)] + [1.0 for _ in range(n - 1)] + + +def generate_circuit(param): + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayers): + for i in range(n - 1): + c.rzz(i, i + 1, theta=param[i, j, 0]) + for i in range(n): + c.rx(i, theta=param[i, j, 1]) + return c + + +def sample_exp(c, ps, w, shots, key): + if isinstance(shots, int): + shots = [shots for _ in range(len(ps))] + loss = 0 + for psi, wi, shot in zip(ps, w, shots): + key, subkey = K.random_split(key) + xyz = {"x": [], "y": [], "z": []} + for i, j in enumerate(psi): + if j == 1: + xyz["x"].append(i) + if j == 2: + xyz["y"].append(i) + if j == 3: + xyz["z"].append(i) + loss += wi * c.sample_expectation_ps(**xyz, shots=shot, random_generator=subkey) + return loss + + +@K.jit +def exp_val_analytical(param): + c = generate_circuit(param) + loss = 0 + for psi, wi in zip(ps, w): + xyz = {"x": [], "y": [], "z": []} + for i, j in enumerate(psi): + if j == 1: + xyz["x"].append(i) + if j == 2: + xyz["y"].append(i) + if j == 3: + xyz["z"].append(i) + loss += wi * c.expectation_ps(**xyz) + return K.real(loss) + + +@partial(K.jit, static_argnums=2) +def exp_val(param, key, shots=40960): + # from circuit parameter to expectation + c = generate_circuit(param) + return sample_exp(c, ps, w, shots, key=key) + + +print("benchmarking sample expectation") +tc.utils.benchmark( + exp_val, K.ones([n, nlayers, 2], dtype="float32"), K.get_random_state(42) +) +print("benchmarking analytical expectation") +tc.utils.benchmark(exp_val_analytical, K.ones([n, nlayers, 2], dtype="float32")) +r1 = exp_val(K.ones([n, nlayers, 2], dtype="float32"), K.get_random_state(42)) +r2 = exp_val_analytical(K.ones([n, nlayers, 2], dtype="float32")) +np.testing.assert_allclose(r1, r2, atol=0.05, rtol=0.01) +print("correctness check passed for expectation value") +gradf1 = K.jit(E.parameter_shift_grad_v2(exp_val, argnums=0, random_argnums=1)) +gradf2 = K.jit(K.grad(exp_val_analytical)) +print("benchmarking sample gradient") +tc.utils.benchmark( + gradf1, K.ones([n, nlayers, 2], dtype="float32"), K.get_random_state(42) +) +print("benchmarking analytical gradient") +tc.utils.benchmark(gradf2, K.ones([n, nlayers, 2], dtype="float32")) +r1 = gradf1(K.ones([n, nlayers, 2], dtype="float32"), K.get_random_state(42)) +r2 = gradf2(K.ones([n, nlayers, 2], dtype="float32")) +print("gradient with measurement shot and parameter shift") +print(r1) +print(r2) +np.testing.assert_allclose(r1, r2, atol=0.2, rtol=0.01) +print("correctness check passed for gradients") diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index fdeac033..907c8950 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -14,6 +14,7 @@ from .quantum import ( QuOperator, QuVector, + correlation_from_samples, correlation_from_counts, measurement_counts, sample_int2bin, @@ -635,23 +636,34 @@ def sample_expectation_ps( for i in y: c.rx(i, theta=np.pi / 2) # type: ignore s = c.state() # type: ignore - if c.is_dm is False: + if self.is_dm is False: p = backend.abs(s) ** 2 else: p = backend.abs(backend.diagonal(s)) # readout error can be processed here later - mc = measurement_counts( - p, - counts=shots, - format="count_vector", - random_generator=random_generator, - jittable=True, - is_prob=True, - ) x = list(x) y = list(y) z = list(z) - r = correlation_from_counts(x + y + z, mc) + if shots is None: + mc = measurement_counts( + p, + counts=shots, + format="count_vector", + random_generator=random_generator, + jittable=True, + is_prob=True, + ) + r = correlation_from_counts(x + y + z, mc) + else: + mc = measurement_counts( + p, + counts=shots, + format="sample_bin", + random_generator=random_generator, + jittable=True, + is_prob=True, + ) + r = correlation_from_samples(x + y + z, mc, self._nqubits) # TODO(@refraction-ray): analytical standard deviation return r diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 137e81a1..2f2a4de5 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -258,3 +258,78 @@ def grad_f(*args: Any, **kws: Any) -> Any: return grad_values[0] return grad_f + + +def parameter_shift_grad_v2( + f: Callable[..., Tensor], + argnums: Union[int, Sequence[int]] = 0, + jit: bool = False, + random_argnums: Optional[Sequence[int]] = None, +) -> Callable[..., Tensor]: + """ + similar to `grad` function but using parameter shift internally instead of AD, + vmap is utilized for evaluation, so the speed is still ok + + :param f: quantum function with weights in and expectation out + :type f: Callable[..., Tensor] + :param argnums: label which args should be differentiated, + defaults to 0 + :type argnums: Union[int, Sequence[int]], optional + :param jit: whether jit the original function `f` at the beginning, + defaults to False + :type jit: bool, optional + :return: the grad function + :rtype: Callable[..., Tensor] + """ + # TODO(@refraction-ray): finite shot sample_expectation_ps not supported well for now + if jit is True: + f = backend.jit(f) + + if isinstance(argnums, int): + argnums = [argnums] + + if random_argnums is None: + vfs = [backend.vmap(f, vectorized_argnums=i) for i in argnums] + else: + if isinstance(random_argnums, int): + random_argnums = [random_argnums] + vfs = [ + backend.vmap(f, vectorized_argnums=[i] + random_argnums) for i in argnums # type: ignore + ] + + def grad_f(*args: Any, **kws: Any) -> Any: + grad_values = [] + for i in argnums: # type: ignore + shape = backend.shape_tuple(args[i]) + size = backend.sizen(args[i]) + onehot = backend.eye(size) + onehot = backend.cast(onehot, args[i].dtype) + onehot = backend.reshape(onehot, [size] + list(shape)) + onehot = np.pi / 2 * onehot + nargs = list(args) + arg = backend.reshape(args[i], [1] + list(shape)) + batched_arg = backend.tile(arg, [size] + [1 for _ in shape]) + nargs[i] = batched_arg + onehot + nargs2 = list(args) + nargs2[i] = batched_arg - onehot + if random_argnums is not None: + for j in random_argnums: + keys = [] + key = args[j] + for _ in range(size): + key, subkey = backend.random_split(key) + keys.append(subkey) + nargs[j] = backend.stack(keys) + keys = [] + for _ in range(size): + key, subkey = backend.random_split(key) + keys.append(subkey) + nargs2[j] = backend.stack(keys) + r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / 2.0 + r = backend.reshape(r, shape) + grad_values.append(r) + if len(argnums) > 1: # type: ignore + return tuple(grad_values) + return grad_values[0] + + return grad_f diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 47d7736b..92c4b910 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -2185,10 +2185,11 @@ def correlation_from_samples(index: Sequence[int], results: Tensor, n: int) -> T """ if len(backend.shape_tuple(results)) == 1: results = sample_int2bin(results, n) - results = results * 2 - 1 + results = 1 - results * 2 r = results[:, index[0]] for i in index[1:]: r *= results[:, i] + r = backend.cast(r, rdtypestr) return backend.mean(r) diff --git a/tests/test_dmcircuit.py b/tests/test_dmcircuit.py index a8117267..674e1f5d 100644 --- a/tests/test_dmcircuit.py +++ b/tests/test_dmcircuit.py @@ -498,6 +498,7 @@ def test_dm_sexpps(backend): ye = c.expectation_ps(x=[1], y=[0], z=[2, 3]) np.testing.assert_allclose(ye, y, atol=1e-5) y2 = c.sample_expectation_ps(x=[1], y=[0], z=[2, 3], shots=81920) + print(y, y2) assert np.abs(y2 - y) < 0.015 From 77e0d9fd13cd6c7da83cd674177df1a957507804 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 8 Oct 2022 20:45:35 +0800 Subject: [PATCH 004/725] fix example sample --- examples/sample_value_gradient.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/examples/sample_value_gradient.py b/examples/sample_value_gradient.py index 52c489fb..841bc507 100644 --- a/examples/sample_value_gradient.py +++ b/examples/sample_value_gradient.py @@ -73,7 +73,7 @@ def exp_val_analytical(param): @partial(K.jit, static_argnums=2) -def exp_val(param, key, shots=40960): +def exp_val(param, key, shots=4096): # from circuit parameter to expectation c = generate_circuit(param) return sample_exp(c, ps, w, shots, key=key) @@ -89,12 +89,13 @@ def exp_val(param, key, shots=40960): r2 = exp_val_analytical(K.ones([n, nlayers, 2], dtype="float32")) np.testing.assert_allclose(r1, r2, atol=0.05, rtol=0.01) print("correctness check passed for expectation value") -gradf1 = K.jit(E.parameter_shift_grad_v2(exp_val, argnums=0, random_argnums=1)) +gradf1 = E.parameter_shift_grad_v2(exp_val, argnums=0, random_argnums=1) gradf2 = K.jit(K.grad(exp_val_analytical)) print("benchmarking sample gradient") tc.utils.benchmark( gradf1, K.ones([n, nlayers, 2], dtype="float32"), K.get_random_state(42) ) +# n=12, nlayers=4, 276s + 0.75s print("benchmarking analytical gradient") tc.utils.benchmark(gradf2, K.ones([n, nlayers, 2], dtype="float32")) r1 = gradf1(K.ones([n, nlayers, 2], dtype="float32"), K.get_random_state(42)) From 0fe0ce1142abd21c94112fca3dc2f81334584535 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 9 Oct 2022 10:02:00 +0800 Subject: [PATCH 005/725] attached microbenchmark info on the example --- examples/sample_value_gradient.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/examples/sample_value_gradient.py b/examples/sample_value_gradient.py index 841bc507..1646f718 100644 --- a/examples/sample_value_gradient.py +++ b/examples/sample_value_gradient.py @@ -7,6 +7,7 @@ from tensorcircuit import experimental as E K = tc.set_backend("jax") +# note this script only supports jax backend n = 5 nlayers = 4 @@ -95,7 +96,7 @@ def exp_val(param, key, shots=4096): tc.utils.benchmark( gradf1, K.ones([n, nlayers, 2], dtype="float32"), K.get_random_state(42) ) -# n=12, nlayers=4, 276s + 0.75s +# n=12, nlayers=4, 276s + 0.75s, mac CPU print("benchmarking analytical gradient") tc.utils.benchmark(gradf2, K.ones([n, nlayers, 2], dtype="float32")) r1 = gradf1(K.ones([n, nlayers, 2], dtype="float32"), K.get_random_state(42)) From 4eab0ec5846905591249742f5b9a40f73d39f8a5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 11 Oct 2022 16:37:55 +0800 Subject: [PATCH 006/725] add integrated vqe example with finite sample noise and parameter shift --- examples/vqe_shot_noise.py | 177 ++++++++++++++++++++++++++++++++++ tensorcircuit/experimental.py | 4 +- 2 files changed, 180 insertions(+), 1 deletion(-) create mode 100644 examples/vqe_shot_noise.py diff --git a/examples/vqe_shot_noise.py b/examples/vqe_shot_noise.py new file mode 100644 index 00000000..9c2a88ba --- /dev/null +++ b/examples/vqe_shot_noise.py @@ -0,0 +1,177 @@ +""" +VQE with finite measurement shot noise +""" +from functools import partial +import numpy as np +from scipy import optimize +import optax +import tensorcircuit as tc +from tensorcircuit import experimental as E + +K = tc.set_backend("jax") +# note this script only supports jax backend + +n = 6 +nlayers = 4 + +# We use OBC 1D TFIM Hamiltonian in this script + +ps = [] +for i in range(n): + l = [0 for _ in range(n)] + l[i] = 1 + ps.append(l) + # X_i +for i in range(n - 1): + l = [0 for _ in range(n)] + l[i] = 3 + l[i + 1] = 3 + ps.append(l) + # Z_i Z_i+1 +w = [-1.0 for _ in range(n)] + [1.0 for _ in range(n - 1)] + + +def generate_circuit(param): + # construct the circuit ansatz + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayers): + for i in range(n - 1): + c.rzz(i, i + 1, theta=param[i, j, 0]) + for i in range(n): + c.rx(i, theta=param[i, j, 1]) + return c + + +def ps2xyz(psi): + # ps2xyz([1, 2, 2, 0]) = {"x": [0], "y": [1, 2], "z": []} + xyz = {"x": [], "y": [], "z": []} + for i, j in enumerate(psi): + if j == 1: + xyz["x"].append(i) + if j == 2: + xyz["y"].append(i) + if j == 3: + xyz["z"].append(i) + return xyz + + +@partial(K.jit, static_argnums=(2)) +def exp_val(param, key, shots=1024): + # expectation with shot noise + # ps, w: H = \sum_i w_i ps_i + # describing the system Hamiltonian as a weighted sum of Pauli string + c = generate_circuit(param) + if isinstance(shots, int): + shots = [shots for _ in range(len(ps))] + loss = 0 + for psi, wi, shot in zip(ps, w, shots): + key, subkey = K.random_split(key) + xyz = ps2xyz(psi) + loss += wi * c.sample_expectation_ps(**xyz, shots=shot, random_generator=subkey) + return K.real(loss) + + +@K.jit +def exp_val_analytical(param): + c = generate_circuit(param) + loss = 0 + for psi, wi in zip(ps, w): + xyz = ps2xyz(psi) + loss += wi * c.expectation_ps(**xyz) + return K.real(loss) + + +# 0. Exact result + +hm = tc.quantum.PauliStringSum2COO(ps, w, numpy=True) +hm = K.to_dense(hm) +e, v = np.linalg.eigh(hm) +print("exact ground state energy: ", e[0]) + +# 1.1 VQE with numerically exact expectation: gradient free + +print("VQE without shot noise") + +exp_val_analytical_sp = tc.interfaces.scipy_interface( + exp_val_analytical, shape=[n, nlayers, 2], gradient=False +) + +r = optimize.minimize( + exp_val_analytical_sp, + np.zeros([n * nlayers * 2]), + method="COBYLA", + options={"maxiter": 5000}, +) +print(r) + + +# 1.2 VQE with numerically exact expectation: gradient based + +exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 +) +opt = K.optimizer(optax.adam(exponential_decay_scheduler)) +param = K.implicit_randn([n, nlayers, 2], stddev=0.1) # zeros stall the gradient +exp_val_grad_analytical = K.jit(K.value_and_grad(exp_val_analytical)) +for i in range(1000): + e, g = exp_val_grad_analytical(param) + param = opt.update(g, param) + if i % 100 == 99: + print(e) + + +# 2.1 VQE with finite shot noise: gradient free + +print("VQE with shot noise") + + +rkey = K.get_random_state(42) + + +def exp_val_wrapper(param): + global rkey + rkey, skey = K.random_split(rkey) + # maintain stateless randomness in scipy optimize interface + return exp_val(param, skey, shots=1024) + + +exp_val_sp = tc.interfaces.scipy_interface( + exp_val_wrapper, shape=[n, nlayers, 2], gradient=False +) + +r = optimize.minimize( + exp_val_sp, + np.random.normal(scale=0.1, size=[n * nlayers * 2]), + method="COBYLA", + options={"maxiter": 5000}, +) +print(r) + +# the real energy position after optimization + +print("converged as: ", exp_val_analytical_sp(r["x"])) + + +# 2.2 VQE with finite shot noise: gradient based + +exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 +) +opt = K.optimizer(optax.adam(exponential_decay_scheduler)) +param = K.implicit_randn([n, nlayers, 2], stddev=0.1) # zeros stall the gradient +exp_grad = E.parameter_shift_grad_v2(exp_val, argnums=0, random_argnums=1) +rkey = K.get_random_state(42) + +for i in range(1000): + rkey, skey = K.random_split(rkey) + g = exp_grad(param, skey) + param = opt.update(g, param) + if i % 100 == 99: + rkey, skey = K.random_split(rkey) + print(exp_val(param, skey)) + +# the real energy position after optimization + +print("converged as:", exp_val_analytical(param)) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 2f2a4de5..8d969d7c 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -268,7 +268,9 @@ def parameter_shift_grad_v2( ) -> Callable[..., Tensor]: """ similar to `grad` function but using parameter shift internally instead of AD, - vmap is utilized for evaluation, so the speed is still ok + vmap is utilized for evaluation, v2 also supports random generator for finite + measurememt shot, only jax backend is supported, since no vmap randomness is + available in tensorflow :param f: quantum function with weights in and expectation out :type f: Callable[..., Tensor] From 1a8b389360b2d44cc7e5cc8648908e7ba65b669e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 12 Oct 2022 20:12:43 +0800 Subject: [PATCH 007/725] token system and cloud module --- tensorcircuit/cloud/__init__.py | 0 tensorcircuit/cloud/apis.py | 181 ++++++++++++++++++++++++++++++++ tensorcircuit/cloud/utils.py | 119 +++++++++++++++++++++ 3 files changed, 300 insertions(+) create mode 100644 tensorcircuit/cloud/__init__.py create mode 100644 tensorcircuit/cloud/apis.py create mode 100644 tensorcircuit/cloud/utils.py diff --git a/tensorcircuit/cloud/__init__.py b/tensorcircuit/cloud/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py new file mode 100644 index 00000000..f7199e9f --- /dev/null +++ b/tensorcircuit/cloud/apis.py @@ -0,0 +1,181 @@ +""" +main entrypoints of cloud module +""" + +from typing import Any, Callable, Optional, Dict, Sequence, Union +from base64 import b64decode, b64encode +from functools import partial, wraps +import json +import os +import sys + +from ..cons import backend + +package_name = "tensorcircuit" +thismodule = sys.modules[__name__] + + +class Provider: + activated_provider: Dict[str, "Provider"] = {} + + def __init__(self, name: str, lower: bool = True): + if lower is True: + name = name.lower() + self.name = name + + def __str__(self) -> str: + return self.name + + __repr__ = __str__ + + @classmethod + def from_name(cls, provider: Union[str, "Provider"] = "tencent") -> "Provider": + if provider is None: + provider = "tencent" + if isinstance(provider, cls): + p = provider + elif isinstance(provider, str): + if provider in cls.activated_provider: + return cls.activated_provider[provider] + else: + p = cls(provider) + cls.activated_provider[provider] = p + else: + raise ValueError( + "Unsupported format for `provider` argument: %s" % provider + ) + return p + + +class Device: + def __init__(self, name: str, lower: bool = False): + if lower is True: + name = name.lower() + self.name = name + + def __str__(self) -> str: + return self.name + + __repr__ = __str__ + + @classmethod + def from_name(cls, device: Optional[Union[str, "Device"]] = None) -> "Device": + if device is None: + raise ValueError("Must specify on device instead of default ``None``") + if isinstance(device, cls): + d = device + elif isinstance(device, str): + d = cls(device) + else: + raise ValueError("Unsupported format for `provider` argument: %s" % device) + return d + + +def convert_provider_device( + f: Callable[..., Any], + provider_argnums: Optional[Sequence[int]] = None, + device_argnums: Optional[Sequence[int]] = None, + provider_kws: Optional[Sequence[str]] = None, + device_kws: Optional[Sequence[str]] = None, +) -> Callable[..., Any]: + if provider_argnums is None: + provider_argnums = [] + if isinstance(provider_argnums, int): + provider_argnums = [provider_argnums] + if device_argnums is None: + device_argnums = [] + if isinstance(device_argnums, int): + device_argnums = [device_argnums] + if provider_kws is None: + provider_kws = [] + if device_kws is None: + device_kws = [] + + @wraps(f) + def wrapper(*args: Any, **kws: Any) -> Any: + nargs = list(args) + nkws = kws + for i, arg in enumerate(args): + if i in provider_argnums: # type: ignore + nargs[i] = Provider.from_name(arg) + elif i in device_argnums: # type: ignore + nargs[i] = Device.from_name(arg) + for k, v in kws.items(): + if k in provider_kws: # type: ignore + nkws[k] = Provider.from_name(v) + if k in device_kws: # type: ignore + nkws[k] = Device.from_name(v) + return f(*nargs, **nkws) + + return wrapper + + +@partial(convert_provider_device, provider_argnums=0, provider_kws="provider") +def set_provider(provider: Optional[str] = None, set_global: bool = True) -> Provider: + if set_global: + for module in sys.modules: + if module.startswith(package_name): + setattr(sys.modules[module], "provider", provider) + return provider # type: ignore + + +get_provider = partial(set_provider, set_global=False) + + +def b64encode_s(s: str) -> str: + return b64encode(s.encode("utf-8")).decode("utf-8") + + +def b64decode_s(s: str) -> str: + return b64decode(s.encode("utf-8")).decode("utf-8") + + +saved_token: Dict[str, Any] = {} + + +@partial( + convert_provider_device, + provider_argnums=1, + provider_kws="provider", + device_argnums=2, + device_kws="device", +) +def set_token( + token: Optional[str] = None, + provider: Optional[str] = None, + device: Optional[str] = None, + cached: bool = True, +) -> Dict[str, Any]: + global saved_token + tcdir = os.path.dirname(os.path.abspath(__file__)) + authpath = os.path.join(tcdir, "auth.json") + + if token is None: + if cached and os.path.exists(authpath): + with open(authpath, "r") as f: + file_token = json.load(f) + file_token = backend.tree_map(b64decode_s, file_token) + else: + file_token = {} + file_token.update(saved_token) + saved_token = file_token + else: # with token + if device is None: + if provider is None: + provider = Provider.from_name("tencent") # type: ignore + added_token = {provider.name + "~": token} # type: ignore + else: + added_token = {provider.name + "~" + device.name: token} # type: ignore + saved_token.update(added_token) + + if cached: + file_token = backend.tree_map(b64encode_s, saved_token) + with open(authpath, "w") as f: + json.dump(file_token, f) + + return saved_token + + +set_token() +# token json structure +# {"tencent~": token1, "tencent~20xmon": token2} diff --git a/tensorcircuit/cloud/utils.py b/tensorcircuit/cloud/utils.py new file mode 100644 index 00000000..2ef4fca1 --- /dev/null +++ b/tensorcircuit/cloud/utils.py @@ -0,0 +1,119 @@ +""" +utility functions for cloud connection +""" +from typing import Any, Callable, Optional +from functools import wraps +import inspect +import logging +import os +import sys +import time + +import requests + +# from simplejson.errors import JSONDecodeError + +logger = logging.getLogger(__name__) +thismodule = sys.modules[__name__] + + +class HttpStatusError(Exception): + """ + Used when the return request has http code beyond 200 + """ + + pass + + +# TODO(@refraction-ray): whether an exception hierarchy for tc is necessary? +connection_errors = ( + ConnectionResetError, + HttpStatusError, + requests.exceptions.RequestException, + requests.exceptions.ConnectionError, + requests.exceptions.SSLError, + # JSONDecodeError, +) + + +def set_proxy(proxy: Optional[str] = None) -> None: + """ + :param proxy: str. format as "http://user:passwd@host:port" user passwd part can be omitted if not set. + None for turning off the proxy. + :return: + """ + if proxy: + os.environ["http_proxy"] = proxy + os.environ["https_proxy"] = proxy + setattr(thismodule, "proxy", proxy) + else: + os.environ["http_proxy"] = "" + os.environ["https_proxy"] = "" + setattr(thismodule, "proxy", None) + + +def reconnect(tries: int = 5, timeout: int = 12) -> Callable[..., Any]: + # wrapper originally designed in xalpha + # https://github.com/refraction-ray/xalpha + def robustify(f: Callable[..., Any]) -> Callable[..., Any]: + @wraps(f) + def wrapper(*args: Any, **kws: Any) -> Any: + if getattr(thismodule, "proxy", None): + kws["proxies"] = { + "http": getattr(thismodule, "proxy"), + "https": getattr(thismodule, "proxy"), + } + logger.debug("Using proxy %s" % getattr(thismodule, "proxy")) + kws["timeout"] = timeout + if args: + url = args[0] + else: + url = kws.get("url", "") + headers = kws.get("headers", {}) + if (not headers.get("user-agent", None)) and ( + not headers.get("User-Agent", None) + ): + headers["user-agent"] = "Mozilla/5.0" + kws["headers"] = headers + for count in range(tries): + try: + logger.debug( + "Fetching url: %s . Inside function `%s`" + % (url, inspect.stack()[1].function) + ) + r = f(*args, **kws) + if ( + getattr(r, "status_code", 200) != 200 + ): # in case r is a json dict + raise HttpStatusError + return r + except connection_errors as e: + logger.warning("Fails at fetching url: %s. Try again." % url) + if count == tries - 1: + logger.error( + "Still wrong at fetching url: %s. after %s tries." + % (url, tries) + ) + logger.error("Fails due to %s" % e.args[0]) + raise e + time.sleep(0.5 * count) + + return wrapper + + return robustify + + +rget = reconnect()(requests.get) +rpost = reconnect()(requests.post) + + +@reconnect() +def rget_json(*args: Any, **kws: Any) -> Any: + r = requests.get(*args, **kws) + return r.json() + + +@reconnect() +def rpost_json(*args: Any, **kws: Any) -> Any: + r = requests.post(*args, **kws) + return r.json() From 77bcecd84ebe52947d0840fe1b43b85e8e036eb1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 12 Oct 2022 20:50:35 +0800 Subject: [PATCH 008/725] add get_token --- tensorcircuit/cloud/apis.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index f7199e9f..b39214d6 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -46,6 +46,12 @@ def from_name(cls, provider: Union[str, "Provider"] = "tencent") -> "Provider": ) return p + def set_token(self, token: str, cached: bool = True) -> Any: + return set_token(token, self, cached=cached) + + def get_token(self) -> str: + return get_token(self) # type: ignore + class Device: def __init__(self, name: str, lower: bool = False): @@ -177,5 +183,29 @@ def set_token( set_token() + + +@partial( + convert_provider_device, + provider_argnums=1, + provider_kws="provider", + device_argnums=2, + device_kws="device", +) +def get_token( + provider: Optional[str] = None, + device: Optional[str] = None, +) -> str: + if provider is None: + provider = Provider.from_name("tencent") # type: ignore + target = provider.name + "~" # type: ignore + if device is not None: + target = target + device.name # type: ignore + for k, v in saved_token.items(): + if k == target: + return v # type: ignore + return "" + + # token json structure # {"tencent~": token1, "tencent~20xmon": token2} From 96ace2dbfee35fbb093ac501519a6412e4e1062f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Oct 2022 10:48:30 +0800 Subject: [PATCH 009/725] add provider and abstratcion submodule --- tensorcircuit/cloud/abstraction.py | 91 ++++++++++++++++++++++++++++ tensorcircuit/cloud/apis.py | 96 +++++++++--------------------- tensorcircuit/cloud/tencent.py | 11 ++++ 3 files changed, 129 insertions(+), 69 deletions(-) create mode 100644 tensorcircuit/cloud/abstraction.py create mode 100644 tensorcircuit/cloud/tencent.py diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py new file mode 100644 index 00000000..33947b0a --- /dev/null +++ b/tensorcircuit/cloud/abstraction.py @@ -0,0 +1,91 @@ +""" +Abstraction for Provider, Device and Task +""" + +from typing import Any, Dict, Optional, Union + + +class Provider: + activated_provider: Dict[str, "Provider"] = {} + + def __init__(self, name: str, lower: bool = True): + if lower is True: + name = name.lower() + self.name = name + + def __str__(self) -> str: + return self.name + + __repr__ = __str__ + + @classmethod + def from_name(cls, provider: Union[str, "Provider"] = "tencent") -> "Provider": + if provider is None: + provider = "tencent" + if isinstance(provider, cls): + p = provider + elif isinstance(provider, str): + if provider in cls.activated_provider: + return cls.activated_provider[provider] + else: + p = cls(provider) + cls.activated_provider[provider] = p + else: + raise ValueError( + "Unsupported format for `provider` argument: %s" % provider + ) + return p + + def set_token(self, token: str, cached: bool = True) -> Any: + from .apis import set_token + + return set_token(token, self, cached=cached) + + def get_token(self) -> str: + from .apis import get_token + + return get_token(self) # type: ignore + + +class Device: + def __init__(self, name: str, lower: bool = True): + if lower is True: + name = name.lower() + if len(name.split("~")) == 1: + name = "tencent" + name # default provider + self.name = name.split("~")[1] + self.provider = Provider.from_name(name.split("~")[0]) + + def __str__(self) -> str: + return self.name + + __repr__ = __str__ + + @classmethod + def from_name(cls, device: Optional[Union[str, "Device"]] = None) -> "Device": + if device is None: + raise ValueError("Must specify on device instead of default ``None``") + if isinstance(device, cls): + d = device + elif isinstance(device, str): + d = cls(device) + else: + raise ValueError("Unsupported format for `provider` argument: %s" % device) + return d + + def set_token(self, token: str, cached: bool = True) -> Any: + from .apis import set_token + + return set_token(token, provider=self.provider, device=self, cached=cached) + + def get_token(self) -> str: + from .apis import get_token + + s = get_token(provider=self.provider, device=self) + if s is not None: + return s # type: ignore + # fallback to provider default + s = get_token(provider=self.provider) + if s is not None: + return s # type: ignore + raise LookupError("no token for device: %s" % self.name) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index b39214d6..3972c0bc 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -9,74 +9,14 @@ import os import sys +from .abstraction import Provider, Device +from . import tencent from ..cons import backend package_name = "tensorcircuit" thismodule = sys.modules[__name__] -class Provider: - activated_provider: Dict[str, "Provider"] = {} - - def __init__(self, name: str, lower: bool = True): - if lower is True: - name = name.lower() - self.name = name - - def __str__(self) -> str: - return self.name - - __repr__ = __str__ - - @classmethod - def from_name(cls, provider: Union[str, "Provider"] = "tencent") -> "Provider": - if provider is None: - provider = "tencent" - if isinstance(provider, cls): - p = provider - elif isinstance(provider, str): - if provider in cls.activated_provider: - return cls.activated_provider[provider] - else: - p = cls(provider) - cls.activated_provider[provider] = p - else: - raise ValueError( - "Unsupported format for `provider` argument: %s" % provider - ) - return p - - def set_token(self, token: str, cached: bool = True) -> Any: - return set_token(token, self, cached=cached) - - def get_token(self) -> str: - return get_token(self) # type: ignore - - -class Device: - def __init__(self, name: str, lower: bool = False): - if lower is True: - name = name.lower() - self.name = name - - def __str__(self) -> str: - return self.name - - __repr__ = __str__ - - @classmethod - def from_name(cls, device: Optional[Union[str, "Device"]] = None) -> "Device": - if device is None: - raise ValueError("Must specify on device instead of default ``None``") - if isinstance(device, cls): - d = device - elif isinstance(device, str): - d = cls(device) - else: - raise ValueError("Unsupported format for `provider` argument: %s" % device) - return d - - def convert_provider_device( f: Callable[..., Any], provider_argnums: Optional[Sequence[int]] = None, @@ -117,7 +57,9 @@ def wrapper(*args: Any, **kws: Any) -> Any: @partial(convert_provider_device, provider_argnums=0, provider_kws="provider") -def set_provider(provider: Optional[str] = None, set_global: bool = True) -> Provider: +def set_provider( + provider: Optional[Union[str, Provider]] = None, set_global: bool = True +) -> Provider: if set_global: for module in sys.modules: if module.startswith(package_name): @@ -148,8 +90,8 @@ def b64decode_s(s: str) -> str: ) def set_token( token: Optional[str] = None, - provider: Optional[str] = None, - device: Optional[str] = None, + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, cached: bool = True, ) -> Dict[str, Any]: global saved_token @@ -193,9 +135,9 @@ def set_token( device_kws="device", ) def get_token( - provider: Optional[str] = None, - device: Optional[str] = None, -) -> str: + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, +) -> Optional[str]: if provider is None: provider = Provider.from_name("tencent") # type: ignore target = provider.name + "~" # type: ignore @@ -204,8 +146,24 @@ def get_token( for k, v in saved_token.items(): if k == target: return v # type: ignore - return "" + return None # token json structure # {"tencent~": token1, "tencent~20xmon": token2} + + +@partial( + convert_provider_device, + provider_argnums=0, + provider_kws="provider", +) +def list_devices( + provider: Optional[Union[str, Provider]] = None, token: Optional[str] = None +) -> Any: + if provider is None: + provider = Provider.from_name("tencent") + if provider.name == "tencent": # type: ignore + tencent.list_devices(provider, token) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py new file mode 100644 index 00000000..e7a69bf2 --- /dev/null +++ b/tensorcircuit/cloud/tencent.py @@ -0,0 +1,11 @@ +""" +Cloud provider from Tencent +""" + +from typing import Any + +from .abstraction import Provider # , Device + + +def list_devices(provider: Provider, token: str) -> Any: + pass From e66d070111c8a5543a0f937e47a2ac4610782ae2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Oct 2022 12:51:41 +0800 Subject: [PATCH 010/725] add cloud test module --- tensorcircuit/cloud/__init__.py | 1 + tensorcircuit/cloud/abstraction.py | 12 +++++++----- tensorcircuit/cloud/apis.py | 6 +++++- tensorcircuit/cloud/tencent.py | 20 ++++++++++++++++---- tests/test_cloud.py | 22 ++++++++++++++++++++++ 5 files changed, 51 insertions(+), 10 deletions(-) create mode 100644 tests/test_cloud.py diff --git a/tensorcircuit/cloud/__init__.py b/tensorcircuit/cloud/__init__.py index e69de29b..71d6ee3b 100644 --- a/tensorcircuit/cloud/__init__.py +++ b/tensorcircuit/cloud/__init__.py @@ -0,0 +1 @@ +from .apis import set_token, list_devices diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 33947b0a..106946d4 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -46,6 +46,11 @@ def get_token(self) -> str: return get_token(self) # type: ignore + def list_devices(self) -> Any: + from .apis import list_devices + + return list_devices(self) + class Device: def __init__(self, name: str, lower: bool = True): @@ -78,14 +83,11 @@ def set_token(self, token: str, cached: bool = True) -> Any: return set_token(token, provider=self.provider, device=self, cached=cached) - def get_token(self) -> str: + def get_token(self) -> Optional[str]: from .apis import get_token s = get_token(provider=self.provider, device=self) if s is not None: return s # type: ignore # fallback to provider default - s = get_token(provider=self.provider) - if s is not None: - return s # type: ignore - raise LookupError("no token for device: %s" % self.name) + return get_token(provider=self.provider) # type: ignore diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 3972c0bc..03af0922 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -60,6 +60,8 @@ def wrapper(*args: Any, **kws: Any) -> Any: def set_provider( provider: Optional[Union[str, Provider]] = None, set_global: bool = True ) -> Provider: + if provider is None: + provider = Provider.from_name("tencent") if set_global: for module in sys.modules: if module.startswith(package_name): @@ -163,7 +165,9 @@ def list_devices( ) -> Any: if provider is None: provider = Provider.from_name("tencent") + if token is None: + token = provider.get_token() # type: ignore if provider.name == "tencent": # type: ignore - tencent.list_devices(provider, token) # type: ignore + return tencent.list_devices(token) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index e7a69bf2..11f64b8e 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -2,10 +2,22 @@ Cloud provider from Tencent """ -from typing import Any +from typing import Any, Dict, Optional -from .abstraction import Provider # , Device +from .config import tencent_base_url +from .utils import rpost_json -def list_devices(provider: Provider, token: str) -> Any: - pass +def tencent_headers(token: Optional[str] = None) -> Dict[str, str]: + if token is None: + token = "ANY;0" + headers = {"Authorization": "Bearer " + token} + return headers + + +def list_devices(token: Optional[str] = None) -> Any: + json: Dict[Any, Any] = {} + r = rpost_json( + tencent_base_url + "device/find", json=json, headers=tencent_headers(token) + ) + return r["devices"] diff --git a/tests/test_cloud.py b/tests/test_cloud.py new file mode 100644 index 00000000..cbe9a21b --- /dev/null +++ b/tests/test_cloud.py @@ -0,0 +1,22 @@ +import sys +import os + +thisfile = os.path.abspath(__file__) +modulepath = os.path.dirname(os.path.dirname(thisfile)) + +sys.path.insert(0, modulepath) +from tensorcircuit.cloud import apis +from tensorcircuit.cloud import config + + +def test_get_token(): + apis.set_token(config.tencent_token) + assert apis.get_token(provider="Tencent") == config.tencent_token + p = apis.get_provider("tencent") + assert p.get_token() == config.tencent_token + + +def test_list_devices(): + print(apis.list_devices()) + p = apis.get_provider() + print(p.list_devices()) From 7218b35dc40c702e797a33c94b95621baa01e99f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Oct 2022 16:06:12 +0800 Subject: [PATCH 011/725] set device --- tensorcircuit/cloud/abstraction.py | 54 ++++++++++--- tensorcircuit/cloud/apis.py | 123 ++++++++++++----------------- tensorcircuit/cloud/tencent.py | 7 +- tests/test_cloud.py | 16 ++++ 4 files changed, 116 insertions(+), 84 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 106946d4..ba03f959 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -6,7 +6,7 @@ class Provider: - activated_provider: Dict[str, "Provider"] = {} + activated_providers: Dict[str, "Provider"] = {} def __init__(self, name: str, lower: bool = True): if lower is True: @@ -25,11 +25,11 @@ def from_name(cls, provider: Union[str, "Provider"] = "tencent") -> "Provider": if isinstance(provider, cls): p = provider elif isinstance(provider, str): - if provider in cls.activated_provider: - return cls.activated_provider[provider] + if provider in cls.activated_providers: + return cls.activated_providers[provider] else: p = cls(provider) - cls.activated_provider[provider] = p + cls.activated_providers[provider] = p else: raise ValueError( "Unsupported format for `provider` argument: %s" % provider @@ -51,29 +51,59 @@ def list_devices(self) -> Any: return list_devices(self) + def get_device(self, device: Optional[Union[str, "Device"]]) -> "Device": + from .apis import get_device + + return get_device(self, device) + + +sep = "::" + class Device: - def __init__(self, name: str, lower: bool = True): + activated_devices: Dict[str, "Device"] = {} + + def __init__( + self, + name: str, + provider: Optional[Union[str, Provider]] = None, + lower: bool = True, + ): if lower is True: name = name.lower() - if len(name.split("~")) == 1: - name = "tencent" + name # default provider - self.name = name.split("~")[1] - self.provider = Provider.from_name(name.split("~")[0]) + if provider is not None: + self.provider = Provider.from_name(provider) + if len(name.split(sep)) > 1: + self.name = name.split(sep)[1] + else: + self.name = name + else: # no explicit provider + if len(name.split(sep)) == 1: + name = "tencent" + sep + name # default provider + self.name = name.split(sep)[1] + self.provider = Provider.from_name(name.split(sep)[0]) def __str__(self) -> str: - return self.name + return self.provider.name + sep + self.name __repr__ = __str__ @classmethod - def from_name(cls, device: Optional[Union[str, "Device"]] = None) -> "Device": + def from_name( + cls, + device: Optional[Union[str, "Device"]] = None, + provider: Optional[Union[str, Provider]] = None, + ) -> "Device": if device is None: raise ValueError("Must specify on device instead of default ``None``") if isinstance(device, cls): d = device elif isinstance(device, str): - d = cls(device) + if device in cls.activated_devices: + return cls.activated_devices[device] + else: + d = cls(device, provider) + cls.activated_devices[device] = d else: raise ValueError("Unsupported format for `provider` argument: %s" % device) return d diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 03af0922..46f432ad 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -2,14 +2,14 @@ main entrypoints of cloud module """ -from typing import Any, Callable, Optional, Dict, Sequence, Union +from typing import Any, Optional, Dict, Union from base64 import b64decode, b64encode -from functools import partial, wraps +from functools import partial import json import os import sys -from .abstraction import Provider, Device +from .abstraction import Provider, Device, sep from . import tencent from ..cons import backend @@ -17,60 +17,49 @@ thismodule = sys.modules[__name__] -def convert_provider_device( - f: Callable[..., Any], - provider_argnums: Optional[Sequence[int]] = None, - device_argnums: Optional[Sequence[int]] = None, - provider_kws: Optional[Sequence[str]] = None, - device_kws: Optional[Sequence[str]] = None, -) -> Callable[..., Any]: - if provider_argnums is None: - provider_argnums = [] - if isinstance(provider_argnums, int): - provider_argnums = [provider_argnums] - if device_argnums is None: - device_argnums = [] - if isinstance(device_argnums, int): - device_argnums = [device_argnums] - if provider_kws is None: - provider_kws = [] - if device_kws is None: - device_kws = [] - - @wraps(f) - def wrapper(*args: Any, **kws: Any) -> Any: - nargs = list(args) - nkws = kws - for i, arg in enumerate(args): - if i in provider_argnums: # type: ignore - nargs[i] = Provider.from_name(arg) - elif i in device_argnums: # type: ignore - nargs[i] = Device.from_name(arg) - for k, v in kws.items(): - if k in provider_kws: # type: ignore - nkws[k] = Provider.from_name(v) - if k in device_kws: # type: ignore - nkws[k] = Device.from_name(v) - return f(*nargs, **nkws) - - return wrapper - - -@partial(convert_provider_device, provider_argnums=0, provider_kws="provider") +default_provider = Provider.from_name("tencent") + + def set_provider( provider: Optional[Union[str, Provider]] = None, set_global: bool = True ) -> Provider: if provider is None: - provider = Provider.from_name("tencent") + provider = default_provider + provider = Provider.from_name(provider) if set_global: for module in sys.modules: if module.startswith(package_name): - setattr(sys.modules[module], "provider", provider) + setattr(sys.modules[module], "default_provider", provider) return provider # type: ignore +set_provider() get_provider = partial(set_provider, set_global=False) +default_device = Device.from_name("tencent::hello") + + +def set_device( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + set_global: bool = True, +) -> Device: + if provider is None: + provider = default_provider + if device is None: + device = default_device + provider = Provider.from_name(provider) + device = Device.from_name(device, provider) + if set_global: + for module in sys.modules: + if module.startswith(package_name): + setattr(sys.modules[module], "default_device", device) + return device # type: ignore + + +set_device() +get_device = partial(set_device, set_global=False) + def b64encode_s(s: str) -> str: return b64encode(s.encode("utf-8")).decode("utf-8") @@ -83,13 +72,6 @@ def b64decode_s(s: str) -> str: saved_token: Dict[str, Any] = {} -@partial( - convert_provider_device, - provider_argnums=1, - provider_kws="provider", - device_argnums=2, - device_kws="device", -) def set_token( token: Optional[str] = None, provider: Optional[Union[str, Provider]] = None, @@ -99,6 +81,13 @@ def set_token( global saved_token tcdir = os.path.dirname(os.path.abspath(__file__)) authpath = os.path.join(tcdir, "auth.json") + if provider is None: + provider = default_provider + provider = Provider.from_name(provider) + if device is not None: + device = Device.from_name(device, provider) + # if device is None: + # device = default_device if token is None: if cached and os.path.exists(authpath): @@ -113,9 +102,9 @@ def set_token( if device is None: if provider is None: provider = Provider.from_name("tencent") # type: ignore - added_token = {provider.name + "~": token} # type: ignore + added_token = {provider.name + sep: token} # type: ignore else: - added_token = {provider.name + "~" + device.name: token} # type: ignore + added_token = {provider.name + sep + device.name: token} # type: ignore saved_token.update(added_token) if cached: @@ -129,20 +118,16 @@ def set_token( set_token() -@partial( - convert_provider_device, - provider_argnums=1, - provider_kws="provider", - device_argnums=2, - device_kws="device", -) def get_token( provider: Optional[Union[str, Provider]] = None, device: Optional[Union[str, Device]] = None, ) -> Optional[str]: if provider is None: - provider = Provider.from_name("tencent") # type: ignore - target = provider.name + "~" # type: ignore + provider = default_provider # type: ignore + provider = Provider.from_name(provider) + if device is not None: + device = Device.from_name(device, provider) + target = provider.name + sep # type: ignore if device is not None: target = target + device.name # type: ignore for k, v in saved_token.items(): @@ -152,22 +137,18 @@ def get_token( # token json structure -# {"tencent~": token1, "tencent~20xmon": token2} +# {"tencent::": token1, "tencent::20xmon": token2} -@partial( - convert_provider_device, - provider_argnums=0, - provider_kws="provider", -) def list_devices( provider: Optional[Union[str, Provider]] = None, token: Optional[str] = None ) -> Any: if provider is None: - provider = Provider.from_name("tencent") + provider = default_provider + provider = Provider.from_name(provider) if token is None: token = provider.get_token() # type: ignore - if provider.name == "tencent": # type: ignore + if provider.name == "tencent": return tencent.list_devices(token) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 11f64b8e..ee0e07a3 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -6,6 +6,7 @@ from .config import tencent_base_url from .utils import rpost_json +from .abstraction import Device, sep def tencent_headers(token: Optional[str] = None) -> Dict[str, str]: @@ -20,4 +21,8 @@ def list_devices(token: Optional[str] = None) -> Any: r = rpost_json( tencent_base_url + "device/find", json=json, headers=tencent_headers(token) ) - return r["devices"] + ds = r["devices"] + rs = [] + for d in ds: + rs.append(Device.from_name("tencent" + sep + d["id"])) + return rs diff --git a/tests/test_cloud.py b/tests/test_cloud.py index cbe9a21b..96fb8cbe 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -20,3 +20,19 @@ def test_list_devices(): print(apis.list_devices()) p = apis.get_provider() print(p.list_devices()) + + +def test_get_device(): + d1 = apis.get_device(device="tecent::hello") + assert d1.name == "hello" + assert d1.provider.name == "tencent" + d2 = apis.get_device(device="hello") + assert d2.name == "hello" + assert d2.provider.name == "tencent" + p = apis.get_provider() + d3 = p.get_device("tencent::hello") + assert d3.name == "hello" + assert d3.provider.name == "tencent" + d4 = p.get_device("hello") + assert d4.name == "hello" + assert d4.provider.name == "tencent" From bd6008e31e9398383df156d6580c04acf67825b9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Oct 2022 10:29:50 +0800 Subject: [PATCH 012/725] add list properties --- tensorcircuit/cloud/abstraction.py | 5 +++++ tensorcircuit/cloud/apis.py | 24 +++++++++++++++++++++--- tensorcircuit/cloud/tencent.py | 15 +++++++++++++-- tensorcircuit/cloud/utils.py | 2 +- tests/test_cloud.py | 11 ++++++++++- 5 files changed, 50 insertions(+), 7 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index ba03f959..56812f5f 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -121,3 +121,8 @@ def get_token(self) -> Optional[str]: return s # type: ignore # fallback to provider default return get_token(provider=self.provider) # type: ignore + + def list_properties(self) -> Dict[str, Any]: + from .apis import list_properties + + return list_properties(self.provider, self) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 46f432ad..9f441b30 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -44,12 +44,11 @@ def set_device( device: Optional[Union[str, Device]] = None, set_global: bool = True, ) -> Device: - if provider is None: - provider = default_provider if device is None: device = default_device - provider = Provider.from_name(provider) device = Device.from_name(device, provider) + if provider is None: + provider = device.provider if set_global: for module in sys.modules: if module.startswith(package_name): @@ -152,3 +151,22 @@ def list_devices( return tencent.list_devices(token) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def list_properties( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + token: Optional[str] = None, +) -> Dict[str, Any]: + if device is None: + device = default_device + device = Device.from_name(device, provider) + if provider is None: + provider = device.provider + + if token is None: + token = provider.get_token() # type: ignore + if provider.name == "tencent": # type: ignore + return tencent.list_properties(device, token) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index ee0e07a3..3ee40767 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -2,7 +2,7 @@ Cloud provider from Tencent """ -from typing import Any, Dict, Optional +from typing import Any, Dict, List, Optional from .config import tencent_base_url from .utils import rpost_json @@ -16,7 +16,7 @@ def tencent_headers(token: Optional[str] = None) -> Dict[str, str]: return headers -def list_devices(token: Optional[str] = None) -> Any: +def list_devices(token: Optional[str] = None) -> List[Device]: json: Dict[Any, Any] = {} r = rpost_json( tencent_base_url + "device/find", json=json, headers=tencent_headers(token) @@ -26,3 +26,14 @@ def list_devices(token: Optional[str] = None) -> Any: for d in ds: rs.append(Device.from_name("tencent" + sep + d["id"])) return rs + + +def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, Any]: + json = {"id": device.name} + r = rpost_json( + tencent_base_url + "device/detail", json=json, headers=tencent_headers(token) + ) + if "device" in r: + return r["device"] # type: ignore + else: + raise ValueError("No device with the name: %s" % device) diff --git a/tensorcircuit/cloud/utils.py b/tensorcircuit/cloud/utils.py index 2ef4fca1..1b88e5fa 100644 --- a/tensorcircuit/cloud/utils.py +++ b/tensorcircuit/cloud/utils.py @@ -53,7 +53,7 @@ def set_proxy(proxy: Optional[str] = None) -> None: def reconnect(tries: int = 5, timeout: int = 12) -> Callable[..., Any]: - # wrapper originally designed in xalpha + # wrapper originally designed in xalpha by @refraction-ray # https://github.com/refraction-ray/xalpha def robustify(f: Callable[..., Any]) -> Callable[..., Any]: @wraps(f) diff --git a/tests/test_cloud.py b/tests/test_cloud.py index 96fb8cbe..ca9e2ac1 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -1,5 +1,6 @@ import sys import os +import pytest thisfile = os.path.abspath(__file__) modulepath = os.path.dirname(os.path.dirname(thisfile)) @@ -23,7 +24,7 @@ def test_list_devices(): def test_get_device(): - d1 = apis.get_device(device="tecent::hello") + d1 = apis.get_device(device="tencent::hello") assert d1.name == "hello" assert d1.provider.name == "tencent" d2 = apis.get_device(device="hello") @@ -36,3 +37,11 @@ def test_get_device(): d4 = p.get_device("hello") assert d4.name == "hello" assert d4.provider.name == "tencent" + + +def test_list_properties(): + d = apis.get_device(device="hello") + print(d.list_properties()) + print(apis.list_properties(device="tencent::hello")) + with pytest.raises(ValueError): + apis.list_properties(device="hell") From 9fa8d79738a08b48aef823c6548853ada83338ee Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Oct 2022 10:56:13 +0800 Subject: [PATCH 013/725] upgrade mypy for cloud part --- tensorcircuit/cloud/abstraction.py | 4 ++-- tensorcircuit/cloud/apis.py | 24 ++++++++++++------------ 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 56812f5f..8efd451b 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -118,9 +118,9 @@ def get_token(self) -> Optional[str]: s = get_token(provider=self.provider, device=self) if s is not None: - return s # type: ignore + return s # fallback to provider default - return get_token(provider=self.provider) # type: ignore + return get_token(provider=self.provider) def list_properties(self) -> Dict[str, Any]: from .apis import list_properties diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 9f441b30..f1f29ba9 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -30,7 +30,7 @@ def set_provider( for module in sys.modules: if module.startswith(package_name): setattr(sys.modules[module], "default_provider", provider) - return provider # type: ignore + return provider set_provider() @@ -53,7 +53,7 @@ def set_device( for module in sys.modules: if module.startswith(package_name): setattr(sys.modules[module], "default_device", device) - return device # type: ignore + return device set_device() @@ -100,10 +100,10 @@ def set_token( else: # with token if device is None: if provider is None: - provider = Provider.from_name("tencent") # type: ignore - added_token = {provider.name + sep: token} # type: ignore + provider = Provider.from_name("tencent") + added_token = {provider.name + sep: token} else: - added_token = {provider.name + sep + device.name: token} # type: ignore + added_token = {provider.name + sep + device.name: token} saved_token.update(added_token) if cached: @@ -122,13 +122,13 @@ def get_token( device: Optional[Union[str, Device]] = None, ) -> Optional[str]: if provider is None: - provider = default_provider # type: ignore + provider = default_provider provider = Provider.from_name(provider) if device is not None: device = Device.from_name(device, provider) - target = provider.name + sep # type: ignore + target = provider.name + sep if device is not None: - target = target + device.name # type: ignore + target = target + device.name for k, v in saved_token.items(): if k == target: return v # type: ignore @@ -146,11 +146,11 @@ def list_devices( provider = default_provider provider = Provider.from_name(provider) if token is None: - token = provider.get_token() # type: ignore + token = provider.get_token() if provider.name == "tencent": - return tencent.list_devices(token) # type: ignore + return tencent.list_devices(token) else: - raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + raise ValueError("Unsupported provider: %s" % provider.name) def list_properties( @@ -167,6 +167,6 @@ def list_properties( if token is None: token = provider.get_token() # type: ignore if provider.name == "tencent": # type: ignore - return tencent.list_properties(device, token) # type: ignore + return tencent.list_properties(device, token) else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore From 649ba6988b40247c110463e75af2e55c6e38e3b2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Oct 2022 11:18:21 +0800 Subject: [PATCH 014/725] upgrade mypy --- .github/workflows/ci.yml | 1 + .github/workflows/nightly_release.yml | 1 + CHANGELOG.md | 2 ++ mypy.ini | 7 ++-- requirements/requirements-dev.txt | 2 +- tensorcircuit/abstractcircuit.py | 38 ++++++++++---------- tensorcircuit/applications/graphdata.py | 2 +- tensorcircuit/applications/utils.py | 8 ++--- tensorcircuit/applications/vags.py | 2 +- tensorcircuit/applications/vqes.py | 4 +-- tensorcircuit/backends/abstract_backend.py | 2 +- tensorcircuit/backends/jax_backend.py | 4 +-- tensorcircuit/backends/jax_ops.py | 4 +-- tensorcircuit/backends/pytorch_backend.py | 2 +- tensorcircuit/backends/tensorflow_backend.py | 6 ++-- tensorcircuit/backends/tf_ops.py | 2 +- tensorcircuit/basecircuit.py | 12 ++++--- tensorcircuit/channels.py | 18 +++++----- tensorcircuit/circuit.py | 2 +- tensorcircuit/cons.py | 16 ++++----- tensorcircuit/densitymatrix.py | 12 ++++--- tensorcircuit/gates.py | 7 ++-- tensorcircuit/interfaces/tensorflow.py | 2 +- tensorcircuit/interfaces/tensortrans.py | 2 +- tensorcircuit/interfaces/torch.py | 4 +-- tensorcircuit/keras.py | 4 +-- tensorcircuit/quantum.py | 6 ++-- tensorcircuit/templates/blocks.py | 2 +- tensorcircuit/torchnn.py | 8 ++--- tensorcircuit/utils.py | 2 +- 30 files changed, 97 insertions(+), 87 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5a3e23ea..65f4ff44 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -26,6 +26,7 @@ jobs: black . --check - name: mypy checker run: | + mypy --install-types mypy tensorcircuit - name: pylint checker run: | diff --git a/.github/workflows/nightly_release.yml b/.github/workflows/nightly_release.yml index a0d351c7..d9da68c2 100644 --- a/.github/workflows/nightly_release.yml +++ b/.github/workflows/nightly_release.yml @@ -31,6 +31,7 @@ jobs: black . --check - name: mypy checker run: | + mypy --install-types mypy tensorcircuit - name: pylint checker run: | diff --git a/CHANGELOG.md b/CHANGELOG.md index 7bdef6af..c1d261ee 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,8 @@ - `tc.quantum.correlation_from_samples` now fix the sign error with odd number of spins +- Updated to the latest version of mypy and get rid of lots of type: ignored + ## 0.4.1 ### Added diff --git a/mypy.ini b/mypy.ini index 6b9982e9..7539c6a0 100644 --- a/mypy.ini +++ b/mypy.ini @@ -2,17 +2,18 @@ python_version = 3.8 ignore_missing_imports = True strict = True -warn_unused_ignores = False +warn_unused_ignores = True disallow_untyped_calls = False local_partial_types = False +implicit_reexport = True [mypy-tensorcircuit.backends.pytorch_ops] ;;mypy simply cannot ignore files with wildcard patterns... ;;only module level * works... ignore_errors = True -;;[mypy-numpy.*] -;;ignore_errors = True +[mypy-cirq.*] +ignore_errors = True ;; doesn't work due to https://github.com/python/mypy/issues/10757 ;; mypy + numpy is currently a disaster, never use mypy in your next project diff --git a/requirements/requirements-dev.txt b/requirements/requirements-dev.txt index 877fc936..7c7a73ed 100644 --- a/requirements/requirements-dev.txt +++ b/requirements/requirements-dev.txt @@ -1,4 +1,4 @@ -mypy==0.782 +mypy==0.982 pytest==6.2.4 pytest-cov pytest-benchmark diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index a1970c3e..bd355930 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -124,7 +124,7 @@ def apply(self: "AbstractCircuit", *index: int, **vars: Any) -> None: split=split, mpo=mpo, ir_dict=gate_dict, - ) # type: ignore + ) return apply @@ -150,7 +150,7 @@ def apply( if name is not None: localname = name else: - localname = defaultname # type: ignore + localname = defaultname # split = None gate = gatef() @@ -353,12 +353,12 @@ def from_qir( if "nqubits" not in circuit_params: nqubits = 0 for d in qir: - if max(d["index"]) > nqubits: # type: ignore - nqubits = max(d["index"]) # type: ignore + if max(d["index"]) > nqubits: + nqubits = max(d["index"]) nqubits += 1 circuit_params["nqubits"] = nqubits - c = cls(**circuit_params) # type: ignore + c = cls(**circuit_params) c = cls._apply_qir(c, qir) return c @@ -368,13 +368,13 @@ def _apply_qir( ) -> "AbstractCircuit": for d in qir: if "parameters" not in d: - c.apply_general_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( # type: ignore - c, *d["index"], split=d["split"] # type: ignore + c.apply_general_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( + c, *d["index"], split=d["split"] ) else: - c.apply_general_variable_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( # type: ignore - c, *d["index"], **d["parameters"], split=d["split"] # type: ignore - ) + c.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], **d["parameters"], split=d["split"]) return c def inverse( @@ -400,16 +400,16 @@ def inverse( if "nqubits" not in circuit_params: circuit_params["nqubits"] = self._nqubits - c = type(self)(**circuit_params) # type: ignore + c = type(self)(**circuit_params) for d in reversed(self._qir): if "parameters" not in d: - self.apply_general_gate_delayed(d["gatef"].adjoint(), d["name"], mpo=d["mpo"])( # type: ignore - c, *d["index"], split=d["split"] # type: ignore - ) + self.apply_general_gate_delayed( + d["gatef"].adjoint(), d["name"], mpo=d["mpo"] + )(c, *d["index"], split=d["split"]) else: - self.apply_general_variable_gate_delayed(d["gatef"].adjoint(), d["name"], mpo=d["mpo"])( # type: ignore - c, *d["index"], **d["parameters"], split=d["split"] # type: ignore - ) + self.apply_general_variable_gate_delayed( + d["gatef"].adjoint(), d["name"], mpo=d["mpo"] + )(c, *d["index"], **d["parameters"], split=d["split"]) return c @@ -690,7 +690,9 @@ def cond_measurement(self, index: int) -> Tensor: :rtype: Tensor """ return self.general_kraus( # type: ignore - [np.array([[1.0, 0], [0, 0]]), np.array([[0, 0], [0, 1]])], index, name="measure" # type: ignore + [np.array([[1.0, 0], [0, 0]]), np.array([[0, 0], [0, 1]])], + index, + name="measure", ) cond_measure = cond_measurement diff --git a/tensorcircuit/applications/graphdata.py b/tensorcircuit/applications/graphdata.py index 1a53b24e..f1b575f3 100644 --- a/tensorcircuit/applications/graphdata.py +++ b/tensorcircuit/applications/graphdata.py @@ -387,7 +387,7 @@ def split_ansatz(g: Graph, split: int = 2) -> Sequence[Graph]: """ edges = np.array(g.edges) ne = len(edges) - np.random.shuffle(edges) # type: ignore + np.random.shuffle(edges) gs = [nx.Graph() for _ in range(split)] for i in range(split): for j, k in edges[int(i * ne / split) : int((i + 1) * ne / split)]: diff --git a/tensorcircuit/applications/utils.py b/tensorcircuit/applications/utils.py index 9ca73f0f..30cfcd63 100644 --- a/tensorcircuit/applications/utils.py +++ b/tensorcircuit/applications/utils.py @@ -349,10 +349,10 @@ def color_svg(circuit: cirq.Circuit, *coords: Tuple[int, int]) -> Any: :return: """ import xml - from cirq.contrib.svg import SVGCircuit # type: ignore + from cirq.contrib.svg import SVGCircuit svg_str = SVGCircuit(circuit)._repr_svg_() - DOMTree = xml.dom.minidom.parseString(svg_str) # type: ignore + DOMTree = xml.dom.minidom.parseString(svg_str) xpos = [] ypos = [] for r in DOMTree.getElementsByTagName("rect"): # [0].setAttribute("fill", "gray") @@ -413,7 +413,7 @@ def Heisenberg1Denergy(L: int, Pauli: bool = True, maxiters: int = 1000) -> floa phi2 = np.zeros([L // 2, L // 2]) lamb = np.array([2 * i + 1 for i in range(L // 2)]) for _ in range(maxiters): - k = 1 / L * (2 * np.pi * lamb + np.sum(phi, axis=-1) - np.diag(phi)) # type: ignore + k = 1 / L * (2 * np.pi * lamb + np.sum(phi, axis=-1) - np.diag(phi)) for i in range(L // 2): for j in range(L // 2): phi2[i, j] = ( @@ -427,7 +427,7 @@ def Heisenberg1Denergy(L: int, Pauli: bool = True, maxiters: int = 1000) -> floa ) * 2 ) - if np.allclose(phi, phi2, rtol=error): # type: ignore # converged + if np.allclose(phi, phi2, rtol=error): # converged break phi = phi2.copy() else: diff --git a/tensorcircuit/applications/vags.py b/tensorcircuit/applications/vags.py index 352a3759..7311eb81 100644 --- a/tensorcircuit/applications/vags.py +++ b/tensorcircuit/applications/vags.py @@ -514,7 +514,7 @@ def qaoa_noise_vag( pnnp = array_to_tensor(np.array(pnnp)) # complex with tf.GradientTape() as t: t.watch(pnnp) - loss = forward_func(pnnp, preset, gdata, measure_func, **kws) # type: ignore + loss = forward_func(pnnp, preset, gdata, measure_func, **kws) loss = cons.backend.real(loss) gr = t.gradient(loss, pnnp) if gr is None: diff --git a/tensorcircuit/applications/vqes.py b/tensorcircuit/applications/vqes.py index 83d4c4db..98ffa355 100644 --- a/tensorcircuit/applications/vqes.py +++ b/tensorcircuit/applications/vqes.py @@ -666,6 +666,6 @@ def multi_training( if rs: es = [r["energy"] for r in rs] ind = np.argmin(es) - self.assign(rs[ind]["model_weights"], rs[ind]["circuit_weights"]) # type: ignore - self.history = rs[ind]["history"] # type: ignore + self.assign(rs[ind]["model_weights"], rs[ind]["circuit_weights"]) + self.history = rs[ind]["history"] return rs diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index d032997f..b6a5cd05 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -1471,7 +1471,7 @@ def _first(x: Sequence[Any]) -> Any: collect = _first # type: ignore jjs = [] - for k in range(len(values)): # type: ignore + for k in range(len(values)): jj = self.vmap(vjp1, vectorized_argnums=2)( pf, args, diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index b4ae3d97..62cdd635 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -401,12 +401,12 @@ def tree_unflatten(self, treedef: Any, leaves: Any) -> Any: def from_dlpack(self, a: Any) -> Tensor: import jax.dlpack - return jax.dlpack.from_dlpack(a) # type: ignore + return jax.dlpack.from_dlpack(a) def to_dlpack(self, a: Tensor) -> Any: import jax.dlpack - return jax.dlpack.to_dlpack(a) # type: ignore + return jax.dlpack.to_dlpack(a) def set_random_state( self, seed: Optional[Union[int, PRNGKeyArray]] = None, get_only: bool = False diff --git a/tensorcircuit/backends/jax_ops.py b/tensorcircuit/backends/jax_ops.py index d9a9ced0..63cd2e33 100644 --- a/tensorcircuit/backends/jax_ops.py +++ b/tensorcircuit/backends/jax_ops.py @@ -11,7 +11,7 @@ Array = Any # jnp.array -@jax.custom_vjp # type: ignore +@jax.custom_vjp def adaware_svd(A: Array) -> Any: return jnp.linalg.svd(A, full_matrices=False) @@ -74,7 +74,7 @@ def jaxsvd_bwd(r: Sequence[Array], tangents: Sequence[Array]) -> Tuple[Array]: qr_epsilon = 1e-8 -@jax.custom_vjp # type: ignore +@jax.custom_vjp def adaware_qr(A: Array) -> Any: # q, r = jnp.linalg.qr(A) return jnp.linalg.qr(A) diff --git a/tensorcircuit/backends/pytorch_backend.py b/tensorcircuit/backends/pytorch_backend.py index 5234a6be..f9a03663 100644 --- a/tensorcircuit/backends/pytorch_backend.py +++ b/tensorcircuit/backends/pytorch_backend.py @@ -283,7 +283,7 @@ def numpy(self, a: Tensor) -> Tensor: def i(self, dtype: Any = None) -> Tensor: if not dtype: - dtype = getattr(torchlib, dtypestr) # type: ignore + dtype = getattr(torchlib, dtypestr) if isinstance(dtype, str): dtype = getattr(torchlib, dtype) return torchlib.tensor(1j, dtype=dtype) diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 70636395..364dcdc0 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -329,7 +329,7 @@ def numpy(self, a: Tensor) -> Tensor: def i(self, dtype: Any = None) -> Tensor: if not dtype: - dtype = getattr(tf, dtypestr) # type: ignore + dtype = getattr(tf, dtypestr) if isinstance(dtype, str): dtype = getattr(tf, dtype) return tf.constant(1j, dtype=dtype) @@ -594,7 +594,7 @@ def wrapper(*args: Any, **kws: Any) -> Any: else: args = tuple( [ - tf.identity(arg) if i in argnums else arg # type: ignore + tf.identity(arg) if i in argnums else arg for i, arg in enumerate(args) ] ) @@ -625,7 +625,7 @@ def wrapper(*args: Any, **kws: Any) -> Any: else: args = tuple( [ - tf.identity(arg) if i in argnums else arg # type: ignore + tf.identity(arg) if i in argnums else arg for i, arg in enumerate(args) ] ) diff --git a/tensorcircuit/backends/tf_ops.py b/tensorcircuit/backends/tf_ops.py index 0dd8a53a..27327722 100644 --- a/tensorcircuit/backends/tf_ops.py +++ b/tensorcircuit/backends/tf_ops.py @@ -5,7 +5,7 @@ from typing import Any -import tensorflow as tf # type: ignore +import tensorflow as tf Array = Any # tensorflow Tensor diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 907c8950..1ea4b0cb 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -136,7 +136,7 @@ def apply_general_gate( ir_dict = gate_dict self._qir.append(ir_dict) assert len(index) == len(set(index)) - index = tuple([i if i >= 0 else self._nqubits + i for i in index]) # type: ignore + index = tuple([i if i >= 0 else self._nqubits + i for i in index]) noe = len(index) nq = self._nqubits applied = False @@ -257,7 +257,7 @@ def _copy_state_tensor( for e in t.edges: newfront.append(edict[e]) return newnodes, newfront - return self._copy(conj) # type: ignore + return self._copy(conj) def expectation_before( self, @@ -311,7 +311,7 @@ def expectation_before( for j in range(nq): if j not in occupied: # edge1[j].is_dangling invalid here! newdang[j] ^ newdang[j + nq] - return nodes # type: ignore + return nodes def to_qir(self) -> List[Dict[str, Any]]: """ @@ -540,7 +540,7 @@ def sample( r = [r] # type: ignore else: - @backend.jit # type: ignore + @backend.jit def perfect_sampling(key: Any) -> Any: backend.set_random_state(key) return self.perfect_sampling() @@ -717,7 +717,9 @@ def cond_measurement(self, index: int) -> Tensor: :rtype: Tensor """ return self.general_kraus( # type: ignore - [np.array([[1.0, 0], [0, 0]]), np.array([[0, 0], [0, 1]])], index, name="measure" # type: ignore + [np.array([[1.0, 0], [0, 0]]), np.array([[0, 0], [0, 1]])], + index, + name="measure", ) cond_measure = cond_measurement diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index 9ce944cc..e2c0e753 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -521,7 +521,7 @@ def kraus_to_super_gate(kraus_list: Sequence[Gate]) -> Tensor: @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0], gate_to_tensor=True, ) @@ -562,7 +562,7 @@ def kraus_to_super(kraus_list: Sequence[Matrix]) -> Matrix: @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0], gate_to_tensor=True, ) @@ -603,7 +603,7 @@ def super_to_choi(superop: Matrix) -> Matrix: @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0], gate_to_tensor=True, ) @@ -630,7 +630,7 @@ def reshuffle(op: Matrix, order: Sequence[int]) -> Matrix: @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0], gate_to_tensor=True, ) @@ -714,7 +714,7 @@ def choi_to_kraus( @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0], gate_to_tensor=True, ) @@ -732,7 +732,7 @@ def kraus_to_choi(kraus_list: Sequence[Matrix]) -> Matrix: @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0], gate_to_tensor=True, ) @@ -749,7 +749,7 @@ def choi_to_super(choi: Matrix) -> Matrix: @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0], gate_to_tensor=True, ) @@ -828,7 +828,7 @@ def krausmatrix_to_krausgate(kraus_list: Sequence[Matrix]) -> Sequence[Gate]: @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0, 1], gate_to_tensor=True, ) @@ -862,7 +862,7 @@ def evol_kraus(density_matrix: Matrix, kraus_list: Sequence[Matrix]) -> Matrix: @partial( - interfaces.args_to_tensor, # type: ignore + interfaces.args_to_tensor, argnums=[0, 1], gate_to_tensor=True, ) diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index d33f764e..c3d53d37 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -100,7 +100,7 @@ def __init__( self._front = new_front self.coloring_nodes(nodes) - self._nodes = nodes # type: ignore + self._nodes = nodes self._start_index = len(nodes) # self._start = nodes diff --git a/tensorcircuit/cons.py b/tensorcircuit/cons.py index 3435af02..844606bf 100644 --- a/tensorcircuit/cons.py +++ b/tensorcircuit/cons.py @@ -16,7 +16,7 @@ from tensornetwork.backend_contextmanager import get_default_backend from .backends.numpy_backend import NumpyBackend -from .backends import get_backend # type: ignore +from .backends import get_backend from .simplify import _multi_remove logger = logging.getLogger(__name__) @@ -140,7 +140,7 @@ def set_dtype(dtype: Optional[str] = None, set_global: bool = True) -> Tuple[str else: rdtype = "float64" if backend.name == "jax": - from jax.config import config # type: ignore + from jax.config import config if dtype == "complex128": config.update("jax_enable_x64", True) @@ -245,7 +245,7 @@ def _merge_single_gates( njs = [i for i, n in enumerate(nodes) if id(n) in [id(e0.node1), id(e0.node2)]] qjs = [i for i, n in enumerate(queue) if id(n) in [id(e0.node1), id(e0.node2)]] new_node = tn.contract(e0) - total_size += _sizen(new_node) # type: ignore + total_size += _sizen(new_node) logger.debug( _sizen(new_node, is_log=True), @@ -259,7 +259,7 @@ def _merge_single_gates( if len(new_node.tensor.shape) <= 2: # queue.append(new_node) queue.insert(0, new_node) - return nodes, total_size # type: ignore + return nodes, total_size def experimental_contractor( @@ -431,7 +431,7 @@ def _get_path( output_set = set([id(e) for e in tn.get_subgraph_dangling(nodes)]) size_dict = {id(edge): edge.dimension for edge in tn.get_all_edges(nodes)} - return algorithm(input_sets, output_set, size_dict), nodes # type: ignore + return algorithm(input_sets, output_set, size_dict), nodes def _get_path_cache_friendly( @@ -462,7 +462,7 @@ def _get_path_cache_friendly( logger.debug("output_set: %s" % output_set) logger.debug("size_dict: %s" % size_dict) logger.debug("path finder algorithm: %s" % algorithm) - return algorithm(input_sets, output_set, size_dict), nodes_new # type: ignore + return algorithm(input_sets, output_set, size_dict), nodes_new # directly get input_sets, output_set and size_dict by using identity function as algorithm @@ -603,8 +603,8 @@ def _base( nodes = _multi_remove(nodes, [a, b]) logger.debug(_sizen(new_node, is_log=True)) - total_size += _sizen(new_node) # type: ignore - logger.info("----- WRITE: %s --------\n" % np.log2(total_size)) # type: ignore + total_size += _sizen(new_node) + logger.info("----- WRITE: %s --------\n" % np.log2(total_size)) # if the final node has more than one edge, # output_edge_order has to be specified diff --git a/tensorcircuit/densitymatrix.py b/tensorcircuit/densitymatrix.py index 2ea1ba2e..e0adae07 100644 --- a/tensorcircuit/densitymatrix.py +++ b/tensorcircuit/densitymatrix.py @@ -62,7 +62,7 @@ def __init__( and (mpo_dminputs is None) ): # Get nodes on the interior - self._nodes = self.all_zero_nodes(nqubits) # type: ignore + self._nodes = self.all_zero_nodes(nqubits) self._front = [n.get_edge(0) for n in self._nodes] self.coloring_nodes(self._nodes) self._double_nodes_front() @@ -82,10 +82,10 @@ def __init__( self._double_nodes_front() elif mps_inputs is not None: - mps_nodes = list(mps_inputs.nodes) # type: ignore + mps_nodes = list(mps_inputs.nodes) for i, n in enumerate(mps_nodes): mps_nodes[i].tensor = backend.cast(n.tensor, dtypestr) # type: ignore - mps_edges = mps_inputs.out_edges + mps_inputs.in_edges # type: ignore + mps_edges = mps_inputs.out_edges + mps_inputs.in_edges self._nodes, self._front = self.copy(mps_nodes, mps_edges) self.coloring_nodes(self._nodes) self._double_nodes_front() @@ -306,7 +306,9 @@ def to_circuit(self, circuit_params: Optional[Dict[str, Any]] = None) -> Circuit class DMCircuit2(DMCircuit): - def apply_general_kraus(self, kraus: Sequence[Gate], *index: int, **kws: Any) -> None: # type: ignore + def apply_general_kraus( + self, kraus: Sequence[Gate], *index: int, **kws: Any + ) -> None: # incompatible API for now kraus = [ k @@ -336,7 +338,7 @@ def apply_general_kraus(self, kraus: Sequence[Gate], *index: int, **kws: Any) -> self._nodes.append(super_op) setattr(self, "state_tensor", None) - general_kraus = apply_general_kraus # type: ignore + general_kraus = apply_general_kraus @staticmethod def apply_general_kraus_delayed( diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index 87003112..bd5f2665 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -13,7 +13,7 @@ from scipy.stats import unitary_group from .cons import backend, dtypestr, npdtype -from .backends import get_backend # type: ignore +from .backends import get_backend from .utils import arg_alias thismodule = sys.modules[__name__] @@ -675,9 +675,8 @@ def random_single_qubit_gate() -> Gate: :rtype: Gate """ # Get the random parameters - theta, alpha, phi = np.random.rand(3) * 2 * np.pi # type: ignore - - return r_gate(theta, alpha, phi) # type: ignore + theta, alpha, phi = np.random.rand(3) * 2 * np.pi + return r_gate(theta, alpha, phi) # rs = random_single_qubit_gate # deprecated diff --git a/tensorcircuit/interfaces/tensorflow.py b/tensorcircuit/interfaces/tensorflow.py index 3febabc3..d2a274d4 100644 --- a/tensorcircuit/interfaces/tensorflow.py +++ b/tensorcircuit/interfaces/tensorflow.py @@ -92,7 +92,7 @@ def vjp_fun(*xv: Tensor) -> Tuple[Tensor, Tensor]: x = x[0] if len(v) == 1: v = v[0] - return backend.vjp(fun, x, v) # type: ignore + return backend.vjp(fun, x, v) if jit is True: vjp_fun = backend.jit(vjp_fun) diff --git a/tensorcircuit/interfaces/tensortrans.py b/tensorcircuit/interfaces/tensortrans.py index efd987c7..b94762a8 100644 --- a/tensorcircuit/interfaces/tensortrans.py +++ b/tensorcircuit/interfaces/tensortrans.py @@ -8,7 +8,7 @@ from ..cons import backend, dtypestr from ..gates import Gate from ..quantum import QuOperator -from ..backends import get_backend # type: ignore +from ..backends import get_backend Tensor = Any Array = Any diff --git a/tensorcircuit/interfaces/torch.py b/tensorcircuit/interfaces/torch.py index 698f4990..4efd08da 100644 --- a/tensorcircuit/interfaces/torch.py +++ b/tensorcircuit/interfaces/torch.py @@ -56,13 +56,13 @@ def f(params): import torch def vjp_fun(x: Tensor, v: Tensor) -> Tuple[Tensor, Tensor]: - return backend.vjp(fun, x, v) # type: ignore + return backend.vjp(fun, x, v) if jit is True: fun = backend.jit(fun) vjp_fun = backend.jit(vjp_fun) - class Fun(torch.autograd.Function): # type: ignore + class Fun(torch.autograd.Function): @staticmethod def forward(ctx: Any, *x: Any) -> Any: # type: ignore # ctx.xdtype = [xi.dtype for xi in x] diff --git a/tensorcircuit/keras.py b/tensorcircuit/keras.py index e09ba532..c8f9415f 100644 --- a/tensorcircuit/keras.py +++ b/tensorcircuit/keras.py @@ -9,7 +9,7 @@ from tensorflow.keras.layers import Layer from tensorflow.keras import initializers, constraints -from .cons import rdtypestr, backend # type: ignore +from .cons import rdtypestr, backend # @tf.keras.utils.register_keras_serializable( # package="tensorcircuit" @@ -71,7 +71,7 @@ def build(self, input_shape: Optional[List[int]] = None) -> None: self.add_weight( name="PQCweights%s" % i, shape=shape, - dtype=getattr(np, rdtypestr), # type: ignore + dtype=getattr(np, rdtypestr), trainable=True, initializer=init, constraint=cst, diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 92c4b910..afcedb1d 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -37,7 +37,7 @@ pass from .cons import backend, contractor, dtypestr, npdtype, rdtypestr -from .backends import get_backend # type: ignore +from .backends import get_backend from .utils import is_m1mac, arg_alias Tensor = Any @@ -1282,7 +1282,7 @@ def PauliStringSum2COO( weight = tf.constant(weight, dtype=getattr(tf, dtypestr)) rsparse = get_backend("numpy").coo_sparse_matrix( indices=np.array([[0, 0]], dtype=np.int64), - values=np.array([0.0], dtype=getattr(np, dtypestr)), # type: ignore + values=np.array([0.0], dtype=getattr(np, dtypestr)), shape=(s, s), ) for i in range(nterms): @@ -1935,7 +1935,7 @@ def sample2count( results = backend.unique_with_counts(sample) # non-jittable else: # jax specified results = backend.unique_with_counts(sample, size=d, fill_value=-1) - return results # type: ignore + return results def count_vector2dict(count: Tensor, n: int, key: str = "bin") -> Dict[Any, int]: diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index ea3370c4..59850ef5 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -136,7 +136,7 @@ def example_block( "fixed_choice": 1, } else: - split_conf = None # type: ignore + split_conf = None n = c._nqubits param = backend.reshape(param, [2 * nlayers, n]) for i in range(n): diff --git a/tensorcircuit/torchnn.py b/tensorcircuit/torchnn.py index 9d0bb6fe..f284e5e7 100644 --- a/tensorcircuit/torchnn.py +++ b/tensorcircuit/torchnn.py @@ -7,13 +7,13 @@ import torch from .cons import backend -from .interfaces import torch_interface # type: ignore +from .interfaces import torch_interface from .utils import is_sequence Tensor = Any -class QuantumNet(torch.nn.Module): # type: ignore +class QuantumNet(torch.nn.Module): def __init__( self, f: Callable[..., Any], @@ -81,7 +81,7 @@ def qpred(x, weights): if use_interface: f = torch_interface(f, jit=use_jit, enable_dlpack=enable_dlpack) self.f = f - self.q_weights = torch.nn.ParameterList() # type: ignore + self.q_weights = torch.nn.ParameterList() if isinstance(weights_shape[0], int): weights_shape = [weights_shape] if not is_sequence(initializer): @@ -89,7 +89,7 @@ def qpred(x, weights): for ws, initf in zip(weights_shape, initializer): if initf is None: initf = torch.randn - self.q_weights.append(torch.nn.Parameter(initf(ws))) # type: ignore + self.q_weights.append(torch.nn.Parameter(initf(ws))) def forward(self, *inputs: Tensor) -> Tensor: ypred = self.f(*inputs, *self.q_weights) diff --git a/tensorcircuit/utils.py b/tensorcircuit/utils.py index 0811cc6a..44861a10 100644 --- a/tensorcircuit/utils.py +++ b/tensorcircuit/utils.py @@ -148,7 +148,7 @@ def wrapper(*args: Any, **kws: Any) -> Any: doc = doc.split("\n") # type: ignore ndoc = [] skip = False - for i, line in enumerate(doc): # type: ignore + for i, line in enumerate(doc): if not skip: ndoc.append(line) else: From 2ab924bd9ee6b0087b2e887cfff3d65b9be308c7 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Oct 2022 11:25:01 +0800 Subject: [PATCH 015/725] mypy type stubs --- .github/workflows/ci.yml | 2 +- .github/workflows/nightly_release.yml | 2 +- requirements/requirements-types.txt | 8 ++++++++ 3 files changed, 10 insertions(+), 2 deletions(-) create mode 100644 requirements/requirements-types.txt diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 65f4ff44..f3ac5cd7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,12 +21,12 @@ jobs: pip install --no-cache-dir -r requirements/requirements.txt pip install --no-cache-dir -r requirements/requirements-extra.txt pip install --no-cache-dir -r requirements/requirements-dev.txt + pip install --no-cache-dir -r requirements/requirements-types.txt - name: black linter run: | black . --check - name: mypy checker run: | - mypy --install-types mypy tensorcircuit - name: pylint checker run: | diff --git a/.github/workflows/nightly_release.yml b/.github/workflows/nightly_release.yml index d9da68c2..d47c1ebe 100644 --- a/.github/workflows/nightly_release.yml +++ b/.github/workflows/nightly_release.yml @@ -25,13 +25,13 @@ jobs: pip install --no-cache-dir -r requirements/requirements.txt pip install --no-cache-dir -r requirements/requirements-extra.txt pip install --no-cache-dir -r requirements/requirements-dev.txt + pip install --no-cache-dir -r requirements/requirements-types.txt pip install requests - name: black linter run: | black . --check - name: mypy checker run: | - mypy --install-types mypy tensorcircuit - name: pylint checker run: | diff --git a/requirements/requirements-types.txt b/requirements/requirements-types.txt new file mode 100644 index 00000000..6626e99d --- /dev/null +++ b/requirements/requirements-types.txt @@ -0,0 +1,8 @@ +types-urllib3 +types-typed-ast +types-toml +types-setuptools +types-requests +types-pytz +types-protobuf +types-docutils \ No newline at end of file From 116ba97c2749fc9e91c4a31ad8e7984598d31a97 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Oct 2022 11:31:09 +0800 Subject: [PATCH 016/725] update cirq version in requirements --- requirements/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index dae1d490..69ddfea0 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,6 +1,6 @@ numpy scipy -cirq==0.11 +cirq==0.13.1 tensorflow==2.7 tensornetwork graphviz From ffd8693a0b370337858d74cd1b995786d36a2350 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 17 Oct 2022 12:27:09 +0800 Subject: [PATCH 017/725] add readout error and its mitigation --- tensorcircuit/basecircuit.py | 73 ++++++++++++- tests/test_channels.py | 196 +++++++++++++++++++++++++++++++++++ 2 files changed, 268 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 1ea4b0cb..1ca122ef 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -10,6 +10,7 @@ import graphviz import tensornetwork as tn +from . import cons from . import gates from .quantum import ( QuOperator, @@ -507,6 +508,7 @@ def sample( self, batch: Optional[int] = None, allow_state: bool = False, + readouterror: Optional[Sequence[Any]] = None, format: Optional[str] = None, random_generator: Optional[Any] = None, ) -> Any: @@ -518,6 +520,8 @@ def sample( :param allow_state: if true, we sample from the final state if memory allsows, True is prefered, defaults to False :type allow_state: bool, optional + :param readouterror: readoutlist, defaults to None + :type readouterror: Optional[Sequence[Any]] :param format: sample format, defaults to None as backward compatibility check the doc in :py:meth:`tensorcircuit.quantum.measurement_results` :type format: Optional[str] @@ -564,8 +568,20 @@ def perfect_sampling(key: Any) -> Any: s = self.state() # type: ignore if self.is_dm is False: p = backend.abs(s) ** 2 + + # readout error + if readouterror is not None: + p = self.readouterror_bs(readouterror, p) + p = backend.real(p) + else: p = backend.abs(backend.diagonal(s)) + + # readout error + if readouterror is not None: + p = self.readouterror_bs(readouterror, p) + p = backend.real(p) + a_range = backend.arange(2**self._nqubits) if random_generator is None: ch = backend.implicit_randc(a=a_range, shape=[nbatch], p=p) @@ -595,6 +611,7 @@ def sample_expectation_ps( z: Optional[Sequence[int]] = None, shots: Optional[int] = None, random_generator: Optional[Any] = None, + readouterror: Optional[Sequence[Any]] = None, **kws: Any, ) -> Tensor: """ @@ -607,6 +624,10 @@ def sample_expectation_ps( >>> c.rx(1, theta=np.pi/2) >>> c.sample_expectation_ps(x=[0], y=[1]) -0.99999976 + >>> readouterror = [] + >>> readouterror.append([0.9,0.75]) + >>> readouterror.append([0.4,0.7]) + >>> c.sample_expectation_ps(x=[0], y=[1],readouterror = readouterror) :param x: index for Pauli X, defaults to None :type x: Optional[Sequence[int]], optional @@ -618,6 +639,8 @@ def sample_expectation_ps( :type shots: Optional[int], optional :param random_generator: random_generator, defaults to None :type random_general: Optional[Any] + :param readouterror: readoutlist, defaults to None + :type readouterror: Optional[Sequence[Any]] :return: [description] :rtype: Tensor """ @@ -640,7 +663,11 @@ def sample_expectation_ps( p = backend.abs(s) ** 2 else: p = backend.abs(backend.diagonal(s)) - # readout error can be processed here later + + # readout error + if readouterror is not None: + p = self.readouterror_bs(readouterror, p) + x = list(x) y = list(y) z = list(z) @@ -669,6 +696,50 @@ def sample_expectation_ps( sexpps = sample_expectation_ps + def readouterror_bs( + self, readouterror: Optional[Sequence[Any]], p: Optional[Any] + ) -> Tensor: + """Apply readout error to original probabilities of bit string and return the noisy probabilities. + + :Example: + + >>> readouterror = [] + >>> readouterror.append([0.9,0.75]) # readout error for qubit 0, [p0|0,p1|1] + >>> readouterror.append([0.4,0.7]) # readout error for qubit 1, [p0|0,p1|1] + + + :param readouterror: list of readout error for each qubits. + :type readouterror: Optional[Sequence[Any]] + :param p: probabilities of bit string + :type p: Optional[Any] + :rtype: Tensor + """ + if isinstance(readouterror, list): + nqubit = len(readouterror) + readoutlist = [] + for i in range(nqubit): + readoutlist.append( + [ + [readouterror[i][0], 1 - readouterror[i][1]], + [1 - readouterror[i][0], readouterror[i][1]], + ] + ) + readoutlist = backend.cast( + backend.convert_to_tensor(readoutlist), dtype=cons.dtypestr + ) + + ms = [Gate(readoutlist[i]) for i in range(nqubit)] + p = backend.cast(p, dtypestr) + p = Gate(backend.reshape2(p)) + for i in range(nqubit): + ms[i][1] ^ p[i] + nodes = ms + [p] + r = contractor(nodes, output_edge_order=[m[0] for m in ms]).tensor + p = backend.reshape(r, [-1]) + else: + raise ValueError("readouterror should be a list") + return p + def replace_inputs(self, inputs: Tensor) -> None: """ Replace the input state with the circuit structure unchanged. diff --git a/tests/test_channels.py b/tests/test_channels.py index 2bba4dca..bdff21df 100644 --- a/tests/test_channels.py +++ b/tests/test_channels.py @@ -1,8 +1,10 @@ import sys import os +import timeit import numpy as np import pytest from pytest_lazyfixture import lazy_fixture as lf +from scipy.optimize import minimize thisfile = os.path.abspath(__file__) @@ -150,3 +152,197 @@ def noisecircuitdm(): valuedm = noisec_jit() np.testing.assert_allclose(valuemc, valuedm, atol=1e-1) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_readout(backend): + + nqubit = 3 + c = tc.Circuit(nqubit) + c.X(0) + + value = c.sample_expectation_ps(z=[0, 1, 2]) + valueaim = -1 + np.testing.assert_allclose(value, valueaim, atol=1e-3) + + readouterror = [] + readouterror.append([0.9, 0.75]) # readout error of qubit 0 + readouterror.append([0.4, 0.7]) # readout error of qubit 1 + readouterror.append([0.7, 0.9]) # readout error of qubit 2 + + value = c.sample_expectation_ps(z=[0, 1, 2], readouterror=readouterror) + valueaim = 0.04 + np.testing.assert_allclose(value, valueaim, atol=1e-1) + + # test jitble + def jitest(readouterror): + nqubit = 3 + c = tc.Circuit(nqubit) + c.X(0) + return c.sample_expectation_ps(z=[0, 1, 2], readouterror=readouterror) + + calvalue = tc.backend.jit(jitest) + value = calvalue(readouterror) + valueaim = 0.04 + np.testing.assert_allclose(value, valueaim, atol=1e-1) + + # test contractor time + start = timeit.default_timer() + + def speed(nqubit): + c = tc.Circuit(nqubit) + c.X(0) + readouterror = [] + for _ in range(nqubit): + readouterror.append([0.9, 0.75]) # readout error of qubit 0 + value = c.sample_expectation_ps( + z=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], readouterror=readouterror + ) + return value + + speed(10) + stop = timeit.default_timer() + print("Time: ", stop - start) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_noisesample(backend): + readouterror = [] + readouterror.append([0.9, 0.75]) # readout error of qubit 0 + readouterror.append([0.4, 0.7]) # readout error of qubit 1 + readouterror.append([0.7, 0.9]) # readout error of qubit 2 + + c = tc.Circuit(3) + c.H(0) + c.cnot(0, 1) + print(c.sample(allow_state=True, readouterror=readouterror)) + print(c.sample(batch=8, allow_state=True, readouterror=readouterror)) + print( + c.sample( + batch=8, + allow_state=True, + readouterror=readouterror, + random_generator=tc.backend.get_random_state(42), + ) + ) + + key = tc.backend.get_random_state(42) + bs = c.sample( + batch=1000, allow_state=True, format_="count_dict_bin", random_generator=key + ) + print(bs) + bs = c.sample( + batch=1000, + allow_state=True, + readouterror=readouterror, + format_="count_dict_bin", + random_generator=key, + ) + print(bs) + + # test jitble + def jitest(readouterror): + c = tc.Circuit(3) + c.H(0) + c.cnot(0, 1) + return c.sample(batch=8, allow_state=True, format_="sample_int") + + calsample = tc.backend.jit(jitest) + sampletest = calsample(readouterror) + print(sampletest) + + +def cali_readout_circ(nqubit): + calicirc = [] + for i in range(2**nqubit): + name = "{:0" + str(nqubit) + "b}" + lisbs = [int(x) for x in name.format(i)] + c = tc.Circuit(nqubit) + for k in range(nqubit): + if lisbs[k] == 1: + c.X(k) + calicirc.append(c) + return calicirc + + +def probability_bs(nqubit, bs, shots): + probability = [0] * 2**nqubit + for s in bs: + probability[int(s, 2)] = bs[s] / shots + 0.0 + return probability + + +def read_mitigate(probability_noise, calmatrix, method="inverse"): + if method == "inverse": + X = np.linalg.inv(calmatrix) + Y = probability_noise + probalibity_cali = X @ Y + else: + + def fun(x): + return sum((probability_noise - calmatrix @ x) ** 2) + + x0 = np.random.rand(len(probability_noise)) + cons = {"type": "eq", "fun": lambda x: 1 - sum(x)} + bnds = tuple((0, 1) for x in x0) + res = minimize(fun, x0, method="SLSQP", constraints=cons, bounds=bnds, tol=1e-6) + probalibity_cali = res.x + return probalibity_cali + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_read_mitigate(backend): + nqubit = 3 + + readouterror = [] + readouterror.append([0.9, 0.75]) # readout error of qubit 0 + readouterror.append([0.4, 0.7]) # readout error of qubit 1 + readouterror.append([0.7, 0.9]) # readout error of qubit 2 + + # calibration matrix + calicirc = cali_readout_circ(nqubit) + shots = 100000 + calmatrix = np.zeros((2**nqubit, 2**nqubit)) + for i in range(2**nqubit): + c = calicirc[i] + key = tc.backend.get_random_state(42) + bs = c.sample( + batch=shots, + allow_state=True, + readouterror=readouterror, + format_="count_dict_bin", + random_generator=key, + ) + for s in bs: + calmatrix[int(s, 2)][i] = bs[s] / shots + 0.0 + + # test circuit + c = tc.Circuit(3) + c.H(0) + c.cnot(0, 1) + c.X(2) + + key = tc.backend.get_random_state(42) + bs = c.sample( + batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key + ) + probability_perfect = probability_bs(nqubit, bs, shots) + print("good", probability_perfect) + + bs = c.sample( + batch=shots, + allow_state=True, + readouterror=readouterror, + format_="count_dict_bin", + random_generator=key, + ) + probability_noise = probability_bs(nqubit, bs, shots) + print("noise", probability_noise) + + probalibity_cali = read_mitigate(probability_noise, calmatrix, method="inverse") + print("cal", probalibity_cali) + np.testing.assert_allclose(probability_perfect, probalibity_cali, atol=1e-1) + + probalibity_cali = read_mitigate(probability_noise, calmatrix, method="square") + print("cal2", probalibity_cali) + np.testing.assert_allclose(probability_perfect, probalibity_cali, atol=1e-1) From 50d38d437e2960286eb989e8ef9880a512212b62 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 17 Oct 2022 14:47:55 +0800 Subject: [PATCH 018/725] revise readout error --- tensorcircuit/basecircuit.py | 94 ++++++++++++++++++------------------ tests/test_channels.py | 87 +++++++++++++++++---------------- 2 files changed, 92 insertions(+), 89 deletions(-) diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 1ca122ef..d7abccc1 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -10,7 +10,6 @@ import graphviz import tensornetwork as tn -from . import cons from . import gates from .quantum import ( QuOperator, @@ -508,7 +507,7 @@ def sample( self, batch: Optional[int] = None, allow_state: bool = False, - readouterror: Optional[Sequence[Any]] = None, + readout_error: Optional[Sequence[Any]] = None, format: Optional[str] = None, random_generator: Optional[Any] = None, ) -> Any: @@ -520,8 +519,8 @@ def sample( :param allow_state: if true, we sample from the final state if memory allsows, True is prefered, defaults to False :type allow_state: bool, optional - :param readouterror: readoutlist, defaults to None - :type readouterror: Optional[Sequence[Any]] + :param readout_error: readout_error, defaults to None + :type readout_error: Optional[Sequence[Any]]. Tensor, List, Tuple :param format: sample format, defaults to None as backward compatibility check the doc in :py:meth:`tensorcircuit.quantum.measurement_results` :type format: Optional[str] @@ -570,17 +569,15 @@ def perfect_sampling(key: Any) -> Any: p = backend.abs(s) ** 2 # readout error - if readouterror is not None: - p = self.readouterror_bs(readouterror, p) - p = backend.real(p) + if readout_error is not None: + p = self.readouterror_bs(readout_error, p) else: p = backend.abs(backend.diagonal(s)) # readout error - if readouterror is not None: - p = self.readouterror_bs(readouterror, p) - p = backend.real(p) + if readout_error is not None: + p = self.readouterror_bs(readout_error, p) a_range = backend.arange(2**self._nqubits) if random_generator is None: @@ -611,7 +608,7 @@ def sample_expectation_ps( z: Optional[Sequence[int]] = None, shots: Optional[int] = None, random_generator: Optional[Any] = None, - readouterror: Optional[Sequence[Any]] = None, + readout_error: Optional[Sequence[Any]] = None, **kws: Any, ) -> Tensor: """ @@ -624,10 +621,10 @@ def sample_expectation_ps( >>> c.rx(1, theta=np.pi/2) >>> c.sample_expectation_ps(x=[0], y=[1]) -0.99999976 - >>> readouterror = [] - >>> readouterror.append([0.9,0.75]) - >>> readouterror.append([0.4,0.7]) - >>> c.sample_expectation_ps(x=[0], y=[1],readouterror = readouterror) + >>> readout_error = [] + >>> readout_error.append([0.9,0.75]) + >>> readout_error.append([0.4,0.7]) + >>> c.sample_expectation_ps(x=[0], y=[1],readout_error = readout_error) :param x: index for Pauli X, defaults to None :type x: Optional[Sequence[int]], optional @@ -639,8 +636,8 @@ def sample_expectation_ps( :type shots: Optional[int], optional :param random_generator: random_generator, defaults to None :type random_general: Optional[Any] - :param readouterror: readoutlist, defaults to None - :type readouterror: Optional[Sequence[Any]] + :param readout_error: readout_error, defaults to None + :type readout_error: Optional[Sequence[Any]]. Tensor, List, Tuple :return: [description] :rtype: Tensor """ @@ -665,8 +662,8 @@ def sample_expectation_ps( p = backend.abs(backend.diagonal(s)) # readout error - if readouterror is not None: - p = self.readouterror_bs(readouterror, p) + if readout_error is not None: + p = self.readouterror_bs(readout_error, p) x = list(x) y = list(y) @@ -697,48 +694,49 @@ def sample_expectation_ps( sexpps = sample_expectation_ps def readouterror_bs( - self, readouterror: Optional[Sequence[Any]], p: Optional[Any] + self, readout_error: Optional[Sequence[Any]] = None, p: Optional[Any] = None ) -> Tensor: """Apply readout error to original probabilities of bit string and return the noisy probabilities. :Example: - >>> readouterror = [] - >>> readouterror.append([0.9,0.75]) # readout error for qubit 0, [p0|0,p1|1] - >>> readouterror.append([0.4,0.7]) # readout error for qubit 1, [p0|0,p1|1] + >>> readout_error = [] + >>> readout_error.append([0.9,0.75]) # readout error for qubit 0, [p0|0,p1|1] + >>> readout_error.append([0.4,0.7]) # readout error for qubit 1, [p0|0,p1|1] - :param readouterror: list of readout error for each qubits. - :type readouterror: Optional[Sequence[Any]] + :param readout_error: list of readout error for each qubits. + :type readout_error: Optional[Sequence[Any]]. Tensor, List, Tuple :param p: probabilities of bit string :type p: Optional[Any] :rtype: Tensor """ - if isinstance(readouterror, list): - nqubit = len(readouterror) - readoutlist = [] - for i in range(nqubit): - readoutlist.append( - [ - [readouterror[i][0], 1 - readouterror[i][1]], - [1 - readouterror[i][0], readouterror[i][1]], - ] - ) - readoutlist = backend.cast( - backend.convert_to_tensor(readoutlist), dtype=cons.dtypestr + # if isinstance(readout_error, tuple): + # readout_error = list[readout_error] # type: ignore + + nqubit = len(readout_error) # type: ignore + readoutlist = [] + for i in range(nqubit): + readoutlist.append( + [ + [readout_error[i][0], 1 - readout_error[i][1]], # type: ignore + [1 - readout_error[i][0], readout_error[i][1]], # type: ignore + ] ) + readoutlist = backend.cast( + backend.convert_to_tensor(readoutlist), dtype=dtypestr + ) - ms = [Gate(readoutlist[i]) for i in range(nqubit)] - p = backend.cast(p, dtypestr) - p = Gate(backend.reshape2(p)) - for i in range(nqubit): - ms[i][1] ^ p[i] - nodes = ms + [p] - r = contractor(nodes, output_edge_order=[m[0] for m in ms]).tensor - p = backend.reshape(r, [-1]) - else: - raise ValueError("readouterror should be a list") - return p + ms = [Gate(readoutlist[i]) for i in range(nqubit)] + p = backend.cast(p, dtypestr) + p = Gate(backend.reshape2(p)) + for i in range(nqubit): + ms[i][1] ^ p[i] + nodes = ms + [p] + r = contractor(nodes, output_edge_order=[m[0] for m in ms]).tensor + p = backend.reshape(r, [-1]) + + return backend.real(p) def replace_inputs(self, inputs: Tensor) -> None: """ diff --git a/tests/test_channels.py b/tests/test_channels.py index bdff21df..dd9a365a 100644 --- a/tests/test_channels.py +++ b/tests/test_channels.py @@ -1,6 +1,5 @@ import sys import os -import timeit import numpy as np import pytest from pytest_lazyfixture import lazy_fixture as lf @@ -165,63 +164,69 @@ def test_readout(backend): valueaim = -1 np.testing.assert_allclose(value, valueaim, atol=1e-3) - readouterror = [] - readouterror.append([0.9, 0.75]) # readout error of qubit 0 - readouterror.append([0.4, 0.7]) # readout error of qubit 1 - readouterror.append([0.7, 0.9]) # readout error of qubit 2 + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + readout_error.append([0.7, 0.9]) # readout error of qubit 2 - value = c.sample_expectation_ps(z=[0, 1, 2], readouterror=readouterror) + # readout_error is a list + value = c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) + valueaim = 0.04 + np.testing.assert_allclose(value, valueaim, atol=1e-1) + + # readout_error is a tensor + readout_error = tc.array_to_tensor(readout_error) + value = c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) valueaim = 0.04 np.testing.assert_allclose(value, valueaim, atol=1e-1) # test jitble - def jitest(readouterror): + def jitest(readout_error): nqubit = 3 c = tc.Circuit(nqubit) c.X(0) - return c.sample_expectation_ps(z=[0, 1, 2], readouterror=readouterror) + return c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) calvalue = tc.backend.jit(jitest) - value = calvalue(readouterror) + value = calvalue(readout_error) valueaim = 0.04 np.testing.assert_allclose(value, valueaim, atol=1e-1) # test contractor time - start = timeit.default_timer() - - def speed(nqubit): - c = tc.Circuit(nqubit) - c.X(0) - readouterror = [] - for _ in range(nqubit): - readouterror.append([0.9, 0.75]) # readout error of qubit 0 - value = c.sample_expectation_ps( - z=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], readouterror=readouterror - ) - return value - - speed(10) - stop = timeit.default_timer() - print("Time: ", stop - start) + # start = timeit.default_timer() + # def speed(nqubit): + # c = tc.Circuit(nqubit) + # c.X(0) + # readout_error = [] + # for _ in range(nqubit): + # readout_error.append([0.9, 0.75]) # readout error of qubit 0 + # value = c.sample_expectation_ps( + # z=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], readout_error=readout_error + # ) + # return value + + # speed(10) + # stop = timeit.default_timer() + # print("Time: ", stop - start) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_noisesample(backend): - readouterror = [] - readouterror.append([0.9, 0.75]) # readout error of qubit 0 - readouterror.append([0.4, 0.7]) # readout error of qubit 1 - readouterror.append([0.7, 0.9]) # readout error of qubit 2 + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + readout_error.append([0.7, 0.9]) # readout error of qubit 2 c = tc.Circuit(3) c.H(0) c.cnot(0, 1) - print(c.sample(allow_state=True, readouterror=readouterror)) - print(c.sample(batch=8, allow_state=True, readouterror=readouterror)) + print(c.sample(allow_state=True, readout_error=readout_error)) + print(c.sample(batch=8, allow_state=True, readout_error=readout_error)) print( c.sample( batch=8, allow_state=True, - readouterror=readouterror, + readout_error=readout_error, random_generator=tc.backend.get_random_state(42), ) ) @@ -234,21 +239,21 @@ def test_noisesample(backend): bs = c.sample( batch=1000, allow_state=True, - readouterror=readouterror, + readout_error=readout_error, format_="count_dict_bin", random_generator=key, ) print(bs) # test jitble - def jitest(readouterror): + def jitest(readout_error): c = tc.Circuit(3) c.H(0) c.cnot(0, 1) return c.sample(batch=8, allow_state=True, format_="sample_int") calsample = tc.backend.jit(jitest) - sampletest = calsample(readouterror) + sampletest = calsample(readout_error) print(sampletest) @@ -294,10 +299,10 @@ def fun(x): def test_read_mitigate(backend): nqubit = 3 - readouterror = [] - readouterror.append([0.9, 0.75]) # readout error of qubit 0 - readouterror.append([0.4, 0.7]) # readout error of qubit 1 - readouterror.append([0.7, 0.9]) # readout error of qubit 2 + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + readout_error.append([0.7, 0.9]) # readout error of qubit 2 # calibration matrix calicirc = cali_readout_circ(nqubit) @@ -309,7 +314,7 @@ def test_read_mitigate(backend): bs = c.sample( batch=shots, allow_state=True, - readouterror=readouterror, + readout_error=readout_error, format_="count_dict_bin", random_generator=key, ) @@ -332,7 +337,7 @@ def test_read_mitigate(backend): bs = c.sample( batch=shots, allow_state=True, - readouterror=readouterror, + readout_error=readout_error, format_="count_dict_bin", random_generator=key, ) From 5a6b633820a56f09d673b076caac30b7b7380f5f Mon Sep 17 00:00:00 2001 From: xptree Date: Mon, 17 Oct 2022 16:30:11 +0800 Subject: [PATCH 019/725] load googles' random circuit in qsim format --- tensorcircuit/abstractcircuit.py | 86 ++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index bd355930..c1700a95 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -8,6 +8,7 @@ from operator import add import json import logging +import math import numpy as np import tensornetwork as tn @@ -600,6 +601,91 @@ def to_json(self, file: Optional[str] = None, simplified: bool = False) -> Any: json.dump(tcqasm, f) return json.dumps(tcqasm) + @classmethod + def from_qsim_file( + cls, file: str, circuit_params: Optional[Dict[str, Any]] = None + ) -> "AbstractCircuit": + with open(file, "r") as f: + lines = f.readlines() + if circuit_params is None: + circuit_params = {} + if "nqubits" not in circuit_params: + circuit_params["nqubits"] = int(lines[0]) + + c = cls(**circuit_params) + c = cls._apply_qsim(c, lines) + return c + + @staticmethod + def _apply_qsim(c: "AbstractCircuit", qsim_str: List[str]) -> "AbstractCircuit": + def _convert_ints_and_floats(x: str) -> Union[str, int, float]: + try: + return int(x) + except ValueError: + pass + + try: + return float(x) + except ValueError: + pass + + return x.lower() + + qsim_gates = [ + tuple(map(_convert_ints_and_floats, line.strip().split(" "))) + for line in qsim_str[1:] + if line + ] + # https://github.com/quantumlib/qsim/blob/master/docs/input_format.md + # https://github.com/jcmgray/quimb/blob/master/quimb/tensor/circuit.py#L241 + for gate in qsim_gates: + print(gate) + if gate[1] == "h": + c.h(gate[2]) + elif gate[1] == "x": + c.x(gate[2]) + elif gate[1] == "y": + c.y(gate[2]) + elif gate[1] == "z": + c.z(gate[2]) + elif gate[1] == "s": + c.phase(gate[2], theta=math.pi / 2) + elif gate[1] == "t": + c.phase(gate[2], theta=math.pi / 4) + elif gate[1] == "x_1_2": + c.rx(gate[2], theta=math.pi / 2) + elif gate[1] == "y_1_2": + c.ry(gate[2], theta=math.pi / 2) + elif gate[1] == "z_1_2": + c.rz(gate[2], theta=math.pi / 2) + elif gate[1] == "w_1_2": + c.u(gate[2], theta=math.pi / 2, phi=-math.pi / 4, lbd=math.pi / 4) + elif gate[1] == "hz_1_2": + c.wroot(gate[2]) + elif gate[1] == "cnot": + c.cnot(gate[2], gate[3]) + elif gate[1] == "cx": + c.cx(gate[2], gate[3]) + elif gate[1] == "cy": + c.cy(gate[2], gate[3]) + elif gate[1] == "cz": + c.cz(gate[2], gate[3]) + elif gate[1] == "is" or gate[1] == "iswap": + c.iswap(gate[2], gate[3]) + elif gate[1] == "rx": + c.rx(gate[2], theta=gate[3]) + elif gate[1] == "ry": + c.ry(gate[2], theta=gate[3]) + elif gate[1] == "rz": + c.rz(gate[2], theta=gate[3]) + elif gate[1] == "fs" or gate[1] == "fsim": + i, j, theta, phi = gate[2:] + c.iswap(i, j, theta=-theta) + c.cphase(i, j, theta=-phi) + else: + raise NotImplementedError + return c + @classmethod def from_json( cls, jsonstr: str, circuit_params: Optional[Dict[str, Any]] = None From 2e58d8f38710dac319032577fc1535946f5385d3 Mon Sep 17 00:00:00 2001 From: xptree Date: Mon, 17 Oct 2022 17:33:25 +0800 Subject: [PATCH 020/725] fix PR review comments * replace math.pi with np.pi * remove print for debug * use getattr to avoid mypy error --- tensorcircuit/abstractcircuit.py | 44 +++++++++++++++----------------- 1 file changed, 21 insertions(+), 23 deletions(-) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index c1700a95..fbb15961 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -8,7 +8,6 @@ from operator import add import json import logging -import math import numpy as np import tensornetwork as tn @@ -639,49 +638,48 @@ def _convert_ints_and_floats(x: str) -> Union[str, int, float]: # https://github.com/quantumlib/qsim/blob/master/docs/input_format.md # https://github.com/jcmgray/quimb/blob/master/quimb/tensor/circuit.py#L241 for gate in qsim_gates: - print(gate) if gate[1] == "h": - c.h(gate[2]) + getattr(c, "H")(gate[2]) elif gate[1] == "x": - c.x(gate[2]) + getattr(c, "X")(gate[2]) elif gate[1] == "y": - c.y(gate[2]) + getattr(c, "Y")(gate[2]) elif gate[1] == "z": - c.z(gate[2]) + getattr(c, "Z")(gate[2]) elif gate[1] == "s": - c.phase(gate[2], theta=math.pi / 2) + getattr(c, "PHASE")(gate[2], theta=np.pi / 2) elif gate[1] == "t": - c.phase(gate[2], theta=math.pi / 4) + getattr(c, "PHASE")(gate[2], theta=np.pi / 4) elif gate[1] == "x_1_2": - c.rx(gate[2], theta=math.pi / 2) + getattr(c, "RX")(gate[2], theta=np.pi / 2) elif gate[1] == "y_1_2": - c.ry(gate[2], theta=math.pi / 2) + getattr(c, "RY")(gate[2], theta=np.pi / 2) elif gate[1] == "z_1_2": - c.rz(gate[2], theta=math.pi / 2) + getattr(c, "RZ")(gate[2], theta=np.pi / 2) elif gate[1] == "w_1_2": - c.u(gate[2], theta=math.pi / 2, phi=-math.pi / 4, lbd=math.pi / 4) + getattr(c, "U")(gate[2], theta=np.pi / 2, phi=-np.pi / 4, lbd=np.pi / 4) elif gate[1] == "hz_1_2": - c.wroot(gate[2]) + getattr(c, "WROOT")(gate[2]) elif gate[1] == "cnot": - c.cnot(gate[2], gate[3]) + getattr(c, "CNOT")(gate[2], gate[3]) elif gate[1] == "cx": - c.cx(gate[2], gate[3]) + getattr(c, "CX")(gate[2], gate[3]) elif gate[1] == "cy": - c.cy(gate[2], gate[3]) + getattr(c, "CY")(gate[2], gate[3]) elif gate[1] == "cz": - c.cz(gate[2], gate[3]) + getattr(c, "CZ")(gate[2], gate[3]) elif gate[1] == "is" or gate[1] == "iswap": - c.iswap(gate[2], gate[3]) + getattr(c, "ISWAP")(gate[2], gate[3]) elif gate[1] == "rx": - c.rx(gate[2], theta=gate[3]) + getattr(c, "RX")(gate[2], theta=gate[3]) elif gate[1] == "ry": - c.ry(gate[2], theta=gate[3]) + getattr(c, "RY")(gate[2], theta=gate[3]) elif gate[1] == "rz": - c.rz(gate[2], theta=gate[3]) + getattr(c, "RZ")(gate[2], theta=gate[3]) elif gate[1] == "fs" or gate[1] == "fsim": i, j, theta, phi = gate[2:] - c.iswap(i, j, theta=-theta) - c.cphase(i, j, theta=-phi) + getattr(c, "ISWAP")(i, j, theta=-theta) # type: ignore + getattr(c, "CPHASE")(i, j, theta=-phi) # type: ignore else: raise NotImplementedError return c From 33319c57a71814a331c643cf52d35a1f554114bc Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Fri, 21 Oct 2022 20:35:41 +0800 Subject: [PATCH 021/725] add docs --- docs/source/quickstart.rst | 59 +++++++++++ examples/noise.py | 208 +++++++++++++++++++++++++++++++++++++ 2 files changed, 267 insertions(+) create mode 100644 examples/noise.py diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 50b972c3..75d1b35c 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -458,10 +458,69 @@ For the Monte Carlo trajectory noise simulator, the unitary Kraus channel can be >>> c.state() array([0.+0.j, 0.+0.j, 0.+1.j, 0.+0.j], dtype=complex64) + >>> def noisecircuit(X): + >>> c = tc.Circuit(n) + >>> c.x(0) + >>> c.thermalrelaxtion(0, t1 = 300, t2 = 400, time=1000, method = "ByChoi",excitedstatepopulation = 0,status = X) + >>> return c.expectation_ps(z=[0]) + >>> K = tc.set_backend("tensorflow") + >>> noisec_vmap = K.jit(K.vmap(noisecircuit, vectorized_argnums=0)) + >>> nmc = 10000 + >>> X = K.implicit_randu(nmc) + >>> valuemc = sum(K.numpy(noisec_vmap(X))) / nmc + (0.931+0j) + + **Density Matrix Simulator:** Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full form, but takes twice qubits to do noiseless simulation. The API is the same as ``tc.Circuit``. +.. code-block:: python + + >>> def noisecircuitdm(): + >>> dmc = tc.DMCircuit(1) + >>> dmc.x(0) + >>> dmc.thermalrelaxation(0, t1=300, t2=400, time=1000, method="ByChoi", excitedstatepopulation=0) + >>> return dmc.expectation_ps(z=[0]) + >>> K = tc.set_backend("tensorflow") + >>> noisec_jit = K.jit(noisecircuitdm) + >>> valuedm = noisec_jit() + (0.931+0j) + + +**Experiment with quantum errors:** + +Multiple quantum errors can be added on circuit. + +.. code-block:: python + + c = tc.Circuit(1) + c.x(0) + c.thermalrelaxation(0,t1 = 300, t2 = 400, time = 1000,method = "ByChoi", excitedstatepopulation = 0) + c.generaldepolarizing(0,p = 0.01, num_qubits =1) + c.phasedamping(0,gamma=0.2) + c.amplitudedamping(0,gamma = 0.25,p = 0.2) + c.reset(0) + c.expectation_ps(z=[0]) + + +**Experiment with readout error:** + +Readout error can be added in experiments for sampling and expectation value calculation. + +.. code-block:: python + + >>> c = tc.Circuit(3) + >>> c.X(0) + >>> readout_error = [] + >>> readout_error.append([0.9, 0.75]) # readout error of qubit 0 + >>> readout_error.append([0.4, 0.7]) # readout error of qubit 1 + >>> readout_error.append([0.7, 0.9]) # readout error of qubit 2 + >>> value = c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) + tf.Tensor(0.039999977, shape=(), dtype=float32) + >>> instance = c.sample(allow_state=True, readout_error=readout_error) + (, ) + MPS and MPO ---------------- diff --git a/examples/noise.py b/examples/noise.py new file mode 100644 index 00000000..8f416d78 --- /dev/null +++ b/examples/noise.py @@ -0,0 +1,208 @@ +""" +1. Add readout error and mitigate readout error with two methods. +2. Add thermalrelaxition error and calibrate the thermalrelaxition error. + +""" + +import numpy as np +from scipy.optimize import minimize, curve_fit +import tensorcircuit as tc + +# Add readout error and mitigate readout error with two methods. +def cali_readout_circ(nqubit): + calicirc = [] + for i in range(2**nqubit): + name = "{:0" + str(nqubit) + "b}" + lisbs = [int(x) for x in name.format(i)] + c = tc.Circuit(nqubit) + for k in range(nqubit): + if lisbs[k] == 1: + c.X(k) + calicirc.append(c) + return calicirc + + +def probability_bs(nqubit, bs, shots): + probability = [0] * 2**nqubit + for s in bs: + probability[int(s, 2)] = bs[s] / shots + 0.0 + return probability + + +def read_mitigate(probability_noise, calmatrix, method="inverse"): + if method == "inverse": + X = np.linalg.inv(calmatrix) + Y = probability_noise + probalibity_cali = X @ Y + else: + + def fun(x): + return sum((probability_noise - calmatrix @ x) ** 2) + + x0 = np.random.rand(len(probability_noise)) + cons = {"type": "eq", "fun": lambda x: 1 - sum(x)} + bnds = tuple((0, 1) for x in x0) + res = minimize(fun, x0, method="SLSQP", constraints=cons, bounds=bnds, tol=1e-6) + probalibity_cali = res.x + return probalibity_cali + + +def mitigate_readout(nqubit, circ, readout_error): + + K = tc.set_backend("tensorflow") + + # calibration matrix + calicirc = cali_readout_circ(nqubit) + shots = 100000 + calmatrix = np.zeros((2**nqubit, 2**nqubit)) + for i in range(2**nqubit): + c = calicirc[i] + key = K.get_random_state(42) + bs = c.sample( + batch=shots, + allow_state=True, + readout_error=readout_error, + format_="count_dict_bin", + random_generator=key, + ) + for s in bs: + calmatrix[int(s, 2)][i] = bs[s] / shots + 0.0 + + key = K.get_random_state(42) + bs = circ.sample( + batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key + ) + probability_perfect = probability_bs(nqubit, bs, shots) + print("good", probability_perfect) + + bs = circ.sample( + batch=shots, + allow_state=True, + readout_error=readout_error, + format_="count_dict_bin", + random_generator=key, + ) + probability_noise = probability_bs(nqubit, bs, shots) + print("noise", probability_noise) + + probalibity_cali = read_mitigate(probability_noise, calmatrix, method="inverse") + print("miti", probalibity_cali) + + probalibity_cali = read_mitigate(probability_noise, calmatrix, method="square") + print("miti2", probalibity_cali) + + +nqubit = 3 +c = tc.Circuit(nqubit) +c.H(0) +c.cnot(0, 1) +c.X(2) + +readout_error = [] +readout_error.append([0.9, 0.75]) # readout error of qubit 0 +readout_error.append([0.4, 0.7]) # readout error of qubit 1 +readout_error.append([0.7, 0.9]) # readout error of qubit 2 + +mitigate_readout(nqubit, c, readout_error) + + +# Thermalrelaxition calibration +def fit_function(x_values, y_values, function, init_params): + fitparams, _ = curve_fit(function, x_values, y_values, init_params) + return fitparams + + +def T1_cali(t1, t2, time, method, excitedstatepopulation): + + # calibrating experiments + nstep = int(4 * t1 / time) + pex = [] + for i in range(nstep): + + dmc = tc.DMCircuit(1) + dmc.x(0) + for _ in range(i): + dmc.i(0) + dmc.thermalrelaxation( + 0, + t1=t1, + t2=t2, + time=time, + method=method, + excitedstatepopulation=excitedstatepopulation, + ) + + val = dmc.expectation_ps(z=[0]) + p = (1 - val) / 2.0 + pex.append(p) + + timelist = np.array([i * time for i in range(nstep)]) + measurement = np.array(np.real(pex)) + + return measurement, timelist + + +def T2_cali(t1, t2, time, method, excitedstatepopulation): + + # calibrating experiments + nstep = int(4 * t2 / time) + pex = [] + for i in range(nstep): + + dmc = tc.DMCircuit(1) + dmc.h(0) + for _ in range(0, i): + dmc.i(0) + dmc.thermalrelaxation( + 0, + t1=t1, + t2=t2, + time=time, + method=method, + excitedstatepopulation=excitedstatepopulation, + ) + # dmc.rz(0,theta = i*np.pi/1.5) + dmc.h(0) + + val = dmc.expectation_ps(z=[0]) + p = (1 - val) / 2.0 + pex.append(p) + + timelist = np.array([i * time for i in range(nstep)]) + measurement = np.array(np.real(pex)) + + return measurement, timelist + + +# calibrating T1 +t1 = 300 +t2 = 100 +time = 100 +method = "AUTO" +excitedstatepopulation = 0 +measurement, timelist = T1_cali(t1, t2, time, method, excitedstatepopulation) + +fit_params = fit_function( + timelist, measurement, lambda x, A, C, T: (A * np.exp(-x / T) + C), [-3, 0, 100] +) + +_, _, T = fit_params + +np.testing.assert_allclose(t1, T, atol=1e-1) + + +# calibrating T2 +t1 = 300 +t2 = 280 +time = 50 +method = "AUTO" +excitedstatepopulation = 0 +measurement, timelist = T2_cali(t1, t2, time, method, excitedstatepopulation) + +fit_params = fit_function( + timelist, measurement, lambda x, A, C, T: (A * np.exp(-x / T) + C), [-3, 0, 100] +) + +_, _, T = fit_params + +np.testing.assert_allclose(t2, T, atol=1e-1) From 1037e70a26a046b6874f43a0cd8868ade0800d2c Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 24 Oct 2022 12:10:35 +0800 Subject: [PATCH 022/725] docs for error part --- docs/source/quickstart.rst | 96 ++++++----- examples/noise_calibration.py | 291 ++++++++++++++++++++++++++++++++++ tests/test_channels.py | 94 ++++++----- 3 files changed, 402 insertions(+), 79 deletions(-) create mode 100644 examples/noise_calibration.py diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 75d1b35c..8ecbf5f6 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -450,24 +450,26 @@ For the Monte Carlo trajectory noise simulator, the unitary Kraus channel can be .. code-block:: python - >>> c = tc.Circuit(2) - >>> c.unitary_kraus(tc.channels.depolarizingchannel(0.2, 0.2, 0.2), 0) - 0.0 - >>> c.general_kraus(tc.channels.resetchannel(), 1) - 0.0 - >>> c.state() - array([0.+0.j, 0.+0.j, 0.+1.j, 0.+0.j], dtype=complex64) + def noisecircuit(random): + c = tc.Circuit(1) + c.x(0) + c.thermalrelaxation( + 0, + t1=300, + t2=400, + time=1000, + method="ByChoi", + excitedstatepopulation=0, + status=random, + ) + return c.expectation_ps(z=[0]) - >>> def noisecircuit(X): - >>> c = tc.Circuit(n) - >>> c.x(0) - >>> c.thermalrelaxtion(0, t1 = 300, t2 = 400, time=1000, method = "ByChoi",excitedstatepopulation = 0,status = X) - >>> return c.expectation_ps(z=[0]) - >>> K = tc.set_backend("tensorflow") - >>> noisec_vmap = K.jit(K.vmap(noisecircuit, vectorized_argnums=0)) - >>> nmc = 10000 - >>> X = K.implicit_randu(nmc) - >>> valuemc = sum(K.numpy(noisec_vmap(X))) / nmc + + K = tc.set_backend("tensorflow") + noisec_vmap = K.jit(K.vmap(noisecircuit, vectorized_argnums=0)) + nmc = 10000 + random = K.implicit_randu(nmc) + valuemc = K.mean(K.numpy(noisec_vmap(random))) (0.931+0j) @@ -477,14 +479,18 @@ Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full form, bu .. code-block:: python - >>> def noisecircuitdm(): - >>> dmc = tc.DMCircuit(1) - >>> dmc.x(0) - >>> dmc.thermalrelaxation(0, t1=300, t2=400, time=1000, method="ByChoi", excitedstatepopulation=0) - >>> return dmc.expectation_ps(z=[0]) - >>> K = tc.set_backend("tensorflow") - >>> noisec_jit = K.jit(noisecircuitdm) - >>> valuedm = noisec_jit() + def noisecircuitdm(): + dmc = tc.DMCircuit(1) + dmc.x(0) + dmc.thermalrelaxation( + 0, t1=300, t2=400, time=1000, method="ByChoi", excitedstatepopulation=0 + ) + return dmc.expectation_ps(z=[0]) + + + K = tc.set_backend("tensorflow") + noisec_jit = K.jit(noisecircuitdm) + valuedm = noisec_jit() (0.931+0j) @@ -496,10 +502,12 @@ Multiple quantum errors can be added on circuit. c = tc.Circuit(1) c.x(0) - c.thermalrelaxation(0,t1 = 300, t2 = 400, time = 1000,method = "ByChoi", excitedstatepopulation = 0) - c.generaldepolarizing(0,p = 0.01, num_qubits =1) - c.phasedamping(0,gamma=0.2) - c.amplitudedamping(0,gamma = 0.25,p = 0.2) + c.thermalrelaxation( + 0, t1=300, t2=400, time=1000, method="ByChoi", excitedstatepopulation=0 + ) + c.generaldepolarizing(0, p=0.01, num_qubits=1) + c.phasedamping(0, gamma=0.2) + c.amplitudedamping(0, gamma=0.25, p=0.2) c.reset(0) c.expectation_ps(z=[0]) @@ -510,16 +518,26 @@ Readout error can be added in experiments for sampling and expectation value cal .. code-block:: python - >>> c = tc.Circuit(3) - >>> c.X(0) - >>> readout_error = [] - >>> readout_error.append([0.9, 0.75]) # readout error of qubit 0 - >>> readout_error.append([0.4, 0.7]) # readout error of qubit 1 - >>> readout_error.append([0.7, 0.9]) # readout error of qubit 2 - >>> value = c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) - tf.Tensor(0.039999977, shape=(), dtype=float32) - >>> instance = c.sample(allow_state=True, readout_error=readout_error) - (, ) + c = tc.Circuit(3) + c.X(0) + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + readout_error.append([0.7, 0.9]) # readout error of qubit 2 + value = c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) + # tf.Tensor(0.039999977, shape=(), dtype=float32) + instances = c.sample( + batch=3, + allow_state=True, + readout_error=readout_error, + random_generator=tc.backend.get_random_state(42), + ) + #[(, + # ), + #(, + # ), + #(, + # )] MPS and MPO diff --git a/examples/noise_calibration.py b/examples/noise_calibration.py new file mode 100644 index 00000000..19b75994 --- /dev/null +++ b/examples/noise_calibration.py @@ -0,0 +1,291 @@ +""" +1. Add readout error and mitigate readout error with two methods. +2. Add thermalrelaxition error and calibrate the thermalrelaxition error. +""" + +import numpy as np +from scipy.optimize import minimize, curve_fit +import tensorcircuit as tc + +# Add readout error and mitigate readout error with two methods. +def miti_readout_circ(nqubit): + miticirc = [] + for i in range(2**nqubit): + name = "{:0" + str(nqubit) + "b}" + lisbs = [int(x) for x in name.format(i)] + c = tc.Circuit(nqubit) + for k in range(nqubit): + if lisbs[k] == 1: + c.X(k) + miticirc.append(c) + return miticirc + + +def probability_bs(bs): + nqubit = len(list(bs.keys())[0]) + probability = [0] * 2**nqubit + shots = sum([bs[s] for s in bs]) + for s in bs: + probability[int(s, 2)] = bs[s] / shots + return probability + + +def mitigate_probability(probability_noise, calmatrix, method="inverse"): + if method == "inverse": + X = np.linalg.inv(calmatrix) + Y = probability_noise + probability_cali = X @ Y + else: # method="square" + + def fun(x): + return sum((probability_noise - calmatrix @ x) ** 2) + + x0 = np.random.rand(len(probability_noise)) + cons = {"type": "eq", "fun": lambda x: 1 - sum(x)} + bnds = tuple((0, 1) for x in x0) + res = minimize(fun, x0, method="SLSQP", constraints=cons, bounds=bnds, tol=1e-6) + probability_cali = res.x + return probability_cali + + +def mitigate_readout(nqubit, circ, readout_error): + + K = tc.set_backend("tensorflow") + + key = K.get_random_state(42) + keys = [] + for _ in range(2**nqubit): + key, subkey = tc.backend.random_split(key) + keys.append(subkey) + + # calibration matrix + miticirc = miti_readout_circ(nqubit) + shots = 100000 + calmatrix = np.zeros((2**nqubit, 2**nqubit)) + for i in range(2**nqubit): + c = miticirc[i] + key = keys[i] + bs = c.sample( + batch=shots, + allow_state=True, + readout_error=readout_error, + format_="count_dict_bin", + random_generator=key, + ) + for s in bs: + calmatrix[int(s, 2)][i] = bs[s] / shots + + key = K.get_random_state(42) + bs = circ.sample( + batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key + ) + probability_perfect = probability_bs(bs) + print("probability_without_readouterror", probability_perfect) + + bs = circ.sample( + batch=shots, + allow_state=True, + readout_error=readout_error, + format_="count_dict_bin", + random_generator=key, + ) + probability_noise = probability_bs(bs) + print("probability_with_readouterror", probability_noise) + + probalibity_miti = mitigate_probability( + probability_noise, calmatrix, method="inverse" + ) + print("mitigate_readouterror_method1", probalibity_miti) + + probalibity_miti = mitigate_probability( + probability_noise, calmatrix, method="square" + ) + print("mitigate_readouterror_method2", probalibity_miti) + + +def example_readout_mitigate(): + nqubit = 3 + c = tc.Circuit(nqubit) + c.H(0) + c.cnot(0, 1) + c.X(2) + + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + readout_error.append([0.7, 0.9]) # readout error of qubit 2 + + mitigate_readout(nqubit, c, readout_error) + + +# Thermalrelaxition calibration +def fit_function(x_values, y_values, function, init_params): + fitparams, _ = curve_fit(function, x_values, y_values, init_params) + return fitparams + + +def T1_cali(t1, t2, time, method, excitedstatepopulation): + + # calibrating experiments + nstep = int(4 * t1 / time) + pex = [] + for i in range(nstep): + + dmc = tc.DMCircuit(1) + dmc.x(0) + for _ in range(i): + dmc.i(0) + dmc.thermalrelaxation( + 0, + t1=t1, + t2=t2, + time=time, + method=method, + excitedstatepopulation=excitedstatepopulation, + ) + + val = dmc.expectation_ps(z=[0]) + p = (1 - val) / 2.0 + pex.append(p) + + timelist = np.array([i * time for i in range(nstep)]) + measurement = np.array(np.real(pex)) + + return measurement, timelist + + +def T2_cali(t1, t2, time, method, excitedstatepopulation): + + # calibrating experiments + nstep = int(4 * t2 / time) + pex = [] + for i in range(nstep): + + dmc = tc.DMCircuit(1) + dmc.h(0) + for _ in range(0, i): + dmc.i(0) + dmc.thermalrelaxation( + 0, + t1=t1, + t2=t2, + time=time, + method=method, + excitedstatepopulation=excitedstatepopulation, + ) + # dmc.rz(0,theta = i*np.pi/1.5) + dmc.h(0) + + val = dmc.expectation_ps(z=[0]) + p = (1 - val) / 2.0 + pex.append(p) + + timelist = np.array([i * time for i in range(nstep)]) + measurement = np.array(np.real(pex)) + + return measurement, timelist + + +def example_T1_cali(): + t1 = 300 + t2 = 100 + time = 100 + method = "AUTO" + excitedstatepopulation = 0 + measurement, timelist = T1_cali(t1, t2, time, method, excitedstatepopulation) + + fit_params = fit_function( + timelist, measurement, lambda x, A, C, T: (A * np.exp(-x / T) + C), [-3, 0, 100] + ) + + _, _, T = fit_params + + print("realistic_T1", t1) + print("calibrated_T1", T) + + +def example_T2_cali(): + t1 = 300 + t2 = 280 + time = 50 + method = "AUTO" + excitedstatepopulation = 0 + measurement, timelist = T2_cali(t1, t2, time, method, excitedstatepopulation) + + fit_params = fit_function( + timelist, measurement, lambda x, A, C, T: (A * np.exp(-x / T) + C), [-3, 0, 100] + ) + + _, _, T = fit_params + + print("realistic_T2", t2) + print("calibrated_T2", T) + + +if __name__ == "__main__": + example_readout_mitigate() + example_T1_cali() + example_T2_cali() + + +c = tc.Circuit(3) +c.X(0) +readout_error = [] +readout_error.append([0.9, 0.75]) # readout error of qubit 0 +readout_error.append([0.4, 0.7]) # readout error of qubit 1 +readout_error.append([0.7, 0.9]) # readout error of qubit 2 +value = c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) +instance = c.sample(allow_state=True, readout_error=readout_error) +instances = c.sample( + batch=3, + allow_state=True, + readout_error=readout_error, + random_generator=tc.backend.get_random_state(42), +) + +c = tc.Circuit(1) +c.x(0) +c.thermalrelaxation( + 0, t1=300, t2=400, time=1000, method="ByChoi", excitedstatepopulation=0 +) +c.generaldepolarizing(0, p=0.01, num_qubits=1) +c.phasedamping(0, gamma=0.2) +c.amplitudedamping(0, gamma=0.25, p=0.2) +c.reset(0) +c.expectation_ps(z=[0]) + + +def noisecircuit(random): + c = tc.Circuit(1) + c.x(0) + c.thermalrelaxation( + 0, + t1=300, + t2=400, + time=1000, + method="ByChoi", + excitedstatepopulation=0, + status=random, + ) + return c.expectation_ps(z=[0]) + + +K = tc.set_backend("tensorflow") +noisec_vmap = K.jit(K.vmap(noisecircuit, vectorized_argnums=0)) +nmc = 10000 +random = K.implicit_randu(nmc) +valuemc = K.mean(K.numpy(noisec_vmap(random))) + + +def noisecircuitdm(): + dmc = tc.DMCircuit(1) + dmc.x(0) + dmc.thermalrelaxation( + 0, t1=300, t2=400, time=1000, method="ByChoi", excitedstatepopulation=0 + ) + return dmc.expectation_ps(z=[0]) + + +K = tc.set_backend("tensorflow") +noisec_jit = K.jit(noisecircuitdm) +valuedm = noisec_jit() diff --git a/tests/test_channels.py b/tests/test_channels.py index dd9a365a..66ae5a06 100644 --- a/tests/test_channels.py +++ b/tests/test_channels.py @@ -257,8 +257,9 @@ def jitest(readout_error): print(sampletest) -def cali_readout_circ(nqubit): - calicirc = [] +# mitigate readout error +def miti_readout_circ(nqubit): + miticirc = [] for i in range(2**nqubit): name = "{:0" + str(nqubit) + "b}" lisbs = [int(x) for x in name.format(i)] @@ -266,23 +267,25 @@ def cali_readout_circ(nqubit): for k in range(nqubit): if lisbs[k] == 1: c.X(k) - calicirc.append(c) - return calicirc + miticirc.append(c) + return miticirc -def probability_bs(nqubit, bs, shots): +def probability_bs(bs): + nqubit = len(list(bs.keys())[0]) probability = [0] * 2**nqubit + shots = sum([bs[s] for s in bs]) for s in bs: - probability[int(s, 2)] = bs[s] / shots + 0.0 + probability[int(s, 2)] = bs[s] / shots return probability -def read_mitigate(probability_noise, calmatrix, method="inverse"): +def mitigate_probability(probability_noise, calmatrix, method="inverse"): if method == "inverse": X = np.linalg.inv(calmatrix) Y = probability_noise - probalibity_cali = X @ Y - else: + probability_cali = X @ Y + else: # method="square" def fun(x): return sum((probability_noise - calmatrix @ x) ** 2) @@ -291,26 +294,25 @@ def fun(x): cons = {"type": "eq", "fun": lambda x: 1 - sum(x)} bnds = tuple((0, 1) for x in x0) res = minimize(fun, x0, method="SLSQP", constraints=cons, bounds=bnds, tol=1e-6) - probalibity_cali = res.x - return probalibity_cali + probability_cali = res.x + return probability_cali -@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) -def test_read_mitigate(backend): - nqubit = 3 +def mitigate_readout(nqubit, circ, readout_error): - readout_error = [] - readout_error.append([0.9, 0.75]) # readout error of qubit 0 - readout_error.append([0.4, 0.7]) # readout error of qubit 1 - readout_error.append([0.7, 0.9]) # readout error of qubit 2 + key = tc.backend.get_random_state(42) + keys = [] + for _ in range(2**nqubit): + key, subkey = tc.backend.random_split(key) + keys.append(subkey) # calibration matrix - calicirc = cali_readout_circ(nqubit) + miticirc = miti_readout_circ(nqubit) shots = 100000 calmatrix = np.zeros((2**nqubit, 2**nqubit)) for i in range(2**nqubit): - c = calicirc[i] - key = tc.backend.get_random_state(42) + c = miticirc[i] + key = keys[i] bs = c.sample( batch=shots, allow_state=True, @@ -319,35 +321,47 @@ def test_read_mitigate(backend): random_generator=key, ) for s in bs: - calmatrix[int(s, 2)][i] = bs[s] / shots + 0.0 - - # test circuit - c = tc.Circuit(3) - c.H(0) - c.cnot(0, 1) - c.X(2) + calmatrix[int(s, 2)][i] = bs[s] / shots key = tc.backend.get_random_state(42) - bs = c.sample( + bs = circ.sample( batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key ) - probability_perfect = probability_bs(nqubit, bs, shots) - print("good", probability_perfect) + probability_perfect = probability_bs(bs) + print("probability_without_readouterror", probability_perfect) - bs = c.sample( + bs = circ.sample( batch=shots, allow_state=True, readout_error=readout_error, format_="count_dict_bin", random_generator=key, ) - probability_noise = probability_bs(nqubit, bs, shots) - print("noise", probability_noise) + probability_noise = probability_bs(bs) + print("probability_with_readouterror", probability_noise) + + probalibity_miti = mitigate_probability( + probability_noise, calmatrix, method="inverse" + ) + print("mitigate_readouterror_method1", probalibity_miti) + + probalibity_miti = mitigate_probability( + probability_noise, calmatrix, method="square" + ) + print("mitigate_readouterror_method2", probalibity_miti) + - probalibity_cali = read_mitigate(probability_noise, calmatrix, method="inverse") - print("cal", probalibity_cali) - np.testing.assert_allclose(probability_perfect, probalibity_cali, atol=1e-1) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_readout_mitigate(backend): + nqubit = 3 + c = tc.Circuit(nqubit) + c.H(0) + c.cnot(0, 1) + c.X(2) + + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + readout_error.append([0.7, 0.9]) # readout error of qubit 2 - probalibity_cali = read_mitigate(probability_noise, calmatrix, method="square") - print("cal2", probalibity_cali) - np.testing.assert_allclose(probability_perfect, probalibity_cali, atol=1e-1) + mitigate_readout(nqubit, c, readout_error) From c6233abdba90b998d7052f885e93d6dcc5cf017c Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 24 Oct 2022 13:00:04 +0800 Subject: [PATCH 023/725] error docs --- docs/source/quickstart.rst | 17 ++- examples/noise.py | 208 ---------------------------- examples/noise_calibration.py | 66 +-------- mypy.ini | 3 +- tensorcircuit/applications/utils.py | 2 +- tests/test_channels.py | 5 +- 6 files changed, 16 insertions(+), 285 deletions(-) delete mode 100644 examples/noise.py diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 8ecbf5f6..00b5084b 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -470,7 +470,7 @@ For the Monte Carlo trajectory noise simulator, the unitary Kraus channel can be nmc = 10000 random = K.implicit_randu(nmc) valuemc = K.mean(K.numpy(noisec_vmap(random))) - (0.931+0j) + # (0.931+0j) **Density Matrix Simulator:** @@ -491,7 +491,7 @@ Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full form, bu K = tc.set_backend("tensorflow") noisec_jit = K.jit(noisecircuitdm) valuedm = noisec_jit() - (0.931+0j) + # (0.931+0j) **Experiment with quantum errors:** @@ -521,7 +521,7 @@ Readout error can be added in experiments for sampling and expectation value cal c = tc.Circuit(3) c.X(0) readout_error = [] - readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.9, 0.75]) # readout error of qubit 0 p0|0=0.9, p1|1=0.75 readout_error.append([0.4, 0.7]) # readout error of qubit 1 readout_error.append([0.7, 0.9]) # readout error of qubit 2 value = c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) @@ -531,13 +531,12 @@ Readout error can be added in experiments for sampling and expectation value cal allow_state=True, readout_error=readout_error, random_generator=tc.backend.get_random_state(42), + format_="sample_bin" ) - #[(, - # ), - #(, - # ), - #(, - # )] + # tf.Tensor( + # [[1 0 0] + # [1 0 0] + # [1 0 1]], shape=(3, 3), dtype=int32) MPS and MPO diff --git a/examples/noise.py b/examples/noise.py deleted file mode 100644 index 8f416d78..00000000 --- a/examples/noise.py +++ /dev/null @@ -1,208 +0,0 @@ -""" -1. Add readout error and mitigate readout error with two methods. -2. Add thermalrelaxition error and calibrate the thermalrelaxition error. - -""" - -import numpy as np -from scipy.optimize import minimize, curve_fit -import tensorcircuit as tc - -# Add readout error and mitigate readout error with two methods. -def cali_readout_circ(nqubit): - calicirc = [] - for i in range(2**nqubit): - name = "{:0" + str(nqubit) + "b}" - lisbs = [int(x) for x in name.format(i)] - c = tc.Circuit(nqubit) - for k in range(nqubit): - if lisbs[k] == 1: - c.X(k) - calicirc.append(c) - return calicirc - - -def probability_bs(nqubit, bs, shots): - probability = [0] * 2**nqubit - for s in bs: - probability[int(s, 2)] = bs[s] / shots + 0.0 - return probability - - -def read_mitigate(probability_noise, calmatrix, method="inverse"): - if method == "inverse": - X = np.linalg.inv(calmatrix) - Y = probability_noise - probalibity_cali = X @ Y - else: - - def fun(x): - return sum((probability_noise - calmatrix @ x) ** 2) - - x0 = np.random.rand(len(probability_noise)) - cons = {"type": "eq", "fun": lambda x: 1 - sum(x)} - bnds = tuple((0, 1) for x in x0) - res = minimize(fun, x0, method="SLSQP", constraints=cons, bounds=bnds, tol=1e-6) - probalibity_cali = res.x - return probalibity_cali - - -def mitigate_readout(nqubit, circ, readout_error): - - K = tc.set_backend("tensorflow") - - # calibration matrix - calicirc = cali_readout_circ(nqubit) - shots = 100000 - calmatrix = np.zeros((2**nqubit, 2**nqubit)) - for i in range(2**nqubit): - c = calicirc[i] - key = K.get_random_state(42) - bs = c.sample( - batch=shots, - allow_state=True, - readout_error=readout_error, - format_="count_dict_bin", - random_generator=key, - ) - for s in bs: - calmatrix[int(s, 2)][i] = bs[s] / shots + 0.0 - - key = K.get_random_state(42) - bs = circ.sample( - batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key - ) - probability_perfect = probability_bs(nqubit, bs, shots) - print("good", probability_perfect) - - bs = circ.sample( - batch=shots, - allow_state=True, - readout_error=readout_error, - format_="count_dict_bin", - random_generator=key, - ) - probability_noise = probability_bs(nqubit, bs, shots) - print("noise", probability_noise) - - probalibity_cali = read_mitigate(probability_noise, calmatrix, method="inverse") - print("miti", probalibity_cali) - - probalibity_cali = read_mitigate(probability_noise, calmatrix, method="square") - print("miti2", probalibity_cali) - - -nqubit = 3 -c = tc.Circuit(nqubit) -c.H(0) -c.cnot(0, 1) -c.X(2) - -readout_error = [] -readout_error.append([0.9, 0.75]) # readout error of qubit 0 -readout_error.append([0.4, 0.7]) # readout error of qubit 1 -readout_error.append([0.7, 0.9]) # readout error of qubit 2 - -mitigate_readout(nqubit, c, readout_error) - - -# Thermalrelaxition calibration -def fit_function(x_values, y_values, function, init_params): - fitparams, _ = curve_fit(function, x_values, y_values, init_params) - return fitparams - - -def T1_cali(t1, t2, time, method, excitedstatepopulation): - - # calibrating experiments - nstep = int(4 * t1 / time) - pex = [] - for i in range(nstep): - - dmc = tc.DMCircuit(1) - dmc.x(0) - for _ in range(i): - dmc.i(0) - dmc.thermalrelaxation( - 0, - t1=t1, - t2=t2, - time=time, - method=method, - excitedstatepopulation=excitedstatepopulation, - ) - - val = dmc.expectation_ps(z=[0]) - p = (1 - val) / 2.0 - pex.append(p) - - timelist = np.array([i * time for i in range(nstep)]) - measurement = np.array(np.real(pex)) - - return measurement, timelist - - -def T2_cali(t1, t2, time, method, excitedstatepopulation): - - # calibrating experiments - nstep = int(4 * t2 / time) - pex = [] - for i in range(nstep): - - dmc = tc.DMCircuit(1) - dmc.h(0) - for _ in range(0, i): - dmc.i(0) - dmc.thermalrelaxation( - 0, - t1=t1, - t2=t2, - time=time, - method=method, - excitedstatepopulation=excitedstatepopulation, - ) - # dmc.rz(0,theta = i*np.pi/1.5) - dmc.h(0) - - val = dmc.expectation_ps(z=[0]) - p = (1 - val) / 2.0 - pex.append(p) - - timelist = np.array([i * time for i in range(nstep)]) - measurement = np.array(np.real(pex)) - - return measurement, timelist - - -# calibrating T1 -t1 = 300 -t2 = 100 -time = 100 -method = "AUTO" -excitedstatepopulation = 0 -measurement, timelist = T1_cali(t1, t2, time, method, excitedstatepopulation) - -fit_params = fit_function( - timelist, measurement, lambda x, A, C, T: (A * np.exp(-x / T) + C), [-3, 0, 100] -) - -_, _, T = fit_params - -np.testing.assert_allclose(t1, T, atol=1e-1) - - -# calibrating T2 -t1 = 300 -t2 = 280 -time = 50 -method = "AUTO" -excitedstatepopulation = 0 -measurement, timelist = T2_cali(t1, t2, time, method, excitedstatepopulation) - -fit_params = fit_function( - timelist, measurement, lambda x, A, C, T: (A * np.exp(-x / T) + C), [-3, 0, 100] -) - -_, _, T = fit_params - -np.testing.assert_allclose(t2, T, atol=1e-1) diff --git a/examples/noise_calibration.py b/examples/noise_calibration.py index 19b75994..f3fefdf7 100644 --- a/examples/noise_calibration.py +++ b/examples/noise_calibration.py @@ -75,7 +75,8 @@ def mitigate_readout(nqubit, circ, readout_error): for s in bs: calmatrix[int(s, 2)][i] = bs[s] / shots - key = K.get_random_state(42) + key, subkey = tc.backend.random_split(key) + key = subkey bs = circ.sample( batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key ) @@ -226,66 +227,3 @@ def example_T2_cali(): example_readout_mitigate() example_T1_cali() example_T2_cali() - - -c = tc.Circuit(3) -c.X(0) -readout_error = [] -readout_error.append([0.9, 0.75]) # readout error of qubit 0 -readout_error.append([0.4, 0.7]) # readout error of qubit 1 -readout_error.append([0.7, 0.9]) # readout error of qubit 2 -value = c.sample_expectation_ps(z=[0, 1, 2], readout_error=readout_error) -instance = c.sample(allow_state=True, readout_error=readout_error) -instances = c.sample( - batch=3, - allow_state=True, - readout_error=readout_error, - random_generator=tc.backend.get_random_state(42), -) - -c = tc.Circuit(1) -c.x(0) -c.thermalrelaxation( - 0, t1=300, t2=400, time=1000, method="ByChoi", excitedstatepopulation=0 -) -c.generaldepolarizing(0, p=0.01, num_qubits=1) -c.phasedamping(0, gamma=0.2) -c.amplitudedamping(0, gamma=0.25, p=0.2) -c.reset(0) -c.expectation_ps(z=[0]) - - -def noisecircuit(random): - c = tc.Circuit(1) - c.x(0) - c.thermalrelaxation( - 0, - t1=300, - t2=400, - time=1000, - method="ByChoi", - excitedstatepopulation=0, - status=random, - ) - return c.expectation_ps(z=[0]) - - -K = tc.set_backend("tensorflow") -noisec_vmap = K.jit(K.vmap(noisecircuit, vectorized_argnums=0)) -nmc = 10000 -random = K.implicit_randu(nmc) -valuemc = K.mean(K.numpy(noisec_vmap(random))) - - -def noisecircuitdm(): - dmc = tc.DMCircuit(1) - dmc.x(0) - dmc.thermalrelaxation( - 0, t1=300, t2=400, time=1000, method="ByChoi", excitedstatepopulation=0 - ) - return dmc.expectation_ps(z=[0]) - - -K = tc.set_backend("tensorflow") -noisec_jit = K.jit(noisecircuitdm) -valuedm = noisec_jit() diff --git a/mypy.ini b/mypy.ini index 7539c6a0..deb964dc 100644 --- a/mypy.ini +++ b/mypy.ini @@ -2,7 +2,7 @@ python_version = 3.8 ignore_missing_imports = True strict = True -warn_unused_ignores = True +warn_unused_ignores = False disallow_untyped_calls = False local_partial_types = False implicit_reexport = True @@ -12,6 +12,7 @@ implicit_reexport = True ;;only module level * works... ignore_errors = True + [mypy-cirq.*] ignore_errors = True diff --git a/tensorcircuit/applications/utils.py b/tensorcircuit/applications/utils.py index 30cfcd63..a2db4fee 100644 --- a/tensorcircuit/applications/utils.py +++ b/tensorcircuit/applications/utils.py @@ -352,7 +352,7 @@ def color_svg(circuit: cirq.Circuit, *coords: Tuple[int, int]) -> Any: from cirq.contrib.svg import SVGCircuit svg_str = SVGCircuit(circuit)._repr_svg_() - DOMTree = xml.dom.minidom.parseString(svg_str) + DOMTree = xml.dom.minidom.parseString(svg_str) # type: ignore xpos = [] ypos = [] for r in DOMTree.getElementsByTagName("rect"): # [0].setAttribute("fill", "gray") diff --git a/tests/test_channels.py b/tests/test_channels.py index 66ae5a06..21486c47 100644 --- a/tests/test_channels.py +++ b/tests/test_channels.py @@ -323,7 +323,8 @@ def mitigate_readout(nqubit, circ, readout_error): for s in bs: calmatrix[int(s, 2)][i] = bs[s] / shots - key = tc.backend.get_random_state(42) + key, subkey = tc.backend.random_split(key) + key = subkey bs = circ.sample( batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key ) @@ -360,7 +361,7 @@ def test_readout_mitigate(backend): c.X(2) readout_error = [] - readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.9, 0.75]) # readout error of qubit 0, p0|0=0.9, p1|1=0.75 readout_error.append([0.4, 0.7]) # readout error of qubit 1 readout_error.append([0.7, 0.9]) # readout error of qubit 2 From 8193f0f52860691b5555e7a68db942654672e828 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 24 Oct 2022 13:30:49 +0800 Subject: [PATCH 024/725] revise error docs --- examples/noise_calibration.py | 17 ++++++++--------- tests/test_channels.py | 17 ++++++++--------- 2 files changed, 16 insertions(+), 18 deletions(-) diff --git a/examples/noise_calibration.py b/examples/noise_calibration.py index f3fefdf7..cd61c897 100644 --- a/examples/noise_calibration.py +++ b/examples/noise_calibration.py @@ -64,44 +64,43 @@ def mitigate_readout(nqubit, circ, readout_error): calmatrix = np.zeros((2**nqubit, 2**nqubit)) for i in range(2**nqubit): c = miticirc[i] - key = keys[i] bs = c.sample( batch=shots, allow_state=True, readout_error=readout_error, format_="count_dict_bin", - random_generator=key, + random_generator=keys[i], ) for s in bs: calmatrix[int(s, 2)][i] = bs[s] / shots key, subkey = tc.backend.random_split(key) - key = subkey bs = circ.sample( - batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key + batch=shots, allow_state=True, format_="count_dict_bin", random_generator=subkey ) probability_perfect = probability_bs(bs) print("probability_without_readouterror", probability_perfect) + key, subkey = tc.backend.random_split(key) bs = circ.sample( batch=shots, allow_state=True, readout_error=readout_error, format_="count_dict_bin", - random_generator=key, + random_generator=subkey, ) probability_noise = probability_bs(bs) print("probability_with_readouterror", probability_noise) - probalibity_miti = mitigate_probability( + probability_miti = mitigate_probability( probability_noise, calmatrix, method="inverse" ) - print("mitigate_readouterror_method1", probalibity_miti) + print("mitigate_readouterror_method1", probability_miti) - probalibity_miti = mitigate_probability( + probability_miti = mitigate_probability( probability_noise, calmatrix, method="square" ) - print("mitigate_readouterror_method2", probalibity_miti) + print("mitigate_readouterror_method2", probability_miti) def example_readout_mitigate(): diff --git a/tests/test_channels.py b/tests/test_channels.py index 21486c47..89a582cf 100644 --- a/tests/test_channels.py +++ b/tests/test_channels.py @@ -312,44 +312,43 @@ def mitigate_readout(nqubit, circ, readout_error): calmatrix = np.zeros((2**nqubit, 2**nqubit)) for i in range(2**nqubit): c = miticirc[i] - key = keys[i] bs = c.sample( batch=shots, allow_state=True, readout_error=readout_error, format_="count_dict_bin", - random_generator=key, + random_generator=keys[i], ) for s in bs: calmatrix[int(s, 2)][i] = bs[s] / shots key, subkey = tc.backend.random_split(key) - key = subkey bs = circ.sample( - batch=shots, allow_state=True, format_="count_dict_bin", random_generator=key + batch=shots, allow_state=True, format_="count_dict_bin", random_generator=subkey ) probability_perfect = probability_bs(bs) print("probability_without_readouterror", probability_perfect) + key, subkey = tc.backend.random_split(key) bs = circ.sample( batch=shots, allow_state=True, readout_error=readout_error, format_="count_dict_bin", - random_generator=key, + random_generator=subkey, ) probability_noise = probability_bs(bs) print("probability_with_readouterror", probability_noise) - probalibity_miti = mitigate_probability( + probability_miti = mitigate_probability( probability_noise, calmatrix, method="inverse" ) - print("mitigate_readouterror_method1", probalibity_miti) + print("mitigate_readouterror_method1", probability_miti) - probalibity_miti = mitigate_probability( + probability_miti = mitigate_probability( probability_noise, calmatrix, method="square" ) - print("mitigate_readouterror_method2", probalibity_miti) + print("mitigate_readouterror_method2", probability_miti) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) From 05fe634c5b06d674ad8a855e2d3a65206ddd096d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 24 Oct 2022 16:56:54 +0800 Subject: [PATCH 025/725] a rought impl on submit_task --- tensorcircuit/cloud/abstraction.py | 18 +++++++++- tensorcircuit/cloud/apis.py | 32 +++++++++++++++-- tensorcircuit/cloud/tencent.py | 57 ++++++++++++++++++++++++++++-- 3 files changed, 101 insertions(+), 6 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 8efd451b..dbd25ae1 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -2,7 +2,7 @@ Abstraction for Provider, Device and Task """ -from typing import Any, Dict, Optional, Union +from typing import Any, Dict, List, Optional, Union class Provider: @@ -126,3 +126,19 @@ def list_properties(self) -> Dict[str, Any]: from .apis import list_properties return list_properties(self.provider, self) + + def submit_task(self, **task_kws: Any) -> List["Task"]: + from .apis import submit_task + + return submit_task(provider=self.provider, device=self, **task_kws) + + +class Task: + def __init__(self, id_: str, device: Device): + self.id_ = id_ + self.device = device + + def __repr__(self) -> str: + return self.device.__repr__() + "~~" + self.id_ + + __str__ = __repr__ diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index f1f29ba9..f09d34ea 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -2,14 +2,14 @@ main entrypoints of cloud module """ -from typing import Any, Optional, Dict, Union +from typing import Any, List, Optional, Dict, Union from base64 import b64decode, b64encode from functools import partial import json import os import sys -from .abstraction import Provider, Device, sep +from .abstraction import Provider, Device, Task, sep from . import tencent from ..cons import backend @@ -18,6 +18,11 @@ default_provider = Provider.from_name("tencent") +avail_providers = ["tencent"] + + +def list_providers() -> List[Provider]: + return [get_provider(s) for s in avail_providers] def set_provider( @@ -165,8 +170,29 @@ def list_properties( provider = device.provider if token is None: - token = provider.get_token() # type: ignore + token = device.get_token() # type: ignore if provider.name == "tencent": # type: ignore return tencent.list_properties(device, token) else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def submit_task( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + token: Optional[str] = None, + **task_kws: Any, +) -> List[Task]: + if device is None: + device = default_device + device = Device.from_name(device, provider) + if provider is None: + provider = device.provider + + if token is None: + token = device.get_token() # type: ignore + + if provider.name == "tencent": # type: ignore + return tencent.submit_task(device, token, **task_kws) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 3ee40767..be77d5a3 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -2,11 +2,14 @@ Cloud provider from Tencent """ -from typing import Any, Dict, List, Optional +from typing import Any, Dict, List, Optional, Sequence, Union +from json import dumps from .config import tencent_base_url from .utils import rpost_json -from .abstraction import Device, sep +from .abstraction import Device, sep, Task +from ..abstractcircuit import AbstractCircuit +from ..utils import is_sequence def tencent_headers(token: Optional[str] = None) -> Dict[str, str]: @@ -37,3 +40,53 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An return r["device"] # type: ignore else: raise ValueError("No device with the name: %s" % device) + + +def submit_task( + device: Device, + token: str, + lang: str, + shots: Union[int, Sequence[int]] = 1024, + version: str = "1", + prior: int = 1, + circuit: Optional[Union[AbstractCircuit, Sequence[AbstractCircuit]]] = None, + source: Optional[Union[str, Sequence[str]]] = None, + remarks: Optional[str] = None, +) -> List[Task]: + if source is None: + pass # circuit to source logic + if is_sequence(source): + # batched mode + json = [] + if not is_sequence(shots): + shots = [shots for _ in source] # type: ignore + for sc, sh in zip(source, shots): # type: ignore + json.append( + { + "device": device.name, + "shots": sh, + "source": sc, + "version": version, + "lang": lang, + "prior": prior, + "remarks": remarks, + } + ) + + else: + json = { # type: ignore + "device": device.name, + "shots": shots, + "source": source, + "version": version, + "lang": lang, + "prior": prior, + "remarks": remarks, + } + r = rpost_json( + tencent_base_url + "task/submit", json=json, headers=tencent_headers(token) + ) + try: + return [Task(id_=t["id"], device=device) for t in r["tasks"]] + except KeyError: + raise ValueError(dumps(r)) From 4bf70b6c012ab34c40a8dff65da4bacf6a1895dc Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 24 Oct 2022 19:10:18 +0800 Subject: [PATCH 026/725] add to_openqasm --- CHANGELOG.md | 2 ++ tensorcircuit/abstractcircuit.py | 11 +++++++++++ tests/test_circuit.py | 10 ++++++++++ 3 files changed, 23 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index c1d261ee..a67a348d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Add new parameter shift gradient API that supports finite measurement shots and the corresponding example scripts +- Add openqasm format transformation method `c.to_openqasm()` + ### Changed - The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index fbb15961..9044f369 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -509,6 +509,17 @@ def to_qiskit(self) -> Any: qir = self.to_qir() return qir2qiskit(qir, n=self._nqubits) + def to_openqasm(self, **kws: Any) -> str: + """ + transform circuit to openqasm via qiskit circuit, + see https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.qasm.html + for usage on possible options for ``kws`` + + :return: circuit representation in openqasm format + :rtype: str + """ + return self.to_qiskit().qasm(**kws) # type: ignore + def draw(self, **kws: Any) -> Any: """ Visualise the circuit. diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 67437c0e..56dde87e 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1193,3 +1193,13 @@ def test_gate_count(): assert c.gate_count(["rx", "multicontrol"]) == 2 print(c.gate_summary()) # {'h': 2, 'rx': 1, 'multicontrol': 1, 'toffoli': 3} + + +def test_to_openqasm(): + c = tc.Circuit(3) + c.H(0) + c.rz(2, theta=0.2) + c.cnot(2, 1) + c.rzz(0, 1, theta=-1.0) + c.ccx(1, 2, 0) + print(c.to_openqasm(formatted=True)) From 9c899515398bbfd9f0ea29eddcc29dc8047a28f3 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 24 Oct 2022 19:27:43 +0800 Subject: [PATCH 027/725] add support for phase gate in qiskit translation --- CHANGELOG.md | 4 ++++ tensorcircuit/gates.py | 2 ++ tensorcircuit/translation.py | 7 +++++++ tests/test_circuit.py | 2 ++ 4 files changed, 15 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index a67a348d..d5b183da 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ - Add openqasm format transformation method `c.to_openqasm()` +- Add native support for `phase` and `cphase` gates when transforming to qiskit + ### Changed - The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed @@ -20,6 +22,8 @@ - Updated to the latest version of mypy and get rid of lots of type: ignored +- Fix the dtype bug when float is pass to u gate or phase gate. + ## 0.4.1 ### Added diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index bd5f2665..6e0b5e05 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -478,6 +478,7 @@ def phase_gate(theta: float = 0) -> Gate: :return: phase gate :rtype: Gate """ + theta = array_to_tensor(theta) i00, i11 = array_to_tensor(np.array([[1, 0], [0, 0]]), np.array([[0, 0], [0, 1]])) unitary = i00 + backend.exp(1.0j * theta) * i11 return Gate(unitary) @@ -527,6 +528,7 @@ def u_gate(theta: float = 0, phi: float = 0, lbd: float = 0) -> Gate: :return: _description_ :rtype: Gate """ + theta, phi, lbd = array_to_tensor(theta, phi, lbd) i00, i01, i10, i11 = array_to_tensor( np.array([[1, 0], [0, 0]]), np.array([[0, 1], [0, 0]]), diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 519a5aa8..05a1a528 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -124,6 +124,13 @@ def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: ).item(), *index ) + elif gate_name in ["phase", "cphase"]: + getattr(qiskit_circ, gate_name[:-4])( + np.real( + backend.numpy(gates.array_to_tensor(parameters["theta"])) + ).item(), + *index + ) elif gate_name in ["orx", "ory", "orz"]: getattr(qiskit_circ, "c" + gate_name[1:])( np.real( diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 56dde87e..af263c50 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -891,6 +891,8 @@ def test_qir2qiskit(backend): c.oy(4, 3) c.oz(4, 3) c.ox(3, 4) + c.phase(2, theta=0.3) + c.cphase(1, 0, theta=-1.2) c.rx(1, theta=tc.array_to_tensor(np.random.uniform())) c.r(5, theta=tc.array_to_tensor(np.random.uniform())) c.cr( From c035ac8ad50ff389ec6bfee38acb8a3092e2f3f1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 25 Oct 2022 11:15:36 +0800 Subject: [PATCH 028/725] a better qiskit translation infra --- CHANGELOG.md | 8 +++- examples/tcgates.inc | 2 + tensorcircuit/translation.py | 73 +++++++++++++++++++++--------------- tests/test_circuit.py | 6 +++ 4 files changed, 58 insertions(+), 31 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d5b183da..f021b6b7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,8 @@ - Add native support for `phase` and `cphase` gates when transforming to qiskit +- Add native support for `rxx`, `ryy`, `rzz` and `u`, `cu` gates when transforming to qiskit + ### Changed - The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed @@ -22,7 +24,11 @@ - Updated to the latest version of mypy and get rid of lots of type: ignored -- Fix the dtype bug when float is pass to u gate or phase gate. +- Fix the dtype bug when float is pass to u gate or phase gate + +- Fix to qiskit bug when parameterized gate has default nonset parameters + +- Fix `iswap` gate translation to qiskit with support for parameters ## 0.4.1 diff --git a/examples/tcgates.inc b/examples/tcgates.inc index 163203dc..0f3e0f57 100644 --- a/examples/tcgates.inc +++ b/examples/tcgates.inc @@ -112,3 +112,5 @@ gate iswap(θ) a, b { cx a, b; h a; cx b, a; phase(θ*π/2) a; cx b, a; phase(- // wroot gate wroot a { U(π/2, -π/4, π/4) a; } + +// qiskit ref: https://github.com/Qiskit/qiskit-terra/blob/main/qiskit/qasm/libs/qelib1.inc diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 05a1a528..12bd5c66 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -12,11 +12,12 @@ try: from qiskit import QuantumCircuit + from qiskit.circuit.library import XXPlusYYGate import qiskit.quantum_info as qi from qiskit.extensions.exceptions import ExtensionError except ImportError: logger.warning( - "Please first ``pip install qiskit`` to enable related functionality" + "Please first ``pip install -U qiskit`` to enable related functionality" ) from . import gates @@ -54,6 +55,10 @@ def perm_matrix(n: int) -> Tensor: return p_mat +def _get_float(parameters: Any, key: str, default: int = 0) -> float: + return np.real(backend.numpy(gates.array_to_tensor(parameters.get(key, default)))).item() # type: ignore + + def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: r""" Generate a qiskit quantum circuit using the quantum intermediate @@ -95,7 +100,7 @@ def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: "s", "t", "swap", - "iswap", + # "iswap", "cnot", "toffoli", "fredkin", @@ -109,35 +114,44 @@ def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: getattr(qiskit_circ, gate_name + "g")(*index) elif gate_name in ["ox", "oy", "oz"]: getattr(qiskit_circ, "c" + gate_name[1:])(*index, ctrl_state=0) - elif gate_name == "wroot": - wroot_op = qi.Operator( - np.reshape( - backend.numpy(gate_info["gatef"](**parameters).tensor), - [2 ** len(index), 2 ** len(index)], - ) + elif gate_name == "u": + getattr(qiskit_circ, "u")( + _get_float(parameters, "theta"), + _get_float(parameters, "phi"), + _get_float(parameters, "lbd"), + *index ) - qiskit_circ.unitary(wroot_op, index, label=qis_name) - elif gate_name in ["rx", "ry", "rz", "crx", "cry", "crz"]: - getattr(qiskit_circ, gate_name)( - np.real( - backend.numpy(gates.array_to_tensor(parameters["theta"])) - ).item(), + elif gate_name == "cu": + getattr(qiskit_circ, "cu")( + _get_float(parameters, "theta"), + _get_float(parameters, "phi"), + _get_float(parameters, "lbd"), + 0, # gamma *index ) + elif gate_name == "iswap": + qiskit_circ.append( + XXPlusYYGate(np.pi * _get_float(parameters, "theta", 1), np.pi), + index, + ) + elif gate_name == "wroot": + getattr(qiskit_circ, "u")(np.pi / 2, -np.pi / 4, np.pi / 4, *index) + # wroot_op = qi.Operator( + # np.reshape( + # backend.numpy(gate_info["gatef"](**parameters).tensor), + # [2 ** len(index), 2 ** len(index)], + # ) + # ) + # qiskit_circ.unitary(wroot_op, index, label=qis_name) + elif gate_name in ["rx", "ry", "rz", "crx", "cry", "crz", "rxx", "ryy", "rzz"]: + getattr(qiskit_circ, gate_name)(_get_float(parameters, "theta"), *index) elif gate_name in ["phase", "cphase"]: getattr(qiskit_circ, gate_name[:-4])( - np.real( - backend.numpy(gates.array_to_tensor(parameters["theta"])) - ).item(), - *index + _get_float(parameters, "theta"), *index ) elif gate_name in ["orx", "ory", "orz"]: getattr(qiskit_circ, "c" + gate_name[1:])( - np.real( - backend.numpy(gates.array_to_tensor(parameters["theta"])) - ).item(), - *index, - ctrl_state=0 + _get_float(parameters, "theta"), *index, ctrl_state=0 ) elif gate_name in ["exp", "exp1"]: unitary = backend.numpy(backend.convert_to_tensor(parameters["unitary"])) @@ -158,19 +172,18 @@ def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: ) ) qiskit_circ.unitary(qop, index[::-1], label=qis_name) - # TODO(@refraction-ray): support for phase gate and U, cU gate for the circuit translation else: # r cr any gate - qop = qi.Operator( - np.reshape( - backend.numpy(gate_info["gatef"](**parameters).tensor), - [2 ** len(index), 2 ** len(index)], - ) + gatem = np.reshape( + backend.numpy(gate_info["gatef"](**parameters).tensor), + [2 ** len(index), 2 ** len(index)], ) + qop = qi.Operator(gatem) try: qiskit_circ.unitary(qop, index[::-1], label=qis_name) except ExtensionError: logger.warning( - "omit non unitary gate in tensorcircuit when transforming to qiskit" + "omit non unitary gate in tensorcircuit when transforming to qiskit: %s" + % gate_name ) qiskit_circ.unitary( np.eye(2 ** len(index)), index[::-1], label=qis_name diff --git a/tests/test_circuit.py b/tests/test_circuit.py index af263c50..470c317d 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -873,6 +873,7 @@ def test_qir2qiskit(backend): c.cx(2, 3) c.swap(0, 1) c.iswap(0, 1) + c.iswap(1, 3, theta=-1.9) c.toffoli(0, 1, 2) c.s(1) c.t(1) @@ -893,6 +894,11 @@ def test_qir2qiskit(backend): c.ox(3, 4) c.phase(2, theta=0.3) c.cphase(1, 0, theta=-1.2) + c.rxx(0, 2, theta=0.9) + c.ryy(1, 4, theta=-2.0) + c.rzz(1, 3, theta=0.5) + c.u(2, theta=0, lbd=4.6, phi=-0.3) + c.cu(4, 1, theta=1.2) c.rx(1, theta=tc.array_to_tensor(np.random.uniform())) c.r(5, theta=tc.array_to_tensor(np.random.uniform())) c.cr( From 443a27d2ecf7b32e64f468996ac57e4d574db37f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 25 Oct 2022 13:26:10 +0800 Subject: [PATCH 029/725] add u gate support translation from qiskit --- CHANGELOG.md | 2 ++ tensorcircuit/translation.py | 4 ++++ tests/test_circuit.py | 1 + 3 files changed, 7 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index f021b6b7..6407f7c0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,8 @@ - Add native support for `rxx`, `ryy`, `rzz` and `u`, `cu` gates when transforming to qiskit +- Add native support for `u` gate when transforming from qiskit + ### Changed - The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 12bd5c66..7fdec09a 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -262,6 +262,10 @@ def qiskit2tc( getattr(tc_circuit, gate_name)(*idx, theta=parameters) elif gate_name in ["crx_o0", "cry_o0", "crz_o0"]: getattr(tc_circuit, "o" + gate_name[1:-3])(*idx, theta=parameters) + elif gate_name in ["u3", "u"]: + getattr(tc_circuit, "u")( + *idx, theta=parameters[0], phi=parameters[1], lbd=parameters[2] + ) elif gate_name == "hamiltonian": tc_circuit.exp(*idx, theta=parameters[-1], unitary=parameters[0]) elif gate_name == "cswap": diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 470c317d..fdd29bf4 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -976,6 +976,7 @@ def test_qiskit2tc(): qisc.cz(0, 1, ctrl_state=0) qisc.cy(0, 1, ctrl_state=0) qisc.cx(0, 1, ctrl_state=0) + qisc.u(0.3, 0.9, -1.2, 2) qisc.rx(np.random.uniform(), 1) qisc.ry(np.random.uniform(), 2) qisc.rz(np.random.uniform(), 3) From 4d20f5ee94a19e3a1d3eac35fc2f583f6d9578ca Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 25 Oct 2022 14:27:53 +0800 Subject: [PATCH 030/725] delete some comments --- tensorcircuit/translation.py | 9 --------- 1 file changed, 9 deletions(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 7fdec09a..060212d2 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -100,7 +100,6 @@ def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: "s", "t", "swap", - # "iswap", "cnot", "toffoli", "fredkin", @@ -136,13 +135,6 @@ def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: ) elif gate_name == "wroot": getattr(qiskit_circ, "u")(np.pi / 2, -np.pi / 4, np.pi / 4, *index) - # wroot_op = qi.Operator( - # np.reshape( - # backend.numpy(gate_info["gatef"](**parameters).tensor), - # [2 ** len(index), 2 ** len(index)], - # ) - # ) - # qiskit_circ.unitary(wroot_op, index, label=qis_name) elif gate_name in ["rx", "ry", "rz", "crx", "cry", "crz", "rxx", "ryy", "rzz"]: getattr(qiskit_circ, gate_name)(_get_float(parameters, "theta"), *index) elif gate_name in ["phase", "cphase"]: @@ -296,7 +288,6 @@ def qiskit2tc( base_gate = gate_info[0].base_gate ctrl_state = [1] * base_gate.num_qubits idx = idx[: -base_gate.num_qubits] + idx[-base_gate.num_qubits :][::-1] - # print(idx) tc_circuit.multicontrol( *idx, ctrl=ctrl_state, unitary=base_gate.to_matrix() ) From 0cfc78914c617fd6e60630ac8c7f73d8a07f5111 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 26 Oct 2022 10:51:38 +0800 Subject: [PATCH 031/725] add job details --- tensorcircuit/cloud/abstraction.py | 12 ++++++++- tensorcircuit/cloud/apis.py | 39 +++++++++++++++++++++++++++++- tensorcircuit/cloud/tencent.py | 22 ++++++++++++++--- tests/test_cloud.py | 15 ++++++++++-- 4 files changed, 81 insertions(+), 7 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index dbd25ae1..52e26357 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -132,9 +132,14 @@ def submit_task(self, **task_kws: Any) -> List["Task"]: return submit_task(provider=self.provider, device=self, **task_kws) + def get_task(self, taskid: str) -> "Task": + from .apis import get_task + + return get_task(taskid, device=self) + class Task: - def __init__(self, id_: str, device: Device): + def __init__(self, id_: str, device: Optional[Device] = None): self.id_ = id_ self.device = device @@ -142,3 +147,8 @@ def __repr__(self) -> str: return self.device.__repr__() + "~~" + self.id_ __str__ = __repr__ + + def details(self) -> Dict[str, Any]: + from .apis import get_task_details + + return get_task_details(self) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index f09d34ea..240c381c 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -41,7 +41,7 @@ def set_provider( set_provider() get_provider = partial(set_provider, set_global=False) -default_device = Device.from_name("tencent::hello") +default_device = Device.from_name("tencent::simulator:aer") def set_device( @@ -49,6 +49,8 @@ def set_device( device: Optional[Union[str, Device]] = None, set_global: bool = True, ) -> Device: + if provider is not None and device is None: + provider, device = None, provider if device is None: device = default_device device = Device.from_name(device, provider) @@ -163,6 +165,8 @@ def list_properties( device: Optional[Union[str, Device]] = None, token: Optional[str] = None, ) -> Dict[str, Any]: + if provider is not None and device is None: + provider, device = None, provider if device is None: device = default_device device = Device.from_name(device, provider) @@ -177,6 +181,39 @@ def list_properties( raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore +def get_task( + taskid: str, + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, +) -> Task: + if provider is not None and device is None: + provider, device = None, provider + if device is not None: # device can be None for identify tasks + device = Device.from_name(device, provider) + return Task(taskid, device=device) + + +def get_task_details( + taskid: Union[str, Task], token: Optional[str] = None +) -> Dict[str, Any]: + if isinstance(taskid, str): + task = Task(taskid) + else: + task = taskid + if task.device is not None: + device = task.device + else: + device = default_device + if token is None: + token = device.get_token() + provider = device.provider + + if provider.name == "tencent": + return tencent.get_task_details(task, device, token) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + def submit_task( provider: Optional[Union[str, Provider]] = None, device: Optional[Union[str, Device]] = None, diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index be77d5a3..4abc3a6d 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -45,7 +45,7 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An def submit_task( device: Device, token: str, - lang: str, + lang: str = "OPENQASM", shots: Union[int, Sequence[int]] = 1024, version: str = "1", prior: int = 1, @@ -54,7 +54,11 @@ def submit_task( remarks: Optional[str] = None, ) -> List[Task]: if source is None: - pass # circuit to source logic + if is_sequence(circuit): + source = [c.to_openqasm() for c in circuit] # type: ignore + else: + source = circuit.to_openqasm() # type: ignore + lang = "OPENQASM" if is_sequence(source): # batched mode json = [] @@ -87,6 +91,18 @@ def submit_task( tencent_base_url + "task/submit", json=json, headers=tencent_headers(token) ) try: - return [Task(id_=t["id"], device=device) for t in r["tasks"]] + rtn = [Task(id_=t["id"], device=device) for t in r["tasks"]] + if len(rtn) == 1: + return rtn[0] # type: ignore + else: + return rtn except KeyError: raise ValueError(dumps(r)) + + +def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: + json = {"id": task.id_} + r = rpost_json( + tencent_base_url + "task/detail", json=json, headers=tencent_headers(token) + ) + return r # type: ignore diff --git a/tests/test_cloud.py b/tests/test_cloud.py index ca9e2ac1..86c94363 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -6,6 +6,7 @@ modulepath = os.path.dirname(os.path.dirname(thisfile)) sys.path.insert(0, modulepath) +import tensorcircuit as tc from tensorcircuit.cloud import apis from tensorcircuit.cloud import config @@ -40,8 +41,18 @@ def test_get_device(): def test_list_properties(): - d = apis.get_device(device="hello") + d = apis.get_device(device="simulator:aer") print(d.list_properties()) - print(apis.list_properties(device="tencent::hello")) + print(apis.list_properties(device="simulator:aer")) with pytest.raises(ValueError): apis.list_properties(device="hell") + + +def test_submit_task(): + c = tc.Circuit(3) + c.H(0) + c.H(1) + c.H(2) + t = apis.submit_task(device="simulator:aer", circuit=c) + r = t.details() + assert r["task"]["state"] in ["pending", "completed"] From 88949cfaf54838b5315084f15af203676d311c56 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 26 Oct 2022 11:09:53 +0800 Subject: [PATCH 032/725] add task results and status --- tensorcircuit/cloud/abstraction.py | 14 ++++++++++++++ tensorcircuit/cloud/tencent.py | 25 ++++++++++++++++++++++++- 2 files changed, 38 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 52e26357..effd4d32 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -152,3 +152,17 @@ def details(self) -> Dict[str, Any]: from .apis import get_task_details return get_task_details(self) + + def state(self) -> str: + r = self.details() + return r["state"] # type: ignore + + def results(self, format: Optional[str] = None) -> Any: + # TODO(@refraction-ray): support different formats compatible with tc, + # also support format_ alias + if self.state() != "completed": + raise ValueError("Task %s is not completed yet" % self.id_) + r = self.details()["results"] + return r + + status = state diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 4abc3a6d..8e3d239d 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -105,4 +105,27 @@ def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: r = rpost_json( tencent_base_url + "task/detail", json=json, headers=tencent_headers(token) ) - return r # type: ignore + try: + if "counts" in r["task"]["result"]: + r["task"]["results"] = r["task"]["result"]["counts"] + return r["task"] # type: ignore + except KeyError: + raise ValueError(dumps(r)) + + # make the return at least contain the following terms across different providers + """ + 'id': 'd947cd76-a961-4c22-b295-76287c9fdaa3', + 'state': 'completed', + 'at': 1666752095915849, + 'shots': 1024, + 'source': 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[3];\nh q[0];\nh q[1];\nh q[2];\n', + 'device': 'simulator:aer', + 'results': {'000': 123, + '001': 126, + '010': 131, + '011': 128, + '100': 122, + '101': 135, + '110': 128, + '111': 131} + """ From 4087817ab39a683964198d81dd908f43246faab7 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 26 Oct 2022 14:01:25 +0800 Subject: [PATCH 033/725] add more on changelog --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6407f7c0..829b6d3f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ ### Added +- Finished quantum noise modeling and simulation development stage 1. Add more quantum channels and the differentiable transformation between different channel forms. Add readout error support for sample and sample_expectation_ps methods. + - Add new parameter shift gradient API that supports finite measurement shots and the corresponding example scripts - Add openqasm format transformation method `c.to_openqasm()` @@ -14,6 +16,8 @@ - Add native support for `u` gate when transforming from qiskit +- Add circuit `from_qsim_file` method to load Google random circuit structure + ### Changed - The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed From d597f900255a90ea6542b935ca93a4cbb76f0536 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 27 Oct 2022 13:07:58 +0800 Subject: [PATCH 034/725] add searchsorted backend method --- CHANGELOG.md | 2 ++ tensorcircuit/backends/abstract_backend.py | 20 ++++++++++++++++++++ tensorcircuit/backends/jax_backend.py | 7 +++++++ tensorcircuit/backends/numpy_backend.py | 3 +++ tensorcircuit/backends/pytorch_backend.py | 7 +++++++ tensorcircuit/backends/tensorflow_backend.py | 3 +++ tensorcircuit/experimental.py | 2 -- tests/test_backends.py | 4 ++++ 8 files changed, 46 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 829b6d3f..6ed501f4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,8 @@ - Add circuit `from_qsim_file` method to load Google random circuit structure +- Add `searchsorted` method for backend + ### Changed - The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index b6a5cd05..ec370a19 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -746,6 +746,26 @@ def solve(self: Any, A: Tensor, b: Tensor, **kws: Any) -> Tensor: "Backend '{}' has not implemented `solve`.".format(self.name) ) + def searchsorted(self: Any, a: Tensor, v: Tensor, side: str = "left") -> Tensor: + """ + Find indices where elements should be inserted to maintain order. + + :param a: input array sorted in ascending order + :type a: Tensor + :param v: value to inserted + :type v: Tensor + :param side: If ‘left’, the index of the first suitable location found is given. + If ‘right’, return the last such index. + If there is no suitable index, return either 0 or N (where N is the length of a), + defaults to "left" + :type side: str, optional + :return: Array of insertion points with the same shape as v, or an integer if v is a scalar. + :rtype: Tensor + """ + raise NotImplementedError( + "Backend '{}' has not implemented `searchsorted`.".format(self.name) + ) + def tree_map(self: Any, f: Callable[..., Any], *pytrees: Any) -> Any: """ Return the new tree map with multiple arg function ``f`` through pytrees. diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 62cdd635..933f10db 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -389,6 +389,13 @@ def is_tensor(self, a: Any) -> bool: def solve(self, A: Tensor, b: Tensor, assume_a: str = "gen") -> Tensor: # type: ignore return jsp.linalg.solve(A, b, assume_a) + def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: + if not self.is_tensor(a): + a = self.convert_to_tensor(a) + if not self.is_tensor(v): + v = self.convert_to_tensor(v) + return jnp.searchsorted(a, v, side) + def tree_map(self, f: Callable[..., Any], *pytrees: Any) -> Any: return libjax.tree_map(f, *pytrees) diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index bbc86ae9..bde0f489 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -223,6 +223,9 @@ def solve(self, A: Tensor, b: Tensor, assume_a: str = "gen") -> Tensor: # type: # https://stackoverflow.com/questions/44672029/difference-between-numpy-linalg-solve-and-numpy-linalg-lu-solve/44710451 return solve(A, b, assume_a) + def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: + return np.searchsorted(a, v, side=side) # type: ignore + def set_random_state( self, seed: Optional[int] = None, get_only: bool = False ) -> Any: diff --git a/tensorcircuit/backends/pytorch_backend.py b/tensorcircuit/backends/pytorch_backend.py index f9a03663..1a486213 100644 --- a/tensorcircuit/backends/pytorch_backend.py +++ b/tensorcircuit/backends/pytorch_backend.py @@ -389,6 +389,13 @@ def left_shift(self, x: Tensor, y: Tensor) -> Tensor: def solve(self, A: Tensor, b: Tensor, **kws: Any) -> Tensor: return torchlib.linalg.solve(A, b) + def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: + if not self.is_tensor(a): + a = self.convert_to_tensor(a) + if not self.is_tensor(v): + v = self.convert_to_tensor(v) + return torchlib.searchsorted(a, v, side=side) + def reverse(self, a: Tensor) -> Tensor: return torchlib.flip(a, dims=(-1,)) diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 364dcdc0..a6a10df7 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -434,6 +434,9 @@ def solve(self, A: Tensor, b: Tensor, **kws: Any) -> Tensor: return self.reshape(x, x.shape[:-1]) return x + def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: + return tf.searchsorted(a, v, side) + def from_dlpack(self, a: Any) -> Tensor: return tf.experimental.dlpack.from_dlpack(a) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 8d969d7c..290bc93c 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -226,7 +226,6 @@ def parameter_shift_grad( :return: the grad function :rtype: Callable[..., Tensor] """ - # TODO(@refraction-ray): finite shot sample_expectation_ps not supported well for now if jit is True: f = backend.jit(f) @@ -283,7 +282,6 @@ def parameter_shift_grad_v2( :return: the grad function :rtype: Callable[..., Tensor] """ - # TODO(@refraction-ray): finite shot sample_expectation_ps not supported well for now if jit is True: f = backend.jit(f) diff --git a/tests/test_backends.py b/tests/test_backends.py index af1666de..bdf803b8 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -279,6 +279,10 @@ def test_backend_methods_2(backend): np.array([1, 3]), ) assert tc.backend.dtype(tc.backend.ones([])) == "complex64" + edges = [-1, 3.3, 9.1, 10.0] + values = tc.backend.convert_to_tensor(np.array([0.0, 4.1, 12.0], dtype=np.float32)) + r = tc.backend.numpy(tc.backend.searchsorted(edges, values)) + np.testing.assert_allclose(r, np.array([1, 2, 4])) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("torchb")]) From f2d48ff14c9bea908dbd2861a3588b6d885e854e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 27 Oct 2022 13:56:03 +0800 Subject: [PATCH 035/725] add probability_sample method for backend --- CHANGELOG.md | 2 ++ tensorcircuit/backends/abstract_backend.py | 35 ++++++++++++++++++++++ tests/test_backends.py | 10 +++++++ 3 files changed, 47 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6ed501f4..29c28910 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,8 @@ - Add `searchsorted` method for backend +- Add `probability_sample` method for backend as an alternative for `random_choice` since it supports `status` as external randomness format + ### Changed - The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index ec370a19..71d49418 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -1067,6 +1067,41 @@ def stateful_randc( "Backend '{}' has not implemented `stateful_randc`.".format(self.name) ) + def probability_sample( + self: Any, shots: int, p: Tensor, status: Optional[Tensor] = None, g: Any = None + ) -> Tensor: + """ + Drawn ``shots`` samples from probability distribution p, given the external randomness + determined by uniform distributed ``status`` tensor or backend random generator ``g``. + This method is similar with ``stateful_randc``, but it supports ``status`` beyond ``g``, + which is convenient when jit or vmap + + :param shots: Number of samples to draw with replacement + :type shots: int + :param p: prbability vector + :type p: Tensor + :param status: external randomness as a tensor with each element drawn uniformly from [0, 1], + defaults to None + :type status: Optional[Tensor], optional + :param g: backend random genrator, defaults to None + :type g: Any, optional + :return: The drawn sample as an int tensor + :rtype: Tensor + """ + if status is not None: + status = self.convert_to_tensor(status) + elif g is not None: + status = self.stateful_randu(g, shape=[shots]) + else: + status = self.implicit_randu(shape=[shots]) + p = p / self.sum(p) + p_cuml = self.cumsum(p) + r = p_cuml[-1] * (1 - self.cast(status, p.dtype)) + ind = self.searchsorted(p_cuml, r) + a = self.arange(shots) + res = self.gather1d(a, ind) + return res + def gather1d(self: Any, operand: Tensor, indices: Tensor) -> Tensor: """ Return ``operand[indices]``, both ``operand`` and ``indices`` are rank-1 tensor. diff --git a/tests/test_backends.py b/tests/test_backends.py index bdf803b8..1297fff0 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -283,6 +283,16 @@ def test_backend_methods_2(backend): values = tc.backend.convert_to_tensor(np.array([0.0, 4.1, 12.0], dtype=np.float32)) r = tc.backend.numpy(tc.backend.searchsorted(edges, values)) np.testing.assert_allclose(r, np.array([1, 2, 4])) + p = tc.backend.convert_to_tensor( + np.array( + [0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.2, 0.4], dtype=np.float32 + ) + ) + r = tc.backend.probability_sample(10000, p, status=np.random.uniform(size=[10000])) + _, r = np.unique(r, return_counts=True) + np.testing.assert_allclose( + r - tc.backend.numpy(p) * 10000.0, np.zeros([10]), atol=100, rtol=1 + ) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("torchb")]) From e9b6e1489fcd484194d459c7fc7805e67e8d9bb1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 27 Oct 2022 15:28:34 +0800 Subject: [PATCH 036/725] sample method now support status --- CHANGELOG.md | 2 ++ tensorcircuit/backends/abstract_backend.py | 2 +- tensorcircuit/basecircuit.py | 29 ++++++++++++++-------- tensorcircuit/quantum.py | 22 ++++++++++------ tests/test_backends.py | 2 +- tests/test_circuit.py | 8 ++++++ 6 files changed, 45 insertions(+), 20 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 29c28910..81919718 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,8 @@ - Add `probability_sample` method for backend as an alternative for `random_choice` since it supports `status` as external randomness format +- Add `status` support for `sample` and `sample_expection_ps` methods + ### Changed - The inner mechanism for `sample_expectation_ps` is changed to sample representation from count representation for a fast speed diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index 71d49418..352f2f46 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -1098,7 +1098,7 @@ def probability_sample( p_cuml = self.cumsum(p) r = p_cuml[-1] * (1 - self.cast(status, p.dtype)) ind = self.searchsorted(p_cuml, r) - a = self.arange(shots) + a = self.arange(self.shape_tuple(p)[0]) res = self.gather1d(a, ind) return res diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index d7abccc1..148cc2ad 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -510,6 +510,7 @@ def sample( readout_error: Optional[Sequence[Any]] = None, format: Optional[str] = None, random_generator: Optional[Any] = None, + status: Optional[Tensor] = None, ) -> Any: """ batched sampling from state or circuit tensor network directly @@ -526,6 +527,9 @@ def sample( :type format: Optional[str] :param random_generator: random generator, defaults to None :type random_generator: Optional[Any], optional + :param status: external randomness given by tensor uniformly from [0, 1], + if set, can overwrite random_generator + :type status: Optional[Tensor] :return: List (if batch) of tuple (binary configuration tensor and correponding probability) if the format is None, and consitent with format when given :rtype: Any @@ -578,21 +582,20 @@ def perfect_sampling(key: Any) -> Any: # readout error if readout_error is not None: p = self.readouterror_bs(readout_error, p) - - a_range = backend.arange(2**self._nqubits) - if random_generator is None: - ch = backend.implicit_randc(a=a_range, shape=[nbatch], p=p) - else: - ch = backend.stateful_randc( - random_generator, a=a_range, shape=[nbatch], p=p - ) + ch = backend.probability_sample(nbatch, p, status, random_generator) + # if random_generator is None: + # ch = backend.implicit_randc(a=a_range, shape=[nbatch], p=p) + # else: + # ch = backend.stateful_randc( + # random_generator, a=a_range, shape=[nbatch], p=p + # ) # confg = backend.mod( # backend.right_shift( # ch[..., None], backend.reverse(backend.arange(self._nqubits)) # ), # 2, # ) - if format is None: + if format is None: # for backward compatibility confg = sample_int2bin(ch, self._nqubits) prob = backend.gather1d(p, ch) r = list(zip(confg, prob)) # type: ignore @@ -608,6 +611,7 @@ def sample_expectation_ps( z: Optional[Sequence[int]] = None, shots: Optional[int] = None, random_generator: Optional[Any] = None, + status: Optional[Tensor] = None, readout_error: Optional[Sequence[Any]] = None, **kws: Any, ) -> Tensor: @@ -635,7 +639,10 @@ def sample_expectation_ps( :param shots: number of measurement shots, defaults to None, indicating analytical result :type shots: Optional[int], optional :param random_generator: random_generator, defaults to None - :type random_general: Optional[Any] + :type random_generator: Optional[Any] + :param status: external randomness given by tensor uniformly from [0, 1], + if set, can overwrite random_generator + :type status: Optional[Tensor] :param readout_error: readout_error, defaults to None :type readout_error: Optional[Sequence[Any]]. Tensor, List, Tuple :return: [description] @@ -674,6 +681,7 @@ def sample_expectation_ps( counts=shots, format="count_vector", random_generator=random_generator, + status=status, jittable=True, is_prob=True, ) @@ -684,6 +692,7 @@ def sample_expectation_ps( counts=shots, format="sample_bin", random_generator=random_generator, + status=status, jittable=True, is_prob=True, ) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index afcedb1d..98f070b4 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1999,6 +1999,7 @@ def measurement_counts( format: str = "count_vector", is_prob: bool = False, random_generator: Optional[Any] = None, + status: Optional[Tensor] = None, jittable: bool = False, ) -> Any: """ @@ -2048,7 +2049,10 @@ def measurement_counts( defaults to be False :type is_prob: bool :param random_generator: random_generator, defaults to None - :type random_general: Optional[Any] + :type random_generator: Optional[Any] + :param status: external randomness given by tensor uniformly from [0, 1], + if set, can overwrite random_generator + :type status: Optional[Tensor] :param jittable: if True, jax backend try using a jittable count, defaults to False :type jittable: bool :return: The counts for each bit string measured. @@ -2066,7 +2070,6 @@ def measurement_counts( pi = backend.reshape(pi, [-1]) d = int(backend.shape_tuple(pi)[0]) n = int(np.log(d) / np.log(2) + 1e-8) - drange = backend.arange(d) if (counts is None) or counts <= 0: if format == "count_vector": return pi @@ -2081,12 +2084,15 @@ def measurement_counts( "unsupported format %s for analytical measurement" % format ) else: - if random_generator is None: - raw_counts = backend.implicit_randc(drange, shape=counts, p=pi) - else: - raw_counts = backend.stateful_randc( - random_generator, a=drange, shape=counts, p=pi - ) + raw_counts = backend.probability_sample( + counts, pi, status=status, g=random_generator + ) + # if random_generator is None: + # raw_counts = backend.implicit_randc(drange, shape=counts, p=pi) + # else: + # raw_counts = backend.stateful_randc( + # random_generator, a=drange, shape=counts, p=pi + # ) return sample2all(raw_counts, n, format=format, jittable=jittable) diff --git a/tests/test_backends.py b/tests/test_backends.py index 1297fff0..5dda35d5 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -291,7 +291,7 @@ def test_backend_methods_2(backend): r = tc.backend.probability_sample(10000, p, status=np.random.uniform(size=[10000])) _, r = np.unique(r, return_counts=True) np.testing.assert_allclose( - r - tc.backend.numpy(p) * 10000.0, np.zeros([10]), atol=100, rtol=1 + r - tc.backend.numpy(p) * 10000.0, np.zeros([10]), atol=200, rtol=1 ) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index fdd29bf4..208a3237 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1017,6 +1017,14 @@ def test_batch_sample(backend): batch=8, allow_state=True, random_generator=tc.backend.get_random_state(42) ) ) + print( + c.sample( + batch=8, + allow_state=True, + status=np.random.uniform(size=[8]), + format="sample_bin", + ) + ) def test_expectation_y_bug(): From 953e2cfc405755d9b455e8444da1e75899bc4a33 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 27 Oct 2022 16:27:18 +0800 Subject: [PATCH 037/725] version0.5.0 --- CHANGELOG.md | 2 ++ tensorcircuit/__init__.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 81919718..d197d91d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.5.0 + ### Added - Finished quantum noise modeling and simulation development stage 1. Add more quantum channels and the differentiable transformation between different channel forms. Add readout error support for sample and sample_expectation_ps methods. diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index a0e33d25..b1fc3eb7 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.4.1" +__version__ = "0.5.0" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From a21dc68071014897a5cedaa4e88831ded7c0d3a4 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Thu, 27 Oct 2022 12:06:52 +0800 Subject: [PATCH 038/725] add noise model --- tensorcircuit/channels.py | 22 ++-- tensorcircuit/interfaces/tensortrans.py | 13 +++ tensorcircuit/noisemodel.py | 136 ++++++++++++++++++++++++ tests/test_noisemodel.py | 110 +++++++++++++++++++ 4 files changed, 274 insertions(+), 7 deletions(-) create mode 100644 tensorcircuit/noisemodel.py create mode 100644 tests/test_noisemodel.py diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index e2c0e753..e2d0f0d8 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -24,6 +24,13 @@ Matrix = Any +class KrausList(list): # type: ignore + def __init__(self, iterable, name, is_unitary): # type: ignore + super().__init__(iterable) + self.name = name + self.is_unitary = is_unitary + + def _sqrt(a: Tensor) -> Tensor: r""" Return the square root of Tensor with default global dtype @@ -93,7 +100,7 @@ def depolarizingchannel(px: float, py: float, pz: float) -> Sequence[Gate]: x = Gate(_sqrt(px) * gates.x().tensor) # type: ignore y = Gate(_sqrt(py) * gates.y().tensor) # type: ignore z = Gate(_sqrt(pz) * gates.z().tensor) # type: ignore - return [i, x, y, z] + return KrausList([i, x, y, z], name="depolarizing", is_unitary=True) def generaldepolarizingchannel( @@ -194,7 +201,7 @@ def generaldepolarizingchannel( for pro, paugate in zip(probs, tup): Gkarus.append(Gate(_sqrt(pro) * paugate)) - return Gkarus + return KrausList(Gkarus, name="depolarizing", is_unitary=True) def amplitudedampingchannel(gamma: float, p: float) -> Sequence[Gate]: @@ -247,7 +254,7 @@ def amplitudedampingchannel(gamma: float, p: float) -> Sequence[Gate]: m1 = _sqrt(p) * (_sqrt(gamma) * g01) m2 = _sqrt(1 - p) * (_sqrt(1 - gamma) * g00 + g11) m3 = _sqrt(1 - p) * (_sqrt(gamma) * g10) - return [m0, m1, m2, m3] + return KrausList([m0, m1, m2, m3], name="amplitude_damping", is_unitary=False) def resetchannel() -> Sequence[Gate]: @@ -274,7 +281,7 @@ def resetchannel() -> Sequence[Gate]: """ m0 = Gate(np.array([[1, 0], [0, 0]], dtype=cons.npdtype)) m1 = Gate(np.array([[0, 1], [0, 0]], dtype=cons.npdtype)) - return [m0, m1] + return KrausList([m0, m1], name="reset", is_unitary=False) def phasedampingchannel(gamma: float) -> Sequence[Gate]: @@ -305,7 +312,7 @@ def phasedampingchannel(gamma: float) -> Sequence[Gate]: g11 = Gate(np.array([[0, 0], [0, 1]], dtype=cons.npdtype)) m0 = 1.0 * (g00 + _sqrt(1 - gamma) * g11) # 1* ensure gate m1 = _sqrt(gamma) * g11 - return [m0, m1] + return KrausList([m0, m1], name="phase_damping", is_unitary=False) def thermalrelaxationchannel( @@ -394,7 +401,7 @@ def thermalrelaxationchannel( Gkraus = [] for pro, paugate in zip(probs, tup): Gkraus.append(Gate(_sqrt(pro) * paugate)) - return Gkraus + return KrausList(Gkraus, name="thermal_relaxation", is_unitary=False) elif method == "ByChoi" or ( method == "AUTO" and backend.real(t2) >= backend.real(t1) @@ -439,7 +446,8 @@ def thermalrelaxationchannel( nmax = 3 listKraus = choi_to_kraus(choi, truncation_rules={"max_singular_values": nmax}) - return [Gate(i) for i in listKraus] + Gatelist = [Gate(i) for i in listKraus] + return KrausList(Gatelist, name="thermal_relaxation", is_unitary=False) else: raise ValueError("No valid method is provided") diff --git a/tensorcircuit/interfaces/tensortrans.py b/tensorcircuit/interfaces/tensortrans.py index b94762a8..c91588e8 100644 --- a/tensorcircuit/interfaces/tensortrans.py +++ b/tensorcircuit/interfaces/tensortrans.py @@ -250,6 +250,8 @@ def f(a, b, c, d): :return: The wrapped function :rtype: Callable[..., Any] """ + from ..channels import KrausList + if isinstance(argnums, int): argnumslist = [argnums] else: @@ -260,6 +262,14 @@ def wrapper(*args: Any, **kws: Any) -> Any: nargs = [] for i, arg in enumerate(args): if i in argnumslist: + if isinstance(arg, KrausList): + is_krauslist = True + name = arg.name + is_unitary = arg.is_unitary + arg = list(arg) + else: + is_krauslist = False + if gate_to_tensor: arg = backend.tree_map( partial(gate_to_matrix, is_reshapem=gate_as_matrix), arg @@ -274,6 +284,9 @@ def wrapper(*args: Any, **kws: Any) -> Any: arg = backend.tree_map(partial(backend.cast, dtype=dtypestr), arg) if tensor_as_matrix: arg = backend.tree_map(backend.reshapem, arg) + + if is_krauslist is True: + arg = KrausList(arg, name, is_unitary) nargs.append(arg) return f(*nargs, **kws) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py new file mode 100644 index 00000000..8d5c0a1c --- /dev/null +++ b/tensorcircuit/noisemodel.py @@ -0,0 +1,136 @@ +from tensorcircuit.tensorcircuit.abstractcircuit import AbstractCircuit +from . import Circuit, DMCircuit +from .cons import backend + + +class NoiseConf: + def __init__(self) -> None: # type: ignore + self.nc = {} # type: ignore + self.quantum = False + self.readout = False + self.num_quantum = 0 + + def add_noise(self, gate_name, kraus): # type: ignore + self.nc[gate_name] = kraus + if gate_name == "readout": + self.readout = True + else: + self.quantum = True + self.num_quantum += 1 + + +def apply_qir(c, qir, noise_conf, randx=None): # type: ignore + + quantum_index = 0 + for d in qir: + + if "parameters" not in d: # paramized gate + c.apply_general_gate_delayed(d["gatef"], d["name"])( # type: ignore + c, *d["index"] # type: ignore + ) + else: + c.apply_general_variable_gate_delayed(d["gatef"], d["name"])( # type: ignore + c, *d["index"], **d["parameters"] # type: ignore + ) + + if isinstance(c, DMCircuit): + if d["name"] in noise_conf.nc: + c.general_kraus(noise_conf.nc[d["name"]], *d["index"]) + + else: + if d["name"] in noise_conf.nc: + quantum_index += 1 + if noise_conf.nc[d["name"]].is_unitary is True: + c.unitary_kraus( + noise_conf.nc[d["name"]], + *d["index"], + status=randx[quantum_index - 1] + ) + else: + c.general_kraus( + noise_conf.nc[d["name"]], + *d["index"], + status=randx[quantum_index - 1] + ) + + return c + + +def circuit_with_noise(c, noise_conf, randx=None): # type: ignore + qir = c.to_qir() + cnew: AbstractCircuit + if isinstance(c, DMCircuit): + cnew = DMCircuit(c._nqubits) + else: + cnew = Circuit(c._nqubits) + cnew = apply_qir(cnew, qir, noise_conf, randx) + return cnew + + +def expectation_ps_noisfy(c, x=None, y=None, z=None, noise_conf=NoiseConf(), nmc=1000): # type: ignore + + if noise_conf.readout is True: + raise ValueError("expectation_ps_noisfy can't support readout error.") + + else: + if noise_conf.quantum is True: + + # density matrix + if isinstance(c, DMCircuit): + cnoise = circuit_with_noise(c, noise_conf) + return cnoise.expectation_ps(x=x, y=y, z=z) + + # monte carlo + else: + + def mcsim(randx): # type: ignore + cnoise = circuit_with_noise(c, noise_conf, randx) + return cnoise.expectation_ps(x=x, y=y, z=z) + + mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) + randx = backend.implicit_randu([nmc, noise_conf.num_quantum]) + value = backend.mean(mcsim_vmap(randx)) + + return value + + else: + return c.expectation_ps(x=x, y=y, z=z) + + +def sample_expectation_ps_noisfy( # type: ignore + c, x=None, y=None, z=None, noise_conf=NoiseConf(), nmc=1000, shots=None +): + + if noise_conf.readout is True: + readout_error = noise_conf.nc["readout"] + else: + readout_error = None + + if noise_conf.quantum is True: + + # density matrix + if isinstance(c, DMCircuit): + cnoise = circuit_with_noise(c, noise_conf) + return cnoise.sample_expectation_ps( + x=x, y=y, z=z, shots=shots, readout_error=readout_error + ) + + # monte carlo + else: + + def mcsim(randx): # type: ignore + cnoise = circuit_with_noise(c, noise_conf, randx) + return cnoise.sample_expectation_ps( + x=x, y=y, z=z, shots=shots, readout_error=readout_error + ) + + mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) + randx = backend.implicit_randu([nmc, noise_conf.num_quantum]) + value = backend.mean(mcsim_vmap(randx)) + return value + + else: + value = c.sample_expectation_ps( + x=x, y=y, z=z, shots=shots, readout_error=readout_error + ) + return value diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py new file mode 100644 index 00000000..e39c7905 --- /dev/null +++ b/tests/test_noisemodel.py @@ -0,0 +1,110 @@ +import pytest +from pytest_lazyfixture import lazy_fixture as lf + + +import tensorcircuit as tc +from tensorcircuit.noisemodel import ( + NoiseConf, + circuit_with_noise, + expectation_ps_noisfy, + sample_expectation_ps_noisfy, +) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_noisemodel_expectvalue(backend): + + error1 = tc.channels.generaldepolarizingchannel(0.1, 1) + # error3 = tc.channels.resetchannel() + error3 = tc.channels.thermalrelaxationchannel(300, 400, 100, "ByChoi", 0) + + noise_conf = NoiseConf() + noise_conf.add_noise("rx", error1) + noise_conf.add_noise("h", error3) + + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + + noise_conf1 = NoiseConf() + noise_conf1.add_noise("readout", readout_error) + + c = tc.Circuit(2) + c.rx(0, theta=0.4) + c.h(0) + c.x(1) + cnoise = circuit_with_noise(c, noise_conf, [0.1] * 2) + value = cnoise.expectation_ps(z=[0, 1]) + print("noise_circuit_value", value) + + dmc = tc.DMCircuit(2) + dmc.rx(0, theta=0.4) + dmc.h(0) + dmc.x(1) + cnoise = circuit_with_noise(dmc, noise_conf) + value = cnoise.expectation_ps(z=[0, 1]) + print("noise_circuit_value", value) + + value = expectation_ps_noisfy(c, z=[0, 1], nmc=10000) + print("mc", value) + + value = expectation_ps_noisfy(dmc, z=[0, 1]) + print("dm", value) + + value = expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf, nmc=10000) + print("mc_quantum", value) + + value = expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf) + print("dm_quantum", value) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_noisemodel_sample(backend): + c = tc.Circuit(2) + c.rx(0, theta=0.4) + c.h(0) + c.x(1) + error1 = tc.channels.generaldepolarizingchannel(0.1, 1) + error3 = tc.channels.thermalrelaxationchannel(300, 400, 100, "ByChoi", 0) + # error3 = tc.channels.resetchannel() + + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + + noise_conf = NoiseConf() + noise_conf.add_noise("rx", error1) + noise_conf.add_noise("h", error3) + noise_conf.add_noise("readout", readout_error) + + noise_conf1 = NoiseConf() + noise_conf1.add_noise("readout", readout_error) + + noise_conf2 = NoiseConf() + noise_conf2.add_noise("rx", error1) + noise_conf2.add_noise("h", error3) + + value = sample_expectation_ps_noisfy( + c, z=[0, 1], noise_conf=noise_conf1, nmc=100000 + ) + print("noise_nmc_read", value) + + value = sample_expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf, nmc=10000) + print("noise_nmc_read_quantum", value) + + value = sample_expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf2, nmc=10000) + print("noise_nmc_quantum", value) + + dmc = tc.DMCircuit(2) + dmc.rx(0, theta=0.4) + dmc.h(0) + dmc.x(1) + + value = sample_expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf1) + print("noise_dm_read", value) + + value = sample_expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf) + print("noise_dm_read_quantum", value) + + value = sample_expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf2) + print("noise_nmc_quantum", value) From a586878ddafe6a455fa50ab0c6984f409d250f94 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Thu, 27 Oct 2022 19:40:21 +0800 Subject: [PATCH 039/725] revise noise model --- tensorcircuit/noisemodel.py | 103 ++++++++++++++++++++++-------------- tests/test_noisemodel.py | 44 ++++++++++----- 2 files changed, 95 insertions(+), 52 deletions(-) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 8d5c0a1c..7e3e89b7 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -1,25 +1,29 @@ -from tensorcircuit.tensorcircuit.abstractcircuit import AbstractCircuit +""" +General Noise Model Construction. +""" +import logging +from tensorcircuit.abstractcircuit import AbstractCircuit from . import Circuit, DMCircuit from .cons import backend +logger = logging.getLogger(__name__) + class NoiseConf: def __init__(self) -> None: # type: ignore self.nc = {} # type: ignore - self.quantum = False - self.readout = False - self.num_quantum = 0 + self.has_quantum = False + self.has_readout = False def add_noise(self, gate_name, kraus): # type: ignore self.nc[gate_name] = kraus if gate_name == "readout": - self.readout = True + self.has_readout = True else: - self.quantum = True - self.num_quantum += 1 + self.has_quantum = True -def apply_qir(c, qir, noise_conf, randx=None): # type: ignore +def apply_qir_with_noise(c, qir, noise_conf, status=None): # type: ignore quantum_index = 0 for d in qir: @@ -39,74 +43,92 @@ def apply_qir(c, qir, noise_conf, randx=None): # type: ignore else: if d["name"] in noise_conf.nc: - quantum_index += 1 if noise_conf.nc[d["name"]].is_unitary is True: c.unitary_kraus( noise_conf.nc[d["name"]], *d["index"], - status=randx[quantum_index - 1] + status=status[quantum_index] ) else: c.general_kraus( noise_conf.nc[d["name"]], *d["index"], - status=randx[quantum_index - 1] + status=status[quantum_index] ) + quantum_index += 1 return c -def circuit_with_noise(c, noise_conf, randx=None): # type: ignore +def circuit_with_noise(c, noise_conf, status=None): # type: ignore qir = c.to_qir() cnew: AbstractCircuit if isinstance(c, DMCircuit): cnew = DMCircuit(c._nqubits) else: cnew = Circuit(c._nqubits) - cnew = apply_qir(cnew, qir, noise_conf, randx) + cnew = apply_qir_with_noise(cnew, qir, noise_conf, status) return cnew -def expectation_ps_noisfy(c, x=None, y=None, z=None, noise_conf=NoiseConf(), nmc=1000): # type: ignore +def expectation_ps_noisfy(c, x=None, y=None, z=None, noise_conf=None, nmc=1000, status=None): # type: ignore - if noise_conf.readout is True: - raise ValueError("expectation_ps_noisfy can't support readout error.") + if noise_conf is None: + noise_conf = NoiseConf() + else: + pass + + num_quantum = c.gate_count(list(noise_conf.nc.keys())) + if noise_conf.has_readout is True: + logger.warning("expectation_ps_noisfy can't support readout error.") else: - if noise_conf.quantum is True: + pass - # density matrix - if isinstance(c, DMCircuit): - cnoise = circuit_with_noise(c, noise_conf) - return cnoise.expectation_ps(x=x, y=y, z=z) + if noise_conf.has_quantum is True: - # monte carlo - else: + # density matrix + if isinstance(c, DMCircuit): + cnoise = circuit_with_noise(c, noise_conf) + return cnoise.expectation_ps(x=x, y=y, z=z) - def mcsim(randx): # type: ignore - cnoise = circuit_with_noise(c, noise_conf, randx) - return cnoise.expectation_ps(x=x, y=y, z=z) + # monte carlo + else: - mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) - randx = backend.implicit_randu([nmc, noise_conf.num_quantum]) - value = backend.mean(mcsim_vmap(randx)) + def mcsim(status): # type: ignore + cnoise = circuit_with_noise(c, noise_conf, status) + return cnoise.expectation_ps(x=x, y=y, z=z) - return value + mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) + if status is None: + status = backend.implicit_randu([nmc, num_quantum]) + else: + pass + value = backend.mean(mcsim_vmap(status)) - else: - return c.expectation_ps(x=x, y=y, z=z) + return value + + else: + return c.expectation_ps(x=x, y=y, z=z) def sample_expectation_ps_noisfy( # type: ignore - c, x=None, y=None, z=None, noise_conf=NoiseConf(), nmc=1000, shots=None + c, x=None, y=None, z=None, noise_conf=None, nmc=1000, shots=None, status=None ): - if noise_conf.readout is True: + if noise_conf is None: + noise_conf = NoiseConf() + else: + pass + + num_quantum = c.gate_count(list(noise_conf.nc.keys())) + + if noise_conf.has_readout is True: readout_error = noise_conf.nc["readout"] else: readout_error = None - if noise_conf.quantum is True: + if noise_conf.has_quantum is True: # density matrix if isinstance(c, DMCircuit): @@ -118,15 +140,18 @@ def sample_expectation_ps_noisfy( # type: ignore # monte carlo else: - def mcsim(randx): # type: ignore - cnoise = circuit_with_noise(c, noise_conf, randx) + def mcsim(status): # type: ignore + cnoise = circuit_with_noise(c, noise_conf, status) return cnoise.sample_expectation_ps( x=x, y=y, z=z, shots=shots, readout_error=readout_error ) mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) - randx = backend.implicit_randu([nmc, noise_conf.num_quantum]) - value = backend.mean(mcsim_vmap(randx)) + if status is None: + status = backend.implicit_randu([nmc, num_quantum]) + else: + pass + value = backend.mean(mcsim_vmap(status)) return value else: diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index e39c7905..921f74bb 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -1,6 +1,6 @@ import pytest from pytest_lazyfixture import lazy_fixture as lf - +import numpy as np import tensorcircuit as tc from tensorcircuit.noisemodel import ( @@ -27,6 +27,8 @@ def test_noisemodel_expectvalue(backend): readout_error.append([0.4, 0.7]) # readout error of qubit 1 noise_conf1 = NoiseConf() + noise_conf1.add_noise("rx", error1) + noise_conf1.add_noise("h", error3) noise_conf1.add_noise("readout", readout_error) c = tc.Circuit(2) @@ -35,7 +37,8 @@ def test_noisemodel_expectvalue(backend): c.x(1) cnoise = circuit_with_noise(c, noise_conf, [0.1] * 2) value = cnoise.expectation_ps(z=[0, 1]) - print("noise_circuit_value", value) + # print("noise_circuit_value", value) + np.testing.assert_allclose(value, -0.18, atol=1e-2) dmc = tc.DMCircuit(2) dmc.rx(0, theta=0.4) @@ -43,19 +46,28 @@ def test_noisemodel_expectvalue(backend): dmc.x(1) cnoise = circuit_with_noise(dmc, noise_conf) value = cnoise.expectation_ps(z=[0, 1]) - print("noise_circuit_value", value) + # print("noise_circuit_value", value) + np.testing.assert_allclose(value, -0.28, atol=1e-2) value = expectation_ps_noisfy(c, z=[0, 1], nmc=10000) - print("mc", value) + # print("mc", value) + np.testing.assert_allclose(value, 0, atol=1e-2) value = expectation_ps_noisfy(dmc, z=[0, 1]) - print("dm", value) + # print("dm", value) + np.testing.assert_allclose(value, 0, atol=1e-2) value = expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf, nmc=10000) - print("mc_quantum", value) + # print("mc_quantum", value) + np.testing.assert_allclose(value, -0.28, atol=1e-2) value = expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf) - print("dm_quantum", value) + # print("dm_quantum", value) + np.testing.assert_allclose(value, -0.28, atol=1e-2) + + value = expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf1, nmc=10000) + # print("mc_readout", value) + np.testing.assert_allclose(value, -0.28, atol=1e-2) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) @@ -87,13 +99,16 @@ def test_noisemodel_sample(backend): value = sample_expectation_ps_noisfy( c, z=[0, 1], noise_conf=noise_conf1, nmc=100000 ) - print("noise_nmc_read", value) + # print("noise_nmc_read", value) + np.testing.assert_allclose(value, -0.06, atol=1e-2) value = sample_expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf, nmc=10000) - print("noise_nmc_read_quantum", value) + # print("noise_nmc_read_quantum", value) + np.testing.assert_allclose(value, -0.133, atol=1e-2) value = sample_expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf2, nmc=10000) - print("noise_nmc_quantum", value) + # print("noise_nmc_quantum", value) + np.testing.assert_allclose(value, -0.28, atol=1e-2) dmc = tc.DMCircuit(2) dmc.rx(0, theta=0.4) @@ -101,10 +116,13 @@ def test_noisemodel_sample(backend): dmc.x(1) value = sample_expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf1) - print("noise_dm_read", value) + # print("noise_dm_read", value) + np.testing.assert_allclose(value, -0.06, atol=1e-2) value = sample_expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf) - print("noise_dm_read_quantum", value) + # print("noise_dm_read_quantum", value) + np.testing.assert_allclose(value, -0.133, atol=1e-2) value = sample_expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf2) - print("noise_nmc_quantum", value) + # print("noise_nmc_quantum", value) + np.testing.assert_allclose(value, -0.28, atol=1e-2) From 34ebd44feee7d9f63c9281dcf3c477753e077e18 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 28 Oct 2022 10:59:54 +0800 Subject: [PATCH 040/725] add from_openqasm method --- .gitignore | 1 + CHANGELOG.md | 8 ++++++++ tensorcircuit/abstractcircuit.py | 28 ++++++++++++++++++++++++++-- tensorcircuit/translation.py | 15 ++++++++++----- tests/test_circuit.py | 10 ++++++++++ 5 files changed, 55 insertions(+), 7 deletions(-) diff --git a/.gitignore b/.gitignore index 32fa5a10..291c4f1c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ +data .prettierignore .idea/ dataset diff --git a/CHANGELOG.md b/CHANGELOG.md index d197d91d..8ab138f4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ ## Unreleased +### Added + +- Add native support for `rxx`, `ryy` and `rzz` gates for translation from qiskit + +- Add `from_openqasm` and `from_openqasm_file` methods for `Circuit` + +- Add `circuit_params` argument for translation from qiskit to make the interface universal and consistent with other `from_` methods + ## 0.5.0 ### Added diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 9044f369..3270a8ec 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -520,6 +520,26 @@ def to_openqasm(self, **kws: Any) -> str: """ return self.to_qiskit().qasm(**kws) # type: ignore + @classmethod + def from_openqasm( + cls, qasmstr: str, circuit_params: Optional[Dict[str, Any]] = None + ) -> "AbstractCircuit": + from qiskit.circuit import QuantumCircuit + + qiskit_circ = QuantumCircuit.from_qasm_str(qasmstr) + c = cls.from_qiskit(qiskit_circ, circuit_params=circuit_params) + return c + + @classmethod + def from_openqasm_file( + cls, file: str, circuit_params: Optional[Dict[str, Any]] = None + ) -> "AbstractCircuit": + from qiskit.circuit import QuantumCircuit + + qiskit_circ = QuantumCircuit.from_qasm_file(file) + c = cls.from_qiskit(qiskit_circ, circuit_params=circuit_params) + return c + def draw(self, **kws: Any) -> Any: """ Visualise the circuit. @@ -543,7 +563,11 @@ def draw(self, **kws: Any) -> Any: @classmethod def from_qiskit( - cls, qc: Any, n: Optional[int] = None, inputs: Optional[List[float]] = None + cls, + qc: Any, + n: Optional[int] = None, + inputs: Optional[List[float]] = None, + circuit_params: Optional[Dict[str, Any]] = None, ) -> "AbstractCircuit": """ Import Qiskit QuantumCircuit object as a ``tc.Circuit`` object. @@ -571,7 +595,7 @@ def from_qiskit( if n is None: n = qc.num_qubits - return qiskit2tc(qc.data, n, inputs, is_dm=cls.is_dm) # type: ignore + return qiskit2tc(qc.data, n, inputs, is_dm=cls.is_dm, circuit_params=circuit_params) # type: ignore def vis_tex(self, **kws: Any) -> str: """ diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 060212d2..226a0532 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -194,6 +194,7 @@ def qiskit2tc( n: int, inputs: Optional[List[float]] = None, is_dm: bool = False, + circuit_params: Optional[Dict[str, Any]] = None, ) -> Any: r""" Generate a tensorcircuit circuit using the quantum circuit data in qiskit. @@ -220,10 +221,14 @@ def qiskit2tc( Circ = DMCircuit2 else: Circ = Circuit # type: ignore - if inputs is None: - tc_circuit: Any = Circ(n) - else: - tc_circuit = Circ(n, inputs=inputs) + if circuit_params is None: + circuit_params = {} + if "nqubits" not in circuit_params: + circuit_params["nqubits"] = n + if inputs is not None: + circuit_params["inputs"] = inputs + + tc_circuit: Any = Circ(**circuit_params) for gate_info in qcdata: idx = [qb.index for qb in gate_info[1]] gate_name = gate_info[0].name @@ -250,7 +255,7 @@ def qiskit2tc( getattr(tc_circuit, gate_name[:-1])(*idx) elif gate_name in ["cx_o0", "cy_o0", "cz_o0"]: getattr(tc_circuit, "o" + gate_name[1])(*idx) - elif gate_name in ["rx", "ry", "rz", "crx", "cry", "crz"]: + elif gate_name in ["rx", "ry", "rz", "crx", "cry", "crz", "rxx", "ryy", "rzz"]: getattr(tc_circuit, gate_name)(*idx, theta=parameters) elif gate_name in ["crx_o0", "cry_o0", "crz_o0"]: getattr(tc_circuit, "o" + gate_name[1:-3])(*idx, theta=parameters) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 208a3237..1738f91c 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -976,6 +976,8 @@ def test_qiskit2tc(): qisc.cz(0, 1, ctrl_state=0) qisc.cy(0, 1, ctrl_state=0) qisc.cx(0, 1, ctrl_state=0) + qisc.rxx(0.3, 1, 2) + qisc.rzz(-0.8, 2, 0) qisc.u(0.3, 0.9, -1.2, 2) qisc.rx(np.random.uniform(), 1) qisc.ry(np.random.uniform(), 2) @@ -1219,4 +1221,12 @@ def test_to_openqasm(): c.cnot(2, 1) c.rzz(0, 1, theta=-1.0) c.ccx(1, 2, 0) + c.u(2, theta=0.5, lbd=1.3) print(c.to_openqasm(formatted=True)) + s = c.to_openqasm() + c1 = tc.Circuit.from_openqasm(s) + print(c1.draw()) + np.testing.assert_allclose(c.state(), c1.state()) + c.to_openqasm(filename="test.qasm") + c2 = tc.Circuit.from_openqasm_file("test.qasm") + np.testing.assert_allclose(c.state(), c2.state()) From fff044a8d1405fbff1b45471df1ea48fd2f6c62a Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 28 Oct 2022 17:32:48 +0800 Subject: [PATCH 041/725] add fast time evol impl --- tensorcircuit/experimental.py | 42 +++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 290bc93c..0c4839d0 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -282,6 +282,7 @@ def parameter_shift_grad_v2( :return: the grad function :rtype: Callable[..., Tensor] """ + # TODO(@refraction-ray): replace with new status support for the sample API if jit is True: f = backend.jit(f) @@ -333,3 +334,44 @@ def grad_f(*args: Any, **kws: Any) -> Any: return grad_values[0] return grad_f + + +# TODO(@refraction-ray): add SPSA gradient wrapper similar to parameter shift + + +def hamiltonian_evol( + tlist: Tensor, + h: Tensor, + psi0: Tensor, + callback: Optional[Callable[..., Any]] = None, +) -> Tensor: + """ + Fast implementation of static full Hamiltonian evolution + + :param tlist: _description_ + :type tlist: Tensor + :param h: _description_ + :type h: Tensor + :param psi0: _description_ + :type psi0: Tensor + :param callback: _description_, defaults to None + :type callback: Optional[Callable[..., Any]], optional + :return: Tensor + :rtype: result dynamics on ``tlist`` + """ + es, u = backend.eigh(h) + utpsi0 = backend.reshape( + backend.transpose(u) @ backend.reshape(psi0, [-1, 1]), [-1] + ) + + @backend.jit + def _evol(t: Tensor) -> Tensor: + ebetah_utpsi0 = backend.exp(-t * es) * utpsi0 + psi_exact = backend.conj(u) @ backend.reshape(ebetah_utpsi0, [-1, 1]) + psi_exact = backend.reshape(psi_exact, [-1]) + psi_exact = psi_exact / backend.norm(psi_exact) + if callback is None: + return psi_exact + return callback(psi_exact) + + return backend.stack([_evol(t) for t in tlist]) From 4ae7dd74fcfdfde6334537667b1cc0d1cc172d17 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 28 Oct 2022 19:02:53 +0800 Subject: [PATCH 042/725] add time evol example --- examples/time_evolution.py | 65 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 examples/time_evolution.py diff --git a/examples/time_evolution.py b/examples/time_evolution.py new file mode 100644 index 00000000..91ddde72 --- /dev/null +++ b/examples/time_evolution.py @@ -0,0 +1,65 @@ +""" +A simple static Hamiltonian evolution benchmark +""" + +import time +from functools import partial +import numpy as np +from scipy.integrate import solve_ivp +import tensorcircuit as tc +from tensorcircuit.experimental import hamiltonian_evol + +K = tc.set_backend("jax") + + +@partial(K.jit, static_argnums=1) +def total_z(psi, N): + return K.real( + K.sum(K.stack([tc.expectation([tc.gates.z(), i], ket=psi) for i in range(N)])) + ) + + +@K.jit +def naive_evol(t, h, psi0): + return K.reshape(K.expm(-1j * t * h) @ K.reshape(psi0, [-1, 1]), [-1]) + + +def main(N): + psi0 = np.zeros([2**N]) + psi0[0] = 1 + psi0 = tc.array_to_tensor(psi0) + g = tc.templates.graphs.Line1D(N, pbc=False) + h = tc.quantum.heisenberg_hamiltonian(g, hzz=1, hxx=0, hyy=0, hx=1, sparse=False) + tlist = K.arange(0, 3, 0.1) + time0 = time.time() + for t in tlist: + psit = naive_evol(t, h, psi0) + psit /= K.norm(psit) + print(total_z(psit, N)) + time1 = time.time() + r = hamiltonian_evol(1.0j * tlist, h, psi0, callback=partial(total_z, N=N)) + print(r) + time2 = time.time() + + def fun(t, y): + y = tc.array_to_tensor(y) + return K.numpy(K.reshape(-1.0j * h @ K.reshape(y, [-1, 1]), [-1])) + + r = solve_ivp( + fun, (0, 3), psi0, method="DOP853", t_eval=K.numpy(tlist), rtol=1e-5, atol=1e-6 + ) + for psit in r.y.T: + print(total_z(psit, N)) + time3 = time.time() + print( + "matrix exponential:", + time1 - time0, + "tc fast implementation", + time2 - time1, + "scipy ode", + time3 - time2, + ) + + +if __name__ == "__main__": + main(10) From fa0fc8fce04debb575f1d465370d0ed944f18496 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 28 Oct 2022 20:33:13 +0800 Subject: [PATCH 043/725] further jit ode computation in the example --- examples/time_evolution.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/examples/time_evolution.py b/examples/time_evolution.py index 91ddde72..c1d0e797 100644 --- a/examples/time_evolution.py +++ b/examples/time_evolution.py @@ -10,6 +10,7 @@ from tensorcircuit.experimental import hamiltonian_evol K = tc.set_backend("jax") +tc.set_dtype("complex128") @partial(K.jit, static_argnums=1) @@ -24,6 +25,11 @@ def naive_evol(t, h, psi0): return K.reshape(K.expm(-1j * t * h) @ K.reshape(psi0, [-1, 1]), [-1]) +@K.jit +def hpsi(h, y): + return K.reshape(-1.0j * h @ K.reshape(y, [-1, 1]), [-1]) + + def main(N): psi0 = np.zeros([2**N]) psi0[0] = 1 @@ -43,10 +49,10 @@ def main(N): def fun(t, y): y = tc.array_to_tensor(y) - return K.numpy(K.reshape(-1.0j * h @ K.reshape(y, [-1, 1]), [-1])) + return K.numpy(hpsi(h, y)) r = solve_ivp( - fun, (0, 3), psi0, method="DOP853", t_eval=K.numpy(tlist), rtol=1e-5, atol=1e-6 + fun, (0, 3), psi0, method="DOP853", t_eval=K.numpy(tlist), rtol=1e-6, atol=1e-6 ) for psit in r.y.T: print(total_z(psit, N)) From d3a7611ef4e30479c9a4525d4d7ee40920366fc5 Mon Sep 17 00:00:00 2001 From: JiaceSun Date: Fri, 28 Oct 2022 16:02:17 -0700 Subject: [PATCH 044/725] fix jit issues --- tensorcircuit/mpscircuit.py | 37 +++++++++++++++++++++++-------------- tests/test_mpscircuit.py | 2 +- 2 files changed, 24 insertions(+), 15 deletions(-) diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index 0c6bee10..ea58b370 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -206,15 +206,7 @@ def apply_single_gate(self, gate: Gate, index: int) -> None: :param index: Qubit index of the gate :type index: int """ - # TODO(@SUSYUSTC): make it jittable - tensor = backend.numpy(gate.tensor) - prod = tensor.dot(tensor.T.conj()) - I = np.eye(prod.shape[0]) - err_max = np.max(np.abs(prod - I)) - # TODO(@SUSYUSTC): change this number to 1e-12 after the dtype bug fixed - is_unitary = err_max < 1e-6 - if not is_unitary: - self.position(index) + self.position(index) self._mps.apply_one_site_gate(gate.tensor, index) def apply_adjacent_double_gate( @@ -299,6 +291,11 @@ def apply_double_gate( :param index2: The second qubit index of the gate :type index2: int """ + assert index1 != index2 + if index1 > index2: + newgate = Gate(backend.transpose(gate.tensor, [1, 0, 3, 2])) + self.apply_double_gate(newgate, index2, index1) + return if split is None: split = self.split # apply N SWAP gates, the required gate, N SWAP gates sequentially on adjacent gates @@ -338,16 +335,19 @@ def gate_to_MPO( # --i--I--j-- = \delta_{i,j} \delta_{a,b} # | # b + + # index must be ordered + assert np.all(np.diff(index) > 0) index_left = np.min(index) if isinstance(gate, tn.Node): gate = backend.copy(gate.tensor) index = np.array(index) - index_left nindex = len(index) # transform gate from (in1, in2, ..., out1, out2 ...) to + # (in1, out1, in2, out2, ...) order = tuple(np.arange(2 * nindex).reshape((2, nindex)).T.flatten()) shape = (4,) * nindex gate = backend.reshape(backend.transpose(gate, order), shape) - # (in1, out1, in2, out2, ...) argsort = np.argsort(index) # reorder the gate according to the site positions gate = backend.transpose(gate, tuple(argsort)) @@ -520,6 +520,15 @@ def apply_nqubit_gate( """ Apply a n-qubit gate by transforming the gate to MPO """ + ordered = np.all(np.diff(index)) > 0 + if not ordered: + order = np.argsort(index) + order2 = order + len(index) + order_all = order.tolist() + order2.tolist() + newgate = backend.transpose(gate.tensor, order_all) + index = np.sort(index).tolist() + self.apply_nqubit_gate(newgate, *index, split=split) + return if split is None: split = self.split MPO, index_left = self.gate_to_MPO(gate, *index) @@ -588,10 +597,10 @@ def mid_measurement(self, index: int, keep: int = 0) -> None: """ # normalization not guaranteed assert keep in [0, 1] - discard = 1 - keep - self.position(index) - # TODO(@SUSYUSTC): make it compatible with other backends - self._mps.tensors[index][:, discard, :] = 0 + gate = backend.zeros((2, 2), dtype=dtypestr) + gate = backend.scatter(gate, backend.convert_to_tensor([[keep, keep]]), backend.convert_to_tensor(np.array([1.0], dtype=dtypestr))) + gate = Gate(gate) + self.apply_single_gate(gate, index) def is_valid(self) -> bool: """ diff --git a/tests/test_mpscircuit.py b/tests/test_mpscircuit.py index 52d07d6c..ad218a9a 100644 --- a/tests/test_mpscircuit.py +++ b/tests/test_mpscircuit.py @@ -316,7 +316,7 @@ def test_circuits_1(backend, dtype): print("time", time.time() - begin) do_test_canonical(circuits) do_test_wavefunction(circuits) - do_test_truncation(circuits, 0.9987293417932497, 0.999440840610151) + do_test_truncation(circuits, 0.9987310049079007, 0.9994452420583485) do_test_amplitude(circuits) do_test_expectation(circuits) external = external_wavefunction() From 92ae29a57d87720e3b758fdcbe92c3669051cd9f Mon Sep 17 00:00:00 2001 From: JiaceSun Date: Sat, 29 Oct 2022 18:08:42 -0700 Subject: [PATCH 045/725] change test for jit --- tensorcircuit/mpscircuit.py | 5 +-- tests/test_mpscircuit.py | 83 ++++++++++++++++++++----------------- 2 files changed, 47 insertions(+), 41 deletions(-) diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index ea58b370..0edbc6ca 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -144,7 +144,6 @@ def __init__( # because the gates are immediately absorted into the MPS when applied, # so it is impossible to remember the initial structure - # @property def get_bond_dimensions(self) -> Tensor: """ Get the MPS bond dimensions @@ -154,7 +153,6 @@ def get_bond_dimensions(self) -> Tensor: """ return self._mps.bond_dimensions - # @property def get_tensors(self) -> List[Tensor]: """ Get the MPS tensors @@ -164,7 +162,6 @@ def get_tensors(self) -> List[Tensor]: """ return self._mps.tensors # type: ignore - # @property def get_center_position(self) -> Optional[int]: """ Get the center position of the MPS @@ -520,7 +517,7 @@ def apply_nqubit_gate( """ Apply a n-qubit gate by transforming the gate to MPO """ - ordered = np.all(np.diff(index)) > 0 + ordered = np.all(np.diff(index) > 0) if not ordered: order = np.argsort(index) order2 = order + len(index) diff --git a/tests/test_mpscircuit.py b/tests/test_mpscircuit.py index ad218a9a..4f238c23 100644 --- a/tests/test_mpscircuit.py +++ b/tests/test_mpscircuit.py @@ -33,7 +33,7 @@ def reproducible_unitary(n): return scipy.linalg.expm(A).astype(tc.dtypestr) -def get_test_circuits(full) -> type_test_circuits: +def simulate(c, full, check=True): O1 = tc.gates.any(reproducible_unitary(2).reshape((2, 2))) O2 = tc.gates.any(reproducible_unitary(4).reshape((2, 2, 2, 2))) O3 = tc.gates.any(reproducible_unitary(8).reshape((2, 2, 2, 2, 2, 2))) @@ -41,45 +41,43 @@ def get_test_circuits(full) -> type_test_circuits: # Construct a complicated circuit by Circuit and MPSCircuit and compare if full: - def rangei(j, N): return range(0, N - 1) - else: - def rangei(j, N): return range(j, N - 1 - j) - def simulate(c): - c.H(0) - # create as much correlation as possible - for j in range(N // 2): - for i in rangei(j, N): - c.apply(O2.copy(), i, i + 1) - c.apply(O1.copy(), i) - # test non-adjacent double gates - c.apply(O2.copy(), N // 2 - 1, N // 2 + 1) - c.apply(O3.copy(), int(N * 0.2), int(N * 0.4), int(N * 0.6)) - if isinstance(c, tc.MPSCircuit): - np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) - c.apply(O2.copy(), N // 2 - 2, N // 2 + 2) - c.apply(O3.copy(), int(N * 0.4), int(N * 0.6), int(N * 0.8)) - if isinstance(c, tc.MPSCircuit): - np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) - c.cz(2, 3) + c.H(0) + # create as much correlation as possible + for j in range(N // 2): + for i in rangei(j, N): + c.apply(O2.copy(), i, i + 1) + c.apply(O1.copy(), i) + # test non-adjacent double gates + c.apply(O2.copy(), N // 2 - 1, N // 2 + 1) + c.apply(O3.copy(), int(N * 0.2), int(N * 0.4), int(N * 0.6)) + if check and isinstance(c, tc.MPSCircuit): + np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) + c.apply(O2.copy(), N // 2 - 2, N // 2 + 2) + c.apply(O3.copy(), int(N * 0.4), int(N * 0.6), int(N * 0.8)) + if check and isinstance(c, tc.MPSCircuit): + np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) + c.cz(2, 3) + +def get_test_circuits(full) -> type_test_circuits: c = tc.Circuit(N) - simulate(c) + simulate(c, full) w_c = c.wavefunction() mps = tc.MPSCircuit(N, split=split) - simulate(mps) + simulate(mps, full) do_test_norm(mps) mps.normalize() w_mps = mps.wavefunction() mps_exact = tc.MPSCircuit(N) - simulate(mps_exact) + simulate(mps_exact, full) w_mps_exact = mps_exact.wavefunction() return [c, w_c, mps, w_mps, mps_exact, w_mps_exact] @@ -133,8 +131,6 @@ def do_test_truncation( np.abs(tc.backend.numpy(w_mps).conj().dot(tc.backend.numpy(w_c))) ** 2 ) estimated_fedility = tc.backend.numpy(mps._fidelity) - print(real_fedility) - print(estimated_fedility) np.testing.assert_allclose(real_fedility, real_fedility_ref, atol=1e-8) np.testing.assert_allclose(estimated_fedility, estimated_fedility_ref, atol=1e-8) @@ -172,7 +168,7 @@ def do_test_expectation(test_circuits: type_test_circuits): [2, 6], ) double_gate = (tc.gates.cnot(), [2, 6]) - triple_gate = (tc.gates.toffoli(), [1, 5, 9]) + triple_gate = (tc.gates.toffoli(), [9, 1, 5]) gates = [single_gate, double_gate_nonunitary, triple_gate] exp_mps = mps_exact.expectation(*gates) @@ -181,7 +177,7 @@ def do_test_expectation(test_circuits: type_test_circuits): # ps x = [0, 2] - y = [1, 3, 5] + y = [5, 3, 1] z = [6, 8, 10] exp_mps = mps_exact.expectation_ps(x=x, y=y, z=z) exp_c = c.expectation_ps(x=x, y=y, z=z) @@ -216,7 +212,6 @@ def do_test_fromwavefunction(external_wavefunction, relative_err_ref): s = np.linalg.svd(w_external.reshape((2 ** (N // 2), 2 ** (N // 2))))[1] theoretical_upper_limit = np.sum(s[0:D] ** 2) relative_err = np.log((1 - real_fedility) / (1 - theoretical_upper_limit)) - print(relative_err) np.testing.assert_allclose(relative_err, 0.11, atol=1e-2) @@ -306,14 +301,10 @@ def test_MPO_conversion(highp, tfb): @pytest.mark.parametrize( - "backend, dtype", [(lf("tfb"), lf("highp")), (lf("jaxb"), lf("highp"))] + "backend, dtype", [(lf("tfb"), lf("highp"))] ) def test_circuits_1(backend, dtype): - import time - - begin = time.time() circuits = get_test_circuits(False) - print("time", time.time() - begin) do_test_canonical(circuits) do_test_wavefunction(circuits) do_test_truncation(circuits, 0.9987310049079007, 0.9994452420583485) @@ -324,9 +315,27 @@ def test_circuits_1(backend, dtype): do_test_proj(circuits, external) do_test_tensor_input(circuits) do_test_measure(circuits) - print("time", time.time() - begin) - -def test_circuits_2(highp): +@pytest.mark.parametrize( + "backend, dtype", [(lf("tfb"), lf("highp"))] +) +def test_circuits_2(backend, dtype): circuits = get_test_circuits(True) do_test_truncation(circuits, 0.9401410770899974, 0.9654331011546374) + +@pytest.mark.parametrize( + "backend, dtype", [(lf("tfb"), lf("highp"))] +) +def test_circuits_jit(backend, dtype): + def expec(): + mps = tc.MPSCircuit(N, split=split) + simulate(mps, False, check=False) + x = [0, 2] + y = [5, 3, 1] + z = [6, 8, 10] + exp = mps.expectation_ps(x=x, y=y, z=z) + return exp + expec_jit = tc.backend.jit(expec) + exp = tc.backend.numpy(expec()) + exp_jit = tc.backend.numpy(expec_jit()) + np.testing.assert_allclose(exp, exp_jit, atol=1e-10) From ed955ca954e692de6f03b403d315e9b326d94a2f Mon Sep 17 00:00:00 2001 From: JiaceSun Date: Sat, 29 Oct 2022 18:15:34 -0700 Subject: [PATCH 046/725] format --- tensorcircuit/mpscircuit.py | 6 +++++- tests/test_mpscircuit.py | 18 +++++++++--------- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index 0edbc6ca..a40af21b 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -595,7 +595,11 @@ def mid_measurement(self, index: int, keep: int = 0) -> None: # normalization not guaranteed assert keep in [0, 1] gate = backend.zeros((2, 2), dtype=dtypestr) - gate = backend.scatter(gate, backend.convert_to_tensor([[keep, keep]]), backend.convert_to_tensor(np.array([1.0], dtype=dtypestr))) + gate = backend.scatter( + gate, + backend.convert_to_tensor([[keep, keep]]), + backend.convert_to_tensor(np.array([1.0], dtype=dtypestr)), + ) gate = Gate(gate) self.apply_single_gate(gate, index) diff --git a/tests/test_mpscircuit.py b/tests/test_mpscircuit.py index 4f238c23..7b5d0440 100644 --- a/tests/test_mpscircuit.py +++ b/tests/test_mpscircuit.py @@ -41,9 +41,12 @@ def simulate(c, full, check=True): # Construct a complicated circuit by Circuit and MPSCircuit and compare if full: + def rangei(j, N): return range(0, N - 1) + else: + def rangei(j, N): return range(j, N - 1 - j) @@ -300,9 +303,7 @@ def test_MPO_conversion(highp, tfb): np.testing.assert_allclose(tensor4, tensor4_ref, atol=1e-12) -@pytest.mark.parametrize( - "backend, dtype", [(lf("tfb"), lf("highp"))] -) +@pytest.mark.parametrize("backend, dtype", [(lf("tfb"), lf("highp"))]) def test_circuits_1(backend, dtype): circuits = get_test_circuits(False) do_test_canonical(circuits) @@ -316,16 +317,14 @@ def test_circuits_1(backend, dtype): do_test_tensor_input(circuits) do_test_measure(circuits) -@pytest.mark.parametrize( - "backend, dtype", [(lf("tfb"), lf("highp"))] -) + +@pytest.mark.parametrize("backend, dtype", [(lf("tfb"), lf("highp"))]) def test_circuits_2(backend, dtype): circuits = get_test_circuits(True) do_test_truncation(circuits, 0.9401410770899974, 0.9654331011546374) -@pytest.mark.parametrize( - "backend, dtype", [(lf("tfb"), lf("highp"))] -) + +@pytest.mark.parametrize("backend, dtype", [(lf("tfb"), lf("highp"))]) def test_circuits_jit(backend, dtype): def expec(): mps = tc.MPSCircuit(N, split=split) @@ -335,6 +334,7 @@ def expec(): z = [6, 8, 10] exp = mps.expectation_ps(x=x, y=y, z=z) return exp + expec_jit = tc.backend.jit(expec) exp = tc.backend.numpy(expec()) exp_jit = tc.backend.numpy(expec_jit()) From 8975974135840a264473e2e6112215a40cc11371 Mon Sep 17 00:00:00 2001 From: JiaceSun Date: Sat, 29 Oct 2022 19:20:20 -0700 Subject: [PATCH 047/725] mypy --- tensorcircuit/mpscircuit.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index a40af21b..d10d242a 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -520,8 +520,8 @@ def apply_nqubit_gate( ordered = np.all(np.diff(index) > 0) if not ordered: order = np.argsort(index) - order2 = order + len(index) - order_all = order.tolist() + order2.tolist() + order2 = order + len(index) # type: ignore + order_all = order.tolist() + order2.tolist() # type: ignore newgate = backend.transpose(gate.tensor, order_all) index = np.sort(index).tolist() self.apply_nqubit_gate(newgate, *index, split=split) From 2b793486410dbbe2f745d8d56851542682444b26 Mon Sep 17 00:00:00 2001 From: JiaceSun Date: Sun, 30 Oct 2022 00:58:57 -0700 Subject: [PATCH 048/725] add jit+ad in test --- tensorcircuit/__init__.py | 1 + tensorcircuit/mpscircuit.py | 3 + tests/test_mpscircuit.py | 143 ++++++++++++++++++------------------ 3 files changed, 76 insertions(+), 71 deletions(-) diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index b1fc3eb7..e89590f7 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -3,6 +3,7 @@ __creator__ = "refraction-ray" from .cons import ( + backend, set_backend, set_dtype, set_contractor, diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index d10d242a..81a3414c 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -514,6 +514,7 @@ def apply_nqubit_gate( *index: int, split: Optional[Dict[str, Any]] = None, ) -> None: + # TODO(@SUSYUSTC): jax autograd is wrong on this function """ Apply a n-qubit gate by transforming the gate to MPO """ @@ -921,6 +922,7 @@ def measure( :return: The sample output and probability (optional) of the quantum line. :rtype: Tuple[Tensor, Tensor] """ + """ is_sorted = np.all(np.sort(index) == np.array(index)) if not is_sorted: order = backend.convert_to_tensor(np.argsort(index).tolist()) @@ -929,6 +931,7 @@ def measure( ) return backend.convert_to_tensor([sample[i] for i in order]), p # set the center to the left side, then gradually move to the right and do measurement at sites + """ mps = self.copy() up = backend.convert_to_tensor(np.array([1, 0]).astype(dtypestr)) down = backend.convert_to_tensor(np.array([0, 1]).astype(dtypestr)) diff --git a/tests/test_mpscircuit.py b/tests/test_mpscircuit.py index 7b5d0440..60922f1c 100644 --- a/tests/test_mpscircuit.py +++ b/tests/test_mpscircuit.py @@ -18,69 +18,58 @@ import tensorcircuit as tc -N = 16 -D = 100 +N = 8 +D = 6 split = tc.cons.split_rules(max_singular_values=D) type_test_circuits = Tuple[ tc.Circuit, Tensor, tc.MPSCircuit, Tensor, tc.MPSCircuit, Tensor ] -def reproducible_unitary(n): - A = np.arange(n**2).reshape((n, n)) - A = A + np.sin(A) * 1j - A = A - A.conj().T - return scipy.linalg.expm(A).astype(tc.dtypestr) +def reproducible_unitary(n, param): + exp2n = 2**n + A = tc.backend.cast( + tc.backend.reshape(tc.backend.arange(exp2n**2), (exp2n, exp2n)), tc.dtypestr + ) + A = A + tc.backend.sin(A) * param * 1j + A = A - tc.backend.conj(tc.backend.transpose(A)) + return tc.backend.reshape(tc.backend.expm(A), (2,) * n * 2) -def simulate(c, full, check=True): - O1 = tc.gates.any(reproducible_unitary(2).reshape((2, 2))) - O2 = tc.gates.any(reproducible_unitary(4).reshape((2, 2, 2, 2))) - O3 = tc.gates.any(reproducible_unitary(8).reshape((2, 2, 2, 2, 2, 2))) +def simulate(c, check=True, params=None): + if params is None: + params = tc.backend.ones((3,), dtype=tc.dtypestr) + O1 = tc.gates.any(reproducible_unitary(1, params[0])) + O2 = tc.gates.any(reproducible_unitary(2, params[1])) + O3 = tc.gates.any(reproducible_unitary(3, params[2])) # Construct a complicated circuit by Circuit and MPSCircuit and compare - if full: - - def rangei(j, N): - return range(0, N - 1) - - else: - - def rangei(j, N): - return range(j, N - 1 - j) - c.H(0) # create as much correlation as possible - for j in range(N // 2): - for i in rangei(j, N): - c.apply(O2.copy(), i, i + 1) - c.apply(O1.copy(), i) - # test non-adjacent double gates - c.apply(O2.copy(), N // 2 - 1, N // 2 + 1) - c.apply(O3.copy(), int(N * 0.2), int(N * 0.4), int(N * 0.6)) - if check and isinstance(c, tc.MPSCircuit): - np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) - c.apply(O2.copy(), N // 2 - 2, N // 2 + 2) - c.apply(O3.copy(), int(N * 0.4), int(N * 0.6), int(N * 0.8)) + for i in range(0, N - 1, 2): + c.apply(O2.copy(), i, i + 1) + c.apply(O1.copy(), i) + c.apply(O3.copy(), int(N * 0.1), int(N * 0.5), int(N * 0.9)) + c.apply(O2.copy(), 1, N - 2) if check and isinstance(c, tc.MPSCircuit): np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) c.cz(2, 3) -def get_test_circuits(full) -> type_test_circuits: +def get_test_circuits() -> type_test_circuits: c = tc.Circuit(N) - simulate(c, full) + simulate(c) w_c = c.wavefunction() mps = tc.MPSCircuit(N, split=split) - simulate(mps, full) + simulate(mps) do_test_norm(mps) mps.normalize() w_mps = mps.wavefunction() mps_exact = tc.MPSCircuit(N) - simulate(mps_exact, full) + simulate(mps_exact) w_mps_exact = mps_exact.wavefunction() return [c, w_c, mps, w_mps, mps_exact, w_mps_exact] @@ -134,8 +123,13 @@ def do_test_truncation( np.abs(tc.backend.numpy(w_mps).conj().dot(tc.backend.numpy(w_c))) ** 2 ) estimated_fedility = tc.backend.numpy(mps._fidelity) - np.testing.assert_allclose(real_fedility, real_fedility_ref, atol=1e-8) - np.testing.assert_allclose(estimated_fedility, estimated_fedility_ref, atol=1e-8) + print(real_fedility, estimated_fedility) + if real_fedility_ref is not None: + np.testing.assert_allclose(real_fedility, real_fedility_ref, atol=1e-5) + if estimated_fedility_ref is not None: + np.testing.assert_allclose( + estimated_fedility, estimated_fedility_ref, atol=1e-5 + ) def do_test_amplitude(test_circuits: type_test_circuits): @@ -164,14 +158,14 @@ def do_test_expectation(test_circuits: type_test_circuits): w_mps_exact, ) = test_circuits - single_gate = (tc.gates.z(), [11]) + single_gate = (tc.gates.z(), [3]) tensor = (np.sin(np.arange(16)) + np.cos(np.arange(16)) * 1j).reshape((2, 2, 2, 2)) double_gate_nonunitary = ( tc.gates.Gate(tc.backend.convert_to_tensor(tensor)), [2, 6], ) double_gate = (tc.gates.cnot(), [2, 6]) - triple_gate = (tc.gates.toffoli(), [9, 1, 5]) + triple_gate = (tc.gates.toffoli(), [7, 1, 5]) gates = [single_gate, double_gate_nonunitary, triple_gate] exp_mps = mps_exact.expectation(*gates) @@ -181,7 +175,7 @@ def do_test_expectation(test_circuits: type_test_circuits): # ps x = [0, 2] y = [5, 3, 1] - z = [6, 8, 10] + z = [6, 4] exp_mps = mps_exact.expectation_ps(x=x, y=y, z=z) exp_c = c.expectation_ps(x=x, y=y, z=z) np.testing.assert_allclose(exp_mps, exp_c, atol=1e-7) @@ -215,7 +209,8 @@ def do_test_fromwavefunction(external_wavefunction, relative_err_ref): s = np.linalg.svd(w_external.reshape((2 ** (N // 2), 2 ** (N // 2))))[1] theoretical_upper_limit = np.sum(s[0:D] ** 2) relative_err = np.log((1 - real_fedility) / (1 - theoretical_upper_limit)) - np.testing.assert_allclose(relative_err, 0.11, atol=1e-2) + if relative_err_ref is not None: + np.testing.assert_allclose(relative_err, relative_err_ref, atol=1e-4) def do_test_proj(test_circuits: type_test_circuits, external_wavefunction): @@ -271,22 +266,17 @@ def do_test_measure(test_circuits: type_test_circuits): mps_exact, w_mps_exact, ) = test_circuits - index = [6, 5, 2, 9] - status = tc.backend.convert_to_tensor([0.1, 0.3, 0.5, 0.7]) + index = [6, 5, 2, 1] + status = tc.backend.convert_to_tensor([0.1, 0.3, 0.7, 0.9]) result_c = c.measure(*index, with_prob=True, status=status) - result_mps = mps.measure(*index, with_prob=True, status=status) result_mps_exact = mps_exact.measure(*index, with_prob=True, status=status) - np.testing.assert_allclose(result_mps[0], result_c[0], atol=1e-8) np.testing.assert_allclose(result_mps_exact[0], result_c[0], atol=1e-8) - np.testing.assert_allclose(result_mps[1], result_c[1], atol=1e-4) np.testing.assert_allclose(result_mps_exact[1], result_c[1], atol=1e-8) def test_MPO_conversion(highp, tfb): - O3 = tc.backend.convert_to_tensor( - reproducible_unitary(8).reshape((2, 2, 2, 2, 2, 2)) - ) - I = tc.backend.convert_to_tensor(np.eye(2).astype("complex128")) + O3 = reproducible_unitary(3, 1.0) + I = tc.backend.eye(2, dtype=tc.dtypestr) gate = tc.gates.Gate(O3) MPO3, _ = tc.MPSCircuit.gate_to_MPO(gate, 2, 3, 4) @@ -303,39 +293,50 @@ def test_MPO_conversion(highp, tfb): np.testing.assert_allclose(tensor4, tensor4_ref, atol=1e-12) -@pytest.mark.parametrize("backend, dtype", [(lf("tfb"), lf("highp"))]) -def test_circuits_1(backend, dtype): - circuits = get_test_circuits(False) +@pytest.mark.parametrize( + "backend, dtype", [(lf("tfb"), lf("highp")), (lf("jaxb"), lf("highp"))] +) +def test_circuits(backend, dtype): + circuits = get_test_circuits() do_test_canonical(circuits) do_test_wavefunction(circuits) - do_test_truncation(circuits, 0.9987310049079007, 0.9994452420583485) + do_test_truncation(circuits, 0.902663090851, 0.910305380327) do_test_amplitude(circuits) do_test_expectation(circuits) external = external_wavefunction() - do_test_fromwavefunction(external, 0.1185) + do_test_fromwavefunction(external, 0.276089) do_test_proj(circuits, external) do_test_tensor_input(circuits) do_test_measure(circuits) -@pytest.mark.parametrize("backend, dtype", [(lf("tfb"), lf("highp"))]) -def test_circuits_2(backend, dtype): - circuits = get_test_circuits(True) - do_test_truncation(circuits, 0.9401410770899974, 0.9654331011546374) - - @pytest.mark.parametrize("backend, dtype", [(lf("tfb"), lf("highp"))]) def test_circuits_jit(backend, dtype): - def expec(): + def expec(params): mps = tc.MPSCircuit(N, split=split) - simulate(mps, False, check=False) + simulate(mps, check=False, params=params) x = [0, 2] y = [5, 3, 1] - z = [6, 8, 10] + z = [6, 4] exp = mps.expectation_ps(x=x, y=y, z=z) - return exp - - expec_jit = tc.backend.jit(expec) - exp = tc.backend.numpy(expec()) - exp_jit = tc.backend.numpy(expec_jit()) - np.testing.assert_allclose(exp, exp_jit, atol=1e-10) + return tc.backend.real(exp) + + params = tc.backend.ones((3,), dtype=tc.dtypestr) + expec_vg = tc.backend.value_and_grad(expec) + expec_vg_jit = tc.backend.jit(expec_vg) + exp = expec(params) + exp_jit, exp_grad_jit = expec_vg_jit(params) + dir = tc.backend.convert_to_tensor(np.array([1.0, 2.0, 3.0], dtype=tc.dtypestr)) + epsilon = 1e-6 + exp_p = expec(params + dir * epsilon) + exp_m = expec(params - dir * epsilon) + exp_grad_dir_numerical = (exp_p - exp_m) / (epsilon * 2) + exp_grad_dir_jit = tc.backend.real(tc.backend.sum(exp_grad_jit * dir)) + np.testing.assert_allclose( + tc.backend.numpy(exp), tc.backend.numpy(exp_jit), atol=1e-10 + ) + np.testing.assert_allclose( + tc.backend.numpy(exp_grad_dir_numerical), + tc.backend.numpy(exp_grad_dir_jit), + atol=1e-6, + ) From 7621582ffdc7b612ee5f29b565ecd09c7fa75fad Mon Sep 17 00:00:00 2001 From: JiaceSun Date: Sun, 30 Oct 2022 19:46:40 -0700 Subject: [PATCH 049/725] update --- tests/test_mpscircuit.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/test_mpscircuit.py b/tests/test_mpscircuit.py index 60922f1c..7050e7af 100644 --- a/tests/test_mpscircuit.py +++ b/tests/test_mpscircuit.py @@ -5,7 +5,6 @@ import sys import os import numpy as np -import scipy import pytest from pytest_lazyfixture import lazy_fixture as lf From 9fdac1789e59bc23ef507cd21085f8b74372bce5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 31 Oct 2022 11:28:46 +0800 Subject: [PATCH 050/725] move the auth to home dir --- tensorcircuit/cloud/apis.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 240c381c..ddf530cb 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -85,8 +85,8 @@ def set_token( cached: bool = True, ) -> Dict[str, Any]: global saved_token - tcdir = os.path.dirname(os.path.abspath(__file__)) - authpath = os.path.join(tcdir, "auth.json") + homedir = os.path.expanduser("~") + authpath = os.path.join(homedir, ".tc.auth.json") if provider is None: provider = default_provider provider = Provider.from_name(provider) From 75487629f38d7ff707d9b31cd08621d15cf01e6b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 31 Oct 2022 20:33:00 +0800 Subject: [PATCH 051/725] add qaoa shots example --- CHANGELOG.md | 4 + examples/qaoa_shot_noise.py | 223 ++++++++++++++++++++++++++++++++++ tensorcircuit/basecircuit.py | 6 +- tensorcircuit/experimental.py | 7 +- 4 files changed, 235 insertions(+), 5 deletions(-) create mode 100644 examples/qaoa_shot_noise.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 8ab138f4..73e387fb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,10 @@ - Add `circuit_params` argument for translation from qiskit to make the interface universal and consistent with other `from_` methods +### Changed + +- Improve the efficiency of `sample_expectation_ps` method by using cached state. + ## 0.5.0 ### Added diff --git a/examples/qaoa_shot_noise.py b/examples/qaoa_shot_noise.py new file mode 100644 index 00000000..b4d26ba0 --- /dev/null +++ b/examples/qaoa_shot_noise.py @@ -0,0 +1,223 @@ +""" +QAOA with finite measurement shot noise +""" +from functools import partial +import numpy as np +from scipy import optimize +import networkx as nx +import optax +import cotengra as ctg +import tensorcircuit as tc +from tensorcircuit import experimental as E +from tensorcircuit.applications.graphdata import maxcut_solution_bruteforce + +K = tc.set_backend("jax") +# note this script only supports jax backend + +opt_ctg = ctg.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel="ray", + minimize="combo", + max_time=10, + max_repeats=128, + progbar=True, +) + +tc.set_contractor("custom", optimizer=opt_ctg, preprocessing=True) + + +def get_graph(n, d, weights=None): + g = nx.random_regular_graph(d, n) + if weights is not None: + i = 0 + for e in g.edges: + g[e[0]][e[1]]["weight"] = weights[i] + i += 1 + return g + + +def get_exact_maxcut_loss(g): + cut, _ = maxcut_solution_bruteforce(g) + totalw = 0 + for e in g.edges: + totalw += g[e[0]][e[1]].get("weight", 1) + loss = totalw - 2 * cut + return loss + + +def get_pauli_string(g): + n = len(g.nodes) + pss = [] + ws = [] + for e in g.edges: + l = [0 for _ in range(n)] + l[e[0]] = 3 + l[e[1]] = 3 + pss.append(l) + ws.append(g[e[0]][e[1]].get("weight", 1)) + return pss, ws + + +def generate_circuit(param, g, n, nlayers): + # construct the circuit ansatz + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayers): + c = tc.templates.blocks.QAOA_block(c, g, param[j, 0], param[j, 1]) + return c + + +def ps2xyz(psi): + # ps2xyz([1, 2, 2, 0]) = {"x": [0], "y": [1, 2], "z": []} + xyz = {"x": [], "y": [], "z": []} + for i, j in enumerate(psi): + if j == 1: + xyz["x"].append(i) + if j == 2: + xyz["y"].append(i) + if j == 3: + xyz["z"].append(i) + return xyz + + +rkey = K.get_random_state(42) + + +def main_benchmark_suite(n, nlayers, d=3, init=None): + g = get_graph(n, d, weights=np.random.uniform(size=[int(d * n / 2)])) + loss_exact = get_exact_maxcut_loss(g) + print("exact minimal loss by max cut bruteforce: ", loss_exact) + pss, ws = get_pauli_string(g) + if init is None: + init = np.random.normal(scale=0.1, size=[nlayers, 2]) + + @partial(K.jit, static_argnums=(2)) + def exp_val(param, key, shots=10000): + # expectation with shot noise + # ps, w: H = \sum_i w_i ps_i + # describing the system Hamiltonian as a weighted sum of Pauli string + c = generate_circuit(param, g, n, nlayers) + loss = 0 + s = c.state() + mc = tc.quantum.measurement_counts( + s, + counts=shots, + format="sample_bin", + random_generator=key, + jittable=True, + is_prob=False, + ) + for psi, wi in zip(pss, ws): + xyz = ps2xyz(psi) + loss += wi * tc.quantum.correlation_from_samples(xyz["z"], mc, c._nqubits) + return K.real(loss) + + @K.jit + def exp_val_analytical(param): + c = generate_circuit(param, g, n, nlayers) + loss = 0 + for psi, wi in zip(pss, ws): + xyz = ps2xyz(psi) + loss += wi * c.expectation_ps(**xyz) + return K.real(loss) + + # for i in range(3): + # print(exp_val(init, K.get_random_state(i))) + # print(exp_val_analytical(init)) + + # 0. Exact result double check + + hm = tc.quantum.PauliStringSum2COO(pss, ws, numpy=True) + hm = K.to_dense(hm) + e, _ = np.linalg.eigh(hm) + print("exact minimal loss via eigenstate: ", e[0]) + + # 1.1 QAOA with numerically exact expectation: gradient free + + print("QAOA without shot noise") + + exp_val_analytical_sp = tc.interfaces.scipy_interface( + exp_val_analytical, shape=[nlayers, 2], gradient=False + ) + + r = optimize.minimize( + exp_val_analytical_sp, + init, + method="Nelder-Mead", + options={"maxiter": 5000}, + ) + print(r) + print("double check the value?: ", exp_val_analytical_sp(r["x"])) + # cobyla seems to have issue to given consistent x and cobyla + + # 1.2 QAOA with numerically exact expectation: gradient based + + exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 + ) + opt = K.optimizer(optax.adam(exponential_decay_scheduler)) + param = init # zeros stall the gradient + param = tc.array_to_tensor(init, dtype=tc.rdtypestr) + exp_val_grad_analytical = K.jit(K.value_and_grad(exp_val_analytical)) + for i in range(1000): + e, gs = exp_val_grad_analytical(param) + param = opt.update(gs, param) + if i % 100 == 99: + print(e) + print("QAOA energy after gradient descent:", e) + + # 2.1 QAOA with finite shot noise: gradient free + + print("QAOA with shot noise") + + def exp_val_wrapper(param): + global rkey + rkey, skey = K.random_split(rkey) + # maintain stateless randomness in scipy optimize interface + return exp_val(param, skey) + + exp_val_sp = tc.interfaces.scipy_interface( + exp_val_wrapper, shape=[nlayers, 2], gradient=False + ) + + r = optimize.minimize( + exp_val_sp, + init, + method="Nelder-Mead", + options={"maxiter": 5000}, + ) + print(r) + + # the real energy position after optimization + + print("converged as: ", exp_val_analytical_sp(r["x"])) + + # 2.2 QAOA with finite shot noise: gradient based + + exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 + ) + opt = K.optimizer(optax.adam(exponential_decay_scheduler)) + param = tc.array_to_tensor(init, dtype=tc.rdtypestr) + exp_grad = E.parameter_shift_grad_v2( + exp_val, argnums=0, random_argnums=1, shifts=(0.001, 0.002) + ) + # parameter shift doesn't directly apply in QAOA case + rkey = K.get_random_state(42) + + for i in range(1000): + rkey, skey = K.random_split(rkey) + gs = exp_grad(param, skey) + param = opt.update(gs, param) + if i % 100 == 99: + rkey, skey = K.random_split(rkey) + print(exp_val(param, skey)) + + # the real energy position after optimization + + print("converged as:", exp_val_analytical(param)) + + +if __name__ == "__main__": + main_benchmark_suite(8, 4) diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 148cc2ad..c22c89ec 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -648,10 +648,12 @@ def sample_expectation_ps( :return: [description] :rtype: Tensor """ + inputs_nodes, _ = self._copy_state_tensor() + inputs = inputs_nodes[0].tensor if self.is_dm is False: - c = type(self)(self._nqubits, mps_inputs=self.quvector()) # type: ignore + c = type(self)(self._nqubits, inputs=inputs) # type: ignore else: - c = type(self)(self._nqubits, mpo_dminputs=self.get_dm_as_quoperator()) # type: ignore + c = type(self)(self._nqubits, dminputs=inputs) # type: ignore if x is None: x = [] if y is None: diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 0c4839d0..bd32a53f 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -3,7 +3,7 @@ """ from functools import partial -from typing import Any, Callable, Optional, Sequence, Union +from typing import Any, Callable, Optional, Tuple, Sequence, Union import numpy as np @@ -264,6 +264,7 @@ def parameter_shift_grad_v2( argnums: Union[int, Sequence[int]] = 0, jit: bool = False, random_argnums: Optional[Sequence[int]] = None, + shifts: Tuple[float, float] = (np.pi / 2, 2), ) -> Callable[..., Tensor]: """ similar to `grad` function but using parameter shift internally instead of AD, @@ -306,7 +307,7 @@ def grad_f(*args: Any, **kws: Any) -> Any: onehot = backend.eye(size) onehot = backend.cast(onehot, args[i].dtype) onehot = backend.reshape(onehot, [size] + list(shape)) - onehot = np.pi / 2 * onehot + onehot = shifts[0] * onehot nargs = list(args) arg = backend.reshape(args[i], [1] + list(shape)) batched_arg = backend.tile(arg, [size] + [1 for _ in shape]) @@ -326,7 +327,7 @@ def grad_f(*args: Any, **kws: Any) -> Any: key, subkey = backend.random_split(key) keys.append(subkey) nargs2[j] = backend.stack(keys) - r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / 2.0 + r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / shifts[1] r = backend.reshape(r, shape) grad_values.append(r) if len(argnums) > 1: # type: ignore From 5d065dc2defb3ca1d1cccd2e334ec7555974148c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 1 Nov 2022 09:59:43 +0800 Subject: [PATCH 052/725] better parameter shift --- .github/workflows/ci.yml | 1 + CHANGELOG.md | 2 ++ examples/qaoa_shot_noise.py | 30 +++++++++++------------------- tensorcircuit/experimental.py | 11 +++++++++-- 4 files changed, 23 insertions(+), 21 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f3ac5cd7..fbcfe4fd 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -48,6 +48,7 @@ jobs: python mcnoise_boost.py python quantumng.py python universal_lr.py + python parameter_shift.py - name: setup build run: | python3 setup.py build diff --git a/CHANGELOG.md b/CHANGELOG.md index 73e387fb..500188a8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,8 @@ - Add `circuit_params` argument for translation from qiskit to make the interface universal and consistent with other `from_` methods +- Add `shifts` tuple parameter for `experimental.parameter_shift_grad` API so that we can also customize finite difference gradient from this method + ### Changed - Improve the efficiency of `sample_expectation_ps` method by using cached state. diff --git a/examples/qaoa_shot_noise.py b/examples/qaoa_shot_noise.py index b4d26ba0..7b6e656e 100644 --- a/examples/qaoa_shot_noise.py +++ b/examples/qaoa_shot_noise.py @@ -68,17 +68,13 @@ def generate_circuit(param, g, n, nlayers): return c -def ps2xyz(psi): +def ps2z(psi): # ps2xyz([1, 2, 2, 0]) = {"x": [0], "y": [1, 2], "z": []} - xyz = {"x": [], "y": [], "z": []} + zs = [] # no x or y for QUBO problem for i, j in enumerate(psi): - if j == 1: - xyz["x"].append(i) - if j == 2: - xyz["y"].append(i) if j == 3: - xyz["z"].append(i) - return xyz + zs.append(i) + return zs rkey = K.get_random_state(42) @@ -108,27 +104,23 @@ def exp_val(param, key, shots=10000): jittable=True, is_prob=False, ) - for psi, wi in zip(pss, ws): - xyz = ps2xyz(psi) - loss += wi * tc.quantum.correlation_from_samples(xyz["z"], mc, c._nqubits) + for ps, w in zip(pss, ws): + loss += w * tc.quantum.correlation_from_samples(ps2z(ps), mc, c._nqubits) return K.real(loss) @K.jit def exp_val_analytical(param): c = generate_circuit(param, g, n, nlayers) loss = 0 - for psi, wi in zip(pss, ws): - xyz = ps2xyz(psi) - loss += wi * c.expectation_ps(**xyz) + for ps, w in zip(pss, ws): + loss += w * c.expectation_ps(z=ps2z(ps)) return K.real(loss) - # for i in range(3): - # print(exp_val(init, K.get_random_state(i))) - # print(exp_val_analytical(init)) - # 0. Exact result double check - hm = tc.quantum.PauliStringSum2COO(pss, ws, numpy=True) + hm = tc.quantum.PauliStringSum2COO( + K.convert_to_tensor(pss), K.convert_to_tensor(ws), numpy=True + ) hm = K.to_dense(hm) e, _ = np.linalg.eigh(hm) print("exact minimal loss via eigenstate: ", e[0]) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index bd32a53f..7cf0d474 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -210,6 +210,7 @@ def parameter_shift_grad( f: Callable[..., Tensor], argnums: Union[int, Sequence[int]] = 0, jit: bool = False, + shifts: Tuple[float, float] = (np.pi / 2, 2), ) -> Callable[..., Tensor]: """ similar to `grad` function but using parameter shift internally instead of AD, @@ -223,6 +224,9 @@ def parameter_shift_grad( :param jit: whether jit the original function `f` at the beginning, defaults to False :type jit: bool, optional + :param shifts: two floats for the delta shift on the numerator and dominator, + defaults to (pi/2, 2) for parameter shift + :type shifts: Tuple[float, float] :return: the grad function :rtype: Callable[..., Tensor] """ @@ -242,14 +246,14 @@ def grad_f(*args: Any, **kws: Any) -> Any: onehot = backend.eye(size) onehot = backend.cast(onehot, args[i].dtype) onehot = backend.reshape(onehot, [size] + list(shape)) - onehot = np.pi / 2 * onehot + onehot = shifts[0] * onehot nargs = list(args) arg = backend.reshape(args[i], [1] + list(shape)) batched_arg = backend.tile(arg, [size] + [1 for _ in shape]) nargs[i] = batched_arg + onehot nargs2 = list(args) nargs2[i] = batched_arg - onehot - r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / 2.0 + r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / shifts[1] r = backend.reshape(r, shape) grad_values.append(r) if len(argnums) > 1: # type: ignore @@ -280,6 +284,9 @@ def parameter_shift_grad_v2( :param jit: whether jit the original function `f` at the beginning, defaults to False :type jit: bool, optional + :param shifts: two floats for the delta shift on the numerator and dominator, + defaults to (pi/2, 2) for parameter shift + :type shifts: Tuple[float, float] :return: the grad function :rtype: Callable[..., Tensor] """ From b753d3fb8e30acac920d8630566325e725897eab Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 1 Nov 2022 10:50:36 +0800 Subject: [PATCH 053/725] add sys path for example --- examples/parameter_shift.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/examples/parameter_shift.py b/examples/parameter_shift.py index b5fa966f..9ccaceb5 100644 --- a/examples/parameter_shift.py +++ b/examples/parameter_shift.py @@ -2,7 +2,11 @@ Demonstration on the correctness and efficiency of parameter shift gradient implementation """ +import sys import numpy as np + +sys.path.insert(0, "../") + import tensorcircuit as tc from tensorcircuit import experimental as E From d788b8a287b3b32ca46fa4ca7df9f80af826473e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 1 Nov 2022 11:27:51 +0800 Subject: [PATCH 054/725] update mpsvsexact example --- .github/workflows/ci.yml | 1 + examples/mpsvsexact.py | 19 +++---------------- 2 files changed, 4 insertions(+), 16 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fbcfe4fd..03dd81bc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -49,6 +49,7 @@ jobs: python quantumng.py python universal_lr.py python parameter_shift.py + python mpsvsexact.py - name: setup build run: | python3 setup.py build diff --git a/examples/mpsvsexact.py b/examples/mpsvsexact.py index 4a4f5cf1..6e0bfa4a 100644 --- a/examples/mpsvsexact.py +++ b/examples/mpsvsexact.py @@ -8,6 +8,7 @@ import tensorcircuit as tc tc.set_backend("tensorflow") +tc.set_dtype("complex128") def tfi_energy(c, n, j=1.0, h=-1.0): @@ -19,23 +20,12 @@ def tfi_energy(c, n, j=1.0, h=-1.0): return e -def tfi_energy_mps(c, n, j=1.0, h=-1.0): - e = 0.0 - for i in range(n): - e += h * c.expectation_single_gate(tc.gates.x(), i) - for i in range(n - 1): - e += j * c.expectation_two_gates_product( - tc.gates.z(), tc.gates.z(), i, (i + 1) % n - ) - return e - - def energy(param, mpsd=None): if mpsd is None: c = tc.Circuit(n) else: c = tc.MPSCircuit(n) - c.set_truncation_rule(max_singular_values=mpsd) + c.set_split_rules({"max_singular_values": mpsd}) for i in range(n): c.H(i) @@ -49,11 +39,8 @@ def energy(param, mpsd=None): ) for i in range(n): c.rx(i, theta=param[2 * j + 1, i]) - if mpsd is None: - e = tfi_energy(c, n) - else: - e = tfi_energy_mps(c, n) + e = tfi_energy(c, n) e = tc.backend.real(e) if mpsd is not None: fidelity = c._fidelity From 06ac704b5cd6e60b077893c02b941d7e256391a8 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 1 Nov 2022 12:59:52 +0800 Subject: [PATCH 055/725] make mps benchmark uptodate --- benchmarks/scripts/utils.py | 17 +++++++++++------ benchmarks/scripts/vqe_tc.py | 11 ++++++----- docs/source/advance.rst | 10 ++++++++++ 3 files changed, 27 insertions(+), 11 deletions(-) diff --git a/benchmarks/scripts/utils.py b/benchmarks/scripts/utils.py index 4ca014a1..7f02f04d 100644 --- a/benchmarks/scripts/utils.py +++ b/benchmarks/scripts/utils.py @@ -6,6 +6,8 @@ import numpy as np import tensorflow as tf from pathlib import Path +import optax +import tensorcircuit as tc qml_data = {} @@ -218,12 +220,11 @@ def save(data, _uuid, path): def timing(f, nitrs, timeLimit): t0 = time.time() - print(f()) + a = f() t1 = time.time() Nitrs = 1e-8 for i in range(nitrs): a = f() - print(a) # if a != None: # print(a) if time.time() - t1 > timeLimit: @@ -263,15 +264,19 @@ def qml_timing(f, nbatch, nitrs, timeLimit, tfq=False): class Opt: - def __init__(self, f, params, lr=0.01, tuning=True): + def __init__(self, f, params, lr=0.002, tuning=True, backend="tensorflow"): self.f = f self.params = params - self.adam = tf.keras.optimizers.Adam(lr) + if backend == "tensorflow": + self.adam = tc.backend.optimizer(tf.keras.optimizers.Adam(lr)) + else: + self.adam = tc.backend.optimizer(optax.adam(lr)) self.tuning = tuning def step(self): e, grad = self.f(*self.params) if self.tuning: - grad = [tf.convert_to_tensor(g) for g in grad] - self.adam.apply_gradients(zip(grad, self.params)) + self.params = self.adam.update(grad, self.params) + # grad = [tf.convert_to_tensor(g) for g in grad] + # self.adam.apply_gradients(zip(grad, self.params)) return e[()] diff --git a/benchmarks/scripts/vqe_tc.py b/benchmarks/scripts/vqe_tc.py index 515afc1e..b626c1b4 100644 --- a/benchmarks/scripts/vqe_tc.py +++ b/benchmarks/scripts/vqe_tc.py @@ -109,7 +109,7 @@ def energy_raw(paramx, paramzz): c = tc.Circuit(n) else: c = tc.MPSCircuit(n) - c.set_truncation_rule(max_singular_values=mpsd) + c.set_split_rules({"max_singular_values": mpsd}) paramx = tc.backend.cast(paramx, dtype) paramzz = tc.backend.cast(paramzz, dtype) @@ -132,8 +132,8 @@ def energy_raw(paramx, paramzz): e = tfi_energy(c, n) fd = c._fidelity # tensorflow only works for complex case, while jax only works for real case, don't know how to solve it - if tcbackend != "tensorflow": - e = tc.backend.real(e) + # if tcbackend != "tensorflow": + e = tc.backend.real(e) return e, fd @@ -144,12 +144,13 @@ def energy(paramx, paramzz): # paramx = tc.backend.convert_to_tensor(paramx) # paramzz = tc.backend.convert_to_tensor(paramzz) (value, f), grads = energy_raw(paramx, paramzz) - print(tc.backend.numpy(f), tc.backend.numpy(value)) + print("fidelity: ", f, value) + # print(tc.backend.numpy(f), tc.backend.numpy(value)) # value = tc.backend.numpy(tc.backend.real(value)) # grads = [tc.backend.numpy(tc.backend.real(g)) for g in grads] return value, grads - opt = utils.Opt(energy, [paramx, paramzz], tuning=False) + opt = utils.Opt(energy, [paramx, paramzz], tuning=True, backend=tcbackend) ct, it, Nitrs = utils.timing(opt.step, nitrs, timeLimit) meta["Results"]["with jit"] = { "Construction time": ct, diff --git a/docs/source/advance.rst b/docs/source/advance.rst index 4b041646..a88c48b1 100644 --- a/docs/source/advance.rst +++ b/docs/source/advance.rst @@ -7,6 +7,16 @@ MPS Simulator (Still experimental support) +Very simple, we provide the same set of API for ``MPSCircuit`` as ``Circuit``, +the only new line is to set the bond dimension for the new simulator. + +.. code-block:: python + + c = tc.MPSCircuit(n) + c.set_split_rules({"max_singular_values": 50}) + +The larger bond dimension we set, the better approximation ratio (of course the most computational cost we pay) + Split Two-qubit Gates ------------------------- From 4dad0837097e15bf141613a63948e9a37c33fd93 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 2 Nov 2022 13:52:23 +0800 Subject: [PATCH 056/725] fix readme cn --- README_cn.md | 4 ---- docs/source/advance.rst | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/README_cn.md b/README_cn.md index 9b19223b..a99970bf 100644 --- a/README_cn.md +++ b/README_cn.md @@ -145,7 +145,3 @@ pip install tensorcircuit-nightly VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mbl.ipynb)。 参考论文: https://arxiv.org/pdf/2111.13719.pdf 。 - -``` - -``` diff --git a/docs/source/advance.rst b/docs/source/advance.rst index a88c48b1..4539326e 100644 --- a/docs/source/advance.rst +++ b/docs/source/advance.rst @@ -15,7 +15,7 @@ the only new line is to set the bond dimension for the new simulator. c = tc.MPSCircuit(n) c.set_split_rules({"max_singular_values": 50}) -The larger bond dimension we set, the better approximation ratio (of course the most computational cost we pay) +The larger bond dimension we set, the better approximation ratio (of course the more computational cost we pay) Split Two-qubit Gates ------------------------- From 54f29d053e5256380d50f501d7e25f3f5a339d1c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 3 Nov 2022 12:47:35 +0800 Subject: [PATCH 057/725] add qiskit vqe benchmark --- benchmarks/scripts/utils.py | 27 +++++--- benchmarks/scripts/vqe_qiskit.py | 108 +++++++++++++++++++++++++++++++ 2 files changed, 126 insertions(+), 9 deletions(-) create mode 100644 benchmarks/scripts/vqe_qiskit.py diff --git a/benchmarks/scripts/utils.py b/benchmarks/scripts/utils.py index 7f02f04d..bd437cec 100644 --- a/benchmarks/scripts/utils.py +++ b/benchmarks/scripts/utils.py @@ -227,10 +227,9 @@ def timing(f, nitrs, timeLimit): a = f() # if a != None: # print(a) + Nitrs += 1 if time.time() - t1 > timeLimit: break - else: - Nitrs += 1 t2 = time.time() return t1 - t0, (t2 - t1) / Nitrs, int(Nitrs) @@ -255,10 +254,9 @@ def qml_timing(f, nbatch, nitrs, timeLimit, tfq=False): ) if a is not None: print(a) + Nitrs += 1 if time.time() - t1 > timeLimit: break - else: - Nitrs += 1 t2 = time.time() return t1 - t0, (t2 - t1) / Nitrs, int(Nitrs) @@ -269,14 +267,25 @@ def __init__(self, f, params, lr=0.002, tuning=True, backend="tensorflow"): self.params = params if backend == "tensorflow": self.adam = tc.backend.optimizer(tf.keras.optimizers.Adam(lr)) - else: + elif backend == "jax": self.adam = tc.backend.optimizer(optax.adam(lr)) + elif backend == "numpy": + self.adam = tc.get_backend("tensorflow").optimizer( + tf.keras.optimizers.Adam(lr) + ) self.tuning = tuning + self.backend = backend def step(self): - e, grad = self.f(*self.params) + if getattr(self.params, "shape", False): + e, grad = self.f(self.params) + else: + e, grad = self.f(*self.params) if self.tuning: + if self.backend == "numpy": + self.params = tf.constant(self.params) self.params = self.adam.update(grad, self.params) - # grad = [tf.convert_to_tensor(g) for g in grad] - # self.adam.apply_gradients(zip(grad, self.params)) - return e[()] + if self.backend == "numpy": + self.params = self.params.numpy() + print(e) + return e diff --git a/benchmarks/scripts/vqe_qiskit.py b/benchmarks/scripts/vqe_qiskit.py new file mode 100644 index 00000000..5b94ae23 --- /dev/null +++ b/benchmarks/scripts/vqe_qiskit.py @@ -0,0 +1,108 @@ +import sys +import datetime +from functools import reduce +from operator import xor, add +import uuid +import numpy as np +import cpuinfo + +import qiskit +from qiskit.opflow import I, X, Z, StateFn +from qiskit.circuit import QuantumCircuit, ParameterVector +from qiskit.opflow.gradients import Gradient + +import utils + + +def qiskit_benchmark(uuid, n, nlayer, nitrs, timeLimit, minus=1): + def tfim_hamiltonian(n, j=1.0, h=-1.0): + hams = [] + for i in range(n): + xi = [I for _ in range(n)] + xi[i] = X + hams.append(h * reduce(xor, xi)) + for i in range(n - 1): + zzi = [I for _ in range(n)] + zzi[i] = Z + zzi[i + 1] = Z + hams.append(j * reduce(xor, zzi)) + return reduce(add, hams) + + def gradf(values): + hamiltonian = tfim_hamiltonian(n) + c = QuantumCircuit(n) + params = ParameterVector("theta", length=2 * n * nlayer) + for i in range(n): + c.h(i) + for j in range(nlayer): + for i in range(n - minus): + c.rzz( + params[j * n * 2 + i * 2], + i, + (i + 1) % n, + ) + for i in range(n): + c.rx(params[j * n * 2 + i * 2 + 1], i) + + # Define the expectation value corresponding to the energy + op = ~StateFn(hamiltonian) @ StateFn(c) + grad = Gradient().convert(operator=op, params=params) + + value_dict = {params: values} + exp_result = op.assign_parameters(value_dict).eval() + grad_result = grad.assign_parameters(value_dict).eval() + return np.real(exp_result), np.real(np.array(grad_result)) + + meta = {} + meta["Software"] = "qiskit" + meta["minus"] = minus + meta["Cpuinfo"] = cpuinfo.get_cpu_info()["brand_raw"] + meta["Version"] = { + "sys": sys.version, + "numpy": np.__version__, + "qiskit": qiskit.version.VERSION, + } + meta["VQE test parameters"] = { + "nQubits": n, + "nlayer": nlayer, + "nitrs": nitrs, + "timeLimit": timeLimit, + } + meta["UUID"] = uuid + meta["Benchmark Time"] = ( + datetime.datetime.now().astimezone().strftime("%Y-%m-%d %H:%M %Z") + ) + meta["Results"] = {} + param = np.random.normal(scale=0.1, size=[2 * n * nlayer]) + opt = utils.Opt(gradf, param, tuning=True, backend="numpy") + ct, it, Nitrs = utils.timing(opt.step, nitrs, timeLimit) + meta["Results"]["with jit"] = { + "Construction time": ct, + "Iteration time": it, + "# of actual iterations": Nitrs, + } + print(meta) + return meta + + +if __name__ == "__main__": + _uuid = str(uuid.uuid4()) + ( + n, + nlayer, + nitrs, + timeLimit, + isgpu, + minus, + path, + ) = utils.arg() + + r = qiskit_benchmark( + _uuid, + n, + nlayer, + nitrs, + timeLimit, + minus=minus, + ) + utils.save(r, _uuid, path) From 98321f9cb7c0a9c4ea54eacf2756b79df3592be8 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 3 Nov 2022 14:36:58 +0800 Subject: [PATCH 058/725] add pennylane lightning cpu benchmark to vqe set --- benchmarks/scripts/vqe_pennylane.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/benchmarks/scripts/vqe_pennylane.py b/benchmarks/scripts/vqe_pennylane.py index 6b62611b..6ab0ede3 100644 --- a/benchmarks/scripts/vqe_pennylane.py +++ b/benchmarks/scripts/vqe_pennylane.py @@ -129,6 +129,32 @@ def f(): "# of actual iterations": Nitrs, } + print("begin testing lightning") + dev = qml.device("lightning.qubit", wires=nwires) + + @qml.qnode(dev, diff_method="adjoint") + def lt_expval(params): + for i in range(nwires): + qml.Hadamard(wires=i) + for j in range(nlayer): + for i in range(nwires - minus): + qml.IsingZZ(params[i + j * 2 * nwires], wires=[i, (i + 1) % nwires]) + for i in range(nwires): + qml.RX(params[nwires + i + j * 2 * nwires], wires=i) + return qml.expval(Htfim) + + vag = qml.grad(lt_expval, argnum=0) + params = np.random.normal(size=[nlayer * 2 * nwires]) + + def f(): + return vag(params) + + ct, it, Nitrs = utils.timing(f, nitrs, timeLimit) + meta["Results"]["lightning.cpu"] = { + "Construction time": ct, + "Iteration time": it, + "# of actual iterations": Nitrs, + } # using tf interface and expvalcost # params.assign(np.random.normal(size=[nlayer * 2 * nwires])) # cost_fn_tf = qml.ExpvalCost(circuit, Htfim, dev, interface="tf") From c897134bdd1ae497a1ff025070738c7f8b436294 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 4 Nov 2022 12:36:44 +0800 Subject: [PATCH 059/725] add pennylane lightning qml benchmark --- benchmarks/README.md | 2 +- benchmarks/scripts/qml_pennylane.py | 50 +++++++++++++++++++++++++++-- 2 files changed, 48 insertions(+), 4 deletions(-) diff --git a/benchmarks/README.md b/benchmarks/README.md index 8167d832..668b7a10 100644 --- a/benchmarks/README.md +++ b/benchmarks/README.md @@ -2,7 +2,7 @@ `cd scripts` -`python benchmark.py -n [# of Qubits] -nlayer [# of QC layers] -nitrs [# of max iterations] -t [time limitation] -gpu [0 for no gpu and 1 for gpu enabled] -tcbackend [jax or tensorflow]` +`python benchmark.py -n [# of Qubits] -nlayer [# of QC layers] -nitrs [# of max iterations] -nbatch [# of batch for QML task] -t [time limitation] -gpu [0 for no gpu and 1 for gpu enabled] -tcbackend [jax or tensorflow]` then a `.json` file will be created in data folder which contains the information of benchmarking parameters and results. diff --git a/benchmarks/scripts/qml_pennylane.py b/benchmarks/scripts/qml_pennylane.py index 68c3db0c..0068ee1d 100644 --- a/benchmarks/scripts/qml_pennylane.py +++ b/benchmarks/scripts/qml_pennylane.py @@ -10,8 +10,6 @@ import tensorcircuit as tc import utils -tc.set_backend("tensorflow") - def pennylane_benchmark( uuid, @@ -60,6 +58,52 @@ def pennylane_benchmark( ) meta["Results"] = {} + dev = qml.device("lightning.qubit", wires=nwires) + + K = tc.get_backend("tensorflow") + + @qml.qnode(dev, diff_method="adjoint", interface="tf") + def lt_expval(img, params): + for i in range(nwires - 1): + qml.RX(img[i] * np.pi, wires=i) + for j in range(nlayer): + for i in range(nwires - 1): + qml.IsingZZ(params[i + j * 2 * nwires], wires=[i, nwires - 1]) + for i in range(nwires): + qml.RX(params[nwires + i + j * 2 * nwires], wires=i) + return qml.expval(qml.Hamiltonian([1.0], [qml.PauliZ(nwires - 1)], True)) + + def loss(imgs, lbls, param): + params = K.stack([param for _ in range(lbls.shape[0])]) + params = K.transpose(params, [1, 0]) + return K.mean( + (lbls - K.cast(lt_expval(imgs, params), "float32") * 0.5 - 0.5) ** 2 + ) + + vag = K.value_and_grad(loss, argnums=2) + param = K.convert_to_tensor((np.random.normal(size=[nlayer * 2 * nwires]))) + + def f(train_imgs, train_lbls): + e, grad = vag( + K.transpose( + K.convert_to_tensor(np.array(train_imgs).astype(np.float32)), (1, 0) + ), + K.reshape( + K.convert_to_tensor(np.array(train_lbls).astype(np.float32)), (-1) + ), + param, + ) + return e + + ct, it, Nitrs = utils.qml_timing(f, nbatch, nitrs, timeLimit) + meta["Results"]["lightning"] = { + "Construction time": ct, + "Iteration time": it, + "# of actual iterations": Nitrs, + } + + print(meta["Results"]["lightning"]) + dev = qml.device("default.qubit.jax", wires=nwires) @qml.qnode(dev, interface="jax") @@ -196,7 +240,7 @@ def tf_loss(img, lbl, params): return loss tf_vvag = tf.function( - tc.backend.vvag(tf_loss, vectorized_argnums=(0, 1), argnums=2) + tc.get_backend("tensorflow").vvag(tf_loss, vectorized_argnums=(0, 1), argnums=2) ) def f(train_imgs, train_lbls): From 143d94ce045b0257898c6adfeae034dac223caca Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 4 Nov 2022 14:22:48 +0800 Subject: [PATCH 060/725] add qibo vqe benchmark --- benchmarks/scripts/vqe_qibo.py | 109 +++++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 benchmarks/scripts/vqe_qibo.py diff --git a/benchmarks/scripts/vqe_qibo.py b/benchmarks/scripts/vqe_qibo.py new file mode 100644 index 00000000..23a7b33a --- /dev/null +++ b/benchmarks/scripts/vqe_qibo.py @@ -0,0 +1,109 @@ +import datetime +import sys +import uuid +import cpuinfo + +import tensorcircuit as tc + +tc.set_backend("tensorflow") +import tensorflow as tf +from functools import reduce +from operator import mul +import qibo + +qibo.set_backend("tensorflow") +from qibo import gates, models, hamiltonians +from qibo.symbols import I, X, Z +import utils + + +def qibo_benchmark(uuid, n, nlayer, nitrs, timeLimit, minus=1): + @tf.function + def geth(s, n): + ctc = tc.Circuit(n, inputs=s) + loss = 0.0 + for i in range(n - 1): + loss += ctc.expectation_ps(z=[i, i + 1]) + for i in range(n): + loss -= ctc.expectation_ps(x=[i]) + return loss + + @tf.function # jit will raise error + def optimize(params): + with tf.GradientTape() as tape: + c = models.Circuit(n) + for i in range(n): + c.add(gates.H(i)) + for j in range(nlayer): + for i in range(n - minus): + c.add(gates.CNOT(i, i + 1)) + c.add(gates.RZ(i + 1, theta=params[j, i, 0])) + c.add(gates.CNOT(i, i + 1)) + for i in range(n): + c.add(gates.RX(0, theta=params[j, i, 1])) + s = c().state() + # h = hamiltonians.TFIM(n, h=-1) + # loss = h.expectation(s) + # failed in jit + # qibo lacks the API for local expectation, using tc as assistance + # we must ensure the observable is computed term by term + # instead of the expectation for the Hamiltonian as a whole + # to ensure the comparison is fair + + loss = geth(s, n) + + grads = tape.gradient(loss, params) + return loss, grads + + meta = {} + meta["Software"] = "qibo" + meta["minus"] = minus + meta["Cpuinfo"] = cpuinfo.get_cpu_info()["brand_raw"] + meta["Version"] = { + "sys": sys.version, + "qiskit": qibo.__version__, + } + meta["VQE test parameters"] = { + "nQubits": n, + "nlayer": nlayer, + "nitrs": nitrs, + "timeLimit": timeLimit, + } + meta["UUID"] = uuid + meta["Benchmark Time"] = ( + datetime.datetime.now().astimezone().strftime("%Y-%m-%d %H:%M %Z") + ) + meta["Results"] = {} + params = tf.Variable(tf.random.normal((nlayer, n, 2), dtype=tf.float64)) + opt = utils.Opt(optimize, params, tuning=True, backend="tensorflow") + ct, it, Nitrs = utils.timing(opt.step, nitrs, timeLimit) + meta["Results"]["with jit"] = { + "Construction time": ct, + "Iteration time": it, + "# of actual iterations": Nitrs, + } + print(meta) + return meta + + +if __name__ == "__main__": + _uuid = str(uuid.uuid4()) + ( + n, + nlayer, + nitrs, + timeLimit, + isgpu, + minus, + path, + ) = utils.arg() + + r = qibo_benchmark( + _uuid, + n, + nlayer, + nitrs, + timeLimit, + minus=minus, + ) + utils.save(r, _uuid, path) From a410e90b95dbfbfecaabefbd106d7d85533fb6e9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 4 Nov 2022 15:49:15 +0800 Subject: [PATCH 061/725] fix type --- benchmarks/scripts/vqe_qibo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmarks/scripts/vqe_qibo.py b/benchmarks/scripts/vqe_qibo.py index 23a7b33a..731c470a 100644 --- a/benchmarks/scripts/vqe_qibo.py +++ b/benchmarks/scripts/vqe_qibo.py @@ -61,7 +61,7 @@ def optimize(params): meta["Cpuinfo"] = cpuinfo.get_cpu_info()["brand_raw"] meta["Version"] = { "sys": sys.version, - "qiskit": qibo.__version__, + "qibo": qibo.__version__, } meta["VQE test parameters"] = { "nQubits": n, From f8f741c766a9702e8b53cce327f1e7c007ea3bb6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 4 Nov 2022 20:27:02 +0800 Subject: [PATCH 062/725] add pennylane in bp --- README.md | 2 +- README_cn.md | 2 +- examples/bp_benchmark.py | 37 +++++++++++++++++++++++++++++++++++++ 3 files changed, 39 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 8b5ff34f..94670343 100644 --- a/README.md +++ b/README.md @@ -109,7 +109,7 @@ We also have [Docker support](/docker). - Efficiency - - Time: 10 to 10^6 times acceleration compared to tfq or qiskit + - Time: 10 to 10^6+ times acceleration compared to TensorFlow Quantum, Pennylane or Qiskit - Space: 600+ qubits 1D VQE workflow (converged energy inaccuracy: < 1%) diff --git a/README_cn.md b/README_cn.md index a99970bf..140cb428 100644 --- a/README_cn.md +++ b/README_cn.md @@ -105,7 +105,7 @@ pip install tensorcircuit-nightly - 效率 - - 时间：与 TFQ 或 Qiskit 相比，加速 10 到 10^6 倍 + - 时间：与 TFQ, Pennylane, 或 Qiskit 相比，加速 10 到 10^6+ 倍 - 空间：600+ qubits 1D VQE 工作流（收敛能量误差：< 1%） diff --git a/examples/bp_benchmark.py b/examples/bp_benchmark.py index 734ddfb6..9d74d12e 100644 --- a/examples/bp_benchmark.py +++ b/examples/bp_benchmark.py @@ -9,6 +9,7 @@ import cirq import sympy import numpy as np +import pennylane as qml import tensorflow_quantum as tfq import tensorcircuit as tc @@ -123,6 +124,42 @@ def op_expectation(params, seed, n_qubits, depth): ) +def pennylane_approach(n_qubits=10, depth=10, n_circuits=100): + + dev = qml.device("lightning.qubit", wires=n_qubits) + gate_set = [qml.RX, qml.RY, qml.RZ] + + @qml.qnode(dev) + def rand_circuit(params, status): + for i in range(n_qubits): + qml.RY(np.pi / 4, wires=i) + + for j in range(depth): + for i in range(n_qubits): + gate_set[status[i, j]](params[j, i], wires=i) + + for i in range(n_qubits - 1): + qml.CZ(wires=[i, i + 1]) + + return qml.expval(qml.Hamiltonian([1.0], [qml.PauliZ(0) @ qml.PauliZ(1)], True)) + + gf = qml.grad(rand_circuit, argnum=0) + params = np.random.uniform(0, 2 * np.pi, size=[n_circuits, depth, n_qubits]) + status = np.random.choice(3, size=[n_circuits, depth, n_qubits]) + + g_results = [] + + for i in range(n_circuits): + g_results.append(gf(params[i], status[i])) + + g_results = np.stack(g_results) + + return np.std(g_results[:, 0, 0]) + + +benchmark(pennylane_approach) + + def tc_approach(n_qubits=10, depth=10, n_circuits=100): seed = tc.array_to_tensor( From 96020ad325f4b855e45bec7ecda82c97fc8e0e2b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 10 Nov 2022 17:22:03 +0800 Subject: [PATCH 063/725] add resubmit job method --- tensorcircuit/cloud/abstraction.py | 15 +++++++++++++-- tensorcircuit/cloud/apis.py | 17 +++++++++++++++++ tensorcircuit/cloud/tencent.py | 18 ++++++++++++++++-- 3 files changed, 46 insertions(+), 4 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index effd4d32..402cd83f 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -148,6 +148,12 @@ def __repr__(self) -> str: __str__ = __repr__ + def get_device(self) -> Device: + if self.device is None: + return Device.from_name(self.details()["device"]) + else: + return Device.from_name(self.device) + def details(self) -> Dict[str, Any]: from .apis import get_task_details @@ -157,6 +163,13 @@ def state(self) -> str: r = self.details() return r["state"] # type: ignore + status = state + + def resubmit(self) -> "Task": + from .apis import resubmit_task + + return resubmit_task(self) + def results(self, format: Optional[str] = None) -> Any: # TODO(@refraction-ray): support different formats compatible with tc, # also support format_ alias @@ -164,5 +177,3 @@ def results(self, format: Optional[str] = None) -> Any: raise ValueError("Task %s is not completed yet" % self.id_) r = self.details()["results"] return r - - status = state diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index ddf530cb..208bffb5 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -233,3 +233,20 @@ def submit_task( return tencent.submit_task(device, token, **task_kws) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def resubmit_task( + task: Optional[Union[str, Task]], + token: Optional[str] = None, +) -> Task: + if isinstance(task, str): + task = Task(task) + device = task.get_device() # type: ignore + if token is None: + token = device.get_token() + provider = device.provider + + if provider.name == "tencent": # type: ignore + return tencent.resubmit_task(task, token) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 8e3d239d..5335d479 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -100,14 +100,28 @@ def submit_task( raise ValueError(dumps(r)) +def resubmit_task(task: Task, token: str) -> Task: + # TODO(@refraction-ray): batch resubmit + json = {"id": task.id_} + r = rpost_json( + tencent_base_url + "task/start", json=json, headers=tencent_headers(token) + ) + try: + return Task(id_=r["tasks"][0]["id"]) + + except KeyError: + raise ValueError(dumps(r)) + + def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: json = {"id": task.id_} r = rpost_json( tencent_base_url + "task/detail", json=json, headers=tencent_headers(token) ) try: - if "counts" in r["task"]["result"]: - r["task"]["results"] = r["task"]["result"]["counts"] + if "result" in r["task"]: + if "counts" in r["task"]["result"]: + r["task"]["results"] = r["task"]["result"]["counts"] return r["task"] # type: ignore except KeyError: raise ValueError(dumps(r)) From e3a5f857dba8770bf1b4fc943ffc75559b49ef8c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 11 Nov 2022 16:45:54 +0800 Subject: [PATCH 064/725] fix unitary kraus bug --- CHANGELOG.md | 4 ++++ tensorcircuit/circuit.py | 1 + 2 files changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 500188a8..73382ae3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,10 @@ - Improve the efficiency of `sample_expectation_ps` method by using cached state. +### Fixed + +- Fixed `unitary_kraus` of Circuit class support for multi-qubit kraus channels, previous implementation fails to reshape the kraus tensor as matrix + ## 0.5.0 ### Added diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index c3d53d37..2a6d1fcc 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -393,6 +393,7 @@ def _unitary_kraus_template( sites = len(index) kraus = [k.tensor if isinstance(k, tn.Node) else k for k in kraus] kraus = [gates.array_to_tensor(k) for k in kraus] + kraus = [backend.reshapem(k) for k in kraus] if prob is None: prob = [ backend.real(backend.trace(backend.adjoint(k) @ k) / k.shape[0]) From f70eb3059950b22768600077cd23610b9e0d1738 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Fri, 11 Nov 2022 16:57:00 +0800 Subject: [PATCH 065/725] update noisemodel --- tensorcircuit/noisemodel.py | 68 ++++++++++++----- tests/test_noisemodel.py | 143 +++++++++++++++++++++++++++++++++++- 2 files changed, 193 insertions(+), 18 deletions(-) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 7e3e89b7..21796581 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -15,19 +15,33 @@ def __init__(self) -> None: # type: ignore self.has_quantum = False self.has_readout = False - def add_noise(self, gate_name, kraus): # type: ignore - self.nc[gate_name] = kraus + def add_noise(self, gate_name, kraus, qubit=None): # type: ignore + if gate_name not in self.nc: + qubit_kraus = {} + else: + qubit_kraus = self.nc[gate_name] + + if qubit == None: + qubit_kraus["Default"]= kraus + else: + for i in range(len(qubit)): + qubit_kraus[tuple(qubit[i])]= kraus[i] + self.nc[gate_name] = qubit_kraus + + if gate_name == "readout": self.has_readout = True else: self.has_quantum = True + + def apply_qir_with_noise(c, qir, noise_conf, status=None): # type: ignore quantum_index = 0 for d in qir: - + print("gate:",d["index"],d["name"]) if "parameters" not in d: # paramized gate c.apply_general_gate_delayed(d["gatef"], d["name"])( # type: ignore c, *d["index"] # type: ignore @@ -39,27 +53,44 @@ def apply_qir_with_noise(c, qir, noise_conf, status=None): # type: ignore if isinstance(c, DMCircuit): if d["name"] in noise_conf.nc: - c.general_kraus(noise_conf.nc[d["name"]], *d["index"]) + if "Default" in noise_conf.nc[d["name"]] or d["index"] in noise_conf.nc[d["name"]]: + print("add:", d["index"], d["name"]) + if "Default" in noise_conf.nc[d["name"]]: + noise_kraus = noise_conf.nc[d["name"]]["Default"] + if d["index"] in noise_conf.nc[d["name"]]: + noise_kraus = noise_conf.nc[d["name"]][d["index"]] + + print(*d["index"]) + c.general_kraus(noise_kraus, *d["index"]) else: if d["name"] in noise_conf.nc: - if noise_conf.nc[d["name"]].is_unitary is True: - c.unitary_kraus( - noise_conf.nc[d["name"]], - *d["index"], - status=status[quantum_index] - ) - else: - c.general_kraus( - noise_conf.nc[d["name"]], - *d["index"], - status=status[quantum_index] - ) - quantum_index += 1 + if "Default" in noise_conf.nc[d["name"]] or d["index"] in noise_conf.nc[d["name"]]: + print("add:", d["index"], d["name"]) + + if "Default" in noise_conf.nc[d["name"]]: + noise_kraus = noise_conf.nc[d["name"]]["Default"] + if d["index"] in noise_conf.nc[d["name"]]: + noise_kraus = noise_conf.nc[d["name"]][d["index"]] + + if noise_kraus.is_unitary is True: + c.general_kraus( + noise_kraus, + *d["index"], + status=status[quantum_index] + ) + else: + c.general_kraus( + noise_kraus, + *d["index"], + status=status[quantum_index] + ) + quantum_index += 1 return c + def circuit_with_noise(c, noise_conf, status=None): # type: ignore qir = c.to_qir() cnew: AbstractCircuit @@ -71,6 +102,8 @@ def circuit_with_noise(c, noise_conf, status=None): # type: ignore return cnew + + def expectation_ps_noisfy(c, x=None, y=None, z=None, noise_conf=None, nmc=1000, status=None): # type: ignore if noise_conf is None: @@ -80,6 +113,7 @@ def expectation_ps_noisfy(c, x=None, y=None, z=None, noise_conf=None, nmc=1000, num_quantum = c.gate_count(list(noise_conf.nc.keys())) + if noise_conf.has_readout is True: logger.warning("expectation_ps_noisfy can't support readout error.") else: diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index 921f74bb..2ae28445 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -38,7 +38,7 @@ def test_noisemodel_expectvalue(backend): cnoise = circuit_with_noise(c, noise_conf, [0.1] * 2) value = cnoise.expectation_ps(z=[0, 1]) # print("noise_circuit_value", value) - np.testing.assert_allclose(value, -0.18, atol=1e-2) + # np.testing.assert_allclose(value, -0.18, atol=1e-2) dmc = tc.DMCircuit(2) dmc.rx(0, theta=0.4) @@ -126,3 +126,144 @@ def test_noisemodel_sample(backend): value = sample_expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf2) # print("noise_nmc_quantum", value) np.testing.assert_allclose(value, -0.28, atol=1e-2) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_noisemodel_qubit(backend): + + # noise_conf = NoiseConf() + # noise_conf.add_noise("h1","t0") + # noise_conf.add_noise("h1",["t1","t2"],[[0],[1]]) + # noise_conf.add_noise("h1",["t3"],[[0]]) + # noise_conf.add_noise("h2",["v1","v2"],[[0],[1]]) + # noise_conf.add_noise("h2",["v3"],[[0]]) + + + + c = tc.Circuit(2) + c.rx(0, theta=0.4) + c.rx(1, theta=0.8) + c.h(0) + c.h(1) + c.x(0) + c.x(1) + c.cnot(0,1) + error1 = tc.channels.generaldepolarizingchannel(0.1, 1) + error2 = tc.channels.generaldepolarizingchannel(0.01, 2) + error3 = tc.channels.thermalrelaxationchannel(300, 400, 100, "ByChoi", 0) + + + readout_error = [] + readout_error.append([0.9, 0.75]) # readout error of qubit 0 + readout_error.append([0.4, 0.7]) # readout error of qubit 1 + + noise_conf = NoiseConf() + noise_conf.add_noise("rx", error1) + noise_conf.add_noise("rx", [error3],[[0]]) + noise_conf.add_noise("h",[error3,error1],[[0],[1]]) + noise_conf.add_noise("x",[error3],[[0]]) + noise_conf.add_noise("cnot", [error2],[[0,1]]) + # #noise_conf.add_noise("readout", readout_error) + + + cnoise = circuit_with_noise(c, noise_conf, [0.1] * 7) + value = cnoise.expectation_ps(z=[0, 1]) + print(value) + + # value = expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf, nmc=10000) + # print(value) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_dep(backend): + c = tc.Circuit(2) + c.cnot(0,1) + + + error1 = tc.channels.generaldepolarizingchannel(0.1, 1) + error2 = tc.channels.generaldepolarizingchannel(0.01, 2) + + + noise_conf = NoiseConf() + #noise_conf.add_noise("rx",[error1,error1],[[0],[1]]) + noise_conf.add_noise("cnot", [error2],[[0,1]]) + + + cnoise = circuit_with_noise(c, noise_conf, [0.1] * 7) + value = cnoise.expectation_ps(z=[0, 1]) + print(value) + + value = expectation_ps_noisfy(c, z=[0, 1], noise_conf=noise_conf, nmc=10000) + print(value) + + + + + + + # value = sample_expectation_ps_noisfy(dmc, z=[0, 1], noise_conf=noise_conf) + # print(value) + + + kraus = tc.channels.generaldepolarizingchannel(0.1, 1) + tc.channels.kraus_identity_check(kraus) + + c.general_kraus(kraus, 0, status=0.1) + print("1",c.expectation_ps(z=[0,1])) + + + c.unitary_kraus(kraus, 0,status=0.8) + print("1",c.expectation_ps(z=[0,1])) + + dmc = tc.DMCircuit(2) + dmc.cnot(0,1) + + dmc.general_kraus(kraus, 0) + print("1",dmc.expectation_ps(z=[0,1])) + + dmc = tc.DMCircuit(2) + dmc.cnot(0,1) + + dmc.generaldepolarizing(0,p=0.1, num_qubits=1) + print("1",dmc.expectation_ps(z=[0,1])) + + + + kraus = tc.channels.generaldepolarizingchannel(0.01, 2) + + + tc.channels.kraus_identity_check(kraus) + + c.general_kraus(kraus, 0,1, status=0.3) + print("2",c.expectation_ps(z=[0,1])) + + + c.unitary_kraus(kraus, 0,1,status=0.7) + print("2",c.expectation_ps(z=[0,1])) + + + dmc.general_kraus(kraus, 0,1) + print("2",dmc.expectation_ps(z=[0,1])) + + dmc = tc.DMCircuit(2) + dmc.cnot(0,1) + + dmc.generaldepolarizing(0,1,p=0.01, num_qubits=2) + print("2",dmc.expectation_ps(z=[0,1])) + + + + + + + + + + + + + + + + + From c626ce8ba8660f5fe03b591eb15fc736a1993fb0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 11 Nov 2022 17:16:00 +0800 Subject: [PATCH 066/725] fix kraus to super bug --- CHANGELOG.md | 2 ++ tensorcircuit/channels.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 73382ae3..2bba8239 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,8 @@ - Fixed `unitary_kraus` of Circuit class support for multi-qubit kraus channels, previous implementation fails to reshape the kraus tensor as matrix +- Fixed `kraus_to_super_gate` bug when multi-qubit kraus channels are presented on tensorflow backend + ## 0.5.0 ### Added diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index e2c0e753..6e5762f7 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -513,6 +513,8 @@ def kraus_to_super_gate(kraus_list: Sequence[Gate]) -> Tensor: :rtype: Tensor """ kraus_tensor_list = [k.tensor for k in kraus_list] + kraus_tensor_list = [backend.reshapem(k) for k in kraus_tensor_list] + k = kraus_tensor_list[0] u = backend.kron(k, backend.conj(k)) for k in kraus_tensor_list[1:]: From d0c6ab8e11afb5588e328611f96a01367a6fb504 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Fri, 11 Nov 2022 17:17:39 +0800 Subject: [PATCH 067/725] update2 noisemodel --- .github/workflows/ci.yml | 2 + .gitignore | 1 + CHANGELOG.md | 18 +++ README.md | 2 +- README_cn.md | 6 +- benchmarks/README.md | 2 +- benchmarks/scripts/qml_pennylane.py | 50 ++++++- benchmarks/scripts/utils.py | 38 +++-- benchmarks/scripts/vqe_pennylane.py | 26 ++++ benchmarks/scripts/vqe_qibo.py | 109 ++++++++++++++ benchmarks/scripts/vqe_qiskit.py | 108 ++++++++++++++ benchmarks/scripts/vqe_tc.py | 11 +- docs/source/advance.rst | 10 ++ examples/bp_benchmark.py | 37 +++++ examples/mpsvsexact.py | 19 +-- examples/parameter_shift.py | 4 + examples/qaoa_shot_noise.py | 215 ++++++++++++++++++++++++++++ examples/time_evolution.py | 71 +++++++++ tensorcircuit/__init__.py | 1 + tensorcircuit/abstractcircuit.py | 28 +++- tensorcircuit/basecircuit.py | 6 +- tensorcircuit/circuit.py | 1 + tensorcircuit/experimental.py | 60 +++++++- tensorcircuit/mpscircuit.py | 47 +++--- tensorcircuit/noisemodel.py | 3 +- tensorcircuit/translation.py | 15 +- tests/test_circuit.py | 10 ++ tests/test_mpscircuit.py | 149 ++++++++++--------- tests/test_noisemodel.py | 9 +- 29 files changed, 910 insertions(+), 148 deletions(-) create mode 100644 benchmarks/scripts/vqe_qibo.py create mode 100644 benchmarks/scripts/vqe_qiskit.py create mode 100644 examples/qaoa_shot_noise.py create mode 100644 examples/time_evolution.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f3ac5cd7..03dd81bc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -48,6 +48,8 @@ jobs: python mcnoise_boost.py python quantumng.py python universal_lr.py + python parameter_shift.py + python mpsvsexact.py - name: setup build run: | python3 setup.py build diff --git a/.gitignore b/.gitignore index 32fa5a10..291c4f1c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ +data .prettierignore .idea/ dataset diff --git a/CHANGELOG.md b/CHANGELOG.md index d197d91d..73382ae3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,24 @@ ## Unreleased +### Added + +- Add native support for `rxx`, `ryy` and `rzz` gates for translation from qiskit + +- Add `from_openqasm` and `from_openqasm_file` methods for `Circuit` + +- Add `circuit_params` argument for translation from qiskit to make the interface universal and consistent with other `from_` methods + +- Add `shifts` tuple parameter for `experimental.parameter_shift_grad` API so that we can also customize finite difference gradient from this method + +### Changed + +- Improve the efficiency of `sample_expectation_ps` method by using cached state. + +### Fixed + +- Fixed `unitary_kraus` of Circuit class support for multi-qubit kraus channels, previous implementation fails to reshape the kraus tensor as matrix + ## 0.5.0 ### Added diff --git a/README.md b/README.md index 8b5ff34f..94670343 100644 --- a/README.md +++ b/README.md @@ -109,7 +109,7 @@ We also have [Docker support](/docker). - Efficiency - - Time: 10 to 10^6 times acceleration compared to tfq or qiskit + - Time: 10 to 10^6+ times acceleration compared to TensorFlow Quantum, Pennylane or Qiskit - Space: 600+ qubits 1D VQE workflow (converged energy inaccuracy: < 1%) diff --git a/README_cn.md b/README_cn.md index 9b19223b..140cb428 100644 --- a/README_cn.md +++ b/README_cn.md @@ -105,7 +105,7 @@ pip install tensorcircuit-nightly - 效率 - - 时间：与 TFQ 或 Qiskit 相比，加速 10 到 10^6 倍 + - 时间：与 TFQ, Pennylane, 或 Qiskit 相比，加速 10 到 10^6+ 倍 - 空间：600+ qubits 1D VQE 工作流（收敛能量误差：< 1%） @@ -145,7 +145,3 @@ pip install tensorcircuit-nightly VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mbl.ipynb)。 参考论文: https://arxiv.org/pdf/2111.13719.pdf 。 - -``` - -``` diff --git a/benchmarks/README.md b/benchmarks/README.md index 8167d832..668b7a10 100644 --- a/benchmarks/README.md +++ b/benchmarks/README.md @@ -2,7 +2,7 @@ `cd scripts` -`python benchmark.py -n [# of Qubits] -nlayer [# of QC layers] -nitrs [# of max iterations] -t [time limitation] -gpu [0 for no gpu and 1 for gpu enabled] -tcbackend [jax or tensorflow]` +`python benchmark.py -n [# of Qubits] -nlayer [# of QC layers] -nitrs [# of max iterations] -nbatch [# of batch for QML task] -t [time limitation] -gpu [0 for no gpu and 1 for gpu enabled] -tcbackend [jax or tensorflow]` then a `.json` file will be created in data folder which contains the information of benchmarking parameters and results. diff --git a/benchmarks/scripts/qml_pennylane.py b/benchmarks/scripts/qml_pennylane.py index 68c3db0c..0068ee1d 100644 --- a/benchmarks/scripts/qml_pennylane.py +++ b/benchmarks/scripts/qml_pennylane.py @@ -10,8 +10,6 @@ import tensorcircuit as tc import utils -tc.set_backend("tensorflow") - def pennylane_benchmark( uuid, @@ -60,6 +58,52 @@ def pennylane_benchmark( ) meta["Results"] = {} + dev = qml.device("lightning.qubit", wires=nwires) + + K = tc.get_backend("tensorflow") + + @qml.qnode(dev, diff_method="adjoint", interface="tf") + def lt_expval(img, params): + for i in range(nwires - 1): + qml.RX(img[i] * np.pi, wires=i) + for j in range(nlayer): + for i in range(nwires - 1): + qml.IsingZZ(params[i + j * 2 * nwires], wires=[i, nwires - 1]) + for i in range(nwires): + qml.RX(params[nwires + i + j * 2 * nwires], wires=i) + return qml.expval(qml.Hamiltonian([1.0], [qml.PauliZ(nwires - 1)], True)) + + def loss(imgs, lbls, param): + params = K.stack([param for _ in range(lbls.shape[0])]) + params = K.transpose(params, [1, 0]) + return K.mean( + (lbls - K.cast(lt_expval(imgs, params), "float32") * 0.5 - 0.5) ** 2 + ) + + vag = K.value_and_grad(loss, argnums=2) + param = K.convert_to_tensor((np.random.normal(size=[nlayer * 2 * nwires]))) + + def f(train_imgs, train_lbls): + e, grad = vag( + K.transpose( + K.convert_to_tensor(np.array(train_imgs).astype(np.float32)), (1, 0) + ), + K.reshape( + K.convert_to_tensor(np.array(train_lbls).astype(np.float32)), (-1) + ), + param, + ) + return e + + ct, it, Nitrs = utils.qml_timing(f, nbatch, nitrs, timeLimit) + meta["Results"]["lightning"] = { + "Construction time": ct, + "Iteration time": it, + "# of actual iterations": Nitrs, + } + + print(meta["Results"]["lightning"]) + dev = qml.device("default.qubit.jax", wires=nwires) @qml.qnode(dev, interface="jax") @@ -196,7 +240,7 @@ def tf_loss(img, lbl, params): return loss tf_vvag = tf.function( - tc.backend.vvag(tf_loss, vectorized_argnums=(0, 1), argnums=2) + tc.get_backend("tensorflow").vvag(tf_loss, vectorized_argnums=(0, 1), argnums=2) ) def f(train_imgs, train_lbls): diff --git a/benchmarks/scripts/utils.py b/benchmarks/scripts/utils.py index 4ca014a1..bd437cec 100644 --- a/benchmarks/scripts/utils.py +++ b/benchmarks/scripts/utils.py @@ -6,6 +6,8 @@ import numpy as np import tensorflow as tf from pathlib import Path +import optax +import tensorcircuit as tc qml_data = {} @@ -218,18 +220,16 @@ def save(data, _uuid, path): def timing(f, nitrs, timeLimit): t0 = time.time() - print(f()) + a = f() t1 = time.time() Nitrs = 1e-8 for i in range(nitrs): a = f() - print(a) # if a != None: # print(a) + Nitrs += 1 if time.time() - t1 > timeLimit: break - else: - Nitrs += 1 t2 = time.time() return t1 - t0, (t2 - t1) / Nitrs, int(Nitrs) @@ -254,24 +254,38 @@ def qml_timing(f, nbatch, nitrs, timeLimit, tfq=False): ) if a is not None: print(a) + Nitrs += 1 if time.time() - t1 > timeLimit: break - else: - Nitrs += 1 t2 = time.time() return t1 - t0, (t2 - t1) / Nitrs, int(Nitrs) class Opt: - def __init__(self, f, params, lr=0.01, tuning=True): + def __init__(self, f, params, lr=0.002, tuning=True, backend="tensorflow"): self.f = f self.params = params - self.adam = tf.keras.optimizers.Adam(lr) + if backend == "tensorflow": + self.adam = tc.backend.optimizer(tf.keras.optimizers.Adam(lr)) + elif backend == "jax": + self.adam = tc.backend.optimizer(optax.adam(lr)) + elif backend == "numpy": + self.adam = tc.get_backend("tensorflow").optimizer( + tf.keras.optimizers.Adam(lr) + ) self.tuning = tuning + self.backend = backend def step(self): - e, grad = self.f(*self.params) + if getattr(self.params, "shape", False): + e, grad = self.f(self.params) + else: + e, grad = self.f(*self.params) if self.tuning: - grad = [tf.convert_to_tensor(g) for g in grad] - self.adam.apply_gradients(zip(grad, self.params)) - return e[()] + if self.backend == "numpy": + self.params = tf.constant(self.params) + self.params = self.adam.update(grad, self.params) + if self.backend == "numpy": + self.params = self.params.numpy() + print(e) + return e diff --git a/benchmarks/scripts/vqe_pennylane.py b/benchmarks/scripts/vqe_pennylane.py index 6b62611b..6ab0ede3 100644 --- a/benchmarks/scripts/vqe_pennylane.py +++ b/benchmarks/scripts/vqe_pennylane.py @@ -129,6 +129,32 @@ def f(): "# of actual iterations": Nitrs, } + print("begin testing lightning") + dev = qml.device("lightning.qubit", wires=nwires) + + @qml.qnode(dev, diff_method="adjoint") + def lt_expval(params): + for i in range(nwires): + qml.Hadamard(wires=i) + for j in range(nlayer): + for i in range(nwires - minus): + qml.IsingZZ(params[i + j * 2 * nwires], wires=[i, (i + 1) % nwires]) + for i in range(nwires): + qml.RX(params[nwires + i + j * 2 * nwires], wires=i) + return qml.expval(Htfim) + + vag = qml.grad(lt_expval, argnum=0) + params = np.random.normal(size=[nlayer * 2 * nwires]) + + def f(): + return vag(params) + + ct, it, Nitrs = utils.timing(f, nitrs, timeLimit) + meta["Results"]["lightning.cpu"] = { + "Construction time": ct, + "Iteration time": it, + "# of actual iterations": Nitrs, + } # using tf interface and expvalcost # params.assign(np.random.normal(size=[nlayer * 2 * nwires])) # cost_fn_tf = qml.ExpvalCost(circuit, Htfim, dev, interface="tf") diff --git a/benchmarks/scripts/vqe_qibo.py b/benchmarks/scripts/vqe_qibo.py new file mode 100644 index 00000000..731c470a --- /dev/null +++ b/benchmarks/scripts/vqe_qibo.py @@ -0,0 +1,109 @@ +import datetime +import sys +import uuid +import cpuinfo + +import tensorcircuit as tc + +tc.set_backend("tensorflow") +import tensorflow as tf +from functools import reduce +from operator import mul +import qibo + +qibo.set_backend("tensorflow") +from qibo import gates, models, hamiltonians +from qibo.symbols import I, X, Z +import utils + + +def qibo_benchmark(uuid, n, nlayer, nitrs, timeLimit, minus=1): + @tf.function + def geth(s, n): + ctc = tc.Circuit(n, inputs=s) + loss = 0.0 + for i in range(n - 1): + loss += ctc.expectation_ps(z=[i, i + 1]) + for i in range(n): + loss -= ctc.expectation_ps(x=[i]) + return loss + + @tf.function # jit will raise error + def optimize(params): + with tf.GradientTape() as tape: + c = models.Circuit(n) + for i in range(n): + c.add(gates.H(i)) + for j in range(nlayer): + for i in range(n - minus): + c.add(gates.CNOT(i, i + 1)) + c.add(gates.RZ(i + 1, theta=params[j, i, 0])) + c.add(gates.CNOT(i, i + 1)) + for i in range(n): + c.add(gates.RX(0, theta=params[j, i, 1])) + s = c().state() + # h = hamiltonians.TFIM(n, h=-1) + # loss = h.expectation(s) + # failed in jit + # qibo lacks the API for local expectation, using tc as assistance + # we must ensure the observable is computed term by term + # instead of the expectation for the Hamiltonian as a whole + # to ensure the comparison is fair + + loss = geth(s, n) + + grads = tape.gradient(loss, params) + return loss, grads + + meta = {} + meta["Software"] = "qibo" + meta["minus"] = minus + meta["Cpuinfo"] = cpuinfo.get_cpu_info()["brand_raw"] + meta["Version"] = { + "sys": sys.version, + "qibo": qibo.__version__, + } + meta["VQE test parameters"] = { + "nQubits": n, + "nlayer": nlayer, + "nitrs": nitrs, + "timeLimit": timeLimit, + } + meta["UUID"] = uuid + meta["Benchmark Time"] = ( + datetime.datetime.now().astimezone().strftime("%Y-%m-%d %H:%M %Z") + ) + meta["Results"] = {} + params = tf.Variable(tf.random.normal((nlayer, n, 2), dtype=tf.float64)) + opt = utils.Opt(optimize, params, tuning=True, backend="tensorflow") + ct, it, Nitrs = utils.timing(opt.step, nitrs, timeLimit) + meta["Results"]["with jit"] = { + "Construction time": ct, + "Iteration time": it, + "# of actual iterations": Nitrs, + } + print(meta) + return meta + + +if __name__ == "__main__": + _uuid = str(uuid.uuid4()) + ( + n, + nlayer, + nitrs, + timeLimit, + isgpu, + minus, + path, + ) = utils.arg() + + r = qibo_benchmark( + _uuid, + n, + nlayer, + nitrs, + timeLimit, + minus=minus, + ) + utils.save(r, _uuid, path) diff --git a/benchmarks/scripts/vqe_qiskit.py b/benchmarks/scripts/vqe_qiskit.py new file mode 100644 index 00000000..5b94ae23 --- /dev/null +++ b/benchmarks/scripts/vqe_qiskit.py @@ -0,0 +1,108 @@ +import sys +import datetime +from functools import reduce +from operator import xor, add +import uuid +import numpy as np +import cpuinfo + +import qiskit +from qiskit.opflow import I, X, Z, StateFn +from qiskit.circuit import QuantumCircuit, ParameterVector +from qiskit.opflow.gradients import Gradient + +import utils + + +def qiskit_benchmark(uuid, n, nlayer, nitrs, timeLimit, minus=1): + def tfim_hamiltonian(n, j=1.0, h=-1.0): + hams = [] + for i in range(n): + xi = [I for _ in range(n)] + xi[i] = X + hams.append(h * reduce(xor, xi)) + for i in range(n - 1): + zzi = [I for _ in range(n)] + zzi[i] = Z + zzi[i + 1] = Z + hams.append(j * reduce(xor, zzi)) + return reduce(add, hams) + + def gradf(values): + hamiltonian = tfim_hamiltonian(n) + c = QuantumCircuit(n) + params = ParameterVector("theta", length=2 * n * nlayer) + for i in range(n): + c.h(i) + for j in range(nlayer): + for i in range(n - minus): + c.rzz( + params[j * n * 2 + i * 2], + i, + (i + 1) % n, + ) + for i in range(n): + c.rx(params[j * n * 2 + i * 2 + 1], i) + + # Define the expectation value corresponding to the energy + op = ~StateFn(hamiltonian) @ StateFn(c) + grad = Gradient().convert(operator=op, params=params) + + value_dict = {params: values} + exp_result = op.assign_parameters(value_dict).eval() + grad_result = grad.assign_parameters(value_dict).eval() + return np.real(exp_result), np.real(np.array(grad_result)) + + meta = {} + meta["Software"] = "qiskit" + meta["minus"] = minus + meta["Cpuinfo"] = cpuinfo.get_cpu_info()["brand_raw"] + meta["Version"] = { + "sys": sys.version, + "numpy": np.__version__, + "qiskit": qiskit.version.VERSION, + } + meta["VQE test parameters"] = { + "nQubits": n, + "nlayer": nlayer, + "nitrs": nitrs, + "timeLimit": timeLimit, + } + meta["UUID"] = uuid + meta["Benchmark Time"] = ( + datetime.datetime.now().astimezone().strftime("%Y-%m-%d %H:%M %Z") + ) + meta["Results"] = {} + param = np.random.normal(scale=0.1, size=[2 * n * nlayer]) + opt = utils.Opt(gradf, param, tuning=True, backend="numpy") + ct, it, Nitrs = utils.timing(opt.step, nitrs, timeLimit) + meta["Results"]["with jit"] = { + "Construction time": ct, + "Iteration time": it, + "# of actual iterations": Nitrs, + } + print(meta) + return meta + + +if __name__ == "__main__": + _uuid = str(uuid.uuid4()) + ( + n, + nlayer, + nitrs, + timeLimit, + isgpu, + minus, + path, + ) = utils.arg() + + r = qiskit_benchmark( + _uuid, + n, + nlayer, + nitrs, + timeLimit, + minus=minus, + ) + utils.save(r, _uuid, path) diff --git a/benchmarks/scripts/vqe_tc.py b/benchmarks/scripts/vqe_tc.py index 515afc1e..b626c1b4 100644 --- a/benchmarks/scripts/vqe_tc.py +++ b/benchmarks/scripts/vqe_tc.py @@ -109,7 +109,7 @@ def energy_raw(paramx, paramzz): c = tc.Circuit(n) else: c = tc.MPSCircuit(n) - c.set_truncation_rule(max_singular_values=mpsd) + c.set_split_rules({"max_singular_values": mpsd}) paramx = tc.backend.cast(paramx, dtype) paramzz = tc.backend.cast(paramzz, dtype) @@ -132,8 +132,8 @@ def energy_raw(paramx, paramzz): e = tfi_energy(c, n) fd = c._fidelity # tensorflow only works for complex case, while jax only works for real case, don't know how to solve it - if tcbackend != "tensorflow": - e = tc.backend.real(e) + # if tcbackend != "tensorflow": + e = tc.backend.real(e) return e, fd @@ -144,12 +144,13 @@ def energy(paramx, paramzz): # paramx = tc.backend.convert_to_tensor(paramx) # paramzz = tc.backend.convert_to_tensor(paramzz) (value, f), grads = energy_raw(paramx, paramzz) - print(tc.backend.numpy(f), tc.backend.numpy(value)) + print("fidelity: ", f, value) + # print(tc.backend.numpy(f), tc.backend.numpy(value)) # value = tc.backend.numpy(tc.backend.real(value)) # grads = [tc.backend.numpy(tc.backend.real(g)) for g in grads] return value, grads - opt = utils.Opt(energy, [paramx, paramzz], tuning=False) + opt = utils.Opt(energy, [paramx, paramzz], tuning=True, backend=tcbackend) ct, it, Nitrs = utils.timing(opt.step, nitrs, timeLimit) meta["Results"]["with jit"] = { "Construction time": ct, diff --git a/docs/source/advance.rst b/docs/source/advance.rst index 4b041646..4539326e 100644 --- a/docs/source/advance.rst +++ b/docs/source/advance.rst @@ -7,6 +7,16 @@ MPS Simulator (Still experimental support) +Very simple, we provide the same set of API for ``MPSCircuit`` as ``Circuit``, +the only new line is to set the bond dimension for the new simulator. + +.. code-block:: python + + c = tc.MPSCircuit(n) + c.set_split_rules({"max_singular_values": 50}) + +The larger bond dimension we set, the better approximation ratio (of course the more computational cost we pay) + Split Two-qubit Gates ------------------------- diff --git a/examples/bp_benchmark.py b/examples/bp_benchmark.py index 734ddfb6..9d74d12e 100644 --- a/examples/bp_benchmark.py +++ b/examples/bp_benchmark.py @@ -9,6 +9,7 @@ import cirq import sympy import numpy as np +import pennylane as qml import tensorflow_quantum as tfq import tensorcircuit as tc @@ -123,6 +124,42 @@ def op_expectation(params, seed, n_qubits, depth): ) +def pennylane_approach(n_qubits=10, depth=10, n_circuits=100): + + dev = qml.device("lightning.qubit", wires=n_qubits) + gate_set = [qml.RX, qml.RY, qml.RZ] + + @qml.qnode(dev) + def rand_circuit(params, status): + for i in range(n_qubits): + qml.RY(np.pi / 4, wires=i) + + for j in range(depth): + for i in range(n_qubits): + gate_set[status[i, j]](params[j, i], wires=i) + + for i in range(n_qubits - 1): + qml.CZ(wires=[i, i + 1]) + + return qml.expval(qml.Hamiltonian([1.0], [qml.PauliZ(0) @ qml.PauliZ(1)], True)) + + gf = qml.grad(rand_circuit, argnum=0) + params = np.random.uniform(0, 2 * np.pi, size=[n_circuits, depth, n_qubits]) + status = np.random.choice(3, size=[n_circuits, depth, n_qubits]) + + g_results = [] + + for i in range(n_circuits): + g_results.append(gf(params[i], status[i])) + + g_results = np.stack(g_results) + + return np.std(g_results[:, 0, 0]) + + +benchmark(pennylane_approach) + + def tc_approach(n_qubits=10, depth=10, n_circuits=100): seed = tc.array_to_tensor( diff --git a/examples/mpsvsexact.py b/examples/mpsvsexact.py index 4a4f5cf1..6e0bfa4a 100644 --- a/examples/mpsvsexact.py +++ b/examples/mpsvsexact.py @@ -8,6 +8,7 @@ import tensorcircuit as tc tc.set_backend("tensorflow") +tc.set_dtype("complex128") def tfi_energy(c, n, j=1.0, h=-1.0): @@ -19,23 +20,12 @@ def tfi_energy(c, n, j=1.0, h=-1.0): return e -def tfi_energy_mps(c, n, j=1.0, h=-1.0): - e = 0.0 - for i in range(n): - e += h * c.expectation_single_gate(tc.gates.x(), i) - for i in range(n - 1): - e += j * c.expectation_two_gates_product( - tc.gates.z(), tc.gates.z(), i, (i + 1) % n - ) - return e - - def energy(param, mpsd=None): if mpsd is None: c = tc.Circuit(n) else: c = tc.MPSCircuit(n) - c.set_truncation_rule(max_singular_values=mpsd) + c.set_split_rules({"max_singular_values": mpsd}) for i in range(n): c.H(i) @@ -49,11 +39,8 @@ def energy(param, mpsd=None): ) for i in range(n): c.rx(i, theta=param[2 * j + 1, i]) - if mpsd is None: - e = tfi_energy(c, n) - else: - e = tfi_energy_mps(c, n) + e = tfi_energy(c, n) e = tc.backend.real(e) if mpsd is not None: fidelity = c._fidelity diff --git a/examples/parameter_shift.py b/examples/parameter_shift.py index b5fa966f..9ccaceb5 100644 --- a/examples/parameter_shift.py +++ b/examples/parameter_shift.py @@ -2,7 +2,11 @@ Demonstration on the correctness and efficiency of parameter shift gradient implementation """ +import sys import numpy as np + +sys.path.insert(0, "../") + import tensorcircuit as tc from tensorcircuit import experimental as E diff --git a/examples/qaoa_shot_noise.py b/examples/qaoa_shot_noise.py new file mode 100644 index 00000000..7b6e656e --- /dev/null +++ b/examples/qaoa_shot_noise.py @@ -0,0 +1,215 @@ +""" +QAOA with finite measurement shot noise +""" +from functools import partial +import numpy as np +from scipy import optimize +import networkx as nx +import optax +import cotengra as ctg +import tensorcircuit as tc +from tensorcircuit import experimental as E +from tensorcircuit.applications.graphdata import maxcut_solution_bruteforce + +K = tc.set_backend("jax") +# note this script only supports jax backend + +opt_ctg = ctg.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel="ray", + minimize="combo", + max_time=10, + max_repeats=128, + progbar=True, +) + +tc.set_contractor("custom", optimizer=opt_ctg, preprocessing=True) + + +def get_graph(n, d, weights=None): + g = nx.random_regular_graph(d, n) + if weights is not None: + i = 0 + for e in g.edges: + g[e[0]][e[1]]["weight"] = weights[i] + i += 1 + return g + + +def get_exact_maxcut_loss(g): + cut, _ = maxcut_solution_bruteforce(g) + totalw = 0 + for e in g.edges: + totalw += g[e[0]][e[1]].get("weight", 1) + loss = totalw - 2 * cut + return loss + + +def get_pauli_string(g): + n = len(g.nodes) + pss = [] + ws = [] + for e in g.edges: + l = [0 for _ in range(n)] + l[e[0]] = 3 + l[e[1]] = 3 + pss.append(l) + ws.append(g[e[0]][e[1]].get("weight", 1)) + return pss, ws + + +def generate_circuit(param, g, n, nlayers): + # construct the circuit ansatz + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayers): + c = tc.templates.blocks.QAOA_block(c, g, param[j, 0], param[j, 1]) + return c + + +def ps2z(psi): + # ps2xyz([1, 2, 2, 0]) = {"x": [0], "y": [1, 2], "z": []} + zs = [] # no x or y for QUBO problem + for i, j in enumerate(psi): + if j == 3: + zs.append(i) + return zs + + +rkey = K.get_random_state(42) + + +def main_benchmark_suite(n, nlayers, d=3, init=None): + g = get_graph(n, d, weights=np.random.uniform(size=[int(d * n / 2)])) + loss_exact = get_exact_maxcut_loss(g) + print("exact minimal loss by max cut bruteforce: ", loss_exact) + pss, ws = get_pauli_string(g) + if init is None: + init = np.random.normal(scale=0.1, size=[nlayers, 2]) + + @partial(K.jit, static_argnums=(2)) + def exp_val(param, key, shots=10000): + # expectation with shot noise + # ps, w: H = \sum_i w_i ps_i + # describing the system Hamiltonian as a weighted sum of Pauli string + c = generate_circuit(param, g, n, nlayers) + loss = 0 + s = c.state() + mc = tc.quantum.measurement_counts( + s, + counts=shots, + format="sample_bin", + random_generator=key, + jittable=True, + is_prob=False, + ) + for ps, w in zip(pss, ws): + loss += w * tc.quantum.correlation_from_samples(ps2z(ps), mc, c._nqubits) + return K.real(loss) + + @K.jit + def exp_val_analytical(param): + c = generate_circuit(param, g, n, nlayers) + loss = 0 + for ps, w in zip(pss, ws): + loss += w * c.expectation_ps(z=ps2z(ps)) + return K.real(loss) + + # 0. Exact result double check + + hm = tc.quantum.PauliStringSum2COO( + K.convert_to_tensor(pss), K.convert_to_tensor(ws), numpy=True + ) + hm = K.to_dense(hm) + e, _ = np.linalg.eigh(hm) + print("exact minimal loss via eigenstate: ", e[0]) + + # 1.1 QAOA with numerically exact expectation: gradient free + + print("QAOA without shot noise") + + exp_val_analytical_sp = tc.interfaces.scipy_interface( + exp_val_analytical, shape=[nlayers, 2], gradient=False + ) + + r = optimize.minimize( + exp_val_analytical_sp, + init, + method="Nelder-Mead", + options={"maxiter": 5000}, + ) + print(r) + print("double check the value?: ", exp_val_analytical_sp(r["x"])) + # cobyla seems to have issue to given consistent x and cobyla + + # 1.2 QAOA with numerically exact expectation: gradient based + + exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 + ) + opt = K.optimizer(optax.adam(exponential_decay_scheduler)) + param = init # zeros stall the gradient + param = tc.array_to_tensor(init, dtype=tc.rdtypestr) + exp_val_grad_analytical = K.jit(K.value_and_grad(exp_val_analytical)) + for i in range(1000): + e, gs = exp_val_grad_analytical(param) + param = opt.update(gs, param) + if i % 100 == 99: + print(e) + print("QAOA energy after gradient descent:", e) + + # 2.1 QAOA with finite shot noise: gradient free + + print("QAOA with shot noise") + + def exp_val_wrapper(param): + global rkey + rkey, skey = K.random_split(rkey) + # maintain stateless randomness in scipy optimize interface + return exp_val(param, skey) + + exp_val_sp = tc.interfaces.scipy_interface( + exp_val_wrapper, shape=[nlayers, 2], gradient=False + ) + + r = optimize.minimize( + exp_val_sp, + init, + method="Nelder-Mead", + options={"maxiter": 5000}, + ) + print(r) + + # the real energy position after optimization + + print("converged as: ", exp_val_analytical_sp(r["x"])) + + # 2.2 QAOA with finite shot noise: gradient based + + exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 + ) + opt = K.optimizer(optax.adam(exponential_decay_scheduler)) + param = tc.array_to_tensor(init, dtype=tc.rdtypestr) + exp_grad = E.parameter_shift_grad_v2( + exp_val, argnums=0, random_argnums=1, shifts=(0.001, 0.002) + ) + # parameter shift doesn't directly apply in QAOA case + rkey = K.get_random_state(42) + + for i in range(1000): + rkey, skey = K.random_split(rkey) + gs = exp_grad(param, skey) + param = opt.update(gs, param) + if i % 100 == 99: + rkey, skey = K.random_split(rkey) + print(exp_val(param, skey)) + + # the real energy position after optimization + + print("converged as:", exp_val_analytical(param)) + + +if __name__ == "__main__": + main_benchmark_suite(8, 4) diff --git a/examples/time_evolution.py b/examples/time_evolution.py new file mode 100644 index 00000000..c1d0e797 --- /dev/null +++ b/examples/time_evolution.py @@ -0,0 +1,71 @@ +""" +A simple static Hamiltonian evolution benchmark +""" + +import time +from functools import partial +import numpy as np +from scipy.integrate import solve_ivp +import tensorcircuit as tc +from tensorcircuit.experimental import hamiltonian_evol + +K = tc.set_backend("jax") +tc.set_dtype("complex128") + + +@partial(K.jit, static_argnums=1) +def total_z(psi, N): + return K.real( + K.sum(K.stack([tc.expectation([tc.gates.z(), i], ket=psi) for i in range(N)])) + ) + + +@K.jit +def naive_evol(t, h, psi0): + return K.reshape(K.expm(-1j * t * h) @ K.reshape(psi0, [-1, 1]), [-1]) + + +@K.jit +def hpsi(h, y): + return K.reshape(-1.0j * h @ K.reshape(y, [-1, 1]), [-1]) + + +def main(N): + psi0 = np.zeros([2**N]) + psi0[0] = 1 + psi0 = tc.array_to_tensor(psi0) + g = tc.templates.graphs.Line1D(N, pbc=False) + h = tc.quantum.heisenberg_hamiltonian(g, hzz=1, hxx=0, hyy=0, hx=1, sparse=False) + tlist = K.arange(0, 3, 0.1) + time0 = time.time() + for t in tlist: + psit = naive_evol(t, h, psi0) + psit /= K.norm(psit) + print(total_z(psit, N)) + time1 = time.time() + r = hamiltonian_evol(1.0j * tlist, h, psi0, callback=partial(total_z, N=N)) + print(r) + time2 = time.time() + + def fun(t, y): + y = tc.array_to_tensor(y) + return K.numpy(hpsi(h, y)) + + r = solve_ivp( + fun, (0, 3), psi0, method="DOP853", t_eval=K.numpy(tlist), rtol=1e-6, atol=1e-6 + ) + for psit in r.y.T: + print(total_z(psit, N)) + time3 = time.time() + print( + "matrix exponential:", + time1 - time0, + "tc fast implementation", + time2 - time1, + "scipy ode", + time3 - time2, + ) + + +if __name__ == "__main__": + main(10) diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index b1fc3eb7..e89590f7 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -3,6 +3,7 @@ __creator__ = "refraction-ray" from .cons import ( + backend, set_backend, set_dtype, set_contractor, diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 9044f369..3270a8ec 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -520,6 +520,26 @@ def to_openqasm(self, **kws: Any) -> str: """ return self.to_qiskit().qasm(**kws) # type: ignore + @classmethod + def from_openqasm( + cls, qasmstr: str, circuit_params: Optional[Dict[str, Any]] = None + ) -> "AbstractCircuit": + from qiskit.circuit import QuantumCircuit + + qiskit_circ = QuantumCircuit.from_qasm_str(qasmstr) + c = cls.from_qiskit(qiskit_circ, circuit_params=circuit_params) + return c + + @classmethod + def from_openqasm_file( + cls, file: str, circuit_params: Optional[Dict[str, Any]] = None + ) -> "AbstractCircuit": + from qiskit.circuit import QuantumCircuit + + qiskit_circ = QuantumCircuit.from_qasm_file(file) + c = cls.from_qiskit(qiskit_circ, circuit_params=circuit_params) + return c + def draw(self, **kws: Any) -> Any: """ Visualise the circuit. @@ -543,7 +563,11 @@ def draw(self, **kws: Any) -> Any: @classmethod def from_qiskit( - cls, qc: Any, n: Optional[int] = None, inputs: Optional[List[float]] = None + cls, + qc: Any, + n: Optional[int] = None, + inputs: Optional[List[float]] = None, + circuit_params: Optional[Dict[str, Any]] = None, ) -> "AbstractCircuit": """ Import Qiskit QuantumCircuit object as a ``tc.Circuit`` object. @@ -571,7 +595,7 @@ def from_qiskit( if n is None: n = qc.num_qubits - return qiskit2tc(qc.data, n, inputs, is_dm=cls.is_dm) # type: ignore + return qiskit2tc(qc.data, n, inputs, is_dm=cls.is_dm, circuit_params=circuit_params) # type: ignore def vis_tex(self, **kws: Any) -> str: """ diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 148cc2ad..c22c89ec 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -648,10 +648,12 @@ def sample_expectation_ps( :return: [description] :rtype: Tensor """ + inputs_nodes, _ = self._copy_state_tensor() + inputs = inputs_nodes[0].tensor if self.is_dm is False: - c = type(self)(self._nqubits, mps_inputs=self.quvector()) # type: ignore + c = type(self)(self._nqubits, inputs=inputs) # type: ignore else: - c = type(self)(self._nqubits, mpo_dminputs=self.get_dm_as_quoperator()) # type: ignore + c = type(self)(self._nqubits, dminputs=inputs) # type: ignore if x is None: x = [] if y is None: diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index c3d53d37..2a6d1fcc 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -393,6 +393,7 @@ def _unitary_kraus_template( sites = len(index) kraus = [k.tensor if isinstance(k, tn.Node) else k for k in kraus] kraus = [gates.array_to_tensor(k) for k in kraus] + kraus = [backend.reshapem(k) for k in kraus] if prob is None: prob = [ backend.real(backend.trace(backend.adjoint(k) @ k) / k.shape[0]) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 290bc93c..7cf0d474 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -3,7 +3,7 @@ """ from functools import partial -from typing import Any, Callable, Optional, Sequence, Union +from typing import Any, Callable, Optional, Tuple, Sequence, Union import numpy as np @@ -210,6 +210,7 @@ def parameter_shift_grad( f: Callable[..., Tensor], argnums: Union[int, Sequence[int]] = 0, jit: bool = False, + shifts: Tuple[float, float] = (np.pi / 2, 2), ) -> Callable[..., Tensor]: """ similar to `grad` function but using parameter shift internally instead of AD, @@ -223,6 +224,9 @@ def parameter_shift_grad( :param jit: whether jit the original function `f` at the beginning, defaults to False :type jit: bool, optional + :param shifts: two floats for the delta shift on the numerator and dominator, + defaults to (pi/2, 2) for parameter shift + :type shifts: Tuple[float, float] :return: the grad function :rtype: Callable[..., Tensor] """ @@ -242,14 +246,14 @@ def grad_f(*args: Any, **kws: Any) -> Any: onehot = backend.eye(size) onehot = backend.cast(onehot, args[i].dtype) onehot = backend.reshape(onehot, [size] + list(shape)) - onehot = np.pi / 2 * onehot + onehot = shifts[0] * onehot nargs = list(args) arg = backend.reshape(args[i], [1] + list(shape)) batched_arg = backend.tile(arg, [size] + [1 for _ in shape]) nargs[i] = batched_arg + onehot nargs2 = list(args) nargs2[i] = batched_arg - onehot - r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / 2.0 + r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / shifts[1] r = backend.reshape(r, shape) grad_values.append(r) if len(argnums) > 1: # type: ignore @@ -264,6 +268,7 @@ def parameter_shift_grad_v2( argnums: Union[int, Sequence[int]] = 0, jit: bool = False, random_argnums: Optional[Sequence[int]] = None, + shifts: Tuple[float, float] = (np.pi / 2, 2), ) -> Callable[..., Tensor]: """ similar to `grad` function but using parameter shift internally instead of AD, @@ -279,9 +284,13 @@ def parameter_shift_grad_v2( :param jit: whether jit the original function `f` at the beginning, defaults to False :type jit: bool, optional + :param shifts: two floats for the delta shift on the numerator and dominator, + defaults to (pi/2, 2) for parameter shift + :type shifts: Tuple[float, float] :return: the grad function :rtype: Callable[..., Tensor] """ + # TODO(@refraction-ray): replace with new status support for the sample API if jit is True: f = backend.jit(f) @@ -305,7 +314,7 @@ def grad_f(*args: Any, **kws: Any) -> Any: onehot = backend.eye(size) onehot = backend.cast(onehot, args[i].dtype) onehot = backend.reshape(onehot, [size] + list(shape)) - onehot = np.pi / 2 * onehot + onehot = shifts[0] * onehot nargs = list(args) arg = backend.reshape(args[i], [1] + list(shape)) batched_arg = backend.tile(arg, [size] + [1 for _ in shape]) @@ -325,7 +334,7 @@ def grad_f(*args: Any, **kws: Any) -> Any: key, subkey = backend.random_split(key) keys.append(subkey) nargs2[j] = backend.stack(keys) - r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / 2.0 + r = (vfs[i](*nargs, **kws) - vfs[i](*nargs2, **kws)) / shifts[1] r = backend.reshape(r, shape) grad_values.append(r) if len(argnums) > 1: # type: ignore @@ -333,3 +342,44 @@ def grad_f(*args: Any, **kws: Any) -> Any: return grad_values[0] return grad_f + + +# TODO(@refraction-ray): add SPSA gradient wrapper similar to parameter shift + + +def hamiltonian_evol( + tlist: Tensor, + h: Tensor, + psi0: Tensor, + callback: Optional[Callable[..., Any]] = None, +) -> Tensor: + """ + Fast implementation of static full Hamiltonian evolution + + :param tlist: _description_ + :type tlist: Tensor + :param h: _description_ + :type h: Tensor + :param psi0: _description_ + :type psi0: Tensor + :param callback: _description_, defaults to None + :type callback: Optional[Callable[..., Any]], optional + :return: Tensor + :rtype: result dynamics on ``tlist`` + """ + es, u = backend.eigh(h) + utpsi0 = backend.reshape( + backend.transpose(u) @ backend.reshape(psi0, [-1, 1]), [-1] + ) + + @backend.jit + def _evol(t: Tensor) -> Tensor: + ebetah_utpsi0 = backend.exp(-t * es) * utpsi0 + psi_exact = backend.conj(u) @ backend.reshape(ebetah_utpsi0, [-1, 1]) + psi_exact = backend.reshape(psi_exact, [-1]) + psi_exact = psi_exact / backend.norm(psi_exact) + if callback is None: + return psi_exact + return callback(psi_exact) + + return backend.stack([_evol(t) for t in tlist]) diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index 0c6bee10..81a3414c 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -144,7 +144,6 @@ def __init__( # because the gates are immediately absorted into the MPS when applied, # so it is impossible to remember the initial structure - # @property def get_bond_dimensions(self) -> Tensor: """ Get the MPS bond dimensions @@ -154,7 +153,6 @@ def get_bond_dimensions(self) -> Tensor: """ return self._mps.bond_dimensions - # @property def get_tensors(self) -> List[Tensor]: """ Get the MPS tensors @@ -164,7 +162,6 @@ def get_tensors(self) -> List[Tensor]: """ return self._mps.tensors # type: ignore - # @property def get_center_position(self) -> Optional[int]: """ Get the center position of the MPS @@ -206,15 +203,7 @@ def apply_single_gate(self, gate: Gate, index: int) -> None: :param index: Qubit index of the gate :type index: int """ - # TODO(@SUSYUSTC): make it jittable - tensor = backend.numpy(gate.tensor) - prod = tensor.dot(tensor.T.conj()) - I = np.eye(prod.shape[0]) - err_max = np.max(np.abs(prod - I)) - # TODO(@SUSYUSTC): change this number to 1e-12 after the dtype bug fixed - is_unitary = err_max < 1e-6 - if not is_unitary: - self.position(index) + self.position(index) self._mps.apply_one_site_gate(gate.tensor, index) def apply_adjacent_double_gate( @@ -299,6 +288,11 @@ def apply_double_gate( :param index2: The second qubit index of the gate :type index2: int """ + assert index1 != index2 + if index1 > index2: + newgate = Gate(backend.transpose(gate.tensor, [1, 0, 3, 2])) + self.apply_double_gate(newgate, index2, index1) + return if split is None: split = self.split # apply N SWAP gates, the required gate, N SWAP gates sequentially on adjacent gates @@ -338,16 +332,19 @@ def gate_to_MPO( # --i--I--j-- = \delta_{i,j} \delta_{a,b} # | # b + + # index must be ordered + assert np.all(np.diff(index) > 0) index_left = np.min(index) if isinstance(gate, tn.Node): gate = backend.copy(gate.tensor) index = np.array(index) - index_left nindex = len(index) # transform gate from (in1, in2, ..., out1, out2 ...) to + # (in1, out1, in2, out2, ...) order = tuple(np.arange(2 * nindex).reshape((2, nindex)).T.flatten()) shape = (4,) * nindex gate = backend.reshape(backend.transpose(gate, order), shape) - # (in1, out1, in2, out2, ...) argsort = np.argsort(index) # reorder the gate according to the site positions gate = backend.transpose(gate, tuple(argsort)) @@ -517,9 +514,19 @@ def apply_nqubit_gate( *index: int, split: Optional[Dict[str, Any]] = None, ) -> None: + # TODO(@SUSYUSTC): jax autograd is wrong on this function """ Apply a n-qubit gate by transforming the gate to MPO """ + ordered = np.all(np.diff(index) > 0) + if not ordered: + order = np.argsort(index) + order2 = order + len(index) # type: ignore + order_all = order.tolist() + order2.tolist() # type: ignore + newgate = backend.transpose(gate.tensor, order_all) + index = np.sort(index).tolist() + self.apply_nqubit_gate(newgate, *index, split=split) + return if split is None: split = self.split MPO, index_left = self.gate_to_MPO(gate, *index) @@ -588,10 +595,14 @@ def mid_measurement(self, index: int, keep: int = 0) -> None: """ # normalization not guaranteed assert keep in [0, 1] - discard = 1 - keep - self.position(index) - # TODO(@SUSYUSTC): make it compatible with other backends - self._mps.tensors[index][:, discard, :] = 0 + gate = backend.zeros((2, 2), dtype=dtypestr) + gate = backend.scatter( + gate, + backend.convert_to_tensor([[keep, keep]]), + backend.convert_to_tensor(np.array([1.0], dtype=dtypestr)), + ) + gate = Gate(gate) + self.apply_single_gate(gate, index) def is_valid(self) -> bool: """ @@ -911,6 +922,7 @@ def measure( :return: The sample output and probability (optional) of the quantum line. :rtype: Tuple[Tensor, Tensor] """ + """ is_sorted = np.all(np.sort(index) == np.array(index)) if not is_sorted: order = backend.convert_to_tensor(np.argsort(index).tolist()) @@ -919,6 +931,7 @@ def measure( ) return backend.convert_to_tensor([sample[i] for i in order]), p # set the center to the left side, then gradually move to the right and do measurement at sites + """ mps = self.copy() up = backend.convert_to_tensor(np.array([1, 0]).astype(dtypestr)) down = backend.convert_to_tensor(np.array([0, 1]).astype(dtypestr)) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 21796581..d6cf67c1 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -60,7 +60,6 @@ def apply_qir_with_noise(c, qir, noise_conf, status=None): # type: ignore if d["index"] in noise_conf.nc[d["name"]]: noise_kraus = noise_conf.nc[d["name"]][d["index"]] - print(*d["index"]) c.general_kraus(noise_kraus, *d["index"]) else: @@ -74,7 +73,7 @@ def apply_qir_with_noise(c, qir, noise_conf, status=None): # type: ignore noise_kraus = noise_conf.nc[d["name"]][d["index"]] if noise_kraus.is_unitary is True: - c.general_kraus( + c.unitary_kraus( noise_kraus, *d["index"], status=status[quantum_index] diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 060212d2..226a0532 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -194,6 +194,7 @@ def qiskit2tc( n: int, inputs: Optional[List[float]] = None, is_dm: bool = False, + circuit_params: Optional[Dict[str, Any]] = None, ) -> Any: r""" Generate a tensorcircuit circuit using the quantum circuit data in qiskit. @@ -220,10 +221,14 @@ def qiskit2tc( Circ = DMCircuit2 else: Circ = Circuit # type: ignore - if inputs is None: - tc_circuit: Any = Circ(n) - else: - tc_circuit = Circ(n, inputs=inputs) + if circuit_params is None: + circuit_params = {} + if "nqubits" not in circuit_params: + circuit_params["nqubits"] = n + if inputs is not None: + circuit_params["inputs"] = inputs + + tc_circuit: Any = Circ(**circuit_params) for gate_info in qcdata: idx = [qb.index for qb in gate_info[1]] gate_name = gate_info[0].name @@ -250,7 +255,7 @@ def qiskit2tc( getattr(tc_circuit, gate_name[:-1])(*idx) elif gate_name in ["cx_o0", "cy_o0", "cz_o0"]: getattr(tc_circuit, "o" + gate_name[1])(*idx) - elif gate_name in ["rx", "ry", "rz", "crx", "cry", "crz"]: + elif gate_name in ["rx", "ry", "rz", "crx", "cry", "crz", "rxx", "ryy", "rzz"]: getattr(tc_circuit, gate_name)(*idx, theta=parameters) elif gate_name in ["crx_o0", "cry_o0", "crz_o0"]: getattr(tc_circuit, "o" + gate_name[1:-3])(*idx, theta=parameters) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 208a3237..1738f91c 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -976,6 +976,8 @@ def test_qiskit2tc(): qisc.cz(0, 1, ctrl_state=0) qisc.cy(0, 1, ctrl_state=0) qisc.cx(0, 1, ctrl_state=0) + qisc.rxx(0.3, 1, 2) + qisc.rzz(-0.8, 2, 0) qisc.u(0.3, 0.9, -1.2, 2) qisc.rx(np.random.uniform(), 1) qisc.ry(np.random.uniform(), 2) @@ -1219,4 +1221,12 @@ def test_to_openqasm(): c.cnot(2, 1) c.rzz(0, 1, theta=-1.0) c.ccx(1, 2, 0) + c.u(2, theta=0.5, lbd=1.3) print(c.to_openqasm(formatted=True)) + s = c.to_openqasm() + c1 = tc.Circuit.from_openqasm(s) + print(c1.draw()) + np.testing.assert_allclose(c.state(), c1.state()) + c.to_openqasm(filename="test.qasm") + c2 = tc.Circuit.from_openqasm_file("test.qasm") + np.testing.assert_allclose(c.state(), c2.state()) diff --git a/tests/test_mpscircuit.py b/tests/test_mpscircuit.py index 52d07d6c..7050e7af 100644 --- a/tests/test_mpscircuit.py +++ b/tests/test_mpscircuit.py @@ -5,7 +5,6 @@ import sys import os import numpy as np -import scipy import pytest from pytest_lazyfixture import lazy_fixture as lf @@ -18,56 +17,46 @@ import tensorcircuit as tc -N = 16 -D = 100 +N = 8 +D = 6 split = tc.cons.split_rules(max_singular_values=D) type_test_circuits = Tuple[ tc.Circuit, Tensor, tc.MPSCircuit, Tensor, tc.MPSCircuit, Tensor ] -def reproducible_unitary(n): - A = np.arange(n**2).reshape((n, n)) - A = A + np.sin(A) * 1j - A = A - A.conj().T - return scipy.linalg.expm(A).astype(tc.dtypestr) +def reproducible_unitary(n, param): + exp2n = 2**n + A = tc.backend.cast( + tc.backend.reshape(tc.backend.arange(exp2n**2), (exp2n, exp2n)), tc.dtypestr + ) + A = A + tc.backend.sin(A) * param * 1j + A = A - tc.backend.conj(tc.backend.transpose(A)) + return tc.backend.reshape(tc.backend.expm(A), (2,) * n * 2) -def get_test_circuits(full) -> type_test_circuits: - O1 = tc.gates.any(reproducible_unitary(2).reshape((2, 2))) - O2 = tc.gates.any(reproducible_unitary(4).reshape((2, 2, 2, 2))) - O3 = tc.gates.any(reproducible_unitary(8).reshape((2, 2, 2, 2, 2, 2))) +def simulate(c, check=True, params=None): + if params is None: + params = tc.backend.ones((3,), dtype=tc.dtypestr) + O1 = tc.gates.any(reproducible_unitary(1, params[0])) + O2 = tc.gates.any(reproducible_unitary(2, params[1])) + O3 = tc.gates.any(reproducible_unitary(3, params[2])) # Construct a complicated circuit by Circuit and MPSCircuit and compare - if full: - - def rangei(j, N): - return range(0, N - 1) - - else: - - def rangei(j, N): - return range(j, N - 1 - j) - - def simulate(c): - c.H(0) - # create as much correlation as possible - for j in range(N // 2): - for i in rangei(j, N): - c.apply(O2.copy(), i, i + 1) - c.apply(O1.copy(), i) - # test non-adjacent double gates - c.apply(O2.copy(), N // 2 - 1, N // 2 + 1) - c.apply(O3.copy(), int(N * 0.2), int(N * 0.4), int(N * 0.6)) - if isinstance(c, tc.MPSCircuit): - np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) - c.apply(O2.copy(), N // 2 - 2, N // 2 + 2) - c.apply(O3.copy(), int(N * 0.4), int(N * 0.6), int(N * 0.8)) - if isinstance(c, tc.MPSCircuit): - np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) - c.cz(2, 3) + c.H(0) + # create as much correlation as possible + for i in range(0, N - 1, 2): + c.apply(O2.copy(), i, i + 1) + c.apply(O1.copy(), i) + c.apply(O3.copy(), int(N * 0.1), int(N * 0.5), int(N * 0.9)) + c.apply(O2.copy(), 1, N - 2) + if check and isinstance(c, tc.MPSCircuit): + np.testing.assert_allclose(np.abs(c._mps.check_canonical()), 0, atol=1e-12) + c.cz(2, 3) + +def get_test_circuits() -> type_test_circuits: c = tc.Circuit(N) simulate(c) w_c = c.wavefunction() @@ -133,10 +122,13 @@ def do_test_truncation( np.abs(tc.backend.numpy(w_mps).conj().dot(tc.backend.numpy(w_c))) ** 2 ) estimated_fedility = tc.backend.numpy(mps._fidelity) - print(real_fedility) - print(estimated_fedility) - np.testing.assert_allclose(real_fedility, real_fedility_ref, atol=1e-8) - np.testing.assert_allclose(estimated_fedility, estimated_fedility_ref, atol=1e-8) + print(real_fedility, estimated_fedility) + if real_fedility_ref is not None: + np.testing.assert_allclose(real_fedility, real_fedility_ref, atol=1e-5) + if estimated_fedility_ref is not None: + np.testing.assert_allclose( + estimated_fedility, estimated_fedility_ref, atol=1e-5 + ) def do_test_amplitude(test_circuits: type_test_circuits): @@ -165,14 +157,14 @@ def do_test_expectation(test_circuits: type_test_circuits): w_mps_exact, ) = test_circuits - single_gate = (tc.gates.z(), [11]) + single_gate = (tc.gates.z(), [3]) tensor = (np.sin(np.arange(16)) + np.cos(np.arange(16)) * 1j).reshape((2, 2, 2, 2)) double_gate_nonunitary = ( tc.gates.Gate(tc.backend.convert_to_tensor(tensor)), [2, 6], ) double_gate = (tc.gates.cnot(), [2, 6]) - triple_gate = (tc.gates.toffoli(), [1, 5, 9]) + triple_gate = (tc.gates.toffoli(), [7, 1, 5]) gates = [single_gate, double_gate_nonunitary, triple_gate] exp_mps = mps_exact.expectation(*gates) @@ -181,8 +173,8 @@ def do_test_expectation(test_circuits: type_test_circuits): # ps x = [0, 2] - y = [1, 3, 5] - z = [6, 8, 10] + y = [5, 3, 1] + z = [6, 4] exp_mps = mps_exact.expectation_ps(x=x, y=y, z=z) exp_c = c.expectation_ps(x=x, y=y, z=z) np.testing.assert_allclose(exp_mps, exp_c, atol=1e-7) @@ -216,8 +208,8 @@ def do_test_fromwavefunction(external_wavefunction, relative_err_ref): s = np.linalg.svd(w_external.reshape((2 ** (N // 2), 2 ** (N // 2))))[1] theoretical_upper_limit = np.sum(s[0:D] ** 2) relative_err = np.log((1 - real_fedility) / (1 - theoretical_upper_limit)) - print(relative_err) - np.testing.assert_allclose(relative_err, 0.11, atol=1e-2) + if relative_err_ref is not None: + np.testing.assert_allclose(relative_err, relative_err_ref, atol=1e-4) def do_test_proj(test_circuits: type_test_circuits, external_wavefunction): @@ -273,22 +265,17 @@ def do_test_measure(test_circuits: type_test_circuits): mps_exact, w_mps_exact, ) = test_circuits - index = [6, 5, 2, 9] - status = tc.backend.convert_to_tensor([0.1, 0.3, 0.5, 0.7]) + index = [6, 5, 2, 1] + status = tc.backend.convert_to_tensor([0.1, 0.3, 0.7, 0.9]) result_c = c.measure(*index, with_prob=True, status=status) - result_mps = mps.measure(*index, with_prob=True, status=status) result_mps_exact = mps_exact.measure(*index, with_prob=True, status=status) - np.testing.assert_allclose(result_mps[0], result_c[0], atol=1e-8) np.testing.assert_allclose(result_mps_exact[0], result_c[0], atol=1e-8) - np.testing.assert_allclose(result_mps[1], result_c[1], atol=1e-4) np.testing.assert_allclose(result_mps_exact[1], result_c[1], atol=1e-8) def test_MPO_conversion(highp, tfb): - O3 = tc.backend.convert_to_tensor( - reproducible_unitary(8).reshape((2, 2, 2, 2, 2, 2)) - ) - I = tc.backend.convert_to_tensor(np.eye(2).astype("complex128")) + O3 = reproducible_unitary(3, 1.0) + I = tc.backend.eye(2, dtype=tc.dtypestr) gate = tc.gates.Gate(O3) MPO3, _ = tc.MPSCircuit.gate_to_MPO(gate, 2, 3, 4) @@ -308,25 +295,47 @@ def test_MPO_conversion(highp, tfb): @pytest.mark.parametrize( "backend, dtype", [(lf("tfb"), lf("highp")), (lf("jaxb"), lf("highp"))] ) -def test_circuits_1(backend, dtype): - import time - - begin = time.time() - circuits = get_test_circuits(False) - print("time", time.time() - begin) +def test_circuits(backend, dtype): + circuits = get_test_circuits() do_test_canonical(circuits) do_test_wavefunction(circuits) - do_test_truncation(circuits, 0.9987293417932497, 0.999440840610151) + do_test_truncation(circuits, 0.902663090851, 0.910305380327) do_test_amplitude(circuits) do_test_expectation(circuits) external = external_wavefunction() - do_test_fromwavefunction(external, 0.1185) + do_test_fromwavefunction(external, 0.276089) do_test_proj(circuits, external) do_test_tensor_input(circuits) do_test_measure(circuits) - print("time", time.time() - begin) -def test_circuits_2(highp): - circuits = get_test_circuits(True) - do_test_truncation(circuits, 0.9401410770899974, 0.9654331011546374) +@pytest.mark.parametrize("backend, dtype", [(lf("tfb"), lf("highp"))]) +def test_circuits_jit(backend, dtype): + def expec(params): + mps = tc.MPSCircuit(N, split=split) + simulate(mps, check=False, params=params) + x = [0, 2] + y = [5, 3, 1] + z = [6, 4] + exp = mps.expectation_ps(x=x, y=y, z=z) + return tc.backend.real(exp) + + params = tc.backend.ones((3,), dtype=tc.dtypestr) + expec_vg = tc.backend.value_and_grad(expec) + expec_vg_jit = tc.backend.jit(expec_vg) + exp = expec(params) + exp_jit, exp_grad_jit = expec_vg_jit(params) + dir = tc.backend.convert_to_tensor(np.array([1.0, 2.0, 3.0], dtype=tc.dtypestr)) + epsilon = 1e-6 + exp_p = expec(params + dir * epsilon) + exp_m = expec(params - dir * epsilon) + exp_grad_dir_numerical = (exp_p - exp_m) / (epsilon * 2) + exp_grad_dir_jit = tc.backend.real(tc.backend.sum(exp_grad_jit * dir)) + np.testing.assert_allclose( + tc.backend.numpy(exp), tc.backend.numpy(exp_jit), atol=1e-10 + ) + np.testing.assert_allclose( + tc.backend.numpy(exp_grad_dir_numerical), + tc.backend.numpy(exp_grad_dir_jit), + atol=1e-6, + ) diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index 2ae28445..f02b991c 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -177,6 +177,8 @@ def test_noisemodel_qubit(backend): @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_dep(backend): c = tc.Circuit(2) + c.rx(0, theta=0.4) + c.rx(1, theta=0.8) c.cnot(0,1) @@ -197,6 +199,10 @@ def test_dep(backend): print(value) + dmc = tc.DMCircuit(2) + dmc.rx(0, theta=0.4) + dmc.rx(1, theta=0.8) + dmc.cnot(0,1) @@ -242,12 +248,11 @@ def test_dep(backend): print("2",c.expectation_ps(z=[0,1])) + dmc = tc.DMCircuit(2) dmc.general_kraus(kraus, 0,1) print("2",dmc.expectation_ps(z=[0,1])) dmc = tc.DMCircuit(2) - dmc.cnot(0,1) - dmc.generaldepolarizing(0,1,p=0.01, num_qubits=2) print("2",dmc.expectation_ps(z=[0,1])) From 5d514df6ccec5b4a071a6b851ae8dcaa2c9d07cb Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 12 Nov 2022 10:59:09 +0800 Subject: [PATCH 068/725] try devcontainer --- .devcontainer/Dockerfile | 22 ++++++++++++++++ .devcontainer/devcontainer.json | 45 +++++++++++++++++++++++++++++++++ requirements/requirements.txt | 3 ++- 3 files changed, 69 insertions(+), 1 deletion(-) create mode 100644 .devcontainer/Dockerfile create mode 100644 .devcontainer/devcontainer.json diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 00000000..7e23fdf3 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,22 @@ +# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.140.1/containers/python-3/.devcontainer/base.Dockerfile + +# [Choice] Python version: 3, 3.8, 3.7, 3.6 +ARG VARIANT="3" +FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT} + +# [Option] Install Node.js +ARG INSTALL_NODE="true" +ARG NODE_VERSION="lts/*" +RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "source /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi + +# [Optional] If your pip requirements rarely change, uncomment this section to add them to the image. +COPY requirements/requirements.txt /tmp/pip-tmp/ +RUN pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \ + && rm -rf /tmp/pip-tmp + +# [Optional] Uncomment this section to install additional OS packages. +# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \ +# && apt-get -y install --no-install-recommends + +# [Optional] Uncomment this line to install global node packages. +# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g " 2>&1 \ No newline at end of file diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 00000000..a36fae8d --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,45 @@ +// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at: +// https://github.com/microsoft/vscode-dev-containers/tree/v0.140.1/containers/python-3 +{ + "name": "TensorCircuit User", + "build": { + "dockerfile": "Dockerfile", + "context": "..", + "args": { + // Update 'VARIANT' to pick a Python version: 3, 3.6, 3.7, 3.8 + "VARIANT": "3.8", + // Options + "INSTALL_NODE": "true", + "NODE_VERSION": "lts/*" + } + }, + + // Set *default* container specific settings.json values on container create. + "settings": { + "terminal.integrated.shell.linux": "/bin/bash", + "python.pythonPath": "/usr/local/bin/python", + "python.linting.enabled": true, + "python.linting.pylintEnabled": true, + "python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8", + "python.formatting.blackPath": "/usr/local/py-utils/bin/black", + "python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf", + "python.linting.banditPath": "/usr/local/py-utils/bin/bandit", + "python.linting.flake8Path": "/usr/local/py-utils/bin/flake8", + "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy", + "python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle", + "python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle", + "python.linting.pylintPath": "/usr/local/py-utils/bin/pylint" + }, + + // Add the IDs of extensions you want installed when the container is created. + "extensions": ["ms-python.python", "ms-toolsai.jupyter"] + + // Use 'forwardPorts' to make a list of ports inside the container available locally. + // "forwardPorts": [], + + // Use 'postCreateCommand' to run commands after the container is created. + // "postCreateCommand": "pip3 install --user -r requirements.txt", + + // Uncomment to connect as a non-root user. See https://aka.ms/vscode-remote/containers/non-root. + // "remoteUser": "vscode" +} diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 69ddfea0..92181d03 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -7,4 +7,5 @@ graphviz jax jaxlib networkx -optax \ No newline at end of file +optax +qiskit \ No newline at end of file From bc8682df2c0e9ef7b3abe86b994042e95729b06d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 12 Nov 2022 16:26:31 +0800 Subject: [PATCH 069/725] update devcontainer --- .devcontainer/Dockerfile | 3 +++ requirements/requirements-extra.txt | 3 ++- requirements/requirements.txt | 3 +-- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 7e23fdf3..f0216aae 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -11,7 +11,10 @@ RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "source /usr/local/shar # [Optional] If your pip requirements rarely change, uncomment this section to add them to the image. COPY requirements/requirements.txt /tmp/pip-tmp/ +COPY requirements/requirements-extra.txt /tmp/pip-tmp/ + RUN pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \ + && pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements-extra.txt \ && rm -rf /tmp/pip-tmp # [Optional] Uncomment this section to install additional OS packages. diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 74b78e9e..8a0cda90 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,3 +1,4 @@ # extra dependencies for ci qiskit -torch \ No newline at end of file +torch +jupyter \ No newline at end of file diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 92181d03..69ddfea0 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -7,5 +7,4 @@ graphviz jax jaxlib networkx -optax -qiskit \ No newline at end of file +optax \ No newline at end of file From b0b3bf31ee9e6ce8b47f6d35393b8a017c5587c6 Mon Sep 17 00:00:00 2001 From: JAllcock Date: Tue, 15 Nov 2022 16:52:47 +0800 Subject: [PATCH 070/725] Update README.md Fixed README typos. --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 94670343..1a3ea07e 100644 --- a/README.md +++ b/README.md @@ -78,13 +78,13 @@ print(g(theta)) ## Install -The package is purely written in Python and can be obtained via pip as: +The package is written in pure Python and can be obtained via pip as: ```python pip install tensorcircuit ``` -And we recommend you install this package with tensorflow also installed as: +We recommend you install this package with tensorflow also installed as: ```python pip install tensorcircuit[tensorflow] @@ -92,7 +92,7 @@ pip install tensorcircuit[tensorflow] Other optional dependencies include `[torch]`, `[jax]` and `[qiskit]`. -For nightly build of tensorcircuit with new features, try: +For the nightly build of tensorcircuit with new features, try: ```python pip uninstall tensorcircuit @@ -121,13 +121,13 @@ We also have [Docker support](/docker). ## Citing TensorCircuit -This project is released by [Tencent Quantum Lab](https://quantum.tencent.com/) and is currently maintained by [Shi-Xin Zhang](https://github.com/refraction-ray) with contributions from the lab and open source community. +This project is released by [Tencent Quantum Lab](https://quantum.tencent.com/) and is currently maintained by [Shi-Xin Zhang](https://github.com/refraction-ray) with contributions from the lab and the open source community. If this project helps in your research, please cite our software whitepaper: [TensorCircuit: a Quantum Software Framework for the NISQ Era](https://arxiv.org/abs/2205.10091) -which is also a good introduction for the software. +which is also a good introduction to the software. ## Contributing @@ -135,7 +135,7 @@ For contribution guidelines and notes, see [CONTRIBUTING](/CONTRIBUTING.md). We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues), [PRs](https://github.com/tencent-quantum-lab/tensorcircuit/pulls), and [discussions](https://github.com/tencent-quantum-lab/tensorcircuit/discussions) from everyone, and these are all hosted on GitHub. -## Researches and Applications +## Research and Applications ### DQAS From ef04f61009cf395bb2751c70521f8756a7614fa5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 17 Nov 2022 16:36:28 +0800 Subject: [PATCH 071/725] add very rough error handling --- tensorcircuit/cloud/tencent.py | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 5335d479..dc020d2c 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -19,11 +19,20 @@ def tencent_headers(token: Optional[str] = None) -> Dict[str, str]: return headers +def error_handling(r: Dict[str, Any]) -> Dict[str, Any]: + if not isinstance(r, dict): + raise ValueError("failed to get legal response from the server") + if "err" in r: + raise ValueError(r["err"]) + return r + + def list_devices(token: Optional[str] = None) -> List[Device]: json: Dict[Any, Any] = {} r = rpost_json( tencent_base_url + "device/find", json=json, headers=tencent_headers(token) ) + r = error_handling(r) ds = r["devices"] rs = [] for d in ds: @@ -36,6 +45,7 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An r = rpost_json( tencent_base_url + "device/detail", json=json, headers=tencent_headers(token) ) + r = error_handling(r) if "device" in r: return r["device"] # type: ignore else: @@ -90,8 +100,12 @@ def submit_task( r = rpost_json( tencent_base_url + "task/submit", json=json, headers=tencent_headers(token) ) + r = error_handling(r) try: - rtn = [Task(id_=t["id"], device=device) for t in r["tasks"]] + rtn = [] + for t in r["tasks"]: + t = error_handling(t) + rtn.append(Task(id_=t["id"], device=device)) if len(rtn) == 1: return rtn[0] # type: ignore else: @@ -106,6 +120,7 @@ def resubmit_task(task: Task, token: str) -> Task: r = rpost_json( tencent_base_url + "task/start", json=json, headers=tencent_headers(token) ) + r = error_handling(r) try: return Task(id_=r["tasks"][0]["id"]) @@ -118,6 +133,7 @@ def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: r = rpost_json( tencent_base_url + "task/detail", json=json, headers=tencent_headers(token) ) + r = error_handling(r) try: if "result" in r["task"]: if "counts" in r["task"]["result"]: From 581f73fe359d6720d7525a6103f0e4e343330d75 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 18 Nov 2022 10:51:11 +0800 Subject: [PATCH 072/725] add list tasks --- tensorcircuit/cloud/abstraction.py | 10 +++++++++ tensorcircuit/cloud/apis.py | 19 ++++++++++++++++ tensorcircuit/cloud/tencent.py | 36 ++++++++++++++++++++++++++++-- tests/test_cloud.py | 27 +++++++++++++++++----- 4 files changed, 85 insertions(+), 7 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 402cd83f..e2cd260c 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -56,6 +56,11 @@ def get_device(self, device: Optional[Union[str, "Device"]]) -> "Device": return get_device(self, device) + def list_tasks(self, **filter_kws: Any) -> List["Task"]: + from .apis import list_tasks + + return list_tasks(self, **filter_kws) + sep = "::" @@ -137,6 +142,11 @@ def get_task(self, taskid: str) -> "Task": return get_task(taskid, device=self) + def list_tasks(self, **filter_kws: Any) -> List["Task"]: + from .apis import list_tasks + + return list_tasks(self.provider, self, **filter_kws) + class Task: def __init__(self, id_: str, device: Optional[Device] = None): diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 208bffb5..7378a932 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -250,3 +250,22 @@ def resubmit_task( return tencent.resubmit_task(task, token) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def list_tasks( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + token: Optional[str] = None, + **filter_kws: Any, +) -> List[Task]: + if provider is None: + provider = default_provider + provider = Provider.from_name(provider) + if token is None: + token = provider.get_token() # type: ignore + if device is not None: + device = Device.from_name(device) + if provider.name == "tencent": # type: ignore + return tencent.list_tasks(device, token, **filter_kws) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index dc020d2c..c87c55ea 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional, Sequence, Union from json import dumps +import logging from .config import tencent_base_url from .utils import rpost_json @@ -11,6 +12,8 @@ from ..abstractcircuit import AbstractCircuit from ..utils import is_sequence +logger = logging.getLogger(__name__) + def tencent_headers(token: Optional[str] = None) -> Dict[str, str]: if token is None: @@ -104,8 +107,10 @@ def submit_task( try: rtn = [] for t in r["tasks"]: - t = error_handling(t) - rtn.append(Task(id_=t["id"], device=device)) + if "err" in t: + logger.warning(t["err"]) + else: + rtn.append(Task(id_=t["id"], device=device)) if len(rtn) == 1: return rtn[0] # type: ignore else: @@ -128,6 +133,33 @@ def resubmit_task(task: Task, token: str) -> Task: raise ValueError(dumps(r)) +def list_tasks(device: Device, token: str, **filter_kws: Any) -> List[Task]: + json = filter_kws + if device is not None: + json["device"] = device.name + r = rpost_json( + tencent_base_url + "task/find?pn=1&npp=50", + json=json, + headers=tencent_headers(token), + ) + r = error_handling(r) + try: + rtn = [] + for t in r["tasks"]: + if "err" in t: + logger.warning(t["err"]) + else: + rtn.append( + Task( + id_=t["id"], + device=Device.from_name("tencent" + sep + t["device"]), + ) + ) + return rtn + except KeyError: + raise ValueError(dumps(r)) + + def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: json = {"id": task.id_} r = rpost_json( diff --git a/tests/test_cloud.py b/tests/test_cloud.py index 86c94363..5a93d7d0 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -1,5 +1,6 @@ import sys import os +import time import pytest thisfile = os.path.abspath(__file__) @@ -8,14 +9,13 @@ sys.path.insert(0, modulepath) import tensorcircuit as tc from tensorcircuit.cloud import apis -from tensorcircuit.cloud import config def test_get_token(): - apis.set_token(config.tencent_token) - assert apis.get_token(provider="Tencent") == config.tencent_token + print(apis.get_token(provider="Tencent")) p = apis.get_provider("tencent") - assert p.get_token() == config.tencent_token + print(p.get_token()) + print(p.get_device("simulator:tc").get_token()) def test_list_devices(): @@ -55,4 +55,21 @@ def test_submit_task(): c.H(2) t = apis.submit_task(device="simulator:aer", circuit=c) r = t.details() - assert r["task"]["state"] in ["pending", "completed"] + assert r["state"] in ["pending", "completed"] + + +def test_resubmit_task(): + c = tc.Circuit(3) + c.H(0) + c.H(1) + t = apis.submit_task(device="simulator:aer", circuit=c) + time.sleep(15) + t1 = apis.resubmit_task(t) + print(t.details()) + print(t1.details()) + + +def test_list_tasks(): + d = apis.get_device(device="simulator:aer") + print(d.list_tasks()) + print(apis.list_tasks(device="simulator:tc")) From 9aad44c53b2c4d5e46e6e9624d254d9535b27451 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 21 Nov 2022 11:10:45 +0800 Subject: [PATCH 073/725] add tc as python package in devcontainer --- .devcontainer/devcontainer.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index a36fae8d..1ea44918 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -32,13 +32,13 @@ }, // Add the IDs of extensions you want installed when the container is created. - "extensions": ["ms-python.python", "ms-toolsai.jupyter"] + "extensions": ["ms-python.python", "ms-toolsai.jupyter"], // Use 'forwardPorts' to make a list of ports inside the container available locally. // "forwardPorts": [], // Use 'postCreateCommand' to run commands after the container is created. - // "postCreateCommand": "pip3 install --user -r requirements.txt", + "postCreateCommand": "python3 setup.py develop" // Uncomment to connect as a non-root user. See https://aka.ms/vscode-remote/containers/non-root. // "remoteUser": "vscode" From bb6a85177a9418a74085f10cef163d4db69da4ee Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 21 Nov 2022 12:24:44 +0800 Subject: [PATCH 074/725] add sudo in postcommand --- .devcontainer/devcontainer.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 1ea44918..f3c6b074 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -38,7 +38,7 @@ // "forwardPorts": [], // Use 'postCreateCommand' to run commands after the container is created. - "postCreateCommand": "python3 setup.py develop" + "postCreateCommand": "sudo python3 setup.py develop" // Uncomment to connect as a non-root user. See https://aka.ms/vscode-remote/containers/non-root. // "remoteUser": "vscode" From 7a08d7f14cd90dc09ece58963f51c75149354ee1 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 21 Nov 2022 14:27:04 +0800 Subject: [PATCH 075/725] revise noisemodel-1 --- CHANGELOG.md | 4 +-- tensorcircuit/noisemodel.py | 69 ++++++++++++++++++------------------- 2 files changed, 35 insertions(+), 38 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3ac7320c..c598085a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,11 +20,9 @@ - Fixed `unitary_kraus` of Circuit class support for multi-qubit kraus channels, previous implementation fails to reshape the kraus tensor as matrix -<<<<<<< HEAD -======= - Fixed `kraus_to_super_gate` bug when multi-qubit kraus channels are presented on tensorflow backend ->>>>>>> master + ## 0.5.0 ### Added diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index e3e180ca..6369245a 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -2,12 +2,13 @@ General Noise Model Construction. """ import logging - from typing import Any, Sequence, Optional, List, Dict -from tensorcircuit.abstractcircuit import AbstractCircuit + +from .abstractcircuit import AbstractCircuit from . import gates from . import Circuit, DMCircuit from .cons import backend +from .channels import KrausList Gate = gates.Gate Tensor = Any @@ -22,19 +23,17 @@ class NoiseConf: error1 = tc.channels.generaldepolarizingchannel(0.1, 1) error2 = tc.channels.thermalrelaxationchannel(300, 400, 100, "ByChoi", 0) - readout_error = [[0.9, 0.75],[0.4, 0.7]] + readout_error = [[0.9, 0.75], [0.4, 0.7]] noise_conf = NoiseConf() - noise_conf.add_noise("x",error1) - noise_conf.add_noise("h",[error1,error2],[[0],[1]]) + noise_conf.add_noise("x", error1) + noise_conf.add_noise("h", [error1, error2], [[0], [1]]) noise_conf.add_noise("readout", readout_error) - """ def __init__(self) -> None: """ Establish a noise configuration. - """ self.nc = {} # type: ignore self.has_quantum = False @@ -43,16 +42,17 @@ def __init__(self) -> None: def add_noise( self, gate_name: str, - kraus: Sequence[Gate], + kraus: Sequence[KrausList], qubit: Optional[Sequence[Any]] = None, ) -> None: - """Add noise channels on specific gates and specific qubits in form of Kraus operators. + """ + Add noise channels on specific gates and specific qubits in form of Kraus operators. :param gate_name: noisy gate :type gate_name: str :param kraus: noise channel :type kraus: Sequence[Gate] - :param qubit: the list of noisy qubit, defaults to None + :param qubit: the list of noisy qubit, defaults to None, indicating applying the noise channel on all qubits :type qubit: Optional[Sequence[Any]], optional """ if gate_name not in self.nc: @@ -74,25 +74,24 @@ def add_noise( def apply_qir_with_noise( - c: AbstractCircuit, + c: Any, qir: List[Dict[str, Any]], noise_conf: NoiseConf, - status: Optional[Sequence[Any]] = None, -) -> AbstractCircuit: + status: Optional[Tensor] = None, +) -> Any: """ :param c: A newly defined circuit :type c: AbstractCircuit - :param qir: The qir of the objective circuit + :param qir: The qir of the clean circuit :type qir: List[Dict[str, Any]] :param noise_conf: Noise Configuration :type noise_conf: NoiseConf :param status: The status for Monte Carlo sampling, defaults to None - :type status: Optional[Sequence[Any]], optional + :type status: 1D Tensor, optional :return: A newly constructed circuit with noise :rtype: AbstractCircuit """ - quantum_index = 0 for d in qir: if "parameters" not in d: # paramized gate @@ -129,13 +128,13 @@ def apply_qir_with_noise( noise_kraus = noise_conf.nc[d["name"]][d["index"]] if noise_kraus.is_unitary is True: - c.unitary_kraus( # type: ignore + c.unitary_kraus( noise_kraus, *d["index"], status=status[quantum_index] # type: ignore ) else: - c.general_kraus( # type: ignore + c.general_kraus( noise_kraus, *d["index"], status=status[quantum_index] # type: ignore @@ -146,16 +145,16 @@ def apply_qir_with_noise( def circuit_with_noise( - c: AbstractCircuit, noise_conf: NoiseConf, status: Optional[Sequence[Any]] = None -) -> AbstractCircuit: - """Noisify an objective circuit. + c: AbstractCircuit, noise_conf: NoiseConf, status: Optional[Tensor] = None +) -> Any: + """Noisify a clean circuit. - :param c: An objective circuit + :param c: A clean circuit :type c: AbstractCircuit :param noise_conf: Noise Configuration :type noise_conf: NoiseConf :param status: The status for Monte Carlo sampling, defaults to None - :type status: Optional[Sequence[Any]], optional + :type status: 1D Tensor, optional :return: A newly constructed circuit with noise :rtype: AbstractCircuit """ @@ -170,13 +169,13 @@ def circuit_with_noise( def expectation_ps_noisfy( - c: AbstractCircuit, + c: Any, x: Optional[Sequence[int]] = None, y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, noise_conf: Optional[NoiseConf] = None, nmc: int = 1000, - status: Optional[Sequence[Any]] = None, + status: Optional[Tensor] = None, ) -> Tensor: if noise_conf is None: @@ -201,8 +200,8 @@ def expectation_ps_noisfy( # monte carlo else: - def mcsim(status): # type: ignore - cnoise = circuit_with_noise(c, noise_conf, status) # type: ignore + def mcsim(status: Optional[Tensor]) -> Tensor: + cnoise = circuit_with_noise(c, noise_conf, status) # type: ignore return cnoise.expectation_ps(x=x, y=y, z=z) mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) @@ -219,14 +218,14 @@ def mcsim(status): # type: ignore def sample_expectation_ps_noisfy( - c: AbstractCircuit, + c: Any, x: Optional[Sequence[int]] = None, y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, noise_conf: Optional[NoiseConf] = None, nmc: int = 1000, shots: Optional[int] = None, - status: Optional[Sequence[Any]] = None, + status: Optional[Tensor] = None, ) -> Tensor: if noise_conf is None: @@ -245,17 +244,17 @@ def sample_expectation_ps_noisfy( # density matrix if isinstance(c, DMCircuit): - cnoise = circuit_with_noise(c, noise_conf) - return cnoise.sample_expectation_ps( # type: ignore + cnoise = circuit_with_noise(c, noise_conf) # type: ignore + return cnoise.sample_expectation_ps( x=x, y=y, z=z, shots=shots, readout_error=readout_error ) # monte carlo else: - def mcsim(status): # type: ignore - cnoise = circuit_with_noise(c, noise_conf, status) # type: ignore - return cnoise.sample_expectation_ps( # type: ignore + def mcsim(status: Optional[Tensor]) -> Tensor: + cnoise = circuit_with_noise(c, noise_conf, status) # type: ignore + return cnoise.sample_expectation_ps( x=x, y=y, z=z, shots=shots, readout_error=readout_error ) @@ -268,7 +267,7 @@ def mcsim(status): # type: ignore return value else: - value = c.sample_expectation_ps( # type: ignore + value = c.sample_expectation_ps( x=x, y=y, z=z, shots=shots, readout_error=readout_error ) return value From b3647197b2c78ad605fb2b736c2458c7fd629a58 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 21 Nov 2022 19:04:55 +0800 Subject: [PATCH 076/725] add composed noise channel --- tensorcircuit/noisemodel.py | 48 +++++++++++++++++++++++++++++++++++-- tests/test_noisemodel.py | 34 ++++++++++++++++++-------- 2 files changed, 70 insertions(+), 12 deletions(-) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 6369245a..8b6625a4 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -39,6 +39,33 @@ def __init__(self) -> None: self.has_quantum = False self.has_readout = False + def composedkraus(self, kraus1: KrausList, kraus2: KrausList) -> KrausList: + """ + Compose the noise channels + + :param kraus1: One noise channel + :type kraus1: KrausList + :param kraus2: Another noise channel + :type kraus2: KrausList + :return: Composed nosie channel + :rtype: KrausList + """ + dim = backend.shape_tuple(kraus1[0].tensor) + dim2 = int(2 ** (len(dim) / 2)) + new_kraus = [] + for i in kraus1: + for j in kraus2: + k = Gate( + backend.reshape(i.tensor, [dim2, dim2]) + @ backend.reshape(j.tensor, [dim2, dim2]) + ) + new_kraus.append(k) + return KrausList( + new_kraus, + name="composed_channel", + is_unitary=kraus1.is_unitary and kraus2.is_unitary, + ) + def add_noise( self, gate_name: str, @@ -61,10 +88,25 @@ def add_noise( qubit_kraus = self.nc[gate_name] if qubit is None: - qubit_kraus["Default"] = kraus + if qubit_kraus: + for qname in qubit_kraus: + qubit_kraus[qname] = self.composedkraus(qubit_kraus[qname], kraus) # type: ignore + else: + qubit_kraus["Default"] = kraus else: for i in range(len(qubit)): - qubit_kraus[tuple(qubit[i])] = kraus[i] + if tuple(qubit[i]) in qubit_kraus: + qubit_kraus[tuple(qubit[i])] = self.composedkraus( + qubit_kraus[tuple(qubit[i])], kraus[i] + ) + else: + if "Default" in qubit_kraus: + qubit_kraus[tuple(qubit[i])] = self.composedkraus( + qubit_kraus["Default"], kraus[i] + ) + else: + qubit_kraus[tuple(qubit[i])] = kraus[i] + self.nc[gate_name] = qubit_kraus if gate_name == "readout": @@ -103,6 +145,7 @@ def apply_qir_with_noise( if isinstance(c, DMCircuit): if d["name"] in noise_conf.nc: + if ( "Default" in noise_conf.nc[d["name"]] or d["index"] in noise_conf.nc[d["name"]] @@ -117,6 +160,7 @@ def apply_qir_with_noise( else: if d["name"] in noise_conf.nc: + if ( "Default" in noise_conf.nc[d["name"]] or d["index"] in noise_conf.nc[d["name"]] diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index be69d841..9692fe69 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -11,16 +11,19 @@ ) -@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_noisemodel(backend): # test data structure # noise_conf = NoiseConf() - # noise_conf.add_noise("h1","t0") - # noise_conf.add_noise("h1",["t1","t2"],[[0],[1]]) - # noise_conf.add_noise("h1",["t3"],[[0]]) - # noise_conf.add_noise("h2",["v1","v2"],[[0],[1]]) - # noise_conf.add_noise("h2",["v3"],[[0]]) + # noise_conf.add_noise("h1", "t0") + # noise_conf.add_noise("h1", ["t1", "t2"], [[0], [1]]) + # noise_conf.add_noise("h1", ["t3"], [[0]]) + # noise_conf.add_noise("h1", "t4") + # noise_conf.add_noise("h1", ["t5"], [[3]]) + # noise_conf.add_noise("h2", ["v1", "v2"], [[0], [1]]) + # noise_conf.add_noise("h2", ["v3"], [[0]]) + # noise_conf.add_noise("h2", "v4") c = tc.Circuit(2) c.cnot(0, 1) @@ -56,14 +59,25 @@ def test_noisemodel(backend): value = cnoise.expectation_ps(x=[0, 1]) value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) - np.testing.assert_allclose(value, 0.15, atol=1e-1) + np.testing.assert_allclose(value, 0.09, atol=1e-2) value = expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf) - np.testing.assert_allclose(value, 0.15, atol=1e-2) + np.testing.assert_allclose(value, 0.09, atol=1e-2) # with readout_error value = sample_expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf) - np.testing.assert_allclose(value, -0.16, atol=1e-2) + np.testing.assert_allclose(value, -0.11, atol=1e-2) value = sample_expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=100000) - np.testing.assert_allclose(value, -0.16, atol=1e-1) + np.testing.assert_allclose(value, -0.11, atol=1e-2) + + noise_conf1 = NoiseConf() + newnoise = noise_conf1.composedkraus(error1, error3) + noise_conf1.add_noise("rx", [newnoise, error1], [[0], [1]]) + noise_conf1.add_noise("h", [error3, error1], [[0], [1]]) + noise_conf1.add_noise("x", [error3], [[0]]) + noise_conf1.add_noise("cnot", [error2], [[0, 1]]) + noise_conf1.add_noise("readout", readout_error) + + value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) + np.testing.assert_allclose(value, 0.09, atol=1e-2) From a77ea341ec3f873176ce55a4c0e3cd56eb56e56a Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Tue, 22 Nov 2022 12:33:35 +0800 Subject: [PATCH 077/725] revise composed channel and standard gate --- tensorcircuit/channels.py | 23 +++++++++++++++++++++ tensorcircuit/noisemodel.py | 41 +++++++++---------------------------- tests/test_noisemodel.py | 30 +++++++++++++++++++-------- 3 files changed, 55 insertions(+), 39 deletions(-) diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index fe63f687..a1580896 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -962,3 +962,26 @@ def check_rep_transformation( print("test evolution identity of kraus and superop") density_matrix3 = evol_superop(density_matrix, superop) np.testing.assert_allclose(density_matrix1, density_matrix3, atol=1e-5) + + +def composedkraus(kraus1: KrausList, kraus2: KrausList) -> KrausList: + """ + Compose the noise channels + + :param kraus1: One noise channel + :type kraus1: KrausList + :param kraus2: Another noise channel + :type kraus2: KrausList + :return: Composed nosie channel + :rtype: KrausList + """ + new_kraus = [] + for i in kraus1: + for j in kraus2: + k = Gate(backend.reshapem(i.tensor) @ backend.reshapem(j.tensor)) + new_kraus.append(k) + return KrausList( + new_kraus, + name="composed_channel", + is_unitary=kraus1.is_unitary and kraus2.is_unitary, + ) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 8b6625a4..3a02461c 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -8,7 +8,7 @@ from . import gates from . import Circuit, DMCircuit from .cons import backend -from .channels import KrausList +from .channels import KrausList, composedkraus Gate = gates.Gate Tensor = Any @@ -39,33 +39,6 @@ def __init__(self) -> None: self.has_quantum = False self.has_readout = False - def composedkraus(self, kraus1: KrausList, kraus2: KrausList) -> KrausList: - """ - Compose the noise channels - - :param kraus1: One noise channel - :type kraus1: KrausList - :param kraus2: Another noise channel - :type kraus2: KrausList - :return: Composed nosie channel - :rtype: KrausList - """ - dim = backend.shape_tuple(kraus1[0].tensor) - dim2 = int(2 ** (len(dim) / 2)) - new_kraus = [] - for i in kraus1: - for j in kraus2: - k = Gate( - backend.reshape(i.tensor, [dim2, dim2]) - @ backend.reshape(j.tensor, [dim2, dim2]) - ) - new_kraus.append(k) - return KrausList( - new_kraus, - name="composed_channel", - is_unitary=kraus1.is_unitary and kraus2.is_unitary, - ) - def add_noise( self, gate_name: str, @@ -82,6 +55,9 @@ def add_noise( :param qubit: the list of noisy qubit, defaults to None, indicating applying the noise channel on all qubits :type qubit: Optional[Sequence[Any]], optional """ + if gate_name is not "readout": + gate_name = AbstractCircuit.standardize_gate(gate_name) + if gate_name not in self.nc: qubit_kraus = {} else: @@ -90,18 +66,18 @@ def add_noise( if qubit is None: if qubit_kraus: for qname in qubit_kraus: - qubit_kraus[qname] = self.composedkraus(qubit_kraus[qname], kraus) # type: ignore + qubit_kraus[qname] = composedkraus(qubit_kraus[qname], kraus) # type: ignore else: qubit_kraus["Default"] = kraus else: for i in range(len(qubit)): if tuple(qubit[i]) in qubit_kraus: - qubit_kraus[tuple(qubit[i])] = self.composedkraus( + qubit_kraus[tuple(qubit[i])] = composedkraus( qubit_kraus[tuple(qubit[i])], kraus[i] ) else: if "Default" in qubit_kraus: - qubit_kraus[tuple(qubit[i])] = self.composedkraus( + qubit_kraus[tuple(qubit[i])] = composedkraus( qubit_kraus["Default"], kraus[i] ) else: @@ -136,6 +112,9 @@ def apply_qir_with_noise( """ quantum_index = 0 for d in qir: + + d["name"] = AbstractCircuit.standardize_gate(d["name"]) + if "parameters" not in d: # paramized gate c.apply_general_gate_delayed(d["gatef"], d["name"])(c, *d["index"]) else: diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index 9692fe69..aca8f546 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -9,6 +9,7 @@ expectation_ps_noisfy, sample_expectation_ps_noisfy, ) +from tensorcircuit.channels import composedkraus @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) @@ -59,25 +60,38 @@ def test_noisemodel(backend): value = cnoise.expectation_ps(x=[0, 1]) value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) - np.testing.assert_allclose(value, 0.09, atol=1e-2) + np.testing.assert_allclose(value, 0.09, atol=1e-1) value = expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf) - np.testing.assert_allclose(value, 0.09, atol=1e-2) + np.testing.assert_allclose(value, 0.09, atol=1e-1) # with readout_error value = sample_expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf) - np.testing.assert_allclose(value, -0.11, atol=1e-2) + np.testing.assert_allclose(value, -0.11, atol=1e-1) value = sample_expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=100000) - np.testing.assert_allclose(value, -0.11, atol=1e-2) + np.testing.assert_allclose(value, -0.11, atol=1e-1) + # test composed channel + newerror = composedkraus(error1, error3) noise_conf1 = NoiseConf() - newnoise = noise_conf1.composedkraus(error1, error3) - noise_conf1.add_noise("rx", [newnoise, error1], [[0], [1]]) + noise_conf1.add_noise("rx", [newerror, error1], [[0], [1]]) noise_conf1.add_noise("h", [error3, error1], [[0], [1]]) noise_conf1.add_noise("x", [error3], [[0]]) noise_conf1.add_noise("cnot", [error2], [[0, 1]]) noise_conf1.add_noise("readout", readout_error) - value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) - np.testing.assert_allclose(value, 0.09, atol=1e-2) + value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf1, nmc=10000) + np.testing.assert_allclose(value, 0.09, atol=1e-1) + + # test standardized gate + newerror = composedkraus(error1, error3) + noise_conf2 = NoiseConf() + noise_conf2.add_noise("Rx", [newerror, error1], [[0], [1]]) + noise_conf2.add_noise("H", [error3, error1], [[0], [1]]) + noise_conf2.add_noise("x", [error3], [[0]]) + noise_conf2.add_noise("cx", [error2], [[0, 1]]) + noise_conf2.add_noise("readout", readout_error) + + value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf2, nmc=10000) + np.testing.assert_allclose(value, 0.09, atol=1e-1) From 22faa8b6357dac7ca954021e8412d2851406ae0f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 22 Nov 2022 16:30:57 +0800 Subject: [PATCH 078/725] add std method --- CHANGELOG.md | 7 +++++- tensorcircuit/backends/abstract_backend.py | 25 ++++++++++++++++++++ tensorcircuit/backends/jax_backend.py | 5 ++++ tensorcircuit/backends/numpy_backend.py | 5 ++++ tensorcircuit/backends/pytorch_backend.py | 7 ++++++ tensorcircuit/backends/tensorflow_backend.py | 5 ++++ tensorcircuit/experimental.py | 1 + tests/test_backends.py | 5 ++++ 8 files changed, 59 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c598085a..220b1da2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,12 @@ - Add `shifts` tuple parameter for `experimental.parameter_shift_grad` API so that we can also customize finite difference gradient from this method +- Add `std` method for backends + +- Add `NoiseModel` class to programmably configure the global error model when simulating the quantum circuit + +- Add `tc.channels.composedkraus` to compose the different Kraus operators as a new one + ### Changed - Improve the efficiency of `sample_expectation_ps` method by using cached state. @@ -22,7 +28,6 @@ - Fixed `kraus_to_super_gate` bug when multi-qubit kraus channels are presented on tensorflow backend - ## 0.5.0 ### Added diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index 352f2f46..2d14d9c7 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -462,6 +462,31 @@ def mean( "Backend '{}' has not implemented `mean`.".format(self.name) ) + def std( + self: Any, + a: Tensor, + axis: Optional[Sequence[int]] = None, + keepdims: bool = False, + ) -> Tensor: + """ + Compute the standard deviation along the specified axis. + + :param a: _description_ + :type a: Tensor + :param axis: Axis or axes along which the standard deviation is computed, + defaults to None, implying all axis + :type axis: Optional[Sequence[int]], optional + :param keepdims: If this is set to True, + the axes which are reduced are left in the result as dimensions with size one, + defaults to False + :type keepdims: bool, optional + :return: _description_ + :rtype: Tensor + """ + raise NotImplementedError( + "Backend '{}' has not implemented `std`.".format(self.name) + ) + def min(self: Any, a: Tensor, axis: Optional[int] = None) -> Tensor: """ Return the minimum of an array or minimum along an axis. diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 933f10db..046a8e6a 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -346,6 +346,11 @@ def mean( ) -> Tensor: return jnp.mean(a, axis=axis, keepdims=keepdims) + def std( + self, a: Tensor, axis: Optional[Sequence[int]] = None, keepdims: bool = False + ) -> Tensor: + return jnp.std(a, axis=axis, keepdims=keepdims) + def min(self, a: Tensor, axis: Optional[int] = None) -> Tensor: return jnp.min(a, axis=axis) diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index bde0f489..f55a4c36 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -154,6 +154,11 @@ def mean( ) -> Tensor: return np.mean(a, axis=axis, keepdims=keepdims) + def std( + self, a: Tensor, axis: Optional[Sequence[int]] = None, keepdims: bool = False + ) -> Tensor: + return np.std(a, axis=axis, keepdims=keepdims) + def unique_with_counts(self, a: Tensor, **kws: Any) -> Tuple[Tensor, Tensor]: return np.unique(a, return_counts=True) # type: ignore diff --git a/tensorcircuit/backends/pytorch_backend.py b/tensorcircuit/backends/pytorch_backend.py index 1a486213..d5124af1 100644 --- a/tensorcircuit/backends/pytorch_backend.py +++ b/tensorcircuit/backends/pytorch_backend.py @@ -324,6 +324,13 @@ def mean( axis = tuple([i for i in range(len(a.shape))]) return torchlib.mean(a, dim=axis, keepdim=keepdims) + def std( + self, a: Tensor, axis: Optional[Sequence[int]] = None, keepdims: bool = False + ) -> Tensor: + if axis is None: + axis = tuple([i for i in range(len(a.shape))]) + return torchlib.std(a, dim=axis, unbiased=False, keepdim=keepdims) + def min(self, a: Tensor, axis: Optional[int] = None) -> Tensor: if axis is None: return torchlib.min(a) diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index a6a10df7..34191fe3 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -368,6 +368,11 @@ def mean( ) -> Tensor: return tf.math.reduce_mean(a, axis=axis, keepdims=keepdims) + def std( + self, a: Tensor, axis: Optional[Sequence[int]] = None, keepdims: bool = False + ) -> Tensor: + return tf.math.reduce_std(a, axis=axis, keepdims=keepdims) + def sigmoid(self, a: Tensor) -> Tensor: return tf.nn.sigmoid(a) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 7cf0d474..b1fa8cdf 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -355,6 +355,7 @@ def hamiltonian_evol( ) -> Tensor: """ Fast implementation of static full Hamiltonian evolution + (default as imaginary time) :param tlist: _description_ :type tlist: Tensor diff --git a/tests/test_backends.py b/tests/test_backends.py index 5dda35d5..270b597a 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -293,6 +293,11 @@ def test_backend_methods_2(backend): np.testing.assert_allclose( r - tc.backend.numpy(p) * 10000.0, np.zeros([10]), atol=200, rtol=1 ) + np.testing.assert_allclose( + tc.backend.std(tc.backend.cast(tc.backend.arange(1, 4), "float32")), + 0.81649658, + atol=1e-5, + ) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("torchb")]) From 8ef223e6966e8409a863b0b8fe7731de2cd406ac Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Wed, 23 Nov 2022 12:53:00 +0800 Subject: [PATCH 079/725] merge noisfy expectations to original expectations --- tensorcircuit/abstractcircuit.py | 31 +++++- tensorcircuit/basecircuit.py | 143 ++++++++++++++++--------- tensorcircuit/channels.py | 2 +- tensorcircuit/circuit.py | 61 ++++++++--- tensorcircuit/densitymatrix.py | 31 +++++- tensorcircuit/mpscircuit.py | 1 + tensorcircuit/noisemodel.py | 175 +++++++++++++++++++++++-------- tests/test_noisemodel.py | 73 +++++++++++-- 8 files changed, 399 insertions(+), 118 deletions(-) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 3270a8ec..ce08da12 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -866,6 +866,9 @@ def expectation( self, *ops: Tuple[tn.Node, List[int]], reuse: bool = True, + noise_conf: Optional[Any] = None, + nmc: int = 1000, + status: Optional[Tensor] = None, **kws: Any, ) -> Tensor: raise NotImplementedError @@ -876,6 +879,9 @@ def expectation_ps( y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, reuse: bool = True, + noise_conf: Optional[Any] = None, + nmc: int = 1000, + status: Optional[Tensor] = None, **kws: Any, ) -> Tensor: """ @@ -890,6 +896,20 @@ def expectation_ps( >>> c.expectation_ps(x=[1], z=[0]) array(-0.99999994+0.j, dtype=complex64) + >>> c = tc.Circuit(2) + >>> c.cnot(0, 1) + >>> c.rx(0, theta=0.4) + >>> c.rx(1, theta=0.8) + >>> c.h(0) + >>> c.h(1) + >>> error1 = tc.channels.generaldepolarizingchannel(0.1, 1) + >>> error2 = tc.channels.generaldepolarizingchannel(0.06, 2) + >>> noise_conf = NoiseConf() + >>> noise_conf.add_noise("rx", error1) + >>> noise_conf.add_noise("cnot", [error2], [[0, 1]]) + >>> c.expectation_ps(x=[0], noise_conf=noise_conf, nmc=10000) + (0.46274087-3.764033e-09j) + :param x: sites to apply X gate, defaults to None :type x: Optional[Sequence[int]], optional :param y: sites to apply Y gate, defaults to None @@ -898,6 +918,13 @@ def expectation_ps( :type z: Optional[Sequence[int]], optional :param reuse: whether to cache and reuse the wavefunction, defaults to True :type reuse: bool, optional + :param noise_conf: Noise Configuration, defaults to None + :type noise_conf: Optional[NoiseConf], optional + :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000 + :type nmc: int, optional + :param status: external randomness given by tensor uniformly from [0, 1], defaults to None, + used for noisfy circuit sampling + :type status: Optional[Tensor], optional :return: Expectation value :rtype: Tensor """ @@ -911,4 +938,6 @@ def expectation_ps( if z is not None: for i in z: obs.append([gates.z(), [i]]) # type: ignore - return self.expectation(*obs, reuse=reuse, **kws) # type: ignore + return self.expectation( + *obs, reuse=reuse, noise_conf=noise_conf, nmc=nmc, status=status, **kws # type: ignore + ) diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index c22c89ec..42d5ea84 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -26,6 +26,7 @@ from .simplify import _split_two_qubit_gate from .utils import arg_alias + Gate = gates.Gate Tensor = Any @@ -613,6 +614,9 @@ def sample_expectation_ps( random_generator: Optional[Any] = None, status: Optional[Tensor] = None, readout_error: Optional[Sequence[Any]] = None, + noise_conf: Optional[Any] = None, + nmc: int = 1000, + statusc: Optional[Tensor] = None, **kws: Any, ) -> Tensor: """ @@ -630,6 +634,22 @@ def sample_expectation_ps( >>> readout_error.append([0.4,0.7]) >>> c.sample_expectation_ps(x=[0], y=[1],readout_error = readout_error) + >>> c = tc.Circuit(2) + >>> c.cnot(0, 1) + >>> c.rx(0, theta=0.4) + >>> c.rx(1, theta=0.8) + >>> c.h(0) + >>> c.h(1) + >>> error1 = tc.channels.generaldepolarizingchannel(0.1, 1) + >>> error2 = tc.channels.generaldepolarizingchannel(0.06, 2) + >>> readout_error = [[0.9, 0.75],[0.4, 0.7]] + >>> noise_conf = NoiseConf() + >>> noise_conf.add_noise("rx", error1) + >>> noise_conf.add_noise("cnot", [error2], [[0, 1]]) + >>> noise_conf.add_noise("readout", readout_error) + >>> c.sample_expectation_ps(x=[0], noise_conf=noise_conf, nmc=10000) + 0.44766843 + :param x: index for Pauli X, defaults to None :type x: Optional[Sequence[int]], optional :param y: index for Pauli Y, defaults to None @@ -645,62 +665,85 @@ def sample_expectation_ps( :type status: Optional[Tensor] :param readout_error: readout_error, defaults to None :type readout_error: Optional[Sequence[Any]]. Tensor, List, Tuple + :param noise_conf: Noise Configuration, defaults to None + :type noise_conf: Optional[NoiseConf], optional + :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000 + :type nmc: int, optional + :param statusc: external randomness given by tensor uniformly from [0, 1], defaults to None, + used for noisfy circuit sampling + :type statusc: Optional[Tensor], optional :return: [description] :rtype: Tensor """ - inputs_nodes, _ = self._copy_state_tensor() - inputs = inputs_nodes[0].tensor - if self.is_dm is False: - c = type(self)(self._nqubits, inputs=inputs) # type: ignore - else: - c = type(self)(self._nqubits, dminputs=inputs) # type: ignore - if x is None: - x = [] - if y is None: - y = [] - if z is None: - z = [] - for i in x: - c.H(i) # type: ignore - for i in y: - c.rx(i, theta=np.pi / 2) # type: ignore - s = c.state() # type: ignore - if self.is_dm is False: - p = backend.abs(s) ** 2 - else: - p = backend.abs(backend.diagonal(s)) - - # readout error - if readout_error is not None: - p = self.readouterror_bs(readout_error, p) - - x = list(x) - y = list(y) - z = list(z) - if shots is None: - mc = measurement_counts( - p, - counts=shots, - format="count_vector", - random_generator=random_generator, - status=status, - jittable=True, - is_prob=True, - ) - r = correlation_from_counts(x + y + z, mc) + from .noisemodel import sample_expectation_ps_noisfy + + if noise_conf is None: + inputs_nodes, _ = self._copy_state_tensor() + inputs = inputs_nodes[0].tensor + if self.is_dm is False: + c = type(self)(self._nqubits, inputs=inputs) # type: ignore + else: + c = type(self)(self._nqubits, dminputs=inputs) # type: ignore + if x is None: + x = [] + if y is None: + y = [] + if z is None: + z = [] + for i in x: + c.H(i) # type: ignore + for i in y: + c.rx(i, theta=np.pi / 2) # type: ignore + s = c.state() # type: ignore + if self.is_dm is False: + p = backend.abs(s) ** 2 + else: + p = backend.abs(backend.diagonal(s)) + + # readout error + if readout_error is not None: + p = self.readouterror_bs(readout_error, p) + + x = list(x) + y = list(y) + z = list(z) + if shots is None: + mc = measurement_counts( + p, + counts=shots, + format="count_vector", + random_generator=random_generator, + status=status, + jittable=True, + is_prob=True, + ) + r = correlation_from_counts(x + y + z, mc) + else: + mc = measurement_counts( + p, + counts=shots, + format="sample_bin", + random_generator=random_generator, + status=status, + jittable=True, + is_prob=True, + ) + r = correlation_from_samples(x + y + z, mc, self._nqubits) + # TODO(@refraction-ray): analytical standard deviation + return r else: - mc = measurement_counts( - p, - counts=shots, - format="sample_bin", - random_generator=random_generator, + return sample_expectation_ps_noisfy( + c=self, + x=x, + y=y, + z=z, + noise_conf=noise_conf, + nmc=nmc, + shots=shots, + statusc=statusc, status=status, - jittable=True, - is_prob=True, + **kws, ) - r = correlation_from_samples(x + y + z, mc, self._nqubits) - # TODO(@refraction-ray): analytical standard deviation - return r sexpps = sample_expectation_ps diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index a1580896..808571ac 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -982,6 +982,6 @@ def composedkraus(kraus1: KrausList, kraus2: KrausList) -> KrausList: new_kraus.append(k) return KrausList( new_kraus, - name="composed_channel", + name=kraus1.name + "_" + kraus2.name, is_unitary=kraus1.is_unitary and kraus2.is_unitary, ) diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index 2a6d1fcc..d785b223 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -772,6 +772,10 @@ def expectation( # type: ignore *ops: Tuple[tn.Node, List[int]], reuse: bool = True, enable_lightcone: bool = False, + noise_conf: Optional[Any] = None, + nmc: int = 1000, + status: Optional[Tensor] = None, + **kws: Any, ) -> Tensor: """ Compute the expectation of corresponding operators. @@ -783,6 +787,20 @@ def expectation( # type: ignore >>> c.expectation((tc.gates.z(), [0])) array(0.+0.j, dtype=complex64) + >>> c = tc.Circuit(2) + >>> c.cnot(0, 1) + >>> c.rx(0, theta=0.4) + >>> c.rx(1, theta=0.8) + >>> c.h(0) + >>> c.h(1) + >>> error1 = tc.channels.generaldepolarizingchannel(0.1, 1) + >>> error2 = tc.channels.generaldepolarizingchannel(0.06, 2) + >>> noise_conf = NoiseConf() + >>> noise_conf.add_noise("rx", error1) + >>> noise_conf.add_noise("cnot", [error2], [[0, 1]]) + >>> c.expectation((tc.gates.x(), [0]), noise_conf=noise_conf, nmc=10000) + (0.46274087-3.764033e-09j) + :param ops: Operator and its position on the circuit, eg. ``(tc.gates.z(), [1, ]), (tc.gates.x(), [2, ])`` is for operator :math:`Z_1X_2`. :type ops: Tuple[tn.Node, List[int]] @@ -791,22 +809,41 @@ def expectation( # type: ignore :type reuse: bool, optional :param enable_lightcone: whether enable light cone simplification, defaults to False :type enable_lightcone: bool, optional + :param noise_conf: Noise Configuration, defaults to None + :type noise_conf: Optional[NoiseConf], optional + :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000 + :type nmc: int, optional + :param status: external randomness given by tensor uniformly from [0, 1], defaults to None, + used for noisfy circuit sampling + :type status: Optional[Tensor], optional :raises ValueError: "Cannot measure two operators in one index" :return: Tensor with one element :rtype: Tensor """ - # if not reuse: - # nodes1, edge1 = self._copy() - # nodes2, edge2 = self._copy(conj=True) - # else: # reuse - - # self._nodes = nodes1 - if enable_lightcone: - reuse = False - nodes1 = self.expectation_before(*ops, reuse=reuse) - if enable_lightcone: - nodes1 = _full_light_cone_cancel(nodes1) - return contractor(nodes1).tensor + from .noisemodel import expectation_noisfy + + if noise_conf is None: + # if not reuse: + # nodes1, edge1 = self._copy() + # nodes2, edge2 = self._copy(conj=True) + # else: # reuse + + # self._nodes = nodes1 + if enable_lightcone: + reuse = False + nodes1 = self.expectation_before(*ops, reuse=reuse) + if enable_lightcone: + nodes1 = _full_light_cone_cancel(nodes1) + return contractor(nodes1).tensor + else: + return expectation_noisfy( + self, + *ops, + noise_conf=noise_conf, + nmc=nmc, + status=status, + **kws, + ) Circuit._meta_apply() diff --git a/tensorcircuit/densitymatrix.py b/tensorcircuit/densitymatrix.py index e0adae07..59a27efa 100644 --- a/tensorcircuit/densitymatrix.py +++ b/tensorcircuit/densitymatrix.py @@ -265,7 +265,13 @@ def get_dm_as_quoperator(self) -> QuOperator: return QuOperator(edges[: self._nqubits], edges[self._nqubits :]) def expectation( - self, *ops: Tuple[tn.Node, List[int]], reuse: bool = True, **kws: Any + self, + *ops: Tuple[tn.Node, List[int]], + reuse: bool = True, + noise_conf: Optional[Any] = None, + nmc: int = 1000, + status: Optional[Tensor] = None, + **kws: Any ) -> tn.Node.tensor: """ Compute the expectation of corresponding operators. @@ -275,11 +281,30 @@ def expectation( :type ops: Tuple[tn.Node, List[int]] :param reuse: whether contract the density matrix in advance, defaults to True :type reuse: bool + :param noise_conf: Noise Configuration, defaults to None + :type noise_conf: Optional[NoiseConf], optional + :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000 + :type nmc: int + :param status: external randomness given by tensor uniformly from [0, 1], defaults to None, + used for noisfy circuit sampling + :type status: Optional[Tensor], optional :return: Tensor with one element :rtype: Tensor """ - nodes = self.expectation_before(*ops, reuse=reuse) - return contractor(nodes).tensor + from .noisemodel import expectation_noisfy + + if noise_conf is None: + nodes = self.expectation_before(*ops, reuse=reuse) + return contractor(nodes).tensor + else: + return expectation_noisfy( + self, + *ops, + noise_conf=noise_conf, + nmc=nmc, + status=status, + **kws, + ) @staticmethod def check_density_matrix(dm: Tensor) -> None: diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index 81a3414c..dfa6eb9c 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -821,6 +821,7 @@ def expectation( # type: ignore conj: bool = True, normalize: bool = False, split: Optional[Dict[str, Any]] = None, + **kws: Any, ) -> Tensor: """ Compute the expectation of corresponding operators in the form of tensor. diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 3a02461c..f3f4782f 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -2,7 +2,9 @@ General Noise Model Construction. """ import logging -from typing import Any, Sequence, Optional, List, Dict +from typing import Any, Sequence, Optional, List, Dict, Tuple + +import tensornetwork as tn from .abstractcircuit import AbstractCircuit from . import gates @@ -154,13 +156,13 @@ def apply_qir_with_noise( c.unitary_kraus( noise_kraus, *d["index"], - status=status[quantum_index] # type: ignore + status=status[quantum_index], # type: ignore ) else: c.general_kraus( noise_kraus, *d["index"], - status=status[quantum_index] # type: ignore + status=status[quantum_index], # type: ignore ) quantum_index += 1 @@ -191,106 +193,195 @@ def circuit_with_noise( return cnew -def expectation_ps_noisfy( +# def expectation_ps_noisfy( +# c: Any, +# x: Optional[Sequence[int]] = None, +# y: Optional[Sequence[int]] = None, +# z: Optional[Sequence[int]] = None, +# noise_conf: Optional[NoiseConf] = None, +# nmc: int = 1000, +# status: Optional[Tensor] = None, +# ) -> Tensor: + +# if noise_conf is None: +# noise_conf = NoiseConf() + +# num_quantum = c.gate_count(list(noise_conf.nc.keys())) + +# if noise_conf.has_readout is True: +# logger.warning("expectation_ps_noisfy can't support readout error.") + +# if noise_conf.has_quantum is True: + +# # density matrix +# if isinstance(c, DMCircuit): +# cnoise = circuit_with_noise(c, noise_conf) +# return cnoise.expectation_ps(x=x, y=y, z=z) + +# # monte carlo +# else: + +# def mcsim(status: Optional[Tensor]) -> Tensor: +# cnoise = circuit_with_noise(c, noise_conf, status) # type: ignore +# return cnoise.expectation_ps(x=x, y=y, z=z) + +# mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) +# if status is None: +# status = backend.implicit_randu([nmc, num_quantum]) + +# value = backend.mean(mcsim_vmap(status)) + +# return value + +# else: +# return c.expectation_ps(x=x, y=y, z=z) + + +def sample_expectation_ps_noisfy( c: Any, x: Optional[Sequence[int]] = None, y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, noise_conf: Optional[NoiseConf] = None, nmc: int = 1000, + shots: Optional[int] = None, + statusc: Optional[Tensor] = None, status: Optional[Tensor] = None, + **kws: Any, ) -> Tensor: + """ + Calculate sample_expectation_ps with noise configuration. + + :param c: The clean circuit + :type c: Any + :param x: sites to apply X gate, defaults to None + :type x: Optional[Sequence[int]], optional + :param y: sites to apply Y gate, defaults to None + :type y: Optional[Sequence[int]], optional + :param z: sites to apply Z gate, defaults to None + :type z: Optional[Sequence[int]], optional + :param noise_conf: Noise Configuration, defaults to None + :type noise_conf: Optional[NoiseConf], optional + :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000 + :type nmc: int, optional + :param shots: number of measurement shots, defaults to None, indicating analytical result + :type shots: Optional[int], optional + :param statusc: external randomness given by tensor uniformly from [0, 1], defaults to None, + used for noisfy circuit sampling + :type statusc: Optional[Tensor], optional + :param status: external randomness given by tensor uniformly from [0, 1], defaults to None, + used for measurement sampling + :type status: Optional[Tensor], optional + :return: sample expectation value with noise + :rtype: Tensor + """ if noise_conf is None: noise_conf = NoiseConf() - else: - pass num_quantum = c.gate_count(list(noise_conf.nc.keys())) if noise_conf.has_readout is True: - logger.warning("expectation_ps_noisfy can't support readout error.") + readout_error = noise_conf.nc["readout"]["Default"] else: - pass + readout_error = None if noise_conf.has_quantum is True: # density matrix if isinstance(c, DMCircuit): - cnoise = circuit_with_noise(c, noise_conf) - return cnoise.expectation_ps(x=x, y=y, z=z) + cnoise = circuit_with_noise(c, noise_conf) # type: ignore + return cnoise.sample_expectation_ps( + x=x, y=y, z=z, shots=shots, status=status, readout_error=readout_error + ) # monte carlo else: - def mcsim(status: Optional[Tensor]) -> Tensor: - cnoise = circuit_with_noise(c, noise_conf, status) # type: ignore - return cnoise.expectation_ps(x=x, y=y, z=z) + def mcsim(statusc: Optional[Tensor], status: Optional[Tensor]) -> Tensor: + cnoise = circuit_with_noise(c, noise_conf, statusc) # type: ignore + return cnoise.sample_expectation_ps( + x=x, + y=y, + z=z, + shots=shots, + status=status, + readout_error=readout_error, + ) + + mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=(0, 1)) + if statusc is None: + statusc = backend.implicit_randu([nmc, num_quantum]) - mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) if status is None: - status = backend.implicit_randu([nmc, num_quantum]) - else: - pass - value = backend.mean(mcsim_vmap(status)) + if shots is None: + status = backend.implicit_randu([nmc, 1]) + else: + status = backend.implicit_randu([nmc, shots]) + value = backend.mean(mcsim_vmap(statusc, status)) return value else: - return c.expectation_ps(x=x, y=y, z=z) + value = c.sample_expectation_ps( + x=x, y=y, z=z, shots=shots, status=status, readout_error=readout_error + ) + return value -def sample_expectation_ps_noisfy( +def expectation_noisfy( c: Any, - x: Optional[Sequence[int]] = None, - y: Optional[Sequence[int]] = None, - z: Optional[Sequence[int]] = None, + *ops: Tuple[tn.Node, List[int]], noise_conf: Optional[NoiseConf] = None, nmc: int = 1000, - shots: Optional[int] = None, status: Optional[Tensor] = None, + **kws: Any, ) -> Tensor: + """ + Calculate expectation value with noise configuration. + + :param c: The clean circuit + :type c: Any + :param noise_conf: Noise Configuration, defaults to None + :type noise_conf: Optional[NoiseConf], optional + :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000 + :type nmc: int, optional + :param status: external randomness given by tensor uniformly from [0, 1], defaults to None, + used for noisfy circuit sampling + :type status: Optional[Tensor], optional + :return: expectation value with noise + :rtype: Tensor + """ if noise_conf is None: noise_conf = NoiseConf() - else: - pass num_quantum = c.gate_count(list(noise_conf.nc.keys())) if noise_conf.has_readout is True: - readout_error = noise_conf.nc["readout"]["Default"] - else: - readout_error = None + logger.warning("expectation_ps_noisfy can't support readout error.") if noise_conf.has_quantum is True: # density matrix if isinstance(c, DMCircuit): - cnoise = circuit_with_noise(c, noise_conf) # type: ignore - return cnoise.sample_expectation_ps( - x=x, y=y, z=z, shots=shots, readout_error=readout_error - ) + cnoise = circuit_with_noise(c, noise_conf) + return cnoise.expectation(*ops, **kws) # monte carlo else: def mcsim(status: Optional[Tensor]) -> Tensor: cnoise = circuit_with_noise(c, noise_conf, status) # type: ignore - return cnoise.sample_expectation_ps( - x=x, y=y, z=z, shots=shots, readout_error=readout_error - ) + return cnoise.expectation(*ops, **kws) mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) if status is None: status = backend.implicit_randu([nmc, num_quantum]) - else: - pass + value = backend.mean(mcsim_vmap(status)) + return value else: - value = c.sample_expectation_ps( - x=x, y=y, z=z, shots=shots, readout_error=readout_error - ) - return value + return c.expectation(*ops, **kws) diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index aca8f546..73ea6a05 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -6,8 +6,8 @@ from tensorcircuit.noisemodel import ( NoiseConf, circuit_with_noise, - expectation_ps_noisfy, sample_expectation_ps_noisfy, + expectation_noisfy, ) from tensorcircuit.channels import composedkraus @@ -59,11 +59,11 @@ def test_noisemodel(backend): cnoise = circuit_with_noise(c, noise_conf, [0.1] * 7) value = cnoise.expectation_ps(x=[0, 1]) - value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) - np.testing.assert_allclose(value, 0.09, atol=1e-1) + # value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) + # np.testing.assert_allclose(value, 0.09, atol=1e-1) - value = expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf) - np.testing.assert_allclose(value, 0.09, atol=1e-1) + # value = expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf) + # np.testing.assert_allclose(value, 0.09, atol=1e-1) # with readout_error value = sample_expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf) @@ -81,8 +81,8 @@ def test_noisemodel(backend): noise_conf1.add_noise("cnot", [error2], [[0, 1]]) noise_conf1.add_noise("readout", readout_error) - value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf1, nmc=10000) - np.testing.assert_allclose(value, 0.09, atol=1e-1) + # value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf1, nmc=10000) + # np.testing.assert_allclose(value, 0.09, atol=1e-1) # test standardized gate newerror = composedkraus(error1, error3) @@ -93,5 +93,60 @@ def test_noisemodel(backend): noise_conf2.add_noise("cx", [error2], [[0, 1]]) noise_conf2.add_noise("readout", readout_error) - value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf2, nmc=10000) - np.testing.assert_allclose(value, 0.09, atol=1e-1) + # value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf2, nmc=10000) + # np.testing.assert_allclose(value, 0.09, atol=1e-1) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_general_noisemodel(backend): + c = tc.Circuit(2) + c.cnot(0, 1) + c.rx(0, theta=0.4) + c.rx(1, theta=0.8) + c.h(0) + c.h(1) + + dmc = tc.DMCircuit(2) + dmc.cnot(0, 1) + dmc.rx(0, theta=0.4) + dmc.rx(1, theta=0.8) + dmc.h(0) + dmc.h(1) + + error1 = tc.channels.generaldepolarizingchannel(0.1, 1) + error2 = tc.channels.generaldepolarizingchannel(0.06, 2) + error3 = tc.channels.thermalrelaxationchannel(300, 400, 100, "ByChoi", 0) + + readout_error = [] + readout_error.append([0.9, 0.75]) + readout_error.append([0.4, 0.7]) + + noise_conf = NoiseConf() + noise_conf.add_noise("rx", error1) + noise_conf.add_noise("rx", [error3], [[0]]) + noise_conf.add_noise("h", [error3, error1], [[0], [1]]) + noise_conf.add_noise("x", [error3], [[0]]) + noise_conf.add_noise("cnot", [error2], [[0, 1]]) + noise_conf.add_noise("readout", readout_error) + + # # test sample_expectation_ps + value1 = sample_expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) + value2 = c.sample_expectation_ps(x=[0, 1], noise_conf=noise_conf, nmc=10000) + value3 = dmc.sample_expectation_ps(x=[0, 1], noise_conf=noise_conf) + np.testing.assert_allclose(value1, value2, atol=1e-1) + np.testing.assert_allclose(value3, value2, atol=1e-1) + + # test expectation + value1 = expectation_noisfy( + c, (tc.gates.z(), [0]), noise_conf=noise_conf, nmc=10000 + ) + value2 = c.expectation((tc.gates.z(), [0]), noise_conf=noise_conf, nmc=10000) + value3 = dmc.expectation((tc.gates.z(), [0]), noise_conf=noise_conf) + np.testing.assert_allclose(value1, value2, atol=1e-1) + np.testing.assert_allclose(value3, value2, atol=1e-1) + + # test expectation_ps + # value = expectation_ps_noisfy(c, x=[0], noise_conf=noise_conf, nmc=10000) + value1 = c.expectation_ps(x=[0], noise_conf=noise_conf, nmc=10000) + value2 = dmc.expectation_ps(x=[0], noise_conf=noise_conf) + np.testing.assert_allclose(value1, value2, atol=1e-1) From 6e11924e1a6fa9c654a32b25fc62506ce74c20a9 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Wed, 23 Nov 2022 19:00:01 +0800 Subject: [PATCH 080/725] revise DMcircuit nmc --- tensorcircuit/densitymatrix.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/tensorcircuit/densitymatrix.py b/tensorcircuit/densitymatrix.py index 59a27efa..4197bcd9 100644 --- a/tensorcircuit/densitymatrix.py +++ b/tensorcircuit/densitymatrix.py @@ -269,7 +269,6 @@ def expectation( *ops: Tuple[tn.Node, List[int]], reuse: bool = True, noise_conf: Optional[Any] = None, - nmc: int = 1000, status: Optional[Tensor] = None, **kws: Any ) -> tn.Node.tensor: @@ -283,8 +282,6 @@ def expectation( :type reuse: bool :param noise_conf: Noise Configuration, defaults to None :type noise_conf: Optional[NoiseConf], optional - :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000 - :type nmc: int :param status: external randomness given by tensor uniformly from [0, 1], defaults to None, used for noisfy circuit sampling :type status: Optional[Tensor], optional @@ -301,7 +298,6 @@ def expectation( self, *ops, noise_conf=noise_conf, - nmc=nmc, status=status, **kws, ) From 94da851f697780ce573a22d15e6371f7b8275a1f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 23 Nov 2022 19:57:33 +0800 Subject: [PATCH 081/725] update changelog --- CHANGELOG.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 220b1da2..d6aa6a86 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,13 +18,15 @@ - Add `tc.channels.composedkraus` to compose the different Kraus operators as a new one +- Add direct support for noise model via `sample_expectation_ps` and `expectation` methods, both Monte Carlo trajectory and density matrix evolution approaches are supported + ### Changed -- Improve the efficiency of `sample_expectation_ps` method by using cached state. +- Improve the efficiency of `sample_expectation_ps` method by using cached state ### Fixed -- Fixed `unitary_kraus` of Circuit class support for multi-qubit kraus channels, previous implementation fails to reshape the kraus tensor as matrix +- Fixed `unitary_kraus` of Circuit class support for multi-qubit kraus channels, previous implementation fails to reshape the multi-qubit kraus tensor as matrix - Fixed `kraus_to_super_gate` bug when multi-qubit kraus channels are presented on tensorflow backend From 7c9f6f4058395df4af94b2c22f61d9aeaad186bf Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 24 Nov 2022 09:54:05 +0800 Subject: [PATCH 082/725] v0.6.0 --- CHANGELOG.md | 2 ++ tensorcircuit/__init__.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d6aa6a86..19e69063 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.6.0 + ### Added - Add native support for `rxx`, `ryy` and `rzz` gates for translation from qiskit diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index e89590f7..86a4385e 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.5.0" +__version__ = "0.6.0" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From 7e01726edcf3b7d73bb1b2550cd62c9cfb30398d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 24 Nov 2022 16:59:10 +0800 Subject: [PATCH 083/725] fix api change in cloud --- tensorcircuit/cloud/tencent.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index c87c55ea..5be77d93 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -170,6 +170,8 @@ def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: if "result" in r["task"]: if "counts" in r["task"]["result"]: r["task"]["results"] = r["task"]["result"]["counts"] + else: + r["task"]["results"] = r["task"]["result"] return r["task"] # type: ignore except KeyError: raise ValueError(dumps(r)) From 166b88eff69d343eff3e50936ac5b07fe8813e02 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 28 Nov 2022 11:24:22 +0800 Subject: [PATCH 084/725] ordered results --- tensorcircuit/cloud/abstraction.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index e2cd260c..30e15e15 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -186,4 +186,5 @@ def results(self, format: Optional[str] = None) -> Any: if self.state() != "completed": raise ValueError("Task %s is not completed yet" % self.id_) r = self.details()["results"] + r = {k: v for k, v in sorted(r.items(), key=lambda item: -item[1])} return r From 460068377990ae9de30ef3b213dd55cc1af9cdbb Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 28 Nov 2022 12:17:24 +0800 Subject: [PATCH 085/725] fix adjoint bug --- CHANGELOG.md | 4 ++++ tensorcircuit/gates.py | 17 ++++++++--------- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 19e69063..ac859305 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Fixed + +- Fix adjoint possible bug with agnostic backend + ## 0.6.0 ### Added diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index 6e0b5e05..5c0fae4b 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -359,15 +359,14 @@ def __call__(self, *args: Any, **kws: Any) -> Gate: def adjoint(self) -> "GateVF": def f(*args: Any, **kws: Any) -> Gate: m = self.__call__(*args, **kws) - npb = get_backend("numpy") - shape0 = npb.shape_tuple(m.tensor) - m0 = npb.reshapem(m.tensor) - ma = npb.adjoint(m0) - if np.allclose(m0, ma, atol=1e-5): - name = self.n - else: - name = self.n + "d" - ma = npb.reshape(ma, shape0) + shape0 = backend.shape_tuple(m.tensor) + m0 = backend.reshapem(m.tensor) + ma = backend.adjoint(m0) + # if np.allclose(m0, ma, atol=1e-5): + # name = self.n + # else: + name = self.n + "d" + ma = backend.reshape(ma, shape0) return Gate(ma, name) return GateVF(f, self.n + "d", self.ctrl) From 628402caef545e6d236f7ed4e174976e8d0b6997 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 29 Nov 2022 11:23:27 +0800 Subject: [PATCH 086/725] add blocked result --- tensorcircuit/cloud/abstraction.py | 18 ++++++++++++------ tensorcircuit/cloud/tencent.py | 13 +++++-------- 2 files changed, 17 insertions(+), 14 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 30e15e15..da94d189 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -3,6 +3,7 @@ """ from typing import Any, Dict, List, Optional, Union +import time class Provider: @@ -180,11 +181,16 @@ def resubmit(self) -> "Task": return resubmit_task(self) - def results(self, format: Optional[str] = None) -> Any: + def results(self, format: Optional[str] = None, blocked: bool = False) -> Any: # TODO(@refraction-ray): support different formats compatible with tc, # also support format_ alias - if self.state() != "completed": - raise ValueError("Task %s is not completed yet" % self.id_) - r = self.details()["results"] - r = {k: v for k, v in sorted(r.items(), key=lambda item: -item[1])} - return r + if not blocked: + if self.state() != "completed": + raise ValueError("Task %s is not completed yet" % self.id_) + r = self.details()["results"] + r = {k: v for k, v in sorted(r.items(), key=lambda item: -item[1])} + return r + else: + while self.state() != "completed": + time.sleep(0.5) + return self.results(format=format, blocked=False) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 5be77d93..ef5478ec 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -146,15 +146,12 @@ def list_tasks(device: Device, token: str, **filter_kws: Any) -> List[Task]: try: rtn = [] for t in r["tasks"]: - if "err" in t: - logger.warning(t["err"]) - else: - rtn.append( - Task( - id_=t["id"], - device=Device.from_name("tencent" + sep + t["device"]), - ) + rtn.append( + Task( + id_=t["id"], + device=Device.from_name("tencent" + sep + t["device"]), ) + ) return rtn except KeyError: raise ValueError(dumps(r)) From 598fd07b4f6884b2c039dac26e0f59372fbe92db Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 29 Nov 2022 16:59:24 +0800 Subject: [PATCH 087/725] cancel task (untest) and get rid of ml backend --- tensorcircuit/cloud/abstraction.py | 2 +- tensorcircuit/cloud/apis.py | 25 ++++++++++++++++++++++--- tensorcircuit/cloud/tencent.py | 10 ++++++++++ tests/test_cloud.py | 1 + 4 files changed, 34 insertions(+), 4 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index da94d189..632ae030 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -188,7 +188,7 @@ def results(self, format: Optional[str] = None, blocked: bool = False) -> Any: if self.state() != "completed": raise ValueError("Task %s is not completed yet" % self.id_) r = self.details()["results"] - r = {k: v for k, v in sorted(r.items(), key=lambda item: -item[1])} + r = {k: v for k, v in sorted(r.items(), key=lambda item: -item[1])} # type: ignore return r else: while self.state() != "completed": diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 7378a932..818c9c57 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -11,7 +11,6 @@ from .abstraction import Provider, Device, Task, sep from . import tencent -from ..cons import backend package_name = "tensorcircuit" thismodule = sys.modules[__name__] @@ -99,7 +98,8 @@ def set_token( if cached and os.path.exists(authpath): with open(authpath, "r") as f: file_token = json.load(f) - file_token = backend.tree_map(b64decode_s, file_token) + file_token = {k: b64decode_s(v) for k, v in file_token.items()} + # file_token = backend.tree_map(b64decode_s, file_token) else: file_token = {} file_token.update(saved_token) @@ -114,7 +114,9 @@ def set_token( saved_token.update(added_token) if cached: - file_token = backend.tree_map(b64encode_s, saved_token) + # file_token = backend.tree_map(b64encode_s, saved_token) + file_token = {k: b64encode_s(v) for k, v in saved_token.items()} + with open(authpath, "w") as f: json.dump(file_token, f) @@ -252,6 +254,23 @@ def resubmit_task( raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore +def cancel_task( + task: Optional[Union[str, Task]], + token: Optional[str] = None, +) -> Task: + if isinstance(task, str): + task = Task(task) + device = task.get_device() # type: ignore + if token is None: + token = device.get_token() + provider = device.provider + + if provider.name == "tencent": # type: ignore + return tencent.cancel_task(task, token) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + def list_tasks( provider: Optional[Union[str, Provider]] = None, device: Optional[Union[str, Device]] = None, diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index ef5478ec..5bb0d4ad 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -133,6 +133,16 @@ def resubmit_task(task: Task, token: str) -> Task: raise ValueError(dumps(r)) +def cancel_task(task: Task, token: str) -> Any: + # TODO(@refraction-ray): batch cancel + json = {"id": task.id_} + r = rpost_json( + tencent_base_url + "task/remove", json=json, headers=tencent_headers(token) + ) + r = error_handling(r) + return r + + def list_tasks(device: Device, token: str, **filter_kws: Any) -> List[Task]: json = filter_kws if device is not None: diff --git a/tests/test_cloud.py b/tests/test_cloud.py index 5a93d7d0..1ea0db0f 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -56,6 +56,7 @@ def test_submit_task(): t = apis.submit_task(device="simulator:aer", circuit=c) r = t.details() assert r["state"] in ["pending", "completed"] + print(t.results(blocked=True)) def test_resubmit_task(): From 32ec35445dece2d817cc68d01b75d798fb97f505 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 30 Nov 2022 12:47:51 +0800 Subject: [PATCH 088/725] fix status bug in blocked results and rename cancel to remove task --- tensorcircuit/cloud/abstraction.py | 8 ++++++-- tensorcircuit/cloud/apis.py | 4 ++-- tensorcircuit/cloud/tencent.py | 2 +- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 632ae030..08a1d548 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -191,6 +191,10 @@ def results(self, format: Optional[str] = None, blocked: bool = False) -> Any: r = {k: v for k, v in sorted(r.items(), key=lambda item: -item[1])} # type: ignore return r else: - while self.state() != "completed": - time.sleep(0.5) + s = self.state() + while s != "completed": + if s in ["failed"]: + raise ValueError("Task %s is in %s state" % (self.id_, s)) + time.sleep(1.0) + s = self.state() return self.results(format=format, blocked=False) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 818c9c57..a5c139a2 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -254,7 +254,7 @@ def resubmit_task( raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore -def cancel_task( +def remove_task( task: Optional[Union[str, Task]], token: Optional[str] = None, ) -> Task: @@ -266,7 +266,7 @@ def cancel_task( provider = device.provider if provider.name == "tencent": # type: ignore - return tencent.cancel_task(task, token) # type: ignore + return tencent.remove_task(task, token) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 5bb0d4ad..f78bedee 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -133,7 +133,7 @@ def resubmit_task(task: Task, token: str) -> Task: raise ValueError(dumps(r)) -def cancel_task(task: Task, token: str) -> Any: +def remove_task(task: Task, token: str) -> Any: # TODO(@refraction-ray): batch cancel json = {"id": task.id_} r = rpost_json( From 4ee6c0e83960c796bfb2662171bc558f10d4ac8c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 1 Dec 2022 17:13:31 +0800 Subject: [PATCH 089/725] fix pytorch sigmoid --- CHANGELOG.md | 2 ++ tensorcircuit/backends/pytorch_backend.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ac859305..d2869a8a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Fix adjoint possible bug with agnostic backend +- Fix `sigmoid` bug on pytorch backend + ## 0.6.0 ### Added diff --git a/tensorcircuit/backends/pytorch_backend.py b/tensorcircuit/backends/pytorch_backend.py index d5124af1..52af8b84 100644 --- a/tensorcircuit/backends/pytorch_backend.py +++ b/tensorcircuit/backends/pytorch_backend.py @@ -351,7 +351,7 @@ def unique_with_counts(self, a: Tensor, **kws: Any) -> Tuple[Tensor, Tensor]: return torchlib.unique(a, return_counts=True) # type: ignore def sigmoid(self, a: Tensor) -> Tensor: - return torchlib.nn.Sigmoid(a) + return torchlib.sigmoid(a) def relu(self, a: Tensor) -> Tensor: return torchlib.nn.ReLU(a) From 65d9f89399fa0ff599b9e7b0b37db6c9c8c9b3e3 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 2 Dec 2022 20:36:24 +0800 Subject: [PATCH 090/725] add results module --- tensorcircuit/results/__init__.py | 2 + tensorcircuit/results/counts.py | 51 +++++++ tensorcircuit/results/readout_mitigation.py | 146 ++++++++++++++++++++ tests/test_results.py | 14 ++ 4 files changed, 213 insertions(+) create mode 100644 tensorcircuit/results/__init__.py create mode 100644 tensorcircuit/results/counts.py create mode 100644 tensorcircuit/results/readout_mitigation.py create mode 100644 tests/test_results.py diff --git a/tensorcircuit/results/__init__.py b/tensorcircuit/results/__init__.py new file mode 100644 index 00000000..523c5ad6 --- /dev/null +++ b/tensorcircuit/results/__init__.py @@ -0,0 +1,2 @@ +from . import counts +from . import readout_mitigation diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py new file mode 100644 index 00000000..c1e29222 --- /dev/null +++ b/tensorcircuit/results/counts.py @@ -0,0 +1,51 @@ +""" +dict related functionalities +""" +from typing import Any, Dict, Sequence + +import numpy as np +import qiskit + + +Tensor = Any +ct = Dict[str, int] + + +def reverse_count(count: ct) -> ct: + ncount = {} + for k, v in count.items(): + ncount[k[::-1]] = v + return ncount + + +def marginal_count(count: ct, keep_list: Sequence[int]) -> ct: + count = reverse_count(count) + ncount = qiskit.result.utils.marginal_distribution(count, keep_list) + return reverse_count(ncount) + + +def count2vec(count: ct, normalization: bool = True) -> Tensor: + nqubit = len(list(count.keys())[0]) + probability = [0] * 2**nqubit + shots = sum([v for k, v in count.items()]) + for k, v in count.items(): + if normalization is True: + v /= shots # type: ignore + probability[int(k, 2)] = v + return np.array(probability) + + +def vec2count(vec: Tensor, prune: bool = False) -> ct: + from ..quantum import count_vector2dict + + if isinstance(vec, list): + vec = np.array(vec) + n = int(np.log(vec.shape[0]) / np.log(2) + 1e-9) + c = count_vector2dict(vec, n, key="bin") + if prune is True: + nc = c.copy() + for k, v in c.items(): + if np.abs(v) < 1e-8: + del nc[k] + return nc + return c diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py new file mode 100644 index 00000000..d092fcb3 --- /dev/null +++ b/tensorcircuit/results/readout_mitigation.py @@ -0,0 +1,146 @@ +""" +readout error mitigation functionalities +""" + +from typing import Any, Callable, List, Union +import numpy as np +from scipy.optimize import minimize + +from .counts import count2vec, vec2count, ct +from ..circuit import Circuit +from ..utils import is_sequence + +Tensor = Any + + +class ReadoutCal: + def __init__(self, cal: Union[Tensor, List[Tensor]]): + self.cal = cal + if is_sequence(cal): + self.local = True + self.n = len(cal) + else: + self.local = False + self.n = int(np.log(cal.shape[0]) / np.log(2) + 1e-9) # type: ignore + + def get_matrix(self) -> Tensor: + # cache + if getattr(self, "calmatrix", False): + return self.calmatrix # type: ignore + if self.local is False: + self.calmatrix = self.cal # type: ignore + return self.cal + # self.local = True + calmatrix = self.cal[0] + for i in range(1, self.n): + calmatrix = np.kron(calmatrix, self.cal[i]) + self.calmatrix = calmatrix + return calmatrix + + +def local_miti_readout_circ(nqubit: int) -> List[Circuit]: + miticirc = [] + c = Circuit(nqubit) + miticirc.append(c) + c = Circuit(nqubit) + for i in range(nqubit): + c.X(i) # type: ignore + miticirc.append(c) + return miticirc + + +def global_miti_readout_circ(nqubit: int) -> List[Circuit]: + miticirc = [] + for i in range(2**nqubit): + name = "{:0" + str(nqubit) + "b}" + lisbs = [int(x) for x in name.format(i)] + c = Circuit(nqubit) + for k in range(nqubit): + if lisbs[k] == 1: + c.X(k) # type: ignore + miticirc.append(c) + return miticirc + + +def mitigate_probability( + probability_noise: Tensor, readout_cal: ReadoutCal, method: str = "inverse" +) -> Tensor: + calmatrix = readout_cal.get_matrix() + if method == "inverse": + X = np.linalg.inv(calmatrix) + Y = probability_noise + probability_cali = X @ Y + else: # method="square" + + def fun(x: Any) -> Any: + return sum((probability_noise - calmatrix @ x) ** 2) + + x0 = np.random.rand(len(probability_noise)) + cons = {"type": "eq", "fun": lambda x: 1 - sum(x)} + bnds = tuple((0, 1) for x in x0) + res = minimize(fun, x0, method="SLSQP", constraints=cons, bounds=bnds, tol=1e-6) + probability_cali = res.x + return probability_cali + + +def apply_readout_mitigation( + raw_count: ct, readout_cal: ReadoutCal, method: str = "inverse" +) -> ct: + probability = count2vec(raw_count) + shots = sum([v for k, v in raw_count.items()]) + probability = mitigate_probability(probability, readout_cal, method=method) + probability = probability * shots + return vec2count(probability) + + +def get_readout_cal( + nqubit: int, shots: int, execute_fun: Callable[..., ct], miti_method: str = "local" +) -> ReadoutCal: + # TODO(@refraction-ray): more general qubit list + if miti_method == "local": + miticirc = local_miti_readout_circ(nqubit) + + lbs = [] + for c in miticirc: + bs = execute_fun(c, shots) + # t = apis.submit_task(device=device, circuit=c, shots=shots) + # bs = t.results(blocked=True) + lbs.append(bs) + + readoutlist = [] + for i in range(nqubit): + error00 = 0 + for s in lbs[0]: + if s[i] == "0": + error00 = error00 + lbs[0][s] / shots # type: ignore + + error10 = 0 + for s in lbs[1]: + if s[i] == "0": + error10 = error10 + lbs[1][s] / shots # type: ignore + readoutlist.append( + np.array( + [ + [error00, error10], + [1 - error00, 1 - error10], + ] + ) + ) + + return ReadoutCal(readoutlist) + + elif miti_method == "global": + miticirc = global_miti_readout_circ(nqubit) + calmatrix = np.zeros((2**nqubit, 2**nqubit)) + for i, c in enumerate(miticirc): + # c = miticirc[i] + # t = apis.submit_task(device=device, circuit=c, shots=shots) + # bs = t.results(blocked=True) + bs = execute_fun(c, shots) + for s in bs: + calmatrix[int(s, 2)][i] = bs[s] / shots + + return ReadoutCal(calmatrix) + + else: + raise ValueError("Unrecognized `miti_method`: %s" % miti_method) diff --git a/tests/test_results.py b/tests/test_results.py new file mode 100644 index 00000000..b5d1ea02 --- /dev/null +++ b/tests/test_results.py @@ -0,0 +1,14 @@ +from tensorcircuit.results import counts + + +d = {"000": 2, "101": 3, "100": 4} + + +def test_marginal_count(): + assert counts.marginal_count(d, [1, 2])["00"] == 6 + assert counts.marginal_count(d, [1])["0"] == 9 + assert counts.marginal_count(d, [2, 1, 0])["001"] == 4 + + +def test_count2vec(): + assert counts.vec2count(counts.count2vec(d, normalization=False), prune=True) == d From 0483d5a72a4f223c1c4213df252dc872c2f0f13d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 5 Dec 2022 10:31:42 +0800 Subject: [PATCH 091/725] add batch processing logical in readout_cal --- tensorcircuit/results/readout_mitigation.py | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index d092fcb3..66f50ba9 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -100,13 +100,7 @@ def get_readout_cal( if miti_method == "local": miticirc = local_miti_readout_circ(nqubit) - lbs = [] - for c in miticirc: - bs = execute_fun(c, shots) - # t = apis.submit_task(device=device, circuit=c, shots=shots) - # bs = t.results(blocked=True) - lbs.append(bs) - + lbs = execute_fun(miticirc, shots) readoutlist = [] for i in range(nqubit): error00 = 0 @@ -132,12 +126,9 @@ def get_readout_cal( elif miti_method == "global": miticirc = global_miti_readout_circ(nqubit) calmatrix = np.zeros((2**nqubit, 2**nqubit)) - for i, c in enumerate(miticirc): - # c = miticirc[i] - # t = apis.submit_task(device=device, circuit=c, shots=shots) - # bs = t.results(blocked=True) - bs = execute_fun(c, shots) - for s in bs: + lbs = execute_fun(miticirc, shots) + for i in range(len(miticirc)): + for s in lbs[i]: calmatrix[int(s, 2)][i] = bs[s] / shots return ReadoutCal(calmatrix) From dcd7676a301bef9a5ec09325c70b333109e6c629 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 5 Dec 2022 13:00:50 +0800 Subject: [PATCH 092/725] fix get calmatrix --- tensorcircuit/results/readout_mitigation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 66f50ba9..c8a0c87e 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -25,7 +25,7 @@ def __init__(self, cal: Union[Tensor, List[Tensor]]): def get_matrix(self) -> Tensor: # cache - if getattr(self, "calmatrix", False): + if getattr(self, "calmatrix", None) is not None: return self.calmatrix # type: ignore if self.local is False: self.calmatrix = self.cal # type: ignore From 1acaba55b56d81fdf2308dee2d8a67ebda004a22 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 5 Dec 2022 16:27:28 +0800 Subject: [PATCH 093/725] add kl divergence --- tensorcircuit/noisemodel.py | 2 +- tensorcircuit/results/counts.py | 15 +++++++++++++++ tensorcircuit/results/readout_mitigation.py | 7 +++++-- tests/test_results.py | 5 +++++ 4 files changed, 26 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index f3f4782f..6f50beb7 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -57,7 +57,7 @@ def add_noise( :param qubit: the list of noisy qubit, defaults to None, indicating applying the noise channel on all qubits :type qubit: Optional[Sequence[Any]], optional """ - if gate_name is not "readout": + if gate_name != "readout": gate_name = AbstractCircuit.standardize_gate(gate_name) if gate_name not in self.nc: diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index c1e29222..bf4868f3 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -18,6 +18,11 @@ def reverse_count(count: ct) -> ct: return ncount +def normalized_count(count: ct) -> Dict[str, float]: + shots = sum([v for k, v in count.items()]) + return {k: v / shots for k, v in count.items()} + + def marginal_count(count: ct, keep_list: Sequence[int]) -> ct: count = reverse_count(count) ncount = qiskit.result.utils.marginal_distribution(count, keep_list) @@ -49,3 +54,13 @@ def vec2count(vec: Tensor, prune: bool = False) -> ct: del nc[k] return nc return c + + +def kl_divergence(c1: ct, c2: ct) -> float: + eps = 1e-4 # typical value for inverse of the total shots + c1 = normalized_count(c1) # type: ignore + c2 = normalized_count(c2) # type: ignore + kl = 0 + for k, v in c1.items(): + kl += v * (np.log(v) - np.log(c2.get(k, eps))) + return kl diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index c8a0c87e..b15a0657 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -94,7 +94,10 @@ def apply_readout_mitigation( def get_readout_cal( - nqubit: int, shots: int, execute_fun: Callable[..., ct], miti_method: str = "local" + nqubit: int, + shots: int, + execute_fun: Callable[..., List[ct]], + miti_method: str = "local", ) -> ReadoutCal: # TODO(@refraction-ray): more general qubit list if miti_method == "local": @@ -129,7 +132,7 @@ def get_readout_cal( lbs = execute_fun(miticirc, shots) for i in range(len(miticirc)): for s in lbs[i]: - calmatrix[int(s, 2)][i] = bs[s] / shots + calmatrix[int(s, 2)][i] = lbs[i][s] / shots return ReadoutCal(calmatrix) diff --git a/tests/test_results.py b/tests/test_results.py index b5d1ea02..7ace4aaa 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -12,3 +12,8 @@ def test_marginal_count(): def test_count2vec(): assert counts.vec2count(counts.count2vec(d, normalization=False), prune=True) == d + + +def test_kl(): + a = {"00": 512, "11": 512} + assert counts.kl_divergence(a, a) == 0 From d76037273c3963cffbff7e5ece187725540980e9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 5 Dec 2022 16:27:28 +0800 Subject: [PATCH 094/725] add kl divergence --- tensorcircuit/noisemodel.py | 2 +- tensorcircuit/results/counts.py | 15 +++++++++++++++ tensorcircuit/results/readout_mitigation.py | 7 +++++-- tests/test_results.py | 5 +++++ 4 files changed, 26 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index f3f4782f..6f50beb7 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -57,7 +57,7 @@ def add_noise( :param qubit: the list of noisy qubit, defaults to None, indicating applying the noise channel on all qubits :type qubit: Optional[Sequence[Any]], optional """ - if gate_name is not "readout": + if gate_name != "readout": gate_name = AbstractCircuit.standardize_gate(gate_name) if gate_name not in self.nc: diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index c1e29222..bf4868f3 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -18,6 +18,11 @@ def reverse_count(count: ct) -> ct: return ncount +def normalized_count(count: ct) -> Dict[str, float]: + shots = sum([v for k, v in count.items()]) + return {k: v / shots for k, v in count.items()} + + def marginal_count(count: ct, keep_list: Sequence[int]) -> ct: count = reverse_count(count) ncount = qiskit.result.utils.marginal_distribution(count, keep_list) @@ -49,3 +54,13 @@ def vec2count(vec: Tensor, prune: bool = False) -> ct: del nc[k] return nc return c + + +def kl_divergence(c1: ct, c2: ct) -> float: + eps = 1e-4 # typical value for inverse of the total shots + c1 = normalized_count(c1) # type: ignore + c2 = normalized_count(c2) # type: ignore + kl = 0 + for k, v in c1.items(): + kl += v * (np.log(v) - np.log(c2.get(k, eps))) + return kl diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index c8a0c87e..b15a0657 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -94,7 +94,10 @@ def apply_readout_mitigation( def get_readout_cal( - nqubit: int, shots: int, execute_fun: Callable[..., ct], miti_method: str = "local" + nqubit: int, + shots: int, + execute_fun: Callable[..., List[ct]], + miti_method: str = "local", ) -> ReadoutCal: # TODO(@refraction-ray): more general qubit list if miti_method == "local": @@ -129,7 +132,7 @@ def get_readout_cal( lbs = execute_fun(miticirc, shots) for i in range(len(miticirc)): for s in lbs[i]: - calmatrix[int(s, 2)][i] = bs[s] / shots + calmatrix[int(s, 2)][i] = lbs[i][s] / shots return ReadoutCal(calmatrix) diff --git a/tests/test_results.py b/tests/test_results.py index b5d1ea02..7ace4aaa 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -12,3 +12,8 @@ def test_marginal_count(): def test_count2vec(): assert counts.vec2count(counts.count2vec(d, normalization=False), prune=True) == d + + +def test_kl(): + a = {"00": 512, "11": 512} + assert counts.kl_divergence(a, a) == 0 From baf084e0c09f75370a211d91a04b7db0e48addb6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 5 Dec 2022 19:35:41 +0800 Subject: [PATCH 095/725] add correlations --- tensorcircuit/results/counts.py | 17 ++++++++++++++++- tests/test_results.py | 4 ++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index bf4868f3..1498e09b 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -1,7 +1,7 @@ """ dict related functionalities """ -from typing import Any, Dict, Sequence +from typing import Any, Dict, Sequence, Tuple import numpy as np import qiskit @@ -64,3 +64,18 @@ def kl_divergence(c1: ct, c2: ct) -> float: for k, v in c1.items(): kl += v * (np.log(v) - np.log(c2.get(k, eps))) return kl + + +def correlation( + count: ct, zlist: Sequence[int], values: Tuple[int, int] = (1, -1) +) -> float: + map_dict = {"0": values[0], "1": values[1]} + r = 0 + shots = 0 + for k, v in count.items(): + ct = 1.0 + for i in zlist: + ct *= map_dict[k[i]] + r += ct * v # type: ignore + shots += v + return r / shots diff --git a/tests/test_results.py b/tests/test_results.py index 7ace4aaa..2426dea2 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -17,3 +17,7 @@ def test_count2vec(): def test_kl(): a = {"00": 512, "11": 512} assert counts.kl_divergence(a, a) == 0 + + +def test_correlation(): + assert counts.correlation(d, [0, 1]) == -5 / 9 From 72d0c935936fd06ccc6b3babe9800f846b01a40b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 5 Dec 2022 20:12:12 +0800 Subject: [PATCH 096/725] add sample_expectation_ps in cloud --- tensorcircuit/cloud/wrapper.py | 46 ++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 tensorcircuit/cloud/wrapper.py diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py new file mode 100644 index 00000000..18925dcd --- /dev/null +++ b/tensorcircuit/cloud/wrapper.py @@ -0,0 +1,46 @@ +""" +higher level wrapper shortcut for submit_task +""" +from typing import Any, Optional, Sequence + +import numpy as np + +from ..circuit import Circuit +from ..results import counts +from .apis import submit_task, get_device +from .abstraction import Device + +Tensor = Any + + +def sample_expectation_ps( + c: Circuit, + x: Optional[Sequence[int]] = None, + y: Optional[Sequence[int]] = None, + z: Optional[Sequence[int]] = None, + shots: int = 1024, + device: Optional[Device] = None, + **kws: Any, +) -> float: + # TODO(@refraction-ray): integrated error mitigation + c1 = Circuit.from_qir(c.to_qir()) + if x is None: + x = [] + if y is None: + y = [] + if z is None: + z = [] + for i in x: + c1.H(i) # type: ignore + for i in y: + c1.rx(i, theta=np.pi / 2) # type: ignore + if device is None: + device = get_device() + t = submit_task(circuit=c1, device=device, shots=shots) + raw_counts = t.results(blocked=True) # type: ignore + x, y, z = list(x), list(y), list(z) + return counts.correlation(raw_counts, x + y + z) + + +# TODO(@refraction-ray): batch support +# def batch_sample_expectation_ps(c, pss, ws, device, shots) From d5cb55b8330310c7116e36d18774bf50cbff6f49 Mon Sep 17 00:00:00 2001 From: JachyMeow <114171061+JachyMeow@users.noreply.github.com> Date: Tue, 6 Dec 2022 11:55:20 +0800 Subject: [PATCH 097/725] add mera --- docs/source/tutorials/mera.ipynb | 325 ++++++++++++++++++++++++++++ docs/source/tutorials/mera_cn.ipynb | 325 ++++++++++++++++++++++++++++ 2 files changed, 650 insertions(+) create mode 100644 docs/source/tutorials/mera.ipynb create mode 100644 docs/source/tutorials/mera_cn.ipynb diff --git a/docs/source/tutorials/mera.ipynb b/docs/source/tutorials/mera.ipynb new file mode 100644 index 00000000..309f820b --- /dev/null +++ b/docs/source/tutorials/mera.ipynb @@ -0,0 +1,325 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "64ba95d6", + "metadata": {}, + "source": [ + "#
MERA" + ] + }, + { + "cell_type": "markdown", + "id": "804d79c1", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "In this tutorial, we'll show you how to implement MERA (multi-scale entangled renormalization ansatz) with TensorCircuit, but not in physics perspective." + ] + }, + { + "cell_type": "markdown", + "id": "f4a7b1eb", + "metadata": {}, + "source": [ + "## Background\n", + "\n", + "MERA is a kind of VQE starts from only one qubit in the $\\ket{0}$ state, and progressively enlarges the Hilbert space by tensoring on new qubits.\n", + "In the MERA we are going to train (denoted by $U(\\theta)$), we use parameterized quantum gates $e^{i\\theta XX}$, $e^{i\\theta ZZ}$ as two-qubit gates and $e^{i\\theta X}$, $e^{i\\theta Z}$ as single-qubit gates.\n", + "The Hamiltonian we choose as the example is from TFIM as $ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $. \n", + "And the loss function to be minimized in this task is $\\mathcal{L}_{MERA}(\\rm{\\theta})=\\langle 0^n\\vert U(\\theta)^\\dagger \\hat{H} U(\\theta)\\vert 0^n\\rangle$. " + ] + }, + { + "cell_type": "markdown", + "id": "f7939c50", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4e1651b9", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('complex128', 'float64')" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import tensorcircuit as tc\n", + "tc.set_backend(\"tensorflow\")\n", + "tc.set_dtype(\"complex128\")" + ] + }, + { + "cell_type": "markdown", + "id": "d78b480b", + "metadata": {}, + "source": [ + "## Energy\n", + "We first design the Hamiltonian energy expectation function as loss.\n", + "$$ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fff67346", + "metadata": {}, + "outputs": [], + "source": [ + "def energy(c: tc.Circuit, j: float = 1.0, hx: float = 1.0):\n", + " e = 0.0\n", + " n = c._nqubits\n", + " # \n", + " for i in range(n-1): \n", + " e += j * c.expectation((tc.gates.z(), [i]), (tc.gates.z(), [i+1])) \n", + " # \n", + " for i in range(n):\n", + " e -= hx * c.expectation((tc.gates.x(), [i])) \n", + " return tc.backend.real(e)" + ] + }, + { + "cell_type": "markdown", + "id": "0ad6a7a6", + "metadata": {}, + "source": [ + "## MERA circuit\n", + "\n", + "Now we design the circuit. We use $\\theta$ as input." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "445b7c86", + "metadata": {}, + "outputs": [], + "source": [ + "def MERA(params, n):\n", + " params = tc.backend.cast(params, \"complex128\")\n", + " c = tc.Circuit(n)\n", + " \n", + " idx = 0 # index of params\n", + " \n", + " for i in range(n):\n", + " c.rx(i, theta=params[2*i])\n", + " c.rz(i, theta=params[2*i+1])\n", + " idx += 2*n\n", + " \n", + " for n_layer in range(1, int(np.log2(n))+1):\n", + " n_qubit = 2**n_layer # number of qubits involving\n", + " step = int(n / n_qubit)\n", + "\n", + " # even \n", + " for i in range(step, n-step, 2*step):\n", + " c.exp1(i, i+step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", + " c.exp1(i, i+step, theta=params[idx+1], unitary=tc.gates._zz_matrix)\n", + " idx += 2\n", + " \n", + " # odd \n", + " for i in range(0, n, 2*step):\n", + " c.exp1(i, i+step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", + " c.exp1(i, i+step, theta=params[idx+1], unitary=tc.gates._zz_matrix)\n", + " idx += 2\n", + " \n", + " # single qubit\n", + " for i in range(0, n, step):\n", + " c.rx(i, theta=params[idx])\n", + " c.rz(i, theta=params[idx+1])\n", + " idx += 2\n", + "\n", + " # measure\n", + " e = energy(c)\n", + " return e\n", + " # return c, idx" + ] + }, + { + "cell_type": "markdown", + "id": "49f0b702", + "metadata": {}, + "source": [ + "We can visualize the MERA circuit. \n", + "\n", + "Hint: Please change return to `return c, idx`, which will only be used here. After visulization, don't forget to restore the return and run the code block above again." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8b5fa87f", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number of parameters is 66\n" + ] + }, + { + "data": { + "image/svg+xml": "\n\n\n \n \n \n \n 2022-12-05T21:29:46.404387\n image/svg+xml\n \n \n Matplotlib v3.5.3, https://matplotlib.org/\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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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", + "text/plain": [ + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n = 8\n", + "cirq, idx = MERA(np.zeros(1000), n)\n", + "print(\"The number of parameters is\", idx)\n", + "cirq.draw()" + ] + }, + { + "cell_type": "markdown", + "id": "e9afb1a5", + "metadata": {}, + "source": [ + "## Train\n", + "\n", + "Now we can train the MERA circuit with tensorflow." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "873ebd5e", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tf.Tensor([-0.6449017 0.14083987 0.17227418 1.42731099 0.93767164], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.57952648 -9.15354269 -9.53415983 -9.55291257 -9.46880555], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.63166728 -9.60922826 -9.59883555 -9.66639936 -9.60174669], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.65441326 -9.61830383 -9.6219077 -9.68289435 -9.61427165], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.66991104 -9.6307931 -9.64993901 -9.71396225 -9.63848947], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.67960751 -9.64303661 -9.67696885 -9.76317346 -9.6507455 ], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68303361 -9.6575349 -9.70118521 -9.7740601 -9.65751254], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68481667 -9.67473162 -9.71392119 -9.78200161 -9.66880068], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.6864865 -9.67835678 -9.73033137 -9.79128949 -9.68317883], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68762425 -9.67928153 -9.77502182 -9.79465957 -9.69252806], shape=(5,), dtype=float64)\n" + ] + } + ], + "source": [ + "MERA_tfim_vvag = tc.backend.jit(\n", + " tc.backend.vectorized_value_and_grad(MERA)\n", + ")\n", + "\n", + "\n", + "def batched_train(n, batch=10, maxiter=10000, lr=0.005):\n", + " params = tf.Variable(\n", + " initial_value=tf.random.normal(\n", + " shape=[batch, idx], stddev=1, dtype=getattr(tf, tc.rdtypestr)\n", + " )\n", + " )\n", + " opt = tf.keras.optimizers.Adam(lr)\n", + " lowest_energy = 1e5\n", + " for i in range(maxiter):\n", + " e, grad = MERA_tfim_vvag(params, n)\n", + " opt.apply_gradients([(grad, params)])\n", + " if tf.reduce_min(e) MERA" + ] + }, + { + "cell_type": "markdown", + "id": "804d79c1", + "metadata": {}, + "source": [ + "## 概述\n", + "\n", + "在本教程中，我们将不涉及物理层面的探讨，而将演示如何使用TensorCircuit实现MERA (多尺度纠缠重整化假设，multi-scale entangled renormalization ansatz)。" + ] + }, + { + "cell_type": "markdown", + "id": "f4a7b1eb", + "metadata": {}, + "source": [ + "## 背景\n", + "\n", + "MERA是VQE的其中一种。它由一个量子比特的 $\\ket{0}$ 态开始，逐层添加新的量子比特以扩张希尔伯特空间。\n", + "在将要训练的MERA（记作 $U(\\theta)$ ）中，我们使用可变参量子门 $e^{i\\theta XX}$ 、$e^{i\\theta ZZ}$ 作为双比特门，以及 $e^{i\\theta X}$ 、$e^{i\\theta Z}$ 作为单比特门。\n", + "在本教程中，我们使用的哈密顿量是横场伊辛模型的哈密顿量 $ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $。\n", + "我们要减小的损失函数是 $\\mathcal{L}_{MERA}(\\rm{\\theta})=\\langle 0^n\\vert U(\\theta)^\\dagger \\hat{H} U(\\theta)\\vert 0^n\\rangle$。" + ] + }, + { + "cell_type": "markdown", + "id": "f7939c50", + "metadata": {}, + "source": [ + "## 设置" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4e1651b9", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('complex128', 'float64')" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import tensorcircuit as tc\n", + "tc.set_backend(\"tensorflow\")\n", + "tc.set_dtype(\"complex128\")" + ] + }, + { + "cell_type": "markdown", + "id": "d78b480b", + "metadata": {}, + "source": [ + "## 能量\n", + "我们先设计哈密顿量的能量期望函数作为损失函数。\n", + "$$ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fff67346", + "metadata": {}, + "outputs": [], + "source": [ + "def energy(c: tc.Circuit, j: float = 1.0, hx: float = 1.0):\n", + " e = 0.0\n", + " n = c._nqubits\n", + " # \n", + " for i in range(n-1): \n", + " e += j * c.expectation((tc.gates.z(), [i]), (tc.gates.z(), [i+1])) \n", + " # \n", + " for i in range(n):\n", + " e -= hx * c.expectation((tc.gates.x(), [i])) \n", + " return tc.backend.real(e)" + ] + }, + { + "cell_type": "markdown", + "id": "0ad6a7a6", + "metadata": {}, + "source": [ + "## MERA 电路\n", + "\n", + "现在，我们设计电路。我们用 $\\theta$ 作为输入。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "445b7c86", + "metadata": {}, + "outputs": [], + "source": [ + "def MERA(params, n):\n", + " params = tc.backend.cast(params, \"complex128\")\n", + " c = tc.Circuit(n)\n", + " \n", + " idx = 0 # index of params\n", + " \n", + " for i in range(n):\n", + " c.rx(i, theta=params[2*i])\n", + " c.rz(i, theta=params[2*i+1])\n", + " idx += 2*n\n", + " \n", + " for n_layer in range(1, int(np.log2(n))+1):\n", + " n_qubit = 2**n_layer # number of qubits involving\n", + " step = int(n / n_qubit)\n", + "\n", + " # 偶数层 \n", + " for i in range(step, n-step, 2*step):\n", + " c.exp1(i, i+step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", + " c.exp1(i, i+step, theta=params[idx+1], unitary=tc.gates._zz_matrix)\n", + " idx += 2\n", + " \n", + " # 奇数层 \n", + " for i in range(0, n, 2*step):\n", + " c.exp1(i, i+step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", + " c.exp1(i, i+step, theta=params[idx+1], unitary=tc.gates._zz_matrix)\n", + " idx += 2\n", + " \n", + " # 单比特门\n", + " for i in range(0, n, step):\n", + " c.rx(i, theta=params[idx])\n", + " c.rz(i, theta=params[idx+1])\n", + " idx += 2\n", + "\n", + " # 测量\n", + " e = energy(c)\n", + " return e\n", + " # return c, idx" + ] + }, + { + "cell_type": "markdown", + "id": "49f0b702", + "metadata": {}, + "source": [ + "我们可以将MERA电路可视化。 \n", + "\n", + "注意：请把return改为`return c, idx`。这个return只有在这儿会被用到。可视化完成后，请别忘了将return还原并重新运行上方代码块。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8b5fa87f", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number of parameters is 66\n" + ] + }, + { + "data": { + "image/svg+xml": "\n\n\n \n \n \n \n 2022-12-05T21:29:46.404387\n image/svg+xml\n \n \n Matplotlib v3.5.3, https://matplotlib.org/\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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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", + "text/plain": [ + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n = 8\n", + "cirq, idx = MERA(np.zeros(1000), n)\n", + "print(\"The number of parameters is\", idx)\n", + "cirq.draw()" + ] + }, + { + "cell_type": "markdown", + "id": "e9afb1a5", + "metadata": {}, + "source": [ + "## 训练\n", + "\n", + "现在，我们使用tensorflow训练MERA电路。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "873ebd5e", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tf.Tensor([-0.6449017 0.14083987 0.17227418 1.42731099 0.93767164], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.57952648 -9.15354269 -9.53415983 -9.55291257 -9.46880555], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.63166728 -9.60922826 -9.59883555 -9.66639936 -9.60174669], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.65441326 -9.61830383 -9.6219077 -9.68289435 -9.61427165], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.66991104 -9.6307931 -9.64993901 -9.71396225 -9.63848947], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.67960751 -9.64303661 -9.67696885 -9.76317346 -9.6507455 ], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68303361 -9.6575349 -9.70118521 -9.7740601 -9.65751254], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68481667 -9.67473162 -9.71392119 -9.78200161 -9.66880068], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.6864865 -9.67835678 -9.73033137 -9.79128949 -9.68317883], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68762425 -9.67928153 -9.77502182 -9.79465957 -9.69252806], shape=(5,), dtype=float64)\n" + ] + } + ], + "source": [ + "MERA_tfim_vvag = tc.backend.jit(\n", + " tc.backend.vectorized_value_and_grad(MERA)\n", + ")\n", + "\n", + "\n", + "def batched_train(n, batch=10, maxiter=10000, lr=0.005):\n", + " params = tf.Variable(\n", + " initial_value=tf.random.normal(\n", + " shape=[batch, idx], stddev=1, dtype=getattr(tf, tc.rdtypestr)\n", + " )\n", + " )\n", + " opt = tf.keras.optimizers.Adam(lr)\n", + " lowest_energy = 1e5\n", + " for i in range(maxiter):\n", + " e, grad = MERA_tfim_vvag(params, n)\n", + " opt.apply_gradients([(grad, params)])\n", + " if tf.reduce_min(e) Date: Tue, 6 Dec 2022 12:04:31 +0800 Subject: [PATCH 098/725] add pistr comment --- tensorcircuit/cloud/tencent.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index f78bedee..584e54dd 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -66,11 +66,14 @@ def submit_task( source: Optional[Union[str, Sequence[str]]] = None, remarks: Optional[str] = None, ) -> List[Task]: + # pistr = "3.14159265358979" if source is None: if is_sequence(circuit): source = [c.to_openqasm() for c in circuit] # type: ignore + # source = [s.replace("pi", pistr) for s in source] else: source = circuit.to_openqasm() # type: ignore + # source = source.replace("pi", pistr) lang = "OPENQASM" if is_sequence(source): # batched mode From 30b3b3c8c4263823ecff4bc34fe2406350f09137 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 6 Dec 2022 12:14:22 +0800 Subject: [PATCH 099/725] black and add to toc --- docs/source/tutorial.rst | 1 + docs/source/tutorial_cn.rst | 1 + docs/source/tutorials/mera.ipynb | 63 +++++++++++++++-------------- docs/source/tutorials/mera_cn.ipynb | 63 +++++++++++++++-------------- 4 files changed, 68 insertions(+), 60 deletions(-) diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index cd6938e5..b7dcf31f 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -12,6 +12,7 @@ Jupyter Tutorials tutorials/qml_scenarios.ipynb tutorials/vqe_h2o.ipynb tutorials/tfim_vqe_diffreph.ipynb + tutorials/mera.ipynb tutorials/gradient_benchmark.ipynb tutorials/contractors.ipynb tutorials/operator_spreading.ipynb diff --git a/docs/source/tutorial_cn.rst b/docs/source/tutorial_cn.rst index e3c062a5..a6f4d03f 100644 --- a/docs/source/tutorial_cn.rst +++ b/docs/source/tutorial_cn.rst @@ -12,6 +12,7 @@ tutorials/qml_scenarios_cn.ipynb tutorials/vqe_h2o_cn.ipynb tutorials/tfim_vqe_diffreph_cn.ipynb + tutorials/mera_cn.ipynb tutorials/gradient_benchmark_cn.ipynb tutorials/contractors_cn.ipynb tutorials/operator_spreading_cn.ipynb diff --git a/docs/source/tutorials/mera.ipynb b/docs/source/tutorials/mera.ipynb index 309f820b..d4b04ecf 100644 --- a/docs/source/tutorials/mera.ipynb +++ b/docs/source/tutorials/mera.ipynb @@ -62,6 +62,7 @@ "import numpy as np\n", "import tensorflow as tf\n", "import tensorcircuit as tc\n", + "\n", "tc.set_backend(\"tensorflow\")\n", "tc.set_dtype(\"complex128\")" ] @@ -87,11 +88,11 @@ " e = 0.0\n", " n = c._nqubits\n", " # \n", - " for i in range(n-1): \n", - " e += j * c.expectation((tc.gates.z(), [i]), (tc.gates.z(), [i+1])) \n", + " for i in range(n - 1):\n", + " e += j * c.expectation((tc.gates.z(), [i]), (tc.gates.z(), [i + 1]))\n", " # \n", " for i in range(n):\n", - " e -= hx * c.expectation((tc.gates.x(), [i])) \n", + " e -= hx * c.expectation((tc.gates.x(), [i]))\n", " return tc.backend.real(e)" ] }, @@ -115,34 +116,34 @@ "def MERA(params, n):\n", " params = tc.backend.cast(params, \"complex128\")\n", " c = tc.Circuit(n)\n", - " \n", - " idx = 0 # index of params\n", - " \n", + "\n", + " idx = 0 # index of params\n", + "\n", " for i in range(n):\n", - " c.rx(i, theta=params[2*i])\n", - " c.rz(i, theta=params[2*i+1])\n", - " idx += 2*n\n", - " \n", - " for n_layer in range(1, int(np.log2(n))+1):\n", - " n_qubit = 2**n_layer # number of qubits involving\n", + " c.rx(i, theta=params[2 * i])\n", + " c.rz(i, theta=params[2 * i + 1])\n", + " idx += 2 * n\n", + "\n", + " for n_layer in range(1, int(np.log2(n)) + 1):\n", + " n_qubit = 2**n_layer # number of qubits involving\n", " step = int(n / n_qubit)\n", "\n", - " # even \n", - " for i in range(step, n-step, 2*step):\n", - " c.exp1(i, i+step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", - " c.exp1(i, i+step, theta=params[idx+1], unitary=tc.gates._zz_matrix)\n", + " # even\n", + " for i in range(step, n - step, 2 * step):\n", + " c.exp1(i, i + step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", + " c.exp1(i, i + step, theta=params[idx + 1], unitary=tc.gates._zz_matrix)\n", " idx += 2\n", - " \n", - " # odd \n", - " for i in range(0, n, 2*step):\n", - " c.exp1(i, i+step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", - " c.exp1(i, i+step, theta=params[idx+1], unitary=tc.gates._zz_matrix)\n", + "\n", + " # odd\n", + " for i in range(0, n, 2 * step):\n", + " c.exp1(i, i + step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", + " c.exp1(i, i + step, theta=params[idx + 1], unitary=tc.gates._zz_matrix)\n", " idx += 2\n", - " \n", + "\n", " # single qubit\n", " for i in range(0, n, step):\n", " c.rx(i, theta=params[idx])\n", - " c.rz(i, theta=params[idx+1])\n", + " c.rz(i, theta=params[idx + 1])\n", " idx += 2\n", "\n", " # measure\n", @@ -231,9 +232,7 @@ } ], "source": [ - "MERA_tfim_vvag = tc.backend.jit(\n", - " tc.backend.vectorized_value_and_grad(MERA)\n", - ")\n", + "MERA_tfim_vvag = tc.backend.jit(tc.backend.vectorized_value_and_grad(MERA))\n", "\n", "\n", "def batched_train(n, batch=10, maxiter=10000, lr=0.005):\n", @@ -247,12 +246,13 @@ " for i in range(maxiter):\n", " e, grad = MERA_tfim_vvag(params, n)\n", " opt.apply_gradients([(grad, params)])\n", - " if tf.reduce_min(e)\n", - " for i in range(n-1): \n", - " e += j * c.expectation((tc.gates.z(), [i]), (tc.gates.z(), [i+1])) \n", + " for i in range(n - 1):\n", + " e += j * c.expectation((tc.gates.z(), [i]), (tc.gates.z(), [i + 1]))\n", " # \n", " for i in range(n):\n", - " e -= hx * c.expectation((tc.gates.x(), [i])) \n", + " e -= hx * c.expectation((tc.gates.x(), [i]))\n", " return tc.backend.real(e)" ] }, @@ -115,34 +116,34 @@ "def MERA(params, n):\n", " params = tc.backend.cast(params, \"complex128\")\n", " c = tc.Circuit(n)\n", - " \n", - " idx = 0 # index of params\n", - " \n", + "\n", + " idx = 0 # index of params\n", + "\n", " for i in range(n):\n", - " c.rx(i, theta=params[2*i])\n", - " c.rz(i, theta=params[2*i+1])\n", - " idx += 2*n\n", - " \n", - " for n_layer in range(1, int(np.log2(n))+1):\n", - " n_qubit = 2**n_layer # number of qubits involving\n", + " c.rx(i, theta=params[2 * i])\n", + " c.rz(i, theta=params[2 * i + 1])\n", + " idx += 2 * n\n", + "\n", + " for n_layer in range(1, int(np.log2(n)) + 1):\n", + " n_qubit = 2**n_layer # number of qubits involving\n", " step = int(n / n_qubit)\n", "\n", - " # 偶数层 \n", - " for i in range(step, n-step, 2*step):\n", - " c.exp1(i, i+step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", - " c.exp1(i, i+step, theta=params[idx+1], unitary=tc.gates._zz_matrix)\n", + " # 偶数层\n", + " for i in range(step, n - step, 2 * step):\n", + " c.exp1(i, i + step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", + " c.exp1(i, i + step, theta=params[idx + 1], unitary=tc.gates._zz_matrix)\n", " idx += 2\n", - " \n", - " # 奇数层 \n", - " for i in range(0, n, 2*step):\n", - " c.exp1(i, i+step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", - " c.exp1(i, i+step, theta=params[idx+1], unitary=tc.gates._zz_matrix)\n", + "\n", + " # 奇数层\n", + " for i in range(0, n, 2 * step):\n", + " c.exp1(i, i + step, theta=params[idx], unitary=tc.gates._xx_matrix)\n", + " c.exp1(i, i + step, theta=params[idx + 1], unitary=tc.gates._zz_matrix)\n", " idx += 2\n", - " \n", + "\n", " # 单比特门\n", " for i in range(0, n, step):\n", " c.rx(i, theta=params[idx])\n", - " c.rz(i, theta=params[idx+1])\n", + " c.rz(i, theta=params[idx + 1])\n", " idx += 2\n", "\n", " # 测量\n", @@ -231,9 +232,7 @@ } ], "source": [ - "MERA_tfim_vvag = tc.backend.jit(\n", - " tc.backend.vectorized_value_and_grad(MERA)\n", - ")\n", + "MERA_tfim_vvag = tc.backend.jit(tc.backend.vectorized_value_and_grad(MERA))\n", "\n", "\n", "def batched_train(n, batch=10, maxiter=10000, lr=0.005):\n", @@ -247,12 +246,13 @@ " for i in range(maxiter):\n", " e, grad = MERA_tfim_vvag(params, n)\n", " opt.apply_gradients([(grad, params)])\n", - " if tf.reduce_min(e) Date: Tue, 6 Dec 2022 13:04:12 +0800 Subject: [PATCH 100/725] delete center in mera tuto --- docs/source/tutorials/mera.ipynb | 189 +++++++++++++--------------- docs/source/tutorials/mera_cn.ipynb | 189 +++++++++++++--------------- 2 files changed, 174 insertions(+), 204 deletions(-) diff --git a/docs/source/tutorials/mera.ipynb b/docs/source/tutorials/mera.ipynb index d4b04ecf..0b3d25c1 100644 --- a/docs/source/tutorials/mera.ipynb +++ b/docs/source/tutorials/mera.ipynb @@ -2,26 +2,22 @@ "cells": [ { "cell_type": "markdown", - "id": "64ba95d6", - "metadata": {}, "source": [ - "#
MERA" - ] + "# MERA" + ], + "metadata": {} }, { "cell_type": "markdown", - "id": "804d79c1", - "metadata": {}, "source": [ "## Overview\n", "\n", "In this tutorial, we'll show you how to implement MERA (multi-scale entangled renormalization ansatz) with TensorCircuit, but not in physics perspective." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "id": "f4a7b1eb", - "metadata": {}, "source": [ "## Background\n", "\n", @@ -29,60 +25,55 @@ "In the MERA we are going to train (denoted by $U(\\theta)$), we use parameterized quantum gates $e^{i\\theta XX}$, $e^{i\\theta ZZ}$ as two-qubit gates and $e^{i\\theta X}$, $e^{i\\theta Z}$ as single-qubit gates.\n", "The Hamiltonian we choose as the example is from TFIM as $ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $. \n", "And the loss function to be minimized in this task is $\\mathcal{L}_{MERA}(\\rm{\\theta})=\\langle 0^n\\vert U(\\theta)^\\dagger \\hat{H} U(\\theta)\\vert 0^n\\rangle$. " - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "id": "f7939c50", - "metadata": {}, "source": [ "## Setup" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 1, - "id": "4e1651b9", - "metadata": { - "scrolled": false - }, + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import tensorcircuit as tc\n", + "\n", + "tc.set_backend(\"tensorflow\")\n", + "tc.set_dtype(\"complex128\")" + ], "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "('complex128', 'float64')" ] }, - "execution_count": 1, "metadata": {}, - "output_type": "execute_result" + "execution_count": 1 } ], - "source": [ - "import numpy as np\n", - "import tensorflow as tf\n", - "import tensorcircuit as tc\n", - "\n", - "tc.set_backend(\"tensorflow\")\n", - "tc.set_dtype(\"complex128\")" - ] + "metadata": { + "scrolled": false + } }, { "cell_type": "markdown", - "id": "d78b480b", - "metadata": {}, "source": [ "## Energy\n", "We first design the Hamiltonian energy expectation function as loss.\n", "$$ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $$" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 2, - "id": "fff67346", - "metadata": {}, - "outputs": [], "source": [ "def energy(c: tc.Circuit, j: float = 1.0, hx: float = 1.0):\n", " e = 0.0\n", @@ -94,24 +85,22 @@ " for i in range(n):\n", " e -= hx * c.expectation((tc.gates.x(), [i]))\n", " return tc.backend.real(e)" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", - "id": "0ad6a7a6", - "metadata": {}, "source": [ "## MERA circuit\n", "\n", "Now we design the circuit. We use $\\theta$ as input." - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 5, - "id": "445b7c86", - "metadata": {}, - "outputs": [], "source": [ "def MERA(params, n):\n", " params = tc.backend.cast(params, \"complex128\")\n", @@ -150,87 +139,64 @@ " e = energy(c)\n", " return e\n", " # return c, idx" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", - "id": "49f0b702", - "metadata": {}, "source": [ "We can visualize the MERA circuit. \n", "\n", "Hint: Please change return to `return c, idx`, which will only be used here. After visulization, don't forget to restore the return and run the code block above again." - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 4, - "id": "8b5fa87f", - "metadata": { - "scrolled": true - }, + "source": [ + "n = 8\n", + "cirq, idx = MERA(np.zeros(1000), n)\n", + "print(\"The number of parameters is\", idx)\n", + "cirq.draw()" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "The number of parameters is 66\n" ] }, { + "output_type": "execute_result", "data": { - "image/svg+xml": "\n\n\n \n \n \n \n 2022-12-05T21:29:46.404387\n image/svg+xml\n \n \n Matplotlib v3.5.3, https://matplotlib.org/\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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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", "text/plain": [ "
" - ] + ], + "image/svg+xml": "\n\n\n \n \n \n \n 2022-12-05T21:29:46.404387\n image/svg+xml\n \n \n Matplotlib v3.5.3, https://matplotlib.org/\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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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" }, - "execution_count": 4, "metadata": {}, - "output_type": "execute_result" + "execution_count": 4 } ], - "source": [ - "n = 8\n", - "cirq, idx = MERA(np.zeros(1000), n)\n", - "print(\"The number of parameters is\", idx)\n", - "cirq.draw()" - ] + "metadata": { + "scrolled": true + } }, { "cell_type": "markdown", - "id": "e9afb1a5", - "metadata": {}, "source": [ "## Train\n", "\n", "Now we can train the MERA circuit with tensorflow." - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 6, - "id": "873ebd5e", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tf.Tensor([-0.6449017 0.14083987 0.17227418 1.42731099 0.93767164], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.57952648 -9.15354269 -9.53415983 -9.55291257 -9.46880555], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.63166728 -9.60922826 -9.59883555 -9.66639936 -9.60174669], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.65441326 -9.61830383 -9.6219077 -9.68289435 -9.61427165], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.66991104 -9.6307931 -9.64993901 -9.71396225 -9.63848947], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.67960751 -9.64303661 -9.67696885 -9.76317346 -9.6507455 ], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.68303361 -9.6575349 -9.70118521 -9.7740601 -9.65751254], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.68481667 -9.67473162 -9.71392119 -9.78200161 -9.66880068], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.6864865 -9.67835678 -9.73033137 -9.79128949 -9.68317883], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.68762425 -9.67928153 -9.77502182 -9.79465957 -9.69252806], shape=(5,), dtype=float64)\n" - ] - } - ], "source": [ "MERA_tfim_vvag = tc.backend.jit(tc.backend.vectorized_value_and_grad(MERA))\n", "\n", @@ -255,33 +221,41 @@ "\n", "n = 8\n", "lowest_energy = batched_train(n, batch=5, maxiter=2000, lr=0.007)" - ] + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tf.Tensor([-0.6449017 0.14083987 0.17227418 1.42731099 0.93767164], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.57952648 -9.15354269 -9.53415983 -9.55291257 -9.46880555], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.63166728 -9.60922826 -9.59883555 -9.66639936 -9.60174669], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.65441326 -9.61830383 -9.6219077 -9.68289435 -9.61427165], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.66991104 -9.6307931 -9.64993901 -9.71396225 -9.63848947], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.67960751 -9.64303661 -9.67696885 -9.76317346 -9.6507455 ], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68303361 -9.6575349 -9.70118521 -9.7740601 -9.65751254], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68481667 -9.67473162 -9.71392119 -9.78200161 -9.66880068], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.6864865 -9.67835678 -9.73033137 -9.79128949 -9.68317883], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68762425 -9.67928153 -9.77502182 -9.79465957 -9.69252806], shape=(5,), dtype=float64)\n" + ] + } + ], + "metadata": { + "scrolled": false + } }, { "cell_type": "markdown", - "id": "c5a7cdb0", - "metadata": {}, "source": [ "## Compare\n", "\n", "We can compare the ground energy we get by MERA with DMRG." - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 7, - "id": "8f8695c0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DMRG solution: -9.837951447459426\n", - "MERA solution: -9.795198473308487\n" - ] - } - ], "source": [ "# DMRG\n", "import quimb\n", @@ -296,7 +270,18 @@ "# Compare\n", "print(\"DMRG solution: \", energy_DMRG)\n", "print(\"MERA solution: \", lowest_energy.numpy())" - ] + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "DMRG solution: -9.837951447459426\n", + "MERA solution: -9.795198473308487\n" + ] + } + ], + "metadata": {} } ], "metadata": { @@ -325,4 +310,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/docs/source/tutorials/mera_cn.ipynb b/docs/source/tutorials/mera_cn.ipynb index fe65a45b..4749cc0b 100644 --- a/docs/source/tutorials/mera_cn.ipynb +++ b/docs/source/tutorials/mera_cn.ipynb @@ -2,26 +2,22 @@ "cells": [ { "cell_type": "markdown", - "id": "64ba95d6", - "metadata": {}, "source": [ - "#
MERA" - ] + "# MERA" + ], + "metadata": {} }, { "cell_type": "markdown", - "id": "804d79c1", - "metadata": {}, "source": [ "## 概述\n", "\n", "在本教程中，我们将不涉及物理层面的探讨，而将演示如何使用TensorCircuit实现MERA (多尺度纠缠重整化假设，multi-scale entangled renormalization ansatz)。" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "id": "f4a7b1eb", - "metadata": {}, "source": [ "## 背景\n", "\n", @@ -29,60 +25,55 @@ "在将要训练的MERA（记作 $U(\\theta)$ ）中，我们使用可变参量子门 $e^{i\\theta XX}$ 、$e^{i\\theta ZZ}$ 作为双比特门，以及 $e^{i\\theta X}$ 、$e^{i\\theta Z}$ 作为单比特门。\n", "在本教程中，我们使用的哈密顿量是横场伊辛模型的哈密顿量 $ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $。\n", "我们要减小的损失函数是 $\\mathcal{L}_{MERA}(\\rm{\\theta})=\\langle 0^n\\vert U(\\theta)^\\dagger \\hat{H} U(\\theta)\\vert 0^n\\rangle$。" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "id": "f7939c50", - "metadata": {}, "source": [ "## 设置" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 1, - "id": "4e1651b9", - "metadata": { - "scrolled": false - }, + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import tensorcircuit as tc\n", + "\n", + "tc.set_backend(\"tensorflow\")\n", + "tc.set_dtype(\"complex128\")" + ], "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "('complex128', 'float64')" ] }, - "execution_count": 1, "metadata": {}, - "output_type": "execute_result" + "execution_count": 1 } ], - "source": [ - "import numpy as np\n", - "import tensorflow as tf\n", - "import tensorcircuit as tc\n", - "\n", - "tc.set_backend(\"tensorflow\")\n", - "tc.set_dtype(\"complex128\")" - ] + "metadata": { + "scrolled": false + } }, { "cell_type": "markdown", - "id": "d78b480b", - "metadata": {}, "source": [ "## 能量\n", "我们先设计哈密顿量的能量期望函数作为损失函数。\n", "$$ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $$" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 2, - "id": "fff67346", - "metadata": {}, - "outputs": [], "source": [ "def energy(c: tc.Circuit, j: float = 1.0, hx: float = 1.0):\n", " e = 0.0\n", @@ -94,24 +85,22 @@ " for i in range(n):\n", " e -= hx * c.expectation((tc.gates.x(), [i]))\n", " return tc.backend.real(e)" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", - "id": "0ad6a7a6", - "metadata": {}, "source": [ "## MERA 电路\n", "\n", "现在，我们设计电路。我们用 $\\theta$ 作为输入。" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 5, - "id": "445b7c86", - "metadata": {}, - "outputs": [], "source": [ "def MERA(params, n):\n", " params = tc.backend.cast(params, \"complex128\")\n", @@ -150,87 +139,64 @@ " e = energy(c)\n", " return e\n", " # return c, idx" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", - "id": "49f0b702", - "metadata": {}, "source": [ "我们可以将MERA电路可视化。 \n", "\n", "注意：请把return改为`return c, idx`。这个return只有在这儿会被用到。可视化完成后，请别忘了将return还原并重新运行上方代码块。" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 4, - "id": "8b5fa87f", - "metadata": { - "scrolled": true - }, + "source": [ + "n = 8\n", + "cirq, idx = MERA(np.zeros(1000), n)\n", + "print(\"The number of parameters is\", idx)\n", + "cirq.draw()" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "The number of parameters is 66\n" ] }, { + "output_type": "execute_result", "data": { - "image/svg+xml": "\n\n\n \n \n \n \n 2022-12-05T21:29:46.404387\n image/svg+xml\n \n \n Matplotlib v3.5.3, https://matplotlib.org/\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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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", "text/plain": [ "
" - ] + ], + "image/svg+xml": "\n\n\n \n \n \n \n 2022-12-05T21:29:46.404387\n image/svg+xml\n \n \n Matplotlib v3.5.3, https://matplotlib.org/\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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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" }, - "execution_count": 4, "metadata": {}, - "output_type": "execute_result" + "execution_count": 4 } ], - "source": [ - "n = 8\n", - "cirq, idx = MERA(np.zeros(1000), n)\n", - "print(\"The number of parameters is\", idx)\n", - "cirq.draw()" - ] + "metadata": { + "scrolled": true + } }, { "cell_type": "markdown", - "id": "e9afb1a5", - "metadata": {}, "source": [ "## 训练\n", "\n", "现在，我们使用tensorflow训练MERA电路。" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 6, - "id": "873ebd5e", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tf.Tensor([-0.6449017 0.14083987 0.17227418 1.42731099 0.93767164], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.57952648 -9.15354269 -9.53415983 -9.55291257 -9.46880555], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.63166728 -9.60922826 -9.59883555 -9.66639936 -9.60174669], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.65441326 -9.61830383 -9.6219077 -9.68289435 -9.61427165], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.66991104 -9.6307931 -9.64993901 -9.71396225 -9.63848947], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.67960751 -9.64303661 -9.67696885 -9.76317346 -9.6507455 ], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.68303361 -9.6575349 -9.70118521 -9.7740601 -9.65751254], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.68481667 -9.67473162 -9.71392119 -9.78200161 -9.66880068], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.6864865 -9.67835678 -9.73033137 -9.79128949 -9.68317883], shape=(5,), dtype=float64)\n", - "tf.Tensor([-9.68762425 -9.67928153 -9.77502182 -9.79465957 -9.69252806], shape=(5,), dtype=float64)\n" - ] - } - ], "source": [ "MERA_tfim_vvag = tc.backend.jit(tc.backend.vectorized_value_and_grad(MERA))\n", "\n", @@ -255,33 +221,41 @@ "\n", "n = 8\n", "lowest_energy = batched_train(n, batch=5, maxiter=2000, lr=0.007)" - ] + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tf.Tensor([-0.6449017 0.14083987 0.17227418 1.42731099 0.93767164], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.57952648 -9.15354269 -9.53415983 -9.55291257 -9.46880555], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.63166728 -9.60922826 -9.59883555 -9.66639936 -9.60174669], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.65441326 -9.61830383 -9.6219077 -9.68289435 -9.61427165], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.66991104 -9.6307931 -9.64993901 -9.71396225 -9.63848947], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.67960751 -9.64303661 -9.67696885 -9.76317346 -9.6507455 ], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68303361 -9.6575349 -9.70118521 -9.7740601 -9.65751254], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68481667 -9.67473162 -9.71392119 -9.78200161 -9.66880068], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.6864865 -9.67835678 -9.73033137 -9.79128949 -9.68317883], shape=(5,), dtype=float64)\n", + "tf.Tensor([-9.68762425 -9.67928153 -9.77502182 -9.79465957 -9.69252806], shape=(5,), dtype=float64)\n" + ] + } + ], + "metadata": { + "scrolled": false + } }, { "cell_type": "markdown", - "id": "c5a7cdb0", - "metadata": {}, "source": [ "## 对比\n", "\n", "我们可以把我们用MERA得到的基态能量和DMRG进行对比。" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 7, - "id": "8f8695c0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DMRG solution: -9.837951447459426\n", - "MERA solution: -9.795198473308487\n" - ] - } - ], "source": [ "# DMRG\n", "import quimb\n", @@ -296,7 +270,18 @@ "# Compare\n", "print(\"DMRG solution: \", energy_DMRG)\n", "print(\"MERA solution: \", lowest_energy.numpy())" - ] + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "DMRG solution: -9.837951447459426\n", + "MERA solution: -9.795198473308487\n" + ] + } + ], + "metadata": {} } ], "metadata": { @@ -325,4 +310,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From 644787641499a54a96f7753366b3dd3fbdde16da Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 6 Dec 2022 14:44:23 +0800 Subject: [PATCH 101/725] temporary mitigated results processing --- tensorcircuit/cloud/abstraction.py | 33 +++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 08a1d548..276f3d5a 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -5,6 +5,8 @@ from typing import Any, Dict, List, Optional, Union import time +from ..results import readout_mitigation as rem + class Provider: activated_providers: Dict[str, "Provider"] = {} @@ -181,7 +183,12 @@ def resubmit(self) -> "Task": return resubmit_task(self) - def results(self, format: Optional[str] = None, blocked: bool = False) -> Any: + def results( + self, + format: Optional[str] = None, + blocked: bool = False, + mitigated: bool = False, + ) -> Any: # TODO(@refraction-ray): support different formats compatible with tc, # also support format_ alias if not blocked: @@ -189,7 +196,6 @@ def results(self, format: Optional[str] = None, blocked: bool = False) -> Any: raise ValueError("Task %s is not completed yet" % self.id_) r = self.details()["results"] r = {k: v for k, v in sorted(r.items(), key=lambda item: -item[1])} # type: ignore - return r else: s = self.state() while s != "completed": @@ -197,4 +203,25 @@ def results(self, format: Optional[str] = None, blocked: bool = False) -> Any: raise ValueError("Task %s is in %s state" % (self.id_, s)) time.sleep(1.0) s = self.state() - return self.results(format=format, blocked=False) + r = self.results(format=format, blocked=False, mitigated=False) + if mitigated is False: + return r + + # mitigated is True: + def run(cs, shots): + """ + current workaround for batch + """ + from .apis import submit_task + + ts = [] + for c in cs: + ts.append(submit_task(circuit=c, shots=shots, device="9gmon?o=0")) + time.sleep(0.5) + return [t.results(blocked=True) for t in ts] + + nqubit = len(list(r.keys())[0]) + shots = self.details()["shots"] + cal = rem.get_readout_cal(nqubit, shots, run, miti_method="local") + miti_count = rem.apply_readout_mitigation(r, cal, "square") + return {k: v for k, v in sorted(miti_count.items(), key=lambda item: -item[1])} From 6092b4b216f427983cc63b42f31395647850a12f Mon Sep 17 00:00:00 2001 From: JachyMeow <114171061+JachyMeow@users.noreply.github.com> Date: Tue, 6 Dec 2022 16:07:24 +0800 Subject: [PATCH 102/725] Update mera.ipynb --- docs/source/tutorials/mera.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorials/mera.ipynb b/docs/source/tutorials/mera.ipynb index 0b3d25c1..b4e144cf 100644 --- a/docs/source/tutorials/mera.ipynb +++ b/docs/source/tutorials/mera.ipynb @@ -23,7 +23,7 @@ "\n", "MERA is a kind of VQE starts from only one qubit in the $\\ket{0}$ state, and progressively enlarges the Hilbert space by tensoring on new qubits.\n", "In the MERA we are going to train (denoted by $U(\\theta)$), we use parameterized quantum gates $e^{i\\theta XX}$, $e^{i\\theta ZZ}$ as two-qubit gates and $e^{i\\theta X}$, $e^{i\\theta Z}$ as single-qubit gates.\n", - "The Hamiltonian we choose as the example is from TFIM as $ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $. \n", + "The Hamiltonian we choose as the example is from TFIM as $\\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}}$. \n", "And the loss function to be minimized in this task is $\\mathcal{L}_{MERA}(\\rm{\\theta})=\\langle 0^n\\vert U(\\theta)^\\dagger \\hat{H} U(\\theta)\\vert 0^n\\rangle$. " ], "metadata": {} @@ -310,4 +310,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From 9bb19fc5a8a08b3b6b8920b3ef607fd3022bb1ff Mon Sep 17 00:00:00 2001 From: JachyMeow <114171061+JachyMeow@users.noreply.github.com> Date: Tue, 6 Dec 2022 16:10:23 +0800 Subject: [PATCH 103/725] Update mera_cn.ipynb --- docs/source/tutorials/mera_cn.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorials/mera_cn.ipynb b/docs/source/tutorials/mera_cn.ipynb index 4749cc0b..b804e868 100644 --- a/docs/source/tutorials/mera_cn.ipynb +++ b/docs/source/tutorials/mera_cn.ipynb @@ -23,7 +23,7 @@ "\n", "MERA是VQE的其中一种。它由一个量子比特的 $\\ket{0}$ 态开始，逐层添加新的量子比特以扩张希尔伯特空间。\n", "在将要训练的MERA（记作 $U(\\theta)$ ）中，我们使用可变参量子门 $e^{i\\theta XX}$ 、$e^{i\\theta ZZ}$ 作为双比特门，以及 $e^{i\\theta X}$ 、$e^{i\\theta Z}$ 作为单比特门。\n", - "在本教程中，我们使用的哈密顿量是横场伊辛模型的哈密顿量 $ \\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}} $。\n", + "在本教程中，我们使用的哈密顿量是横场伊辛模型的哈密顿量 $\\hat{H}_{Ising}=J\\sum_{i}{Z_{i}Z_{i+1}}-B_{x}\\sum_{i}{X_{i}}$。\n", "我们要减小的损失函数是 $\\mathcal{L}_{MERA}(\\rm{\\theta})=\\langle 0^n\\vert U(\\theta)^\\dagger \\hat{H} U(\\theta)\\vert 0^n\\rangle$。" ], "metadata": {} @@ -310,4 +310,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From 0d08bc5ff3d21504d5f3d97ca136b3ae0ebc023e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 6 Dec 2022 17:06:52 +0800 Subject: [PATCH 104/725] add compiling in submit task --- tensorcircuit/cloud/tencent.py | 40 +++++++++++++++++++++++++++++----- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 584e54dd..6de9598c 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Sequence, Union from json import dumps import logging +import re from .config import tencent_base_url from .utils import rpost_json @@ -55,6 +56,23 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An raise ValueError("No device with the name: %s" % device) +def _free_pi(s): + # dirty trick to get rid of pi in openqasm from qiskit + rs = [] + pistr = "3.141592653589793" + s = s.replace("pi", pistr) + for r in s.split("\n"): + inc = re.search(r"\(.*\)", r) + if inc is None: + rs.append(r) + else: + v = r[inc.start() : inc.end()] + v = eval(v) + r = r[: inc.start()] + "(" + str(v) + ")" + r[inc.end() :] + rs.append(r) + return "\n".join(rs) + + def submit_task( device: Device, token: str, @@ -65,15 +83,27 @@ def submit_task( circuit: Optional[Union[AbstractCircuit, Sequence[AbstractCircuit]]] = None, source: Optional[Union[str, Sequence[str]]] = None, remarks: Optional[str] = None, + compiling: bool = False, ) -> List[Task]: - # pistr = "3.14159265358979" if source is None: + + def c2qasm(c: Any, compiling: bool) -> str: + if compiling is True: + from qiskit.compiler import transpile + + c1 = transpile( + c.to_qiskit(), basis_gates=["h", "rz", "x", "y", "z", "cx"] + ) + s = c1.qasm() + else: + s = c.to_openqasm() + # s = _free_pi(s) + return s + if is_sequence(circuit): - source = [c.to_openqasm() for c in circuit] # type: ignore - # source = [s.replace("pi", pistr) for s in source] + source = [c2qasm(c, compiling) for c in circuit] # type: ignore else: - source = circuit.to_openqasm() # type: ignore - # source = source.replace("pi", pistr) + source = c2qasm(circuit, compiling) lang = "OPENQASM" if is_sequence(source): # batched mode From dcc92de32869f83775aa5272b0a3197ead03228b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 6 Dec 2022 21:21:01 +0800 Subject: [PATCH 105/725] mitigated results --- tensorcircuit/cloud/abstraction.py | 41 ++++++++++++++++++------------ tensorcircuit/cloud/tencent.py | 10 +++++--- 2 files changed, 31 insertions(+), 20 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 276f3d5a..ab719863 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -188,6 +188,7 @@ def results( format: Optional[str] = None, blocked: bool = False, mitigated: bool = False, + readout_cal: Optional[rem.ReadoutCal] = None, ) -> Any: # TODO(@refraction-ray): support different formats compatible with tc, # also support format_ alias @@ -208,20 +209,28 @@ def results( return r # mitigated is True: - def run(cs, shots): - """ - current workaround for batch - """ - from .apis import submit_task - - ts = [] - for c in cs: - ts.append(submit_task(circuit=c, shots=shots, device="9gmon?o=0")) - time.sleep(0.5) - return [t.results(blocked=True) for t in ts] - - nqubit = len(list(r.keys())[0]) - shots = self.details()["shots"] - cal = rem.get_readout_cal(nqubit, shots, run, miti_method="local") - miti_count = rem.apply_readout_mitigation(r, cal, "square") + if readout_cal is None and getattr(self, "readout_cal", None) is None: + + def run(cs: Any, shots: Any) -> Any: + """ + current workaround for batch + """ + from .apis import submit_task + + ts = [] + for c in cs: + ts.append( + submit_task(circuit=c, shots=shots, device=self.get_device()) + ) + time.sleep(0.5) + return [t.results(blocked=True) for t in ts] # type: ignore + + nqubit = len(list(r.keys())[0]) + shots = self.details()["shots"] + readout_cal = rem.get_readout_cal(nqubit, shots, run, miti_method="local") + self.readout_cal = readout_cal + elif readout_cal is None: + readout_cal = self.readout_cal + + miti_count = rem.apply_readout_mitigation(r, readout_cal, "square") return {k: v for k, v in sorted(miti_count.items(), key=lambda item: -item[1])} diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 6de9598c..d7a0f266 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -56,7 +56,7 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An raise ValueError("No device with the name: %s" % device) -def _free_pi(s): +def _free_pi(s: str) -> str: # dirty trick to get rid of pi in openqasm from qiskit rs = [] pistr = "3.141592653589793" @@ -92,13 +92,15 @@ def c2qasm(c: Any, compiling: bool) -> str: from qiskit.compiler import transpile c1 = transpile( - c.to_qiskit(), basis_gates=["h", "rz", "x", "y", "z", "cx"] + c.to_qiskit(), + basis_gates=["h", "rz", "x", "y", "z", "cx"], + optimization_level=2, ) s = c1.qasm() else: s = c.to_openqasm() - # s = _free_pi(s) - return s + # s = _free_pi(s) # tQuk translation now supports this + return s # type: ignore if is_sequence(circuit): source = [c2qasm(c, compiling) for c in circuit] # type: ignore From ce91b3c2a5f9f3c228d29f203c0dbef24c56ba00 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Dec 2022 16:49:29 +0800 Subject: [PATCH 106/725] add compiled alias --- tensorcircuit/cloud/tencent.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index d7a0f266..82f967c7 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -5,13 +5,14 @@ from typing import Any, Dict, List, Optional, Sequence, Union from json import dumps import logging +from functools import partial import re from .config import tencent_base_url from .utils import rpost_json from .abstraction import Device, sep, Task from ..abstractcircuit import AbstractCircuit -from ..utils import is_sequence +from ..utils import is_sequence, arg_alias logger = logging.getLogger(__name__) @@ -73,6 +74,7 @@ def _free_pi(s: str) -> str: return "\n".join(rs) +@partial(arg_alias, alias_dict={"compiling": ["compiled"]}) def submit_task( device: Device, token: str, From 01d8b98045451f8adbc7e20a48d68db22680ac9d Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Thu, 8 Dec 2022 21:41:26 +0800 Subject: [PATCH 107/725] device readout API --- tensorcircuit/results/readout_mitigation.py | 641 ++++++++++++++++---- 1 file changed, 532 insertions(+), 109 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index b15a0657..7974c2e6 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -1,140 +1,563 @@ """ readout error mitigation functionalities """ +# Part of the code in this file is from mthree: https://github.com/Qiskit-Partners/mthree -from typing import Any, Callable, List, Union +from typing import Any, Callable, List, Sequence, Optional +import warnings +from time import perf_counter + +import psutil import numpy as np +import scipy.linalg as la +import scipy.sparse.linalg as spla from scipy.optimize import minimize -from .counts import count2vec, vec2count, ct +try: + from mthree.matrix import _reduced_cal_matrix + from mthree.utils import counts_to_vector, vector_to_quasiprobs + from mthree.norms import ainv_onenorm_est_lu, ainv_onenorm_est_iter + from mthree.matvec import M3MatVec + from mthree.exceptions import M3Error + from mthree.classes import QuasiCollection + + mthree_installed = True +except ImportError: + mthree_installed = False + +from .counts import count2vec, vec2count, ct, marginal_count from ..circuit import Circuit -from ..utils import is_sequence + Tensor = Any -class ReadoutCal: - def __init__(self, cal: Union[Tensor, List[Tensor]]): - self.cal = cal - if is_sequence(cal): - self.local = True - self.n = len(cal) - else: - self.local = False - self.n = int(np.log(cal.shape[0]) / np.log(2) + 1e-9) # type: ignore +class ReadoutMit: + def __init__(self, execute: Callable[..., List[ct]], iter_threshold: int = 4096): + """ + The Class for readout error mitigation + + :param execute: execute function to run the cirucit + :type execute: Callable[..., List[ct]] + :param iter_threshold: iteration threshold, defaults to 4096 + :type iter_threshold: int, optional + """ + + self.cal_qubits = None # qubit list for calibration + self.use_qubits = None # qubit list for mitigation + + self.local = None + self.single_qubit_cals = None + self.global_cals = None + + self.iter_threshold = iter_threshold + + self.execute_fun = execute + + def ubs(self, i: int) -> int: + """ + Help omit calibration results that not in used qubit list. + + :param i: index + :type i: int + :return: omitation related value + :rtype: int + """ + name = "{:0" + str(len(self.cal_qubits)) + "b}" # type: ignore + lisbs = [int(x) for x in name.format(i)] + + vomit = 0 + for k in list(filter(lambda x: x not in self.use_qubits, self.cal_qubits)): # type: ignore + vomit += lisbs[self.cal_qubits.index(k)] # type: ignore + return vomit + + def newrange(self, m: int) -> int: + """ + Rerange the order according to used qubit list. + + :param m: index + :type m: int + :return: new index + :rtype: int + """ + sorted_index = sorted( + range(len(self.use_qubits)), key=lambda k: self.use_qubits[k] # type: ignore + ) + name = "{:0" + str(len(self.use_qubits)) + "b}" # type: ignore + lisbs = [int(x) for x in name.format(m)] + lisbs2 = [lisbs[i] for i in sorted_index] + + indexstr = "" + for i in lisbs2: + indexstr += str(i) + return int(indexstr, 2) + + def get_matrix(self, qubits: Optional[Sequence[Any]] = None) -> Tensor: + """ + Calculate cal_matrix according to use qubit list. + + :param qubits: used qubit list, defaults to None + :type qubits: Sequence[Any], optional + :return: cal_matrix + :rtype: Tensor + """ + + if qubits is None: + qubits = self.use_qubits - def get_matrix(self) -> Tensor: - # cache - if getattr(self, "calmatrix", None) is not None: - return self.calmatrix # type: ignore if self.local is False: - self.calmatrix = self.cal # type: ignore - return self.cal + + lbs = [marginal_count(i, qubits) for i in self.global_cal] + calmatrix = np.zeros((2 ** len(qubits), 2 ** len(qubits))) + + m = 0 + for i in range(len(lbs)): + vv = self.ubs(i) + if vv == 0: + for s in lbs[i]: + calmatrix[int(s, 2)][self.newrange(m)] = ( + lbs[i][s] / self.cal_shots + ) + m += 1 + self.calmatrix = calmatrix + return calmatrix + # self.local = True - calmatrix = self.cal[0] - for i in range(1, self.n): - calmatrix = np.kron(calmatrix, self.cal[i]) - self.calmatrix = calmatrix + calmatrix = self.single_qubit_cals[qubits[0]] # type: ignore + for i in range(1, len(qubits)): # type: ignore + calmatrix = np.kron(calmatrix, self.single_qubit_cals[qubits[i]]) # type: ignore + self.calmatrix = calmatrix # type: ignore return calmatrix + def _form_cals(self, qubits): # type: ignore -def local_miti_readout_circ(nqubit: int) -> List[Circuit]: - miticirc = [] - c = Circuit(nqubit) - miticirc.append(c) - c = Circuit(nqubit) - for i in range(nqubit): - c.X(i) # type: ignore - miticirc.append(c) - return miticirc + qubits = np.asarray(qubits, dtype=int) + cals = np.zeros(4 * qubits.shape[0], dtype=float) + # Reverse index qubits for easier indexing later + for kk, qubit in enumerate(qubits[::-1]): + cals[4 * kk : 4 * kk + 4] = self.single_qubit_cals[qubit].ravel() # type: ignore + return cals -def global_miti_readout_circ(nqubit: int) -> List[Circuit]: - miticirc = [] - for i in range(2**nqubit): - name = "{:0" + str(nqubit) + "b}" - lisbs = [int(x) for x in name.format(i)] - c = Circuit(nqubit) - for k in range(nqubit): - if lisbs[k] == 1: - c.X(k) # type: ignore + def local_miti_readout_circ(self) -> List[Circuit]: + """ + Generate circuits for local calibration. + + :return: circuit list + :rtype: List[Circuit] + """ + # TODO(@yutuer): Note on qubit mapping + miticirc = [] + c = Circuit(max(self.cal_qubits) + 1) # type: ignore miticirc.append(c) - return miticirc - - -def mitigate_probability( - probability_noise: Tensor, readout_cal: ReadoutCal, method: str = "inverse" -) -> Tensor: - calmatrix = readout_cal.get_matrix() - if method == "inverse": - X = np.linalg.inv(calmatrix) - Y = probability_noise - probability_cali = X @ Y - else: # method="square" - - def fun(x: Any) -> Any: - return sum((probability_noise - calmatrix @ x) ** 2) - - x0 = np.random.rand(len(probability_noise)) - cons = {"type": "eq", "fun": lambda x: 1 - sum(x)} - bnds = tuple((0, 1) for x in x0) - res = minimize(fun, x0, method="SLSQP", constraints=cons, bounds=bnds, tol=1e-6) - probability_cali = res.x - return probability_cali - - -def apply_readout_mitigation( - raw_count: ct, readout_cal: ReadoutCal, method: str = "inverse" -) -> ct: - probability = count2vec(raw_count) - shots = sum([v for k, v in raw_count.items()]) - probability = mitigate_probability(probability, readout_cal, method=method) - probability = probability * shots - return vec2count(probability) - - -def get_readout_cal( - nqubit: int, - shots: int, - execute_fun: Callable[..., List[ct]], - miti_method: str = "local", -) -> ReadoutCal: - # TODO(@refraction-ray): more general qubit list - if miti_method == "local": - miticirc = local_miti_readout_circ(nqubit) - - lbs = execute_fun(miticirc, shots) - readoutlist = [] - for i in range(nqubit): - error00 = 0 - for s in lbs[0]: - if s[i] == "0": - error00 = error00 + lbs[0][s] / shots # type: ignore - - error10 = 0 - for s in lbs[1]: - if s[i] == "0": - error10 = error10 + lbs[1][s] / shots # type: ignore - readoutlist.append( - np.array( + c = Circuit(max(self.cal_qubits) + 1) # type: ignore + for i in self.cal_qubits: # type: ignore + c.X(i) # type: ignore + miticirc.append(c) + return miticirc + + def global_miti_readout_circ(self) -> List[Circuit]: + """ + Generate circuits for local calibration. + + :return: circuit list + :rtype: List[Circuit] + """ + miticirc = [] + for i in range(2 ** len(self.cal_qubits)): # type: ignore + name = "{:0" + str(len(self.cal_qubits)) + "b}" # type: ignore + lisbs = [int(x) for x in name.format(i)] + c = Circuit(max(self.cal_qubits) + 1) # type: ignore + for k in range(len(self.cal_qubits)): # type: ignore + if lisbs[k] == 1: + c.X(self.cal_qubits[k]) # type: ignore + miticirc.append(c) + return miticirc + + def cals_from_system( # type: ignore + self, qubits: List[Any], shots: int = 8192, method: str = "local" + ): + """ + Get calibrattion information from system. + + :param qubits: calibration qubit list + :type qubits: Sequence[Any] + :param shots: shots used for runing the circuit, defaults to 8192 + :type shots: int, optional + :param method: calibration method, defaults to "local", it can also be "global" + :type method: str, optional + """ + qubits.sort() + self.cal_qubits = qubits # type: ignore + self.cal_shots = shots + + if method == "local": + self.local = True # type: ignore + miticirc = self.local_miti_readout_circ() + lbsall = self.execute_fun(miticirc, self.cal_shots) + lbs = [marginal_count(i, self.cal_qubits) for i in lbsall] # type: ignore + + self.single_qubit_cals = [None] * (max(self.cal_qubits) + 1) # type: ignore + for i in range(len(self.cal_qubits)): # type: ignore + error00 = 0 + for s in lbs[0]: + if s[i] == "0": + error00 = error00 + lbs[0][s] / self.cal_shots # type: ignore + + error10 = 0 + for s in lbs[1]: + if s[i] == "0": + error10 = error10 + lbs[1][s] / self.cal_shots # type: ignore + + readout_single = np.array( [ [error00, error10], [1 - error00, 1 - error10], ] ) + self.single_qubit_cals[self.cal_qubits[i]] = readout_single # type: ignore + + elif method == "global": + self.local = False # type: ignore + miticirc = self.global_miti_readout_circ() + lbsall = self.execute_fun(miticirc, self.cal_shots) + self.global_cal = lbsall + + else: + raise ValueError("Unrecognized `miti_method`: %s" % method) + + def mitigate_probability( + self, probability_noise: Tensor, method: str = "inverse" + ) -> Tensor: + """ + Get the mitigated probability. + + :param probability_noise: probability of raw count + :type probability_noise: Tensor + :param method: mitigation methods, defaults to "inverse", it can also be "square" + :type method: str, optional + :return: mitigated probability + :rtype: Tensor + """ + calmatrix = self.get_matrix() + if method == "inverse": + X = np.linalg.inv(calmatrix) + Y = probability_noise + probability_cali = X @ Y + else: # method="square" + + def fun(x: Any) -> Any: + return sum((probability_noise - calmatrix @ x) ** 2) + + x0 = np.random.rand(len(probability_noise)) + cons = {"type": "eq", "fun": lambda x: 1 - sum(x)} + bnds = tuple((0, 1) for x in x0) + res = minimize( + fun, x0, method="SLSQP", constraints=cons, bounds=bnds, tol=1e-6 + ) + probability_cali = res.x + return probability_cali + + def apply_readout_mitigation(self, raw_count: ct, method: str = "inverse") -> ct: + """ + Main readout mitigation program for method="inverse" or "square" + + :param raw_count: the raw count + :type raw_count: ct + :param method: mitigation method, defaults to "inverse" + :type method: str, optional + :return: mitigated count + :rtype: ct + """ + probability = count2vec(raw_count) + shots = sum([v for k, v in raw_count.items()]) + probability = self.mitigate_probability(probability, method=method) + probability = probability * shots + return vec2count(probability) + + def apply_correction( + self, + counts: ct, + qubits: Sequence[Any], + distance: Optional[int] = None, + method: str = "square", + max_iter: int = 25, + tol: float = 1e-5, + return_mitigation_overhead: bool = False, + details: bool = False, + ) -> ct: + """ + Main readout mitigation program for all methods. + + :param counts: raw count + :type counts: ct + :param qubits: used qubit list + :type qubits: Sequence[Any] + :param distance: defaults to None + :type distance: int, optional + :param method: mitigation method, defaults to "square" + :type method: str, optional + :param max_iter: defaults to 25 + :type max_iter: int, optional + :param tol: defaults to 1e-5 + :type tol: float, optional + :param return_mitigation_overhead:defaults to False + :type return_mitigation_overhead: bool, optional + :param details: defaults to False + :type details: bool, optional + :return: mitigated count + :rtype: ct + """ + + self.use_qubits = qubits # type: ignore + if not set(self.use_qubits).issubset(set(self.cal_qubits)): # type: ignore + raise ValueError( + "The qubit list used in calculation must included in the calibration qubit list." + ) + + counts = marginal_count(counts, self.use_qubits) # type: ignore + + # methods for small system, "global" calibration only fit for those methods. + if method == "inverse": + mitcounts = self.apply_readout_mitigation(counts, method="inverse") + return mitcounts + elif method == "square": + mitcounts = self.apply_readout_mitigation(counts, method="square") + return mitcounts + if mthree_installed is False: + warnings.warn( + " To use [scalable-] related methods, please pip install mthree !" + ) + + if len(counts) == 0: + raise M3Error("Input counts is any empty dict.") + given_list = False + if isinstance(counts, (list, np.ndarray)): + given_list = True + if not given_list: + counts = [counts] # type: ignore + + if isinstance(qubits, dict): + # If a mapping was given for qubits + qubits = [list(qubits)] + elif not any(isinstance(qq, (list, tuple, np.ndarray, dict)) for qq in qubits): + qubits = [qubits] * len(counts) + else: + if isinstance(qubits[0], dict): + # assuming passed a list of mappings + qubits = [list(qu) for qu in qubits] + + if len(qubits) != len(counts): + raise M3Error("Length of counts does not match length of qubits.") + + quasi_out = [] + for idx, cnts in enumerate(counts): + + quasi_out.append( + self._apply_correction( + cnts, + qubits=qubits[idx], + distance=distance, + method=method, + max_iter=max_iter, + tol=tol, + return_mitigation_overhead=return_mitigation_overhead, + details=details, + ) ) - return ReadoutCal(readoutlist) + if not given_list: + return quasi_out[0] # type: ignore + mitcounts = QuasiCollection(quasi_out) + return mitcounts.nearest_probability_distribution() # type: ignore + + def _apply_correction( # type: ignore + self, + counts, + qubits, + distance=None, + method="auto", + max_iter=25, + tol=1e-5, + return_mitigation_overhead=False, + details=False, + ): + + # This is needed because counts is a Counts object in Qiskit not a dict. + counts = dict(counts) + shots = sum(counts.values()) + + # If distance is None, then assume max distance. + num_bits = len(qubits) + num_elems = len(counts) + if distance is None: + distance = num_bits + + # check if len of bitstrings does not equal number of qubits passed. + bitstring_len = len(next(iter(counts))) + if bitstring_len != num_bits: + raise M3Error( + "Bitstring length ({}) does not match".format(bitstring_len) + + " number of qubits ({})".format(num_bits) + ) + + # Check if no cals done yet + if self.single_qubit_cals is None: + warnings.warn("No calibration data. Calibrating: {}".format(qubits)) + self._grab_additional_cals(qubits, method=self.cal_method) # type: ignore + + # Check if one or more new qubits need to be calibrated. + missing_qubits = [qq for qq in qubits if self.single_qubit_cals[qq] is None] # type: ignore + if any(missing_qubits): + warnings.warn( + "Computing missing calibrations for qubits: {}".format(missing_qubits) + ) + self._grab_additional_cals(missing_qubits, method=self.cal_method) # type: ignore + + if method == "Max1": + current_free_mem = psutil.virtual_memory().available / 1024**3 + # First check if direct method can be run + if num_elems <= self.iter_threshold and ( + (num_elems**2 + num_elems) * 8 / 1024**3 < current_free_mem / 2 + ): + method = "direct" + else: + method = "iterative" + + if method == "Max2": + st = perf_counter() + mit_counts, col_norms, gamma = self._direct_solver( + counts, qubits, distance, return_mitigation_overhead + ) + dur = perf_counter() - st + mit_counts.shots = shots + if gamma is not None: + mit_counts.mitigation_overhead = gamma * gamma + if details: + info = {"method": "direct", "time": dur, "dimension": num_elems} + info["col_norms"] = col_norms + return mit_counts, info + return mit_counts + + elif method == "Max3": + iter_count = np.zeros(1, dtype=int) + + def callback(_): # type: ignore + iter_count[0] += 1 + + if details: + st = perf_counter() + mit_counts, col_norms, gamma = self._matvec_solver( + counts, + qubits, + distance, + tol, + max_iter, + 1, + callback, + return_mitigation_overhead, + ) + dur = perf_counter() - st + mit_counts.shots = shots + if gamma is not None: + mit_counts.mitigation_overhead = gamma * gamma + info = {"method": "iterative", "time": dur, "dimension": num_elems} + info["iterations"] = iter_count[0] + info["col_norms"] = col_norms + return mit_counts, info + # pylint: disable=unbalanced-tuple-unpacking + mit_counts, gamma = self._matvec_solver( + counts, + qubits, + distance, + tol, + max_iter, + 0, + None, + return_mitigation_overhead, + ) + mit_counts.shots = shots + if gamma is not None: + mit_counts.mitigation_overhead = gamma * gamma + return mit_counts + + else: + raise M3Error("Invalid method: {}".format(method)) + + def reduced_cal_matrix(self, counts, qubits, distance=None): # type: ignore + + counts = dict(counts) + # If distance is None, then assume max distance. + num_bits = len(qubits) + if distance is None: + distance = num_bits + + # check if len of bitstrings does not equal number of qubits passed. + bitstring_len = len(next(iter(counts))) + if bitstring_len != num_bits: + raise M3Error( + "Bitstring length ({}) does not match".format(bitstring_len) + + " number of qubits ({})".format(num_bits) + ) + + cals = self._form_cals(qubits) + A, counts, _ = _reduced_cal_matrix(counts, cals, num_bits, distance) + return A, counts + + def _direct_solver( # type: ignore + self, counts, qubits, distance=None, return_mitigation_overhead=False + ): + + cals = self._form_cals(qubits) + num_bits = len(qubits) + A, sorted_counts, col_norms = _reduced_cal_matrix( + counts, cals, num_bits, distance + ) + vec = counts_to_vector(sorted_counts) + LU = la.lu_factor(A, check_finite=False) + x = la.lu_solve(LU, vec, check_finite=False) + gamma = None + if return_mitigation_overhead: + gamma = ainv_onenorm_est_lu(A, LU) + out = vector_to_quasiprobs(x, sorted_counts) + return out, col_norms, gamma + + def _matvec_solver( # type: ignore + self, + counts, + qubits, + distance, + tol=1e-5, + max_iter=25, + details=0, + callback=None, + return_mitigation_overhead=False, + ): + + cals = self._form_cals(qubits) + M = M3MatVec(dict(counts), cals, distance) + L = spla.LinearOperator( + (M.num_elems, M.num_elems), matvec=M.matvec, rmatvec=M.rmatvec + ) + diags = M.get_diagonal() + + def precond_matvec(x): # type: ignore + out = x / diags + return out - elif miti_method == "global": - miticirc = global_miti_readout_circ(nqubit) - calmatrix = np.zeros((2**nqubit, 2**nqubit)) - lbs = execute_fun(miticirc, shots) - for i in range(len(miticirc)): - for s in lbs[i]: - calmatrix[int(s, 2)][i] = lbs[i][s] / shots + P = spla.LinearOperator((M.num_elems, M.num_elems), precond_matvec) + vec = counts_to_vector(M.sorted_counts) + out, error = spla.gmres( + L, vec, tol=tol, atol=tol, maxiter=max_iter, M=P, callback=callback + ) + if error: + raise M3Error("GMRES did not converge: {}".format(error)) - return ReadoutCal(calmatrix) + gamma = None + if return_mitigation_overhead: + gamma = ainv_onenorm_est_iter(M, tol=tol, max_iter=max_iter) - else: - raise ValueError("Unrecognized `miti_method`: %s" % miti_method) + quasi = vector_to_quasiprobs(out, M.sorted_counts) + if details: + return quasi, M.get_col_norms(), gamma + return quasi, gamma From f4223d4607a1bc45f078a25d45723295e6db2041 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Dec 2022 22:09:50 +0800 Subject: [PATCH 108/725] update codecov workflow os --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 03dd81bc..f14ebe2a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -35,7 +35,7 @@ jobs: run: | pytest --cov=tensorcircuit --cov-report=xml -svv --benchmark-skip - name: Upload coverage to Codecov - if: matrix.os == 'ubuntu-18.04' + if: matrix.os == 'ubuntu-20.04' uses: codecov/codecov-action@v2 with: verbose: true From cfb8166ca001378c1d6e14725c344c89c07acb29 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Thu, 8 Dec 2022 22:36:57 +0800 Subject: [PATCH 109/725] revise device readout mitigate --- tensorcircuit/results/readout_mitigation.py | 2 +- tests/test_results.py | 48 ++++++++++++++++++++- 2 files changed, 48 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 7974c2e6..adb99ca7 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -158,7 +158,7 @@ def local_miti_readout_circ(self) -> List[Circuit]: def global_miti_readout_circ(self) -> List[Circuit]: """ - Generate circuits for local calibration. + Generate circuits for global calibration. :return: circuit list :rtype: List[Circuit] diff --git a/tests/test_results.py b/tests/test_results.py index 2426dea2..90e5352f 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -1,5 +1,7 @@ +import tensorcircuit as tc from tensorcircuit.results import counts - +from tensorcircuit.results.readout_mitigation import ReadoutMit +import numpy as np d = {"000": 2, "101": 3, "100": 4} @@ -21,3 +23,47 @@ def test_kl(): def test_correlation(): assert counts.correlation(d, [0, 1]) == -5 / 9 + + +def test_readout(): + + def run(cs, shots): + nqubit = cs[0]._nqubits + gg= [] + for i in range(2*nqubit): + gg.append(np.sin(i)*0.02+0.978) + readout_error = np.reshape(gg,(nqubit,2)) + + ts = [] + for c in cs: + count=c.sample(batch = shots,allow_state=True, readout_error=readout_error,format='count_dict_bin') + ts.append(count) + return ts + + nqubit = 4 + shots=4096 + c = tc.Circuit(nqubit) + c.H(0) + c.cnot(0, 1) + c.x(3) + + idea_count = c.sample(batch = shots,allow_state=True, format='count_dict_bin') + raw_count = run([c],shots)[0] + + mit = ReadoutMit(execute=run) + mit.cals_from_system([0,1,2,3,6], shots=10000, method="local") + + # TODO(@yutuer21): add m3 method + mit_count1 = mit.apply_correction(raw_count, [1,3,2],method = 'inverse') # direct(Max2),iterative(Max3), inverse,square + mit_count2 = mit.apply_correction(raw_count, [1,3,2],method = 'square') + idea_count2 = counts.marginal_count(idea_count, [1,3,2]) + + + assert counts.kl_divergence(idea_count2, mit_count1) < 0.05 + assert counts.kl_divergence(idea_count2, mit_count2) < 0.05 + + + + + + From 41815d12018ce0e93fd2d3fba8aac54b27ef956c Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Thu, 8 Dec 2022 22:50:53 +0800 Subject: [PATCH 110/725] revise device readout mitigate2 --- tests/test_results.py | 43 +++++++++++++++++++++---------------------- 1 file changed, 21 insertions(+), 22 deletions(-) diff --git a/tests/test_results.py b/tests/test_results.py index 90e5352f..5bc76dec 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -26,44 +26,43 @@ def test_correlation(): def test_readout(): - def run(cs, shots): nqubit = cs[0]._nqubits - gg= [] - for i in range(2*nqubit): - gg.append(np.sin(i)*0.02+0.978) - readout_error = np.reshape(gg,(nqubit,2)) + gg = [] + for i in range(2 * nqubit): + gg.append(np.sin(i) * 0.02 + 0.978) + readout_error = np.reshape(gg, (nqubit, 2)) ts = [] for c in cs: - count=c.sample(batch = shots,allow_state=True, readout_error=readout_error,format='count_dict_bin') + count = c.sample( + batch=shots, + allow_state=True, + readout_error=readout_error, + format="count_dict_bin", + ) ts.append(count) return ts - + nqubit = 4 - shots=4096 + shots = 4096 c = tc.Circuit(nqubit) c.H(0) c.cnot(0, 1) c.x(3) - - idea_count = c.sample(batch = shots,allow_state=True, format='count_dict_bin') - raw_count = run([c],shots)[0] + + idea_count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") + raw_count = run([c], shots)[0] mit = ReadoutMit(execute=run) - mit.cals_from_system([0,1,2,3,6], shots=10000, method="local") + mit.cals_from_system([0, 1, 2, 3, 6], shots=10000, method="local") # TODO(@yutuer21): add m3 method - mit_count1 = mit.apply_correction(raw_count, [1,3,2],method = 'inverse') # direct(Max2),iterative(Max3), inverse,square - mit_count2 = mit.apply_correction(raw_count, [1,3,2],method = 'square') - idea_count2 = counts.marginal_count(idea_count, [1,3,2]) - + mit_count1 = mit.apply_correction( + raw_count, [1, 3, 2], method="inverse" + ) # direct(Max2),iterative(Max3), inverse,square + mit_count2 = mit.apply_correction(raw_count, [1, 3, 2], method="square") + idea_count2 = counts.marginal_count(idea_count, [1, 3, 2]) assert counts.kl_divergence(idea_count2, mit_count1) < 0.05 assert counts.kl_divergence(idea_count2, mit_count2) < 0.05 - - - - - - From 0587034f3e9eba963ef01923d6fd6b1da2e16151 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Thu, 8 Dec 2022 23:20:37 +0800 Subject: [PATCH 111/725] revise device readout mitigate2 --- tests/test_results.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/test_results.py b/tests/test_results.py index 5bc76dec..d852e2b3 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -1,7 +1,8 @@ +import numpy as np + import tensorcircuit as tc from tensorcircuit.results import counts from tensorcircuit.results.readout_mitigation import ReadoutMit -import numpy as np d = {"000": 2, "101": 3, "100": 4} From 6f3eab05966b6a1402c641af9230a19d2ba60a22 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 9 Dec 2022 12:58:28 +0800 Subject: [PATCH 112/725] add new mit in results and compiled options in submit --- tensorcircuit/cloud/abstraction.py | 30 +++++++++++++++++++----------- tensorcircuit/cloud/tencent.py | 12 +++++++----- tensorcircuit/cloud/wrapper.py | 26 +++++++++++++++++++++++++- 3 files changed, 51 insertions(+), 17 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index ab719863..f68099e5 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -6,6 +6,7 @@ import time from ..results import readout_mitigation as rem +from ..results import counts class Provider: @@ -188,7 +189,9 @@ def results( format: Optional[str] = None, blocked: bool = False, mitigated: bool = False, - readout_cal: Optional[rem.ReadoutCal] = None, + calibriation_options: Optional[Dict[str, Any]] = None, + readout_mit: Optional[rem.ReadoutMit] = None, + mitigation_options: Optional[Dict[str, Any]] = None, ) -> Any: # TODO(@refraction-ray): support different formats compatible with tc, # also support format_ alias @@ -196,20 +199,20 @@ def results( if self.state() != "completed": raise ValueError("Task %s is not completed yet" % self.id_) r = self.details()["results"] - r = {k: v for k, v in sorted(r.items(), key=lambda item: -item[1])} # type: ignore + r = counts.sort_count(r) # type: ignore else: s = self.state() while s != "completed": if s in ["failed"]: raise ValueError("Task %s is in %s state" % (self.id_, s)) - time.sleep(1.0) + time.sleep(0.5) s = self.state() r = self.results(format=format, blocked=False, mitigated=False) if mitigated is False: return r # mitigated is True: - if readout_cal is None and getattr(self, "readout_cal", None) is None: + if readout_mit is None and getattr(self, "readout_mit", None) is None: def run(cs: Any, shots: Any) -> Any: """ @@ -227,10 +230,15 @@ def run(cs: Any, shots: Any) -> Any: nqubit = len(list(r.keys())[0]) shots = self.details()["shots"] - readout_cal = rem.get_readout_cal(nqubit, shots, run, miti_method="local") - self.readout_cal = readout_cal - elif readout_cal is None: - readout_cal = self.readout_cal - - miti_count = rem.apply_readout_mitigation(r, readout_cal, "square") - return {k: v for k, v in sorted(miti_count.items(), key=lambda item: -item[1])} + mit = rem.ReadoutMit(run) + if calibriation_options is None: + calibriation_options = {} + mit.cals_from_system(list(range(nqubit)), shots, **calibriation_options) + self.readout_mit = readout_mit + elif readout_mit is None: + readout_mit = self.readout_mit + + if mitigation_options is None: + mitigation_options = {} + miti_count = mit.apply_correction(r, list(range(nqubit)), **mitigation_options) + return counts.sort_count(miti_count) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 82f967c7..d61bf3a7 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -86,18 +86,20 @@ def submit_task( source: Optional[Union[str, Sequence[str]]] = None, remarks: Optional[str] = None, compiling: bool = False, + compiled_options: Optional[Dict[str, Any]] = None, ) -> List[Task]: if source is None: + if compiled_options is None: + compiled_options = { + "basis_gates": ["h", "rz", "x", "y", "z", "cx"], + "optimization_level": 2, + } def c2qasm(c: Any, compiling: bool) -> str: if compiling is True: from qiskit.compiler import transpile - c1 = transpile( - c.to_qiskit(), - basis_gates=["h", "rz", "x", "y", "z", "cx"], - optimization_level=2, - ) + c1 = transpile(c.to_qiskit(), **compiled_options) s = c1.qasm() else: s = c.to_openqasm() diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 18925dcd..64b9fb43 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -1,18 +1,42 @@ """ higher level wrapper shortcut for submit_task """ -from typing import Any, Optional, Sequence +from typing import Any, Callable, List, Optional, Sequence, Union +import time import numpy as np from ..circuit import Circuit from ..results import counts +from ..utils import is_sequence from .apis import submit_task, get_device from .abstraction import Device Tensor = Any +def batch_submit_template(device: str) -> Callable[..., List[counts.ct]]: + # TODO(@refraction-ray): fixed when batch submission really works + def run(cs: Union[Circuit, Sequence[Circuit]], shots: int) -> List[counts.ct]: + """ + batch circuit running alternative + """ + single = False + if not is_sequence(cs): + cs = [cs] # type: ignore + single = True + ts = [] + for c in cs: # type: ignore + ts.append(submit_task(circuit=c, shots=shots, device=device)) + time.sleep(0.5) + l = [t.results(blocked=True) for t in ts] # type: ignore + if single is False: + return l + return l[0] # type: ignore + + return run + + def sample_expectation_ps( c: Circuit, x: Optional[Sequence[int]] = None, From c0aa15c3cca2c0ed753231cf0f7cedef90580970 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 9 Dec 2022 12:59:46 +0800 Subject: [PATCH 113/725] allow int qubit in mit --- tensorcircuit/results/counts.py | 4 ++++ tensorcircuit/results/readout_mitigation.py | 20 ++++++++++++-------- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index 1498e09b..cf01b1b0 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -18,6 +18,10 @@ def reverse_count(count: ct) -> ct: return ncount +def sort_count(count: ct) -> ct: + return {k: v for k, v in sorted(count.items(), key=lambda item: -item[1])} + + def normalized_count(count: ct) -> Dict[str, float]: shots = sum([v for k, v in count.items()]) return {k: v / shots for k, v in count.items()} diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index adb99ca7..d95fd041 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -3,7 +3,7 @@ """ # Part of the code in this file is from mthree: https://github.com/Qiskit-Partners/mthree -from typing import Any, Callable, List, Sequence, Optional +from typing import Any, Callable, List, Sequence, Optional, Union import warnings from time import perf_counter @@ -27,6 +27,7 @@ from .counts import count2vec, vec2count, ct, marginal_count from ..circuit import Circuit +from ..utils import is_sequence Tensor = Any @@ -175,7 +176,7 @@ def global_miti_readout_circ(self) -> List[Circuit]: return miticirc def cals_from_system( # type: ignore - self, qubits: List[Any], shots: int = 8192, method: str = "local" + self, qubits: Union[int, List[int]], shots: int = 8192, method: str = "local" ): """ Get calibrattion information from system. @@ -187,7 +188,9 @@ def cals_from_system( # type: ignore :param method: calibration method, defaults to "local", it can also be "global" :type method: str, optional """ - qubits.sort() + if not is_sequence(qubits): + qubits = list(range(qubits)) # type: ignore + qubits.sort() # type: ignore self.cal_qubits = qubits # type: ignore self.cal_shots = shots @@ -278,7 +281,7 @@ def apply_readout_mitigation(self, raw_count: ct, method: str = "inverse") -> ct def apply_correction( self, counts: ct, - qubits: Sequence[Any], + qubits: Sequence[int], distance: Optional[int] = None, method: str = "square", max_iter: int = 25, @@ -308,7 +311,8 @@ def apply_correction( :return: mitigated count :rtype: ct """ - + if not is_sequence(qubits): + qubits = list(range(qubits)) # type: ignore self.use_qubits = qubits # type: ignore if not set(self.use_qubits).issubset(set(self.cal_qubits)): # type: ignore raise ValueError( @@ -339,13 +343,13 @@ def apply_correction( if isinstance(qubits, dict): # If a mapping was given for qubits - qubits = [list(qubits)] + qubits = [list(qubits)] # type: ignore elif not any(isinstance(qq, (list, tuple, np.ndarray, dict)) for qq in qubits): - qubits = [qubits] * len(counts) + qubits = [qubits] * len(counts) # type: ignore else: if isinstance(qubits[0], dict): # assuming passed a list of mappings - qubits = [list(qu) for qu in qubits] + qubits = [list(qu) for qu in qubits] # type: ignore if len(qubits) != len(counts): raise M3Error("Length of counts does not match length of qubits.") From a8c668ee8e3da004ab80a01d8974389c26bef2da Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 9 Dec 2022 17:23:11 +0800 Subject: [PATCH 114/725] add probability method --- CHANGELOG.md | 6 ++++++ tensorcircuit/basecircuit.py | 32 +++++++++++++++++++------------- tests/test_circuit.py | 10 ++++++++++ 3 files changed, 35 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d2869a8a..3c3e10b6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ ## Unreleased +### Added + +- Add `c.probability()` method to return probability amplitude + +- Add results module including funtionalities on count dict manipulation and readout error mitigation + ### Fixed - Fix adjoint possible bug with agnostic backend diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 42d5ea84..59b0060b 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -503,6 +503,21 @@ def amplitude(self, l: Union[str, Tensor]) -> Tensor: no.extend(msconj) return contractor(no).tensor + def probability(self) -> Tensor: + """ + get the 2^n length probability vector over computational basis + + :return: probability vector + :rtype: Tensor + """ + s = self.state() # type: ignore + if self.is_dm is False: + p = backend.abs(s) ** 2 + + else: + p = backend.abs(backend.diagonal(s)) + return p + @partial(arg_alias, alias_dict={"format": ["format_"]}) def sample( self, @@ -569,20 +584,11 @@ def perfect_sampling(key: Any) -> Any: nbatch = 1 else: nbatch = batch - s = self.state() # type: ignore - if self.is_dm is False: - p = backend.abs(s) ** 2 - - # readout error - if readout_error is not None: - p = self.readouterror_bs(readout_error, p) - - else: - p = backend.abs(backend.diagonal(s)) + p = self.probability() - # readout error - if readout_error is not None: - p = self.readouterror_bs(readout_error, p) + # readout error + if readout_error is not None: + p = self.readouterror_bs(readout_error, p) ch = backend.probability_sample(nbatch, p, status, random_generator) # if random_generator is None: # ch = backend.implicit_randc(a=a_range, shape=[nbatch], p=p) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 1738f91c..ae8e2eb0 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -413,6 +413,16 @@ def test_expectation_ps(): np.testing.assert_allclose(r, 1, atol=1e-5) +def test_probability(): + for c_cls in [tc.Circuit, tc.DMCircuit]: + c = c_cls(2) + c.h(0) + c.h(1) + np.testing.assert_allclose( + c.probability(), np.array([1, 1, 1, 1]) / 4, atol=1e-5 + ) + + @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_dqas_type_circuit(backend): eye = tc.gates.i().tensor From 59795093cffc776becd0b00812c6eaef42debe73 Mon Sep 17 00:00:00 2001 From: JiaceSun Date: Sun, 11 Dec 2022 02:08:13 -0800 Subject: [PATCH 115/725] fix bug --- tensorcircuit/basecircuit.py | 3 ++- tensorcircuit/circuit.py | 10 ++++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 148cc2ad..21df9f40 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -766,7 +766,7 @@ def replace_inputs(self, inputs: Tensor) -> None: else: # TODO(@refraction-ray) replace several start as inputs raise NotImplementedError("not support replace with no inputs") - def cond_measurement(self, index: int) -> Tensor: + def cond_measurement(self, index: int, status: Optional[float] = None) -> Tensor: """ Measurement on z basis at ``index`` qubit based on quantum amplitude (not post-selection). The highlight is that this method can return the @@ -797,6 +797,7 @@ def cond_measurement(self, index: int) -> Tensor: return self.general_kraus( # type: ignore [np.array([[1.0, 0], [0, 0]]), np.array([[0, 0], [0, 1]])], index, + status=status, name="measure", ) diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index c3d53d37..4ba9809a 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -407,9 +407,12 @@ def _unitary_kraus_template( l = int(prob.shape[0]) # type: ignore def step_function(x: Tensor) -> Tensor: - r = backend.sum( - backend.stack([backend.sign(x - prob_cumsum[i]) for i in range(l - 1)]) - ) + if l == 1: + r = backend.convert_to_tensor(0.0) + else: + r = backend.sum( + backend.stack([backend.sign(x - prob_cumsum[i]) for i in range(l - 1)]) + ) r = backend.cast(r / 2.0 + (l - 1) / 2.0, dtype="int32") # [0: kraus[0], 1: kraus[1]...] return r @@ -429,7 +432,6 @@ def step_function(x: Tensor) -> Tensor: def _general_kraus_tf( self, - kraus: Sequence[Gate], *index: int, status: Optional[float] = None, ) -> float: From df6679561e71cbc3eec1d3f5f2c731b008591a8f Mon Sep 17 00:00:00 2001 From: JiaceSun Date: Sun, 11 Dec 2022 02:43:52 -0800 Subject: [PATCH 116/725] update --- tensorcircuit/circuit.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index 5ec015a4..19a9bc56 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -412,7 +412,9 @@ def step_function(x: Tensor) -> Tensor: r = backend.convert_to_tensor(0.0) else: r = backend.sum( - backend.stack([backend.sign(x - prob_cumsum[i]) for i in range(l - 1)]) + backend.stack( + [backend.sign(x - prob_cumsum[i]) for i in range(l - 1)] + ) ) r = backend.cast(r / 2.0 + (l - 1) / 2.0, dtype="int32") # [0: kraus[0], 1: kraus[1]...] @@ -433,6 +435,7 @@ def step_function(x: Tensor) -> Tensor: def _general_kraus_tf( self, + kraus: Sequence[Gate], *index: int, status: Optional[float] = None, ) -> float: From 78b591d7be92d71d55fb977e2c35195a531731be Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 12 Dec 2022 18:31:19 +0800 Subject: [PATCH 117/725] support measure and direct qiskit use in submit_task --- tensorcircuit/cloud/tencent.py | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index d61bf3a7..d545df0e 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -87,6 +87,7 @@ def submit_task( remarks: Optional[str] = None, compiling: bool = False, compiled_options: Optional[Dict[str, Any]] = None, + measure: Optional[Sequence[int]] = None, ) -> List[Task]: if source is None: if compiled_options is None: @@ -96,14 +97,32 @@ def submit_task( } def c2qasm(c: Any, compiling: bool) -> str: + from qiskit.compiler import transpile + from qiskit.circuit import QuantumCircuit + if compiling is True: - from qiskit.compiler import transpile + if not isinstance(c, QuantumCircuit): + c = c.to_qiskit() - c1 = transpile(c.to_qiskit(), **compiled_options) + nq = c.num_qubits + c1 = transpile(c, **compiled_options) s = c1.qasm() else: - s = c.to_openqasm() + if isinstance(c, QuantumCircuit): + s = c.qasm() + nq = c.num_qubits + else: + s = c.to_openqasm() + nq = c._nqubits # s = _free_pi(s) # tQuk translation now supports this + if measure is not None: # ad hoc partial measurement + slist = s.split("\n")[:-1] + if len(slist) > 3 and not slist[3].startswith("creg"): + slist.insert(3, "creg c[%s];" % nq) + for m in measure: + slist.append("measure q[%s]->c[%s];" % (m, m)) + slist.append("") + s = "\n".join(slist) return s # type: ignore if is_sequence(circuit): From 9dedd14349362b25dcf91cd6763ed1c1cce883b1 Mon Sep 17 00:00:00 2001 From: weitang li Date: Tue, 13 Dec 2022 17:17:44 +0800 Subject: [PATCH 118/725] fix typo --- tensorcircuit/basecircuit.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index d379a0d3..02599d31 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -534,7 +534,7 @@ def sample( :param batch: number of samples, defaults to None :type batch: Optional[int], optional :param allow_state: if true, we sample from the final state - if memory allsows, True is prefered, defaults to False + if memory allows, True is preferred, defaults to False :type allow_state: bool, optional :param readout_error: readout_error, defaults to None :type readout_error: Optional[Sequence[Any]]. Tensor, List, Tuple @@ -546,8 +546,8 @@ def sample( :param status: external randomness given by tensor uniformly from [0, 1], if set, can overwrite random_generator :type status: Optional[Tensor] - :return: List (if batch) of tuple (binary configuration tensor and correponding probability) - if the format is None, and consitent with format when given + :return: List (if batch) of tuple (binary configuration tensor and corresponding probability) + if the format is None, and consistent with format when given :rtype: Any """ # allow_state = False is compatibility issue From bce0dacf9792b0102988078a4dd7fd24447a6b22 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 13 Dec 2022 17:18:56 +0800 Subject: [PATCH 119/725] add local provider --- tensorcircuit/cloud/apis.py | 37 +++++++++++++++--- tensorcircuit/cloud/local.py | 72 ++++++++++++++++++++++++++++++++++++ tests/test_cloud.py | 38 +++++++++++++++++++ 3 files changed, 141 insertions(+), 6 deletions(-) create mode 100644 tensorcircuit/cloud/local.py diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index a5c139a2..1847262b 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -11,13 +11,14 @@ from .abstraction import Provider, Device, Task, sep from . import tencent +from . import local package_name = "tensorcircuit" thismodule = sys.modules[__name__] default_provider = Provider.from_name("tencent") -avail_providers = ["tencent"] +avail_providers = ["tencent", "local"] def list_providers() -> List[Provider]: @@ -52,9 +53,19 @@ def set_device( provider, device = None, provider if device is None: device = default_device - device = Device.from_name(device, provider) - if provider is None: - provider = device.provider + + if isinstance(device, str): + if len(device.split(sep)) > 1: + device = Device(device, provider) + else: + if provider is None: + provider = get_provider() + device = Device(device, provider) + else: + if provider is None: + provider = get_provider() + device = Device.from_name(device, provider) + if set_global: for module in sys.modules: if module.startswith(package_name): @@ -158,6 +169,8 @@ def list_devices( token = provider.get_token() if provider.name == "tencent": return tencent.list_devices(token) + elif provider.name == "local": + return local.list_devices(token) else: raise ValueError("Unsupported provider: %s" % provider.name) @@ -212,6 +225,8 @@ def get_task_details( if provider.name == "tencent": return tencent.get_task_details(task, device, token) # type: ignore + elif provider.name == "local": + return local.get_task_details(task, device, token) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore @@ -223,8 +238,14 @@ def submit_task( **task_kws: Any, ) -> List[Task]: if device is None: - device = default_device - device = Device.from_name(device, provider) + device = get_device() + if isinstance(device, str): + if len(device.split(sep)) > 1: + device = Device(device, provider) + else: + if provider is None: + provider = get_provider() + device = Device(device, provider) if provider is None: provider = device.provider @@ -233,6 +254,8 @@ def submit_task( if provider.name == "tencent": # type: ignore return tencent.submit_task(device, token, **task_kws) # type: ignore + elif provider.name == "local": # type: ignore + return local.submit_task(device, token, **task_kws) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore @@ -286,5 +309,7 @@ def list_tasks( device = Device.from_name(device) if provider.name == "tencent": # type: ignore return tencent.list_tasks(device, token, **filter_kws) # type: ignore + elif provider.name == "local": # type: ignore + return local.list_tasks(device, token, **filter_kws) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/local.py b/tensorcircuit/cloud/local.py new file mode 100644 index 00000000..fa01aeab --- /dev/null +++ b/tensorcircuit/cloud/local.py @@ -0,0 +1,72 @@ +""" +Cloud provider from local machine +""" + +from typing import Any, Dict, List, Optional, Union, Sequence +from uuid import uuid4 +import time + +from .abstraction import Device, sep, Task +from ..utils import is_sequence +from ..abstractcircuit import AbstractCircuit + +local_devices = ["testing"] + +task_list: Dict[str, Any] = {} # memory only task cache + + +def list_devices(token: Optional[str] = None) -> List[Device]: + rs = [] + for d in local_devices: + rs.append(Device.from_name("local" + sep + d)) + return rs + + +def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: + if task.id_ in task_list: + return task_list[task.id_] # type: ignore + raise ValueError("no task with id: %s" % task.id_) + + +def submit_task( + device: Device, + token: str, + shots: Union[int, Sequence[int]] = 1024, + version: str = "1", + circuit: Optional[Union[AbstractCircuit, Sequence[AbstractCircuit]]] = None, +) -> List[Task]: + def _circuit2result(c: AbstractCircuit) -> Dict[str, Any]: + if device.name == "testing": + count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") # type: ignore + else: + raise ValueError("Unsupported device from local provider: %s" % device.name) + d = { + "id": str(uuid4()), + "state": "completed", + "at": time.time() * 1e6, + "shots": shots, + "device": device.name, + "results": count, + } + return d + + if is_sequence(circuit): + tl = [] + for c in circuit: # type: ignore + d = _circuit2result(c) + task_list[d["id"]] = d + tl.append(Task(id_=d["id"], device=device)) + return tl + else: + d = _circuit2result(circuit) # type: ignore + task_list[d["id"]] = d + + return Task(id_=d["id"], device=device) # type: ignore + + +def list_tasks(device: Device, token: str, **filter_kws: Any) -> List[Task]: + r = [] + for t, v in task_list.items(): + if (device is not None and v["device"] == device.name) or device is None: + r.append(Task(id_=t, device=Device.from_name("local" + sep + v["device"]))) + return r diff --git a/tests/test_cloud.py b/tests/test_cloud.py index 1ea0db0f..c45a057c 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -9,6 +9,7 @@ sys.path.insert(0, modulepath) import tensorcircuit as tc from tensorcircuit.cloud import apis +from tensorcircuit.results import counts def test_get_token(): @@ -74,3 +75,40 @@ def test_list_tasks(): d = apis.get_device(device="simulator:aer") print(d.list_tasks()) print(apis.list_tasks(device="simulator:tc")) + + +def test_local_list_device(): + dd = apis.list_devices(provider="local") + assert dd[0].name == "testing" + + +def test_local_submit_task(): + c = tc.Circuit(2) + c.h(0) + c.cx(0, 1) + + t = apis.submit_task(device="local::testing", circuit=c, shots=2048) + r = t.results(blocked=True) + assert counts.kl_divergence({"00": 0.5, "11": 0.5}, r) < 0.1 + print(t.details()) + print(t.get_device()) + + +def test_local_list_tasks(): + print(apis.list_tasks(provider="local")) + + +def test_local_batch_submit(): + apis.set_provider("local") + c = tc.Circuit(2) + c.h(1) + c.ry(1, theta=0.8) + + ts = apis.submit_task(device="testing", circuit=[c, c]) + print(ts[0].results(mitigated=True)) + + apis.set_device("testing") + ts = apis.submit_task(circuit=[c, c]) + print(ts[1].results()) + print(ts[1].details()) + apis.set_provider() From 9f60b28ca2a777f0d54a05d7037303ae9fc00225 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 14 Dec 2022 11:06:39 +0800 Subject: [PATCH 120/725] change expectation api --- tensorcircuit/cloud/wrapper.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 64b9fb43..bd5c2505 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -63,7 +63,7 @@ def sample_expectation_ps( t = submit_task(circuit=c1, device=device, shots=shots) raw_counts = t.results(blocked=True) # type: ignore x, y, z = list(x), list(y), list(z) - return counts.correlation(raw_counts, x + y + z) + return counts.expectation(raw_counts, x + y + z) # TODO(@refraction-ray): batch support From de46394c3967e18fae0ee5eec5684d77fccdeb63 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 14 Dec 2022 11:07:27 +0800 Subject: [PATCH 121/725] update results module and counts.expectation method --- tensorcircuit/__init__.py | 1 + tensorcircuit/results/counts.py | 52 +++++++++++++++++---- tensorcircuit/results/readout_mitigation.py | 12 +++-- tests/test_results.py | 5 +- 4 files changed, 56 insertions(+), 14 deletions(-) diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 86a4385e..0a5f4786 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -30,6 +30,7 @@ from .vis import qir2tex, render_pdf from . import interfaces from . import templates +from . import results from . import quantum from .quantum import QuOperator, QuVector, QuAdjointVector, QuScalar diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index cf01b1b0..2a7cbec0 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -1,10 +1,9 @@ """ dict related functionalities """ -from typing import Any, Dict, Sequence, Tuple +from typing import Any, Dict, Optional, Sequence import numpy as np -import qiskit Tensor = Any @@ -28,6 +27,8 @@ def normalized_count(count: ct) -> Dict[str, float]: def marginal_count(count: ct, keep_list: Sequence[int]) -> ct: + import qiskit + count = reverse_count(count) ncount = qiskit.result.utils.marginal_distribution(count, keep_list) return reverse_count(ncount) @@ -70,16 +71,49 @@ def kl_divergence(c1: ct, c2: ct) -> float: return kl -def correlation( - count: ct, zlist: Sequence[int], values: Tuple[int, int] = (1, -1) +def expectation( + count: ct, z: Optional[Sequence[int]] = None, diagonal_op: Optional[Tensor] = None ) -> float: - map_dict = {"0": values[0], "1": values[1]} + """ + compute diagonal operator expectation value from bit string count dictionary + + :param count: count dict for bitstring histogram + :type count: ct + :param z: if defaults as None, then ``diagonal_op`` must be set + a list of qubit that we measure Z op on + :type z: Optional[Sequence[int]] + :param diagoal_op: shape [n, 2], explicitly indicate the diagonal op on each qubit + eg. [1, -1] for z [1, 1] for I, etc. + :type diagoal_op: Tensor + :return: the expectation value + :rtype: float + """ + if z is None and diagonal_op is None: + raise ValueError("One of `z` and `diagonal_op` must be set") + n = len(list(count.keys())[0]) + if z is not None: + diagonal_op = [[1, -1] if i in z else [1, 1] for i in range(n)] r = 0 shots = 0 for k, v in count.items(): - ct = 1.0 - for i in zlist: - ct *= map_dict[k[i]] - r += ct * v # type: ignore + cr = 1.0 + for i in range(n): + cr *= diagonal_op[i][int(k[i])] # type: ignore + r += cr * v # type: ignore shots += v return r / shots + + +# def correlation( +# count: ct, zlist: Sequence[int], values: Tuple[int, int] = (1, -1) +# ) -> float: +# map_dict = {"0": values[0], "1": values[1]} +# r = 0 +# shots = 0 +# for k, v in count.items(): +# ct = 1.0 +# for i in zlist: +# ct *= map_dict[k[i]] +# r += ct * v # type: ignore +# shots += v +# return r / shots diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index d95fd041..4719022a 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -1,13 +1,13 @@ """ readout error mitigation functionalities """ -# Part of the code in this file is from mthree: https://github.com/Qiskit-Partners/mthree +# Part of the code in this file is from mthree: https://github.com/Qiskit-Partners/mthree (Apache2) from typing import Any, Callable, List, Sequence, Optional, Union import warnings from time import perf_counter - import psutil + import numpy as np import scipy.linalg as la import scipy.sparse.linalg as spla @@ -53,7 +53,13 @@ def __init__(self, execute: Callable[..., List[ct]], iter_threshold: int = 4096) self.iter_threshold = iter_threshold - self.execute_fun = execute + if isinstance(execute, str): + # execute is a device name str + from ..cloud.wrapper import batch_submit_template + + self.execute_fun: Callable[..., List[ct]] = batch_submit_template(execute) + else: + self.execute_fun = execute def ubs(self, i: int) -> int: """ diff --git a/tests/test_results.py b/tests/test_results.py index d852e2b3..d11a796a 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -22,8 +22,9 @@ def test_kl(): assert counts.kl_divergence(a, a) == 0 -def test_correlation(): - assert counts.correlation(d, [0, 1]) == -5 / 9 +def test_expectation(): + assert counts.expectation(d, [0, 1]) == -5 / 9 + assert counts.expectation(d, None, [[1, -1], [1, 0], [1, 1]]) == -5 / 9 def test_readout(): From 2bec28da2d1196f84d8f777fb4215cdba4cc6d80 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 14 Dec 2022 14:26:41 +0800 Subject: [PATCH 122/725] fix bug for results with mitigated --- tensorcircuit/cloud/abstraction.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index f68099e5..8cb58aa9 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -230,15 +230,19 @@ def run(cs: Any, shots: Any) -> Any: nqubit = len(list(r.keys())[0]) shots = self.details()["shots"] - mit = rem.ReadoutMit(run) + readout_mit = rem.ReadoutMit(run) if calibriation_options is None: calibriation_options = {} - mit.cals_from_system(list(range(nqubit)), shots, **calibriation_options) + readout_mit.cals_from_system( + list(range(nqubit)), shots, **calibriation_options + ) self.readout_mit = readout_mit elif readout_mit is None: readout_mit = self.readout_mit if mitigation_options is None: mitigation_options = {} - miti_count = mit.apply_correction(r, list(range(nqubit)), **mitigation_options) + miti_count = readout_mit.apply_correction( + r, list(range(nqubit)), **mitigation_options + ) return counts.sort_count(miti_count) From 6703f5993c95d6a3ce321f4977d6d23465f16d9a Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 15 Dec 2022 15:10:40 +0800 Subject: [PATCH 123/725] fix t.results bug --- tensorcircuit/cloud/abstraction.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 8cb58aa9..f8933aec 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -210,6 +210,7 @@ def results( r = self.results(format=format, blocked=False, mitigated=False) if mitigated is False: return r + nqubit = len(list(r.keys())[0]) # mitigated is True: if readout_mit is None and getattr(self, "readout_mit", None) is None: @@ -228,7 +229,6 @@ def run(cs: Any, shots: Any) -> Any: time.sleep(0.5) return [t.results(blocked=True) for t in ts] # type: ignore - nqubit = len(list(r.keys())[0]) shots = self.details()["shots"] readout_mit = rem.ReadoutMit(run) if calibriation_options is None: From 8bac83b8d12844c074f16684d4b9cf7404f17910 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 15 Dec 2022 15:12:50 +0800 Subject: [PATCH 124/725] fix rem bug --- tensorcircuit/results/readout_mitigation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 4719022a..658c3a0b 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -282,7 +282,7 @@ def apply_readout_mitigation(self, raw_count: ct, method: str = "inverse") -> ct shots = sum([v for k, v in raw_count.items()]) probability = self.mitigate_probability(probability, method=method) probability = probability * shots - return vec2count(probability) + return vec2count(probability, prune=True) def apply_correction( self, From a3c02e41595d0c5fbfa7b1fa83c2bd3da098bffb Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 16 Dec 2022 10:15:43 +0800 Subject: [PATCH 125/725] rename readme --- README.md | 2 +- README_cn.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 1a3ea07e..bb4c1ad8 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@

- + diff --git a/README_cn.md b/README_cn.md index 140cb428..6f74966a 100644 --- a/README_cn.md +++ b/README_cn.md @@ -3,7 +3,7 @@

- + From a44e1ffea2bbf406381ab96966c7683ee0b1c378 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 16 Dec 2022 11:14:41 +0800 Subject: [PATCH 126/725] more err message and more get_task improvement --- tensorcircuit/cloud/abstraction.py | 11 +++++++++-- tensorcircuit/cloud/apis.py | 5 ++++- tests/test_cloud.py | 2 +- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index f8933aec..f29e13be 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -152,13 +152,16 @@ def list_tasks(self, **filter_kws: Any) -> List["Task"]: return list_tasks(self.provider, self, **filter_kws) +sep2 = "~~" + + class Task: def __init__(self, id_: str, device: Optional[Device] = None): self.id_ = id_ self.device = device def __repr__(self) -> str: - return self.device.__repr__() + "~~" + self.id_ + return self.device.__repr__() + sep2 + self.id_ __str__ = __repr__ @@ -204,7 +207,11 @@ def results( s = self.state() while s != "completed": if s in ["failed"]: - raise ValueError("Task %s is in %s state" % (self.id_, s)) + err = self.details().get("err", "") + raise ValueError( + "Task %s is in %s state with err message %s" + % (self.id_, s, err) + ) time.sleep(0.5) s = self.state() r = self.results(format=format, blocked=False, mitigated=False) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 1847262b..d5ac8661 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -9,7 +9,7 @@ import os import sys -from .abstraction import Provider, Device, Task, sep +from .abstraction import Provider, Device, Task, sep, sep2 from . import tencent from . import local @@ -205,6 +205,9 @@ def get_task( provider, device = None, provider if device is not None: # device can be None for identify tasks device = Device.from_name(device, provider) + elif len(taskid.split(sep2)) > 1: + device = Device(taskid.split(sep2)[0]) + taskid = taskid.split(sep2)[1] return Task(taskid, device=device) diff --git a/tests/test_cloud.py b/tests/test_cloud.py index c45a057c..aa6c17e1 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -54,7 +54,7 @@ def test_submit_task(): c.H(0) c.H(1) c.H(2) - t = apis.submit_task(device="simulator:aer", circuit=c) + t = apis.submit_task(device="simulator:tc", circuit=c) r = t.details() assert r["state"] in ["pending", "completed"] print(t.results(blocked=True)) From 61f44f73f2476906bb8143eba8e986372bcd410d Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Sun, 18 Dec 2022 11:13:18 +0800 Subject: [PATCH 127/725] revise warning of tc gate support --- tensorcircuit/abstractcircuit.py | 4 +++- tensorcircuit/noisemodel.py | 5 ++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index ce08da12..f17680a6 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -453,7 +453,9 @@ def standardize_gate(name: str) -> str: name = g1 break if name not in sgates + vgates + mpogates: - logger.warning("gate name not in the common gate set that tc supported") + logger.warning( + "gate name %s not in the common gate set that tc supported" % name + ) return name def gate_count(self, gate_list: Optional[Sequence[str]] = None) -> int: diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 6f50beb7..a222a230 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -279,7 +279,10 @@ def sample_expectation_ps_noisfy( if noise_conf is None: noise_conf = NoiseConf() - num_quantum = c.gate_count(list(noise_conf.nc.keys())) + lgate = list(noise_conf.nc.keys()) + if "readout" in lgate: + lgate.remove("readout") + num_quantum = c.gate_count(lgate) if noise_conf.has_readout is True: readout_error = noise_conf.nc["readout"]["Default"] From bad2aac92ca1395d545d42efb37a117361101a14 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 19 Dec 2022 14:31:24 +0800 Subject: [PATCH 128/725] enable batch submission --- tensorcircuit/cloud/abstraction.py | 2 +- tensorcircuit/cloud/wrapper.py | 7 ++++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index f29e13be..5a6034a6 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -233,7 +233,7 @@ def run(cs: Any, shots: Any) -> Any: ts.append( submit_task(circuit=c, shots=shots, device=self.get_device()) ) - time.sleep(0.5) + time.sleep(0.3) return [t.results(blocked=True) for t in ts] # type: ignore shots = self.details()["shots"] diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index bd5c2505..87fd5a06 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -26,9 +26,10 @@ def run(cs: Union[Circuit, Sequence[Circuit]], shots: int) -> List[counts.ct]: cs = [cs] # type: ignore single = True ts = [] - for c in cs: # type: ignore - ts.append(submit_task(circuit=c, shots=shots, device=device)) - time.sleep(0.5) + # for c in cs: # type: ignore + # ts.append(submit_task(circuit=c, shots=shots, device=device)) + # time.sleep(0.3) + ts = submit_task(circuit=cs, shots=shots, device=device) l = [t.results(blocked=True) for t in ts] # type: ignore if single is False: return l From fabc82f175f519f7f400567f2d297ec01d7e4e45 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 19 Dec 2022 16:47:05 +0800 Subject: [PATCH 129/725] add tc own exception class for better error handling --- tensorcircuit/cloud/abstraction.py | 121 +++++++++++++++++++++++++---- tensorcircuit/cloud/wrapper.py | 1 - 2 files changed, 104 insertions(+), 18 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 5a6034a6..38d4ac5b 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -3,13 +3,47 @@ """ from typing import Any, Dict, List, Optional, Union +from functools import partial import time from ..results import readout_mitigation as rem from ..results import counts +from ..utils import arg_alias + + +class TCException(BaseException): + pass + + +class TaskException(TCException): + pass + + +class TaskUnfinished(TaskException): + def __init__(self, taskid: str, state: str): + self.taskid = taskid + self.state = state + super().__init__( + "Task %s is not completed yet, now in %s state" % (self.taskid, self.state) + ) + + +class TaskFailed(TaskException): + def __init__(self, taskid: str, state: str, message: str): + self.taskid = taskid + self.state = state + self.message = message + super().__init__( + "Task %s is in %s state with err message %s" + % (self.taskid, self.state, self.message) + ) class Provider: + """ + Provider abstraction for cloud connection, eg. "tencent", "local" + """ + activated_providers: Dict[str, "Provider"] = {} def __init__(self, name: str, lower: bool = True): @@ -70,6 +104,10 @@ def list_tasks(self, **filter_kws: Any) -> List["Task"]: class Device: + """ + Device abstraction for cloud connection, eg. quantum chips + """ + activated_devices: Dict[str, "Device"] = {} def __init__( @@ -156,6 +194,10 @@ def list_tasks(self, **filter_kws: Any) -> List["Task"]: class Task: + """ + Task abstraction for quantum jobs on the cloud + """ + def __init__(self, id_: str, device: Optional[Device] = None): self.id_ = id_ self.device = device @@ -166,27 +208,52 @@ def __repr__(self) -> str: __str__ = __repr__ def get_device(self) -> Device: + """ + Query which device the task is run on + + :return: _description_ + :rtype: Device + """ if self.device is None: return Device.from_name(self.details()["device"]) else: return Device.from_name(self.device) def details(self) -> Dict[str, Any]: + """ + Get the current task details + + :return: _description_ + :rtype: Dict[str, Any] + """ from .apis import get_task_details return get_task_details(self) def state(self) -> str: + """ + Query the current task status + + :return: _description_ + :rtype: str + """ r = self.details() return r["state"] # type: ignore status = state def resubmit(self) -> "Task": + """ + resubmit the task + + :return: the resubmitted task + :rtype: Task + """ from .apis import resubmit_task return resubmit_task(self) + @partial(arg_alias, alias_dict={"format": ["format_"]}) def results( self, format: Optional[str] = None, @@ -195,28 +262,47 @@ def results( calibriation_options: Optional[Dict[str, Any]] = None, readout_mit: Optional[rem.ReadoutMit] = None, mitigation_options: Optional[Dict[str, Any]] = None, - ) -> Any: - # TODO(@refraction-ray): support different formats compatible with tc, - # also support format_ alias + ) -> counts.ct: + """ + get task results of the qjob + + :param format: unsupported now, defaults to None, which is "count_dict_bin" + :type format: Optional[str], optional + :param blocked: whether blocked to wait until the result is returned, defaults to False, + which raise error when the task is unfinished + :type blocked: bool, optional + :param mitigated: whether enable readout error mitigation, defaults to False + :type mitigated: bool, optional + :param calibriation_options: option dict for ``ReadoutMit.cals_from_system``, + defaults to None + :type calibriation_options: Optional[Dict[str, Any]], optional + :param readout_mit: if given, directly use the calibriation info on ``readout_mit``, + defaults to None + :type readout_mit: Optional[rem.ReadoutMit], optional + :param mitigation_options: option dict for ``ReadoutMit.apply_correction``, defaults to None + :type mitigation_options: Optional[Dict[str, Any]], optional + :return: count dict results + :rtype: Any + """ if not blocked: - if self.state() != "completed": - raise ValueError("Task %s is not completed yet" % self.id_) + s = self.state() + if s != "completed": + raise TaskUnfinished(self.id_, s) r = self.details()["results"] r = counts.sort_count(r) # type: ignore else: s = self.state() + tries = 0 while s != "completed": if s in ["failed"]: err = self.details().get("err", "") - raise ValueError( - "Task %s is in %s state with err message %s" - % (self.id_, s, err) - ) - time.sleep(0.5) + raise TaskFailed(self.id_, s, err) + time.sleep(0.5 + tries / 10) + tries += 1 s = self.state() r = self.results(format=format, blocked=False, mitigated=False) if mitigated is False: - return r + return r # type: ignore nqubit = len(list(r.keys())[0]) # mitigated is True: @@ -228,12 +314,13 @@ def run(cs: Any, shots: Any) -> Any: """ from .apis import submit_task - ts = [] - for c in cs: - ts.append( - submit_task(circuit=c, shots=shots, device=self.get_device()) - ) - time.sleep(0.3) + # ts = [] + # for c in cs: + # ts.append( + # submit_task(circuit=c, shots=shots, device=self.get_device()) + # ) + # time.sleep(0.3) + ts = submit_task(circuit=cs, shots=shots, device=self.get_device()) return [t.results(blocked=True) for t in ts] # type: ignore shots = self.details()["shots"] diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 87fd5a06..67ec14f5 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -2,7 +2,6 @@ higher level wrapper shortcut for submit_task """ from typing import Any, Callable, List, Optional, Sequence, Union -import time import numpy as np From ecd83e90e8b089a472aa75972c713a5b803d9989 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 19 Dec 2022 18:06:01 +0800 Subject: [PATCH 130/725] revise readoutmit add m3 add expectation --- tensorcircuit/noisemodel.py | 5 +- tensorcircuit/results/readout_mitigation.py | 105 +++++++++++++++--- tests/test_results.py | 112 +++++++++++++++++++- 3 files changed, 202 insertions(+), 20 deletions(-) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index a222a230..be9d3326 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -359,7 +359,10 @@ def expectation_noisfy( if noise_conf is None: noise_conf = NoiseConf() - num_quantum = c.gate_count(list(noise_conf.nc.keys())) + lgate = list(noise_conf.nc.keys()) + if "readout" in lgate: + lgate.remove("readout") + num_quantum = c.gate_count(lgate) if noise_conf.has_readout is True: logger.warning("expectation_ps_noisfy can't support readout error.") diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 658c3a0b..e9bf874f 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -25,7 +25,7 @@ except ImportError: mthree_installed = False -from .counts import count2vec, vec2count, ct, marginal_count +from .counts import count2vec, vec2count, ct, marginal_count, expectation from ..circuit import Circuit from ..utils import is_sequence @@ -61,12 +61,14 @@ def __init__(self, execute: Callable[..., List[ct]], iter_threshold: int = 4096) else: self.execute_fun = execute - def ubs(self, i: int) -> int: + def ubs(self, i: int, qubits: Optional[Sequence[Any]]) -> int: """ Help omit calibration results that not in used qubit list. :param i: index :type i: int + :param qubits: used qubit list + :type qubits: Sequence[Any] :return: omitation related value :rtype: int """ @@ -74,23 +76,25 @@ def ubs(self, i: int) -> int: lisbs = [int(x) for x in name.format(i)] vomit = 0 - for k in list(filter(lambda x: x not in self.use_qubits, self.cal_qubits)): # type: ignore + for k in list(filter(lambda x: x not in qubits, self.cal_qubits)): # type: ignore vomit += lisbs[self.cal_qubits.index(k)] # type: ignore return vomit - def newrange(self, m: int) -> int: + def newrange(self, m: int, qubits: Optional[Sequence[Any]]) -> int: """ Rerange the order according to used qubit list. :param m: index :type m: int + :param qubits: used qubit list + :type qubits: Sequence[Any] :return: new index :rtype: int """ sorted_index = sorted( - range(len(self.use_qubits)), key=lambda k: self.use_qubits[k] # type: ignore + range(len(qubits)), key=lambda k: qubits[k] # type: ignore ) - name = "{:0" + str(len(self.use_qubits)) + "b}" # type: ignore + name = "{:0" + str(len(qubits)) + "b}" # type: ignore lisbs = [int(x) for x in name.format(m)] lisbs2 = [lisbs[i] for i in sorted_index] @@ -110,7 +114,10 @@ def get_matrix(self, qubits: Optional[Sequence[Any]] = None) -> Tensor: """ if qubits is None: - qubits = self.use_qubits + if self.use_qubits is not None: + qubits = self.use_qubits + else: + qubits = self.cal_qubits if self.local is False: @@ -119,10 +126,10 @@ def get_matrix(self, qubits: Optional[Sequence[Any]] = None) -> Tensor: m = 0 for i in range(len(lbs)): - vv = self.ubs(i) + vv = self.ubs(i, qubits) if vv == 0: for s in lbs[i]: - calmatrix[int(s, 2)][self.newrange(m)] = ( + calmatrix[int(s, 2)][self.newrange(m, qubits)] = ( lbs[i][s] / self.cal_shots ) m += 1 @@ -289,7 +296,7 @@ def apply_correction( counts: ct, qubits: Sequence[int], distance: Optional[int] = None, - method: str = "square", + method: str = "constrained_least_square", max_iter: int = 25, tol: float = 1e-5, return_mitigation_overhead: bool = False, @@ -328,10 +335,10 @@ def apply_correction( counts = marginal_count(counts, self.use_qubits) # type: ignore # methods for small system, "global" calibration only fit for those methods. - if method == "inverse": + if method in ["inverse", "pseudo_inverse"]: mitcounts = self.apply_readout_mitigation(counts, method="inverse") return mitcounts - elif method == "square": + elif method == "constrained_least_square": mitcounts = self.apply_readout_mitigation(counts, method="square") return mitcounts if mthree_installed is False: @@ -424,17 +431,24 @@ def _apply_correction( # type: ignore ) self._grab_additional_cals(missing_qubits, method=self.cal_method) # type: ignore - if method == "Max1": + if method == "M3_auto": + + if self.local is False: + raise ValueError("M3 methods need local calibration") + current_free_mem = psutil.virtual_memory().available / 1024**3 # First check if direct method can be run if num_elems <= self.iter_threshold and ( (num_elems**2 + num_elems) * 8 / 1024**3 < current_free_mem / 2 ): - method = "direct" + method = "M3_direct" else: - method = "iterative" + method = "M3_iterative" + + if method == "M3_direct": + if self.local is False: + raise ValueError("M3 methods need local calibration") - if method == "Max2": st = perf_counter() mit_counts, col_norms, gamma = self._direct_solver( counts, qubits, distance, return_mitigation_overhead @@ -449,7 +463,10 @@ def _apply_correction( # type: ignore return mit_counts, info return mit_counts - elif method == "Max3": + elif method == "M3_iterative": + if self.local is False: + raise ValueError("M3 methods need local calibration") + iter_count = np.zeros(1, dtype=int) def callback(_): # type: ignore @@ -571,3 +588,57 @@ def precond_matvec(x): # type: ignore if details: return quasi, M.get_col_norms(), gamma return quasi, gamma + + def expectation( + self, + counts: ct, + z: Optional[Sequence[int]] = None, + diagonal_op: Optional[Tensor] = None, + method: str = "constrained_least_square", + ) -> float: + """ + Calculate expectation value after readout error mitigation + + :param counts: raw counts + :type counts: ct + :param z: if defaults as None, then ``diagonal_op`` must be set + a list of qubit that we measure Z op on + :type z: Optional[Sequence[int]] + :param diagoal_op: shape [n, 2], explicitly indicate the diagonal op on each qubit + eg. [1, -1] for z [1, 1] for I, etc. + :type diagoal_op: Tensor + :param method: readout mitigation method, defaults to "constrained_least_square" + :type method: str, optional + :return: expectation value after readout error mitigation + :rtype: float + """ + + if z is None and diagonal_op is None: + raise ValueError("One of `z` and `diagonal_op` must be set") + n = len(list(counts.keys())[0]) + + if self.local is True: + inv_single_qubit_cals = [] + for i in range(n): + inv_single_qubit_cals.append(np.linalg.pinv(self.single_qubit_cals[i])) + + if z is None: + diagonal_op = [ + diagonal_op[i] @ inv_single_qubit_cals[i] + for i in range(diagonal_op) + ] + else: + diagonal_op = [ + [1, -1] @ inv_single_qubit_cals[i] + if i in z + else [1, 1] @ inv_single_qubit_cals[i] + for i in range(n) + ] + + mit_value = expectation(counts, diagonal_op=diagonal_op) + + else: + mit_count = self.apply_correction(counts, list(range(n)), method=method) + mit_value = expectation(mit_count, z, diagonal_op) + + return mit_value diff --git a/tests/test_results.py b/tests/test_results.py index d11a796a..8517567a 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -1,5 +1,6 @@ import numpy as np + import tensorcircuit as tc from tensorcircuit.results import counts from tensorcircuit.results.readout_mitigation import ReadoutMit @@ -56,15 +57,122 @@ def run(cs, shots): idea_count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") raw_count = run([c], shots)[0] + # test "inverse", "constrained_least_square", "M3" mit = ReadoutMit(execute=run) mit.cals_from_system([0, 1, 2, 3, 6], shots=10000, method="local") - # TODO(@yutuer21): add m3 method mit_count1 = mit.apply_correction( raw_count, [1, 3, 2], method="inverse" ) # direct(Max2),iterative(Max3), inverse,square - mit_count2 = mit.apply_correction(raw_count, [1, 3, 2], method="square") + mit_count2 = mit.apply_correction( + raw_count, [1, 3, 2], method="constrained_least_square" + ) + mit_count3 = mit.apply_correction(raw_count, [1, 3, 2], method="M3_direct") + mit_count4 = mit.apply_correction(raw_count, [1, 3, 2], method="M3_iterative") idea_count2 = counts.marginal_count(idea_count, [1, 3, 2]) assert counts.kl_divergence(idea_count2, mit_count1) < 0.05 assert counts.kl_divergence(idea_count2, mit_count2) < 0.05 + assert counts.kl_divergence(idea_count2, mit_count3) < 0.05 + assert counts.kl_divergence(idea_count2, mit_count4) < 0.05 + + # test "global" and "equal" + mit = ReadoutMit(execute=run) + mit.cals_from_system([0, 1, 2, 3], shots=100000, method="global") + A_global = mit.get_matrix([1, 3, 2]) + mit_countg = mit.apply_correction( + raw_count, [1, 3, 2], method="constrained_least_square" + ) + + mit = ReadoutMit(execute=run) + mit.cals_from_system([0, 1, 2, 3], shots=100000, method="local") + A_local = mit.get_matrix([1, 3, 2]) + mit_countl = mit.apply_correction( + raw_count, [1, 3, 2], method="constrained_least_square" + ) + + np.testing.assert_allclose(A_global, A_local, atol=1e-2) + assert counts.kl_divergence(mit_countg, mit_countl) < 0.05 + + +def test_readout_expv(): + def run(cs, shots): + nqubit = cs[0]._nqubits + gg = [] + for i in range(2 * nqubit): + gg.append(np.sin(i) * 0.02 + 0.978) + readout_error = np.reshape(gg, (nqubit, 2)) + + ts = [] + for c in cs: + count = c.sample( + batch=shots, + allow_state=True, + readout_error=readout_error, + format="count_dict_bin", + ) + ts.append(count) + return ts + + nqubit = 4 + c = tc.Circuit(nqubit) + c.H(0) + c.cnot(0, 1) + c.x(3) + + idea_count = c.sample(batch=100000, allow_state=True, format="count_dict_bin") + raw_count = run([c], 100000)[0] + + cal_qubits = [0, 1, 2, 3] + use_qubits = [0, 1] + + # idea_value = c.expectation_ps(z=[0,1]) + idea_count2 = counts.marginal_count(idea_count, use_qubits) + idea_value = counts.expectation(idea_count2, z=[0, 1]) + + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="local") + mit_count = mit.apply_correction(raw_count, use_qubits, method="inverse") + mit_value = counts.expectation(mit_count, z=[0, 1]) + + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="local") + mit_value1 = mit.expectation(raw_count, z=[0, 1], method="inverse") + + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="global") + mit_value2 = mit.expectation(raw_count, z=[0, 1], method="inverse") + + np.testing.assert_allclose(idea_value, mit_value, atol=1e-2) + np.testing.assert_allclose(idea_value, mit_value1, atol=1e-2) + np.testing.assert_allclose(idea_value, mit_value2, atol=1e-2) + + # test large size + nqubit = 20 + c = tc.Circuit(nqubit) + c.H(0) + for i in range(nqubit - 1): + c.cnot(i, i + 1) + c.rx(1, theta=0.9) + + idea_count = c.sample(batch=100000, allow_state=True, format="count_dict_bin") + raw_count = run([c], 100000)[0] + + cal_qubits = list(range(nqubit)) + use_qubits = list(range(nqubit)) + + # idea_value = c.expectation_ps(z=[0,1]) + idea_count2 = counts.marginal_count(idea_count, use_qubits) + idea_value = counts.expectation(idea_count2, z=list(range(nqubit))) + + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="local") + mit_count = mit.apply_correction(raw_count, use_qubits, method="M3_auto") + mit_value = counts.expectation(mit_count, z=list(range(nqubit))) + + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="local") + mit_value1 = mit.expectation(raw_count, z=list(range(nqubit)), method="inverse") + + np.testing.assert_allclose(idea_value, mit_value, atol=1e-1) + np.testing.assert_allclose(idea_value, mit_value1, atol=1e-1) From 2e4584b17dfe4324d63322f5febdf0c1dba09b73 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 19 Dec 2022 18:55:23 +0800 Subject: [PATCH 131/725] support any kws for local provider submit task --- tensorcircuit/cloud/abstraction.py | 18 ++++++++++------ tensorcircuit/cloud/apis.py | 34 +++++++++++++++++++++++++++++- tensorcircuit/cloud/local.py | 1 + 3 files changed, 45 insertions(+), 8 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 38d4ac5b..3bcdf035 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -125,10 +125,14 @@ def __init__( else: self.name = name else: # no explicit provider - if len(name.split(sep)) == 1: - name = "tencent" + sep + name # default provider - self.name = name.split(sep)[1] - self.provider = Provider.from_name(name.split(sep)[0]) + if len(name.split(sep)) > 1: + self.name = name.split(sep)[1] + self.provider = Provider.from_name(name.split(sep)[0]) + else: + from .apis import get_provider + + self.name = name + self.provider = get_provider() def __str__(self) -> str: return self.provider.name + sep + self.name @@ -138,11 +142,11 @@ def __str__(self) -> str: @classmethod def from_name( cls, - device: Optional[Union[str, "Device"]] = None, + device: Union[str, "Device"], provider: Optional[Union[str, Provider]] = None, ) -> "Device": - if device is None: - raise ValueError("Must specify on device instead of default ``None``") + # if device is None: + # raise ValueError("Must specify on device instead of default ``None``") if isinstance(device, cls): d = device elif isinstance(device, str): diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index d5ac8661..50c4e3d3 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -22,12 +22,29 @@ def list_providers() -> List[Provider]: + """ + list all providers that tensorcircuit supports + + :return: _description_ + :rtype: List[Provider] + """ return [get_provider(s) for s in avail_providers] def set_provider( provider: Optional[Union[str, Provider]] = None, set_global: bool = True ) -> Provider: + """ + set default provider for the program + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param set_global: whether set, defaults to True, + if False, equivalent to ``get_provider`` + :type set_global: bool, optional + :return: _description_ + :rtype: Provider + """ if provider is None: provider = default_provider provider = Provider.from_name(provider) @@ -41,7 +58,7 @@ def set_provider( set_provider() get_provider = partial(set_provider, set_global=False) -default_device = Device.from_name("tencent::simulator:aer") +default_device = Device.from_name("tencent::simulator:tc") def set_device( @@ -49,8 +66,23 @@ def set_device( device: Optional[Union[str, Device]] = None, set_global: bool = True, ) -> Device: + """ + _summary_ + + :param provider: provider of the device, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: the device, defaults to None + :type device: Optional[Union[str, Device]], optional + :param set_global: whether set, defaults to True, + if False, equivalent to ``get_device``, defaults to True + :type set_global: bool, optional + :return: _description_ + :rtype: Device + """ if provider is not None and device is None: provider, device = None, provider + if device is None and provider is not None: + raise ValueError("Please specify the device apart from the provider") if device is None: device = default_device diff --git a/tensorcircuit/cloud/local.py b/tensorcircuit/cloud/local.py index fa01aeab..53e4e20d 100644 --- a/tensorcircuit/cloud/local.py +++ b/tensorcircuit/cloud/local.py @@ -34,6 +34,7 @@ def submit_task( shots: Union[int, Sequence[int]] = 1024, version: str = "1", circuit: Optional[Union[AbstractCircuit, Sequence[AbstractCircuit]]] = None, + **kws: Any ) -> List[Task]: def _circuit2result(c: AbstractCircuit) -> Dict[str, Any]: if device.name == "testing": From cf7028b9bde88385c1ae6eeeb1a08a6e493a9e4c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 19 Dec 2022 20:39:27 +0800 Subject: [PATCH 132/725] unified provider/device choose interface --- tensorcircuit/cloud/abstraction.py | 10 +- tensorcircuit/cloud/apis.py | 144 +++++++++++++++++++++++------ tests/test_cloud.py | 13 +++ 3 files changed, 132 insertions(+), 35 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 3bcdf035..5958d7ac 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -178,16 +178,16 @@ def list_properties(self) -> Dict[str, Any]: return list_properties(self.provider, self) - def submit_task(self, **task_kws: Any) -> List["Task"]: - from .apis import submit_task - - return submit_task(provider=self.provider, device=self, **task_kws) - def get_task(self, taskid: str) -> "Task": from .apis import get_task return get_task(taskid, device=self) + def submit_task(self, **task_kws: Any) -> List["Task"]: + from .apis import submit_task + + return submit_task(provider=self.provider, device=self, **task_kws) + def list_tasks(self, **filter_kws: Any) -> List["Task"]: from .apis import list_tasks diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 50c4e3d3..54b99bf0 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -2,7 +2,7 @@ main entrypoints of cloud module """ -from typing import Any, List, Optional, Dict, Union +from typing import Any, List, Optional, Dict, Union, Tuple from base64 import b64decode, b64encode from functools import partial import json @@ -120,22 +120,60 @@ def b64decode_s(s: str) -> str: saved_token: Dict[str, Any] = {} +def _preprocess( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, +) -> Tuple[Provider, Device]: + """ + Smartly determine the provider and device based on the input + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :return: a pair of provider and device after preprocessing + :rtype: Tuple[Provider, Device] + """ + if provider is not None and device is None: + provider, device = None, provider + if device is None: + device = get_device() + if isinstance(device, str): + if len(device.split(sep)) > 1: + device = Device.from_name(device, provider) + else: + if provider is None: + provider = get_provider() + device = Device.from_name(device, provider) + if provider is None: + provider = device.provider + return provider, device # type: ignore + + def set_token( token: Optional[str] = None, provider: Optional[Union[str, Provider]] = None, device: Optional[Union[str, Device]] = None, cached: bool = True, ) -> Dict[str, Any]: + """ + Set API token for given provider or specifically to given device + + :param token: the API token, defaults to None + :type token: Optional[str], optional + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :param cached: whether save on the disk, defaults to True + :type cached: bool, optional + :return: _description_ + :rtype: Dict[str, Any] + """ global saved_token homedir = os.path.expanduser("~") authpath = os.path.join(homedir, ".tc.auth.json") - if provider is None: - provider = default_provider - provider = Provider.from_name(provider) - if device is not None: - device = Device.from_name(device, provider) - # if device is None: - # device = default_device + provider, device = _preprocess(provider, device) if token is None: if cached and os.path.exists(authpath): @@ -173,13 +211,23 @@ def get_token( provider: Optional[Union[str, Provider]] = None, device: Optional[Union[str, Device]] = None, ) -> Optional[str]: + """ + Get API token setted for given provider or device, + if no device token saved, the corresponding provider tken is returned + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :return: _description_ + :rtype: Optional[str] + """ if provider is None: - provider = default_provider + provider = get_provider() provider = Provider.from_name(provider) - if device is not None: - device = Device.from_name(device, provider) target = provider.name + sep if device is not None: + device = Device.from_name(device, provider) target = target + device.name for k, v in saved_token.items(): if k == target: @@ -193,7 +241,17 @@ def get_token( def list_devices( provider: Optional[Union[str, Provider]] = None, token: Optional[str] = None -) -> Any: +) -> List[Device]: + """ + List all devices under a provider + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: _description_ + :rtype: Any + """ if provider is None: provider = default_provider provider = Provider.from_name(provider) @@ -212,13 +270,26 @@ def list_properties( device: Optional[Union[str, Device]] = None, token: Optional[str] = None, ) -> Dict[str, Any]: - if provider is not None and device is None: - provider, device = None, provider - if device is None: - device = default_device - device = Device.from_name(device, provider) - if provider is None: - provider = device.provider + """ + List properties of a given device + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: Propeties dict + :rtype: Dict[str, Any] + """ + # if provider is not None and device is None: + # provider, device = None, provider + # if device is None: + # device = default_device + # device = Device.from_name(device, provider) + # if provider is None: + # provider = device.provider + provider, device = _preprocess(provider, device) if token is None: token = device.get_token() # type: ignore @@ -233,6 +304,18 @@ def get_task( provider: Optional[Union[str, Provider]] = None, device: Optional[Union[str, Device]] = None, ) -> Task: + """ + Get ``Task`` object from task string, the binding device can also be provided + + :param taskid: _description_ + :type taskid: str + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :return: _description_ + :rtype: Task + """ if provider is not None and device is None: provider, device = None, provider if device is not None: # device can be None for identify tasks @@ -272,17 +355,18 @@ def submit_task( token: Optional[str] = None, **task_kws: Any, ) -> List[Task]: - if device is None: - device = get_device() - if isinstance(device, str): - if len(device.split(sep)) > 1: - device = Device(device, provider) - else: - if provider is None: - provider = get_provider() - device = Device(device, provider) - if provider is None: - provider = device.provider + # if device is None: + # device = get_device() + # if isinstance(device, str): + # if len(device.split(sep)) > 1: + # device = Device(device, provider) + # else: + # if provider is None: + # provider = get_provider() + # device = Device(device, provider) + # if provider is None: + # provider = device.provider + provider, device = _preprocess(provider, device) if token is None: token = device.get_token() # type: ignore diff --git a/tests/test_cloud.py b/tests/test_cloud.py index aa6c17e1..82902fa0 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -71,6 +71,19 @@ def test_resubmit_task(): print(t1.details()) +def test_get_task(): + apis.set_device("simulator:tcn1") + c = tc.Circuit(2) + c.cx(0, 1) + t = apis.submit_task(circuit=c) + t1 = apis.get_task(t.id_) + assert t1.id_ == t.id_ + t2 = apis.get_device("tencent::simulator:tcn1").get_task(t.id_) + assert t2.id_ == t.id_ + + apis.set_device() + + def test_list_tasks(): d = apis.get_device(device="simulator:aer") print(d.list_tasks()) From bc32881973ee9cbeff5d9e6ea5f267780169dd2f Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 19 Dec 2022 20:46:07 +0800 Subject: [PATCH 133/725] ignore test m3 --- tests/test_results.py | 109 +++++++++++++++++++++++++----------------- 1 file changed, 65 insertions(+), 44 deletions(-) diff --git a/tests/test_results.py b/tests/test_results.py index 8517567a..5b0df97f 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -1,3 +1,4 @@ +import pytest import numpy as np @@ -28,25 +29,26 @@ def test_expectation(): assert counts.expectation(d, None, [[1, -1], [1, 0], [1, 1]]) == -5 / 9 -def test_readout(): - def run(cs, shots): - nqubit = cs[0]._nqubits - gg = [] - for i in range(2 * nqubit): - gg.append(np.sin(i) * 0.02 + 0.978) - readout_error = np.reshape(gg, (nqubit, 2)) - - ts = [] - for c in cs: - count = c.sample( - batch=shots, - allow_state=True, - readout_error=readout_error, - format="count_dict_bin", - ) - ts.append(count) - return ts +def run(cs, shots): + nqubit = cs[0]._nqubits + gg = [] + for i in range(2 * nqubit): + gg.append(np.sin(i) * 0.02 + 0.978) + readout_error = np.reshape(gg, (nqubit, 2)) + + ts = [] + for c in cs: + count = c.sample( + batch=shots, + allow_state=True, + readout_error=readout_error, + format="count_dict_bin", + ) + ts.append(count) + return ts + +def test_readout(): nqubit = 4 shots = 4096 c = tc.Circuit(nqubit) @@ -67,14 +69,10 @@ def run(cs, shots): mit_count2 = mit.apply_correction( raw_count, [1, 3, 2], method="constrained_least_square" ) - mit_count3 = mit.apply_correction(raw_count, [1, 3, 2], method="M3_direct") - mit_count4 = mit.apply_correction(raw_count, [1, 3, 2], method="M3_iterative") idea_count2 = counts.marginal_count(idea_count, [1, 3, 2]) assert counts.kl_divergence(idea_count2, mit_count1) < 0.05 assert counts.kl_divergence(idea_count2, mit_count2) < 0.05 - assert counts.kl_divergence(idea_count2, mit_count3) < 0.05 - assert counts.kl_divergence(idea_count2, mit_count4) < 0.05 # test "global" and "equal" mit = ReadoutMit(execute=run) @@ -96,23 +94,6 @@ def run(cs, shots): def test_readout_expv(): - def run(cs, shots): - nqubit = cs[0]._nqubits - gg = [] - for i in range(2 * nqubit): - gg.append(np.sin(i) * 0.02 + 0.978) - readout_error = np.reshape(gg, (nqubit, 2)) - - ts = [] - for c in cs: - count = c.sample( - batch=shots, - allow_state=True, - readout_error=readout_error, - format="count_dict_bin", - ) - ts.append(count) - return ts nqubit = 4 c = tc.Circuit(nqubit) @@ -167,12 +148,52 @@ def run(cs, shots): mit = ReadoutMit(execute=run) mit.cals_from_system(cal_qubits, shots=100000, method="local") - mit_count = mit.apply_correction(raw_count, use_qubits, method="M3_auto") - mit_value = counts.expectation(mit_count, z=list(range(nqubit))) + mit_value1 = mit.expectation(raw_count, z=list(range(nqubit)), method="inverse") + + np.testing.assert_allclose(idea_value, mit_value1, atol=1e-1) + + +def test_M3(): + + try: + import mthree # pylint: disable=unused-import + except ImportError: + pytest.skip("****** No mthree, skipping test suit *******") + + nqubit = 20 + c = tc.Circuit(nqubit) + c.H(0) + for i in range(nqubit - 1): + c.cnot(i, i + 1) + c.rx(1, theta=0.9) + + idea_count = c.sample(batch=100000, allow_state=True, format="count_dict_bin") + raw_count = run([c], 100000)[0] + + cal_qubits = list(range(nqubit)) + use_qubits = list(range(nqubit)) + + idea_count2 = counts.marginal_count(idea_count, use_qubits) + idea_value = counts.expectation(idea_count2, z=list(range(nqubit))) mit = ReadoutMit(execute=run) mit.cals_from_system(cal_qubits, shots=100000, method="local") - mit_value1 = mit.expectation(raw_count, z=list(range(nqubit)), method="inverse") - + mit_count = mit.apply_correction(raw_count, use_qubits, method="M3_auto") + mit_value = counts.expectation(mit_count, z=list(range(nqubit))) np.testing.assert_allclose(idea_value, mit_value, atol=1e-1) - np.testing.assert_allclose(idea_value, mit_value1, atol=1e-1) + + nqubit = 4 + shots = 4096 + c = tc.Circuit(nqubit) + c.H(0) + c.cnot(0, 1) + c.x(3) + + idea_count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") + raw_count = run([c], shots)[0] + + mit_count3 = mit.apply_correction(raw_count, [1, 3, 2], method="M3_direct") + mit_count4 = mit.apply_correction(raw_count, [1, 3, 2], method="M3_iterative") + idea_count2 = counts.marginal_count(idea_count, [1, 3, 2]) + assert counts.kl_divergence(idea_count2, mit_count3) < 0.05 + assert counts.kl_divergence(idea_count2, mit_count4) < 0.05 From d4c4bef0116a7972ea2ebc64920fccf3f65b5c4b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 19 Dec 2022 20:48:05 +0800 Subject: [PATCH 134/725] add more docstring --- tensorcircuit/cloud/apis.py | 48 +++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 54b99bf0..bf4d5cf0 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -329,6 +329,16 @@ def get_task( def get_task_details( taskid: Union[str, Task], token: Optional[str] = None ) -> Dict[str, Any]: + """ + Get task details dict given task id + + :param taskid: _description_ + :type taskid: Union[str, Task] + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: _description_ + :rtype: Dict[str, Any] + """ if isinstance(taskid, str): task = Task(taskid) else: @@ -355,6 +365,22 @@ def submit_task( token: Optional[str] = None, **task_kws: Any, ) -> List[Task]: + """ + submit task to the cloud platform, batch submission default enabled + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :param token: _description_, defaults to None + :type token: Optional[str], optional + :param task_kws: all necessary keywords arguments for task submission, + see detailed API in each provider backend: + 1. tencent - :py:meth:`tensorcircuit.cloud.tencent.submit_task` + :type task_kws: Any + :return: The task object + :rtype: List[Task] + """ # if device is None: # device = get_device() # if isinstance(device, str): @@ -383,6 +409,16 @@ def resubmit_task( task: Optional[Union[str, Task]], token: Optional[str] = None, ) -> Task: + """ + Rerun the given task + + :param task: _description_ + :type task: Optional[Union[str, Task]] + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: _description_ + :rtype: Task + """ if isinstance(task, str): task = Task(task) device = task.get_device() # type: ignore @@ -419,6 +455,18 @@ def list_tasks( token: Optional[str] = None, **filter_kws: Any, ) -> List[Task]: + """ + List tasks based on given filters + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: list of task object that satisfy these filter criteria + :rtype: List[Task] + """ if provider is None: provider = default_provider provider = Provider.from_name(provider) From f551052b7e993330a2c571de0f1c1b9e7593cc13 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Tue, 20 Dec 2022 10:32:07 +0800 Subject: [PATCH 135/725] add ref --- tensorcircuit/results/readout_mitigation.py | 4 +++- tests/test_results.py | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index e9bf874f..27181c96 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -2,6 +2,7 @@ readout error mitigation functionalities """ # Part of the code in this file is from mthree: https://github.com/Qiskit-Partners/mthree (Apache2) +# https://journals.aps.org/prxquantum/pdf/10.1103/PRXQuantum.2.040326 from typing import Any, Callable, List, Sequence, Optional, Union import warnings @@ -338,7 +339,7 @@ def apply_correction( if method in ["inverse", "pseudo_inverse"]: mitcounts = self.apply_readout_mitigation(counts, method="inverse") return mitcounts - elif method == "constrained_least_square": + elif method in ["square", "constrained_least_square"]: mitcounts = self.apply_readout_mitigation(counts, method="square") return mitcounts if mthree_installed is False: @@ -612,6 +613,7 @@ def expectation( :return: expectation value after readout error mitigation :rtype: float """ + # https://arxiv.org/pdf/2006.14044.pdf if z is None and diagonal_op is None: raise ValueError("One of `z` and `diagonal_op` must be set") diff --git a/tests/test_results.py b/tests/test_results.py index 5b0df97f..c5597fe0 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -122,7 +122,7 @@ def test_readout_expv(): mit = ReadoutMit(execute=run) mit.cals_from_system(cal_qubits, shots=100000, method="global") - mit_value2 = mit.expectation(raw_count, z=[0, 1], method="inverse") + mit_value2 = mit.expectation(raw_count, z=[0, 1], method="square") np.testing.assert_allclose(idea_value, mit_value, atol=1e-2) np.testing.assert_allclose(idea_value, mit_value1, atol=1e-2) From 7fab89a1c1e7879387a553200aa5e2b336223ea7 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 21 Dec 2022 10:42:27 +0800 Subject: [PATCH 136/725] fix warnings and omit psutil package --- CHANGELOG.md | 4 +++- tensorcircuit/backends/jax_backend.py | 9 ++++++--- tensorcircuit/backends/numpy_backend.py | 9 ++++++--- tensorcircuit/results/readout_mitigation.py | 12 +++--------- tests/test_results.py | 1 + 5 files changed, 19 insertions(+), 16 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c3e10b6..b89ba264 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,7 +6,7 @@ - Add `c.probability()` method to return probability amplitude -- Add results module including funtionalities on count dict manipulation and readout error mitigation +- Add results module including funtionalities on count dict manipulation and readout error mitigation (local/global calibriation, scalable counts and expectation mitigation from research papers) ### Fixed @@ -14,6 +14,8 @@ - Fix `sigmoid` bug on pytorch backend +- Ignore ComplexWarning for ``cast`` method on numpy and jax backend + ## 0.6.0 ### Added diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 046a8e6a..617ceebe 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -5,6 +5,7 @@ from functools import partial import logging +import warnings from typing import Any, Callable, Optional, Sequence, Tuple, Union import numpy as np @@ -306,9 +307,11 @@ def dtype(self, a: Tensor) -> str: return a.dtype.__str__() # type: ignore def cast(self, a: Tensor, dtype: str) -> Tensor: - if isinstance(dtype, str): - return a.astype(getattr(jnp, dtype)) - return a.astype(dtype) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", np.ComplexWarning) + if isinstance(dtype, str): + return a.astype(getattr(jnp, dtype)) + return a.astype(dtype) def arange(self, start: int, stop: Optional[int] = None, step: int = 1) -> Tensor: if stop is None: diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index f55a4c36..69edad23 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -4,6 +4,7 @@ # pylint: disable=invalid-name import logging +import warnings from typing import Any, Callable, Optional, Sequence, Tuple, Union import numpy as np @@ -205,9 +206,11 @@ def imag(self, a: Tensor) -> Tensor: return np.imag(a) def cast(self, a: Tensor, dtype: str) -> Tensor: - if isinstance(dtype, str): - return a.astype(getattr(np, dtype)) - return a.astype(dtype) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", np.ComplexWarning) + if isinstance(dtype, str): + return a.astype(getattr(np, dtype)) + return a.astype(dtype) def arange(self, start: int, stop: Optional[int] = None, step: int = 1) -> Tensor: if stop is None: diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 27181c96..836e116b 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -7,7 +7,6 @@ from typing import Any, Callable, List, Sequence, Optional, Union import warnings from time import perf_counter -import psutil import numpy as np import scipy.linalg as la @@ -400,6 +399,8 @@ def _apply_correction( # type: ignore return_mitigation_overhead=False, details=False, ): + if self.local is False: + raise ValueError("M3 methods need local calibration") # This is needed because counts is a Counts object in Qiskit not a dict. counts = dict(counts) @@ -434,8 +435,7 @@ def _apply_correction( # type: ignore if method == "M3_auto": - if self.local is False: - raise ValueError("M3 methods need local calibration") + import psutil current_free_mem = psutil.virtual_memory().available / 1024**3 # First check if direct method can be run @@ -447,9 +447,6 @@ def _apply_correction( # type: ignore method = "M3_iterative" if method == "M3_direct": - if self.local is False: - raise ValueError("M3 methods need local calibration") - st = perf_counter() mit_counts, col_norms, gamma = self._direct_solver( counts, qubits, distance, return_mitigation_overhead @@ -465,9 +462,6 @@ def _apply_correction( # type: ignore return mit_counts elif method == "M3_iterative": - if self.local is False: - raise ValueError("M3 methods need local calibration") - iter_count = np.zeros(1, dtype=int) def callback(_): # type: ignore diff --git a/tests/test_results.py b/tests/test_results.py index c5597fe0..5221cf5e 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -30,6 +30,7 @@ def test_expectation(): def run(cs, shots): + # customized backend for mitigation test nqubit = cs[0]._nqubits gg = [] for i in range(2 * nqubit): From 987474d69d4ea35e714e5cc78818c18176ea4262 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 29 Dec 2022 19:19:15 +0800 Subject: [PATCH 137/725] add optimization level and dry run in tencent backend --- tensorcircuit/cloud/tencent.py | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index d545df0e..fc06ff1a 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -88,6 +88,10 @@ def submit_task( compiling: bool = False, compiled_options: Optional[Dict[str, Any]] = None, measure: Optional[Sequence[int]] = None, + enable_qos_qubit_mapping: bool = True, + enable_qos_gate_decomposition: bool = True, + enable_qos_initial_mapping: bool = False, + qos_dry_run: bool = False, ) -> List[Task]: if source is None: if compiled_options is None: @@ -130,6 +134,21 @@ def c2qasm(c: Any, compiling: bool) -> str: else: source = c2qasm(circuit, compiling) lang = "OPENQASM" + + if len(device.name.split("?")) > 1: + device_str = device.name + else: + oint = 0 + if enable_qos_qubit_mapping: + oint += 1 + if enable_qos_gate_decomposition: + oint += 2 + if enable_qos_initial_mapping: + oint += 4 + device_str = device.name + "?o=" + str(oint) + if qos_dry_run: + device_str += "&dry" + if is_sequence(source): # batched mode json = [] @@ -138,7 +157,7 @@ def c2qasm(c: Any, compiling: bool) -> str: for sc, sh in zip(source, shots): # type: ignore json.append( { - "device": device.name, + "device": device_str, "shots": sh, "source": sc, "version": version, @@ -150,7 +169,7 @@ def c2qasm(c: Any, compiling: bool) -> str: else: json = { # type: ignore - "device": device.name, + "device": device_str, "shots": shots, "source": source, "version": version, From 3bec8805045a8766b8da9fcb69833a5d34cfcb31 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 29 Dec 2022 20:15:50 +0800 Subject: [PATCH 138/725] add compile details in task class --- tensorcircuit/cloud/abstraction.py | 15 ++++++++++ tensorcircuit/cloud/tencent.py | 44 ++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 5958d7ac..aa3169d1 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -344,3 +344,18 @@ def run(cs: Any, shots: Any) -> Any: r, list(range(nqubit)), **mitigation_options ) return counts.sort_count(miti_count) + + def get_compiled_details(self) -> Any: + """ + Experimental, the compiled artifact format is not guaranteed + + :return: [description] + :rtype: Any + """ + results = {} + d = self.details() + if "source" in d: + results["frontend"] = d["source"] + if "optimization" in d and d["state"] == "completed": + results["backend"] = d["optimization"] + return results diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index fc06ff1a..f30e5e79 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -93,6 +93,50 @@ def submit_task( enable_qos_initial_mapping: bool = False, qos_dry_run: bool = False, ) -> List[Task]: + """ + Submit task via tencent provider + + :param device: [description] + :type device: Device + :param token: [description] + :type token: str + :param lang: language choice for ``source``, defaults to "OPENQASM" + :type lang: str, optional + :param shots: number of measurement shots, defaults to 1024 + :type shots: Union[int, Sequence[int]], optional + :param version: submit task protocol version, defaults to "1" + :type version: str, optional + :param prior: priority for the task queue, defaults to 1 + :type prior: int, optional + :param circuit: tensorcircuit or qiskit circuit object, defaults to None + :type circuit: Optional[Union[AbstractCircuit, Sequence[AbstractCircuit]]], optional + :param source: directly given circuit representation, defaults to None + :type source: Optional[Union[str, Sequence[str]]], optional + :param remarks: remarks on the task, defaults to None + :type remarks: Optional[str], optional + :param compiling: whether compiling in tc via qiskit compiling system, + defaults to False + :type compiling: bool, optional + :param compiled_options: compiling options for qiskit ``transpile`` method, + defaults to None + :type compiled_options: Optional[Dict[str, Any]], optional + :param measure: which group of qubit to measure, + defaults to None, the measure result is in the order of qubit index + instead of the ``measure`` list + :type measure: Optional[Sequence[int]], optional + :param enable_qos_qubit_mapping: whether to insert swap if necessary in qos, defaults to True + :type enable_qos_qubit_mapping: bool, optional + :param enable_qos_gate_decomposition: whether to compile the gate in qos, defaults to True + :type enable_qos_gate_decomposition: bool, optional + :param enable_qos_initial_mapping: whether to run an initial qubit mapping in qos, + defaults to False + :type enable_qos_initial_mapping: bool, optional + :param qos_dry_run: when dry run, only compiled circuit is returned (no real circuit execution), + defaults to False + :type qos_dry_run: bool, optional + :return: Task object or List of Task for batch submission + :rtype: List[Task] + """ if source is None: if compiled_options is None: compiled_options = { From 21ffb43d3d3e9f81837d22ac2cf5f53e41031512 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 30 Dec 2022 12:36:41 +0800 Subject: [PATCH 139/725] introduce instruction level extra qir --- CHANGELOG.md | 6 ++++ tensorcircuit/abstractcircuit.py | 47 +++++++++++++++++++++++++++++--- tensorcircuit/circuit.py | 1 + tensorcircuit/densitymatrix.py | 1 + tensorcircuit/mpscircuit.py | 1 + tensorcircuit/translation.py | 42 ++++++++++++++++++++++++++-- tests/test_circuit.py | 1 + 7 files changed, 93 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b89ba264..ae4deec0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,12 @@ - Add results module including funtionalities on count dict manipulation and readout error mitigation (local/global calibriation, scalable counts and expectation mitigation from research papers) +- Add `_extra_qir` to store information on hardware level measurement and reset + +- Add `enable_instruction` option in `to_qiskit` method that enables measurements in qiskit export + +- Add circuit method `measure_instruction` and `reset_instruction` for hardware level instruction flags + ### Fixed - Fix adjoint possible bug with agnostic backend diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index f17680a6..8f60a397 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -66,6 +66,7 @@ class AbstractCircuit: _nqubits: int _qir: List[Dict[str, Any]] + _extra_qir: List[Dict[str, Any]] inputs: Tensor circuit_param: Dict[str, Any] is_mps: bool @@ -500,16 +501,54 @@ def gate_summary(self) -> Dict[str, int]: summary[d["name"]] = summary.get(d["name"], 0) + 1 return summary - def to_qiskit(self) -> Any: + def measure_instruction(self, index: int) -> None: + """ + add a measurement instruction flag, no effect on numerical simulation + + :param index: the corresponding qubit + :type index: int + """ + l = len(self._qir) + d = { + "index": index, + "name": "measure", + "gatef": "measure", + "instruction": True, + "pos": l, + } + self._extra_qir.append(d) + + def reset_instruction(self, index: int) -> None: + """ + add a reset instruction flag, no effect on numerical simulation + + :param index: the corresponding qubit + :type index: int + """ + l = len(self._qir) + d = { + "index": index, + "name": "reset", + "gatef": "reset", + "instruction": True, + "pos": l, + } + self._extra_qir.append(d) + + def to_qiskit(self, enable_instruction: bool = False) -> Any: """ Translate ``tc.Circuit`` to a qiskit QuantumCircuit object. + :param enable_instruction: whether also export measurement and reset instructions + :type enable_instruction: bool, defaults to False :return: A qiskit object of this circuit. """ from .translation import qir2qiskit qir = self.to_qir() - return qir2qiskit(qir, n=self._nqubits) + if enable_instruction is False: + return qir2qiskit(qir, n=self._nqubits) + return qir2qiskit(qir, n=self._nqubits, extra_qir=self._extra_qir) def to_openqasm(self, **kws: Any) -> str: """ @@ -520,7 +559,7 @@ def to_openqasm(self, **kws: Any) -> str: :return: circuit representation in openqasm format :rtype: str """ - return self.to_qiskit().qasm(**kws) # type: ignore + return self.to_qiskit(enable_instruction=True).qasm(**kws) # type: ignore @classmethod def from_openqasm( @@ -561,7 +600,7 @@ def draw(self, **kws: Any) -> Any: q_2: ┤ X ├───── └───┘ """ - return self.to_qiskit().draw(**kws) + return self.to_qiskit(enable_instruction=True).draw(**kws) @classmethod def from_qiskit( diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index 19a9bc56..04df94b2 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -109,6 +109,7 @@ def __init__( # self._qcode = "" # deprecated # self._qcode += str(self._nqubits) + "\n" self._qir: List[Dict[str, Any]] = [] + self._extra_qir: List[Dict[str, Any]] = [] def replace_mps_inputs(self, mps_inputs: QuOperator) -> None: """ diff --git a/tensorcircuit/densitymatrix.py b/tensorcircuit/densitymatrix.py index 4197bcd9..03fd52b1 100644 --- a/tensorcircuit/densitymatrix.py +++ b/tensorcircuit/densitymatrix.py @@ -128,6 +128,7 @@ def __init__( } self._qir: List[Dict[str, Any]] = [] + self._extra_qir: List[Dict[str, Any]] = [] def _double_nodes_front(self) -> None: lnodes, lfront = self.copy(self._nodes, self._front, conj=True) diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index dfa6eb9c..bf33d507 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -139,6 +139,7 @@ def __init__( self._nqubits = nqubits self._fidelity = 1.0 self._qir: List[Dict[str, Any]] = [] + self._extra_qir: List[Dict[str, Any]] = [] # `MPSCircuit` does not has `replace_inputs` like `Circuit` # because the gates are immediately absorted into the MPS when applied, diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 226a0532..c44787ef 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -59,7 +59,24 @@ def _get_float(parameters: Any, key: str, default: int = 0) -> float: return np.real(backend.numpy(gates.array_to_tensor(parameters.get(key, default)))).item() # type: ignore -def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: +def _merge_extra_qir( + qir: List[Dict[str, Any]], extra_qir: List[Dict[str, Any]] +) -> List[Dict[str, Any]]: + nqir = [] + inds = {d["pos"]: d for d in extra_qir} + for i, q in enumerate(qir): + if i in inds: + nqir.append(inds[i]) + nqir.append(q) + for k in inds: + if k >= len(qir): + nqir.append(inds[k]) + return nqir + + +def qir2qiskit( + qir: List[Dict[str, Any]], n: int, extra_qir: Optional[List[Dict[str, Any]]] = None +) -> Any: r""" Generate a qiskit quantum circuit using the quantum intermediate representation (qir) in tensorcircuit. @@ -78,10 +95,17 @@ def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: :type qir: List[Dict[str, Any]] :param n: # of qubits :type n: int + :param extra_qir: The extra quantum IR of tc circuit including measure and reset on hardware, + defaults to None + :type extra_qir: Optional[List[Dict[str, Any]]] :return: qiskit QuantumCircuit object :rtype: Any """ - qiskit_circ = QuantumCircuit(n) + if extra_qir is not None: + qir = _merge_extra_qir(qir, extra_qir) + qiskit_circ = QuantumCircuit(n, n) + else: + qiskit_circ = QuantumCircuit(n) for gate_info in qir: index = gate_info["index"] gate_name = str(gate_info["gatef"]) @@ -164,6 +188,10 @@ def qir2qiskit(qir: List[Dict[str, Any]], n: int) -> Any: ) ) qiskit_circ.unitary(qop, index[::-1], label=qis_name) + elif gate_name == "measure": + qiskit_circ.measure(index, index) + elif gate_name == "reset": + qiskit_circ.reset(index) else: # r cr any gate gatem = np.reshape( backend.numpy(gate_info["gatef"](**parameters).tensor), @@ -305,6 +333,16 @@ def qiskit2tc( tc_circuit.multicontrol( *idx, ctrl=ctrl_state, unitary=base_gate.to_matrix() ) + elif gate_name == "measure": + tc_circuit.measure_instruction(*idx) + # logger.warning( + # "qiskit to tc translation currently doesn't support measure instruction, just skipping" + # ) + elif gate_name == "reset": + tc_circuit.reset_instruction(*idx) + # logger.warning( + # "qiskit to tc translation currently doesn't support reset instruction, just skipping" + # ) else: # unitary gate idx_inverse = (x for x in idx[::-1]) tc_circuit.any(*idx_inverse, unitary=gate_info[0].to_matrix()) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index ae8e2eb0..67664e58 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1232,6 +1232,7 @@ def test_to_openqasm(): c.rzz(0, 1, theta=-1.0) c.ccx(1, 2, 0) c.u(2, theta=0.5, lbd=1.3) + c.measure_instruction(1) print(c.to_openqasm(formatted=True)) s = c.to_openqasm() c1 = tc.Circuit.from_openqasm(s) From 00e44c964a1d12c3150de72955f0f1bd3424e7ab Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 30 Dec 2022 19:43:05 +0800 Subject: [PATCH 140/725] fix extra qir multiple same pos bug when merge --- tensorcircuit/results/readout_mitigation.py | 10 +++++++--- tensorcircuit/translation.py | 13 +++++++++---- 2 files changed, 16 insertions(+), 7 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 836e116b..bcf60b51 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -25,7 +25,7 @@ except ImportError: mthree_installed = False -from .counts import count2vec, vec2count, ct, marginal_count, expectation +from .counts import count2vec, vec2count, ct, marginal_count, expectation, sort_count from ..circuit import Circuit from ..utils import is_sequence @@ -333,7 +333,7 @@ def apply_correction( ) counts = marginal_count(counts, self.use_qubits) # type: ignore - + shots = sum([v for _, v in counts.items()]) # methods for small system, "global" calibration only fit for those methods. if method in ["inverse", "pseudo_inverse"]: mitcounts = self.apply_readout_mitigation(counts, method="inverse") @@ -384,7 +384,11 @@ def apply_correction( ) if not given_list: - return quasi_out[0] # type: ignore + r = quasi_out[0] + r = sort_count(r) + r = {k: v * shots for k, v in r.items()} + return r # type: ignore + # return quasi_out[0] # type: ignore mitcounts = QuasiCollection(quasi_out) return mitcounts.nearest_probability_distribution() # type: ignore diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index c44787ef..fa4d0b4e 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -63,14 +63,19 @@ def _merge_extra_qir( qir: List[Dict[str, Any]], extra_qir: List[Dict[str, Any]] ) -> List[Dict[str, Any]]: nqir = [] - inds = {d["pos"]: d for d in extra_qir} + # caution on the same pos! + inds: Dict[int, List[Dict[str, Any]]] = {} + for d in extra_qir: + if d["pos"] not in inds: + inds[d["pos"]] = [] + inds[d["pos"]].append(d) for i, q in enumerate(qir): if i in inds: - nqir.append(inds[i]) + nqir += inds[i] nqir.append(q) for k in inds: if k >= len(qir): - nqir.append(inds[k]) + nqir += inds[k] return nqir @@ -101,7 +106,7 @@ def qir2qiskit( :return: qiskit QuantumCircuit object :rtype: Any """ - if extra_qir is not None: + if extra_qir is not None and len(extra_qir) > 0: qir = _merge_extra_qir(qir, extra_qir) qiskit_circ = QuantumCircuit(n, n) else: From f806a1dc065692b15dad2da77a67eee474ff5b0c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 30 Dec 2022 19:44:57 +0800 Subject: [PATCH 141/725] add sdk tutorial --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 1529 +++++++++++++++++++++ 1 file changed, 1529 insertions(+) create mode 100644 docs/source/tutorials/tc_qcloud_sdk.ipynb diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb new file mode 100644 index 00000000..88297b2f --- /dev/null +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -0,0 +1,1529 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "38c73e8c", + "metadata": {}, + "source": [ + "# tensorcircuit SDK for QCloud（221230 ver）" + ] + }, + { + "cell_type": "markdown", + "id": "f77a17c8", + "metadata": {}, + "source": [ + "## import the package\n", + "\n", + "``apis`` is temporarily as the entry point submodule for qcloud" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8595b0b0", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "from tensorcircuit.cloud import apis\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "faece4fa", + "metadata": {}, + "source": [ + "## setup the token\n", + "\n", + "The users need an API token from tQuK to connect to the server and submit tasks, the token only need be set once and it is then written to the local computer" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "06e38047", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'tencent::': 'wROld-1665558660551115293;8',\n", + " 'tencent::simulator:tc': 'wROld-1665558660551115293;8'}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "apis.set_token(\"wROld-1665558660551115293;8\")\n", + "# only required running once for a given laptop" + ] + }, + { + "cell_type": "markdown", + "id": "f3e53835", + "metadata": {}, + "source": [ + "## list providers/devices/properties" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "59dc5c6f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[tencent, local]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "apis.list_providers()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d231e5c3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[tencent::20xmon,\n", + " tencent::9gmon,\n", + " tencent::simulator:aer,\n", + " tencent::simulator:qx,\n", + " tencent::simulator:tc,\n", + " tencent::simulator:tcn1]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "apis.list_devices(\"tencent\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e2ab9a2c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'id': '9gmon',\n", + " 'type': 'CHIP',\n", + " 'qubits': 9,\n", + " 'state': 'on',\n", + " 'queue': 0,\n", + " 'langs': ['tQASM', 'eQASM'],\n", + " 'memo': 'tQLab 9Gmon',\n", + " 'usage': '9gmon?o=0 \\nthe o(ptimized) to specify optimization level bits: both = 3 (bits 11) = gate decomposition = 2 (bit 10) | qubit mapping = 1 (bit 01)'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "apis.list_properties(device=\"9gmon\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "aaec43c3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'id': 'simulator:tcn1',\n", + " 'alias': 'simulator:tc?noise',\n", + " 'state': '',\n", + " 'queue': 0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "apis.list_properties(device=\"simulator:tcn1\")" + ] + }, + { + "cell_type": "markdown", + "id": "148b9b40", + "metadata": {}, + "source": [ + "## Task submit and the results" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "94404d7a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'id': '2831cfb4-cdae-4b1d-8917-70d4a0fa4b72', 'queue': 'low', 'device': 'simulator:tc?o=3', 'state': 'pending', 'shots': 1024, 'at': 1672391326132532, 'ts': {'pending': 1672391326132532, 'scheduled': 1672391326129379}, 'md5': 'db493e15a6e8a68beed1815f760b45d0', 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[1];\\ncreg c[1];\\nh q[0];', 'version': '1', 'lang': 'OPENQASM', 'prior': 1, 'optimization': {}}\n" + ] + }, + { + "data": { + "text/plain": [ + "{'0': 549, '1': 475}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = tc.Circuit(1)\n", + "c.H(0)\n", + "\n", + "t = apis.submit_task(device=\"simulator:tc\", circuit=c, shots=1024)\n", + "print(t.details())\n", + "t.results(blocked=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "617cbd84", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'completed'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.status()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a6e686be", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tencent::simulator:tc" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.get_device()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "77dddd16", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'id': '7e212512-8d10-4bb9-bd24-5cf036da41d2', 'queue': 'low', 'device': 'simulator:tc?o=3', 'qubits': 1, 'state': 'pending', 'shots': 1024, 'at': 1672391337185756, 'ts': {'completed': 1672391327686452, 'pending': 1672391337185756, 'scheduled': 1672391337178889}, 'md5': 'db493e15a6e8a68beed1815f760b45d0', 'runAt': 1672391326, 'runDur': 1036, 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[1];\\ncreg c[1];\\nh q[0];', 'version': '1', 'lang': 'OPENQASM', 'prior': 1, 'result': {'0': 549, '1': 475}, 'optimization': {}, 'results': {'0': 549, '1': 475}}\n" + ] + }, + { + "data": { + "text/plain": [ + "{'0': 534, '1': 490}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# resubmit a job\n", + "t1 = t.resubmit()\n", + "print(t1.details())\n", + "t1.results(blocked=True)" + ] + }, + { + "cell_type": "markdown", + "id": "8c795e68", + "metadata": {}, + "source": [ + "## local provider enable quick debugging and testing" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "570159fe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[local::testing]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "apis.set_provider(\"local\")\n", + "# using tc simulator on local device: your own laptop is your server\n", + "apis.list_devices()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "fd99ee01", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'00': 4100, '11': 4092}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = tc.Circuit(2)\n", + "c.h(0)\n", + "c.cx(0, 1)\n", + "\n", + "# exactly the same API as tQuK\n", + "t = apis.submit_task(circuit=c, device=\"testing\", shots=8192)\n", + "t.results(blocked=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "bb62ed45", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[local::testing~~0e061ad5-e721-402a-a649-8dd4eb520d80]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tl = apis.list_tasks()\n", + "tl" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "045a19ef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "local::testing~~0e061ad5-e721-402a-a649-8dd4eb520d80\n" + ] + }, + { + "data": { + "text/plain": [ + "{'id': '0e061ad5-e721-402a-a649-8dd4eb520d80',\n", + " 'state': 'completed',\n", + " 'at': 1672391359398387.0,\n", + " 'shots': 8192,\n", + " 'device': 'testing',\n", + " 'results': {'00': 4100, '11': 4092}}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "id_ = tl[0].__str__()\n", + "print(id_)\n", + "t = apis.get_task(id_)\n", + "t.details()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "307eeb42", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tencent" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# back to tencent server by\n", + "apis.set_provider(\"tencent\")" + ] + }, + { + "cell_type": "markdown", + "id": "9bf0d5ca", + "metadata": {}, + "source": [ + "## GHZ on real device and readout mitigation" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "2cc7c82c", + "metadata": {}, + "outputs": [], + "source": [ + "nqubit = 9\n", + "shots = 4096\n", + "c = tc.Circuit(nqubit)\n", + "c.H(8)\n", + "c.cnot(8, 4)\n", + "c.cnot(4, 0)\n", + "c.cnot(0, 2)\n", + "c.cnot(2, 6)\n", + "\n", + "t = apis.submit_task(\n", + " circuit=c, shots=shots, device=\"9gmon\", enable_qos_qubit_mapping=False\n", + ")\n", + "raw_count = t.results(blocked=True)\n", + "# blocked = True will block the process until the result is returned\n", + "# the default behavior is blocked=False, where only one query is made and raise error when the task is incomplete" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "f2ed2419", + "metadata": {}, + "outputs": [], + "source": [ + "ReadoutMit = tc.results.readout_mitigation.ReadoutMit\n", + "mit = ReadoutMit(\"9gmon?o=0\")\n", + "mit.cals_from_system(nqubit, shots, method=\"local\")\n", + "miti_count = mit.apply_correction(raw_count, nqubit, \"square\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "139700b3", + "metadata": {}, + "outputs": [], + "source": [ + "raw_count = tc.results.counts.marginal_count(raw_count, [8, 4, 0, 2, 6])\n", + "miti_count = tc.results.counts.marginal_count(miti_count, [8, 4, 0, 2, 6])\n", + "# only keep the result for qubit 8, 4, 0, 2, 6 and in that order" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "093ec74c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.visualization import plot_histogram\n", + "\n", + "plot_histogram([raw_count, miti_count])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "e4bd6569", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.4302675317947488, 0.08294928617219555)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ideal_count = tc.results.counts.vec2count(c.probability(), prune=True)\n", + "ideal_count = tc.results.counts.marginal_count(ideal_count, [8, 4, 0, 2, 6])\n", + "tc.results.counts.kl_divergence(\n", + " ideal_count, raw_count\n", + "), tc.results.counts.kl_divergence(ideal_count, miti_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "91720f2c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "readout matrix\n", + "qubit 0:\n", + "[[0.95800781 0.16650391]\n", + " [0.04199219 0.83349609]]\n", + "qubit 1:\n", + "[[0.96606445 0.08862305]\n", + " [0.03393555 0.91137695]]\n", + "qubit 2:\n", + "[[0.98266602 0.06079102]\n", + " [0.01733398 0.93920898]]\n", + "qubit 3:\n", + "[[0.99389648 0.07177734]\n", + " [0.00610352 0.92822266]]\n", + "qubit 4:\n", + "[[0.984375 0.06225586]\n", + " [0.015625 0.93774414]]\n", + "qubit 5:\n", + "[[0.97802734 0.06787109]\n", + " [0.02197266 0.93212891]]\n", + "qubit 6:\n", + "[[0.95703125 0.0925293 ]\n", + " [0.04296875 0.9074707 ]]\n", + "qubit 7:\n", + "[[0.97607422 0.07910156]\n", + " [0.02392578 0.92089844]]\n", + "qubit 8:\n", + "[[0.95629883 0.14672852]\n", + " [0.04370117 0.85327148]]\n" + ] + } + ], + "source": [ + "# we can directly check local readout matrix on each qubit\n", + "print(\"readout matrix\")\n", + "for i, m in enumerate(mit.single_qubit_cals):\n", + " print(\"qubit %s:\" % i)\n", + " print(m)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "db3e59b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'00': 526, '10': 481, '01': 10, '11': 7}\n", + "{'00': 524, '01': 470, '11': 18, '10': 12}\n" + ] + } + ], + "source": [ + "# we can also do batch submission\n", + "\n", + "c = tc.Circuit(2)\n", + "c.h(0)\n", + "\n", + "c1 = tc.Circuit(2)\n", + "c1.h(1)\n", + "\n", + "ts = apis.submit_task(device=\"9gmon\", circuit=[c, c1], shots=1024)\n", + "\n", + "for t in ts:\n", + " print(t.results(blocked=True))" + ] + }, + { + "cell_type": "markdown", + "id": "4d2c56b6", + "metadata": {}, + "source": [ + "## three approaches for measure on partial of the qubits\n", + "\n", + "Note the return order is not according to the original qubit order instead of measure order in the instructions" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "9d7abd03", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'00000': 1645, '11111': 988, '00101': 205, '11110': 147, '01111': 142, '11010': 137, '00001': 135, '11101': 101, '11011': 76, '01010': 70, '00010': 64, '10111': 58, '00100': 53, '01101': 36, '01000': 31, '10000': 29, '10101': 29, '00111': 23, '01011': 19, '11000': 18, '11100': 16, '01110': 15, '01100': 10, '10110': 9, '01001': 7, '10010': 7, '10001': 6, '10011': 6, '10100': 5, '11001': 5, '00011': 4}\n" + ] + } + ], + "source": [ + "# directly partial measure\n", + "\n", + "# approach 1\n", + "nqubit = 9\n", + "shots = 4096\n", + "c = tc.Circuit(nqubit)\n", + "c.H(8)\n", + "c.cnot(8, 4)\n", + "c.cnot(4, 0)\n", + "c.cnot(0, 2)\n", + "c.cnot(2, 6)\n", + "\n", + "t = apis.submit_task(\n", + " circuit=c, shots=shots, device=\"9gmon?o=0\", measure=[8, 4, 0, 2, 6]\n", + ")\n", + "print(t.results(blocked=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "9ac0b2fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'00000': 3305, '11111': 2115, '00001': 378, '11110': 354, '11101': 296, '01111': 247, '00101': 212, '00010': 146, '11010': 145, '10111': 139, '11011': 135, '10101': 96, '00100': 86, '01010': 79, '01101': 71, '01000': 61, '11100': 54, '01110': 43, '10000': 28, '00111': 24, '01011': 24, '10110': 23, '00011': 22, '11001': 22, '10100': 15, '01100': 14, '11000': 14, '01001': 11, '10010': 10, '10001': 9, '10011': 8, '00110': 6}\n" + ] + } + ], + "source": [ + "# directly partial measure\n", + "\n", + "# approach 2\n", + "from qiskit.circuit import QuantumCircuit\n", + "\n", + "qc = QuantumCircuit(9, 9)\n", + "qc.h(8)\n", + "qc.cnot(8, 4)\n", + "qc.cnot(4, 0)\n", + "qc.cnot(0, 2)\n", + "qc.cnot(2, 6)\n", + "qc.measure(8, 8)\n", + "qc.measure(4, 4)\n", + "qc.measure(0, 0)\n", + "qc.measure(2, 2)\n", + "qc.measure(6, 6)\n", + "\n", + "t = apis.submit_task(\n", + " circuit=qc, shots=shots, device=\"9gmon?o=0\"\n", + ")\n", + "print(t.results(blocked=True))" + ] + }, + { + "cell_type": "markdown", + "id": "7ea3ea0f", + "metadata": {}, + "source": [ + " The above case also indicate that our ``submit_task`` API directly support Qiskit ``QuantumCircuit`` object" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5ce371e9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'00000': 1594, '11111': 984, '00101': 214, '11010': 167, '00001': 148, '11110': 125, '01111': 122, '11101': 120, '11011': 87, '10111': 74, '00010': 68, '00100': 44, '01000': 43, '01010': 39, '10101': 35, '01101': 32, '10000': 27, '00111': 23, '11000': 22, '11100': 18, '01110': 16, '10010': 15, '10110': 14, '01011': 10, '01100': 10, '01001': 9, '11001': 9, '00011': 8, '10011': 6, '10100': 6, '00110': 4, '10001': 3}\n" + ] + } + ], + "source": [ + "# directly partial measure\n", + "\n", + "# approach 3\n", + "\n", + "nqubit = 9\n", + "shots = 4096\n", + "c = tc.Circuit(nqubit)\n", + "c.H(8)\n", + "c.cnot(8, 4)\n", + "c.cnot(4, 0)\n", + "c.cnot(0, 2)\n", + "c.cnot(2, 6)\n", + "c.measure_instruction(8)\n", + "c.measure_instruction(4)\n", + "c.measure_instruction(0)\n", + "c.measure_instruction(2)\n", + "c.measure_instruction(6)\n", + "\n", + "t = apis.submit_task(circuit=c, shots=shots, device=\"9gmon?o=0\")\n", + "print(t.results(blocked=True))" + ] + }, + { + "cell_type": "markdown", + "id": "20b8b1d5", + "metadata": {}, + "source": [ + "## two level compiling system\n", + "\n", + "We provide compiling support at frond end (via tc-qiskit pipeline) and at back end (in qos)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "03aed751", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exact: [array(-5.9604645e-08, dtype=float32), array(0.3623577, dtype=float32), array(0.76484215, dtype=float32)]\n", + "experiments (mitigated): [0.04084053550245752, 0.28041151119143615, 0.8151639888461032]\n" + ] + } + ], + "source": [ + "# directly use built-in mitigation with expectation evaluation + front-end (tc/qiskit) compiling system\n", + "\n", + "nqubit = 3\n", + "shots = 8192\n", + "c = tc.Circuit(nqubit)\n", + "c.h(0)\n", + "c.h(1)\n", + "c.rx(2, theta=0.7)\n", + "c.ry(1, theta=-1.2)\n", + "c.cnot(0, 1)\n", + "c.cnot(2, 0)\n", + "c.h(1)\n", + "\n", + "print(\"exact: \", [np.real(c.expectation_ps(z=[i])) for i in range(nqubit)])\n", + "t = apis.submit_task(\n", + " circuit=c,\n", + " shots=shots,\n", + " device=\"9gmon\",\n", + " compiled=True,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + ")\n", + "\n", + "ct = t.results(blocked=True)\n", + "\n", + "mit = tc.results.readout_mitigation.ReadoutMit(\"9gmon?o=0\")\n", + "mit.cals_from_system(3, method=\"local\")\n", + "\n", + "print(\n", + " \"experiments (mitigated): \",\n", + " [mit.expectation(ct, [i]) for i in range(nqubit)],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bd760c6b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
        ┌───┐                    ┌───┐     \n",
+       "q_0: ───┤ H ├─────────────────■──┤ X ├─────\n",
+       "        ├───┤   ┌──────────┐┌─┴─┐└─┬─┘┌───┐\n",
+       "q_1: ───┤ H ├───┤ Ry(-1.2) ├┤ X ├──┼──┤ H ├\n",
+       "     ┌──┴───┴──┐└──────────┘└───┘  │  └───┘\n",
+       "q_2: ┤ Rx(0.7) ├───────────────────■───────\n",
+       "     └─────────┘                           \n",
+       "c: 3/══════════════════════════════════════\n",
+       "
" + ], + "text/plain": [ + " ┌───┐ ┌───┐ \n", + "q_0: ───┤ H ├─────────────────■──┤ X ├─────\n", + " ├───┤ ┌──────────┐┌─┴─┐└─┬─┘┌───┐\n", + "q_1: ───┤ H ├───┤ Ry(-1.2) ├┤ X ├──┼──┤ H ├\n", + " ┌──┴───┴──┐└──────────┘└───┘ │ └───┘\n", + "q_2: ┤ Rx(0.7) ├───────────────────■───────\n", + " └─────────┘ \n", + "c: 3/══════════════════════════════════════\n", + " " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a45fa6f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exact: [array(-5.9604645e-08, dtype=float32), array(0.3623577, dtype=float32), array(0.76484215, dtype=float32)]\n", + "experiments (mitigated): [0.022390317700453997, 0.3906313645621186, 0.7582969721010189]\n" + ] + } + ], + "source": [ + "# use backend compiling system enabled by qos\n", + "\n", + "nqubit = 3\n", + "shots = 8192\n", + "c = tc.Circuit(nqubit)\n", + "c.h(0)\n", + "c.h(1)\n", + "c.rx(2, theta=0.7)\n", + "c.ry(1, theta=-1.2)\n", + "c.cnot(0, 1)\n", + "c.cnot(2, 0)\n", + "c.h(1)\n", + "\n", + "print(\"exact: \", [np.real(c.expectation_ps(z=[i])) for i in range(nqubit)])\n", + "\n", + "t = apis.submit_task(\n", + " circuit=c,\n", + " shots=shots,\n", + " device=\"9gmon\",\n", + " compiled=False,\n", + " enable_qos_qubit_mapping=True,\n", + " enable_qos_gate_decomposition=True,\n", + ")\n", + "\n", + "ct = t.results(blocked=True)\n", + "\n", + "mit = tc.results.readout_mitigation.ReadoutMit(\"9gmon\")\n", + "mit.cals_from_system(3, method=\"local\")\n", + "\n", + "print(\n", + " \"experiments (mitigated): \",\n", + " [mit.expectation(ct, [i]) for i in range(nqubit)],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cf2d2690", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'frontend': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[3];\\nh q[0];\\nh q[1];\\nrx(0.69999999) q[2];\\nry(-1.2) q[1];\\ncx q[0],q[1];\\ncx q[2],q[0];\\nh q[1];',\n", + " 'backend': {'progs': [{'code': 'Tencent Quantum Program\\nversion 1.0\\nqubit involved: q0,q1,q2,q3,q4,q5,q6,q7,q8\\n# section: eqasm\\n# section lines 33\\neqasm program\\nbs 1 H q0\\nbs 0 H q1\\nbs 0 RZB2 q2\\nbs 1 S q2\\nbs 0 S q1\\nbs 1 H q2\\nbs 0 H q1\\nbs 1 RZB4 q2\\nbs 0 RZB5 q2\\nbs 0 RZB6 q2\\nbs 0 RZB9 q2\\nbs 0 RZB14 q2\\nbs 0 RZB16 q2\\nbs 0 RZB1 q1\\nbs 0 RZB2 q1\\nbs 0 RZB5 q1\\nbs 0 RZB6 q1\\nbs 0 RZB7 q1\\nbs 0 RZB8 q1\\nbs 0 RZB12 q1\\nbs 0 RZB13 q1\\nbs 0 RZB15 q1\\nbs 0 RZB16 q1\\nbs 1 H q2\\nbs 0 H q1\\nbs 1 SD q2\\nbs 0 SD q1\\nbs 1 RZB1 q2\\nbs 0 RZB2 q2\\nbs 0 CX (q0, q1)\\nbs 1 H q1\\nbs 0 CX (q2, q0)\\nMEASZ q0,q1,q2\\n# section: end\\n',\n", + " 'lang': 'QEXE'}]}}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# inspect compiling results from the tc and qos for the task\n", + "\n", + "t.get_compiled_details()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7fee9a15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exact: [array(-5.9604645e-08, dtype=float32), array(0.3623577, dtype=float32), array(0.76484215, dtype=float32)]\n" + ] + } + ], + "source": [ + "# dry run mode to query compiled circuit only from qos (not really sending the circuit to chips)\n", + "\n", + "nqubit = 3\n", + "shots = 8192\n", + "c = tc.Circuit(nqubit)\n", + "c.h(0)\n", + "c.h(1)\n", + "c.rx(2, theta=0.7)\n", + "c.ry(1, theta=-1.2)\n", + "c.cnot(0, 1)\n", + "c.cnot(2, 0)\n", + "c.h(1)\n", + "\n", + "print(\"exact: \", [np.real(c.expectation_ps(z=[i])) for i in range(nqubit)])\n", + "\n", + "t = apis.submit_task(\n", + " circuit=c,\n", + " shots=shots,\n", + " device=\"9gmon\",\n", + " compiled=True,\n", + " enable_qos_qubit_mapping=True,\n", + " enable_qos_gate_decomposition=True,\n", + " qos_dry_run=True\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e262a682", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'frontend': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[3];\\nh q[0];\\nh q[1];\\nrz(-pi/2) q[1];\\nh q[1];\\nrz(-1.2) q[1];\\nh q[1];\\nrz(5*pi/2) q[1];\\ncx q[0],q[1];\\nh q[1];\\nh q[2];\\nrz(0.69999999) q[2];\\nh q[2];\\ncx q[2],q[0];',\n", + " 'backend': {'progs': [{'code': 'Tencent Quantum Program\\nversion 1.0\\nqubit involved: q0,q1,q2,q3,q4,q5,q6,q7,q8\\n# section: eqasm\\n# section lines 10\\neqasm program\\nbs 1 H q0\\nbs 0 H q1\\nbs 0 H q2\\nbs 1 H q1\\nbs 0 H q2\\nbs 1 H q1\\nbs 1 CX (q0, q1)\\nbs 1 H q1\\nbs 0 CX (q2, q0)\\nMEASZ q0,q1,q2\\n# section: end\\n',\n", + " 'lang': 'QEXE'}]}}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.get_compiled_details()" + ] + }, + { + "cell_type": "markdown", + "id": "ea015c48", + "metadata": {}, + "source": [ + "## scalable readout simulation and mitigation\n", + "\n", + "Via TensorCircuit, we provide the capability to do scalable (20+ qubits) readout error simulation and mitigation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2b509155", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'000': 7725, '001': 261, '100': 164, '010': 33, '101': 9}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# scalable readout error simulation on tQuK with tensorcircuit backend using tensor network approach\n", + "\n", + "c = tc.Circuit(3)\n", + "t = apis.submit_task(circuit=c, device=\"simulator:tcn1\", shots=8192)\n", + "t.results(blocked=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "71f634ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'000': 8192.0}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.results(mitigated=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7533330d", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "c = tc.Circuit(25)\n", + "t = apis.submit_task(circuit=c, device=\"simulator:tcn1\", shots=8192)\n", + "t.results(blocked=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "cdfb639c", + "metadata": {}, + "outputs": [], + "source": [ + "# batch submission to the simulator\n", + "cs = []\n", + "for i in range(15):\n", + " c = tc.Circuit(15)\n", + " c.x(i)\n", + " cs.append(c)\n", + "ts = apis.submit_task(circuit=cs, device=\"simulator:tcn1\", shots=8192)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f8d8217e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'100000000000000': 8419.697440088592,\n", + " '100100000000000': 70.62067781260015,\n", + " '100000100000000': 32.06999431920804,\n", + " '100000000000010': 21.05429511303664,\n", + " '100000000100100': 12.737459534668831,\n", + " '100000000010000': 6.717028675136155,\n", + " '100000100000001': 5.517504244766566,\n", + " '101000000000000': 5.343221628567916,\n", + " '100000000000100': 5.316502711797031,\n", + " '100101000000000': 5.055791656340502,\n", + " '100000000100000': 4.583753814772621,\n", + " '100000001010000': 4.563675472853387,\n", + " '100100001000000': 4.200871093607515,\n", + " '100000001000001': 4.037583611576253,\n", + " '100000000100001': 3.993740071242359,\n", + " '100000100000100': 3.620123993770483,\n", + " '100100000000001': 3.331528047004301,\n", + " '100000000000101': 2.9602206346214883,\n", + " '110000000000100': 2.4447297020449055,\n", + " '100100000000100': 2.1864507226578893,\n", + " '100000101100000': 2.0581439661798693,\n", + " '100000000000110': 1.6273556338878277,\n", + " '110000001000000': 1.6165778033772777,\n", + " '101000100000000': 1.5943040213903492,\n", + " '100000100100000': 1.5109801589828913,\n", + " '110001000000000': 1.4878748649195706,\n", + " '101000000000001': 1.4554025461864313,\n", + " '100000100010000': 1.4387429080263332,\n", + " '100001001000000': 1.3911841049012317,\n", + " '100000000110000': 1.27595864225905,\n", + " '100001100000000': 1.1203274457975498,\n", + " '100100000100010': 1.078941729230564,\n", + " '100001100000010': 1.058872714188839,\n", + " '110000000110000': 1.0071832705686932,\n", + " '101100000001001': 0.9802634521345814,\n", + " '100010000001000': 0.9411197364818454,\n", + " '000000000100000': 0.9316389155910612,\n", + " '101000001100000': 0.9175529942539858,\n", + " '100011000000000': 0.9077887012464176,\n", + " '100001000001100': 0.9014187801746705,\n", + " '101000000000101': 0.8934662599445671,\n", + " '000000000000100': 0.8930840706602694,\n", + " '110000000100100': 0.8821880862632059,\n", + " '101001000001000': 0.8781652435907243,\n", + " '101100000001000': 0.8724239475595535,\n", + " '100010000000100': 0.8345195977528056,\n", + " '101100100000000': 0.8319641116304223,\n", + " '100010100000000': 0.8218914654493159,\n", + " '000001000000000': 0.8049948545166198,\n", + " '101010000000000': 0.8000672364423292,\n", + " '101001001000000': 0.7969743025592275,\n", + " '100001000100000': 0.7956137409639294,\n", + " '001000000000000': 0.789606059795129,\n", + " '100100100000001': 0.7884318597525475,\n", + " '100101000001000': 0.7415010114429998,\n", + " '101001000100000': 0.6919729246648194,\n", + " '100000000010001': 0.6798365988865034,\n", + " '100001000000100': 0.6746774495099936,\n", + " '100000001001000': 0.6656234863552265,\n", + " '100000010001000': 0.6621556388191783,\n", + " '100000001100100': 0.6345752195408909,\n", + " '110000000001000': 0.6076581375075842,\n", + " '100000010100000': 0.4745304454976847,\n", + " '101000000100100': 0.44415633504428315,\n", + " '101000000000010': 0.3724845125075598,\n", + " '110000000100000': 0.25702564175016074,\n", + " '100001000010000': 0.254962007546872,\n", + " '101100000000000': 0.25345181627314156,\n", + " '111000000000000': 0.20808484786196516,\n", + " '100000000010100': 0.1832565235759075,\n", + " '101000000010000': 0.09102957852547792,\n", + " '100100000100000': 0.04365953380230936,\n", + " '100100000000010': -0.027541754030945935,\n", + " '100100000001000': -0.028714529367154015,\n", + " '100000000001010': -0.09047987962965393,\n", + " '100000100000010': -0.214103726888365,\n", + " '101001000000000': -0.3152465552779923,\n", + " '000100000000000': -0.3989564181995144,\n", + " '101000000100000': -0.4118194835787859,\n", + " '100001000000010': -0.47025162263150116,\n", + " '100000000100010': -0.5690654957937074,\n", + " '000000100000000': -0.6191879565167421,\n", + " '100001000000001': -0.695357972540988,\n", + " '100100100000000': -0.7175884771016332,\n", + " '100001000001000': -0.7630782732138829,\n", + " '100000000001001': -1.008694690776709,\n", + " '101000000001000': -1.2504938465007915,\n", + " '101000001000000': -1.4343739078734263,\n", + " '100000000001100': -1.6129859188764608,\n", + " '100000101000000': -1.7145196696995655,\n", + " '100000001100000': -1.9094346951735794,\n", + " '100000001000100': -2.878659473184994,\n", + " '100000000101000': -3.5969775749822315,\n", + " '100000100001000': -4.660489024999659,\n", + " '100000010000000': -7.228177465795695,\n", + " '101000000000100': -7.433443342353611,\n", + " '100010000000000': -18.713786232606235,\n", + " '110000000000000': -26.25306538585136,\n", + " '100000001000000': -27.852335007043337,\n", + " '100001000000000': -29.805593058690288,\n", + " '100000000001000': -30.14314633475033,\n", + " '100000000000001': -70.20285091373152,\n", + " '000000000000000': -229.9578391969697}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# mitigated with m3 scalable on count dict\n", + "c = tc.Circuit(15)\n", + "c.x(0)\n", + "t = apis.submit_task(circuit=c, device=\"simulator:tcn1\", shots=8192)\n", + "\n", + "mit = tc.results.readout_mitigation.ReadoutMit(\"simulator:tcn1\")\n", + "mit.cals_from_system(15)\n", + "\n", + "raw_count = t.results(blocked=True)\n", + "mit.apply_correction(raw_count, 15, method=\"M3_auto\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "292f9b11", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.9987468671679187" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# mitigated with m3 scalable directly on expectation: not a wrapper for count but a new algorithm!\n", + "# see eq 6 in https://arxiv.org/pdf/2006.14044.pdf\n", + "\n", + "mit.expectation(raw_count, [0])" + ] + }, + { + "cell_type": "markdown", + "id": "bd454737", + "metadata": {}, + "source": [ + "## list task and get previous task\n", + "\n", + "get history tasks" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2b80411b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[tencent::9gmon?o=1~~0793030c-a3d0-426f-bf2c-0cb8ec4ad0b0,\n", + " tencent::simulator:tcn1?o=3~~fdde7cb9-1738-4b82-becf-5add3bebdcc0,\n", + " tencent::simulator:tcn1?o=3~~949ba88c-ba4f-44e1-b03b-e35873cc429e,\n", + " tencent::simulator:tcn1?o=3~~a434a0d2-9d7e-46ff-ae42-e8397dd09cea,\n", + " tencent::simulator:tcn1?o=3~~6462e2eb-cfb4-407a-bf93-12afe70ed73e,\n", + " tencent::simulator:tcn1?o=3~~44bc1bba-628f-4739-9cf5-cc612059b635,\n", + " tencent::simulator:tcn1?o=3~~67f33828-357e-49e8-a8f8-6ded2a16b5d3,\n", + " tencent::simulator:tcn1?o=3~~e0e6660b-306d-494c-902b-630d656bc64d,\n", + " tencent::simulator:tcn1?o=3~~13ac4aea-e6b7-469d-a67f-ad28a9dc16a0,\n", + " tencent::simulator:tcn1?o=3~~dc53b3bf-48c5-43ee-a42c-8b140c14080d,\n", + " tencent::simulator:tcn1?o=3~~53a949b9-a763-4cce-b11d-1d83b65095b3,\n", + " tencent::simulator:tcn1?o=3~~7fdb1e4c-801a-4236-8ec8-be61101ff499,\n", + " tencent::simulator:tcn1?o=3~~e7819297-e989-4620-840a-b15a6f988a1a,\n", + " tencent::simulator:tcn1?o=3~~29ca9ff7-1063-4477-b827-e2e11613ef46,\n", + " tencent::simulator:tcn1?o=3~~aa05e4e2-72fb-4b0b-969e-56c65cd7e4cc,\n", + " tencent::simulator:tcn1?o=3~~5f006fe4-1a1f-47ab-b12d-34c6ed4d9040,\n", + " tencent::simulator:tcn1?o=3~~7bea264d-e714-45d7-8893-3310b73ab168,\n", + " tencent::simulator:tcn1?o=3~~48dbd262-aaab-48e2-96de-fd6396a24284,\n", + " tencent::simulator:tcn1?o=3~~054b7901-6b36-44e6-9f71-c9a360e7b4a4,\n", + " tencent::simulator:tcn1?o=3~~fcf97cbd-ff78-4a0e-8cfe-aa11309dba99,\n", + " tencent::simulator:tcn1?o=3~~bd4c8937-e3dd-4f84-ab6f-20dc33096aea,\n", + " tencent::simulator:tcn1?o=3~~b4900bf6-ef83-46bd-8735-e941679b88fc,\n", + " tencent::simulator:tcn1?o=3~~b093b1cd-ff4b-42b9-9db7-b0983dc0e503,\n", + " tencent::simulator:tcn1?o=3~~3d151c82-e441-4b13-aebd-57cd896f1577,\n", + " tencent::simulator:tcn1?o=3~~6e38b4b3-eddb-414b-afd8-ae45a48966bd,\n", + " tencent::simulator:tcn1?o=3~~987b17fd-79d6-4099-9601-d26d42a29d14,\n", + " tencent::simulator:tcn1?o=3~~20485921-564a-45b1-9e07-276048b29de9,\n", + " tencent::simulator:tcn1?o=3~~59b3cd63-0126-4f8d-a4e8-1b8e6994a3ed,\n", + " tencent::simulator:tcn1?o=3~~136cdf82-081f-4b90-8f2e-00dcfea4e08d,\n", + " tencent::simulator:tcn1?o=3~~70549fd3-67aa-4e42-b474-b29b313e8278,\n", + " tencent::simulator:tcn1?o=3~~2da1a4bc-81a6-4f6d-82a0-60cebd5f6e0f,\n", + " tencent::simulator:tcn1?o=3~~81a6884d-c4ad-423c-ae2d-9799f56d550b,\n", + " tencent::simulator:tcn1?o=3~~8253dba0-9cf6-46e1-8eaa-63d04cbdf7ec,\n", + " tencent::simulator:tcn1?o=3~~dde2431f-6815-436b-ac16-a80050a1e27a,\n", + " tencent::simulator:tcn1?o=3~~442d8839-25c4-4f26-8d53-1f723941ce7a,\n", + " tencent::simulator:tcn1?o=3~~546090a9-31d5-441a-bc6a-ed5e12c3f9ad,\n", + " tencent::simulator:tcn1?o=3~~227ae13c-04a0-41e0-a0aa-1c8ea77c0b7a,\n", + " tencent::simulator:tcn1?o=3~~dc1b5b60-6ccd-4ca5-96e3-458e41ad8ca9,\n", + " tencent::simulator:tcn1?o=3~~d5712b1c-0988-4f3f-8347-56b91492b4dc,\n", + " tencent::simulator:tcn1?o=3~~0bbb4222-117c-47cc-be50-b0dbbee22ee2,\n", + " tencent::simulator:tcn1?o=3~~a5a87e9a-8990-4ed9-86bc-066b6a4f5a1d,\n", + " tencent::simulator:tcn1?o=3~~8589e1f2-8e35-467a-b45b-810ff5d5281a,\n", + " tencent::simulator:tcn1?o=3~~d1d2dcd0-e6d5-4dd4-be97-ec3e7fc808b5,\n", + " tencent::simulator:tcn1?o=3~~cd68b30a-3319-45ed-9931-af4b41e7af09,\n", + " tencent::simulator:tcn1?o=3~~b1d450cb-ebfc-478d-9c4f-0d6b0ef7418d,\n", + " tencent::simulator:tcn1?o=3~~dc48ba37-2760-4da2-b348-b6c1190c2ca2,\n", + " tencent::simulator:tcn1?o=3~~ee45ae23-3b99-4507-8110-f6eeece30eaf,\n", + " tencent::simulator:tcn1?o=3~~bcc806e5-a021-44f8-83ce-aba9d054cf75,\n", + " tencent::9gmon?o=0~~5d2d8e11-760e-4f88-b003-5b5901edbf21,\n", + " tencent::9gmon?o=0~~8e3a77f7-838e-4d08-a75a-b864704b89e3]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "apis.list_tasks()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8dffbcfd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[tencent::9gmon?o=1~~0793030c-a3d0-426f-bf2c-0cb8ec4ad0b0,\n", + " tencent::9gmon?o=0~~5d2d8e11-760e-4f88-b003-5b5901edbf21,\n", + " tencent::9gmon?o=0~~8e3a77f7-838e-4d08-a75a-b864704b89e3,\n", + " tencent::9gmon?o=0~~e3c137fc-e478-48f6-bc89-c077c1a3cd9e,\n", + " tencent::9gmon?o=0~~7a251212-f21d-46f1-976d-9a5ba066bb40,\n", + " tencent::9gmon?o=0~~6445a6bf-9cf8-4b7d-af6f-aeeb5f4989ef,\n", + " tencent::9gmon?o=0~~91be022d-afd5-414e-8776-88acb6f1d3dd,\n", + " tencent::9gmon?o=0~~f962fbd8-dffc-4369-b2e6-696c3db561ed,\n", + " tencent::9gmon?o=0~~26dc60ad-f9c1-4d82-bd87-266c8520bd90,\n", + " tencent::9gmon?o=0~~d841bb5b-5549-488c-b660-47f59e129a7b,\n", + " tencent::9gmon?o=2~~315fb708-c9da-4a53-b2ac-c206e563620b,\n", + " tencent::9gmon?o=0~~198b0d28-1c9b-400c-aecc-af926d789c1e,\n", + " tencent::9gmon~~27562978-1588-4314-8517-782fd7b27265,\n", + " tencent::9gmon~~bcc06a7a-350d-4b6a-b536-829eca1cf07f,\n", + " tencent::9gmon~~b0a0c0ab-d902-457c-97c8-0a731d0982d8,\n", + " tencent::9gmon~~c64a78d3-54c8-40f1-b64f-f7027890368b,\n", + " tencent::9gmon?o=3~~ebceb01d-9902-4879-b4c1-be39c2dd0053,\n", + " tencent::9gmon?o=2&dry~~45101e92-70aa-49f0-805b-f5187b6da72f,\n", + " tencent::9gmon?o=3~~135fc458-54f1-4f7f-bcc2-4922682e25cd,\n", + " tencent::9gmon?o=3~~9f510558-1151-49e8-8f21-e9a8b344cdf6,\n", + " tencent::9gmon~~98574130-e4ee-4b16-afe7-ec09a245cf86,\n", + " tencent::9gmon~~0e76f4da-ec80-47c7-9d16-bd837afc6905,\n", + " tencent::9gmon~~a2b185d4-9684-4d2e-8bb5-ec5087ddd882,\n", + " tencent::9gmon~~787a9b09-6c62-40b6-a9e6-f172d73ea300,\n", + " tencent::9gmon~~e621f4f7-9f83-4dd5-ae8e-43ba336a3c86,\n", + " tencent::9gmon~~638246cf-f642-4cab-9959-8f007e45bfd3,\n", + " tencent::9gmon~~d341e961-b05e-465a-82bf-fb85b4614a6a,\n", + " tencent::9gmon~~45fa081f-9834-4d53-a72e-9bec73d02a6d,\n", + " tencent::9gmon~~62bca49a-ecee-43fe-a27e-76d48021f66a,\n", + " tencent::9gmon~~91cb4589-d840-492d-bad1-800517cc80a4,\n", + " tencent::9gmon~~0d7c82d6-b71b-442e-a7a2-923452daf279,\n", + " tencent::9gmon~~5453692b-1a5f-4a3e-9689-a407d5bd787c,\n", + " tencent::9gmon~~4ab5e201-0784-476e-b23b-551fbac1772a,\n", + " tencent::9gmon~~9fd46395-3bed-49b1-a262-4afc49bb545a,\n", + " tencent::9gmon~~a458a62d-f270-4921-a0dd-9cf8b57e4581,\n", + " tencent::9gmon~~f5bfd675-afbc-4e92-ac06-dd1f780bf0e2,\n", + " tencent::9gmon~~4c483a0d-0aa4-49b5-803b-f0cacf5d5c50,\n", + " tencent::9gmon~~f5ff62ae-df69-46fd-806d-b294ac8cfb90,\n", + " tencent::9gmon~~dbb9dc21-ffed-4004-a755-76f183ade2a8,\n", + " tencent::9gmon~~ea84339e-2c6a-46f6-b3c9-6f422df68d87,\n", + " tencent::9gmon~~cb2531bf-e730-46b7-ab3a-11ece77303f8,\n", + " tencent::9gmon?o=3&dry~~a0186d54-c93a-4abf-b81f-c5b69bef733c,\n", + " tencent::9gmon?o=1&dry~~d990b42e-6c15-488c-8524-96a9fef48316,\n", + " tencent::9gmon?o=1~~06764d75-a365-4d6e-a1b3-40eacc84f527,\n", + " tencent::9gmon?o=1~~d12859da-ac27-4990-9217-5f7b582928fc,\n", + " tencent::9gmon?o=1~~d437ebbc-9f4b-44df-a07c-70ebdca9bfbc,\n", + " tencent::9gmon?o=1~~234e6a65-59ab-4736-9e89-6aba5a8cce6a,\n", + " tencent::9gmon?o=1~~f532daa7-f9af-4311-befa-910589cd7826,\n", + " tencent::9gmon?o=1~~ffbb1a37-632c-4b2c-a2d6-faa59b1f6c6b,\n", + " tencent::9gmon?o=1~~c1e99c59-1aca-4487-a7d1-96cb878feabf]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "apis.list_tasks(device=\"9gmon\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5e29190d", + "metadata": {}, + "outputs": [], + "source": [ + "t = apis.get_task(\"d77bec2f-ab07-4dbc-a273-caa8b23a921c\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d24ddc18", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'id': 'd77bec2f-ab07-4dbc-a273-caa8b23a921c',\n", + " 'queue': 'txqlab',\n", + " 'device': '9gmon',\n", + " 'state': 'completed',\n", + " 'shots': 4096,\n", + " 'at': 1670549560020389,\n", + " 'ts': {'completed': 1670549560020389,\n", + " 'pending': 1670549557999879,\n", + " 'scheduled': 1670549557997345},\n", + " 'md5': '4a2e4269b3a3e78e0f6509ba78d9bdd8',\n", + " 'runAt': 1670549557,\n", + " 'runDur': 2000,\n", + " 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[3];\\nh q[0];\\nrz(-pi/2) q[1];\\nh q[1];\\ncx q[0],q[1];\\nrz(-1.4) q[1];\\ncx q[0],q[1];\\nrz(-1.4) q[1];\\nh q[1];\\nrz(5*pi/2) q[1];\\nh q[1];\\nrz(-pi/2) q[2];\\nh q[2];\\ncx q[0],q[2];\\nrz(1.4) q[2];\\ncx q[0],q[2];\\nrz(-1.4) q[2];\\nh q[2];\\nrz(5*pi/2) q[2];\\nh q[2];',\n", + " 'version': '1',\n", + " 'lang': 'OPENQASM',\n", + " 'prior': 1,\n", + " 'result': {'000': 492,\n", + " '001': 599,\n", + " '010': 589,\n", + " '011': 685,\n", + " '100': 255,\n", + " '101': 518,\n", + " '110': 363,\n", + " '111': 595},\n", + " 'optimization': {},\n", + " 'results': {'000': 492,\n", + " '001': 599,\n", + " '010': 589,\n", + " '011': 685,\n", + " '100': 255,\n", + " '101': 518,\n", + " '110': 363,\n", + " '111': 595}}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.details()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "706c9c08", + "metadata": {}, + "outputs": [], + "source": [ + "t = apis.get_task(\"tencent::9gmon~~e32bb488-5ee9-4b07-8217-1e78ceb4bde3\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8ad61cb9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'id': 'e32bb488-5ee9-4b07-8217-1e78ceb4bde3',\n", + " 'queue': 'txq.low',\n", + " 'device': '9gmon',\n", + " 'state': 'completed',\n", + " 'shots': 8192,\n", + " 'at': 1671158467283362,\n", + " 'ts': {'completed': 1671158467283362,\n", + " 'pending': 1671158406209032,\n", + " 'scheduled': 1671158406206228},\n", + " 'md5': 'e2b1202e83341de33b19b9acce1e795d',\n", + " 'runAt': 1671158405,\n", + " 'runDur': 61000,\n", + " 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[3];\\nx q[0];\\nx q[1];\\nx q[2];',\n", + " 'version': '1',\n", + " 'lang': 'OPENQASM',\n", + " 'prior': 1,\n", + " 'result': {'000': 8,\n", + " '001': 39,\n", + " '010': 28,\n", + " '011': 367,\n", + " '100': 41,\n", + " '101': 493,\n", + " '110': 530,\n", + " '111': 6686},\n", + " 'optimization': {},\n", + " 'results': {'000': 8,\n", + " '001': 39,\n", + " '010': 28,\n", + " '011': 367,\n", + " '100': 41,\n", + " '101': 493,\n", + " '110': 530,\n", + " '111': 6686}}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.details()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06dc69f2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 78f6d1183071d6bbd1336801edca4734eafd5f76 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 1 Jan 2023 12:53:48 +0800 Subject: [PATCH 142/725] prettify task details --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 9 +++------ tensorcircuit/cloud/abstraction.py | 19 ++----------------- tensorcircuit/cloud/apis.py | 9 ++++++--- tensorcircuit/cloud/local.py | 4 +++- tensorcircuit/cloud/tencent.py | 22 ++++++++++++++++++++-- 5 files changed, 34 insertions(+), 29 deletions(-) diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb index 88297b2f..da9ae336 100644 --- a/docs/source/tutorials/tc_qcloud_sdk.ipynb +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -682,9 +682,7 @@ "qc.measure(2, 2)\n", "qc.measure(6, 6)\n", "\n", - "t = apis.submit_task(\n", - " circuit=qc, shots=shots, device=\"9gmon?o=0\"\n", - ")\n", + "t = apis.submit_task(circuit=qc, shots=shots, device=\"9gmon?o=0\")\n", "print(t.results(blocked=True))" ] }, @@ -948,9 +946,8 @@ " compiled=True,\n", " enable_qos_qubit_mapping=True,\n", " enable_qos_gate_decomposition=True,\n", - " qos_dry_run=True\n", - ")\n", - "\n" + " qos_dry_run=True,\n", + ")" ] }, { diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index aa3169d1..b18fc2b5 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -223,7 +223,7 @@ def get_device(self) -> Device: else: return Device.from_name(self.device) - def details(self) -> Dict[str, Any]: + def details(self, **kws: Any) -> Dict[str, Any]: """ Get the current task details @@ -232,7 +232,7 @@ def details(self) -> Dict[str, Any]: """ from .apis import get_task_details - return get_task_details(self) + return get_task_details(self, **kws) def state(self) -> str: """ @@ -344,18 +344,3 @@ def run(cs: Any, shots: Any) -> Any: r, list(range(nqubit)), **mitigation_options ) return counts.sort_count(miti_count) - - def get_compiled_details(self) -> Any: - """ - Experimental, the compiled artifact format is not guaranteed - - :return: [description] - :rtype: Any - """ - results = {} - d = self.details() - if "source" in d: - results["frontend"] = d["source"] - if "optimization" in d and d["state"] == "completed": - results["backend"] = d["optimization"] - return results diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index bf4d5cf0..e8b03bcf 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -327,7 +327,7 @@ def get_task( def get_task_details( - taskid: Union[str, Task], token: Optional[str] = None + taskid: Union[str, Task], token: Optional[str] = None, prettify: bool = False ) -> Dict[str, Any]: """ Get task details dict given task id @@ -336,6 +336,9 @@ def get_task_details( :type taskid: Union[str, Task] :param token: _description_, defaults to None :type token: Optional[str], optional + :param prettify: whether make the returned dict more readable and more phythonic, + defaults to False + :type prettify: bool :return: _description_ :rtype: Dict[str, Any] """ @@ -352,9 +355,9 @@ def get_task_details( provider = device.provider if provider.name == "tencent": - return tencent.get_task_details(task, device, token) # type: ignore + return tencent.get_task_details(task, device, token, prettify) # type: ignore elif provider.name == "local": - return local.get_task_details(task, device, token) # type: ignore + return local.get_task_details(task, device, token, prettify) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/local.py b/tensorcircuit/cloud/local.py index 53e4e20d..959a9493 100644 --- a/tensorcircuit/cloud/local.py +++ b/tensorcircuit/cloud/local.py @@ -22,7 +22,9 @@ def list_devices(token: Optional[str] = None) -> List[Device]: return rs -def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: +def get_task_details( + task: Task, device: Device, token: str, prettify: bool +) -> Dict[str, Any]: if task.id_ in task_list: return task_list[task.id_] # type: ignore raise ValueError("no task with id: %s" % task.id_) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index f30e5e79..97c9dc9e 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -3,6 +3,7 @@ """ from typing import Any, Dict, List, Optional, Sequence, Union +from datetime import datetime from json import dumps import logging from functools import partial @@ -13,6 +14,8 @@ from .abstraction import Device, sep, Task from ..abstractcircuit import AbstractCircuit from ..utils import is_sequence, arg_alias +from ..circuit import Circuit +from ..translation import eqasm2tc logger = logging.getLogger(__name__) @@ -288,7 +291,9 @@ def list_tasks(device: Device, token: str, **filter_kws: Any) -> List[Task]: raise ValueError(dumps(r)) -def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: +def get_task_details( + task: Task, device: Device, token: str, prettify: bool +) -> Dict[str, Any]: json = {"id": task.id_} r = rpost_json( tencent_base_url + "task/detail", json=json, headers=tencent_headers(token) @@ -300,7 +305,20 @@ def get_task_details(task: Task, device: Device, token: str) -> Dict[str, Any]: r["task"]["results"] = r["task"]["result"]["counts"] else: r["task"]["results"] = r["task"]["result"] - return r["task"] # type: ignore + if prettify is False: + return r["task"] # type: ignore + # make the results more readable + r = r["task"] + if "at" in r: + r["at"] = datetime.fromtimestamp(r["at"] / 1e6) + if "ts" in r: + for k in r["ts"]: + r["ts"][k] = datetime.fromtimestamp(r["ts"][k] / 1e6) + if "source" in r: + r["frontend"] = Circuit.from_openqasm(r["source"]) + if "optimization" in r and r["state"] == "completed": + r["backend"] = eqasm2tc(r["optimization"]["progs"][0]["code"]) + return r # type: ignore except KeyError: raise ValueError(dumps(r)) From 94c0656570e5a8babcaf4d91768ae42e7b578cf0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 1 Jan 2023 12:54:10 +0800 Subject: [PATCH 143/725] add eqasm translation --- tensorcircuit/translation.py | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index fa4d0b4e..336235e8 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -2,7 +2,7 @@ Circuit object translation in different packages """ -from typing import Any, Dict, List, Optional +from typing import Any, Dict, List, Optional, Tuple from copy import deepcopy import logging import numpy as np @@ -463,3 +463,32 @@ def json2qir(tcqasm: List[Dict[str, Any]]) -> List[Dict[str, Any]]: } ) return qir + + +def eqasm2tc( + eqasm: str, nqubits: Optional[int] = None, headers: Tuple[int, int] = (6, 1) +) -> Circuit: + eqasm_list = eqasm.split("\n") + if nqubits is None: + nqubits = len(eqasm_list[2].split(",")) + eqasm_list = eqasm_list[headers[0] : -headers[1]] + c = Circuit(nqubits) + # measure z not considered + for inst in eqasm_list: + if inst.startswith("bs"): + inst_list = inst.split(" ") + if inst_list[2].startswith("RZ"): + exponent = int(inst_list[2][3:]) + index = (int(inst_list[3][1:]),) + c.rz(*index, theta=2 * np.pi / 2**exponent) # type: ignore + else: + gate_name = inst_list[2].lower() + if len(inst_list) == 4: + index = (int(inst_list[3][1:]),) + elif len(inst_list) == 5: + index = (int(inst_list[3][2:-1]), int(inst_list[4][1:-1])) # type: ignore + else: + raise ValueError("Unknown format for eqasm: %s" % str(inst_list)) + getattr(c, gate_name)(*index) + + return c From c901c842390fe5bc26e2f8039f8aa9d65e046cf0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 1 Jan 2023 17:02:53 +0800 Subject: [PATCH 144/725] add rz in native gate set --- tensorcircuit/cloud/tencent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 97c9dc9e..65b9beb0 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -143,7 +143,7 @@ def submit_task( if source is None: if compiled_options is None: compiled_options = { - "basis_gates": ["h", "rz", "x", "y", "z", "cx"], + "basis_gates": ["h", "rz", "x", "y", "z", "cx", "cz"], "optimization_level": 2, } From 0e661bebaeacc2c9f890bd48e6858a320ff78bbf Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 3 Jan 2023 22:10:15 +0800 Subject: [PATCH 145/725] fix vjp bug on tf backend; add more interface docs --- CHANGELOG.md | 2 + docs/source/infras.rst | 6 ++ docs/source/quickstart.rst | 76 +++++++++++++++++++- tensorcircuit/backends/tensorflow_backend.py | 5 ++ tensorcircuit/interfaces/tensorflow.py | 2 +- tensorcircuit/interfaces/tensortrans.py | 2 + tensorcircuit/results/__init__.py | 2 + tests/test_torchnn.py | 12 ++-- 8 files changed, 99 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ae4deec0..2763847e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,8 @@ - Ignore ComplexWarning for ``cast`` method on numpy and jax backend +- Fix `vjp` method bug on tensorflow backend, where none is replaced with zeros + ## 0.6.0 ### Added diff --git a/docs/source/infras.rst b/docs/source/infras.rst index 1727b3cf..fb65098a 100644 --- a/docs/source/infras.rst +++ b/docs/source/infras.rst @@ -28,6 +28,8 @@ Overview of Modules - :py:mod:`tensorcircuit.densitymatrix`: Referenced and highly efficient implementation of ``tc.DMCircuit`` class, with similar set API of ``tc.Circuit`` while simulating the noise in the full form of the density matrix. +- :py:mod:`tensorcircuit.noisemodel`: The global noise configuration and circuit noisy method APIs + **ML Interfaces Related Modules:** - :py:mod:`tensorcircuit.interfaces`: Provide interfaces when quantum simulation backend is different from neural libraries. Currently include PyTorch and scipy optimizer interfaces. @@ -58,6 +60,10 @@ Overview of Modules - :py:mod:`tensorcircuit.translation`: Translate circuit object to circuit object in other quantum packages. +**Processing and error mitigation on sample results:** + +- :py:mod:`tensorcircuit.results`: Provide tools to process count dict and to apply error mitigation + **Shortcuts and Templates for Circuit Manipulation:** - :py:mod:`tensorcircuit.templates`: provide handy shortcuts functions for expectation or circuit building patterns. diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 00b5084b..adac2bf4 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -262,9 +262,12 @@ and the other part is implemented in `TensorCircuit package `__. + +We also provider wrapper of quantum function for torch module as :py:meth:`tensorcircuit.TorchLayer` alias to :py:meth:`tensorcircuit.torchnn.QuantumNet`. + +For ``TorchLayer``, ``use_interface=True`` is by default, which natively allow the quantum function defined on other tensorcircuit backends, such as jax or tf for speed consideration. + +``TorchLayer`` can process multiple input arguments as multiple function inputs, following torch practice. + +.. code-block:: python + + n = 3 + p = 0.1 + K = tc.backend + torchb = tc.get_backend("pytorch") + + def f(state, noise, weights): + c = tc.Circuit(n, inputs=state) + for i in range(n): + c.rz(i, theta=weights[i]) + for i in range(n): + c.depolarizing(i, px=p, py=p, pz=p, status=noise[i]) + return K.real(c.expectation_ps(x=[0])) + + layer = tc.TorchLayer(f, [n], use_vmap=True, vectorized_argnums=[0, 1]) + state = torchb.ones([2, 2**n]) / 2 ** (n / 2) + noise = 0.2 * torchb.ones([2, n], dtype="float32") + l = layer(state,noise) + lsum = torchb.sum(l) + print(l) + lsum.backward() + for p in layer.parameters(): + print(p.grad) + + +**TensorFlow interfaces:** + +Similar rules apply similar as torch interface. The interface can even be used within jit environment outside. +See :py:meth:`tensorcircuit.interfaces.tensorflow.tensorflow_interface`. + +We also provider ``enable_dlpack=True`` option in torch and tf interfaces, which allow the tensor transformation happen without memory transfer via dlpack, +higher version of tf or torch package required. + +We also provider wrapper of quantum function for keras layer as :py:meth:`tensorcircuit.KerasLayer` alias to :py:meth:`tensorcircuit.keras.KerasLayer`. + +``KerasLayer`` can process multiple input arguments with the input as a dict, following the common keras practice, see example below. + +.. code-block:: python + + def f(inputs, weights): + state = inputs["state"] + noise = inputs["noise"] + c = tc.Circuit(n, inputs=state) + for i in range(n): + c.rz(i, theta=weights[i]) + for i in range(n): + c.depolarizing(i, px=p, py=p, pz=p, status=noise[i]) + return K.real(c.expectation_ps(x=[0])) + + layer = tc.KerasLayer(f, [n]) + v = {"state": K.ones([1, 2**n]) / 2 ** (n / 2), "noise": 0.2 * K.ones([1, n])} + with tf.GradientTape() as tape: + l = layer(v) + grad = tape.gradient(l, layer.trainable_variables) + + **Scipy Interface to Utilize Scipy Optimizers:** diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 34191fe3..dbee893c 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -692,6 +692,11 @@ def vjp( t.watch(inputs) y = f(*inputs) g = t.gradient(y, inputs, v) + g = list(g) + for i, gi in enumerate(g): + if gi is None: + g[i] = tf.zeros_like(inputs[i]) + g = tuple(g) if one_input: g = g[0] return y, g diff --git a/tensorcircuit/interfaces/tensorflow.py b/tensorcircuit/interfaces/tensorflow.py index d2a274d4..7166e4e7 100644 --- a/tensorcircuit/interfaces/tensorflow.py +++ b/tensorcircuit/interfaces/tensorflow.py @@ -58,7 +58,7 @@ def f(params): f = tc.interfaces.tf_interface(f, ydtype=tf.float32, jit=True) tfb = tc.get_backend("tensorflow") - grads = tfb.jit(tfb.grad(f))(tc.get_backend("tensorflow").ones([2])) + grads = tfb.jit(tfb.grad(f))(tfb.ones([2])) :param fun: The quantum function with tensor in and tensor out :type fun: Callable[..., Any] diff --git a/tensorcircuit/interfaces/tensortrans.py b/tensorcircuit/interfaces/tensortrans.py index c91588e8..704ae8a3 100644 --- a/tensorcircuit/interfaces/tensortrans.py +++ b/tensorcircuit/interfaces/tensortrans.py @@ -44,6 +44,8 @@ def which_backend(a: Tensor, return_backend: bool = True) -> Any: def tensor_to_numpy(t: Tensor) -> Array: if isinstance(t, int) or isinstance(t, float): return t + if t is None: + return return which_backend(t).numpy(t) diff --git a/tensorcircuit/results/__init__.py b/tensorcircuit/results/__init__.py index 523c5ad6..7a953ae9 100644 --- a/tensorcircuit/results/__init__.py +++ b/tensorcircuit/results/__init__.py @@ -1,2 +1,4 @@ from . import counts from . import readout_mitigation + +rem = readout_mitigation # alias diff --git a/tests/test_torchnn.py b/tests/test_torchnn.py index 93432c3a..6e85eedc 100644 --- a/tests/test_torchnn.py +++ b/tests/test_torchnn.py @@ -56,6 +56,7 @@ def test_inputs_multiple(backend): n = 3 p = 0.1 K = tc.backend + torchb = tc.get_backend("pytorch") def f(state, noise, weights): c = tc.Circuit(n, inputs=state) @@ -66,8 +67,11 @@ def f(state, noise, weights): return K.real(c.expectation_ps(x=[0])) layer = tc.TorchLayer(f, [n], use_vmap=True, vectorized_argnums=[0, 1]) - l = layer( - tc.get_backend("pytorch").ones([2, 2**n]) / 2 ** (n / 2), - 0.2 * tc.get_backend("pytorch").ones([2, n], dtype="float32"), - ) + state = torchb.ones([2, 2**n]) / 2 ** (n / 2) + noise = 0.2 * torchb.ones([2, n], dtype="float32") + l = layer(state, noise) + lsum = torchb.sum(l) print(l) + lsum.backward() + for p in layer.parameters(): + print(p.grad) From daa1660af5635b63d2754f53ca729be7cba38ffd Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 4 Jan 2023 22:26:18 +0800 Subject: [PATCH 146/725] fix set token bug --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 885 ++-------------------- tensorcircuit/cloud/apis.py | 12 +- 2 files changed, 87 insertions(+), 810 deletions(-) diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb index da9ae336..c7e3ef0e 100644 --- a/docs/source/tutorials/tc_qcloud_sdk.ipynb +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "8595b0b0", "metadata": {}, "outputs": [], @@ -42,24 +42,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "06e38047", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'tencent::': 'wROld-1665558660551115293;8',\n", - " 'tencent::simulator:tc': 'wROld-1665558660551115293;8'}" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "apis.set_token(\"wROld-1665558660551115293;8\")\n", + "apis.set_token(\"foobar\")\n", "# only required running once for a given laptop" ] }, @@ -73,99 +61,40 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "59dc5c6f", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[tencent, local]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "apis.list_providers()" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "d231e5c3", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[tencent::20xmon,\n", - " tencent::9gmon,\n", - " tencent::simulator:aer,\n", - " tencent::simulator:qx,\n", - " tencent::simulator:tc,\n", - " tencent::simulator:tcn1]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "apis.list_devices(\"tencent\")" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "e2ab9a2c", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'id': '9gmon',\n", - " 'type': 'CHIP',\n", - " 'qubits': 9,\n", - " 'state': 'on',\n", - " 'queue': 0,\n", - " 'langs': ['tQASM', 'eQASM'],\n", - " 'memo': 'tQLab 9Gmon',\n", - " 'usage': '9gmon?o=0 \\nthe o(ptimized) to specify optimization level bits: both = 3 (bits 11) = gate decomposition = 2 (bit 10) | qubit mapping = 1 (bit 01)'}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "apis.list_properties(device=\"9gmon\")" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "aaec43c3", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'id': 'simulator:tcn1',\n", - " 'alias': 'simulator:tc?noise',\n", - " 'state': '',\n", - " 'queue': 0}" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "apis.list_properties(device=\"simulator:tcn1\")" ] @@ -180,28 +109,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "94404d7a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'id': '2831cfb4-cdae-4b1d-8917-70d4a0fa4b72', 'queue': 'low', 'device': 'simulator:tc?o=3', 'state': 'pending', 'shots': 1024, 'at': 1672391326132532, 'ts': {'pending': 1672391326132532, 'scheduled': 1672391326129379}, 'md5': 'db493e15a6e8a68beed1815f760b45d0', 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[1];\\ncreg c[1];\\nh q[0];', 'version': '1', 'lang': 'OPENQASM', 'prior': 1, 'optimization': {}}\n" - ] - }, - { - "data": { - "text/plain": [ - "{'0': 549, '1': 475}" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "c = tc.Circuit(1)\n", "c.H(0)\n", @@ -213,70 +124,30 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "617cbd84", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'completed'" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t.status()" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "a6e686be", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tencent::simulator:tc" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t.get_device()" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "77dddd16", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'id': '7e212512-8d10-4bb9-bd24-5cf036da41d2', 'queue': 'low', 'device': 'simulator:tc?o=3', 'qubits': 1, 'state': 'pending', 'shots': 1024, 'at': 1672391337185756, 'ts': {'completed': 1672391327686452, 'pending': 1672391337185756, 'scheduled': 1672391337178889}, 'md5': 'db493e15a6e8a68beed1815f760b45d0', 'runAt': 1672391326, 'runDur': 1036, 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[1];\\ncreg c[1];\\nh q[0];', 'version': '1', 'lang': 'OPENQASM', 'prior': 1, 'result': {'0': 549, '1': 475}, 'optimization': {}, 'results': {'0': 549, '1': 475}}\n" - ] - }, - { - "data": { - "text/plain": [ - "{'0': 534, '1': 490}" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# resubmit a job\n", "t1 = t.resubmit()\n", @@ -294,21 +165,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "570159fe", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[local::testing]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "apis.set_provider(\"local\")\n", "# using tc simulator on local device: your own laptop is your server\n", @@ -317,21 +177,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "fd99ee01", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'00': 4100, '11': 4092}" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "c = tc.Circuit(2)\n", "c.h(0)\n", @@ -344,21 +193,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "bb62ed45", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[local::testing~~0e061ad5-e721-402a-a649-8dd4eb520d80]" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "tl = apis.list_tasks()\n", "tl" @@ -366,33 +204,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "045a19ef", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "local::testing~~0e061ad5-e721-402a-a649-8dd4eb520d80\n" - ] - }, - { - "data": { - "text/plain": [ - "{'id': '0e061ad5-e721-402a-a649-8dd4eb520d80',\n", - " 'state': 'completed',\n", - " 'at': 1672391359398387.0,\n", - " 'shots': 8192,\n", - " 'device': 'testing',\n", - " 'results': {'00': 4100, '11': 4092}}" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "id_ = tl[0].__str__()\n", "print(id_)\n", @@ -402,21 +217,10 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "307eeb42", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tencent" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# back to tencent server by\n", "apis.set_provider(\"tencent\")" @@ -432,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "2cc7c82c", "metadata": {}, "outputs": [], @@ -456,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "f2ed2419", "metadata": {}, "outputs": [], @@ -469,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "139700b3", "metadata": {}, "outputs": [], @@ -481,22 +285,10 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "id": "093ec74c", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from qiskit.visualization import plot_histogram\n", "\n", @@ -505,21 +297,10 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "id": "e4bd6569", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.4302675317947488, 0.08294928617219555)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ideal_count = tc.results.counts.vec2count(c.probability(), prune=True)\n", "ideal_count = tc.results.counts.marginal_count(ideal_count, [8, 4, 0, 2, 6])\n", @@ -530,45 +311,10 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "91720f2c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "readout matrix\n", - "qubit 0:\n", - "[[0.95800781 0.16650391]\n", - " [0.04199219 0.83349609]]\n", - "qubit 1:\n", - "[[0.96606445 0.08862305]\n", - " [0.03393555 0.91137695]]\n", - "qubit 2:\n", - "[[0.98266602 0.06079102]\n", - " [0.01733398 0.93920898]]\n", - "qubit 3:\n", - "[[0.99389648 0.07177734]\n", - " [0.00610352 0.92822266]]\n", - "qubit 4:\n", - "[[0.984375 0.06225586]\n", - " [0.015625 0.93774414]]\n", - "qubit 5:\n", - "[[0.97802734 0.06787109]\n", - " [0.02197266 0.93212891]]\n", - "qubit 6:\n", - "[[0.95703125 0.0925293 ]\n", - " [0.04296875 0.9074707 ]]\n", - "qubit 7:\n", - "[[0.97607422 0.07910156]\n", - " [0.02392578 0.92089844]]\n", - "qubit 8:\n", - "[[0.95629883 0.14672852]\n", - " [0.04370117 0.85327148]]\n" - ] - } - ], + "outputs": [], "source": [ "# we can directly check local readout matrix on each qubit\n", "print(\"readout matrix\")\n", @@ -579,19 +325,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "db3e59b5", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'00': 526, '10': 481, '01': 10, '11': 7}\n", - "{'00': 524, '01': 470, '11': 18, '10': 12}\n" - ] - } - ], + "outputs": [], "source": [ "# we can also do batch submission\n", "\n", @@ -619,18 +356,10 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "id": "9d7abd03", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'00000': 1645, '11111': 988, '00101': 205, '11110': 147, '01111': 142, '11010': 137, '00001': 135, '11101': 101, '11011': 76, '01010': 70, '00010': 64, '10111': 58, '00100': 53, '01101': 36, '01000': 31, '10000': 29, '10101': 29, '00111': 23, '01011': 19, '11000': 18, '11100': 16, '01110': 15, '01100': 10, '10110': 9, '01001': 7, '10010': 7, '10001': 6, '10011': 6, '10100': 5, '11001': 5, '00011': 4}\n" - ] - } - ], + "outputs": [], "source": [ "# directly partial measure\n", "\n", @@ -652,18 +381,10 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "9ac0b2fe", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'00000': 3305, '11111': 2115, '00001': 378, '11110': 354, '11101': 296, '01111': 247, '00101': 212, '00010': 146, '11010': 145, '10111': 139, '11011': 135, '10101': 96, '00100': 86, '01010': 79, '01101': 71, '01000': 61, '11100': 54, '01110': 43, '10000': 28, '00111': 24, '01011': 24, '10110': 23, '00011': 22, '11001': 22, '10100': 15, '01100': 14, '11000': 14, '01001': 11, '10010': 10, '10001': 9, '10011': 8, '00110': 6}\n" - ] - } - ], + "outputs": [], "source": [ "# directly partial measure\n", "\n", @@ -696,18 +417,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "5ce371e9", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'00000': 1594, '11111': 984, '00101': 214, '11010': 167, '00001': 148, '11110': 125, '01111': 122, '11101': 120, '11011': 87, '10111': 74, '00010': 68, '00100': 44, '01000': 43, '01010': 39, '10101': 35, '01101': 32, '10000': 27, '00111': 23, '11000': 22, '11100': 18, '01110': 16, '10010': 15, '10110': 14, '01011': 10, '01100': 10, '01001': 9, '11001': 9, '00011': 8, '10011': 6, '10100': 6, '00110': 4, '10001': 3}\n" - ] - } - ], + "outputs": [], "source": [ "# directly partial measure\n", "\n", @@ -743,19 +456,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "03aed751", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "exact: [array(-5.9604645e-08, dtype=float32), array(0.3623577, dtype=float32), array(0.76484215, dtype=float32)]\n", - "experiments (mitigated): [0.04084053550245752, 0.28041151119143615, 0.8151639888461032]\n" - ] - } - ], + "outputs": [], "source": [ "# directly use built-in mitigation with expectation evaluation + front-end (tc/qiskit) compiling system\n", "\n", @@ -793,61 +497,22 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "bd760c6b", "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "text/html": [ - "
        ┌───┐                    ┌───┐     \n",
-       "q_0: ───┤ H ├─────────────────■──┤ X ├─────\n",
-       "        ├───┤   ┌──────────┐┌─┴─┐└─┬─┘┌───┐\n",
-       "q_1: ───┤ H ├───┤ Ry(-1.2) ├┤ X ├──┼──┤ H ├\n",
-       "     ┌──┴───┴──┐└──────────┘└───┘  │  └───┘\n",
-       "q_2: ┤ Rx(0.7) ├───────────────────■───────\n",
-       "     └─────────┘                           \n",
-       "c: 3/══════════════════════════════════════\n",
-       "
" - ], - "text/plain": [ - " ┌───┐ ┌───┐ \n", - "q_0: ───┤ H ├─────────────────■──┤ X ├─────\n", - " ├───┤ ┌──────────┐┌─┴─┐└─┬─┘┌───┐\n", - "q_1: ───┤ H ├───┤ Ry(-1.2) ├┤ X ├──┼──┤ H ├\n", - " ┌──┴───┴──┐└──────────┘└───┘ │ └───┘\n", - "q_2: ┤ Rx(0.7) ├───────────────────■───────\n", - " └─────────┘ \n", - "c: 3/══════════════════════════════════════\n", - " " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "c.draw()" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "a45fa6f5", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "exact: [array(-5.9604645e-08, dtype=float32), array(0.3623577, dtype=float32), array(0.76484215, dtype=float32)]\n", - "experiments (mitigated): [0.022390317700453997, 0.3906313645621186, 0.7582969721010189]\n" - ] - } - ], + "outputs": [], "source": [ "# use backend compiling system enabled by qos\n", "\n", @@ -886,23 +551,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "cf2d2690", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'frontend': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[3];\\nh q[0];\\nh q[1];\\nrx(0.69999999) q[2];\\nry(-1.2) q[1];\\ncx q[0],q[1];\\ncx q[2],q[0];\\nh q[1];',\n", - " 'backend': {'progs': [{'code': 'Tencent Quantum Program\\nversion 1.0\\nqubit involved: q0,q1,q2,q3,q4,q5,q6,q7,q8\\n# section: eqasm\\n# section lines 33\\neqasm program\\nbs 1 H q0\\nbs 0 H q1\\nbs 0 RZB2 q2\\nbs 1 S q2\\nbs 0 S q1\\nbs 1 H q2\\nbs 0 H q1\\nbs 1 RZB4 q2\\nbs 0 RZB5 q2\\nbs 0 RZB6 q2\\nbs 0 RZB9 q2\\nbs 0 RZB14 q2\\nbs 0 RZB16 q2\\nbs 0 RZB1 q1\\nbs 0 RZB2 q1\\nbs 0 RZB5 q1\\nbs 0 RZB6 q1\\nbs 0 RZB7 q1\\nbs 0 RZB8 q1\\nbs 0 RZB12 q1\\nbs 0 RZB13 q1\\nbs 0 RZB15 q1\\nbs 0 RZB16 q1\\nbs 1 H q2\\nbs 0 H q1\\nbs 1 SD q2\\nbs 0 SD q1\\nbs 1 RZB1 q2\\nbs 0 RZB2 q2\\nbs 0 CX (q0, q1)\\nbs 1 H q1\\nbs 0 CX (q2, q0)\\nMEASZ q0,q1,q2\\n# section: end\\n',\n", - " 'lang': 'QEXE'}]}}" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# inspect compiling results from the tc and qos for the task\n", "\n", @@ -911,18 +563,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "7fee9a15", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "exact: [array(-5.9604645e-08, dtype=float32), array(0.3623577, dtype=float32), array(0.76484215, dtype=float32)]\n" - ] - } - ], + "outputs": [], "source": [ "# dry run mode to query compiled circuit only from qos (not really sending the circuit to chips)\n", "\n", @@ -952,23 +596,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "e262a682", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'frontend': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[3];\\nh q[0];\\nh q[1];\\nrz(-pi/2) q[1];\\nh q[1];\\nrz(-1.2) q[1];\\nh q[1];\\nrz(5*pi/2) q[1];\\ncx q[0],q[1];\\nh q[1];\\nh q[2];\\nrz(0.69999999) q[2];\\nh q[2];\\ncx q[2],q[0];',\n", - " 'backend': {'progs': [{'code': 'Tencent Quantum Program\\nversion 1.0\\nqubit involved: q0,q1,q2,q3,q4,q5,q6,q7,q8\\n# section: eqasm\\n# section lines 10\\neqasm program\\nbs 1 H q0\\nbs 0 H q1\\nbs 0 H q2\\nbs 1 H q1\\nbs 0 H q2\\nbs 1 H q1\\nbs 1 CX (q0, q1)\\nbs 1 H q1\\nbs 0 CX (q2, q0)\\nMEASZ q0,q1,q2\\n# section: end\\n',\n", - " 'lang': 'QEXE'}]}}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t.get_compiled_details()" ] @@ -985,21 +616,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "2b509155", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'000': 7725, '001': 261, '100': 164, '010': 33, '101': 9}" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# scalable readout error simulation on tQuK with tensorcircuit backend using tensor network approach\n", "\n", @@ -1010,21 +630,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "71f634ff", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'000': 8192.0}" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t.results(mitigated=True)" ] @@ -1045,7 +654,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "cdfb639c", "metadata": {}, "outputs": [], @@ -1061,123 +670,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "f8d8217e", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'100000000000000': 8419.697440088592,\n", - " '100100000000000': 70.62067781260015,\n", - " '100000100000000': 32.06999431920804,\n", - " '100000000000010': 21.05429511303664,\n", - " '100000000100100': 12.737459534668831,\n", - " '100000000010000': 6.717028675136155,\n", - " '100000100000001': 5.517504244766566,\n", - " '101000000000000': 5.343221628567916,\n", - " '100000000000100': 5.316502711797031,\n", - " '100101000000000': 5.055791656340502,\n", - " '100000000100000': 4.583753814772621,\n", - " '100000001010000': 4.563675472853387,\n", - " '100100001000000': 4.200871093607515,\n", - " '100000001000001': 4.037583611576253,\n", - " '100000000100001': 3.993740071242359,\n", - " '100000100000100': 3.620123993770483,\n", - " '100100000000001': 3.331528047004301,\n", - " '100000000000101': 2.9602206346214883,\n", - " '110000000000100': 2.4447297020449055,\n", - " '100100000000100': 2.1864507226578893,\n", - " '100000101100000': 2.0581439661798693,\n", - " '100000000000110': 1.6273556338878277,\n", - " '110000001000000': 1.6165778033772777,\n", - " '101000100000000': 1.5943040213903492,\n", - " '100000100100000': 1.5109801589828913,\n", - " '110001000000000': 1.4878748649195706,\n", - " '101000000000001': 1.4554025461864313,\n", - " '100000100010000': 1.4387429080263332,\n", - " '100001001000000': 1.3911841049012317,\n", - " '100000000110000': 1.27595864225905,\n", - " '100001100000000': 1.1203274457975498,\n", - " '100100000100010': 1.078941729230564,\n", - " '100001100000010': 1.058872714188839,\n", - " '110000000110000': 1.0071832705686932,\n", - " '101100000001001': 0.9802634521345814,\n", - " '100010000001000': 0.9411197364818454,\n", - " '000000000100000': 0.9316389155910612,\n", - " '101000001100000': 0.9175529942539858,\n", - " '100011000000000': 0.9077887012464176,\n", - " '100001000001100': 0.9014187801746705,\n", - " '101000000000101': 0.8934662599445671,\n", - " '000000000000100': 0.8930840706602694,\n", - " '110000000100100': 0.8821880862632059,\n", - " '101001000001000': 0.8781652435907243,\n", - " '101100000001000': 0.8724239475595535,\n", - " '100010000000100': 0.8345195977528056,\n", - " '101100100000000': 0.8319641116304223,\n", - " '100010100000000': 0.8218914654493159,\n", - " '000001000000000': 0.8049948545166198,\n", - " '101010000000000': 0.8000672364423292,\n", - " '101001001000000': 0.7969743025592275,\n", - " '100001000100000': 0.7956137409639294,\n", - " '001000000000000': 0.789606059795129,\n", - " '100100100000001': 0.7884318597525475,\n", - " '100101000001000': 0.7415010114429998,\n", - " '101001000100000': 0.6919729246648194,\n", - " '100000000010001': 0.6798365988865034,\n", - " '100001000000100': 0.6746774495099936,\n", - " '100000001001000': 0.6656234863552265,\n", - " '100000010001000': 0.6621556388191783,\n", - " '100000001100100': 0.6345752195408909,\n", - " '110000000001000': 0.6076581375075842,\n", - " '100000010100000': 0.4745304454976847,\n", - " '101000000100100': 0.44415633504428315,\n", - " '101000000000010': 0.3724845125075598,\n", - " '110000000100000': 0.25702564175016074,\n", - " '100001000010000': 0.254962007546872,\n", - " '101100000000000': 0.25345181627314156,\n", - " '111000000000000': 0.20808484786196516,\n", - " '100000000010100': 0.1832565235759075,\n", - " '101000000010000': 0.09102957852547792,\n", - " '100100000100000': 0.04365953380230936,\n", - " '100100000000010': -0.027541754030945935,\n", - " '100100000001000': -0.028714529367154015,\n", - " '100000000001010': -0.09047987962965393,\n", - " '100000100000010': -0.214103726888365,\n", - " '101001000000000': -0.3152465552779923,\n", - " '000100000000000': -0.3989564181995144,\n", - " '101000000100000': -0.4118194835787859,\n", - " '100001000000010': -0.47025162263150116,\n", - " '100000000100010': -0.5690654957937074,\n", - " '000000100000000': -0.6191879565167421,\n", - " '100001000000001': -0.695357972540988,\n", - " '100100100000000': -0.7175884771016332,\n", - " '100001000001000': -0.7630782732138829,\n", - " '100000000001001': -1.008694690776709,\n", - " '101000000001000': -1.2504938465007915,\n", - " '101000001000000': -1.4343739078734263,\n", - " '100000000001100': -1.6129859188764608,\n", - " '100000101000000': -1.7145196696995655,\n", - " '100000001100000': -1.9094346951735794,\n", - " '100000001000100': -2.878659473184994,\n", - " '100000000101000': -3.5969775749822315,\n", - " '100000100001000': -4.660489024999659,\n", - " '100000010000000': -7.228177465795695,\n", - " '101000000000100': -7.433443342353611,\n", - " '100010000000000': -18.713786232606235,\n", - " '110000000000000': -26.25306538585136,\n", - " '100000001000000': -27.852335007043337,\n", - " '100001000000000': -29.805593058690288,\n", - " '100000000001000': -30.14314633475033,\n", - " '100000000000001': -70.20285091373152,\n", - " '000000000000000': -229.9578391969697}" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# mitigated with m3 scalable on count dict\n", "c = tc.Circuit(15)\n", @@ -1193,21 +689,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "292f9b11", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-0.9987468671679187" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# mitigated with m3 scalable directly on expectation: not a wrapper for count but a new algorithm!\n", "# see eq 6 in https://arxiv.org/pdf/2006.14044.pdf\n", @@ -1227,147 +712,27 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "2b80411b", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[tencent::9gmon?o=1~~0793030c-a3d0-426f-bf2c-0cb8ec4ad0b0,\n", - " tencent::simulator:tcn1?o=3~~fdde7cb9-1738-4b82-becf-5add3bebdcc0,\n", - " tencent::simulator:tcn1?o=3~~949ba88c-ba4f-44e1-b03b-e35873cc429e,\n", - " tencent::simulator:tcn1?o=3~~a434a0d2-9d7e-46ff-ae42-e8397dd09cea,\n", - " tencent::simulator:tcn1?o=3~~6462e2eb-cfb4-407a-bf93-12afe70ed73e,\n", - " tencent::simulator:tcn1?o=3~~44bc1bba-628f-4739-9cf5-cc612059b635,\n", - " tencent::simulator:tcn1?o=3~~67f33828-357e-49e8-a8f8-6ded2a16b5d3,\n", - " tencent::simulator:tcn1?o=3~~e0e6660b-306d-494c-902b-630d656bc64d,\n", - " tencent::simulator:tcn1?o=3~~13ac4aea-e6b7-469d-a67f-ad28a9dc16a0,\n", - " tencent::simulator:tcn1?o=3~~dc53b3bf-48c5-43ee-a42c-8b140c14080d,\n", - " tencent::simulator:tcn1?o=3~~53a949b9-a763-4cce-b11d-1d83b65095b3,\n", - " tencent::simulator:tcn1?o=3~~7fdb1e4c-801a-4236-8ec8-be61101ff499,\n", - " tencent::simulator:tcn1?o=3~~e7819297-e989-4620-840a-b15a6f988a1a,\n", - " tencent::simulator:tcn1?o=3~~29ca9ff7-1063-4477-b827-e2e11613ef46,\n", - " tencent::simulator:tcn1?o=3~~aa05e4e2-72fb-4b0b-969e-56c65cd7e4cc,\n", - " tencent::simulator:tcn1?o=3~~5f006fe4-1a1f-47ab-b12d-34c6ed4d9040,\n", - " tencent::simulator:tcn1?o=3~~7bea264d-e714-45d7-8893-3310b73ab168,\n", - " tencent::simulator:tcn1?o=3~~48dbd262-aaab-48e2-96de-fd6396a24284,\n", - " tencent::simulator:tcn1?o=3~~054b7901-6b36-44e6-9f71-c9a360e7b4a4,\n", - " tencent::simulator:tcn1?o=3~~fcf97cbd-ff78-4a0e-8cfe-aa11309dba99,\n", - " tencent::simulator:tcn1?o=3~~bd4c8937-e3dd-4f84-ab6f-20dc33096aea,\n", - " tencent::simulator:tcn1?o=3~~b4900bf6-ef83-46bd-8735-e941679b88fc,\n", - " tencent::simulator:tcn1?o=3~~b093b1cd-ff4b-42b9-9db7-b0983dc0e503,\n", - " tencent::simulator:tcn1?o=3~~3d151c82-e441-4b13-aebd-57cd896f1577,\n", - " tencent::simulator:tcn1?o=3~~6e38b4b3-eddb-414b-afd8-ae45a48966bd,\n", - " tencent::simulator:tcn1?o=3~~987b17fd-79d6-4099-9601-d26d42a29d14,\n", - " tencent::simulator:tcn1?o=3~~20485921-564a-45b1-9e07-276048b29de9,\n", - " tencent::simulator:tcn1?o=3~~59b3cd63-0126-4f8d-a4e8-1b8e6994a3ed,\n", - " tencent::simulator:tcn1?o=3~~136cdf82-081f-4b90-8f2e-00dcfea4e08d,\n", - " tencent::simulator:tcn1?o=3~~70549fd3-67aa-4e42-b474-b29b313e8278,\n", - " tencent::simulator:tcn1?o=3~~2da1a4bc-81a6-4f6d-82a0-60cebd5f6e0f,\n", - " tencent::simulator:tcn1?o=3~~81a6884d-c4ad-423c-ae2d-9799f56d550b,\n", - " tencent::simulator:tcn1?o=3~~8253dba0-9cf6-46e1-8eaa-63d04cbdf7ec,\n", - " tencent::simulator:tcn1?o=3~~dde2431f-6815-436b-ac16-a80050a1e27a,\n", - " tencent::simulator:tcn1?o=3~~442d8839-25c4-4f26-8d53-1f723941ce7a,\n", - " tencent::simulator:tcn1?o=3~~546090a9-31d5-441a-bc6a-ed5e12c3f9ad,\n", - " tencent::simulator:tcn1?o=3~~227ae13c-04a0-41e0-a0aa-1c8ea77c0b7a,\n", - " tencent::simulator:tcn1?o=3~~dc1b5b60-6ccd-4ca5-96e3-458e41ad8ca9,\n", - " tencent::simulator:tcn1?o=3~~d5712b1c-0988-4f3f-8347-56b91492b4dc,\n", - " tencent::simulator:tcn1?o=3~~0bbb4222-117c-47cc-be50-b0dbbee22ee2,\n", - " tencent::simulator:tcn1?o=3~~a5a87e9a-8990-4ed9-86bc-066b6a4f5a1d,\n", - " tencent::simulator:tcn1?o=3~~8589e1f2-8e35-467a-b45b-810ff5d5281a,\n", - " tencent::simulator:tcn1?o=3~~d1d2dcd0-e6d5-4dd4-be97-ec3e7fc808b5,\n", - " tencent::simulator:tcn1?o=3~~cd68b30a-3319-45ed-9931-af4b41e7af09,\n", - " tencent::simulator:tcn1?o=3~~b1d450cb-ebfc-478d-9c4f-0d6b0ef7418d,\n", - " tencent::simulator:tcn1?o=3~~dc48ba37-2760-4da2-b348-b6c1190c2ca2,\n", - " tencent::simulator:tcn1?o=3~~ee45ae23-3b99-4507-8110-f6eeece30eaf,\n", - " tencent::simulator:tcn1?o=3~~bcc806e5-a021-44f8-83ce-aba9d054cf75,\n", - " tencent::9gmon?o=0~~5d2d8e11-760e-4f88-b003-5b5901edbf21,\n", - " tencent::9gmon?o=0~~8e3a77f7-838e-4d08-a75a-b864704b89e3]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "apis.list_tasks()" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "8dffbcfd", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[tencent::9gmon?o=1~~0793030c-a3d0-426f-bf2c-0cb8ec4ad0b0,\n", - " tencent::9gmon?o=0~~5d2d8e11-760e-4f88-b003-5b5901edbf21,\n", - " tencent::9gmon?o=0~~8e3a77f7-838e-4d08-a75a-b864704b89e3,\n", - " tencent::9gmon?o=0~~e3c137fc-e478-48f6-bc89-c077c1a3cd9e,\n", - " tencent::9gmon?o=0~~7a251212-f21d-46f1-976d-9a5ba066bb40,\n", - " tencent::9gmon?o=0~~6445a6bf-9cf8-4b7d-af6f-aeeb5f4989ef,\n", - " tencent::9gmon?o=0~~91be022d-afd5-414e-8776-88acb6f1d3dd,\n", - " tencent::9gmon?o=0~~f962fbd8-dffc-4369-b2e6-696c3db561ed,\n", - " tencent::9gmon?o=0~~26dc60ad-f9c1-4d82-bd87-266c8520bd90,\n", - " tencent::9gmon?o=0~~d841bb5b-5549-488c-b660-47f59e129a7b,\n", - " tencent::9gmon?o=2~~315fb708-c9da-4a53-b2ac-c206e563620b,\n", - " tencent::9gmon?o=0~~198b0d28-1c9b-400c-aecc-af926d789c1e,\n", - " tencent::9gmon~~27562978-1588-4314-8517-782fd7b27265,\n", - " tencent::9gmon~~bcc06a7a-350d-4b6a-b536-829eca1cf07f,\n", - " tencent::9gmon~~b0a0c0ab-d902-457c-97c8-0a731d0982d8,\n", - " tencent::9gmon~~c64a78d3-54c8-40f1-b64f-f7027890368b,\n", - " tencent::9gmon?o=3~~ebceb01d-9902-4879-b4c1-be39c2dd0053,\n", - " tencent::9gmon?o=2&dry~~45101e92-70aa-49f0-805b-f5187b6da72f,\n", - " tencent::9gmon?o=3~~135fc458-54f1-4f7f-bcc2-4922682e25cd,\n", - " tencent::9gmon?o=3~~9f510558-1151-49e8-8f21-e9a8b344cdf6,\n", - " tencent::9gmon~~98574130-e4ee-4b16-afe7-ec09a245cf86,\n", - " tencent::9gmon~~0e76f4da-ec80-47c7-9d16-bd837afc6905,\n", - " tencent::9gmon~~a2b185d4-9684-4d2e-8bb5-ec5087ddd882,\n", - " tencent::9gmon~~787a9b09-6c62-40b6-a9e6-f172d73ea300,\n", - " tencent::9gmon~~e621f4f7-9f83-4dd5-ae8e-43ba336a3c86,\n", - " tencent::9gmon~~638246cf-f642-4cab-9959-8f007e45bfd3,\n", - " tencent::9gmon~~d341e961-b05e-465a-82bf-fb85b4614a6a,\n", - " tencent::9gmon~~45fa081f-9834-4d53-a72e-9bec73d02a6d,\n", - " tencent::9gmon~~62bca49a-ecee-43fe-a27e-76d48021f66a,\n", - " tencent::9gmon~~91cb4589-d840-492d-bad1-800517cc80a4,\n", - " tencent::9gmon~~0d7c82d6-b71b-442e-a7a2-923452daf279,\n", - " tencent::9gmon~~5453692b-1a5f-4a3e-9689-a407d5bd787c,\n", - " tencent::9gmon~~4ab5e201-0784-476e-b23b-551fbac1772a,\n", - " tencent::9gmon~~9fd46395-3bed-49b1-a262-4afc49bb545a,\n", - " tencent::9gmon~~a458a62d-f270-4921-a0dd-9cf8b57e4581,\n", - " tencent::9gmon~~f5bfd675-afbc-4e92-ac06-dd1f780bf0e2,\n", - " tencent::9gmon~~4c483a0d-0aa4-49b5-803b-f0cacf5d5c50,\n", - " tencent::9gmon~~f5ff62ae-df69-46fd-806d-b294ac8cfb90,\n", - " tencent::9gmon~~dbb9dc21-ffed-4004-a755-76f183ade2a8,\n", - " tencent::9gmon~~ea84339e-2c6a-46f6-b3c9-6f422df68d87,\n", - " tencent::9gmon~~cb2531bf-e730-46b7-ab3a-11ece77303f8,\n", - " tencent::9gmon?o=3&dry~~a0186d54-c93a-4abf-b81f-c5b69bef733c,\n", - " tencent::9gmon?o=1&dry~~d990b42e-6c15-488c-8524-96a9fef48316,\n", - " tencent::9gmon?o=1~~06764d75-a365-4d6e-a1b3-40eacc84f527,\n", - " tencent::9gmon?o=1~~d12859da-ac27-4990-9217-5f7b582928fc,\n", - " tencent::9gmon?o=1~~d437ebbc-9f4b-44df-a07c-70ebdca9bfbc,\n", - " tencent::9gmon?o=1~~234e6a65-59ab-4736-9e89-6aba5a8cce6a,\n", - " tencent::9gmon?o=1~~f532daa7-f9af-4311-befa-910589cd7826,\n", - " tencent::9gmon?o=1~~ffbb1a37-632c-4b2c-a2d6-faa59b1f6c6b,\n", - " tencent::9gmon?o=1~~c1e99c59-1aca-4487-a7d1-96cb878feabf]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "apis.list_tasks(device=\"9gmon\")" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "5e29190d", "metadata": {}, "outputs": [], @@ -1377,62 +742,19 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "d24ddc18", "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'id': 'd77bec2f-ab07-4dbc-a273-caa8b23a921c',\n", - " 'queue': 'txqlab',\n", - " 'device': '9gmon',\n", - " 'state': 'completed',\n", - " 'shots': 4096,\n", - " 'at': 1670549560020389,\n", - " 'ts': {'completed': 1670549560020389,\n", - " 'pending': 1670549557999879,\n", - " 'scheduled': 1670549557997345},\n", - " 'md5': '4a2e4269b3a3e78e0f6509ba78d9bdd8',\n", - " 'runAt': 1670549557,\n", - " 'runDur': 2000,\n", - " 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[3];\\nh q[0];\\nrz(-pi/2) q[1];\\nh q[1];\\ncx q[0],q[1];\\nrz(-1.4) q[1];\\ncx q[0],q[1];\\nrz(-1.4) q[1];\\nh q[1];\\nrz(5*pi/2) q[1];\\nh q[1];\\nrz(-pi/2) q[2];\\nh q[2];\\ncx q[0],q[2];\\nrz(1.4) q[2];\\ncx q[0],q[2];\\nrz(-1.4) q[2];\\nh q[2];\\nrz(5*pi/2) q[2];\\nh q[2];',\n", - " 'version': '1',\n", - " 'lang': 'OPENQASM',\n", - " 'prior': 1,\n", - " 'result': {'000': 492,\n", - " '001': 599,\n", - " '010': 589,\n", - " '011': 685,\n", - " '100': 255,\n", - " '101': 518,\n", - " '110': 363,\n", - " '111': 595},\n", - " 'optimization': {},\n", - " 'results': {'000': 492,\n", - " '001': 599,\n", - " '010': 589,\n", - " '011': 685,\n", - " '100': 255,\n", - " '101': 518,\n", - " '110': 363,\n", - " '111': 595}}" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t.details()" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "706c9c08", "metadata": {}, "outputs": [], @@ -1442,64 +764,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "8ad61cb9", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'id': 'e32bb488-5ee9-4b07-8217-1e78ceb4bde3',\n", - " 'queue': 'txq.low',\n", - " 'device': '9gmon',\n", - " 'state': 'completed',\n", - " 'shots': 8192,\n", - " 'at': 1671158467283362,\n", - " 'ts': {'completed': 1671158467283362,\n", - " 'pending': 1671158406209032,\n", - " 'scheduled': 1671158406206228},\n", - " 'md5': 'e2b1202e83341de33b19b9acce1e795d',\n", - " 'runAt': 1671158405,\n", - " 'runDur': 61000,\n", - " 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[3];\\nx q[0];\\nx q[1];\\nx q[2];',\n", - " 'version': '1',\n", - " 'lang': 'OPENQASM',\n", - " 'prior': 1,\n", - " 'result': {'000': 8,\n", - " '001': 39,\n", - " '010': 28,\n", - " '011': 367,\n", - " '100': 41,\n", - " '101': 493,\n", - " '110': 530,\n", - " '111': 6686},\n", - " 'optimization': {},\n", - " 'results': {'000': 8,\n", - " '001': 39,\n", - " '010': 28,\n", - " '011': 367,\n", - " '100': 41,\n", - " '101': 493,\n", - " '110': 530,\n", - " '111': 6686}}" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t.details()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "06dc69f2", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index e8b03bcf..ca396180 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -173,7 +173,7 @@ def set_token( global saved_token homedir = os.path.expanduser("~") authpath = os.path.join(homedir, ".tc.auth.json") - provider, device = _preprocess(provider, device) + # provider, device = _preprocess(provider, device) if token is None: if cached and os.path.exists(authpath): @@ -186,12 +186,18 @@ def set_token( file_token.update(saved_token) saved_token = file_token else: # with token + if isinstance(provider, str): + provider = Provider.from_name(provider) if device is None: if provider is None: - provider = Provider.from_name("tencent") + provider = default_provider added_token = {provider.name + sep: token} else: - added_token = {provider.name + sep + device.name: token} + if provider is None: + provider = device.provider # type: ignore + if provider is None: + provider = default_provider + added_token = {provider.name + sep + device.name: token} # type: ignore saved_token.update(added_token) if cached: From e8b2c700b6d1720878228e61570b78fc92ad53b0 Mon Sep 17 00:00:00 2001 From: weitang li Date: Thu, 5 Jan 2023 17:48:31 +0800 Subject: [PATCH 147/725] support barrier when converting from qiskit to tc --- tensorcircuit/backends/backend_factory.py | 1 + tensorcircuit/basecircuit.py | 2 +- tensorcircuit/translation.py | 2 ++ tests/test_circuit.py | 1 + tests/test_torchnn.py | 2 +- 5 files changed, 6 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/backends/backend_factory.py b/tensorcircuit/backends/backend_factory.py index 10cf82bf..ca5f71a7 100644 --- a/tensorcircuit/backends/backend_factory.py +++ b/tensorcircuit/backends/backend_factory.py @@ -43,6 +43,7 @@ def get_backend(backend: Union[Text, bk]) -> bk: """ if isinstance(backend, tnbackend): return backend + backend = backend.lower() if backend not in _BACKENDS: raise ValueError("Backend '{}' does not exist".format(backend)) if backend in _INSTANTIATED_BACKENDS: diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 02599d31..bad32b0f 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -669,7 +669,7 @@ def sample_expectation_ps( :param status: external randomness given by tensor uniformly from [0, 1], if set, can overwrite random_generator :type status: Optional[Tensor] - :param readout_error: readout_error, defaults to None + :param readout_error: readout_error, defaults to None. Overrided if noise_conf is provided. :type readout_error: Optional[Sequence[Any]]. Tensor, List, Tuple :param noise_conf: Noise Configuration, defaults to None :type noise_conf: Optional[NoiseConf], optional diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 226a0532..e9a13c66 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -275,6 +275,8 @@ def qiskit2tc( tc_circuit.multicontrol( *idx, ctrl=ctrl_state, unitary=gates._x_matrix, name="x" ) + elif gate_name == "barrier": + pass elif gate_name[:3] == "mcx": if gate_name[3:] == "": tc_circuit.multicontrol( diff --git a/tests/test_circuit.py b/tests/test_circuit.py index ae8e2eb0..91936f5a 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -974,6 +974,7 @@ def test_qiskit2tc(): qisc.swap(0, 1) qisc.iswap(0, 1) qisc.toffoli(0, 1, 2) + qisc.barrier(0, 1, 2) qisc.s(1) qisc.t(1) qisc.sdg(2) diff --git a/tests/test_torchnn.py b/tests/test_torchnn.py index 93432c3a..38942c56 100644 --- a/tests/test_torchnn.py +++ b/tests/test_torchnn.py @@ -14,7 +14,7 @@ try: import torch except ImportError: - pytest.skip("torch is not installed") + pytestmark = pytest.mark.skip @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("torchb")]) From 9bf81d4fabb2a6b858b1a15363658600033d8190 Mon Sep 17 00:00:00 2001 From: weitang li Date: Fri, 6 Jan 2023 10:34:57 +0800 Subject: [PATCH 148/725] revert pytest skip --- tests/test_torchnn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_torchnn.py b/tests/test_torchnn.py index 38942c56..93432c3a 100644 --- a/tests/test_torchnn.py +++ b/tests/test_torchnn.py @@ -14,7 +14,7 @@ try: import torch except ImportError: - pytestmark = pytest.mark.skip + pytest.skip("torch is not installed") @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("torchb")]) From 0102455bcef112d2e46f78bcfd0af6681b71217b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 6 Jan 2023 12:41:22 +0800 Subject: [PATCH 149/725] add blocked option in t.details --- tensorcircuit/cloud/abstraction.py | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index b18fc2b5..73eebfd4 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -223,16 +223,27 @@ def get_device(self) -> Device: else: return Device.from_name(self.device) - def details(self, **kws: Any) -> Dict[str, Any]: + def details(self, blocked: bool = False, **kws: Any) -> Dict[str, Any]: """ Get the current task details + + :param blocked: whether return until task is finished, defaults to False + :type blocked: bool :return: _description_ :rtype: Dict[str, Any] """ from .apis import get_task_details - return get_task_details(self, **kws) + if blocked is False: + return get_task_details(self, **kws) + s = self.state() + tries = 0 + while s == "pending": + time.sleep(0.5 + tries / 10) + tries += 1 + s = self.state() + return self.details(**kws) def state(self) -> str: """ From 8c0b7962d393ff1794227c8b67dc5a28719e70e8 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 6 Jan 2023 14:14:52 +0800 Subject: [PATCH 150/725] add highly customized local readout calibriation --- tensorcircuit/results/readout_mitigation.py | 94 +++++++++++++++------ tests/test_results.py | 10 +++ 2 files changed, 80 insertions(+), 24 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index bcf60b51..9180126e 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -170,6 +170,17 @@ def local_miti_readout_circ(self) -> List[Circuit]: miticirc.append(c) return miticirc + def local_miti_readout_circ_by_mask(self, bsl: List[str]) -> List[Circuit]: + cs = [] + n = max(self.cal_qubits) + 1 # type: ignore + for bs in bsl: + c = Circuit(n) + for j, i in enumerate(bs): + if i == "1": + c.X(j) # type: ignore + cs.append(c) + return cs + def global_miti_readout_circ(self) -> List[Circuit]: """ Generate circuits for global calibration. @@ -189,7 +200,11 @@ def global_miti_readout_circ(self) -> List[Circuit]: return miticirc def cals_from_system( # type: ignore - self, qubits: Union[int, List[int]], shots: int = 8192, method: str = "local" + self, + qubits: Union[int, List[int]], + shots: int = 8192, + method: str = "local", + masks: Optional[List[str]] = None, ): """ Get calibrattion information from system. @@ -209,29 +224,60 @@ def cals_from_system( # type: ignore if method == "local": self.local = True # type: ignore - miticirc = self.local_miti_readout_circ() - lbsall = self.execute_fun(miticirc, self.cal_shots) - lbs = [marginal_count(i, self.cal_qubits) for i in lbsall] # type: ignore - - self.single_qubit_cals = [None] * (max(self.cal_qubits) + 1) # type: ignore - for i in range(len(self.cal_qubits)): # type: ignore - error00 = 0 - for s in lbs[0]: - if s[i] == "0": - error00 = error00 + lbs[0][s] / self.cal_shots # type: ignore - - error10 = 0 - for s in lbs[1]: - if s[i] == "0": - error10 = error10 + lbs[1][s] / self.cal_shots # type: ignore - - readout_single = np.array( - [ - [error00, error10], - [1 - error00, 1 - error10], - ] - ) - self.single_qubit_cals[self.cal_qubits[i]] = readout_single # type: ignore + if masks is None: + miticirc = self.local_miti_readout_circ() + lbsall = self.execute_fun(miticirc, self.cal_shots) + lbs = [marginal_count(i, self.cal_qubits) for i in lbsall] # type: ignore + + self.single_qubit_cals = [None] * (max(self.cal_qubits) + 1) # type: ignore + for i in range(len(self.cal_qubits)): # type: ignore + error00 = 0 + for s in lbs[0]: + if s[i] == "0": + error00 = error00 + lbs[0][s] / self.cal_shots # type: ignore + + error10 = 0 + for s in lbs[1]: + if s[i] == "0": + error10 = error10 + lbs[1][s] / self.cal_shots # type: ignore + + readout_single = np.array( + [ + [error00, error10], + [1 - error00, 1 - error10], + ] + ) + self.single_qubit_cals[self.cal_qubits[i]] = readout_single # type: ignore + + else: + miticirc = self.local_miti_readout_circ_by_mask(masks) + lbsall = self.execute_fun(miticirc, self.cal_shots) + # lbs = [marginal_count(i, self.cal_qubits) for i in lbsall] # type: ignore + self.single_qubit_cals = [None] * (max(self.cal_qubits) + 1) # type: ignore + for i in self.cal_qubits: # type: ignore + error00n = 0 + error00d = 0 + error11n = 0 + error11d = 0 + for j, bs in enumerate(lbsall): + ans = masks[j][i] + if ans == "0": + error00d += self.cal_shots + else: # ans == "1" + error11d += self.cal_shots + for s in bs: + if s[i] == ans and ans == "0": + error00n += bs[s] + elif s[i] == ans and ans == "1": + error11n += bs[s] + + readout_single = np.array( + [ + [error00n / error00d, 1 - error11n / error11d], + [1 - error00n / error00d, error11n / error11d], + ] + ) + self.single_qubit_cals[i] = readout_single # type: ignore elif method == "global": self.local = False # type: ignore diff --git a/tests/test_results.py b/tests/test_results.py index 5221cf5e..8a8aa036 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -94,6 +94,16 @@ def test_readout(): assert counts.kl_divergence(mit_countg, mit_countl) < 0.05 +def test_readout_masks(): + mit = ReadoutMit(execute=run) + mit.cals_from_system( + [1, 2, 4], shots=8192, method="local", masks=["01010", "10101", "11111"] + ) + np.testing.assert_allclose( + mit.single_qubit_cals[1][0, 0], 0.02 * np.sin(2) + 0.978, atol=1e-3 + ) + + def test_readout_expv(): nqubit = 4 From eb39e56c55a56b955abd72df2a0d469a22f4e60c Mon Sep 17 00:00:00 2001 From: weitang li Date: Fri, 6 Jan 2023 14:59:45 +0800 Subject: [PATCH 151/725] fix qiskit instruction translation --- tensorcircuit/abstractcircuit.py | 14 +++++++++++++- tensorcircuit/translation.py | 14 +++++++++++--- tests/test_circuit.py | 10 ++++++++++ 3 files changed, 34 insertions(+), 4 deletions(-) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 8f60a397..0c4623e5 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -872,7 +872,9 @@ def prepend(self, c: "AbstractCircuit") -> "AbstractCircuit": self.__dict__.update(newc.__dict__) return self - def append(self, c: "AbstractCircuit") -> "AbstractCircuit": + def append( + self, c: "AbstractCircuit", indices: Optional[List[int]] = None + ) -> "AbstractCircuit": """ append circuit ``c`` before @@ -894,11 +896,21 @@ def append(self, c: "AbstractCircuit") -> "AbstractCircuit": :param c: The other circuit to be appended :type c: BaseCircuit + :param indices: the qubit indices to which ``c`` is appended on + :type indices: List[int] :return: The composed circuit :rtype: BaseCircuit """ qir1 = self.to_qir() qir2 = c.to_qir() + if indices is not None: + qir2_old = qir2 + qir2 = [] + for d in qir2_old: + # avoid modifying the original circuit + d = d.copy() + d["index"] = [indices[i] for i in d["index"]] + qir2.append(d) newc = type(self).from_qir(qir1 + qir2, self.circuit_param) self.__dict__.update(newc.__dict__) return self diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 3fb54819..191fa9c3 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -308,8 +308,6 @@ def qiskit2tc( tc_circuit.multicontrol( *idx, ctrl=ctrl_state, unitary=gates._x_matrix, name="x" ) - elif gate_name == "barrier": - pass elif gate_name[:3] == "mcx": if gate_name[3:] == "": tc_circuit.multicontrol( @@ -320,7 +318,7 @@ def qiskit2tc( tc_circuit.multicontrol( *idx, ctrl=ctrl_state, unitary=gates._x_matrix, name="x" ) - elif gate_name[0] == "c": + elif gate_name[0] == "c" and gate_name[:7] != "circuit": for i in range(1, len(gate_name)): if (gate_name[-i] == "o") & (gate_name[-i - 1] == "_"): break @@ -350,6 +348,16 @@ def qiskit2tc( # logger.warning( # "qiskit to tc translation currently doesn't support reset instruction, just skipping" # ) + elif not hasattr(gate_info[0], "__array__"): + # an instruction containing a lot of gates. + # the condition is based on + # https://github.com/Qiskit/qiskit-terra/blob/2f5944d60140ceb6e30d5b891e8ffec735247ce9/qiskit/circuit/gate.py#L43 + qiskit_circuit = gate_info[0].definition + if qiskit_circuit is None: + # handles barrier + continue + c = Circuit.from_qiskit(qiskit_circuit) + tc_circuit.append(c, idx) else: # unitary gate idx_inverse = (x for x in idx[::-1]) tc_circuit.any(*idx_inverse, unitary=gate_info[0].to_matrix()) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index e620222f..9d34fe9d 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -795,6 +795,12 @@ def test_append_circuit(backend): c.prepend(c1) np.testing.assert_allclose(c.expectation_ps(z=[1]), -1.0) + c = tc.Circuit(2) + c1 = tc.Circuit(1) + c1.x(0) + c.append(c1, [1]) + np.testing.assert_allclose(c.state(), [0, 1, 0, 0]) + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_apply_mpo_gate(backend): @@ -974,6 +980,10 @@ def test_qiskit2tc(): qisc.swap(0, 1) qisc.iswap(0, 1) qisc.toffoli(0, 1, 2) + # test Instructions + qisc2 = QuantumCircuit(1) + qisc2.h(0) + qisc.compose(qisc2, qubits=[1], inplace=True, wrap=True) qisc.barrier(0, 1, 2) qisc.s(1) qisc.t(1) From a064dd06ac0549f20499eea46488116b9327cef0 Mon Sep 17 00:00:00 2001 From: weitang li Date: Fri, 6 Jan 2023 17:42:15 +0800 Subject: [PATCH 152/725] support barrier instruction --- tensorcircuit/abstractcircuit.py | 22 ++++++++++++++++++++-- tensorcircuit/translation.py | 12 +++++++++--- tests/test_circuit.py | 4 ++++ 3 files changed, 33 insertions(+), 5 deletions(-) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 0c4623e5..42f98c75 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -535,6 +535,23 @@ def reset_instruction(self, index: int) -> None: } self._extra_qir.append(d) + def barrier_instruction(self, *index: List[int]) -> None: + """ + add a barrier instruction flag, no effect on numerical simulation + + :param index: the corresponding qubits + :type index: List[int] + """ + l = len(self._qir) + d = { + "index": index, + "name": "barrier", + "gatef": "barrier", + "instruction": True, + "pos": l, + } + self._extra_qir.append(d) + def to_qiskit(self, enable_instruction: bool = False) -> Any: """ Translate ``tc.Circuit`` to a qiskit QuantumCircuit object. @@ -896,8 +913,9 @@ def append( :param c: The other circuit to be appended :type c: BaseCircuit - :param indices: the qubit indices to which ``c`` is appended on - :type indices: List[int] + :param indices: the qubit indices to which ``c`` is appended on. + Defaults to None, which means plain concatenation. + :type indices: Optional[List[int]], optional :return: The composed circuit :rtype: BaseCircuit """ diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 191fa9c3..1a1823b3 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -147,7 +147,7 @@ def qir2qiskit( _get_float(parameters, "theta"), _get_float(parameters, "phi"), _get_float(parameters, "lbd"), - *index + *index, ) elif gate_name == "cu": getattr(qiskit_circ, "cu")( @@ -155,7 +155,7 @@ def qir2qiskit( _get_float(parameters, "phi"), _get_float(parameters, "lbd"), 0, # gamma - *index + *index, ) elif gate_name == "iswap": qiskit_circ.append( @@ -197,6 +197,8 @@ def qir2qiskit( qiskit_circ.measure(index, index) elif gate_name == "reset": qiskit_circ.reset(index) + elif gate_name == "barrier": + qiskit_circ.barrier(index) else: # r cr any gate gatem = np.reshape( backend.numpy(gate_info["gatef"](**parameters).tensor), @@ -348,13 +350,17 @@ def qiskit2tc( # logger.warning( # "qiskit to tc translation currently doesn't support reset instruction, just skipping" # ) + elif gate_name == "barrier": + tc_circuit.barrier_instruction(*idx) elif not hasattr(gate_info[0], "__array__"): # an instruction containing a lot of gates. # the condition is based on # https://github.com/Qiskit/qiskit-terra/blob/2f5944d60140ceb6e30d5b891e8ffec735247ce9/qiskit/circuit/gate.py#L43 qiskit_circuit = gate_info[0].definition if qiskit_circuit is None: - # handles barrier + logger.warning( + f"qiskit to tc translation doesn't support {gate_name} instruction, skipping" + ) continue c = Circuit.from_qiskit(qiskit_circuit) tc_circuit.append(c, idx) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 9d34fe9d..1c3f9e50 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1023,6 +1023,10 @@ def test_qiskit2tc(): qis_unitary = np.reshape(qis_unitary, [2**n, 2**n]) p_mat = perm_matrix(n) np.testing.assert_allclose(p_mat @ tc_unitary @ p_mat, qis_unitary, atol=1e-5) + qisc_from_tc = c.to_qiskit(enable_instruction=True) + qis_unitary2 = qi.Operator(qisc_from_tc) + qis_unitary2 = np.reshape(qis_unitary2, [2**n, 2**n]) + np.testing.assert_allclose(qis_unitary2, qis_unitary, atol=1e-5) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) From 25013d7db8ca5f6e09ac093714ca945d629a2b7f Mon Sep 17 00:00:00 2001 From: weitang li Date: Mon, 9 Jan 2023 10:56:40 +0800 Subject: [PATCH 153/725] unpack barrier arguments --- tensorcircuit/translation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 1a1823b3..289f83a8 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -198,7 +198,7 @@ def qir2qiskit( elif gate_name == "reset": qiskit_circ.reset(index) elif gate_name == "barrier": - qiskit_circ.barrier(index) + qiskit_circ.barrier(*index) else: # r cr any gate gatem = np.reshape( backend.numpy(gate_info["gatef"](**parameters).tensor), From 405cd9864392d29d39bcd132c7b648efe52ad637 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 9 Jan 2023 11:30:46 +0800 Subject: [PATCH 154/725] update cloud sdk --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 236 ++++++++++++++++++---- tensorcircuit/cloud/tencent.py | 5 +- 2 files changed, 200 insertions(+), 41 deletions(-) diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb index c7e3ef0e..444b6028 100644 --- a/docs/source/tutorials/tc_qcloud_sdk.ipynb +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -5,7 +5,7 @@ "id": "38c73e8c", "metadata": {}, "source": [ - "# tensorcircuit SDK for QCloud（221230 ver）" + "# tensorcircuit SDK for QCloud（230109 ver）" ] }, { @@ -122,6 +122,14 @@ "t.results(blocked=True)" ] }, + { + "cell_type": "markdown", + "id": "fab152bb", + "metadata": {}, + "source": [ + "``blocked=True`` can wait until the task is finished or failed (rasing an error)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -151,8 +159,17 @@ "source": [ "# resubmit a job\n", "t1 = t.resubmit()\n", - "print(t1.details())\n", - "t1.results(blocked=True)" + "t1.details(blocked=True, prettify=True)" + ] + }, + { + "cell_type": "markdown", + "id": "e227f48a", + "metadata": {}, + "source": [ + "``t.details`` can also permit the ``blocked=True`` option, which waits until the task is finished or failed (no error raised).\n", + "\n", + "Also note by using ``prettfiy=True`` option, we have python datatime object for the timestamp which is easy to read but hard for io (not directly json serializable anymore) " ] }, { @@ -215,6 +232,27 @@ "t.details()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "510f8d82", + "metadata": {}, + "outputs": [], + "source": [ + "id_ = tl[0].__str__()\n", + "print(id_.split(\"~~\")[1])\n", + "t = apis.get_task(id_)\n", + "t.details()" + ] + }, + { + "cell_type": "markdown", + "id": "2e359725", + "metadata": {}, + "source": [ + "The task can indexed either with device information or not (as long as we use ``set_provider``)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -222,7 +260,7 @@ "metadata": {}, "outputs": [], "source": [ - "# back to tencent server by\n", + "# back to tencent server for demonstration below\n", "apis.set_provider(\"tencent\")" ] }, @@ -258,6 +296,14 @@ "# the default behavior is blocked=False, where only one query is made and raise error when the task is incomplete" ] }, + { + "cell_type": "markdown", + "id": "80b617b4", + "metadata": {}, + "source": [ + "In the below, we use tensorcircuit builtin powerful tool for readout mitigation: ``tc.results.readout_mitigation.ReadoutMit``, it supports various method for calibriation and mitigation" + ] + }, { "cell_type": "code", "execution_count": null, @@ -271,6 +317,15 @@ "miti_count = mit.apply_correction(raw_count, nqubit, \"square\")" ] }, + { + "cell_type": "markdown", + "id": "07cacbed", + "metadata": {}, + "source": [ + "By attaching ``?o=0`` after the device string, we have the same effect of setting ``enable_qos_qubit_mapping=False`` (o=1)\n", + "and ``enable_qos_gate_decomposition=False`` (o=2), and both of them of by default True (o=3)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -280,7 +335,7 @@ "source": [ "raw_count = tc.results.counts.marginal_count(raw_count, [8, 4, 0, 2, 6])\n", "miti_count = tc.results.counts.marginal_count(miti_count, [8, 4, 0, 2, 6])\n", - "# only keep the result for qubit 8, 4, 0, 2, 6 and in that order" + "# only keep the result for qubit 8, 4, 0, 2, 6 and in that exact order" ] }, { @@ -303,6 +358,8 @@ "outputs": [], "source": [ "ideal_count = tc.results.counts.vec2count(c.probability(), prune=True)\n", + "# we can obtain analytic count results by ``c.probability()`` method, and ``vec2count`` with transform the vector as a dict\n", + "\n", "ideal_count = tc.results.counts.marginal_count(ideal_count, [8, 4, 0, 2, 6])\n", "tc.results.counts.kl_divergence(\n", " ideal_count, raw_count\n", @@ -323,6 +380,14 @@ " print(m)" ] }, + { + "cell_type": "markdown", + "id": "f13baa43", + "metadata": {}, + "source": [ + "batch submission is possible with multiple circuits in a list and the return is a list of task, respectively" + ] + }, { "cell_type": "code", "execution_count": null, @@ -330,7 +395,7 @@ "metadata": {}, "outputs": [], "source": [ - "# we can also do batch submission\n", + "# we can also do a batch submission for the real hardware chip, simply by provide a circuit list\n", "\n", "c = tc.Circuit(2)\n", "c.h(0)\n", @@ -351,7 +416,7 @@ "source": [ "## three approaches for measure on partial of the qubits\n", "\n", - "Note the return order is not according to the original qubit order instead of measure order in the instructions" + "Note the return order should ideally follow the measure order in the instructions (wait to be fixed both on simulator backend and on the return from the real chips, can skip this section for now)" ] }, { @@ -367,15 +432,10 @@ "nqubit = 9\n", "shots = 4096\n", "c = tc.Circuit(nqubit)\n", - "c.H(8)\n", - "c.cnot(8, 4)\n", - "c.cnot(4, 0)\n", - "c.cnot(0, 2)\n", - "c.cnot(2, 6)\n", + "c.x(8)\n", + "c.x(6)\n", "\n", - "t = apis.submit_task(\n", - " circuit=c, shots=shots, device=\"9gmon?o=0\", measure=[8, 4, 0, 2, 6]\n", - ")\n", + "t = apis.submit_task(circuit=c, shots=shots, device=\"9gmon?o=0\", measure=[8, 2, 6])\n", "print(t.results(blocked=True))" ] }, @@ -392,14 +452,9 @@ "from qiskit.circuit import QuantumCircuit\n", "\n", "qc = QuantumCircuit(9, 9)\n", - "qc.h(8)\n", - "qc.cnot(8, 4)\n", - "qc.cnot(4, 0)\n", - "qc.cnot(0, 2)\n", - "qc.cnot(2, 6)\n", + "qc.x(8)\n", + "qc.x(6)\n", "qc.measure(8, 8)\n", - "qc.measure(4, 4)\n", - "qc.measure(0, 0)\n", "qc.measure(2, 2)\n", "qc.measure(6, 6)\n", "\n", @@ -412,7 +467,7 @@ "id": "7ea3ea0f", "metadata": {}, "source": [ - " The above case also indicate that our ``submit_task`` API directly support Qiskit ``QuantumCircuit`` object" + " The above case also indicates that tc ``submit_task`` API directly support Qiskit ``QuantumCircuit`` object" ] }, { @@ -424,19 +479,14 @@ "source": [ "# directly partial measure\n", "\n", - "# approach 3\n", + "# approach 3, recommended approach\n", "\n", "nqubit = 9\n", "shots = 4096\n", "c = tc.Circuit(nqubit)\n", - "c.H(8)\n", - "c.cnot(8, 4)\n", - "c.cnot(4, 0)\n", - "c.cnot(0, 2)\n", - "c.cnot(2, 6)\n", + "c.x(8)\n", + "c.x(6)\n", "c.measure_instruction(8)\n", - "c.measure_instruction(4)\n", - "c.measure_instruction(0)\n", "c.measure_instruction(2)\n", "c.measure_instruction(6)\n", "\n", @@ -444,6 +494,56 @@ "print(t.results(blocked=True))" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f9a47c6", + "metadata": {}, + "outputs": [], + "source": [ + "# partial measurment also supported via the simulator" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6150317", + "metadata": {}, + "outputs": [], + "source": [ + "nqubit = 9\n", + "shots = 4096\n", + "c = tc.Circuit(nqubit)\n", + "c.x(8)\n", + "c.x(6)\n", + "c.measure_instruction(8)\n", + "c.measure_instruction(2)\n", + "c.measure_instruction(6)\n", + "\n", + "t = apis.submit_task(circuit=c, shots=shots, device=\"simulator:tc\")\n", + "print(t.results(blocked=True))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40bdf80d", + "metadata": {}, + "outputs": [], + "source": [ + "nqubit = 9\n", + "shots = 4096\n", + "c = tc.Circuit(nqubit)\n", + "c.x(8)\n", + "c.x(6)\n", + "c.measure_instruction(8)\n", + "c.measure_instruction(2)\n", + "c.measure_instruction(6)\n", + "\n", + "t = apis.submit_task(circuit=c, shots=shots, device=\"simulator:aer\")\n", + "print(t.results(blocked=True))" + ] + }, { "cell_type": "markdown", "id": "20b8b1d5", @@ -451,7 +551,8 @@ "source": [ "## two level compiling system\n", "\n", - "We provide compiling support at frond end (via tc-qiskit pipeline) and at back end (in qos)" + "We provide compiling support at frond end (via tc-qiskit pipeline) and at back end (in qos).\n", + "The front end option is enabled by ``compiled-True`` (default to False) and also with an optional dict for ``qiskit.transpile`` arguments called ``compiled_options``. The backend qos compiling is controlled by ``enable_qos_qubit_mapping`` and ``enable_qos_gate_decomposition`` (all default to True). The ``?o=int`` str after the device name can overide qos compiling options." ] }, { @@ -556,9 +657,38 @@ "metadata": {}, "outputs": [], "source": [ - "# inspect compiling results from the tc and qos for the task\n", + "# inspect compiling results from the tc and qos for the task, we can directly get the circuit objects from prettified details\n", "\n", - "t.get_compiled_details()" + "c_complied_before_qos = t.details(prettify=True)[\"frontend\"]\n", + "c_complied_after_qos = t.details(prettify=True)[\"backend\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2b4b1e9", + "metadata": {}, + "outputs": [], + "source": [ + "c_complied_before_qos.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1af33b6", + "metadata": {}, + "outputs": [], + "source": [ + "c_complied_after_qos.draw()" + ] + }, + { + "cell_type": "markdown", + "id": "1ad85e14", + "metadata": {}, + "source": [ + "dry run mode to query compiled circuit only from qos (not really sending the circuit to chips), we can use ``qos_dry_run=True`` option\n" ] }, { @@ -568,8 +698,6 @@ "metadata": {}, "outputs": [], "source": [ - "# dry run mode to query compiled circuit only from qos (not really sending the circuit to chips)\n", - "\n", "nqubit = 3\n", "shots = 8192\n", "c = tc.Circuit(nqubit)\n", @@ -598,10 +726,12 @@ "cell_type": "code", "execution_count": null, "id": "e262a682", - "metadata": {}, + "metadata": { + "scrolled": false + }, "outputs": [], "source": [ - "t.get_compiled_details()" + "t.details(prettify=True)[\"backend\"].draw()" ] }, { @@ -652,6 +782,14 @@ "t.results(blocked=True)" ] }, + { + "cell_type": "markdown", + "id": "06281585", + "metadata": {}, + "source": [ + "Simulator device also support batch submission" + ] + }, { "cell_type": "code", "execution_count": null, @@ -707,7 +845,7 @@ "source": [ "## list task and get previous task\n", "\n", - "get history tasks" + "get history tasks and their details" ] }, { @@ -769,8 +907,26 @@ "metadata": {}, "outputs": [], "source": [ - "t.details()" + "t.details(prettify=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a5426c97", + "metadata": {}, + "outputs": [], + "source": [ + "t.results()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b9ea323f", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 65b9beb0..82716c75 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -317,7 +317,10 @@ def get_task_details( if "source" in r: r["frontend"] = Circuit.from_openqasm(r["source"]) if "optimization" in r and r["state"] == "completed": - r["backend"] = eqasm2tc(r["optimization"]["progs"][0]["code"]) + try: + r["backend"] = eqasm2tc(r["optimization"]["progs"][0]["code"]) + except KeyError: + pass return r # type: ignore except KeyError: raise ValueError(dumps(r)) From 95516309f104424c427173502266c49d86a555cc Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 9 Jan 2023 12:04:10 +0800 Subject: [PATCH 155/725] fix relu bug on torch backend --- CHANGELOG.md | 9 +++++++-- tensorcircuit/applications/graphdata.py | 2 +- tensorcircuit/backends/pytorch_backend.py | 2 +- tests/test_backends.py | 13 ++++++------- 4 files changed, 15 insertions(+), 11 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2763847e..167e9571 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,7 +12,10 @@ - Add `enable_instruction` option in `to_qiskit` method that enables measurements in qiskit export -- Add circuit method `measure_instruction` and `reset_instruction` for hardware level instruction flags +- Add circuit method `measure_instruction`, `barrier_instruction` and `reset_instruction` for hardware level + instruction flags + +- Auto unroll composite qiskit instructions when translating to tc circuit ### Fixed @@ -20,7 +23,9 @@ - Fix `sigmoid` bug on pytorch backend -- Ignore ComplexWarning for ``cast`` method on numpy and jax backend +- Fix `relu` bug on pytorch backend + +- Ignore ComplexWarning for `cast` method on numpy and jax backend - Fix `vjp` method bug on tensorflow backend, where none is replaced with zeros diff --git a/tensorcircuit/applications/graphdata.py b/tensorcircuit/applications/graphdata.py index f1b575f3..5dce317f 100644 --- a/tensorcircuit/applications/graphdata.py +++ b/tensorcircuit/applications/graphdata.py @@ -322,7 +322,7 @@ def ensemble_maxcut_solution(g: Graph, samples: int = 100) -> Tuple[float, float r = [] for _ in range(samples): r.append(maxcut_solution_bruteforce(g.send(None))[0]) - return np.mean(r), np.std(r) / np.sqrt(len(r)) + return np.mean(r), np.std(r) / np.sqrt(len(r)) # type: ignore def reduce_edges(g: Graph, m: int = 1) -> Sequence[Graph]: diff --git a/tensorcircuit/backends/pytorch_backend.py b/tensorcircuit/backends/pytorch_backend.py index 52af8b84..481f0b20 100644 --- a/tensorcircuit/backends/pytorch_backend.py +++ b/tensorcircuit/backends/pytorch_backend.py @@ -354,7 +354,7 @@ def sigmoid(self, a: Tensor) -> Tensor: return torchlib.sigmoid(a) def relu(self, a: Tensor) -> Tensor: - return torchlib.nn.ReLU(a) + return torchlib.relu(a) def softmax(self, a: Sequence[Tensor], axis: Optional[int] = None) -> Tensor: return torchlib.nn.Softmax(a, dim=axis) diff --git a/tests/test_backends.py b/tests/test_backends.py index 270b597a..398b705b 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -110,13 +110,6 @@ def test_backend_methods(backend): atol=1e-4, ) - arr = np.random.normal(size=(6, 6)) - np.testing.assert_allclose( - tc.backend.relu(tc.array_to_tensor(arr, dtype="float32")), - np.maximum(arr, 0), - atol=1e-4, - ) - np.testing.assert_allclose( tc.backend.adjoint(tc.array_to_tensor(arr + 1.0j * arr)), arr.T - 1.0j * arr.T, @@ -298,6 +291,12 @@ def test_backend_methods_2(backend): 0.81649658, atol=1e-5, ) + arr = np.random.normal(size=(6, 6)) + np.testing.assert_allclose( + tc.backend.relu(tc.array_to_tensor(arr, dtype="float32")), + np.maximum(arr, 0), + atol=1e-4, + ) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("torchb")]) From 9487405c5d1b41d07954453abb099f38652b35a2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 9 Jan 2023 13:02:36 +0800 Subject: [PATCH 156/725] fix test backend --- tests/test_backends.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/test_backends.py b/tests/test_backends.py index 398b705b..58daeb69 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -110,6 +110,8 @@ def test_backend_methods(backend): atol=1e-4, ) + arr = np.random.normal(size=(6, 6)) + np.testing.assert_allclose( tc.backend.adjoint(tc.array_to_tensor(arr + 1.0j * arr)), arr.T - 1.0j * arr.T, From 5723ca6e2b0e249c5cde0a6421822fc7749f6283 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 9 Jan 2023 13:44:26 +0800 Subject: [PATCH 157/725] relax test atol --- tests/test_results.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_results.py b/tests/test_results.py index 8a8aa036..4b2d4031 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -100,7 +100,7 @@ def test_readout_masks(): [1, 2, 4], shots=8192, method="local", masks=["01010", "10101", "11111"] ) np.testing.assert_allclose( - mit.single_qubit_cals[1][0, 0], 0.02 * np.sin(2) + 0.978, atol=1e-3 + mit.single_qubit_cals[1][0, 0], 0.02 * np.sin(2) + 0.978, atol=1e-2 ) From 9f6d5e359d1b68312f1534c3683a13a541101b4e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 9 Jan 2023 15:17:58 +0800 Subject: [PATCH 158/725] add keep_measure_order option in from_openqasm method --- CHANGELOG.md | 2 ++ tensorcircuit/abstractcircuit.py | 26 ++++++++++++++++++++++---- tensorcircuit/quantum.py | 2 +- tensorcircuit/translation.py | 30 +++++++++++++++++++++++++++++- tests/test_circuit.py | 14 ++++++++++++++ 5 files changed, 68 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 167e9571..6833c652 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,8 @@ - Auto unroll composite qiskit instructions when translating to tc circuit +- Add `keep_measure_order` bool option to `from_openqasm` methods so that the measure instruction order is kept by qiskit + ### Fixed - Fix adjoint possible bug with agnostic backend diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 42f98c75..01070431 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -580,21 +580,39 @@ def to_openqasm(self, **kws: Any) -> str: @classmethod def from_openqasm( - cls, qasmstr: str, circuit_params: Optional[Dict[str, Any]] = None + cls, + qasmstr: str, + circuit_params: Optional[Dict[str, Any]] = None, + keep_measure_order: bool = False, ) -> "AbstractCircuit": from qiskit.circuit import QuantumCircuit - qiskit_circ = QuantumCircuit.from_qasm_str(qasmstr) + if keep_measure_order is True: + from .translation import qiskit_from_qasm_str_ordered_measure + + qiskit_circ = qiskit_from_qasm_str_ordered_measure(qasmstr) + else: + qiskit_circ = QuantumCircuit.from_qasm_str(qasmstr) c = cls.from_qiskit(qiskit_circ, circuit_params=circuit_params) return c @classmethod def from_openqasm_file( - cls, file: str, circuit_params: Optional[Dict[str, Any]] = None + cls, + file: str, + circuit_params: Optional[Dict[str, Any]] = None, + keep_measure_order: bool = False, ) -> "AbstractCircuit": from qiskit.circuit import QuantumCircuit - qiskit_circ = QuantumCircuit.from_qasm_file(file) + if keep_measure_order is True: + from .translation import qiskit_from_qasm_str_ordered_measure + + with open(file) as f: + qasmstr = f.read() + qiskit_circ = qiskit_from_qasm_str_ordered_measure(qasmstr) + else: + qiskit_circ = QuantumCircuit.from_qasm_file(file) c = cls.from_qiskit(qiskit_circ, circuit_params=circuit_params) return c diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 98f070b4..cd92f40f 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1387,7 +1387,7 @@ def ps2coo_core( return tf.SparseTensor(indices=indices, values=values, dense_shape=(s, s)) # type: ignore except (NameError, ImportError): - logger.warning( + logger.info( "tensorflow is not installed, and sparse Hamiltonian generation utilities are disabled" ) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 289f83a8..00eae6c7 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -17,7 +17,7 @@ from qiskit.extensions.exceptions import ExtensionError except ImportError: logger.warning( - "Please first ``pip install -U qiskit`` to enable related functionality" + "Please first ``pip install -U qiskit`` to enable related functionality in translation module" ) from . import gates @@ -508,3 +508,31 @@ def eqasm2tc( getattr(c, gate_name)(*index) return c + + +def qiskit_from_qasm_str_ordered_measure(qasm_str: str) -> Any: + """ + qiskit ``from_qasm_str`` method cannot keep the order of measure as the qasm file, + we provide this alternative function in case the order of measure instruction matters + + :param qasm_str: open qasm str + :type qasm_str: str + :return: ``qiskit.circuit.QuantumCircuit`` + :rtype: Any + """ + measure_sequence = [] + qasm_instruction = [] + for line in qasm_str.split("\n"): + if line.startswith("measure"): + print(line) + index = int(line.split(" ")[1][2:-1]) + cindex = int(line.split(" ")[3].strip(";")[2:-1]) + + measure_sequence.append((index, cindex)) + else: + qasm_instruction.append(line) + + qc = QuantumCircuit.from_qasm_str("\n".join(qasm_instruction)) + for qid, cid in measure_sequence: + qc.measure(qid, cid) + return qc diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 1c3f9e50..4d56955e 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1256,3 +1256,17 @@ def test_to_openqasm(): c.to_openqasm(filename="test.qasm") c2 = tc.Circuit.from_openqasm_file("test.qasm") np.testing.assert_allclose(c.state(), c2.state()) + + +def test_from_qasm_keep_measure_order(): + qasm_str = """OPENQASM 2.0; +include "qelib1.inc"; +qreg q[2]; +creg c[2]; +h q[0]; +measure q[1] -> c[1]; +measure q[0] -> c[0];""" + c = tc.Circuit.from_openqasm(qasm_str) + c.to_openqasm().split("\n")[-2][-3] == "1" + c = tc.Circuit.from_openqasm(qasm_str, keep_measure_order=True) + c.to_openqasm().split("\n")[-2][-3] == "0" From b6f770bcae30d28105593f505033622662d9e29d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 9 Jan 2023 16:10:46 +0800 Subject: [PATCH 159/725] version0.7.0 --- CHANGELOG.md | 2 ++ tensorcircuit/__init__.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6833c652..fced1f89 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.7.0 + ### Added - Add `c.probability()` method to return probability amplitude diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 0a5f4786..2119e20f 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.6.0" +__version__ = "0.7.0" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From af8938e9d6047d67183d7b453b8f115a899680b1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 9 Jan 2023 17:13:52 +0800 Subject: [PATCH 160/725] add initial mapping --- CHANGELOG.md | 4 +++ tensorcircuit/abstractcircuit.py | 52 ++++++++++++++++++++++++++++++-- tensorcircuit/translation.py | 16 ++++++++-- tests/test_circuit.py | 28 +++++++++++++++++ 4 files changed, 96 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fced1f89..d3d711b9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Added + +- Add `initial_mapping` circuit method to return a new circuit with the `logical_physical_mapping` + ## 0.7.0 ### Added diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 01070431..af685e62 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -4,6 +4,7 @@ # pylint: disable=invalid-name from typing import Any, Callable, Dict, List, Optional, Sequence, Union, Tuple +from copy import deepcopy from functools import reduce from operator import add import json @@ -438,6 +439,53 @@ def append_from_qir(self, qir: List[Dict[str, Any]]) -> None: """ self._apply_qir(self, qir) + def initial_mapping( + self, + logical_physical_mapping: Dict[int, int], + n: Optional[int] = None, + circuit_params: Optional[Dict[str, Any]] = None, + ) -> "AbstractCircuit": + """ + generate a new circuit with the qubit mapping given by ``logical_physical_mapping`` + + :param logical_physical_mapping: how to map logical qubits to the physical qubits on the new circuit + :type logical_physical_mapping: Dict[int, int] + :param n: number of qubit of the new circuit, can be different from the original one, defaults to None + :type n: Optional[int], optional + :param circuit_params: _description_, defaults to None + :type circuit_params: Optional[Dict[str, Any]], optional + :return: _description_ + :rtype: AbstractCircuit + """ + if circuit_params is None: + circuit_params = {} + if "nqubits" not in circuit_params: + if n is not None: + circuit_params["nqubits"] = n + else: + circuit_params["nqubits"] = self._nqubits + + c = type(self)(**circuit_params) + + for d in self.to_qir(): + mapped_index = [logical_physical_mapping[i] for i in d["index"]] + + if "parameters" not in d: + c.apply_general_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( + c, *mapped_index, split=d["split"] + ) + else: + c.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *mapped_index, **d["parameters"], split=d["split"]) + for d in self._extra_qir: + mapped_index = [logical_physical_mapping[i] for i in d["index"]] + dc = deepcopy(d) + dc["index"] = mapped_index + c._extra_qir.append(dc) + + return c + @staticmethod def standardize_gate(name: str) -> str: """ @@ -510,7 +558,7 @@ def measure_instruction(self, index: int) -> None: """ l = len(self._qir) d = { - "index": index, + "index": [index], "name": "measure", "gatef": "measure", "instruction": True, @@ -527,7 +575,7 @@ def reset_instruction(self, index: int) -> None: """ l = len(self._qir) d = { - "index": index, + "index": [index], "name": "reset", "gatef": "reset", "instruction": True, diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 00eae6c7..d07aa645 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -194,9 +194,9 @@ def qir2qiskit( ) qiskit_circ.unitary(qop, index[::-1], label=qis_name) elif gate_name == "measure": - qiskit_circ.measure(index, index) + qiskit_circ.measure(index[0], index[0]) elif gate_name == "reset": - qiskit_circ.reset(index) + qiskit_circ.reset(index[0]) elif gate_name == "barrier": qiskit_circ.barrier(*index) else: # r cr any gate @@ -484,6 +484,18 @@ def json2qir(tcqasm: List[Dict[str, Any]]) -> List[Dict[str, Any]]: def eqasm2tc( eqasm: str, nqubits: Optional[int] = None, headers: Tuple[int, int] = (6, 1) ) -> Circuit: + """ + Translation qexe/eqasm instruction to tensorcircuit Circuit object + + :param eqasm: _description_ + :type eqasm: str + :param nqubits: _description_, defaults to None + :type nqubits: Optional[int], optional + :param headers: lines of ignored code at the head and the tail, defaults to (6, 1) + :type headers: Tuple[int, int], optional + :return: _description_ + :rtype: Circuit + """ eqasm_list = eqasm.split("\n") if nqubits is None: nqubits = len(eqasm_list[2].split(",")) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 4d56955e..59cfae04 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1270,3 +1270,31 @@ def test_from_qasm_keep_measure_order(): c.to_openqasm().split("\n")[-2][-3] == "1" c = tc.Circuit.from_openqasm(qasm_str, keep_measure_order=True) c.to_openqasm().split("\n")[-2][-3] == "0" + + +def test_initial_mapping(): + c = tc.Circuit(3) + c.cnot(0, 1) + c.h(1) + c.rx(1, theta=0.5) + c.cz(2, 1) + c.measure_instruction(2) + + c1 = c.initial_mapping({0: 1, 1: 2, 2: 0}) + print(c1.draw()) + + np.testing.assert_allclose( + c.expectation_ps(z=[1]), c1.expectation_ps(z=[2]), atol=1e-5 + ) + assert c1._extra_qir[0]["index"][0] == 0 + + c2 = c1.initial_mapping({1: 0, 2: 1, 0: 2}) + np.testing.assert_allclose( + c.expectation_ps(z=[1]), c2.expectation_ps(z=[1]), atol=1e-5 + ) + + c3 = c.initial_mapping({0: 2, 1: 7, 2: 0}, n=9) + np.testing.assert_allclose( + c.expectation_ps(z=[1]), c3.expectation_ps(z=[7]), atol=1e-5 + ) + print(c3.draw()) From 49ba05eed5bbdbcc31653d4bab0c6a6629065d50 Mon Sep 17 00:00:00 2001 From: weitang li Date: Mon, 9 Jan 2023 19:16:54 +0800 Subject: [PATCH 161/725] support converting parameterized qiskit circuit --- requirements/requirements-extra.txt | 3 +- tensorcircuit/abstractcircuit.py | 9 ++++- tensorcircuit/translation.py | 54 +++++++++++++++++++++++++++-- tests/test_circuit.py | 44 +++++++++++++++++++++++ 4 files changed, 105 insertions(+), 5 deletions(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 8a0cda90..0e2b5cf6 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,4 +1,5 @@ # extra dependencies for ci qiskit +qiskit-nature torch -jupyter \ No newline at end of file +jupyter diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index af685e62..ff8bd8a0 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -692,6 +692,7 @@ def from_qiskit( n: Optional[int] = None, inputs: Optional[List[float]] = None, circuit_params: Optional[Dict[str, Any]] = None, + binding_params: Optional[Union[Sequence, Dict]] = None, ) -> "AbstractCircuit": """ Import Qiskit QuantumCircuit object as a ``tc.Circuit`` object. @@ -711,6 +712,12 @@ def from_qiskit( :type n: int :param inputs: possible input wavefunction for ``tc.Circuit``, defaults to None :type inputs: Optional[List[float]], optional + :param circuit_params: circuit attributes such as the number of qubits + :type circuit_params: Optional[Dict[str, Any]] + :param binding_params: (variational) parameters for the circuit. + Could be either a sequence or dictionary depending on the type of parameters in the Qiskit circuit. + For ``ParameterVectorElement`` use sequence. For ``Parameter`` use dictionary + :type binding_params: Optional[Union[Sequence, Dict]] :return: The same circuit but as tensorcircuit object :rtype: Circuit """ @@ -719,7 +726,7 @@ def from_qiskit( if n is None: n = qc.num_qubits - return qiskit2tc(qc.data, n, inputs, is_dm=cls.is_dm, circuit_params=circuit_params) # type: ignore + return qiskit2tc(qc.data, n, inputs, is_dm=cls.is_dm, circuit_params=circuit_params, binding_params=binding_params) # type: ignore def vis_tex(self, **kws: Any) -> str: """ diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index d07aa645..fd239cb6 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -2,7 +2,7 @@ Circuit object translation in different packages """ -from typing import Any, Dict, List, Optional, Tuple +from typing import Any, Dict, List, Optional, Tuple, Union, Sequence from copy import deepcopy import logging import numpy as np @@ -219,6 +219,47 @@ def qir2qiskit( return qiskit_circ +def _translate_qiskit_params(gate_info, binding_params): + parameters = [] + for p in gate_info[0].params: + from qiskit.circuit.parametervector import ParameterVectorElement + from qiskit.circuit import Parameter, ParameterExpression + + if isinstance(p, ParameterVectorElement): + parameters.append(binding_params[p.index]) + elif isinstance(p, Parameter): + parameters.append(binding_params[p]) + elif isinstance(p, ParameterExpression): + if len(p.parameters) != 1: + raise ValueError( + f"Can't translate parameter expression with more than 1 parameters: {p}" + ) + p_real = list(p.parameters)[0] + if not isinstance(p_real, ParameterVectorElement): + raise TypeError( + "Parameters in parameter expression should be ParameterVectorElement" + ) + # note "sym" != "sim" + expr = p.sympify().simplify() + # only allow simple expressions like 1.0 * theta + if not expr.is_Mul: + raise ValueError(f"Unsupported parameter expression: {p}") + arg1, arg2 = expr.args + if arg1.is_number and arg2.is_symbol: + coeff = arg1 + elif arg1.is_symbol and arg2.is_number: + coeff = arg2 + else: + raise ValueError(f"Unsupported parameter expression: {p}") + # taking real part here because using complex type will result in a type error + # for tf backend when the binding parameter is real + parameters.append(float(coeff) * binding_params[p_real.index]) + else: + # numbers, arrays, etc. + parameters.append(p) + return parameters + + def ctrl_str2ctrl_state(ctrl_str: str, nctrl: int) -> List[int]: ctrl_state_bin = int(ctrl_str) return [0x1 & (ctrl_state_bin >> (i)) for i in range(nctrl)] @@ -230,6 +271,7 @@ def qiskit2tc( inputs: Optional[List[float]] = None, is_dm: bool = False, circuit_params: Optional[Dict[str, Any]] = None, + binding_params: Optional[Union[Sequence, Dict]] = None, ) -> Any: r""" Generate a tensorcircuit circuit using the quantum circuit data in qiskit. @@ -249,6 +291,12 @@ def qiskit2tc( :type n: int :param inputs: Input state of the circuit. Default is None. :type inputs: Optional[List[float]] + :param circuit_params: circuit attributes such as the number of qubits + :type circuit_params: Optional[Dict[str, Any]] + :param binding_params: (variational) parameters for the circuit. + Could be either a sequence or dictionary depending on the type of parameters in the Qiskit circuit. + For ``ParameterVectorElement`` use sequence. For ``Parameter`` use dictionary + :type binding_params: Optional[Union[Sequence, Dict]] :return: A quantum circuit in tensorcircuit :rtype: Any """ @@ -267,7 +315,7 @@ def qiskit2tc( for gate_info in qcdata: idx = [qb.index for qb in gate_info[1]] gate_name = gate_info[0].name - parameters = gate_info[0].params + parameters = _translate_qiskit_params(gate_info, binding_params) if gate_name in [ "h", "x", @@ -362,7 +410,7 @@ def qiskit2tc( f"qiskit to tc translation doesn't support {gate_name} instruction, skipping" ) continue - c = Circuit.from_qiskit(qiskit_circuit) + c = Circuit.from_qiskit(qiskit_circuit, binding_params=binding_params) tc_circuit.append(c, idx) else: # unitary gate idx_inverse = (x for x in idx[::-1]) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 59cfae04..01be265c 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1029,6 +1029,50 @@ def test_qiskit2tc(): np.testing.assert_allclose(qis_unitary2, qis_unitary, atol=1e-5) +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_qiskit2tc_parameterized(backend): + try: + from qiskit.circuit import QuantumCircuit, Parameter + from qiskit.quantum_info import Statevector, Operator + from qiskit.circuit.library import TwoLocal + from qiskit_nature.second_q.circuit.library import UCCSD + from qiskit_nature.second_q.mappers import ParityMapper, QubitConverter + except ImportError: + pytest.skip("qiskit or qiskit-nature is not installed") + from tensorcircuit.translation import perm_matrix + + mapper = ParityMapper() + converter = QubitConverter(mapper=mapper, two_qubit_reduction=True) + ansatz1 = UCCSD(2, [1, 1], converter) + ansatz2 = TwoLocal(2, rotation_blocks="ry", entanglement_blocks="cz") + ansatz3 = QuantumCircuit(1) + ansatz3_param = Parameter("θ") + ansatz3.rx(ansatz3_param, 0) + ansatz_list = [ansatz1, ansatz2, ansatz3] + for ansatz in ansatz_list: + n = ansatz.num_qubits + if ansatz in [ansatz1, ansatz2]: + params = np.random.rand(ansatz.num_parameters) + else: + params = {ansatz3_param: 0.618} + qisc = ansatz.assign_parameters(params) + qiskit_unitary = Operator(qisc) + qiskit_unitary = np.reshape(qiskit_unitary, [2**n, 2**n]) + + @tc.backend.jit + def get_unitary(_params): + return tc.Circuit.from_qiskit( + ansatz, inputs=np.eye(2**n), binding_params=_params + ).state() + + tc_unitary = get_unitary(params) + tc_unitary = np.reshape(tc_unitary, [2**n, 2**n]) + p_mat = perm_matrix(n) + np.testing.assert_allclose( + p_mat @ tc_unitary @ p_mat, qiskit_unitary, atol=1e-5 + ) + + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_batch_sample(backend): c = tc.Circuit(3) From 5e3454cf29740bf9df6b3d37d6b8483251494f77 Mon Sep 17 00:00:00 2001 From: weitang li Date: Tue, 10 Jan 2023 11:11:11 +0800 Subject: [PATCH 162/725] fix mypy and document --- CHANGELOG.md | 2 ++ docs/source/quickstart.rst | 4 +++- tensorcircuit/abstractcircuit.py | 6 +++--- tensorcircuit/translation.py | 19 +++++++++++-------- 4 files changed, 19 insertions(+), 12 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d3d711b9..dfc2587a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,6 +23,8 @@ - Auto unroll composite qiskit instructions when translating to tc circuit +- Add `binding_parameters` argument for translating parameterized qiskit circuit to tc circuit + - Add `keep_measure_order` bool option to `from_openqasm` methods so that the measure instruction order is kept by qiskit ### Fixed diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index adac2bf4..3251bb6b 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -81,7 +81,9 @@ We currently support transform ``tc.Circuit`` from and to Qiskit ``QuantumCircui Export to Qiskit (possible for further hardware experiment, compiling, and visualization): ``c.to_qiskit()``. -Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)`` +Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``. +Parameterized Qiskit circuit is supported by passing the parameters to the ``from_qiskit`` function, +similar to the ``assign_parameters`` function in Qiskit. **Circuit Visualization:** diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index ff8bd8a0..3a46cb18 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -692,7 +692,7 @@ def from_qiskit( n: Optional[int] = None, inputs: Optional[List[float]] = None, circuit_params: Optional[Dict[str, Any]] = None, - binding_params: Optional[Union[Sequence, Dict]] = None, + binding_params: Optional[Union[Sequence[float], Dict[Any, float]]] = None, ) -> "AbstractCircuit": """ Import Qiskit QuantumCircuit object as a ``tc.Circuit`` object. @@ -712,12 +712,12 @@ def from_qiskit( :type n: int :param inputs: possible input wavefunction for ``tc.Circuit``, defaults to None :type inputs: Optional[List[float]], optional - :param circuit_params: circuit attributes such as the number of qubits + :param circuit_params: kwargs given in Circuit.__init__ construction function, default to None. :type circuit_params: Optional[Dict[str, Any]] :param binding_params: (variational) parameters for the circuit. Could be either a sequence or dictionary depending on the type of parameters in the Qiskit circuit. For ``ParameterVectorElement`` use sequence. For ``Parameter`` use dictionary - :type binding_params: Optional[Union[Sequence, Dict]] + :type binding_params: Optional[Union[Sequence[float], Dict[Any, float]]] :return: The same circuit but as tensorcircuit object :rtype: Circuit """ diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index fd239cb6..7b6f110b 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -15,6 +15,9 @@ from qiskit.circuit.library import XXPlusYYGate import qiskit.quantum_info as qi from qiskit.extensions.exceptions import ExtensionError + from qiskit.circuit.quantumcircuitdata import CircuitInstruction + from qiskit.circuit.parametervector import ParameterVectorElement + from qiskit.circuit import Parameter, ParameterExpression except ImportError: logger.warning( "Please first ``pip install -U qiskit`` to enable related functionality in translation module" @@ -219,11 +222,11 @@ def qir2qiskit( return qiskit_circ -def _translate_qiskit_params(gate_info, binding_params): +def _translate_qiskit_params( + gate_info: CircuitInstruction, binding_params: Any +) -> List[float]: parameters = [] for p in gate_info[0].params: - from qiskit.circuit.parametervector import ParameterVectorElement - from qiskit.circuit import Parameter, ParameterExpression if isinstance(p, ParameterVectorElement): parameters.append(binding_params[p.index]) @@ -266,12 +269,12 @@ def ctrl_str2ctrl_state(ctrl_str: str, nctrl: int) -> List[int]: def qiskit2tc( - qcdata: List[List[Any]], + qcdata: List[CircuitInstruction], n: int, inputs: Optional[List[float]] = None, is_dm: bool = False, circuit_params: Optional[Dict[str, Any]] = None, - binding_params: Optional[Union[Sequence, Dict]] = None, + binding_params: Optional[Union[Sequence[float], Dict[Any, float]]] = None, ) -> Any: r""" Generate a tensorcircuit circuit using the quantum circuit data in qiskit. @@ -286,17 +289,17 @@ def qiskit2tc( h :param qcdata: Quantum circuit data from qiskit. - :type qcdata: List[List[Any]] + :type qcdata: List[CircuitInstruction] :param n: # of qubits :type n: int :param inputs: Input state of the circuit. Default is None. :type inputs: Optional[List[float]] - :param circuit_params: circuit attributes such as the number of qubits + :param circuit_params: kwargs given in Circuit.__init__ construction function, default to None. :type circuit_params: Optional[Dict[str, Any]] :param binding_params: (variational) parameters for the circuit. Could be either a sequence or dictionary depending on the type of parameters in the Qiskit circuit. For ``ParameterVectorElement`` use sequence. For ``Parameter`` use dictionary - :type binding_params: Optional[Union[Sequence, Dict]] + :type binding_params: Optional[Union[Sequence[float], Dict[Any, float]]] :return: A quantum circuit in tensorcircuit :rtype: Any """ From 39dd5c45f85f77faf62288b348e61c10663a4f0d Mon Sep 17 00:00:00 2001 From: weitang li Date: Tue, 10 Jan 2023 12:22:05 +0800 Subject: [PATCH 163/725] add grad test --- docs/source/quickstart.rst | 4 ++-- tensorcircuit/abstractcircuit.py | 10 +++++++++- tests/test_circuit.py | 17 ++++++++++++++++- 3 files changed, 27 insertions(+), 4 deletions(-) diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 3251bb6b..8ff6d6ff 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -82,8 +82,8 @@ We currently support transform ``tc.Circuit`` from and to Qiskit ``QuantumCircui Export to Qiskit (possible for further hardware experiment, compiling, and visualization): ``c.to_qiskit()``. Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``. -Parameterized Qiskit circuit is supported by passing the parameters to the ``from_qiskit`` function, -similar to the ``assign_parameters`` function in Qiskit. +Parameterized Qiskit circuit is supported by passing the parameters to the ``binding_parameters`` argument +of the ``from_qiskit`` function, similar to the ``assign_parameters`` function in Qiskit. **Circuit Visualization:** diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 3a46cb18..de28e547 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -71,6 +71,7 @@ class AbstractCircuit: inputs: Tensor circuit_param: Dict[str, Any] is_mps: bool + is_dm: bool sgates = sgates vgates = vgates @@ -726,7 +727,14 @@ def from_qiskit( if n is None: n = qc.num_qubits - return qiskit2tc(qc.data, n, inputs, is_dm=cls.is_dm, circuit_params=circuit_params, binding_params=binding_params) # type: ignore + return qiskit2tc( # type: ignore + qc.data, + n, + inputs, + is_dm=cls.is_dm, + circuit_params=circuit_params, + binding_params=binding_params, + ) def vis_tex(self, **kws: Any) -> str: """ diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 01be265c..61571be7 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1033,7 +1033,7 @@ def test_qiskit2tc(): def test_qiskit2tc_parameterized(backend): try: from qiskit.circuit import QuantumCircuit, Parameter - from qiskit.quantum_info import Statevector, Operator + from qiskit.quantum_info import Operator from qiskit.circuit.library import TwoLocal from qiskit_nature.second_q.circuit.library import UCCSD from qiskit_nature.second_q.mappers import ParityMapper, QubitConverter @@ -1059,6 +1059,7 @@ def test_qiskit2tc_parameterized(backend): qiskit_unitary = Operator(qisc) qiskit_unitary = np.reshape(qiskit_unitary, [2**n, 2**n]) + # test jit @tc.backend.jit def get_unitary(_params): return tc.Circuit.from_qiskit( @@ -1072,6 +1073,20 @@ def get_unitary(_params): p_mat @ tc_unitary @ p_mat, qiskit_unitary, atol=1e-5 ) + # test grad + def cost_fn(_params): + return tc.backend.real(tc.backend.sum(get_unitary(_params))) + + if ansatz in [ansatz1, ansatz2]: + grad = tc.backend.grad(cost_fn)(tc.backend.convert_to_tensor(params)) + assert np.sum(np.isnan(grad)) == 0 + else: + # tf only supports tf tensor as input + grad = tc.backend.grad(cost_fn)( + {ansatz3_param: tc.backend.convert_to_tensor(0.618)} + ) + assert not np.isnan(grad[ansatz3_param]) + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_batch_sample(backend): From af0b06deed41f67bbbcd02db9ba8aea357ebd70b Mon Sep 17 00:00:00 2001 From: xptree Date: Tue, 10 Jan 2023 16:48:02 +0800 Subject: [PATCH 164/725] third-party OMEinsum contractor example --- examples/circuit_n12_m14_s0_e0_pEFGH.qsim | 481 ++++++++++++++++++++++ examples/omeinsum_contractor.py | 131 ++++++ tensorcircuit/cons.py | 4 +- 3 files changed, 614 insertions(+), 2 deletions(-) create mode 100644 examples/circuit_n12_m14_s0_e0_pEFGH.qsim create mode 100644 examples/omeinsum_contractor.py diff --git a/examples/circuit_n12_m14_s0_e0_pEFGH.qsim b/examples/circuit_n12_m14_s0_e0_pEFGH.qsim new file mode 100644 index 00000000..2be8b29b --- /dev/null +++ b/examples/circuit_n12_m14_s0_e0_pEFGH.qsim @@ -0,0 +1,481 @@ +12 +0 hz_1_2 0 +0 hz_1_2 1 +0 hz_1_2 2 +0 y_1_2 3 +0 hz_1_2 4 +0 y_1_2 5 +0 x_1_2 6 +0 x_1_2 7 +0 x_1_2 8 +0 x_1_2 9 +0 y_1_2 10 +0 hz_1_2 11 +1 rz 1 0.8693959871027742 +1 rz 2 -0.5809728937821895 +1 rz 5 -3.1455232066056915 +1 rz 6 3.5262953599473446 +1 rz 9 -1.0402901334038208 +1 rz 10 1.2704822022121596 +2 fs 1 2 1.5862983338115253 0.5200148508319427 +2 fs 5 6 1.5289739216684795 0.5055240639761313 +2 fs 9 10 1.5346175385256955 0.5131039467233695 +3 rz 1 -2.1118243782923773 +3 rz 2 2.4002474716129623 +3 rz 5 2.510370594218442 +3 rz 6 -2.1295984408767894 +3 rz 9 0.15501230573908462 +3 rz 10 0.07517976306925431 +4 y_1_2 0 +4 x_1_2 1 +4 y_1_2 2 +4 hz_1_2 3 +4 y_1_2 4 +4 hz_1_2 5 +4 y_1_2 6 +4 y_1_2 7 +4 y_1_2 8 +4 hz_1_2 9 +4 hz_1_2 10 +4 y_1_2 11 +5 rz 0 7.95878242287787 +5 rz 1 -7.774843741231972 +5 rz 2 -14.076559546984539 +5 rz 3 14.218497333398785 +5 rz 4 6.7102990377713985 +5 rz 5 -6.8557924692300185 +5 rz 6 -11.869086784143517 +5 rz 7 11.992514358506712 +5 rz 8 2.4540157696942893 +5 rz 9 -2.130087599403273 +5 rz 10 5.854589755013336 +5 rz 11 -6.755719773321365 +6 fs 0 1 1.2947043217999283 0.4859467238431821 +6 fs 2 3 1.541977006124425 0.6073798124875975 +6 fs 4 5 1.5138652502397498 0.47710618607286504 +6 fs 6 7 1.5849169442855044 0.54346233613361 +6 fs 8 9 1.5398075246432927 0.5174515645943538 +6 fs 10 11 1.4593314109380113 0.5230636172671492 +7 rz 0 -7.370403665363804 +7 rz 1 7.554342347009701 +7 rz 2 15.859387461711556 +7 rz 3 -15.71744967529731 +7 rz 4 -8.338843337248123 +7 rz 5 8.193349905789502 +7 rz 6 12.26637631755088 +7 rz 7 -12.142948743187686 +7 rz 8 -4.874679037269875 +7 rz 9 5.198607207560892 +7 rz 10 -5.948000038116973 +7 rz 11 5.046870019808944 +8 x_1_2 0 +8 y_1_2 1 +8 x_1_2 2 +8 y_1_2 3 +8 x_1_2 4 +8 x_1_2 5 +8 x_1_2 6 +8 hz_1_2 7 +8 x_1_2 8 +8 x_1_2 9 +8 x_1_2 10 +8 x_1_2 11 +9 rz 4 -10.300317334985465 +9 rz 8 10.489798112305557 +9 rz 5 -16.935559040199575 +9 rz 9 17.018814476659895 +9 rz 6 -17.65620553132214 +9 rz 10 17.688640528946085 +9 rz 7 13.72138435193195 +9 rz 11 -12.285441868370123 +10 fs 4 8 1.589821065740506 0.5045391214115686 +10 fs 5 9 1.5472406430590444 0.5216932173558055 +10 fs 6 10 1.5124128267683938 0.5133142626030278 +10 fs 7 11 1.5707871303628709 0.5176678491729374 +11 rz 4 9.244163795666879 +11 rz 8 -9.054683018346786 +11 rz 5 14.03202226075948 +11 rz 9 -13.94876682429916 +11 rz 6 14.094665893757096 +11 rz 10 -14.062230896133155 +11 rz 7 -15.384431193528544 +11 rz 11 16.82037367709037 +12 hz_1_2 0 +12 hz_1_2 1 +12 hz_1_2 2 +12 hz_1_2 3 +12 hz_1_2 4 +12 hz_1_2 5 +12 y_1_2 6 +12 y_1_2 7 +12 hz_1_2 8 +12 hz_1_2 9 +12 y_1_2 10 +12 hz_1_2 11 +13 rz 0 39.909529911684075 +13 rz 4 -40.171428733227174 +13 rz 1 38.277959915149545 +13 rz 5 -38.040241149679936 +13 rz 2 11.883270567757798 +13 rz 6 -12.169262658895612 +13 rz 3 14.993690269805821 +13 rz 7 -14.989527131529702 +14 fs 0 4 1.4668587973263782 0.4976074601121169 +14 fs 1 5 1.47511091993527 0.538612093835262 +14 fs 2 6 1.603651215218248 0.46649538437100246 +14 fs 3 7 1.6160334279232749 0.4353897326147861 +15 rz 0 -39.198437626672444 +15 rz 4 38.936538805129345 +15 rz 1 -35.53420813044422 +15 rz 5 35.77192689591383 +15 rz 2 -17.246915283138684 +15 rz 6 16.96092319200087 +15 rz 3 -18.421895502761547 +15 rz 7 18.426058641037667 +16 x_1_2 0 +16 x_1_2 1 +16 y_1_2 2 +16 x_1_2 3 +16 x_1_2 4 +16 x_1_2 5 +16 hz_1_2 6 +16 hz_1_2 7 +16 y_1_2 8 +16 x_1_2 9 +16 x_1_2 10 +16 y_1_2 11 +17 rz 1 16.21293450723508 +17 rz 2 -15.924511413914495 +17 rz 5 -14.76941602488768 +17 rz 6 15.150188178229332 +17 rz 9 -11.269315813491886 +17 rz 10 11.499507882300225 +18 fs 1 2 1.5862983338115253 0.5200148508319427 +18 fs 5 6 1.5289739216684795 0.5055240639761313 +18 fs 9 10 1.5346175385256955 0.5131039467233695 +19 rz 1 -17.455362898424685 +19 rz 2 17.743785991745266 +19 rz 5 14.134263412500427 +19 rz 6 -13.753491259158777 +19 rz 9 10.384037985827149 +19 rz 10 -10.15384591701881 +20 hz_1_2 0 +20 hz_1_2 1 +20 x_1_2 2 +20 y_1_2 3 +20 y_1_2 4 +20 y_1_2 5 +20 y_1_2 6 +20 x_1_2 7 +20 hz_1_2 8 +20 y_1_2 9 +20 y_1_2 10 +20 hz_1_2 11 +21 rz 0 23.76727665574203 +21 rz 1 -23.583337974096132 +21 rz 2 -48.01832657636844 +21 rz 3 48.160264362782684 +21 rz 4 22.053837557903705 +21 rz 5 -22.199330989362323 +21 rz 6 -43.48607524987143 +21 rz 7 43.609502824234625 +21 rz 8 9.42835146066348 +21 rz 9 -9.104423290372464 +21 rz 10 17.47848257329532 +21 rz 11 -18.37961259160335 +22 fs 0 1 1.2947043217999283 0.4859467238431821 +22 fs 2 3 1.541977006124425 0.6073798124875975 +22 fs 4 5 1.5138652502397498 0.47710618607286504 +22 fs 6 7 1.5849169442855044 0.54346233613361 +22 fs 8 9 1.5398075246432927 0.5174515645943538 +22 fs 10 11 1.4593314109380113 0.5230636172671492 +23 rz 0 -23.178897898227966 +23 rz 1 23.362836579873864 +23 rz 2 49.801154491095446 +23 rz 3 -49.6592167046812 +23 rz 4 -23.682381857380427 +23 rz 5 23.53688842592181 +23 rz 6 43.88336478327879 +23 rz 7 -43.7599372089156 +23 rz 8 -11.849014728239068 +23 rz 9 12.172942898530083 +23 rz 10 -17.571892856398957 +23 rz 11 16.670762838090926 +24 x_1_2 0 +24 x_1_2 1 +24 hz_1_2 2 +24 x_1_2 3 +24 x_1_2 4 +24 hz_1_2 5 +24 x_1_2 6 +24 y_1_2 7 +24 x_1_2 8 +24 x_1_2 9 +24 hz_1_2 10 +24 x_1_2 11 +25 rz 4 -25.643855855118186 +25 rz 8 25.833336632438275 +25 rz 5 -40.648300389495404 +25 rz 9 40.73155582595572 +25 rz 6 -39.97407974242405 +25 rz 10 40.00651474004799 +25 rz 7 34.64439142483994 +25 rz 11 -33.20844894127811 +26 fs 4 8 1.589821065740506 0.5045391214115686 +26 fs 5 9 1.5472406430590444 0.5216932173558055 +26 fs 6 10 1.5124128267683938 0.5133142626030278 +26 fs 7 11 1.5707871303628709 0.5176678491729374 +27 rz 4 24.587702315799596 +27 rz 8 -24.398221538479504 +27 rz 5 37.744763610055315 +27 rz 9 -37.661508173594996 +27 rz 6 36.412540104859005 +27 rz 10 -36.38010510723507 +27 rz 7 -36.307438266436534 +27 rz 11 37.743380749998366 +28 hz_1_2 0 +28 hz_1_2 1 +28 y_1_2 2 +28 hz_1_2 3 +28 hz_1_2 4 +28 x_1_2 5 +28 y_1_2 6 +28 x_1_2 7 +28 y_1_2 8 +28 hz_1_2 9 +28 x_1_2 10 +28 hz_1_2 11 +29 rz 0 81.75554405750046 +29 rz 4 -82.01744287904356 +29 rz 1 79.65901834823408 +29 rz 5 -79.42129958276446 +29 rz 2 26.296897662428034 +29 rz 6 -26.58288975356585 +29 rz 3 31.732095928132054 +29 rz 7 -31.727932789855927 +30 fs 0 4 1.4668587973263782 0.4976074601121169 +30 fs 1 5 1.47511091993527 0.538612093835262 +30 fs 2 6 1.603651215218248 0.46649538437100246 +30 fs 3 7 1.6160334279232749 0.4353897326147861 +31 rz 0 -81.04445177248883 +31 rz 4 80.78255295094573 +31 rz 1 -76.91526656352876 +31 rz 5 77.15298532899838 +31 rz 2 -31.660542377808927 +31 rz 6 31.37455028667111 +31 rz 3 -35.16030116108778 +31 rz 7 35.16446429936389 +32 x_1_2 0 +32 x_1_2 1 +32 x_1_2 2 +32 y_1_2 3 +32 y_1_2 4 +32 hz_1_2 5 +32 hz_1_2 6 +32 hz_1_2 7 +32 hz_1_2 8 +32 x_1_2 9 +32 hz_1_2 10 +32 y_1_2 11 +33 rz 1 31.556473027367385 +33 rz 2 -31.268049934046807 +33 rz 5 -26.393308843169667 +33 rz 6 26.774080996511316 +33 rz 9 -21.49834149357995 +33 rz 10 21.728533562388286 +34 fs 1 2 1.5862983338115253 0.5200148508319427 +34 fs 5 6 1.5289739216684795 0.5055240639761313 +34 fs 9 10 1.5346175385256955 0.5131039467233695 +35 rz 1 -32.798901418556994 +35 rz 2 33.08732451187758 +35 rz 5 25.75815623078241 +35 rz 6 -25.37738407744076 +35 rz 9 20.613063665915213 +35 rz 10 -20.382871597106877 +36 y_1_2 0 +36 y_1_2 1 +36 y_1_2 2 +36 x_1_2 3 +36 x_1_2 4 +36 y_1_2 5 +36 y_1_2 6 +36 x_1_2 7 +36 x_1_2 8 +36 hz_1_2 9 +36 y_1_2 10 +36 hz_1_2 11 +37 rz 0 39.57577088860619 +37 rz 1 -39.391832206960295 +37 rz 2 -81.96009360575232 +37 rz 3 82.10203139216657 +37 rz 4 37.39737607803601 +37 rz 5 -37.54286950949463 +37 rz 6 -75.10306371559935 +37 rz 7 75.22649128996255 +37 rz 8 16.402687151632673 +37 rz 9 -16.078758981341654 +37 rz 10 29.102375391577308 +37 rz 11 -30.00350540988534 +38 fs 0 1 1.2947043217999283 0.4859467238431821 +38 fs 2 3 1.541977006124425 0.6073798124875975 +38 fs 4 5 1.5138652502397498 0.47710618607286504 +38 fs 6 7 1.5849169442855044 0.54346233613361 +38 fs 8 9 1.5398075246432927 0.5174515645943538 +38 fs 10 11 1.4593314109380113 0.5230636172671492 +39 rz 0 -38.98739213109213 +39 rz 1 39.17133081273803 +39 rz 2 83.74292152047934 +39 rz 3 -83.6009837340651 +39 rz 4 -39.025920377512726 +39 rz 5 38.88042694605411 +39 rz 6 75.50035324900671 +39 rz 7 -75.3769256746435 +39 rz 8 -18.823350419208257 +39 rz 9 19.147278589499276 +39 rz 10 -29.19578567468094 +39 rz 11 28.294655656372914 +40 hz_1_2 0 +40 x_1_2 1 +40 x_1_2 2 +40 hz_1_2 3 +40 hz_1_2 4 +40 x_1_2 5 +40 x_1_2 6 +40 hz_1_2 7 +40 y_1_2 8 +40 y_1_2 9 +40 x_1_2 10 +40 x_1_2 11 +41 rz 4 -40.9873943752509 +41 rz 8 41.176875152571 +41 rz 5 -64.36104173879124 +41 rz 9 64.44429717525156 +41 rz 6 -62.29195395352596 +41 rz 10 62.3243889511499 +41 rz 7 55.56739849774794 +41 rz 11 -54.13145601418609 +42 fs 4 8 1.589821065740506 0.5045391214115686 +42 fs 5 9 1.5472406430590444 0.5216932173558055 +42 fs 6 10 1.5124128267683938 0.5133142626030278 +42 fs 7 11 1.5707871303628709 0.5176678491729374 +43 rz 4 39.931240835932314 +43 rz 8 -39.741760058612215 +43 rz 5 61.45750495935115 +43 rz 9 -61.37424952289083 +43 rz 6 58.730414315960914 +43 rz 10 -58.69797931833698 +43 rz 7 -57.23044533934453 +43 rz 11 58.666387822906366 +44 y_1_2 0 +44 y_1_2 1 +44 y_1_2 2 +44 y_1_2 3 +44 x_1_2 4 +44 y_1_2 5 +44 hz_1_2 6 +44 y_1_2 7 +44 x_1_2 8 +44 hz_1_2 9 +44 y_1_2 10 +44 y_1_2 11 +45 rz 0 123.60155820331686 +45 rz 4 -123.86345702485994 +45 rz 1 121.04007678131862 +45 rz 5 -120.80235801584898 +45 rz 2 40.71052475709828 +45 rz 6 -40.99651684823609 +45 rz 3 48.47050158645827 +45 rz 7 -48.46633844818216 +46 fs 0 4 1.4668587973263782 0.4976074601121169 +46 fs 1 5 1.47511091993527 0.538612093835262 +46 fs 2 6 1.603651215218248 0.46649538437100246 +46 fs 3 7 1.6160334279232749 0.4353897326147861 +47 rz 0 -122.89046591830522 +47 rz 4 122.62856709676213 +47 rz 1 -118.29632499661328 +47 rz 5 118.5340437620829 +47 rz 2 -46.07416947247916 +47 rz 6 45.78817738134135 +47 rz 3 -51.89870681941401 +47 rz 7 51.902869957690115 +48 x_1_2 0 +48 x_1_2 1 +48 hz_1_2 2 +48 x_1_2 3 +48 hz_1_2 4 +48 x_1_2 5 +48 x_1_2 6 +48 x_1_2 7 +48 y_1_2 8 +48 y_1_2 9 +48 hz_1_2 10 +48 x_1_2 11 +49 rz 1 46.900011547499695 +49 rz 2 -46.611588454179106 +49 rz 5 -38.017201661451644 +49 rz 6 38.397973814793296 +49 rz 9 -31.727367173668014 +49 rz 10 31.957559242476353 +50 fs 1 2 1.5862983338115253 0.5200148508319427 +50 fs 5 6 1.5289739216684795 0.5055240639761313 +50 fs 9 10 1.5346175385256955 0.5131039467233695 +51 rz 1 -48.1424399386893 +51 rz 2 48.43086303200989 +51 rz 5 37.3820490490644 +51 rz 6 -37.00127689572275 +51 rz 9 30.842089346003284 +51 rz 10 -30.611897277194945 +52 y_1_2 0 +52 y_1_2 1 +52 y_1_2 2 +52 hz_1_2 3 +52 y_1_2 4 +52 y_1_2 5 +52 hz_1_2 6 +52 hz_1_2 7 +52 x_1_2 8 +52 hz_1_2 9 +52 y_1_2 10 +52 y_1_2 11 +53 rz 0 55.38426512147036 +53 rz 1 -55.20032643982446 +53 rz 2 -115.90186063513623 +53 rz 3 116.04379842155048 +53 rz 4 52.740914598168324 +53 rz 5 -52.88640802962693 +53 rz 6 -106.72005218132728 +53 rz 7 106.84347975569048 +53 rz 8 23.377022842601868 +53 rz 9 -23.05309467231085 +53 rz 10 40.72626820985929 +53 rz 11 -41.627398228167316 +54 fs 0 1 1.2947043217999283 0.4859467238431821 +54 fs 2 3 1.541977006124425 0.6073798124875975 +54 fs 4 5 1.5138652502397498 0.47710618607286504 +54 fs 6 7 1.5849169442855044 0.54346233613361 +54 fs 8 9 1.5398075246432927 0.5174515645943538 +54 fs 10 11 1.4593314109380113 0.5230636172671492 +55 rz 0 -54.795886363956285 +55 rz 1 54.97982504560218 +55 rz 2 117.68468854986324 +55 rz 3 -117.54275076344899 +55 rz 4 -54.36945889764503 +55 rz 5 54.22396546618641 +55 rz 6 107.11734171473461 +55 rz 7 -106.9939141403714 +55 rz 8 -25.797686110177455 +55 rz 9 26.12161428046847 +55 rz 10 -40.81967849296293 +55 rz 11 39.918548474654905 +56 hz_1_2 0 +56 x_1_2 1 +56 x_1_2 2 +56 x_1_2 3 +56 x_1_2 4 +56 hz_1_2 5 +56 x_1_2 6 +56 y_1_2 7 +56 y_1_2 8 +56 y_1_2 9 +56 hz_1_2 10 +56 x_1_2 11 diff --git a/examples/omeinsum_contractor.py b/examples/omeinsum_contractor.py new file mode 100644 index 00000000..35d4ccdb --- /dev/null +++ b/examples/omeinsum_contractor.py @@ -0,0 +1,131 @@ +import os +import json +from typing import List, Set, Dict, Tuple +import tempfile +import cotengra as ctg + +# Please install a julia >= 1.8.5, the 1.6.7 LTS version raises: +# Error in `python': free(): invalid pointer +from juliacall import Main as jl + +# We assume OMEinsum package is installed in julia +jl.seval("using OMEinsum") + +import tensorcircuit as tc + +tc.set_backend("tensorflow") + + +class OMEinsumTreeSAOptimizer(object): + def __init__( + self, + sc_target: float = 20, + betas: Tuple[float, float, float] = (0.01, 0.01, 15), + ntrials: int = 10, + niters: int = 50, + sc_weight: float = 1.0, + rw_weight: float = 0.2, + ): + self.sc_target = sc_target + self.betas = betas + self.ntrials = ntrials + self.niters = niters + self.sc_weight = sc_weight + self.rw_weight = rw_weight + + def _contraction_tree_to_contraction_path(self, ei, queue, path, idx): + if ei["isleaf"]: + # OMEinsum provide 1-based index + # but in contraction path we want 0-based index + ei["tensorindex"] -= 1 + return idx + assert len(ei["args"]) == 2, "must be a binary tree" + for child in ei["args"]: + idx = self._contraction_tree_to_contraction_path(child, queue, path, idx) + assert "tensorindex" in child + + lhs_args = sorted( + [queue.index(child["tensorindex"]) for child in ei["args"]], reverse=True + ) + for arg in lhs_args: + queue.pop(arg) + + ei["tensorindex"] = idx + path.append(lhs_args) + queue.append(idx) + return idx + 1 + + def __call__( + self, + inputs: List[Set[str]], + output: Set[str], + size: Dict[str, int], + memory_limit=None, + ) -> List[Tuple[int, int]]: + inputs_omeinsum = tuple(map(tuple, inputs)) + output_omeinsum = tuple(output) + + eincode = jl.OMEinsum.EinCode(inputs_omeinsum, output_omeinsum) + + size_dict = jl.OMEinsum.uniformsize(eincode, 2) + for k, v in size.items(): + size_dict[k] = v + + algorithm = jl.OMEinsum.TreeSA( + sc_target=self.sc_target, + βs=jl.range(self.betas[0], step=self.betas[1], stop=self.betas[2]), + ntrials=self.ntrials, + niters=self.niters, + sc_weight=self.sc_weight, + rw_weight=self.rw_weight, + ) + optcode = jl.OMEinsum.optimize_code(eincode, size_dict, algorithm) + # jl.println("time and space complexity computed by OMEinsum: ", + # jl.OMEinsum.timespace_complexity(optcode, size_dict)) + + fp = tempfile.NamedTemporaryFile(suffix=".json", delete=False) + fp.close() + jl.OMEinsum.writejson(fp.name, optcode) + with open(fp.name, "r") as f: + contraction_tree = json.load(f) + os.unlink(fp.name) + + num_tensors = len(contraction_tree["inputs"]) + assert num_tensors == len( + inputs + ), "should have the same number of input tensors" + queue = list(range(num_tensors)) + path = [] + self._contraction_tree_to_contraction_path( + contraction_tree["tree"], queue, path, num_tensors + ) + return path + + +# For more random circuits, please refer to +# https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8 +c = tc.Circuit.from_qsim_file("circuit_n12_m14_s0_e0_pEFGH.qsim") + +opt = ctg.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel=True, + minimize="flops", + max_repeats=1024, + progbar=False, +) +print("cotengra contractor") +tc.set_contractor( + "custom", optimizer=opt, preprocessing=True, contraction_info=True, debug_level=2 +) +c.expectation_ps(z=[0], reuse=False) + +print("OMEinsum contractor") +opt_treesa = OMEinsumTreeSAOptimizer(sc_target=30, sc_weight=0.0, rw_weight=0.0) +tc.set_contractor( + "custom", + optimizer=opt_treesa, + preprocessing=True, + contraction_info=True, + debug_level=2, +) +c.expectation_ps(z=[0], reuse=False) diff --git a/tensorcircuit/cons.py b/tensorcircuit/cons.py index 844606bf..2223b1a3 100644 --- a/tensorcircuit/cons.py +++ b/tensorcircuit/cons.py @@ -697,11 +697,11 @@ def new_algorithm( print("------ contraction cost summary ------") print( "log10[FLOPs]: ", - "%.3f" % np.log10(tree.total_flops()), + "%.3f" % np.log10(float(tree.total_flops())), " log2[SIZE]: ", "%.0f" % tree.contraction_width(), " log2[WRITE]: ", - "%.3f" % np.log2(tree.total_write()), + "%.3f" % np.log2(float(tree.total_write())), ) return path From 577251531800170cf0278edd4cd27c9aeba80a0b Mon Sep 17 00:00:00 2001 From: xptree Date: Tue, 10 Jan 2023 20:47:44 +0800 Subject: [PATCH 165/725] add more details on the env setup and versions --- examples/omeinsum_contractor.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/examples/omeinsum_contractor.py b/examples/omeinsum_contractor.py index 35d4ccdb..ffe34302 100644 --- a/examples/omeinsum_contractor.py +++ b/examples/omeinsum_contractor.py @@ -4,11 +4,16 @@ import tempfile import cotengra as ctg -# Please install a julia >= 1.8.5, the 1.6.7 LTS version raises: -# Error in `python': free(): invalid pointer +# Prerequisites for running this example: +# Step 1: install julia, see https://julialang.org/download/, +# Please install julia >= 1.8.5, the 1.6.7 LTS version raises: +# `Error in python: free(): invalid pointer` +# Step 2: add julia path to the PATH env variable so that juliacall can find it +# Step 3: install juliacall via `pip install juliacall`, this example was tested with juliacall 0.9.9 +# Step 4: install julia package `OMEinsum`, this example was tested with OMEinsum v0.7.2, +# see https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager from juliacall import Main as jl -# We assume OMEinsum package is installed in julia jl.seval("using OMEinsum") import tensorcircuit as tc From b81be71a948bfaf9b2f3c8cbbce0ce60f13bd175 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Wed, 11 Jan 2023 19:35:31 +0800 Subject: [PATCH 166/725] add qubit mapping for counts and expectation --- tensorcircuit/results/readout_mitigation.py | 155 ++++++++++++++--- tests/test_results.py | 183 +++++++++++++++++--- 2 files changed, 298 insertions(+), 40 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 9180126e..7dce6d36 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -4,7 +4,7 @@ # Part of the code in this file is from mthree: https://github.com/Qiskit-Partners/mthree (Apache2) # https://journals.aps.org/prxquantum/pdf/10.1103/PRXQuantum.2.040326 -from typing import Any, Callable, List, Sequence, Optional, Union +from typing import Any, Callable, List, Sequence, Optional, Union, Dict import warnings from time import perf_counter @@ -78,6 +78,7 @@ def ubs(self, i: int, qubits: Optional[Sequence[Any]]) -> int: vomit = 0 for k in list(filter(lambda x: x not in qubits, self.cal_qubits)): # type: ignore vomit += lisbs[self.cal_qubits.index(k)] # type: ignore + return vomit def newrange(self, m: int, qubits: Optional[Sequence[Any]]) -> int: @@ -91,9 +92,13 @@ def newrange(self, m: int, qubits: Optional[Sequence[Any]]) -> int: :return: new index :rtype: int """ - sorted_index = sorted( - range(len(qubits)), key=lambda k: qubits[k] # type: ignore - ) + # sorted_index = sorted( + # range(len(qubits)), key=lambda k: qubits[k] # type: ignore + # ) + sorted_index = [] + for i in qubits: # type: ignore + sorted_index.append(sorted(qubits).index(i)) # type: ignore + name = "{:0" + str(len(qubits)) + "b}" # type: ignore lisbs = [int(x) for x in name.format(m)] lisbs2 = [lisbs[i] for i in sorted_index] @@ -127,6 +132,7 @@ def get_matrix(self, qubits: Optional[Sequence[Any]] = None) -> Tensor: m = 0 for i in range(len(lbs)): vv = self.ubs(i, qubits) + if vv == 0: for s in lbs[i]: calmatrix[int(s, 2)][self.newrange(m, qubits)] = ( @@ -337,10 +343,73 @@ def apply_readout_mitigation(self, raw_count: ct, method: str = "inverse") -> ct probability = probability * shots return vec2count(probability, prune=True) + def mapping_preprocess( + self, + counts: ct, + qubits: Sequence[int], + positional_logical_mapping: Optional[Dict[int, int]] = None, + logical_physical_mapping: Optional[Dict[int, int]] = None, + ) -> ct: + """ + Preprocessing to deal with qubit mapping, including positional_logical_mapping and + logical_physical_mapping. Return self.use_qubits(physical) and corresponding counts. + + :param counts: raw_counts on positional_qubits + :type counts: ct + :param qubits: user-defined logical qubits to show final mitted results + :type qubits: Sequence[int] + :param positional_logical_mapping: positional_logical_mapping, defaults to None. + :type positional_logical_mapping: Optional[Dict[int, int]], optional + :param logical_physical_mapping: logical_physical_mapping, defaults to None + :type logical_physical_mapping: Optional[Dict[int, int]], optional + :return: counts on self.use_qubit(physical) + :rtype: ct + """ + # counts [0,1,2] / logic_qubit(circuit,meas) [3,4,6] / physic_qubit [2,8,6] + # / use_logic_qubits [4,3] / cal_qubits[0-8] + # input: counts [0,1,2], use_logical_qubits [4,3], logic_physic_mapping {3:2,4:8,6:6}, + # input: position_logical_mapping{0:3,1:4,2:6} + # self.use_qubits(physic)[8,2] + # use_position_qubits [1,0] + # counts = marginal_count(counts[0,1,2], [1,0]) corresponds to self.use_qubits(physic) + + if not is_sequence(qubits): + qubits = list(range(qubits)) # type: ignore + + if logical_physical_mapping is None: + self.use_qubits = qubits # type: ignore + + if positional_logical_mapping is None: + use_position_qubits = self.use_qubits + else: + logical_qubits = list(positional_logical_mapping.values()) + use_position_qubits = [] + for i in qubits: + use_position_qubits.append(logical_qubits.index(i)) + + else: + logical_qubits = list(logical_physical_mapping.keys()) + self.use_qubits = [] # type: ignore + use_position_qubits = [] + for i in qubits: + self.use_qubits.append(logical_physical_mapping[i]) # type: ignore + use_position_qubits.append(logical_qubits.index(i)) + + counts = marginal_count(counts, use_position_qubits) + + if not set(self.use_qubits).issubset(set(self.cal_qubits)): # type: ignore + raise ValueError( + "The qubit list used in calculation must included in the calibration qubit list." + ) + + return counts + def apply_correction( self, counts: ct, qubits: Sequence[int], + positional_logical_mapping: Optional[Dict[int, int]] = None, + logical_physical_mapping: Optional[Dict[int, int]] = None, distance: Optional[int] = None, method: str = "constrained_least_square", max_iter: int = 25, @@ -353,8 +422,12 @@ def apply_correction( :param counts: raw count :type counts: ct - :param qubits: used qubit list - :type qubits: Sequence[Any] + :param qubits: user-defined logical qubits to show final mitted results + :type qubits: Sequence[int] + :param positional_logical_mapping: positional_logical_mapping, defaults to None. + :type positional_logical_mapping: Optional[Dict[int, int]], optional + :param logical_physical_mapping: logical_physical_mapping, defaults to None + :type logical_physical_mapping: Optional[Dict[int, int]], optional :param distance: defaults to None :type distance: int, optional :param method: mitigation method, defaults to "square" @@ -370,15 +443,25 @@ def apply_correction( :return: mitigated count :rtype: ct """ - if not is_sequence(qubits): - qubits = list(range(qubits)) # type: ignore - self.use_qubits = qubits # type: ignore - if not set(self.use_qubits).issubset(set(self.cal_qubits)): # type: ignore - raise ValueError( - "The qubit list used in calculation must included in the calibration qubit list." - ) + # if not is_sequence(qubits): + # qubits = list(range(qubits)) # type: ignore + # self.use_qubits = qubits # type: ignore + # if not set(self.use_qubits).issubset(set(self.cal_qubits)): # type: ignore + # raise ValueError( + # "The qubit list used in calculation must included in the calibration qubit list." + # ) + + # counts = marginal_count(counts, self.use_qubits) # type: ignore + + counts = self.mapping_preprocess( + counts=counts, + qubits=qubits, + positional_logical_mapping=positional_logical_mapping, + logical_physical_mapping=logical_physical_mapping, + ) + + qubits = self.use_qubits # type: ignore - counts = marginal_count(counts, self.use_qubits) # type: ignore shots = sum([v for _, v in counts.items()]) # methods for small system, "global" calibration only fit for those methods. if method in ["inverse", "pseudo_inverse"]: @@ -639,6 +722,8 @@ def expectation( counts: ct, z: Optional[Sequence[int]] = None, diagonal_op: Optional[Tensor] = None, + positional_logical_mapping: Optional[Dict[int, int]] = None, + logical_physical_mapping: Optional[Dict[int, int]] = None, method: str = "constrained_least_square", ) -> float: """ @@ -652,6 +737,10 @@ def expectation( :param diagoal_op: shape [n, 2], explicitly indicate the diagonal op on each qubit eg. [1, -1] for z [1, 1] for I, etc. :type diagoal_op: Tensor + :param positional_logical_mapping: positional_logical_mapping, defaults to None. + :type positional_logical_mapping: Optional[Dict[int, int]], optional + :param logical_physical_mapping: logical_physical_mapping, defaults to None + :type logical_physical_mapping: Optional[Dict[int, int]], optional :param method: readout mitigation method, defaults to "constrained_least_square" :type method: str, optional :return: expectation value after readout error mitigation @@ -659,13 +748,32 @@ def expectation( """ # https://arxiv.org/pdf/2006.14044.pdf - if z is None and diagonal_op is None: - raise ValueError("One of `z` and `diagonal_op` must be set") + # count[0,1,2], logical[3,4,5], physic[6,7,8], z=[4,5](logical) + # z1=[1,2](position), z=[7,8] (physic) + # diagonal_op [i6 z7 z8 ] + n = len(list(counts.keys())[0]) + if logical_physical_mapping is None: + if positional_logical_mapping is None: + logical_qubits = list(range(n)) + else: + logical_qubits = list(positional_logical_mapping.values()) + physical_qubits = logical_qubits + else: + logical_qubits = list(logical_physical_mapping.keys()) + physical_qubits = list(logical_physical_mapping.values()) + + if z is None: + z1 = None + if diagonal_op is None: + raise ValueError("One of `z` and `diagonal_op` must be set") + else: + z1 = [logical_qubits.index(i) for i in z] + if self.local is True: inv_single_qubit_cals = [] - for i in range(n): + for i in physical_qubits: inv_single_qubit_cals.append(np.linalg.pinv(self.single_qubit_cals[i])) if z is None: @@ -676,7 +784,7 @@ def expectation( else: diagonal_op = [ [1, -1] @ inv_single_qubit_cals[i] - if i in z + if i in z1 else [1, 1] @ inv_single_qubit_cals[i] for i in range(n) ] @@ -684,7 +792,14 @@ def expectation( mit_value = expectation(counts, diagonal_op=diagonal_op) else: - mit_count = self.apply_correction(counts, list(range(n)), method=method) - mit_value = expectation(mit_count, z, diagonal_op) + mit_count = self.apply_correction( + counts, + qubits=logical_qubits, + positional_logical_mapping=positional_logical_mapping, + logical_physical_mapping=logical_physical_mapping, + method=method, + ) + + mit_value = expectation(mit_count, z1, diagonal_op) return mit_value diff --git a/tests/test_results.py b/tests/test_results.py index 4b2d4031..94a37b92 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -29,26 +29,6 @@ def test_expectation(): assert counts.expectation(d, None, [[1, -1], [1, 0], [1, 1]]) == -5 / 9 -def run(cs, shots): - # customized backend for mitigation test - nqubit = cs[0]._nqubits - gg = [] - for i in range(2 * nqubit): - gg.append(np.sin(i) * 0.02 + 0.978) - readout_error = np.reshape(gg, (nqubit, 2)) - - ts = [] - for c in cs: - count = c.sample( - batch=shots, - allow_state=True, - readout_error=readout_error, - format="count_dict_bin", - ) - ts.append(count) - return ts - - def test_readout(): nqubit = 4 shots = 4096 @@ -208,3 +188,166 @@ def test_M3(): idea_count2 = counts.marginal_count(idea_count, [1, 3, 2]) assert counts.kl_divergence(idea_count2, mit_count3) < 0.05 assert counts.kl_divergence(idea_count2, mit_count4) < 0.05 + + +def partial_sample(c, batch, readout_error=None): + measure_index = [] + for inst in c._extra_qir: + if inst["name"] == "measure": + measure_index.append(inst["index"]) + if len(measure_index) == 0: + measure_index = list(range(c._nqubits)) + + ct = c.sample( + allow_state=True, + batch=batch, + readout_error=readout_error, + format="count_dict_bin", + ) + return tc.results.counts.marginal_count(ct, measure_index) + + +def run(cs, shots): + # customized backend for mitigation test + nqubit = cs[0]._nqubits + gg = [] + for i in range(2 * nqubit): + gg.append(np.sin(i) * 0.02 + 0.978) + # gg.append(0.98 - i * 0.01) + readout_error = np.reshape(gg, (nqubit, 2)) + + ts = [] + for c in cs: + count = c.sample( + batch=shots, + allow_state=True, + readout_error=readout_error, + format="count_dict_bin", + ) + ts.append(count) + return ts + + +def simulator(c, shots, logical_physical_mapping): + # with readout_error noise + nqubit = c._nqubits + gg = [] + for i in range(200): + gg.append(np.sin(i) * 0.02 + 0.978) + # gg.append(0.98 - i * 0.01) + readout_error = np.reshape(gg[0 : nqubit * 2], (nqubit, 2)) + mapped_readout_error = [[1, 1]] * nqubit + for lq, phyq in logical_physical_mapping.items(): + mapped_readout_error[lq] = readout_error[phyq] + return partial_sample(c, shots, mapped_readout_error) + + +def test_mapping2(): + nqubit = 15 + shots = 100000 + c = tc.Circuit(nqubit) + c.H(4) + c.cnot(4, 5) + c.cnot(5, 6) + c.cnot(6, 7) + c.rx(4, theta=0.8) + c.rx(7, theta=1.8) + c.measure_instruction(4) + c.measure_instruction(5) + c.measure_instruction(6) + c.measure_instruction(7) + + mit = ReadoutMit(execute=run) + mit.cals_from_system(list(range(15)), shots=100000, method="local") + + show_qubits = [6, 7, 5] + + idea_count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") + idea_count1 = counts.marginal_count(idea_count, show_qubits) + + def hh(logical_physical_mapping): + listtt = [] + for _ in range(10): + raw_count = simulator(c, shots, logical_physical_mapping) + mit_count1 = mit.apply_correction( + raw_count, + qubits=show_qubits, + positional_logical_mapping={0: 4, 1: 5, 2: 6, 3: 7}, + logical_physical_mapping=logical_physical_mapping, + method="square", + ) + listtt.append(counts.kl_divergence(idea_count1, mit_count1)) + # print("std", np.std(listtt), np.mean(listtt)) # smaller error rate and larger shots, better mititation. + np.testing.assert_allclose(np.mean(listtt), 0.01, atol=1e-2) + + logical_physical_mapping = {4: 0, 5: 1, 6: 2, 7: 3} + hh(logical_physical_mapping) + + logical_physical_mapping = {4: 4, 5: 5, 6: 6, 7: 7} + hh(logical_physical_mapping) + + logical_physical_mapping = {4: 8, 5: 9, 6: 10, 7: 11} + hh(logical_physical_mapping) + + +def test_readout_expv_map(): + shots = 100000 + nqubit = 9 + c = tc.Circuit(nqubit) + c.H(3) + c.cnot(3, 4) + c.cnot(4, 5) + c.rx(3, theta=0.8) + c.rx(4, theta=1.2) + c.measure_instruction(3) + c.measure_instruction(4) + c.measure_instruction(5) + + idea_count = c.sample(batch=100000, allow_state=True, format="count_dict_bin") + idea_value = counts.expectation(idea_count, z=[4, 5]) + + # logical_physical_mapping = {3: 3, 4: 4, 5: 5} + logical_physical_mapping = {3: 1, 4: 8, 5: 3} + positional_logical_mapping = {0: 3, 1: 4, 2: 5} + + raw_count = simulator(c, shots, logical_physical_mapping) + + cal_qubits = list(range(nqubit)) + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="global") + mit_count = mit.apply_correction( + raw_count, + qubits=[3, 4, 5], + positional_logical_mapping=positional_logical_mapping, + logical_physical_mapping=logical_physical_mapping, + method="inverse", + ) + mit_value = counts.expectation(mit_count, z=[1, 2]) + # print("idea", idea_value) + # print("mit", mit_value) + + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="local") + mit_value1 = mit.expectation( + raw_count, + z=[4, 5], + positional_logical_mapping=positional_logical_mapping, + logical_physical_mapping=logical_physical_mapping, + method="inverse", + ) + + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="global") + mit_value2 = mit.expectation( + raw_count, + z=[4, 5], + positional_logical_mapping=positional_logical_mapping, + logical_physical_mapping=logical_physical_mapping, + method="inverse", + ) + + # print("mit1", mit_value1) + # print("mit2", mit_value2) + np.testing.assert_allclose(idea_value, mit_value, atol=1e-2) + np.testing.assert_allclose(idea_value, mit_value1, atol=1e-2) + np.testing.assert_allclose(idea_value, mit_value2, atol=1e-2) From 62acbd88b10aea6ac3fa7a23aee44898b67401f7 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Wed, 11 Jan 2023 21:57:09 +0800 Subject: [PATCH 167/725] revise qubit mapping count and expectation --- tensorcircuit/results/readout_mitigation.py | 38 +++++------ tests/test_results.py | 72 +++++++++------------ 2 files changed, 47 insertions(+), 63 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 7dce6d36..4f458a6b 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -96,8 +96,9 @@ def newrange(self, m: int, qubits: Optional[Sequence[Any]]) -> int: # range(len(qubits)), key=lambda k: qubits[k] # type: ignore # ) sorted_index = [] + qubits1 = sorted(qubits) # type: ignore for i in qubits: # type: ignore - sorted_index.append(sorted(qubits).index(i)) # type: ignore + sorted_index.append(qubits1.index(i)) name = "{:0" + str(len(qubits)) + "b}" # type: ignore lisbs = [int(x) for x in name.format(m)] @@ -376,24 +377,18 @@ def mapping_preprocess( if not is_sequence(qubits): qubits = list(range(qubits)) # type: ignore + if positional_logical_mapping is None: + use_position_qubits = qubits + else: + logical_positional_mapping = { + v: k for k, v in positional_logical_mapping.items() + } + use_position_qubits = [logical_positional_mapping[lq] for lq in qubits] + if logical_physical_mapping is None: self.use_qubits = qubits # type: ignore - - if positional_logical_mapping is None: - use_position_qubits = self.use_qubits - else: - logical_qubits = list(positional_logical_mapping.values()) - use_position_qubits = [] - for i in qubits: - use_position_qubits.append(logical_qubits.index(i)) - else: - logical_qubits = list(logical_physical_mapping.keys()) - self.use_qubits = [] # type: ignore - use_position_qubits = [] - for i in qubits: - self.use_qubits.append(logical_physical_mapping[i]) # type: ignore - use_position_qubits.append(logical_qubits.index(i)) + self.use_qubits = [logical_physical_mapping[lq] for lq in qubits] # type: ignore counts = marginal_count(counts, use_position_qubits) @@ -754,15 +749,14 @@ def expectation( n = len(list(counts.keys())[0]) + if positional_logical_mapping is None: + logical_qubits = list(range(n)) + else: + logical_qubits = [positional_logical_mapping[pq] for pq in range(n)] if logical_physical_mapping is None: - if positional_logical_mapping is None: - logical_qubits = list(range(n)) - else: - logical_qubits = list(positional_logical_mapping.values()) physical_qubits = logical_qubits else: - logical_qubits = list(logical_physical_mapping.keys()) - physical_qubits = list(logical_physical_mapping.values()) + physical_qubits = [logical_physical_mapping[i] for i in logical_qubits] if z is None: z1 = None diff --git a/tests/test_results.py b/tests/test_results.py index 94a37b92..791c22b9 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -194,7 +194,7 @@ def partial_sample(c, batch, readout_error=None): measure_index = [] for inst in c._extra_qir: if inst["name"] == "measure": - measure_index.append(inst["index"]) + measure_index.append(inst["index"][0]) if len(measure_index) == 0: measure_index = list(range(c._nqubits)) @@ -209,28 +209,19 @@ def partial_sample(c, batch, readout_error=None): def run(cs, shots): # customized backend for mitigation test - nqubit = cs[0]._nqubits - gg = [] - for i in range(2 * nqubit): - gg.append(np.sin(i) * 0.02 + 0.978) - # gg.append(0.98 - i * 0.01) - readout_error = np.reshape(gg, (nqubit, 2)) - ts = [] for c in cs: - count = c.sample( - batch=shots, - allow_state=True, - readout_error=readout_error, - format="count_dict_bin", - ) + count = simulator(c, shots) ts.append(count) return ts -def simulator(c, shots, logical_physical_mapping): +def simulator(c, shots, logical_physical_mapping=None): # with readout_error noise nqubit = c._nqubits + if logical_physical_mapping is None: + logical_physical_mapping = {i: i for i in range(nqubit)} + gg = [] for i in range(200): gg.append(np.sin(i) * 0.02 + 0.978) @@ -242,7 +233,7 @@ def simulator(c, shots, logical_physical_mapping): return partial_sample(c, shots, mapped_readout_error) -def test_mapping2(): +def test_mapping(): nqubit = 15 shots = 100000 c = tc.Circuit(nqubit) @@ -265,34 +256,34 @@ def test_mapping2(): idea_count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") idea_count1 = counts.marginal_count(idea_count, show_qubits) - def hh(logical_physical_mapping): - listtt = [] + def miti_kl_mean(logical_physical_mapping): + ls = [] for _ in range(10): raw_count = simulator(c, shots, logical_physical_mapping) mit_count1 = mit.apply_correction( raw_count, qubits=show_qubits, - positional_logical_mapping={0: 4, 1: 5, 2: 6, 3: 7}, + positional_logical_mapping={1: 5, 0: 4, 2: 6, 3: 7}, logical_physical_mapping=logical_physical_mapping, method="square", ) - listtt.append(counts.kl_divergence(idea_count1, mit_count1)) + ls.append(counts.kl_divergence(idea_count1, mit_count1)) # print("std", np.std(listtt), np.mean(listtt)) # smaller error rate and larger shots, better mititation. - np.testing.assert_allclose(np.mean(listtt), 0.01, atol=1e-2) + np.testing.assert_allclose(np.mean(ls), 0.01, atol=1e-2) - logical_physical_mapping = {4: 0, 5: 1, 6: 2, 7: 3} - hh(logical_physical_mapping) + logical_physical_mapping = {4: 0, 6: 2, 7: 3, 5: 1} + miti_kl_mean(logical_physical_mapping) logical_physical_mapping = {4: 4, 5: 5, 6: 6, 7: 7} - hh(logical_physical_mapping) + miti_kl_mean(logical_physical_mapping) logical_physical_mapping = {4: 8, 5: 9, 6: 10, 7: 11} - hh(logical_physical_mapping) + miti_kl_mean(logical_physical_mapping) def test_readout_expv_map(): shots = 100000 - nqubit = 9 + nqubit = 7 c = tc.Circuit(nqubit) c.H(3) c.cnot(3, 4) @@ -307,34 +298,33 @@ def test_readout_expv_map(): idea_value = counts.expectation(idea_count, z=[4, 5]) # logical_physical_mapping = {3: 3, 4: 4, 5: 5} - logical_physical_mapping = {3: 1, 4: 8, 5: 3} - positional_logical_mapping = {0: 3, 1: 4, 2: 5} + logical_physical_mapping = {3: 1, 5: 3, 4: 6} + positional_logical_mapping = {1: 4, 0: 3, 2: 5} raw_count = simulator(c, shots, logical_physical_mapping) cal_qubits = list(range(nqubit)) + mit = ReadoutMit(execute=run) - mit.cals_from_system(cal_qubits, shots=100000, method="global") - mit_count = mit.apply_correction( + mit.cals_from_system(cal_qubits, shots=100000, method="local") + mit_value1 = mit.expectation( raw_count, - qubits=[3, 4, 5], + z=[4, 5], positional_logical_mapping=positional_logical_mapping, logical_physical_mapping=logical_physical_mapping, method="inverse", ) - mit_value = counts.expectation(mit_count, z=[1, 2]) - # print("idea", idea_value) - # print("mit", mit_value) - mit = ReadoutMit(execute=run) - mit.cals_from_system(cal_qubits, shots=100000, method="local") - mit_value1 = mit.expectation( + mit_count = mit.apply_correction( raw_count, - z=[4, 5], + qubits=[3, 4, 5], positional_logical_mapping=positional_logical_mapping, logical_physical_mapping=logical_physical_mapping, method="inverse", ) + mit_value = counts.expectation(mit_count, z=[1, 2]) + # print("idea", idea_value) + # print("mit", mit_value) mit = ReadoutMit(execute=run) mit.cals_from_system(cal_qubits, shots=100000, method="global") @@ -348,6 +338,6 @@ def test_readout_expv_map(): # print("mit1", mit_value1) # print("mit2", mit_value2) - np.testing.assert_allclose(idea_value, mit_value, atol=1e-2) - np.testing.assert_allclose(idea_value, mit_value1, atol=1e-2) - np.testing.assert_allclose(idea_value, mit_value2, atol=1e-2) + np.testing.assert_allclose(idea_value, mit_value, atol=3 * 1e-2) + np.testing.assert_allclose(idea_value, mit_value1, atol=3 * 1e-2) + np.testing.assert_allclose(idea_value, mit_value2, atol=3 * 1e-2) From 048e82e1b1941293135c47e78af9335b7265cb10 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 11 Jan 2023 22:30:02 +0800 Subject: [PATCH 168/725] fix some warnings in tests --- pytest.ini | 4 ++++ tensorcircuit/abstractcircuit.py | 2 +- tensorcircuit/applications/graphdata.py | 2 +- tensorcircuit/applications/layers.py | 8 ++++---- tensorcircuit/asciiart.py | 10 +++++----- tensorcircuit/backends/jax_backend.py | 6 +++--- tensorcircuit/backends/numpy_backend.py | 2 +- tensorcircuit/quantum.py | 6 +++--- tensorcircuit/templates/measurements.py | 2 +- tensorcircuit/utils.py | 2 +- tensorcircuit/vis.py | 2 +- 11 files changed, 25 insertions(+), 21 deletions(-) create mode 100644 pytest.ini diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..a8f7d7ea --- /dev/null +++ b/pytest.ini @@ -0,0 +1,4 @@ +[pytest] +filterwarnings = + ignore::DeprecationWarning + ignore:Explicitly requested dtype*:UserWarning \ No newline at end of file diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index de28e547..93a12380 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -745,7 +745,7 @@ def vis_tex(self, **kws: Any) -> str: """ if (not self.is_mps) and (self.inputs is not None): init = ["" for _ in range(self._nqubits)] - init[self._nqubits // 2] = "\psi" + init[self._nqubits // 2] = r"\psi" okws = {"init": init} else: okws = {"init": None} # type: ignore diff --git a/tensorcircuit/applications/graphdata.py b/tensorcircuit/applications/graphdata.py index 5dce317f..d5b694dd 100644 --- a/tensorcircuit/applications/graphdata.py +++ b/tensorcircuit/applications/graphdata.py @@ -290,7 +290,7 @@ def regular_graph_generator(d: int, n: int, weights: bool = False) -> Iterator[G def _maxcut(g: Graph, values: Sequence[int]) -> float: - """ + r""" To get the max-cut for the graph g by given values $$\pm 1$$ on each vertex as a list. :param g: The graph diff --git a/tensorcircuit/applications/layers.py b/tensorcircuit/applications/layers.py index 7101ef8d..18f53db6 100644 --- a/tensorcircuit/applications/layers.py +++ b/tensorcircuit/applications/layers.py @@ -81,7 +81,7 @@ def f( def generate_gate_layer(gate: str) -> None: - """ + r""" $$e^{-i\theta \sigma}$$ :param gate: @@ -108,7 +108,7 @@ def f( def generate_any_gate_layer(gate: str) -> None: - """ + r""" $$e^{-i\theta_i \sigma}$$ :param gate: @@ -392,7 +392,7 @@ def cirqcnotgate( return circuit def generate_cirq_gate_layer(gate: str) -> None: - """ + r""" $$e^{-i\theta \sigma}$$ :param gate: @@ -422,7 +422,7 @@ def f( setattr(thismodule, "cirq" + gate + "layer", f) def generate_cirq_any_gate_layer(gate: str) -> None: - """ + r""" $$e^{-i\theta \sigma}$$ :param gate: diff --git a/tensorcircuit/asciiart.py b/tensorcircuit/asciiart.py index f4a635aa..b63b317e 100644 --- a/tensorcircuit/asciiart.py +++ b/tensorcircuit/asciiart.py @@ -38,7 +38,7 @@ def __str__(self) -> str: (*)`(*) """ -__bigbike__ = """ +__bigbike__ = r""" $" *. d$$$$$$$P" $ J ^$. 4r " @@ -58,7 +58,7 @@ def __str__(self) -> str: "*==*"" ^"*==*"" Gilo94' """ -__moon__ = """ +__moon__ = r""" ___---___ .-- --. ./ () .-. \. @@ -77,7 +77,7 @@ def __str__(self) -> str: """ -__cat__ = """ +__cat__ = r""" ,_ _ |\ _,-~/ / _ _ | ,--. @@ -90,7 +90,7 @@ def __str__(self) -> str: ((_/`(____,-' """ -__moonlanding__ = """ +__moonlanding__ = r""" _ _ ____________.--. |\|_|//_.-"" .' \ /| | |.-"-"-.| / \_/ | | @@ -124,7 +124,7 @@ def __str__(self) -> str: """ -__moonshot__ = """ +__moonshot__ = r""" .-. ( ( `-' diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 617ceebe..23475da0 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -395,7 +395,7 @@ def is_tensor(self, a: Any) -> bool: return False def solve(self, A: Tensor, b: Tensor, assume_a: str = "gen") -> Tensor: # type: ignore - return jsp.linalg.solve(A, b, assume_a) + return jsp.linalg.solve(A, b, assume_a=assume_a) def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: if not self.is_tensor(a): @@ -408,10 +408,10 @@ def tree_map(self, f: Callable[..., Any], *pytrees: Any) -> Any: return libjax.tree_map(f, *pytrees) def tree_flatten(self, pytree: Any) -> Tuple[Any, Any]: - return libjax.tree_flatten(pytree) # type: ignore + return libjax.tree_util.tree_flatten(pytree) # type: ignore def tree_unflatten(self, treedef: Any, leaves: Any) -> Any: - return libjax.tree_unflatten(treedef, leaves) + return libjax.tree_util.tree_unflatten(treedef, leaves) def from_dlpack(self, a: Any) -> Tensor: import jax.dlpack diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index 69edad23..6ab2bde2 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -229,7 +229,7 @@ def left_shift(self, x: Tensor, y: Tensor) -> Tensor: def solve(self, A: Tensor, b: Tensor, assume_a: str = "gen") -> Tensor: # type: ignore # gen, sym, her, pos # https://stackoverflow.com/questions/44672029/difference-between-numpy-linalg-solve-and-numpy-linalg-lu-solve/44710451 - return solve(A, b, assume_a) + return solve(A, b, assume_a=assume_a) def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: return np.searchsorted(a, v, side=side) # type: ignore diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index cd92f40f..d8ba38f9 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -711,7 +711,7 @@ def eval( return list(nodes)[0].tensor def eval_matrix(self, final_edge_order: Optional[Sequence[Edge]] = None) -> Tensor: - """ + r""" Contracts the tensor network in place and returns the final tensor in two dimentional matrix. The default ordering for the axes of the final tensor is: @@ -2176,7 +2176,7 @@ def spin_by_basis(n: int, m: int, elements: Tuple[int, int] = (1, -1)) -> Tensor def correlation_from_samples(index: Sequence[int], results: Tensor, n: int) -> Tensor: - """ + r""" Compute :math:`\prod_{i\in \\text{index}} s_i (s=\pm 1)`, Results is in the format of "sample_int" or "sample_bin" @@ -2200,7 +2200,7 @@ def correlation_from_samples(index: Sequence[int], results: Tensor, n: int) -> T def correlation_from_counts(index: Sequence[int], results: Tensor) -> Tensor: - """ + r""" Compute :math:`\prod_{i\in \\text{index}} s_i`, where the probability for each bitstring is given as a vector ``results``. Results is in the format of "count_vector" diff --git a/tensorcircuit/templates/measurements.py b/tensorcircuit/templates/measurements.py index c72ccd9c..aca804d9 100644 --- a/tensorcircuit/templates/measurements.py +++ b/tensorcircuit/templates/measurements.py @@ -218,7 +218,7 @@ def heisenberg_measurements( hy: float = 0.0, reuse: bool = True, ) -> Tensor: - """ + r""" Evaluate Heisenberg energy expectation, whose Hamiltonian is defined on the lattice graph ``g`` as follows: (e are edges in graph ``g`` where e1 and e2 are two nodes for edge e and v are nodes in graph ``g``) diff --git a/tensorcircuit/utils.py b/tensorcircuit/utils.py index 44861a10..ebb31a3e 100644 --- a/tensorcircuit/utils.py +++ b/tensorcircuit/utils.py @@ -136,7 +136,7 @@ def wrapper(*args: Any, **kws: Any) -> Any: if isinstance(vs, str): vs = [] for v in vs: - if kws.get(v, "qazxswedcvfr198") != "qazxswedcvfr198": + if v in kws: # in case it is None by design! kws[k] = kws[v] del kws[v] diff --git a/tensorcircuit/vis.py b/tensorcircuit/vis.py index ab6dd73e..ab96540a 100644 --- a/tensorcircuit/vis.py +++ b/tensorcircuit/vis.py @@ -102,7 +102,7 @@ def qir2tex( p = max(flag[min(idx) : max(idx) + 1]) + 1 for i in range(min(idx), max(idx) + 1): tex_string_table[i] += [r"\qw "] * (p - flag[i] - 1) - tex_string_table[i] += [r"\ghost{" + x["name"][7:] + "}\qw "] + tex_string_table[i] += [r"\ghost{" + x["name"][7:] + r"}\qw "] flag[i] = p else: ctrl_number, gate_name = gate_name_trans(x["name"]) From 2b35a73ae436c08b9aecd6f5ed32123d89b28da0 Mon Sep 17 00:00:00 2001 From: /bin/eash Date: Thu, 12 Jan 2023 12:00:59 +0800 Subject: [PATCH 169/725] noisy circuit with circuit parameter --- tensorcircuit/densitymatrix.py | 12 ++++++------ tensorcircuit/noisemodel.py | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/tensorcircuit/densitymatrix.py b/tensorcircuit/densitymatrix.py index 03fd52b1..ec0277a6 100644 --- a/tensorcircuit/densitymatrix.py +++ b/tensorcircuit/densitymatrix.py @@ -75,10 +75,10 @@ def __init__( n = int(np.log(N) / np.log(2)) assert n == nqubits inputs = backend.reshape(inputs, [2 for _ in range(n)]) - inputs = Gate(inputs) - self._nodes = [inputs] + inputs_gate = Gate(inputs) + self._nodes = [inputs_gate] self.coloring_nodes(self._nodes) - self._front = [inputs.get_edge(i) for i in range(n)] + self._front = [inputs_gate.get_edge(i) for i in range(n)] self._double_nodes_front() elif mps_inputs is not None: @@ -94,9 +94,9 @@ def __init__( dminputs = backend.convert_to_tensor(dminputs) dminputs = backend.cast(dminputs, dtype=dtypestr) dminputs = backend.reshape(dminputs, [2 for _ in range(2 * nqubits)]) - dminputs = Gate(dminputs) - nodes = [dminputs] - self._front = [dminputs.get_edge(i) for i in range(2 * nqubits)] + dminputs_gate = Gate(dminputs) + nodes = [dminputs_gate] + self._front = [dminputs_gate.get_edge(i) for i in range(2 * nqubits)] self._nodes = nodes self.coloring_nodes(self._nodes) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index be9d3326..031816ef 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -186,9 +186,9 @@ def circuit_with_noise( qir = c.to_qir() cnew: AbstractCircuit if isinstance(c, DMCircuit): - cnew = DMCircuit(c._nqubits) + cnew = DMCircuit(**c.circuit_param) else: - cnew = Circuit(c._nqubits) + cnew = Circuit(**c.circuit_param) cnew = apply_qir_with_noise(cnew, qir, noise_conf, status) return cnew From 6e181f7a633401c278509ea5d868f0e1ec7078b4 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 12 Jan 2023 13:54:36 +0800 Subject: [PATCH 170/725] delete unused print --- tensorcircuit/translation.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 7b6f110b..f3db6c0c 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -587,7 +587,6 @@ def qiskit_from_qasm_str_ordered_measure(qasm_str: str) -> Any: qasm_instruction = [] for line in qasm_str.split("\n"): if line.startswith("measure"): - print(line) index = int(line.split(" ")[1][2:-1]) cindex = int(line.split(" ")[3].strip(";")[2:-1]) From 4bb5ce84ed44475118ed185232bf71633bd20cf8 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 12 Jan 2023 13:59:26 +0800 Subject: [PATCH 171/725] add mthree to the github ci requirements --- requirements/requirements-extra.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 0e2b5cf6..09cacbba 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -3,3 +3,4 @@ qiskit qiskit-nature torch jupyter +mthree==1.1.0 From 90e46b79254eadec86fb8ac940a9c917503a3647 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 12 Jan 2023 14:09:26 +0800 Subject: [PATCH 172/725] fix codecov ignore path --- codecov.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/codecov.yml b/codecov.yml index 3cad6aa6..1708389f 100644 --- a/codecov.yml +++ b/codecov.yml @@ -1,2 +1,2 @@ ignore: - - "applications" + - "tensorcircuit/applications" From 32ea293bb2e949bc8d812bb71ade8570e1adc025 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 12 Jan 2023 14:29:35 +0800 Subject: [PATCH 173/725] add cache for github ci --- .github/workflows/ci.yml | 3 ++- .github/workflows/nightly_release.yml | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f14ebe2a..7a0a7dff 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -12,9 +12,10 @@ jobs: steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v1 + uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} + cache: "pip" - name: install dependencies run: | python -m pip install --upgrade pip diff --git a/.github/workflows/nightly_release.yml b/.github/workflows/nightly_release.yml index d47c1ebe..ce62cc9c 100644 --- a/.github/workflows/nightly_release.yml +++ b/.github/workflows/nightly_release.yml @@ -16,9 +16,10 @@ jobs: with: ref: beta - name: Set up Python - uses: actions/setup-python@v1 + uses: actions/setup-python@v4 with: python-version: 3.8 + cache: "pip" - name: install dependencies run: | python -m pip install --upgrade pip From 5f3bb12d48559b50feba4eebc433d86926e03c1a Mon Sep 17 00:00:00 2001 From: xptree Date: Thu, 12 Jan 2023 14:48:01 +0800 Subject: [PATCH 174/725] fix juliacall multi-threading segmentation fault --- examples/omeinsum_contractor.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/examples/omeinsum_contractor.py b/examples/omeinsum_contractor.py index ffe34302..60043025 100644 --- a/examples/omeinsum_contractor.py +++ b/examples/omeinsum_contractor.py @@ -2,6 +2,7 @@ import json from typing import List, Set, Dict, Tuple import tempfile +import warnings import cotengra as ctg # Prerequisites for running this example: @@ -12,6 +13,10 @@ # Step 3: install juliacall via `pip install juliacall`, this example was tested with juliacall 0.9.9 # Step 4: install julia package `OMEinsum`, this example was tested with OMEinsum v0.7.2, # see https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager +# Step 5: for julia multi-threading, set env variable PYTHON_JULIACALL_THREADS=. +# However, in order to use julia multi-threading in juliacall, +# we have to turn off julia GC at the risk of OOM. +# See see https://github.com/cjdoris/PythonCall.jl/issues/219 for more details. from juliacall import Main as jl jl.seval("using OMEinsum") @@ -84,7 +89,21 @@ def __call__( sc_weight=self.sc_weight, rw_weight=self.rw_weight, ) + + nthreads = jl.Threads.nthreads() + if nthreads > 1: + warnings.warn( + "Julia receives Threads.nthreads()={0}. " + "However, in order to use julia multi-threading in juliacall, " + "we have to turn off julia GC at the risk of OOM. " + "That means you may need a large memory machine. " + "Please see https://github.com/cjdoris/PythonCall.jl/issues/219 " + "for more details.".format(nthreads) + ) + jl.GC.enable(False) optcode = jl.OMEinsum.optimize_code(eincode, size_dict, algorithm) + if nthreads > 1: + jl.GC.enable(True) # jl.println("time and space complexity computed by OMEinsum: ", # jl.OMEinsum.timespace_complexity(optcode, size_dict)) From c1a740fd5658cb8b96ef568a06cdbeb26e998ec9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 12 Jan 2023 14:58:56 +0800 Subject: [PATCH 175/725] add get_positional_logical_mapping method --- CHANGELOG.md | 14 +++++++++++++- tensorcircuit/abstractcircuit.py | 22 ++++++++++++++++++++++ tests/test_circuit.py | 14 ++++++++++++++ 3 files changed, 49 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index dfc2587a..ad17c284 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,7 +4,19 @@ ### Added -- Add `initial_mapping` circuit method to return a new circuit with the `logical_physical_mapping` +- Add `initial_mapping` circuit method to return a new circuit with given `logical_physical_mapping` + +- Add `get_positional_logical_mapping` circuit method to return the mapping when only part of the qubits are measured + +- `results.rem.ReadoutMit` class now support three layers of abstriction on qubits: positional, logical, and physical + +- Add an example script demonstrating how tc can use external contraction path finder wirtten in Julia + +### Fixed + +- Circuit nosify in noise model now support all circuit attributs apart from qubit number + +- Some string warnings are fixed by using r-string ## 0.7.0 diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 93a12380..578de7d7 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -487,6 +487,28 @@ def initial_mapping( return c + def get_positional_logical_mapping(self) -> Dict[int, int]: + """ + Get positional logical mapping dict based on measure instruction. + This function is useful when we only measure part of the qubits in the circuit, + to process the count result from partial measurement, we must be aware of the mapping, + i.e. for each position in the count bitstring, what is the corresponding qubits (logical) + defined on the circuit + + :return: ``positional_logical_mapping`` + :rtype: Dict[int, int] + """ + id_mapping = {i: i for i in range(self._nqubits)} + if len(self._extra_qir) == 0: + return id_mapping + measure_index = [] + for inst in self._extra_qir: + if inst["name"] == "measure": + measure_index.append(inst["index"][0]) + if len(measure_index) == 0: + return id_mapping + return {i: j for i, j in enumerate(measure_index)} + @staticmethod def standardize_gate(name: str) -> str: """ diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 61571be7..11ae59c0 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1357,3 +1357,17 @@ def test_initial_mapping(): c.expectation_ps(z=[1]), c3.expectation_ps(z=[7]), atol=1e-5 ) print(c3.draw()) + + +def test_get_positional_logical_mapping(): + c = tc.Circuit(3) + c.cx(0, 1) + c.cz(1, 2) + c.h(1) + assert c.get_positional_logical_mapping() == {0: 0, 1: 1, 2: 2} + c = tc.Circuit(3) + c.cx(0, 1) + c.h(1) + c.measure_instruction(2) + c.measure_instruction(0) + assert c.get_positional_logical_mapping() == {0: 2, 1: 0} From c299072782a2b41bf6d07f1e566f2d1b26e97ac3 Mon Sep 17 00:00:00 2001 From: Mark Song <78847784+MarkSong535@users.noreply.github.com> Date: Fri, 13 Jan 2023 09:46:25 +0800 Subject: [PATCH 176/725] Translate sharpbit in docs to Chinese --- CHANGELOG.md | 2 + .../source/locale/zh/LC_MESSAGES/sharpbits.po | 38 +++++++++++++++---- 2 files changed, 32 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c3e10b6..ac9c63c9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ - Add results module including funtionalities on count dict manipulation and readout error mitigation +- Add Chinese translation for doc Sharpbit + ### Fixed - Fix adjoint possible bug with agnostic backend diff --git a/docs/source/locale/zh/LC_MESSAGES/sharpbits.po b/docs/source/locale/zh/LC_MESSAGES/sharpbits.po index b36da0fc..95459bb9 100644 --- a/docs/source/locale/zh/LC_MESSAGES/sharpbits.po +++ b/docs/source/locale/zh/LC_MESSAGES/sharpbits.po @@ -20,7 +20,7 @@ msgstr "" #: ../../source/sharpbits.rst:3 msgid "TensorCircuit: The Sharp Bits 🔪" -msgstr "" +msgstr "TensorCircuit: 常见错误 🔪" #: ../../source/sharpbits.rst:5 msgid "" @@ -28,14 +28,16 @@ msgid "" "have to be cautious especially in terms of AD, JIT compatibility. We will" " go through the main sharp edges 🔪 in this note." msgstr "" +"虽然在TensorCircuit中速度很快，但是你必须小心，尤其是在AD和JIT兼容性" +"方面。" #: ../../source/sharpbits.rst:9 msgid "Jit Compatibility" -msgstr "" +msgstr "Jit 兼容性" #: ../../source/sharpbits.rst:12 msgid "Non tensor input or varying shape tensor input" -msgstr "" +msgstr "非向量输入或者变化形状的向量输入" #: ../../source/sharpbits.rst:14 msgid "" @@ -44,10 +46,13 @@ msgid "" "Therefore, if there are input args that are non-tensor or varying shape " "tensors and frequently change, jit is not recommend." msgstr "" +"输入必须是张量形式，且输入张量的形状必须固定，否则会重新编译，这是非常耗" +"时的。因此，如果有输入参数是非张量或者变化形状的张量，且经常变化，不建议" +"使用jit。" #: ../../source/sharpbits.rst:38 msgid "Mix use of numpy and ML backend APIs" -msgstr "" +msgstr "混合使用numpy和ML后端API" #: ../../source/sharpbits.rst:40 msgid "" @@ -58,16 +63,21 @@ msgid "" "For numpy ops, they will be only called in jit staging time (the first " "run)." msgstr "" +"为了使函数可jit和可AD，函数中的每个操作都应该通过ML后端（``tc.backend`` API" +"或者直接调用后端API ``tf`` 或者 ``jax``）。这是因为ML后端必须创建计算" +"图来"进行AD和JIT转换。对于numpy操作，它们只会在jit编译阶段被调用（第一" +"次运行）。" #: ../../source/sharpbits.rst:54 msgid "" "Numpy call inside jitted function can be helpful if you are sure of the " "behavior is what you expect." msgstr "" +"如果你确定numpy调用的行为是你期望的，那么在jit函数中调用numpy是有帮助的。" #: ../../source/sharpbits.rst:83 msgid "list append under if" -msgstr "" +msgstr "if下的list append" #: ../../source/sharpbits.rst:85 msgid "" @@ -75,20 +85,24 @@ msgid "" "tensor values will lead to wrong results. Actually values of both branch " "will be attached to the list. See example below." msgstr "" +"在if条件基于张量值的情况下，将内容附加到Python列表中会导致错误的结果。实际" +"上，两个分支的值都会被附加到列表中。参见下面的例子。" #: ../../source/sharpbits.rst:108 msgid "" "The above code raise ``ConcretizationTypeError`` exception directly for " "Jax backend since Jax jit doesn't support tensor value if condition." msgstr "" +"上面的代码直接为Jax后端引发了``ConcretizationTypeError``异常，因为Jax " +"jit不支持张量值if条件。" #: ../../source/sharpbits.rst:110 msgid "Similarly, conditional gate application must be takend carefully." -msgstr "" +msgstr "类似地，必须小心地应用条件门。" #: ../../source/sharpbits.rst:145 msgid "AD Consistency" -msgstr "" +msgstr "AD一致性" #: ../../source/sharpbits.rst:147 msgid "" @@ -97,6 +111,8 @@ msgid "" "discussion `tensorflow issue " "`_." msgstr "" +"TF和JAX后端对复值函数的微分规则的管理方式不同（实际上是复共轭）。参见讨论 " +"`tensorflow issue `_。" #: ../../source/sharpbits.rst:149 msgid "" @@ -108,6 +124,10 @@ msgid "" "careful when dealing with AD on complex valued function in a backend " "agnostic way in TensorCircuit." msgstr "" +"在TensorCircuit中，我们目前使AD的差异透明，即在切换后端时，复值函数的AD行为" +"和结果可能不同，并由相应后端框架的本质行为决定。所有与AD相关的操作，如 " +"``grad`` 或者 ``jacrev`` 都可能受到影响。因此，用户在TensorCircuit中以后端" +"无关的方式处理复值函数的AD时必须小心。" #: ../../source/sharpbits.rst:152 msgid "" @@ -116,4 +136,6 @@ msgid "" "lab/tensorcircuit/blob/master/examples/jacobian_cal.py>`_. Also see the " "code below for a reference:" msgstr "" - +"参考不同后端的不同模式下计算Jacobian的示例脚本：`jacobian_cal.py `_。" +"另外请参考下面的代码:" From d47a1a8cfe1f6a943babedd3d175018833e9e88d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 13 Jan 2023 11:20:20 +0800 Subject: [PATCH 177/725] update doc auto generation --- docs/source/api/noisemodel.rst | 7 + docs/source/api/results.rst | 5 + docs/source/api/results/counts.rst | 7 + .../source/api/results/readout_mitigation.rst | 7 + docs/source/locale/zh/LC_MESSAGES/advance.po | 200 +- docs/source/locale/zh/LC_MESSAGES/api.po | 18631 ++++++++++++---- docs/source/locale/zh/LC_MESSAGES/contribs.po | 246 +- docs/source/locale/zh/LC_MESSAGES/faq.po | 69 +- docs/source/locale/zh/LC_MESSAGES/index.po | 43 +- docs/source/locale/zh/LC_MESSAGES/infras.po | 136 +- .../locale/zh/LC_MESSAGES/quickstart.po | 238 +- docs/source/modules.rst | 3 + 12 files changed, 14774 insertions(+), 4818 deletions(-) create mode 100644 docs/source/api/noisemodel.rst create mode 100644 docs/source/api/results.rst create mode 100644 docs/source/api/results/counts.rst create mode 100644 docs/source/api/results/readout_mitigation.rst diff --git a/docs/source/api/noisemodel.rst b/docs/source/api/noisemodel.rst new file mode 100644 index 00000000..ab152857 --- /dev/null +++ b/docs/source/api/noisemodel.rst @@ -0,0 +1,7 @@ +tensorcircuit.noisemodel +================================================== +.. automodule:: tensorcircuit.noisemodel + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/results.rst b/docs/source/api/results.rst new file mode 100644 index 00000000..0bea95e7 --- /dev/null +++ b/docs/source/api/results.rst @@ -0,0 +1,5 @@ +tensorcircuit.results +================================================== +.. toctree:: + results/counts.rst + results/readout_mitigation.rst \ No newline at end of file diff --git a/docs/source/api/results/counts.rst b/docs/source/api/results/counts.rst new file mode 100644 index 00000000..7542d722 --- /dev/null +++ b/docs/source/api/results/counts.rst @@ -0,0 +1,7 @@ +tensorcircuit.results.counts +================================================== +.. automodule:: tensorcircuit.results.counts + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/results/readout_mitigation.rst b/docs/source/api/results/readout_mitigation.rst new file mode 100644 index 00000000..0d9baa3d --- /dev/null +++ b/docs/source/api/results/readout_mitigation.rst @@ -0,0 +1,7 @@ +tensorcircuit.results.readout_mitigation +================================================== +.. automodule:: tensorcircuit.results.readout_mitigation + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/locale/zh/LC_MESSAGES/advance.po b/docs/source/locale/zh/LC_MESSAGES/advance.po index 16e19463..4e4b7fca 100644 --- a/docs/source/locale/zh/LC_MESSAGES/advance.po +++ b/docs/source/locale/zh/LC_MESSAGES/advance.po @@ -6,9 +6,9 @@ # msgid "" msgstr "" -"Project-Id-Version: tensorcircuit\n" +"Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2022-04-10 17:39+0800\n" +"POT-Creation-Date: 2023-01-13 11:04+0800\n" "PO-Revision-Date: 2022-04-11 07:50+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -17,7 +17,6 @@ msgstr "" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.9.1\n" -"X-Generator: Poedit 1.6.11\n" #: ../../source/advance.rst:3 msgid "Advanced Usage" @@ -31,155 +30,174 @@ msgstr "MPS 模拟器" msgid "(Still experimental support)" msgstr "施工中" -#: ../../source/advance.rst:11 +#: ../../source/advance.rst:10 +msgid "" +"Very simple, we provide the same set of API for ``MPSCircuit`` as " +"``Circuit``, the only new line is to set the bond dimension for the new " +"simulator." +msgstr "" + +#: ../../source/advance.rst:18 +msgid "" +"The larger bond dimension we set, the better approximation ratio (of " +"course the more computational cost we pay)" +msgstr "" + +#: ../../source/advance.rst:21 msgid "Split Two-qubit Gates" msgstr "分解双量子比特门" -#: ../../source/advance.rst:13 +#: ../../source/advance.rst:23 msgid "" -"The two-qubit gates applied on the circuit can be decomposed via SVD, which " -"may further improve the optimality of the contraction pathfinding." -msgstr "" -"应用在电路上的双量子比特门可以通过 SVD 进行分解，这可以进一步提高收缩路径查找" -"的最优性。" +"The two-qubit gates applied on the circuit can be decomposed via SVD, " +"which may further improve the optimality of the contraction pathfinding." +msgstr "应用在电路上的双量子比特门可以通过 SVD 进行分解，这可以进一步提高收缩路径查找的最优性。" -#: ../../source/advance.rst:15 +#: ../../source/advance.rst:25 msgid "`split` configuration can be set at circuit-level or gate-level." msgstr "`split` 配置可以在电路级或门级设置。" -#: ../../source/advance.rst:36 +#: ../../source/advance.rst:46 msgid "" -"Note ``max_singular_values`` must be specified to make the whole procedure " -"static and thus jittable." -msgstr "" -"请注意 ``max_singular_values`` 必须被指定明以使整个过程成为静态的，因此是可即" -"时编译的。" +"Note ``max_singular_values`` must be specified to make the whole " +"procedure static and thus jittable." +msgstr "请注意 ``max_singular_values`` 必须被指定明以使整个过程成为静态的，因此是可即时编译的。" -#: ../../source/advance.rst:40 +#: ../../source/advance.rst:50 msgid "Jitted Function Save/Load" msgstr "即时编译函的保存/加载" -#: ../../source/advance.rst:42 +#: ../../source/advance.rst:52 msgid "" -"To reuse the jitted function, we can save it on the disk via support from " -"the TensorFlow `SavedModel `_. " -"That is to say, only jitted quantum function on the TensorFlow backend can " -"be saved on the disk." +"To reuse the jitted function, we can save it on the disk via support from" +" the TensorFlow `SavedModel " +"`_. That is to say, only " +"jitted quantum function on the TensorFlow backend can be saved on the " +"disk." msgstr "" -"要重新使用可即时编译函数，我们可以通过 TensorFlow `SavedModel `_. 的帮助将其保存在磁盘上。也就是说，只有 " +"要重新使用可即时编译函数，我们可以通过 TensorFlow `SavedModel " +"`_. 的帮助将其保存在磁盘上。也就是说，只有 " "TensorFlow 后端的可即时编译量子函数才能保存在磁盘上。" -#: ../../source/advance.rst:44 +#: ../../source/advance.rst:54 msgid "" -"For the JAX-backend quantum function, one can first transform them into the " -"tf-backend function via JAX experimental support: `jax2tf `_." +"For the JAX-backend quantum function, one can first transform them into " +"the tf-backend function via JAX experimental support: `jax2tf " +"`_." msgstr "" -"对于 jax-backend 量子函数，可以先通过 jax 实验支持将它们转换为 tf-backend 函" -"数: `jax2tf `_。" +"对于 jax-backend 量子函数，可以先通过 jax 实验支持将它们转换为 tf-backend 函数: `jax2tf " +"`_。" -#: ../../source/advance.rst:46 +#: ../../source/advance.rst:56 msgid "" -"We wrap the tf-backend `SavedModel` as very easy-to-use function :py:meth:" -"`tensorcircuit.keras.save_func` and :py:meth:`tensorcircuit.keras.load_func`." +"We wrap the tf-backend `SavedModel` as very easy-to-use function " +":py:meth:`tensorcircuit.keras.save_func` and " +":py:meth:`tensorcircuit.keras.load_func`." msgstr "" -"我们将 tf-backend `SavedModel` 包装为非常易于使用的函数 :py:meth:" -"`tensorcircuit.keras.save_func` 和 :py:meth:`tensorcircuit.keras.load_func`。" +"我们将 tf-backend `SavedModel` 包装为非常易于使用的函数 " +":py:meth:`tensorcircuit.keras.save_func` 和 " +":py:meth:`tensorcircuit.keras.load_func`。" -#: ../../source/advance.rst:49 +#: ../../source/advance.rst:59 msgid "Parameterized Measurements" msgstr "参数化测量" -#: ../../source/advance.rst:51 +#: ../../source/advance.rst:61 msgid "" -"For plain measurements API on a ``tc.Circuit``, eg. `c = tc.Circuit(n=3)`, " -"if we want to evaluate the expectation :math:``, we need to call the " -"API as ``c.expectation((tc.gates.z(), [1]), (tc.gates.z(), [2]))``." +"For plain measurements API on a ``tc.Circuit``, eg. `c = " +"tc.Circuit(n=3)`, if we want to evaluate the expectation " +":math:``, we need to call the API as " +"``c.expectation((tc.gates.z(), [1]), (tc.gates.z(), [2]))``." msgstr "" -"对于 ``tc.Circuit`` 上的普通测量 API, 例如 `c = tc.Circuit(n=3)`, 如果我们要" -"评估期望 :math:``, 我们需要调用API为 ``c.expectation((tc.gates.z(), " -"[1]), (tc.gates.z(), [2]))``。" +"对于 ``tc.Circuit`` 上的普通测量 API, 例如 `c = tc.Circuit(n=3)`, 如果我们要评估期望 " +":math:``, 我们需要调用API为 ``c.expectation((tc.gates.z(), [1]), " +"(tc.gates.z(), [2]))``。" -#: ../../source/advance.rst:53 +#: ../../source/advance.rst:63 msgid "" "In some cases, we may want to tell the software what to measure but in a " -"tensor fashion. For example, if we want to get the above expectation, we can " -"use the following API: :py:meth:`tensorcircuit.templates.measurements." -"parameterized_measurements`." +"tensor fashion. For example, if we want to get the above expectation, we " +"can use the following API: " +":py:meth:`tensorcircuit.templates.measurements.parameterized_measurements`." msgstr "" -"在某些情况下，我们可能希望以张量形式告诉软件要测量什么。例如，如果我们想获得" -"上述期望，我们可以使用以下 API ： :py:meth:`tensorcircuit.templates." -"measurements.parameterized_measurements`。" +"在某些情况下，我们可能希望以张量形式告诉软件要测量什么。例如，如果我们想获得上述期望，我们可以使用以下 API ： " +":py:meth:`tensorcircuit.templates.measurements.parameterized_measurements`。" -#: ../../source/advance.rst:60 +#: ../../source/advance.rst:70 msgid "" -"This API corresponds to measure :math:`I_0Z_1Z_2I_3` where 0, 1, 2, 3 are " -"for local I, X, Y, and Z operators respectively." -msgstr "" -"此 API 对应于测量 :math:`I_0Z_1Z_2I_3`， 其中 0、1、2、3 分别用于 I、X、Y、Z " -"局部运算符。" +"This API corresponds to measure :math:`I_0Z_1Z_2I_3` where 0, 1, 2, 3 are" +" for local I, X, Y, and Z operators respectively." +msgstr "此 API 对应于测量 :math:`I_0Z_1Z_2I_3`， 其中 0、1、2、3 分别用于 I、X、Y、Z 局部运算符。" -#: ../../source/advance.rst:63 +#: ../../source/advance.rst:73 msgid "Sparse Matrix" msgstr "稀疏矩阵" -#: ../../source/advance.rst:65 +#: ../../source/advance.rst:75 msgid "" "We support COO format sparse matrix as most backends only support this " -"format, and some common backend methods for sparse matrices are listed below:" -msgstr "" -"我们只支持 COO 格式的稀疏矩阵，因为大多数后端只支持这种格式，下面列出了一些常" -"用的稀疏矩阵后端方法：" +"format, and some common backend methods for sparse matrices are listed " +"below:" +msgstr "我们只支持 COO 格式的稀疏矩阵，因为大多数后端只支持这种格式，下面列出了一些常用的稀疏矩阵后端方法：" -#: ../../source/advance.rst:80 +#: ../../source/advance.rst:90 msgid "" -"The sparse matrix is specifically useful to evaluate Hamiltonian expectation " -"on the circuit, where sparse matrix representation has a good tradeoff " -"between space and time. Please refer to :py:meth:`tensorcircuit.templates." -"measurements.sparse_expectation` for more detail." +"The sparse matrix is specifically useful to evaluate Hamiltonian " +"expectation on the circuit, where sparse matrix representation has a good" +" tradeoff between space and time. Please refer to " +":py:meth:`tensorcircuit.templates.measurements.sparse_expectation` for " +"more detail." msgstr "" -"稀疏矩阵对于评估电路上的哈密顿期望特别有用，其中稀疏矩阵表示在空间和时间之间" -"具有良好的效率。请参阅 :py:meth:`tensorcircuit.templates.measurements." -"sparse_expectation` 了解更多详细信息。" +"稀疏矩阵对于评估电路上的哈密顿期望特别有用，其中稀疏矩阵表示在空间和时间之间具有良好的效率。请参阅 " +":py:meth:`tensorcircuit.templates.measurements.sparse_expectation` " +"了解更多详细信息。" -#: ../../source/advance.rst:83 +#: ../../source/advance.rst:93 msgid "" "For different representations to evaluate Hamiltonian expectation in " "tensorcircuit, please refer to :doc:`tutorials/tfim_vqe_diffreph`." -msgstr "" -"对于在张量电路中评估哈密顿期望的不同表示，请参阅 :doc:`tutorials/" -"tfim_vqe_diffreph` 。" +msgstr "对于在张量电路中评估哈密顿期望的不同表示，请参阅 :doc:`tutorials/tfim_vqe_diffreph` 。" -#: ../../source/advance.rst:86 +#: ../../source/advance.rst:96 msgid "Randoms, Jit, Backend Agnostic, and Their Interplay" msgstr "随机数，即时编译，后端无关特性，和他们的相互作用" -#: ../../source/advance.rst:129 +#: ../../source/advance.rst:139 msgid "" -"Therefore, a unified jittable random infrastructure with backend agnostic " -"can be formulated as" +"Therefore, a unified jittable random infrastructure with backend agnostic" +" can be formulated as" msgstr "因此，一个与后端无关并且统一可即时编译的随机基础设施可以表述为" -#: ../../source/advance.rst:157 +#: ../../source/advance.rst:167 msgid "And a more neat approach to achieve this is as follows:" msgstr "实现这一目标的更简洁的方法如下：" -#: ../../source/advance.rst:172 +#: ../../source/advance.rst:182 msgid "" -"It is worth noting that since ``Circuit.unitary_kraus`` and ``Circuit." -"general_kraus`` call ``implicit_rand*`` API, the correct usage of these APIs " -"is the same as above." +"It is worth noting that since ``Circuit.unitary_kraus`` and " +"``Circuit.general_kraus`` call ``implicit_rand*`` API, the correct usage " +"of these APIs is the same as above." msgstr "" -"值得注意的是，由于 ``Circuit.unitary_kraus`` 和 ``Circuit.general_kraus`` 调" -"用 ``implicit_rand*`` API，这些 API 的正确用法与上面相同。" +"值得注意的是，由于 ``Circuit.unitary_kraus`` 和 ``Circuit.general_kraus`` 调用 " +"``implicit_rand*`` API，这些 API 的正确用法与上面相同。" -#: ../../source/advance.rst:174 +#: ../../source/advance.rst:184 msgid "" "One may wonder why random numbers are dealt in such a complicated way, " -"please refer to the `Jax design note `_ for some hints." +"please refer to the `Jax design note " +"`_ for" +" some hints." msgstr "" "有人可能想知道为什么以如此复杂的方式处理随机数，请参阅 `Jax 设计说明 " -"`_ 提示。" +"`_ " +"提示。" + +#: ../../source/advance.rst:186 +msgid "" +"If vmap is also involved apart from jit, I currently find no way to " +"maintain the backend agnosticity as TensorFlow seems to have no support " +"of vmap over random keys (ping me on GitHub if you think you have a way " +"to do this). I strongly recommend the users using Jax backend in the " +"vmap+random setup." +msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/api.po b/docs/source/locale/zh/LC_MESSAGES/api.po index da199805..e46120b1 100644 --- a/docs/source/locale/zh/LC_MESSAGES/api.po +++ b/docs/source/locale/zh/LC_MESSAGES/api.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2022-06-27 20:10+0800\n" +"POT-Creation-Date: 2023-01-13 11:04+0800\n" "PO-Revision-Date: 2022-04-13 14:58+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -18,23 +18,97 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.9.1\n" -#: ../../source/api/applications.rst:2 -msgid "tensorcircuit.applications" +#: ../../source/api/abstractcircuit.rst:2 +msgid "tensorcircuit.abstractcircuit" msgstr "" -#: ../../source/api/applications/dqas.rst:2 -msgid "tensorcircuit.applications.dqas" +#: of tensorcircuit.abstractcircuit:1 +msgid "Methods for abstract circuits independent of nodes, edges and contractions" msgstr "" -#: of tensorcircuit.applications.dqas:1 -msgid "Modules for DQAS framework" +#: of tensorcircuit.abstractcircuit.AbstractCircuit:1 +#: tensorcircuit.applications.utils.FakeModule:1 +#: tensorcircuit.applications.vqes.VQNHE:1 +#: tensorcircuit.backends.jax_backend.optax_optimizer:1 +#: tensorcircuit.backends.pytorch_backend.torch_optimizer:1 +#: tensorcircuit.backends.tensorflow_backend.keras_optimizer:1 +#: tensorcircuit.gates.GateF:1 tensorcircuit.noisemodel.NoiseConf:1 +#: tensorcircuit.quantum.QuOperator:1 +#: tensorcircuit.results.readout_mitigation.ReadoutMit:1 +#: tensorcircuit.templates.graphs.Grid2DCoord:1 +msgid "Bases: :py:class:`object`" msgstr "" -#: of tensorcircuit.applications.dqas.DQAS_search:1 -msgid "DQAS framework entrypoint" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append:1 +msgid "append circuit ``c`` before" +msgstr "" + +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append +#: tensorcircuit.templates.measurements.any_local_measurements +#: tensorcircuit.templates.measurements.any_measurements +#: tensorcircuit.templates.measurements.heisenberg_measurements +#: tensorcircuit.templates.measurements.spin_glass_measurements +msgid "example" msgstr "" -#: of tensorcircuit.applications.dqas.DQAS_search +#: keras.engine.base_layer.Layer.add_loss +#: keras.engine.base_layer.Layer.add_metric +#: keras.engine.base_layer.Layer.add_update +#: keras.engine.base_layer.Layer.add_weight keras.engine.base_layer.Layer.apply +#: keras.engine.base_layer.Layer.build +#: keras.engine.base_layer.Layer.compute_mask +#: keras.engine.base_layer.Layer.compute_output_shape +#: keras.engine.base_layer.Layer.compute_output_signature +#: keras.engine.base_layer.Layer.from_config +#: keras.engine.base_layer.Layer.get_input_at +#: keras.engine.base_layer.Layer.get_input_mask_at +#: keras.engine.base_layer.Layer.get_input_shape_at +#: keras.engine.base_layer.Layer.get_losses_for +#: keras.engine.base_layer.Layer.get_output_at +#: keras.engine.base_layer.Layer.get_output_mask_at +#: keras.engine.base_layer.Layer.get_output_shape_at +#: keras.engine.base_layer.Layer.get_updates_for +#: keras.engine.base_layer.Layer.set_weights keras.engine.training.Model.build +#: keras.engine.training.Model.compile keras.engine.training.Model.evaluate +#: keras.engine.training.Model.fit keras.engine.training.Model.from_config +#: keras.engine.training.Model.get_layer +#: keras.engine.training.Model.load_weights +#: keras.engine.training.Model.make_predict_function +#: keras.engine.training.Model.make_test_function +#: keras.engine.training.Model.make_train_function +#: keras.engine.training.Model.predict +#: keras.engine.training.Model.predict_on_batch +#: keras.engine.training.Model.predict_step keras.engine.training.Model.save +#: keras.engine.training.Model.save_spec +#: keras.engine.training.Model.save_weights keras.engine.training.Model.summary +#: keras.engine.training.Model.test_on_batch +#: keras.engine.training.Model.test_step keras.engine.training.Model.to_json +#: keras.engine.training.Model.to_yaml +#: keras.engine.training.Model.train_on_batch +#: keras.engine.training.Model.train_step +#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append +#: tensorcircuit.abstractcircuit.AbstractCircuit.append_from_qir +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply +#: tensorcircuit.abstractcircuit.AbstractCircuit.barrier_instruction +#: tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement +#: tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_json +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_json_file +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_qir +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit +#: tensorcircuit.abstractcircuit.AbstractCircuit.gate_count +#: tensorcircuit.abstractcircuit.AbstractCircuit.initial_mapping +#: tensorcircuit.abstractcircuit.AbstractCircuit.inverse +#: tensorcircuit.abstractcircuit.AbstractCircuit.measure_instruction +#: tensorcircuit.abstractcircuit.AbstractCircuit.prepend +#: tensorcircuit.abstractcircuit.AbstractCircuit.reset_instruction +#: tensorcircuit.abstractcircuit.AbstractCircuit.select_gate +#: tensorcircuit.abstractcircuit.AbstractCircuit.standardize_gate +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_json +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit +#: tensorcircuit.applications.dqas.DQAS_search #: tensorcircuit.applications.dqas.DQAS_search_pmb #: tensorcircuit.applications.dqas.get_var #: tensorcircuit.applications.dqas.get_weights @@ -67,8 +141,46 @@ msgstr "" #: tensorcircuit.applications.vags.tfim_measurements #: tensorcircuit.applications.vags.unitary_design #: tensorcircuit.applications.vags.unitary_design_block +#: tensorcircuit.applications.van.MADE.call +#: tensorcircuit.applications.van.MaskedConv2D.build +#: tensorcircuit.applications.van.MaskedConv2D.call +#: tensorcircuit.applications.van.MaskedLinear.call +#: tensorcircuit.applications.van.NMF.call +#: tensorcircuit.applications.van.PixelCNN.call +#: tensorcircuit.applications.van.ResidualBlock.call +#: tensorcircuit.applications.vqes.Linear.call #: tensorcircuit.applications.vqes.VQNHE.evaluation #: tensorcircuit.applications.vqes.VQNHE.plain_evaluation +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.adjoint +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix_from_numpy +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.from_dlpack +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.gather1d +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.get_random_state +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.jacfwd +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.jacrev +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.random_split +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshape2 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshapem +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reverse +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.set_random_state +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sizen +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sqrtmh +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dlpack +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_flatten +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_unflatten #: tensorcircuit.backends.backend_factory.get_backend #: tensorcircuit.backends.jax_backend.JaxBackend.acos #: tensorcircuit.backends.jax_backend.JaxBackend.acosh @@ -79,16 +191,20 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.asinh #: tensorcircuit.backends.jax_backend.JaxBackend.atan #: tensorcircuit.backends.jax_backend.JaxBackend.atan2 +#: tensorcircuit.backends.jax_backend.JaxBackend.atanh #: tensorcircuit.backends.jax_backend.JaxBackend.cast #: tensorcircuit.backends.jax_backend.JaxBackend.concat #: tensorcircuit.backends.jax_backend.JaxBackend.cond #: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix #: tensorcircuit.backends.jax_backend.JaxBackend.copy -#: tensorcircuit.backends.jax_backend.JaxBackend.cos #: tensorcircuit.backends.jax_backend.JaxBackend.cosh #: tensorcircuit.backends.jax_backend.JaxBackend.cumsum +#: tensorcircuit.backends.jax_backend.JaxBackend.device +#: tensorcircuit.backends.jax_backend.JaxBackend.device_move +#: tensorcircuit.backends.jax_backend.JaxBackend.dtype #: tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh -#: tensorcircuit.backends.jax_backend.JaxBackend.expm +#: tensorcircuit.backends.jax_backend.JaxBackend.eye +#: tensorcircuit.backends.jax_backend.JaxBackend.from_dlpack #: tensorcircuit.backends.jax_backend.JaxBackend.grad #: tensorcircuit.backends.jax_backend.JaxBackend.i #: tensorcircuit.backends.jax_backend.JaxBackend.imag @@ -97,7 +213,6 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu #: tensorcircuit.backends.jax_backend.JaxBackend.is_sparse #: tensorcircuit.backends.jax_backend.JaxBackend.is_tensor -#: tensorcircuit.backends.jax_backend.JaxBackend.jit #: tensorcircuit.backends.jax_backend.JaxBackend.jvp #: tensorcircuit.backends.jax_backend.JaxBackend.kron #: tensorcircuit.backends.jax_backend.JaxBackend.left_shift @@ -112,9 +227,9 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.relu #: tensorcircuit.backends.jax_backend.JaxBackend.right_shift #: tensorcircuit.backends.jax_backend.JaxBackend.scatter +#: tensorcircuit.backends.jax_backend.JaxBackend.searchsorted #: tensorcircuit.backends.jax_backend.JaxBackend.set_random_state #: tensorcircuit.backends.jax_backend.JaxBackend.sigmoid -#: tensorcircuit.backends.jax_backend.JaxBackend.sin #: tensorcircuit.backends.jax_backend.JaxBackend.sinh #: tensorcircuit.backends.jax_backend.JaxBackend.size #: tensorcircuit.backends.jax_backend.JaxBackend.softmax @@ -124,12 +239,14 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu +#: tensorcircuit.backends.jax_backend.JaxBackend.std #: tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient #: tensorcircuit.backends.jax_backend.JaxBackend.switch #: tensorcircuit.backends.jax_backend.JaxBackend.tan #: tensorcircuit.backends.jax_backend.JaxBackend.tanh #: tensorcircuit.backends.jax_backend.JaxBackend.tile #: tensorcircuit.backends.jax_backend.JaxBackend.to_dense +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dlpack #: tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten #: tensorcircuit.backends.jax_backend.JaxBackend.tree_map #: tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten @@ -138,6 +255,7 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad #: tensorcircuit.backends.jax_backend.JaxBackend.vjp #: tensorcircuit.backends.jax_backend.JaxBackend.vmap +#: tensorcircuit.backends.jax_backend._svd_jax #: tensorcircuit.backends.numpy_backend.NumpyBackend.acos #: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh #: tensorcircuit.backends.numpy_backend.NumpyBackend.arange @@ -147,22 +265,24 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atanh #: tensorcircuit.backends.numpy_backend.NumpyBackend.cast #: tensorcircuit.backends.numpy_backend.NumpyBackend.concat #: tensorcircuit.backends.numpy_backend.NumpyBackend.cond #: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix #: tensorcircuit.backends.numpy_backend.NumpyBackend.copy -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cos #: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh #: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move +#: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype #: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh -#: tensorcircuit.backends.numpy_backend.NumpyBackend.expm +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye #: tensorcircuit.backends.numpy_backend.NumpyBackend.grad #: tensorcircuit.backends.numpy_backend.NumpyBackend.i #: tensorcircuit.backends.numpy_backend.NumpyBackend.imag #: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse #: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jit #: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp #: tensorcircuit.backends.numpy_backend.NumpyBackend.kron #: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift @@ -176,9 +296,9 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.relu #: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift #: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter +#: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted #: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state #: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sin #: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh #: tensorcircuit.backends.numpy_backend.NumpyBackend.size #: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax @@ -188,6 +308,7 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu +#: tensorcircuit.backends.numpy_backend.NumpyBackend.std #: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient #: tensorcircuit.backends.numpy_backend.NumpyBackend.switch #: tensorcircuit.backends.numpy_backend.NumpyBackend.tan @@ -208,20 +329,23 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atanh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.concat #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.from_dlpack #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift @@ -235,18 +359,20 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.to_dlpack #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten @@ -255,6 +381,8 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap +#: tensorcircuit.backends.pytorch_backend._qr_torch +#: tensorcircuit.backends.pytorch_backend._rq_torch #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange @@ -264,23 +392,26 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atanh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.concat #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.from_dlpack #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift @@ -294,9 +425,9 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax @@ -306,71 +437,92 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dlpack #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap +#: tensorcircuit.backends.tensorflow_backend._qr_tf +#: tensorcircuit.backends.tensorflow_backend._rq_tf +#: tensorcircuit.backends.tensorflow_backend._tensordot_tf +#: tensorcircuit.basecircuit.BaseCircuit.amplitude +#: tensorcircuit.basecircuit.BaseCircuit.cond_measurement +#: tensorcircuit.basecircuit.BaseCircuit.expectation_before +#: tensorcircuit.basecircuit.BaseCircuit.measure_jit +#: tensorcircuit.basecircuit.BaseCircuit.perfect_sampling +#: tensorcircuit.basecircuit.BaseCircuit.readouterror_bs +#: tensorcircuit.basecircuit.BaseCircuit.replace_inputs +#: tensorcircuit.basecircuit.BaseCircuit.sample +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps #: tensorcircuit.channels.amplitudedampingchannel -#: tensorcircuit.channels.depolarizingchannel +#: tensorcircuit.channels.check_rep_transformation +#: tensorcircuit.channels.choi_to_kraus tensorcircuit.channels.choi_to_super +#: tensorcircuit.channels.composedkraus +#: tensorcircuit.channels.depolarizingchannel tensorcircuit.channels.evol_kraus +#: tensorcircuit.channels.evol_superop +#: tensorcircuit.channels.generaldepolarizingchannel +#: tensorcircuit.channels.is_hermitian_matrix +#: tensorcircuit.channels.kraus_identity_check +#: tensorcircuit.channels.kraus_to_choi tensorcircuit.channels.kraus_to_super #: tensorcircuit.channels.kraus_to_super_gate -#: tensorcircuit.channels.phasedampingchannel -#: tensorcircuit.channels.single_qubit_kraus_identity_check +#: tensorcircuit.channels.krausgate_to_krausmatrix +#: tensorcircuit.channels.krausmatrix_to_krausgate +#: tensorcircuit.channels.phasedampingchannel tensorcircuit.channels.reshuffle +#: tensorcircuit.channels.super_to_choi tensorcircuit.channels.super_to_kraus +#: tensorcircuit.channels.thermalrelaxationchannel #: tensorcircuit.circuit.Circuit.__init__ -#: tensorcircuit.circuit.Circuit.amplitude -#: tensorcircuit.circuit.Circuit.append_from_qir -#: tensorcircuit.circuit.Circuit.apply_double_gate -#: tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply -#: tensorcircuit.circuit.Circuit.apply_single_gate -#: tensorcircuit.circuit.Circuit.cond_measurement -#: tensorcircuit.circuit.Circuit.depolarizing +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply +#: tensorcircuit.circuit.Circuit.depolarizing_reference #: tensorcircuit.circuit.Circuit.expectation -#: tensorcircuit.circuit.Circuit.expectation_before -#: tensorcircuit.circuit.Circuit.from_qir -#: tensorcircuit.circuit.Circuit.from_qiskit #: tensorcircuit.circuit.Circuit.general_kraus -#: tensorcircuit.circuit.Circuit.measure_jit #: tensorcircuit.circuit.Circuit.measure_reference #: tensorcircuit.circuit.Circuit.mid_measurement -#: tensorcircuit.circuit.Circuit.replace_inputs #: tensorcircuit.circuit.Circuit.replace_mps_inputs -#: tensorcircuit.circuit.Circuit.sample -#: tensorcircuit.circuit.Circuit.select_gate #: tensorcircuit.circuit.Circuit.unitary_kraus -#: tensorcircuit.circuit.Circuit.wavefunction -#: tensorcircuit.circuit._expectation_ps tensorcircuit.circuit.expectation +#: tensorcircuit.circuit.Circuit.wavefunction tensorcircuit.circuit.expectation #: tensorcircuit.cons.get_contractor tensorcircuit.cons.get_dtype #: tensorcircuit.cons.plain_contractor tensorcircuit.cons.runtime_backend #: tensorcircuit.cons.runtime_dtype tensorcircuit.cons.set_contractor #: tensorcircuit.cons.set_dtype tensorcircuit.cons.set_function_backend #: tensorcircuit.cons.set_function_dtype -#: tensorcircuit.cons.set_tensornetwork_backend +#: tensorcircuit.cons.set_tensornetwork_backend tensorcircuit.cons.split_rules #: tensorcircuit.densitymatrix.DMCircuit.__init__ -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply #: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply #: tensorcircuit.densitymatrix.DMCircuit.densitymatrix #: tensorcircuit.densitymatrix.DMCircuit.expectation -#: tensorcircuit.densitymatrix.DMCircuit.measure_jit -#: tensorcircuit.densitymatrix2.DMCircuit2.apply_general_kraus_delayed..apply +#: tensorcircuit.densitymatrix.DMCircuit.to_circuit +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply +#: tensorcircuit.experimental.hamiltonian_evol +#: tensorcircuit.experimental.parameter_shift_grad +#: tensorcircuit.experimental.parameter_shift_grad_v2 #: tensorcircuit.gates.any_gate tensorcircuit.gates.bmatrix #: tensorcircuit.gates.cr_gate tensorcircuit.gates.exponential_gate -#: tensorcircuit.gates.exponential_gate_unity tensorcircuit.gates.iswap_gate -#: tensorcircuit.gates.matrix_for_gate tensorcircuit.gates.num_to_tensor +#: tensorcircuit.gates.exponential_gate_unity +#: tensorcircuit.gates.get_u_parameter tensorcircuit.gates.iswap_gate +#: tensorcircuit.gates.matrix_for_gate tensorcircuit.gates.multicontrol_gate +#: tensorcircuit.gates.num_to_tensor tensorcircuit.gates.phase_gate #: tensorcircuit.gates.r_gate tensorcircuit.gates.rgate_theoretical #: tensorcircuit.gates.rx_gate tensorcircuit.gates.rxx_gate #: tensorcircuit.gates.ry_gate tensorcircuit.gates.ryy_gate #: tensorcircuit.gates.rz_gate tensorcircuit.gates.rzz_gate -#: tensorcircuit.interfaces.scipy_optimize_interface -#: tensorcircuit.interfaces.torch_interface -#: tensorcircuit.keras.QuantumLayer.__init__ tensorcircuit.keras.load_func +#: tensorcircuit.gates.u_gate tensorcircuit.interfaces.numpy.numpy_interface +#: tensorcircuit.interfaces.scipy.scipy_optimize_interface +#: tensorcircuit.interfaces.tensorflow.tensorflow_interface +#: tensorcircuit.interfaces.tensortrans.args_to_tensor +#: tensorcircuit.interfaces.tensortrans.general_args_to_numpy +#: tensorcircuit.interfaces.tensortrans.numpy_args_to_backend +#: tensorcircuit.interfaces.tensortrans.which_backend +#: tensorcircuit.interfaces.torch.torch_interface +#: tensorcircuit.keras.QuantumLayer.__init__ +#: tensorcircuit.keras.QuantumLayer.build tensorcircuit.keras.load_func #: tensorcircuit.keras.output_asis_loss tensorcircuit.keras.save_func #: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate #: tensorcircuit.mps_base.FiniteMPS.measure_local_operator @@ -379,21 +531,22 @@ msgstr "" #: tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate #: tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate #: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply #: tensorcircuit.mpscircuit.MPSCircuit.apply_single_gate -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_double_gates -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_single_gate -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product -#: tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction -#: tensorcircuit.mpscircuit.MPSCircuit.general_expectation +#: tensorcircuit.mpscircuit.MPSCircuit.expectation #: tensorcircuit.mpscircuit.MPSCircuit.measure #: tensorcircuit.mpscircuit.MPSCircuit.mid_measurement #: tensorcircuit.mpscircuit.MPSCircuit.position #: tensorcircuit.mpscircuit.MPSCircuit.proj_with_mps -#: tensorcircuit.mpscircuit.MPSCircuit.set_truncation_rule +#: tensorcircuit.mpscircuit.MPSCircuit.set_split_rules #: tensorcircuit.mpscircuit.MPSCircuit.wavefunction -#: tensorcircuit.mpscircuit.split_tensor tensorcircuit.quantum.PauliString2COO +#: tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors +#: tensorcircuit.mpscircuit.split_tensor +#: tensorcircuit.noisemodel.NoiseConf.add_noise +#: tensorcircuit.noisemodel.apply_qir_with_noise +#: tensorcircuit.noisemodel.circuit_with_noise +#: tensorcircuit.noisemodel.expectation_noisfy +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy +#: tensorcircuit.quantum.PauliString2COO #: tensorcircuit.quantum.PauliStringSum2COO #: tensorcircuit.quantum.PauliStringSum2COO_numpy #: tensorcircuit.quantum.PauliStringSum2COO_tf @@ -415,7 +568,10 @@ msgstr "" #: tensorcircuit.quantum.QuVector.reduced_density #: tensorcircuit.quantum.check_spaces #: tensorcircuit.quantum.correlation_from_counts -#: tensorcircuit.quantum.double_state +#: tensorcircuit.quantum.correlation_from_samples +#: tensorcircuit.quantum.count_d2s tensorcircuit.quantum.count_s2d +#: tensorcircuit.quantum.count_tuple2dict +#: tensorcircuit.quantum.count_vector2dict tensorcircuit.quantum.double_state #: tensorcircuit.quantum.eliminate_identities tensorcircuit.quantum.entropy #: tensorcircuit.quantum.fidelity tensorcircuit.quantum.free_energy #: tensorcircuit.quantum.generate_local_hamiltonian @@ -426,9 +582,22 @@ msgstr "" #: tensorcircuit.quantum.quantum_constructor tensorcircuit.quantum.quimb2qop #: tensorcircuit.quantum.reduced_density_matrix #: tensorcircuit.quantum.renyi_entropy tensorcircuit.quantum.renyi_free_energy +#: tensorcircuit.quantum.sample2all tensorcircuit.quantum.sample2count +#: tensorcircuit.quantum.sample_bin2int tensorcircuit.quantum.sample_int2bin #: tensorcircuit.quantum.spin_by_basis tensorcircuit.quantum.taylorlnm #: tensorcircuit.quantum.tn2qop tensorcircuit.quantum.trace_distance #: tensorcircuit.quantum.truncated_free_energy +#: tensorcircuit.results.counts.expectation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.__init__ +#: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_correction +#: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_readout_mitigation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_system +#: tensorcircuit.results.readout_mitigation.ReadoutMit.expectation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.get_matrix +#: tensorcircuit.results.readout_mitigation.ReadoutMit.mapping_preprocess +#: tensorcircuit.results.readout_mitigation.ReadoutMit.mitigate_probability +#: tensorcircuit.results.readout_mitigation.ReadoutMit.newrange +#: tensorcircuit.results.readout_mitigation.ReadoutMit.ubs #: tensorcircuit.simplify.infer_new_shape #: tensorcircuit.simplify.pseudo_contract_between #: tensorcircuit.templates.blocks.Bell_pair_block @@ -440,125 +609,197 @@ msgstr "" #: tensorcircuit.templates.graphs.Grid2DCoord.all_rows #: tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph #: tensorcircuit.templates.graphs.Line1D +#: tensorcircuit.templates.measurements.any_local_measurements #: tensorcircuit.templates.measurements.any_measurements #: tensorcircuit.templates.measurements.heisenberg_measurements #: tensorcircuit.templates.measurements.mpo_expectation #: tensorcircuit.templates.measurements.operator_expectation #: tensorcircuit.templates.measurements.sparse_expectation #: tensorcircuit.templates.measurements.spin_glass_measurements -#: tensorcircuit.torchnn.QuantumNet.__init__ -#: tensorcircuit.translation.perm_matrix tensorcircuit.translation.qir2qiskit -#: tensorcircuit.translation.qiskit2tc tensorcircuit.utils.append +#: tensorcircuit.torchnn.QuantumNet.__init__ tensorcircuit.translation.eqasm2tc +#: tensorcircuit.translation.perm_matrix tensorcircuit.translation.qir2json +#: tensorcircuit.translation.qir2qiskit tensorcircuit.translation.qiskit2tc +#: tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure +#: tensorcircuit.utils.append tensorcircuit.utils.arg_alias #: tensorcircuit.utils.benchmark tensorcircuit.utils.return_partial #: tensorcircuit.vis.gate_name_trans tensorcircuit.vis.qir2tex #: tensorcircuit.vis.render_pdf +#: tensorflow.python.module.module.Module.with_name_scope +#: tensornetwork.backends.abstract_backend.AbstractBackend.deserialize_tensor +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigs +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos +#: tensornetwork.backends.abstract_backend.AbstractBackend.gmres +#: tensornetwork.backends.abstract_backend.AbstractBackend.pivot +#: tensornetwork.backends.abstract_backend.AbstractBackend.power +#: tensornetwork.backends.abstract_backend.AbstractBackend.serialize_tensor +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigh +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eps +#: tensornetwork.backends.jax.jax_backend.JaxBackend.index_update +#: tensornetwork.backends.jax.jax_backend.JaxBackend.inv +#: tensornetwork.backends.jax.jax_backend.JaxBackend.item +#: tensornetwork.backends.jax.jax_backend.JaxBackend.power +#: tensornetwork.backends.jax.jax_backend.JaxBackend.reshape +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sign +#: tensornetwork.backends.jax.jax_backend.JaxBackend.slice +#: tensornetwork.backends.jax.jax_backend.JaxBackend.tensordot +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.deserialize_tensor +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.item +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.reshape +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.serialize_tensor +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tensor +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tuple +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.sign +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.slice +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.tensordot +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.item +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.reshape +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tensor +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tuple +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.sign +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.slice +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.tensordot +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.item +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.reshape +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tensor +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sign +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.position +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.__init__ +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.random +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs +#: tensornetwork.network_components.AbstractNode.add_axis_names +#: tensornetwork.network_components.AbstractNode.add_edge +#: tensornetwork.network_components.AbstractNode.get_dimension +#: tensornetwork.network_components.AbstractNode.reorder_axes +#: tensornetwork.network_components.AbstractNode.reorder_edges +#: tensornetwork.network_components.Node.__init__ +#: tensornetwork.network_components.Node.from_serial_dict +#: torch.nn.modules.module.Module.add_module +#: torch.nn.modules.module.Module.apply torch.nn.modules.module.Module.buffers +#: torch.nn.modules.module.Module.cuda +#: torch.nn.modules.module.Module.get_buffer +#: torch.nn.modules.module.Module.get_parameter +#: torch.nn.modules.module.Module.get_submodule +#: torch.nn.modules.module.Module.load_state_dict +#: torch.nn.modules.module.Module.named_buffers +#: torch.nn.modules.module.Module.named_modules +#: torch.nn.modules.module.Module.named_parameters +#: torch.nn.modules.module.Module.parameters +#: torch.nn.modules.module.Module.register_buffer +#: torch.nn.modules.module.Module.register_parameter +#: torch.nn.modules.module.Module.requires_grad_ +#: torch.nn.modules.module.Module.set_extra_state +#: torch.nn.modules.module.Module.to torch.nn.modules.module.Module.to_empty +#: torch.nn.modules.module.Module.train torch.nn.modules.module.Module.type +#: torch.nn.modules.module.Module.xpu torch.nn.modules.module.Module.zero_grad msgid "Parameters" msgstr "" -#: of tensorcircuit.applications.dqas.DQAS_search:3 -msgid "" -"function with input of data instance, circuit parameters theta and " -"structural paramter k, return tuple of objective value and gradient with " -"respect to theta" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:5 -msgid "data generator as dataset" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:6 -msgid "list of operations as primitive operator pool" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:7 -msgid "the default layer number of the circuit ansatz" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:8 -msgid "" -"shape of circuit parameter pool, in general p_stp*l, where l is the max " -"number of circuit parameters for op in the operator pool" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:10 -msgid "the same as p in the most times" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:11 -msgid "batch size of one epoch" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:12 -msgid "prethermal update times" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:13 -msgid "training epochs" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:14 -msgid "parallel thread number, 0 to disable multiprocessing model by default" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:15 -msgid "set verbose log to print" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:16 -msgid "function to output verbose information" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:17 -msgid "function return intermiediate result for final history list" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:18 -msgid "cutoff probability to avoid peak distribution" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:19 -msgid "" -"function accepting list of objective values and return the baseline value" -" used in the next round" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:21 -msgid "return noise with the same shape as circuit parameter pool" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:22 -msgid "initial values for circuit parameter pool" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:23 -msgid "initial values for probabilistic model parameters" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:24 -msgid "optimizer for circuit parameters theta" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:25 -msgid "optimizer for model parameters alpha" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:26 -msgid "optimizer for circuit parameters in prethermal stage" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:27 -msgid "fixed structural parameters for prethermal training" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:28 -msgid "regularization function for model parameters alpha" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search:29 -msgid "regularization function for circuit parameters theta" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append:19 +msgid "The other circuit to be appended" +msgstr "" + +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append:21 +msgid "" +"the qubit indices to which ``c`` is appended on. Defaults to None, which " +"means plain concatenation." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight keras.engine.base_layer.Layer.apply +#: keras.engine.base_layer.Layer.compute_mask +#: keras.engine.base_layer.Layer.compute_output_shape +#: keras.engine.base_layer.Layer.compute_output_signature +#: keras.engine.base_layer.Layer.count_params +#: keras.engine.base_layer.Layer.from_config +#: keras.engine.base_layer.Layer.get_config +#: keras.engine.base_layer.Layer.get_input_at +#: keras.engine.base_layer.Layer.get_input_mask_at +#: keras.engine.base_layer.Layer.get_input_shape_at +#: keras.engine.base_layer.Layer.get_losses_for +#: keras.engine.base_layer.Layer.get_output_at +#: keras.engine.base_layer.Layer.get_output_mask_at +#: keras.engine.base_layer.Layer.get_output_shape_at +#: keras.engine.base_layer.Layer.get_updates_for +#: keras.engine.base_layer.Layer.get_weights +#: keras.engine.training.Model.evaluate keras.engine.training.Model.fit +#: keras.engine.training.Model.from_config +#: keras.engine.training.Model.get_config keras.engine.training.Model.get_layer +#: keras.engine.training.Model.get_weights +#: keras.engine.training.Model.load_weights +#: keras.engine.training.Model.make_predict_function +#: keras.engine.training.Model.make_test_function +#: keras.engine.training.Model.make_train_function +#: keras.engine.training.Model.predict +#: keras.engine.training.Model.predict_on_batch +#: keras.engine.training.Model.predict_step +#: keras.engine.training.Model.save_spec +#: keras.engine.training.Model.test_on_batch +#: keras.engine.training.Model.test_step keras.engine.training.Model.to_json +#: keras.engine.training.Model.to_yaml +#: keras.engine.training.Model.train_on_batch +#: keras.engine.training.Model.train_step +#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append +#: tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement +#: tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_json +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_json_file +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_qir +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit +#: tensorcircuit.abstractcircuit.AbstractCircuit.gate_count +#: tensorcircuit.abstractcircuit.AbstractCircuit.gate_summary +#: tensorcircuit.abstractcircuit.AbstractCircuit.get_positional_logical_mapping +#: tensorcircuit.abstractcircuit.AbstractCircuit.initial_mapping +#: tensorcircuit.abstractcircuit.AbstractCircuit.inverse +#: tensorcircuit.abstractcircuit.AbstractCircuit.prepend +#: tensorcircuit.abstractcircuit.AbstractCircuit.standardize_gate +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_json +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_openqasm +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_qir +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit +#: tensorcircuit.abstractcircuit.AbstractCircuit.vis_tex +#: tensorcircuit.applications.dqas.DQAS_search #: tensorcircuit.applications.dqas.DQAS_search_pmb #: tensorcircuit.applications.dqas.get_var #: tensorcircuit.applications.dqas.get_weights @@ -591,9 +832,167 @@ msgstr "" #: tensorcircuit.applications.vags.tfim_measurements #: tensorcircuit.applications.vags.unitary_design #: tensorcircuit.applications.vags.unitary_design_block +#: tensorcircuit.applications.van.MADE.call +#: tensorcircuit.applications.van.MADE.compute_dtype +#: tensorcircuit.applications.van.MADE.input +#: tensorcircuit.applications.van.MADE.input_mask +#: tensorcircuit.applications.van.MADE.input_shape +#: tensorcircuit.applications.van.MADE.input_spec +#: tensorcircuit.applications.van.MADE.losses +#: tensorcircuit.applications.van.MADE.non_trainable_variables +#: tensorcircuit.applications.van.MADE.non_trainable_weights +#: tensorcircuit.applications.van.MADE.output +#: tensorcircuit.applications.van.MADE.output_mask +#: tensorcircuit.applications.van.MADE.output_shape +#: tensorcircuit.applications.van.MADE.run_eagerly +#: tensorcircuit.applications.van.MADE.state_updates +#: tensorcircuit.applications.van.MADE.submodules +#: tensorcircuit.applications.van.MADE.trainable_variables +#: tensorcircuit.applications.van.MADE.trainable_weights +#: tensorcircuit.applications.van.MADE.variables +#: tensorcircuit.applications.van.MADE.weights +#: tensorcircuit.applications.van.MaskedConv2D.call +#: tensorcircuit.applications.van.MaskedConv2D.compute_dtype +#: tensorcircuit.applications.van.MaskedConv2D.input +#: tensorcircuit.applications.van.MaskedConv2D.input_mask +#: tensorcircuit.applications.van.MaskedConv2D.input_shape +#: tensorcircuit.applications.van.MaskedConv2D.input_spec +#: tensorcircuit.applications.van.MaskedConv2D.losses +#: tensorcircuit.applications.van.MaskedConv2D.metrics +#: tensorcircuit.applications.van.MaskedConv2D.non_trainable_variables +#: tensorcircuit.applications.van.MaskedConv2D.non_trainable_weights +#: tensorcircuit.applications.van.MaskedConv2D.output +#: tensorcircuit.applications.van.MaskedConv2D.output_mask +#: tensorcircuit.applications.van.MaskedConv2D.output_shape +#: tensorcircuit.applications.van.MaskedConv2D.submodules +#: tensorcircuit.applications.van.MaskedConv2D.trainable_variables +#: tensorcircuit.applications.van.MaskedConv2D.trainable_weights +#: tensorcircuit.applications.van.MaskedConv2D.variables +#: tensorcircuit.applications.van.MaskedConv2D.weights +#: tensorcircuit.applications.van.MaskedLinear.call +#: tensorcircuit.applications.van.MaskedLinear.compute_dtype +#: tensorcircuit.applications.van.MaskedLinear.input +#: tensorcircuit.applications.van.MaskedLinear.input_mask +#: tensorcircuit.applications.van.MaskedLinear.input_shape +#: tensorcircuit.applications.van.MaskedLinear.input_spec +#: tensorcircuit.applications.van.MaskedLinear.losses +#: tensorcircuit.applications.van.MaskedLinear.metrics +#: tensorcircuit.applications.van.MaskedLinear.non_trainable_variables +#: tensorcircuit.applications.van.MaskedLinear.non_trainable_weights +#: tensorcircuit.applications.van.MaskedLinear.output +#: tensorcircuit.applications.van.MaskedLinear.output_mask +#: tensorcircuit.applications.van.MaskedLinear.output_shape +#: tensorcircuit.applications.van.MaskedLinear.submodules +#: tensorcircuit.applications.van.MaskedLinear.trainable_variables +#: tensorcircuit.applications.van.MaskedLinear.trainable_weights +#: tensorcircuit.applications.van.MaskedLinear.variables +#: tensorcircuit.applications.van.MaskedLinear.weights +#: tensorcircuit.applications.van.NMF.call +#: tensorcircuit.applications.van.NMF.compute_dtype +#: tensorcircuit.applications.van.NMF.input +#: tensorcircuit.applications.van.NMF.input_mask +#: tensorcircuit.applications.van.NMF.input_shape +#: tensorcircuit.applications.van.NMF.input_spec +#: tensorcircuit.applications.van.NMF.losses +#: tensorcircuit.applications.van.NMF.non_trainable_variables +#: tensorcircuit.applications.van.NMF.non_trainable_weights +#: tensorcircuit.applications.van.NMF.output +#: tensorcircuit.applications.van.NMF.output_mask +#: tensorcircuit.applications.van.NMF.output_shape +#: tensorcircuit.applications.van.NMF.run_eagerly +#: tensorcircuit.applications.van.NMF.state_updates +#: tensorcircuit.applications.van.NMF.submodules +#: tensorcircuit.applications.van.NMF.trainable_variables +#: tensorcircuit.applications.van.NMF.trainable_weights +#: tensorcircuit.applications.van.NMF.variables +#: tensorcircuit.applications.van.NMF.weights +#: tensorcircuit.applications.van.PixelCNN.call +#: tensorcircuit.applications.van.PixelCNN.compute_dtype +#: tensorcircuit.applications.van.PixelCNN.input +#: tensorcircuit.applications.van.PixelCNN.input_mask +#: tensorcircuit.applications.van.PixelCNN.input_shape +#: tensorcircuit.applications.van.PixelCNN.input_spec +#: tensorcircuit.applications.van.PixelCNN.losses +#: tensorcircuit.applications.van.PixelCNN.non_trainable_variables +#: tensorcircuit.applications.van.PixelCNN.non_trainable_weights +#: tensorcircuit.applications.van.PixelCNN.output +#: tensorcircuit.applications.van.PixelCNN.output_mask +#: tensorcircuit.applications.van.PixelCNN.output_shape +#: tensorcircuit.applications.van.PixelCNN.run_eagerly +#: tensorcircuit.applications.van.PixelCNN.state_updates +#: tensorcircuit.applications.van.PixelCNN.submodules +#: tensorcircuit.applications.van.PixelCNN.trainable_variables +#: tensorcircuit.applications.van.PixelCNN.trainable_weights +#: tensorcircuit.applications.van.PixelCNN.variables +#: tensorcircuit.applications.van.PixelCNN.weights +#: tensorcircuit.applications.van.ResidualBlock.call +#: tensorcircuit.applications.van.ResidualBlock.compute_dtype +#: tensorcircuit.applications.van.ResidualBlock.input +#: tensorcircuit.applications.van.ResidualBlock.input_mask +#: tensorcircuit.applications.van.ResidualBlock.input_shape +#: tensorcircuit.applications.van.ResidualBlock.input_spec +#: tensorcircuit.applications.van.ResidualBlock.losses +#: tensorcircuit.applications.van.ResidualBlock.metrics +#: tensorcircuit.applications.van.ResidualBlock.non_trainable_variables +#: tensorcircuit.applications.van.ResidualBlock.non_trainable_weights +#: tensorcircuit.applications.van.ResidualBlock.output +#: tensorcircuit.applications.van.ResidualBlock.output_mask +#: tensorcircuit.applications.van.ResidualBlock.output_shape +#: tensorcircuit.applications.van.ResidualBlock.submodules +#: tensorcircuit.applications.van.ResidualBlock.trainable_variables +#: tensorcircuit.applications.van.ResidualBlock.trainable_weights +#: tensorcircuit.applications.van.ResidualBlock.variables +#: tensorcircuit.applications.van.ResidualBlock.weights +#: tensorcircuit.applications.vqes.Linear.call +#: tensorcircuit.applications.vqes.Linear.compute_dtype +#: tensorcircuit.applications.vqes.Linear.input +#: tensorcircuit.applications.vqes.Linear.input_mask +#: tensorcircuit.applications.vqes.Linear.input_shape +#: tensorcircuit.applications.vqes.Linear.input_spec +#: tensorcircuit.applications.vqes.Linear.losses +#: tensorcircuit.applications.vqes.Linear.metrics +#: tensorcircuit.applications.vqes.Linear.non_trainable_variables +#: tensorcircuit.applications.vqes.Linear.non_trainable_weights +#: tensorcircuit.applications.vqes.Linear.output +#: tensorcircuit.applications.vqes.Linear.output_mask +#: tensorcircuit.applications.vqes.Linear.output_shape +#: tensorcircuit.applications.vqes.Linear.submodules +#: tensorcircuit.applications.vqes.Linear.trainable_variables +#: tensorcircuit.applications.vqes.Linear.trainable_weights +#: tensorcircuit.applications.vqes.Linear.variables +#: tensorcircuit.applications.vqes.Linear.weights #: tensorcircuit.applications.vqes.VQNHE.evaluation #: tensorcircuit.applications.vqes.VQNHE.plain_evaluation +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.adjoint +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix_from_numpy +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.from_dlpack +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.gather1d +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.jacfwd +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.jacrev +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.random_split +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshape2 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshapem +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reverse +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sizen +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sqrtmh +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dlpack +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_flatten +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_unflatten #: tensorcircuit.backends.backend_factory.get_backend +#: tensorcircuit.backends.jax_backend.JaxBackend.abs #: tensorcircuit.backends.jax_backend.JaxBackend.acos #: tensorcircuit.backends.jax_backend.JaxBackend.acosh #: tensorcircuit.backends.jax_backend.JaxBackend.arange @@ -603,6 +1002,7 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.asinh #: tensorcircuit.backends.jax_backend.JaxBackend.atan #: tensorcircuit.backends.jax_backend.JaxBackend.atan2 +#: tensorcircuit.backends.jax_backend.JaxBackend.atanh #: tensorcircuit.backends.jax_backend.JaxBackend.cast #: tensorcircuit.backends.jax_backend.JaxBackend.cond #: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix @@ -610,8 +1010,12 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.cos #: tensorcircuit.backends.jax_backend.JaxBackend.cosh #: tensorcircuit.backends.jax_backend.JaxBackend.cumsum +#: tensorcircuit.backends.jax_backend.JaxBackend.device +#: tensorcircuit.backends.jax_backend.JaxBackend.device_move +#: tensorcircuit.backends.jax_backend.JaxBackend.dtype #: tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh #: tensorcircuit.backends.jax_backend.JaxBackend.expm +#: tensorcircuit.backends.jax_backend.JaxBackend.from_dlpack #: tensorcircuit.backends.jax_backend.JaxBackend.grad #: tensorcircuit.backends.jax_backend.JaxBackend.i #: tensorcircuit.backends.jax_backend.JaxBackend.imag @@ -635,6 +1039,7 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.relu #: tensorcircuit.backends.jax_backend.JaxBackend.right_shift #: tensorcircuit.backends.jax_backend.JaxBackend.scatter +#: tensorcircuit.backends.jax_backend.JaxBackend.searchsorted #: tensorcircuit.backends.jax_backend.JaxBackend.sigmoid #: tensorcircuit.backends.jax_backend.JaxBackend.sin #: tensorcircuit.backends.jax_backend.JaxBackend.sinh @@ -646,12 +1051,14 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu +#: tensorcircuit.backends.jax_backend.JaxBackend.std #: tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient #: tensorcircuit.backends.jax_backend.JaxBackend.switch #: tensorcircuit.backends.jax_backend.JaxBackend.tan #: tensorcircuit.backends.jax_backend.JaxBackend.tanh #: tensorcircuit.backends.jax_backend.JaxBackend.tile #: tensorcircuit.backends.jax_backend.JaxBackend.to_dense +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dlpack #: tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten #: tensorcircuit.backends.jax_backend.JaxBackend.tree_map #: tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten @@ -660,6 +1067,8 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad #: tensorcircuit.backends.jax_backend.JaxBackend.vjp #: tensorcircuit.backends.jax_backend.JaxBackend.vmap +#: tensorcircuit.backends.jax_backend._svd_jax +#: tensorcircuit.backends.numpy_backend.NumpyBackend.abs #: tensorcircuit.backends.numpy_backend.NumpyBackend.acos #: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh #: tensorcircuit.backends.numpy_backend.NumpyBackend.arange @@ -669,6 +1078,7 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atanh #: tensorcircuit.backends.numpy_backend.NumpyBackend.cast #: tensorcircuit.backends.numpy_backend.NumpyBackend.cond #: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix @@ -676,6 +1086,9 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.cos #: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh #: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move +#: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype #: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh #: tensorcircuit.backends.numpy_backend.NumpyBackend.expm #: tensorcircuit.backends.numpy_backend.NumpyBackend.grad @@ -697,6 +1110,7 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.relu #: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift #: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter +#: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted #: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid #: tensorcircuit.backends.numpy_backend.NumpyBackend.sin #: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh @@ -708,6 +1122,7 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu +#: tensorcircuit.backends.numpy_backend.NumpyBackend.std #: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient #: tensorcircuit.backends.numpy_backend.NumpyBackend.switch #: tensorcircuit.backends.numpy_backend.NumpyBackend.tan @@ -719,6 +1134,7 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad #: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp #: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap +#: tensorcircuit.backends.numpy_backend._sum_numpy #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange @@ -728,14 +1144,19 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atanh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.from_dlpack #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag @@ -754,6 +1175,7 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh @@ -761,11 +1183,13 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.to_dlpack #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten @@ -774,6 +1198,11 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap +#: tensorcircuit.backends.pytorch_backend._conj_torch +#: tensorcircuit.backends.pytorch_backend._qr_torch +#: tensorcircuit.backends.pytorch_backend._rq_torch +#: tensorcircuit.backends.pytorch_backend._sum_torch +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange @@ -783,6 +1212,7 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atanh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix @@ -790,8 +1220,12 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.from_dlpack #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i @@ -812,6 +1246,7 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh @@ -823,40 +1258,55 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dlpack #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap +#: tensorcircuit.backends.tensorflow_backend._matmul_tf +#: tensorcircuit.backends.tensorflow_backend._qr_tf +#: tensorcircuit.backends.tensorflow_backend._rq_tf +#: tensorcircuit.basecircuit.BaseCircuit.amplitude +#: tensorcircuit.basecircuit.BaseCircuit.cond_measurement +#: tensorcircuit.basecircuit.BaseCircuit.copy +#: tensorcircuit.basecircuit.BaseCircuit.expectation_before +#: tensorcircuit.basecircuit.BaseCircuit.get_quvector +#: tensorcircuit.basecircuit.BaseCircuit.measure_jit +#: tensorcircuit.basecircuit.BaseCircuit.perfect_sampling +#: tensorcircuit.basecircuit.BaseCircuit.probability +#: tensorcircuit.basecircuit.BaseCircuit.sample +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps +#: tensorcircuit.basecircuit.BaseCircuit.to_qir #: tensorcircuit.channels.amplitudedampingchannel -#: tensorcircuit.channels.depolarizingchannel +#: tensorcircuit.channels.choi_to_kraus tensorcircuit.channels.choi_to_super +#: tensorcircuit.channels.composedkraus +#: tensorcircuit.channels.depolarizingchannel tensorcircuit.channels.evol_kraus +#: tensorcircuit.channels.evol_superop +#: tensorcircuit.channels.generaldepolarizingchannel +#: tensorcircuit.channels.is_hermitian_matrix +#: tensorcircuit.channels.kraus_to_choi tensorcircuit.channels.kraus_to_super #: tensorcircuit.channels.kraus_to_super_gate +#: tensorcircuit.channels.krausgate_to_krausmatrix +#: tensorcircuit.channels.krausmatrix_to_krausgate #: tensorcircuit.channels.phasedampingchannel -#: tensorcircuit.channels.resetchannel tensorcircuit.circuit.Circuit.amplitude -#: tensorcircuit.circuit.Circuit.cond_measurement -#: tensorcircuit.circuit.Circuit.depolarizing +#: tensorcircuit.channels.resetchannel tensorcircuit.channels.reshuffle +#: tensorcircuit.channels.super_to_choi tensorcircuit.channels.super_to_kraus +#: tensorcircuit.channels.thermalrelaxationchannel +#: tensorcircuit.circuit.Circuit.depolarizing_reference #: tensorcircuit.circuit.Circuit.expectation -#: tensorcircuit.circuit.Circuit.expectation_before -#: tensorcircuit.circuit.Circuit.from_qir -#: tensorcircuit.circuit.Circuit.from_qiskit #: tensorcircuit.circuit.Circuit.get_quoperator -#: tensorcircuit.circuit.Circuit.get_quvector #: tensorcircuit.circuit.Circuit.is_valid tensorcircuit.circuit.Circuit.matrix -#: tensorcircuit.circuit.Circuit.measure_jit #: tensorcircuit.circuit.Circuit.measure_reference -#: tensorcircuit.circuit.Circuit.perfect_sampling -#: tensorcircuit.circuit.Circuit.sample tensorcircuit.circuit.Circuit.to_qir -#: tensorcircuit.circuit.Circuit.to_qiskit #: tensorcircuit.circuit.Circuit.unitary_kraus -#: tensorcircuit.circuit.Circuit.vis_tex -#: tensorcircuit.circuit.Circuit.wavefunction -#: tensorcircuit.circuit._expectation_ps tensorcircuit.circuit.expectation +#: tensorcircuit.circuit.Circuit.wavefunction tensorcircuit.circuit.expectation #: tensorcircuit.cons.get_contractor tensorcircuit.cons.get_dtype #: tensorcircuit.cons.plain_contractor tensorcircuit.cons.set_contractor #: tensorcircuit.cons.set_dtype tensorcircuit.cons.set_function_backend @@ -865,20 +1315,49 @@ msgstr "" #: tensorcircuit.cons.set_tensornetwork_backend #: tensorcircuit.densitymatrix.DMCircuit.densitymatrix #: tensorcircuit.densitymatrix.DMCircuit.expectation -#: tensorcircuit.densitymatrix.DMCircuit.measure_jit -#: tensorcircuit.densitymatrix.DMCircuit.perfect_sampling +#: tensorcircuit.densitymatrix.DMCircuit.get_dm_as_quoperator +#: tensorcircuit.densitymatrix.DMCircuit.to_circuit +#: tensorcircuit.densitymatrix.DMCircuit.wavefunction +#: tensorcircuit.experimental.hamiltonian_evol +#: tensorcircuit.experimental.parameter_shift_grad +#: tensorcircuit.experimental.parameter_shift_grad_v2 #: tensorcircuit.gates.any_gate tensorcircuit.gates.bmatrix #: tensorcircuit.gates.cr_gate tensorcircuit.gates.exponential_gate -#: tensorcircuit.gates.exponential_gate_unity tensorcircuit.gates.iswap_gate -#: tensorcircuit.gates.matrix_for_gate tensorcircuit.gates.num_to_tensor +#: tensorcircuit.gates.exponential_gate_unity +#: tensorcircuit.gates.get_u_parameter tensorcircuit.gates.iswap_gate +#: tensorcircuit.gates.matrix_for_gate tensorcircuit.gates.multicontrol_gate +#: tensorcircuit.gates.num_to_tensor tensorcircuit.gates.phase_gate #: tensorcircuit.gates.r_gate tensorcircuit.gates.random_single_qubit_gate #: tensorcircuit.gates.random_two_qubit_gate #: tensorcircuit.gates.rgate_theoretical tensorcircuit.gates.rx_gate #: tensorcircuit.gates.rxx_gate tensorcircuit.gates.ry_gate #: tensorcircuit.gates.ryy_gate tensorcircuit.gates.rz_gate -#: tensorcircuit.gates.rzz_gate -#: tensorcircuit.interfaces.scipy_optimize_interface -#: tensorcircuit.interfaces.torch_interface tensorcircuit.keras.load_func +#: tensorcircuit.gates.rzz_gate tensorcircuit.gates.u_gate +#: tensorcircuit.interfaces.numpy.numpy_interface +#: tensorcircuit.interfaces.scipy.scipy_optimize_interface +#: tensorcircuit.interfaces.tensorflow.tensorflow_interface +#: tensorcircuit.interfaces.tensortrans.args_to_tensor +#: tensorcircuit.interfaces.tensortrans.general_args_to_numpy +#: tensorcircuit.interfaces.tensortrans.numpy_args_to_backend +#: tensorcircuit.interfaces.tensortrans.which_backend +#: tensorcircuit.interfaces.torch.torch_interface +#: tensorcircuit.keras.QuantumLayer.compute_dtype +#: tensorcircuit.keras.QuantumLayer.input +#: tensorcircuit.keras.QuantumLayer.input_mask +#: tensorcircuit.keras.QuantumLayer.input_shape +#: tensorcircuit.keras.QuantumLayer.input_spec +#: tensorcircuit.keras.QuantumLayer.losses +#: tensorcircuit.keras.QuantumLayer.metrics +#: tensorcircuit.keras.QuantumLayer.non_trainable_variables +#: tensorcircuit.keras.QuantumLayer.non_trainable_weights +#: tensorcircuit.keras.QuantumLayer.output +#: tensorcircuit.keras.QuantumLayer.output_mask +#: tensorcircuit.keras.QuantumLayer.output_shape +#: tensorcircuit.keras.QuantumLayer.submodules +#: tensorcircuit.keras.QuantumLayer.trainable_variables +#: tensorcircuit.keras.QuantumLayer.trainable_weights +#: tensorcircuit.keras.QuantumLayer.variables +#: tensorcircuit.keras.QuantumLayer.weights tensorcircuit.keras.load_func #: tensorcircuit.keras.output_asis_loss #: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate #: tensorcircuit.mps_base.FiniteMPS.measure_local_operator @@ -886,16 +1365,23 @@ msgstr "" #: tensorcircuit.mpscircuit.MPSCircuit.conj #: tensorcircuit.mpscircuit.MPSCircuit.copy #: tensorcircuit.mpscircuit.MPSCircuit.copy_without_tensor -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_single_gate -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product -#: tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction -#: tensorcircuit.mpscircuit.MPSCircuit.general_expectation +#: tensorcircuit.mpscircuit.MPSCircuit.expectation +#: tensorcircuit.mpscircuit.MPSCircuit.get_bond_dimensions +#: tensorcircuit.mpscircuit.MPSCircuit.get_center_position #: tensorcircuit.mpscircuit.MPSCircuit.get_norm +#: tensorcircuit.mpscircuit.MPSCircuit.get_quvector +#: tensorcircuit.mpscircuit.MPSCircuit.get_tensors #: tensorcircuit.mpscircuit.MPSCircuit.is_valid #: tensorcircuit.mpscircuit.MPSCircuit.measure #: tensorcircuit.mpscircuit.MPSCircuit.proj_with_mps #: tensorcircuit.mpscircuit.MPSCircuit.wavefunction -#: tensorcircuit.mpscircuit.split_tensor tensorcircuit.quantum.PauliString2COO +#: tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors +#: tensorcircuit.mpscircuit.split_tensor +#: tensorcircuit.noisemodel.apply_qir_with_noise +#: tensorcircuit.noisemodel.circuit_with_noise +#: tensorcircuit.noisemodel.expectation_noisfy +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy +#: tensorcircuit.quantum.PauliString2COO #: tensorcircuit.quantum.PauliStringSum2COO #: tensorcircuit.quantum.PauliStringSum2COO_numpy #: tensorcircuit.quantum.PauliStringSum2COO_tf @@ -915,7 +1401,10 @@ msgstr "" #: tensorcircuit.quantum.QuVector.projector #: tensorcircuit.quantum.QuVector.reduced_density #: tensorcircuit.quantum.correlation_from_counts -#: tensorcircuit.quantum.double_state +#: tensorcircuit.quantum.correlation_from_samples +#: tensorcircuit.quantum.count_d2s tensorcircuit.quantum.count_s2d +#: tensorcircuit.quantum.count_tuple2dict +#: tensorcircuit.quantum.count_vector2dict tensorcircuit.quantum.double_state #: tensorcircuit.quantum.eliminate_identities tensorcircuit.quantum.entropy #: tensorcircuit.quantum.fidelity tensorcircuit.quantum.free_energy #: tensorcircuit.quantum.generate_local_hamiltonian @@ -926,10 +1415,22 @@ msgstr "" #: tensorcircuit.quantum.quantum_constructor tensorcircuit.quantum.quimb2qop #: tensorcircuit.quantum.reduced_density_matrix #: tensorcircuit.quantum.renyi_entropy tensorcircuit.quantum.renyi_free_energy +#: tensorcircuit.quantum.sample2all tensorcircuit.quantum.sample2count +#: tensorcircuit.quantum.sample_bin2int tensorcircuit.quantum.sample_int2bin #: tensorcircuit.quantum.spin_by_basis tensorcircuit.quantum.taylorlnm #: tensorcircuit.quantum.tn2qop tensorcircuit.quantum.trace_distance #: tensorcircuit.quantum.trace_product #: tensorcircuit.quantum.truncated_free_energy +#: tensorcircuit.results.counts.expectation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_readout_mitigation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.expectation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.get_matrix +#: tensorcircuit.results.readout_mitigation.ReadoutMit.global_miti_readout_circ +#: tensorcircuit.results.readout_mitigation.ReadoutMit.local_miti_readout_circ +#: tensorcircuit.results.readout_mitigation.ReadoutMit.mapping_preprocess +#: tensorcircuit.results.readout_mitigation.ReadoutMit.mitigate_probability +#: tensorcircuit.results.readout_mitigation.ReadoutMit.newrange +#: tensorcircuit.results.readout_mitigation.ReadoutMit.ubs #: tensorcircuit.simplify.infer_new_shape #: tensorcircuit.simplify.pseudo_contract_between #: tensorcircuit.templates.blocks.Bell_pair_block @@ -940,83 +1441,226 @@ msgstr "" #: tensorcircuit.templates.graphs.Grid2DCoord.all_rows #: tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph #: tensorcircuit.templates.graphs.Line1D +#: tensorcircuit.templates.measurements.any_local_measurements #: tensorcircuit.templates.measurements.any_measurements #: tensorcircuit.templates.measurements.heisenberg_measurements #: tensorcircuit.templates.measurements.mpo_expectation #: tensorcircuit.templates.measurements.operator_expectation #: tensorcircuit.templates.measurements.sparse_expectation #: tensorcircuit.templates.measurements.spin_glass_measurements -#: tensorcircuit.translation.perm_matrix tensorcircuit.translation.qir2qiskit -#: tensorcircuit.translation.qiskit2tc tensorcircuit.utils.append +#: tensorcircuit.translation.eqasm2tc tensorcircuit.translation.perm_matrix +#: tensorcircuit.translation.qir2json tensorcircuit.translation.qir2qiskit +#: tensorcircuit.translation.qiskit2tc +#: tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure +#: tensorcircuit.utils.append tensorcircuit.utils.arg_alias #: tensorcircuit.utils.benchmark tensorcircuit.utils.is_m1mac #: tensorcircuit.utils.return_partial tensorcircuit.vis.gate_name_trans -#: tensorcircuit.vis.render_pdf +#: tensorcircuit.vis.qir2tex tensorcircuit.vis.render_pdf +#: tensorflow.python.module.module.Module.with_name_scope +#: tensornetwork.backends.abstract_backend.AbstractBackend.deserialize_tensor +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigs +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos +#: tensornetwork.backends.abstract_backend.AbstractBackend.exp +#: tensornetwork.backends.abstract_backend.AbstractBackend.gmres +#: tensornetwork.backends.abstract_backend.AbstractBackend.log +#: tensornetwork.backends.abstract_backend.AbstractBackend.pivot +#: tensornetwork.backends.abstract_backend.AbstractBackend.power +#: tensornetwork.backends.abstract_backend.AbstractBackend.serialize_tensor +#: tensornetwork.backends.jax.jax_backend.JaxBackend.addition +#: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_left_multiplication +#: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_right_multiplication +#: tensornetwork.backends.jax.jax_backend.JaxBackend.conj +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagflat +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal +#: tensornetwork.backends.jax.jax_backend.JaxBackend.divide +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigh +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eps +#: tensornetwork.backends.jax.jax_backend.JaxBackend.exp +#: tensornetwork.backends.jax.jax_backend.JaxBackend.inv +#: tensornetwork.backends.jax.jax_backend.JaxBackend.item +#: tensornetwork.backends.jax.jax_backend.JaxBackend.log +#: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul +#: tensornetwork.backends.jax.jax_backend.JaxBackend.multiply +#: tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform +#: tensornetwork.backends.jax.jax_backend.JaxBackend.reshape +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple +#: tensornetwork.backends.jax.jax_backend.JaxBackend.subtraction +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sum +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace +#: tensornetwork.backends.jax.jax_backend.JaxBackend.transpose +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.addition +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_left_multiplication +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_right_multiplication +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.conj +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.deserialize_tensor +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagflat +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.divide +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.exp +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.item +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.log +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.multiply +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.random_uniform +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.reshape +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.serialize_tensor +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tensor +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tuple +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.subtraction +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.transpose +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.abs +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.addition +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_left_multiplication +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_right_multiplication +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagflat +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.divide +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.item +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.multiply +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.random_uniform +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.reshape +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tensor +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tuple +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.subtraction +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.transpose +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.addition +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.broadcast_left_multiplication +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.broadcast_right_multiplication +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.conj +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagflat +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.divide +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.exp +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.item +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.log +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.multiply +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.reshape +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tensor +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.subtraction +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.transpose +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.position +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.check_canonical +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.random +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs +#: tensornetwork.network_components.AbstractNode.get_dimension +#: tensornetwork.network_components.AbstractNode.reorder_axes +#: tensornetwork.network_components.AbstractNode.reorder_edges +#: tensornetwork.network_components.Node.from_serial_dict +#: torch.nn.modules.module.Module.apply torch.nn.modules.module.Module.bfloat16 +#: torch.nn.modules.module.Module.cpu torch.nn.modules.module.Module.cuda +#: torch.nn.modules.module.Module.double torch.nn.modules.module.Module.eval +#: torch.nn.modules.module.Module.float +#: torch.nn.modules.module.Module.get_buffer +#: torch.nn.modules.module.Module.get_extra_state +#: torch.nn.modules.module.Module.get_parameter +#: torch.nn.modules.module.Module.get_submodule +#: torch.nn.modules.module.Module.half +#: torch.nn.modules.module.Module.load_state_dict +#: torch.nn.modules.module.Module.register_backward_hook +#: torch.nn.modules.module.Module.register_forward_hook +#: torch.nn.modules.module.Module.register_forward_pre_hook +#: torch.nn.modules.module.Module.register_full_backward_hook +#: torch.nn.modules.module.Module.requires_grad_ +#: torch.nn.modules.module.Module.state_dict torch.nn.modules.module.Module.to +#: torch.nn.modules.module.Module.to_empty torch.nn.modules.module.Module.train +#: torch.nn.modules.module.Module.type torch.nn.modules.module.Module.xpu msgid "Returns" msgstr "" -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:1 -msgid "" -"The probabilistic model based DQAS, can use extensively for DQAS case for" -" ``NMF`` probabilistic model." -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:3 -msgid "vag func, return loss and nabla lnp" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:4 -msgid "keras model" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:5 -msgid "sample func of logic with keras model input" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:6 -msgid "input data pipeline generator" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:7 -msgid "operation pool" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:8 -msgid "depth for DQAS" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:12 -msgid "parallel kernels" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:23 -msgid "final loss function in terms of average of sub loss for each circuit" -msgstr "" - -#: of tensorcircuit.applications.dqas.DQAS_search_pmb:24 -msgid "derivative function for ``loss_func``" -msgstr "" - -#: of tensorcircuit.applications.dqas.get_var:1 -msgid "" -"Call in customized functions and grab variables within DQAS framework " -"function by var name str." -msgstr "" - -#: of tensorcircuit.applications.dqas.get_var:3 -msgid "The DQAS framework function" -msgstr "" - -#: of tensorcircuit.applications.dqas.get_var:5 -msgid "Variables within the DQAS framework" -msgstr "" - -#: of tensorcircuit.applications.dqas.get_var +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append:24 +#: tensorcircuit.abstractcircuit.AbstractCircuit.prepend:5 +msgid "The composed circuit" +msgstr "" + +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append +#: tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement +#: tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_json +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_json_file +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_qir +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit +#: tensorcircuit.abstractcircuit.AbstractCircuit.gate_count +#: tensorcircuit.abstractcircuit.AbstractCircuit.gate_summary +#: tensorcircuit.abstractcircuit.AbstractCircuit.get_positional_logical_mapping +#: tensorcircuit.abstractcircuit.AbstractCircuit.initial_mapping +#: tensorcircuit.abstractcircuit.AbstractCircuit.inverse +#: tensorcircuit.abstractcircuit.AbstractCircuit.prepend +#: tensorcircuit.abstractcircuit.AbstractCircuit.standardize_gate +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_json +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_openqasm +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_qir +#: tensorcircuit.abstractcircuit.AbstractCircuit.vis_tex +#: tensorcircuit.applications.dqas.get_var #: tensorcircuit.applications.graphdata.graph1D #: tensorcircuit.applications.graphdata.reduced_ansatz #: tensorcircuit.applications.graphdata.split_ansatz #: tensorcircuit.applications.vqes.VQNHE.evaluation #: tensorcircuit.applications.vqes.VQNHE.plain_evaluation +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.adjoint +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix_from_numpy +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.from_dlpack +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.gather1d +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.jacfwd +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.jacrev +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.random_split +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshape2 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshapem +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reverse +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sizen +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sqrtmh +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dlpack +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_flatten +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_unflatten #: tensorcircuit.backends.backend_factory.get_backend +#: tensorcircuit.backends.jax_backend.JaxBackend.abs #: tensorcircuit.backends.jax_backend.JaxBackend.acos #: tensorcircuit.backends.jax_backend.JaxBackend.acosh #: tensorcircuit.backends.jax_backend.JaxBackend.arange @@ -1026,15 +1670,18 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.asinh #: tensorcircuit.backends.jax_backend.JaxBackend.atan #: tensorcircuit.backends.jax_backend.JaxBackend.atan2 +#: tensorcircuit.backends.jax_backend.JaxBackend.atanh #: tensorcircuit.backends.jax_backend.JaxBackend.cast #: tensorcircuit.backends.jax_backend.JaxBackend.cond #: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix #: tensorcircuit.backends.jax_backend.JaxBackend.copy -#: tensorcircuit.backends.jax_backend.JaxBackend.cos #: tensorcircuit.backends.jax_backend.JaxBackend.cosh #: tensorcircuit.backends.jax_backend.JaxBackend.cumsum +#: tensorcircuit.backends.jax_backend.JaxBackend.device +#: tensorcircuit.backends.jax_backend.JaxBackend.device_move +#: tensorcircuit.backends.jax_backend.JaxBackend.dtype #: tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh -#: tensorcircuit.backends.jax_backend.JaxBackend.expm +#: tensorcircuit.backends.jax_backend.JaxBackend.from_dlpack #: tensorcircuit.backends.jax_backend.JaxBackend.grad #: tensorcircuit.backends.jax_backend.JaxBackend.i #: tensorcircuit.backends.jax_backend.JaxBackend.imag @@ -1058,8 +1705,8 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.relu #: tensorcircuit.backends.jax_backend.JaxBackend.right_shift #: tensorcircuit.backends.jax_backend.JaxBackend.scatter +#: tensorcircuit.backends.jax_backend.JaxBackend.searchsorted #: tensorcircuit.backends.jax_backend.JaxBackend.sigmoid -#: tensorcircuit.backends.jax_backend.JaxBackend.sin #: tensorcircuit.backends.jax_backend.JaxBackend.sinh #: tensorcircuit.backends.jax_backend.JaxBackend.size #: tensorcircuit.backends.jax_backend.JaxBackend.softmax @@ -1069,12 +1716,14 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu +#: tensorcircuit.backends.jax_backend.JaxBackend.std #: tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient #: tensorcircuit.backends.jax_backend.JaxBackend.switch #: tensorcircuit.backends.jax_backend.JaxBackend.tan #: tensorcircuit.backends.jax_backend.JaxBackend.tanh #: tensorcircuit.backends.jax_backend.JaxBackend.tile #: tensorcircuit.backends.jax_backend.JaxBackend.to_dense +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dlpack #: tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten #: tensorcircuit.backends.jax_backend.JaxBackend.tree_map #: tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten @@ -1083,6 +1732,8 @@ msgstr "" #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad #: tensorcircuit.backends.jax_backend.JaxBackend.vjp #: tensorcircuit.backends.jax_backend.JaxBackend.vmap +#: tensorcircuit.backends.jax_backend._svd_jax +#: tensorcircuit.backends.numpy_backend.NumpyBackend.abs #: tensorcircuit.backends.numpy_backend.NumpyBackend.acos #: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh #: tensorcircuit.backends.numpy_backend.NumpyBackend.arange @@ -1092,15 +1743,17 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atanh #: tensorcircuit.backends.numpy_backend.NumpyBackend.cast #: tensorcircuit.backends.numpy_backend.NumpyBackend.cond #: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix #: tensorcircuit.backends.numpy_backend.NumpyBackend.copy -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cos #: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh #: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move +#: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype #: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh -#: tensorcircuit.backends.numpy_backend.NumpyBackend.expm #: tensorcircuit.backends.numpy_backend.NumpyBackend.grad #: tensorcircuit.backends.numpy_backend.NumpyBackend.i #: tensorcircuit.backends.numpy_backend.NumpyBackend.imag @@ -1120,8 +1773,8 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.relu #: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift #: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter +#: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted #: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sin #: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh #: tensorcircuit.backends.numpy_backend.NumpyBackend.size #: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax @@ -1131,6 +1784,7 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu +#: tensorcircuit.backends.numpy_backend.NumpyBackend.std #: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient #: tensorcircuit.backends.numpy_backend.NumpyBackend.switch #: tensorcircuit.backends.numpy_backend.NumpyBackend.tan @@ -1142,6 +1796,7 @@ msgstr "" #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad #: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp #: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap +#: tensorcircuit.backends.numpy_backend._sum_numpy #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange @@ -1151,14 +1806,17 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atanh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.from_dlpack #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag @@ -1177,18 +1835,20 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.to_dlpack #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten @@ -1197,6 +1857,10 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap +#: tensorcircuit.backends.pytorch_backend._qr_torch +#: tensorcircuit.backends.pytorch_backend._rq_torch +#: tensorcircuit.backends.pytorch_backend._sum_torch +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange @@ -1206,15 +1870,18 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atanh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.from_dlpack #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i @@ -1235,8 +1902,8 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax @@ -1246,39 +1913,55 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dlpack #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap +#: tensorcircuit.backends.tensorflow_backend._matmul_tf +#: tensorcircuit.backends.tensorflow_backend._qr_tf +#: tensorcircuit.backends.tensorflow_backend._rq_tf +#: tensorcircuit.basecircuit.BaseCircuit.amplitude +#: tensorcircuit.basecircuit.BaseCircuit.cond_measurement +#: tensorcircuit.basecircuit.BaseCircuit.expectation_before +#: tensorcircuit.basecircuit.BaseCircuit.get_quvector +#: tensorcircuit.basecircuit.BaseCircuit.measure_jit +#: tensorcircuit.basecircuit.BaseCircuit.perfect_sampling +#: tensorcircuit.basecircuit.BaseCircuit.probability +#: tensorcircuit.basecircuit.BaseCircuit.readouterror_bs +#: tensorcircuit.basecircuit.BaseCircuit.sample +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps +#: tensorcircuit.basecircuit.BaseCircuit.to_qir #: tensorcircuit.channels.amplitudedampingchannel -#: tensorcircuit.channels.depolarizingchannel +#: tensorcircuit.channels.choi_to_kraus tensorcircuit.channels.choi_to_super +#: tensorcircuit.channels.composedkraus +#: tensorcircuit.channels.depolarizingchannel tensorcircuit.channels.evol_kraus +#: tensorcircuit.channels.evol_superop +#: tensorcircuit.channels.generaldepolarizingchannel +#: tensorcircuit.channels.is_hermitian_matrix +#: tensorcircuit.channels.kraus_to_choi tensorcircuit.channels.kraus_to_super #: tensorcircuit.channels.kraus_to_super_gate +#: tensorcircuit.channels.krausgate_to_krausmatrix +#: tensorcircuit.channels.krausmatrix_to_krausgate #: tensorcircuit.channels.phasedampingchannel -#: tensorcircuit.channels.resetchannel tensorcircuit.circuit.Circuit.amplitude -#: tensorcircuit.circuit.Circuit.cond_measurement -#: tensorcircuit.circuit.Circuit.depolarizing +#: tensorcircuit.channels.resetchannel tensorcircuit.channels.reshuffle +#: tensorcircuit.channels.super_to_choi tensorcircuit.channels.super_to_kraus +#: tensorcircuit.channels.thermalrelaxationchannel +#: tensorcircuit.circuit.Circuit.depolarizing_reference #: tensorcircuit.circuit.Circuit.expectation -#: tensorcircuit.circuit.Circuit.expectation_before -#: tensorcircuit.circuit.Circuit.from_qir -#: tensorcircuit.circuit.Circuit.from_qiskit #: tensorcircuit.circuit.Circuit.get_quoperator -#: tensorcircuit.circuit.Circuit.get_quvector #: tensorcircuit.circuit.Circuit.is_valid tensorcircuit.circuit.Circuit.matrix -#: tensorcircuit.circuit.Circuit.measure_jit #: tensorcircuit.circuit.Circuit.measure_reference -#: tensorcircuit.circuit.Circuit.perfect_sampling -#: tensorcircuit.circuit.Circuit.sample tensorcircuit.circuit.Circuit.to_qir #: tensorcircuit.circuit.Circuit.unitary_kraus -#: tensorcircuit.circuit.Circuit.vis_tex -#: tensorcircuit.circuit.Circuit.wavefunction -#: tensorcircuit.circuit._expectation_ps tensorcircuit.circuit.expectation +#: tensorcircuit.circuit.Circuit.wavefunction tensorcircuit.circuit.expectation #: tensorcircuit.cons.get_contractor tensorcircuit.cons.get_dtype #: tensorcircuit.cons.plain_contractor tensorcircuit.cons.runtime_backend #: tensorcircuit.cons.runtime_contractor tensorcircuit.cons.runtime_dtype @@ -1289,20 +1972,32 @@ msgstr "" #: tensorcircuit.cons.set_tensornetwork_backend #: tensorcircuit.densitymatrix.DMCircuit.densitymatrix #: tensorcircuit.densitymatrix.DMCircuit.expectation -#: tensorcircuit.densitymatrix.DMCircuit.measure_jit -#: tensorcircuit.densitymatrix.DMCircuit.perfect_sampling +#: tensorcircuit.densitymatrix.DMCircuit.get_dm_as_quoperator +#: tensorcircuit.densitymatrix.DMCircuit.to_circuit +#: tensorcircuit.densitymatrix.DMCircuit.wavefunction +#: tensorcircuit.experimental.hamiltonian_evol +#: tensorcircuit.experimental.parameter_shift_grad +#: tensorcircuit.experimental.parameter_shift_grad_v2 #: tensorcircuit.gates.any_gate tensorcircuit.gates.bmatrix #: tensorcircuit.gates.cr_gate tensorcircuit.gates.exponential_gate -#: tensorcircuit.gates.exponential_gate_unity tensorcircuit.gates.iswap_gate -#: tensorcircuit.gates.matrix_for_gate tensorcircuit.gates.num_to_tensor +#: tensorcircuit.gates.exponential_gate_unity +#: tensorcircuit.gates.get_u_parameter tensorcircuit.gates.iswap_gate +#: tensorcircuit.gates.matrix_for_gate tensorcircuit.gates.multicontrol_gate +#: tensorcircuit.gates.num_to_tensor tensorcircuit.gates.phase_gate #: tensorcircuit.gates.r_gate tensorcircuit.gates.random_single_qubit_gate #: tensorcircuit.gates.random_two_qubit_gate #: tensorcircuit.gates.rgate_theoretical tensorcircuit.gates.rx_gate #: tensorcircuit.gates.rxx_gate tensorcircuit.gates.ry_gate #: tensorcircuit.gates.ryy_gate tensorcircuit.gates.rz_gate -#: tensorcircuit.gates.rzz_gate -#: tensorcircuit.interfaces.scipy_optimize_interface -#: tensorcircuit.interfaces.torch_interface tensorcircuit.keras.load_func +#: tensorcircuit.gates.rzz_gate tensorcircuit.gates.u_gate +#: tensorcircuit.interfaces.numpy.numpy_interface +#: tensorcircuit.interfaces.scipy.scipy_optimize_interface +#: tensorcircuit.interfaces.tensorflow.tensorflow_interface +#: tensorcircuit.interfaces.tensortrans.args_to_tensor +#: tensorcircuit.interfaces.tensortrans.general_args_to_numpy +#: tensorcircuit.interfaces.tensortrans.numpy_args_to_backend +#: tensorcircuit.interfaces.tensortrans.which_backend +#: tensorcircuit.interfaces.torch.torch_interface tensorcircuit.keras.load_func #: tensorcircuit.keras.output_asis_loss #: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate #: tensorcircuit.mps_base.FiniteMPS.measure_local_operator @@ -1310,15 +2005,23 @@ msgstr "" #: tensorcircuit.mpscircuit.MPSCircuit.conj #: tensorcircuit.mpscircuit.MPSCircuit.copy #: tensorcircuit.mpscircuit.MPSCircuit.copy_without_tensor -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_single_gate -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product -#: tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction -#: tensorcircuit.mpscircuit.MPSCircuit.general_expectation +#: tensorcircuit.mpscircuit.MPSCircuit.expectation +#: tensorcircuit.mpscircuit.MPSCircuit.get_bond_dimensions +#: tensorcircuit.mpscircuit.MPSCircuit.get_center_position #: tensorcircuit.mpscircuit.MPSCircuit.get_norm +#: tensorcircuit.mpscircuit.MPSCircuit.get_quvector +#: tensorcircuit.mpscircuit.MPSCircuit.get_tensors #: tensorcircuit.mpscircuit.MPSCircuit.is_valid +#: tensorcircuit.mpscircuit.MPSCircuit.measure #: tensorcircuit.mpscircuit.MPSCircuit.proj_with_mps #: tensorcircuit.mpscircuit.MPSCircuit.wavefunction -#: tensorcircuit.mpscircuit.split_tensor tensorcircuit.quantum.PauliString2COO +#: tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors +#: tensorcircuit.mpscircuit.split_tensor +#: tensorcircuit.noisemodel.apply_qir_with_noise +#: tensorcircuit.noisemodel.circuit_with_noise +#: tensorcircuit.noisemodel.expectation_noisfy +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy +#: tensorcircuit.quantum.PauliString2COO #: tensorcircuit.quantum.PauliStringSum2COO #: tensorcircuit.quantum.PauliStringSum2COO_numpy #: tensorcircuit.quantum.PauliStringSum2COO_tf @@ -1338,7 +2041,10 @@ msgstr "" #: tensorcircuit.quantum.QuVector.projector #: tensorcircuit.quantum.QuVector.reduced_density #: tensorcircuit.quantum.correlation_from_counts -#: tensorcircuit.quantum.double_state +#: tensorcircuit.quantum.correlation_from_samples +#: tensorcircuit.quantum.count_d2s tensorcircuit.quantum.count_s2d +#: tensorcircuit.quantum.count_tuple2dict +#: tensorcircuit.quantum.count_vector2dict tensorcircuit.quantum.double_state #: tensorcircuit.quantum.eliminate_identities tensorcircuit.quantum.entropy #: tensorcircuit.quantum.fidelity tensorcircuit.quantum.free_energy #: tensorcircuit.quantum.generate_local_hamiltonian @@ -1349,10 +2055,22 @@ msgstr "" #: tensorcircuit.quantum.quantum_constructor tensorcircuit.quantum.quimb2qop #: tensorcircuit.quantum.reduced_density_matrix #: tensorcircuit.quantum.renyi_entropy tensorcircuit.quantum.renyi_free_energy +#: tensorcircuit.quantum.sample2all tensorcircuit.quantum.sample2count +#: tensorcircuit.quantum.sample_bin2int tensorcircuit.quantum.sample_int2bin #: tensorcircuit.quantum.spin_by_basis tensorcircuit.quantum.taylorlnm #: tensorcircuit.quantum.tn2qop tensorcircuit.quantum.trace_distance #: tensorcircuit.quantum.trace_product #: tensorcircuit.quantum.truncated_free_energy +#: tensorcircuit.results.counts.expectation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_readout_mitigation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.expectation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.get_matrix +#: tensorcircuit.results.readout_mitigation.ReadoutMit.global_miti_readout_circ +#: tensorcircuit.results.readout_mitigation.ReadoutMit.local_miti_readout_circ +#: tensorcircuit.results.readout_mitigation.ReadoutMit.mapping_preprocess +#: tensorcircuit.results.readout_mitigation.ReadoutMit.mitigate_probability +#: tensorcircuit.results.readout_mitigation.ReadoutMit.newrange +#: tensorcircuit.results.readout_mitigation.ReadoutMit.ubs #: tensorcircuit.simplify.infer_new_shape #: tensorcircuit.simplify.pseudo_contract_between #: tensorcircuit.templates.blocks.Bell_pair_block @@ -1363,6564 +2081,15189 @@ msgstr "" #: tensorcircuit.templates.graphs.Grid2DCoord.all_rows #: tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph #: tensorcircuit.templates.graphs.Line1D +#: tensorcircuit.templates.measurements.any_local_measurements #: tensorcircuit.templates.measurements.any_measurements #: tensorcircuit.templates.measurements.heisenberg_measurements #: tensorcircuit.templates.measurements.mpo_expectation #: tensorcircuit.templates.measurements.operator_expectation #: tensorcircuit.templates.measurements.sparse_expectation #: tensorcircuit.templates.measurements.spin_glass_measurements -#: tensorcircuit.translation.perm_matrix tensorcircuit.translation.qir2qiskit -#: tensorcircuit.translation.qiskit2tc tensorcircuit.utils.append +#: tensorcircuit.translation.eqasm2tc tensorcircuit.translation.perm_matrix +#: tensorcircuit.translation.qir2json tensorcircuit.translation.qir2qiskit +#: tensorcircuit.translation.qiskit2tc +#: tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure +#: tensorcircuit.utils.append tensorcircuit.utils.arg_alias #: tensorcircuit.utils.benchmark tensorcircuit.utils.is_m1mac #: tensorcircuit.utils.return_partial tensorcircuit.vis.gate_name_trans -#: tensorcircuit.vis.render_pdf +#: tensorcircuit.vis.qir2tex tensorcircuit.vis.render_pdf +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigs +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh +#: tensornetwork.backends.abstract_backend.AbstractBackend.gmres +#: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_left_multiplication +#: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_right_multiplication +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagflat +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigh +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eps +#: tensornetwork.backends.jax.jax_backend.JaxBackend.inv +#: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul +#: tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sum +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_left_multiplication +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_right_multiplication +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagflat +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.random_uniform +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.abs +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_left_multiplication +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_right_multiplication +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagflat +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.random_uniform +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.broadcast_left_multiplication +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.broadcast_right_multiplication +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagflat +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.position +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs +#: torch.nn.modules.module.Module.apply torch.nn.modules.module.Module.bfloat16 +#: torch.nn.modules.module.Module.cpu torch.nn.modules.module.Module.cuda +#: torch.nn.modules.module.Module.double torch.nn.modules.module.Module.eval +#: torch.nn.modules.module.Module.float +#: torch.nn.modules.module.Module.get_buffer +#: torch.nn.modules.module.Module.get_extra_state +#: torch.nn.modules.module.Module.get_parameter +#: torch.nn.modules.module.Module.get_submodule +#: torch.nn.modules.module.Module.half +#: torch.nn.modules.module.Module.load_state_dict +#: torch.nn.modules.module.Module.register_backward_hook +#: torch.nn.modules.module.Module.register_forward_hook +#: torch.nn.modules.module.Module.register_forward_pre_hook +#: torch.nn.modules.module.Module.register_full_backward_hook +#: torch.nn.modules.module.Module.requires_grad_ +#: torch.nn.modules.module.Module.state_dict torch.nn.modules.module.Module.to +#: torch.nn.modules.module.Module.to_empty torch.nn.modules.module.Module.train +#: torch.nn.modules.module.Module.type torch.nn.modules.module.Module.xpu msgid "Return type" msgstr "" -#: of tensorcircuit.applications.dqas.get_weights:1 -msgid "" -"This function works only when nnp has the same shape as stp, i.e. one " -"parameter for each op." -msgstr "" - -#: of tensorcircuit.applications.dqas.parallel_kernel:1 -msgid "The kernel for multiprocess to run parallel in DQAS function/" -msgstr "" - -#: of tensorcircuit.applications.dqas.parallel_qaoa_train:1 +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append_from_qir:1 msgid "" -"parallel variational parameter training and search to avoid local minimum" -" not limited to qaoa setup as the function name indicates, as long as you" -" provided suitable `vag_func`" -msgstr "" - -#: of tensorcircuit.applications.dqas.parallel_qaoa_train:6 -msgid "data input generator for vag_func" -msgstr "" - -#: of tensorcircuit.applications.dqas.parallel_qaoa_train:7 -msgid "vag_kernel" -msgstr "" - -#: of tensorcircuit.applications.dqas.parallel_qaoa_train:10 -msgid "number of tries" -msgstr "" - -#: of tensorcircuit.applications.dqas.parallel_qaoa_train:11 -msgid "for optimization problem the input is in general fixed so batch is often 1" +"Apply the ciurict in form of quantum intermediate representation after " +"the current cirucit." msgstr "" -#: of tensorcircuit.applications.dqas.parallel_qaoa_train:12 -msgid "number of parallel jobs" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append_from_qir +#: tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement +#: tensorcircuit.abstractcircuit.AbstractCircuit.draw +#: tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_qir +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit +#: tensorcircuit.abstractcircuit.AbstractCircuit.gate_count +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_qir +#: tensorcircuit.backends.jax_backend.JaxBackend.grad +#: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad +#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad +#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad +#: tensorcircuit.backends.pytorch_backend._qr_torch +#: tensorcircuit.backends.pytorch_backend._rq_torch +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad +#: tensorcircuit.backends.tensorflow_backend._qr_tf +#: tensorcircuit.backends.tensorflow_backend._rq_tf +#: tensorcircuit.basecircuit.BaseCircuit.amplitude +#: tensorcircuit.basecircuit.BaseCircuit.cond_measurement +#: tensorcircuit.basecircuit.BaseCircuit.readouterror_bs +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps +#: tensorcircuit.basecircuit.BaseCircuit.to_qir +#: tensorcircuit.channels.amplitudedampingchannel +#: tensorcircuit.channels.depolarizingchannel +#: tensorcircuit.channels.generaldepolarizingchannel +#: tensorcircuit.channels.phasedampingchannel +#: tensorcircuit.channels.resetchannel +#: tensorcircuit.channels.thermalrelaxationchannel +#: tensorcircuit.circuit.Circuit.expectation +#: tensorcircuit.circuit.Circuit.measure_reference +#: tensorcircuit.circuit.Circuit.replace_mps_inputs +#: tensorcircuit.cons.set_tensornetwork_backend tensorcircuit.gates.bmatrix +#: tensorcircuit.gates.matrix_for_gate tensorcircuit.gates.num_to_tensor +#: tensorcircuit.interfaces.numpy.numpy_interface +#: tensorcircuit.interfaces.scipy.scipy_optimize_interface +#: tensorcircuit.interfaces.tensorflow.tensorflow_interface +#: tensorcircuit.interfaces.tensortrans.args_to_tensor +#: tensorcircuit.interfaces.torch.torch_interface tensorcircuit.keras.load_func +#: tensorcircuit.keras.save_func +#: tensorcircuit.quantum.QuAdjointVector.from_tensor +#: tensorcircuit.quantum.QuOperator.from_tensor +#: tensorcircuit.quantum.QuOperator.tensor_product +#: tensorcircuit.quantum.QuScalar.from_tensor +#: tensorcircuit.quantum.QuVector.from_tensor +#: tensorcircuit.quantum.correlation_from_counts +#: tensorcircuit.quantum.count_d2s tensorcircuit.quantum.entropy +#: tensorcircuit.quantum.free_energy +#: tensorcircuit.quantum.heisenberg_hamiltonian tensorcircuit.quantum.identity +#: tensorcircuit.quantum.measurement_counts +#: tensorcircuit.quantum.quantum_constructor +#: tensorcircuit.quantum.renyi_free_energy tensorcircuit.quantum.spin_by_basis +#: tensorcircuit.quantum.trace_product tensorcircuit.simplify.infer_new_shape +#: tensorcircuit.torchnn.QuantumNet.__init__ +#: tensorcircuit.translation.qir2qiskit tensorcircuit.translation.qiskit2tc +#: tensorcircuit.utils.append tensorcircuit.utils.return_partial +#: tensorcircuit.vis.gate_name_trans tensorcircuit.vis.qir2tex +#: tensorcircuit.vis.render_pdf +msgid "Example" msgstr "" -#: of tensorcircuit.applications.dqas.parallel_qaoa_train:13 -msgid "mean value of normal distribution for nnp" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.append_from_qir:18 +msgid "The quantum intermediate representation." msgstr "" -#: of tensorcircuit.applications.dqas.parallel_qaoa_train:14 -msgid "std deviation of normal distribution for nnp" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate:1 +#: tensorcircuit.basecircuit.BaseCircuit.apply_general_gate:1 +msgid "" +"An implementation of this method should also append gate directionary to " +"self._qir" msgstr "" -#: of tensorcircuit.applications.dqas.verbose_output:1 -msgid "Doesn't support prob model DQAS search." +#: of tensorcircuit.abstractcircuit.AbstractCircuit.barrier_instruction:1 +msgid "add a barrier instruction flag, no effect on numerical simulation" msgstr "" -#: ../../source/api/applications/graphdata.rst:2 -msgid "tensorcircuit.applications.graphdata" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.barrier_instruction:3 +msgid "the corresponding qubits" msgstr "" -#: of tensorcircuit.applications.graphdata:1 -msgid "Modules for graph instance data and more" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement:1 +#: tensorcircuit.basecircuit.BaseCircuit.cond_measurement:1 +msgid "" +"Measurement on z basis at ``index`` qubit based on quantum amplitude (not" +" post-selection). The highlight is that this method can return the " +"measured result as a int Tensor and thus maintained a jittable pipeline." msgstr "" -#: of tensorcircuit.applications.graphdata.dict2graph:1 -msgid "```python d = nx.to_dict_of_dicts(g) ```" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement:16 +#: tensorcircuit.basecircuit.BaseCircuit.cond_measurement:16 +msgid "" +"In terms of ``DMCircuit``, this method returns nothing and the density " +"matrix after this method is kept in mixed state without knowing the " +"measuremet resuslts" msgstr "" -#: of tensorcircuit.applications.graphdata.graph1D:1 -msgid "1D PBC chain with n sites." +#: of tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement:22 +#: tensorcircuit.basecircuit.BaseCircuit.cond_measurement:22 +msgid "the qubit for the z-basis measurement" msgstr "" -#: of tensorcircuit.applications.graphdata.graph1D:3 -msgid "The number of nodes" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement:24 +#: tensorcircuit.basecircuit.BaseCircuit.cond_measurement:24 +msgid "0 or 1 for z measurement on up and down freedom" msgstr "" -#: of tensorcircuit.applications.graphdata.graph1D:5 -msgid "The resulted graph g" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.select_gate:1 +msgid "Apply ``which``-th gate from ``kraus`` list, i.e. apply kraus[which]" msgstr "" -#: of tensorcircuit.applications.graphdata.reduce_edges:3 -msgid "all graphs with m edge out from g" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.select_gate:3 +msgid "Tensor of shape [] and dtype int" msgstr "" -#: of tensorcircuit.applications.graphdata.reduced_ansatz:1 -msgid "" -"Generate a reduced graph with given ratio of edges compared to the " -"original graph g." +#: of tensorcircuit.abstractcircuit.AbstractCircuit.select_gate:5 +msgid "A list of gate in the form of ``tc.gate`` or Tensor" msgstr "" -#: of tensorcircuit.applications.graphdata.reduced_ansatz:3 -msgid "The base graph" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.select_gate:7 +msgid "the qubit lines the gate applied on" msgstr "" -#: of tensorcircuit.applications.graphdata.reduced_ansatz:5 -msgid "number of edges kept, default half of the edges" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.draw:1 +msgid "" +"Visualise the circuit. This method recevies the keywords as same as " +"qiskit.circuit.QuantumCircuit.draw. More details can be found here: " +"https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.draw.html." msgstr "" -#: of tensorcircuit.applications.graphdata.reduced_ansatz:6 -msgid "The resulted reduced graph" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:1 +msgid "" +"Shortcut for Pauli string expectation. x, y, z list are for X, Y, Z " +"positions" msgstr "" -#: of tensorcircuit.applications.graphdata.split_ansatz:1 -msgid "Split the graph in exactly ``split`` piece evenly." +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:26 +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy:5 +msgid "sites to apply X gate, defaults to None" msgstr "" -#: of tensorcircuit.applications.graphdata.split_ansatz:3 -msgid "The mother graph" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:28 +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy:7 +msgid "sites to apply Y gate, defaults to None" msgstr "" -#: of tensorcircuit.applications.graphdata.split_ansatz:5 -msgid "The number of the graph we want to divide into, defaults to 2" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:30 +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy:9 +msgid "sites to apply Z gate, defaults to None" msgstr "" -#: of tensorcircuit.applications.graphdata.split_ansatz:7 -msgid "List of graph instance of size ``split``" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:32 +msgid "whether to cache and reuse the wavefunction, defaults to True" msgstr "" -#: ../../source/api/applications/layers.rst:2 -msgid "tensorcircuit.applications.layers" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:34 +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:46 +#: tensorcircuit.circuit.Circuit.expectation:32 +#: tensorcircuit.densitymatrix.DMCircuit.expectation:8 +#: tensorcircuit.noisemodel.expectation_noisfy:5 +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy:11 +msgid "Noise Configuration, defaults to None" msgstr "" -#: of tensorcircuit.applications.layers:1 -msgid "Module for functions adding layers of circuits" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:36 +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:48 +#: tensorcircuit.circuit.Circuit.expectation:34 +#: tensorcircuit.noisemodel.expectation_noisfy:7 +msgid "" +"repetition time for Monte Carlo sampling for noisfy calculation, defaults" +" to 1000" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_gate_layer..f:1 -msgid "Hlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:38 +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:50 +#: tensorcircuit.circuit.Circuit.expectation:36 +#: tensorcircuit.densitymatrix.DMCircuit.expectation:10 +#: tensorcircuit.noisemodel.expectation_noisfy:9 +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy:17 +msgid "" +"external randomness given by tensor uniformly from [0, 1], defaults to " +"None, used for noisfy circuit sampling" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_gate_layer..f:1 -msgid "anyrxlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:41 +msgid "Expectation value" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_gate_layer..f:1 -msgid "anyrylayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_json:1 +msgid "load json str as a Circuit" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_gate_layer..f:1 -msgid "anyrzlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_json:3 +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_json:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.from_json_file:7 +#: tensorcircuit.abstractcircuit.AbstractCircuit.initial_mapping:9 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.from_dlpack:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dlpack:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dlpack:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.arange:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.from_dlpack:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.mean:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.std:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.std:12 +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dlpack:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dlpack:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.std:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.std:12 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.from_dlpack:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std:12 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.to_dlpack:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.to_dlpack:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.from_dlpack:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std:12 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dlpack:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dlpack:5 +#: tensorcircuit.basecircuit.BaseCircuit.expectation_before:6 +#: tensorcircuit.basecircuit.BaseCircuit.expectation_before:7 +#: tensorcircuit.channels.is_hermitian_matrix:9 +#: tensorcircuit.cons.runtime_contractor:3 +#: tensorcircuit.cons.set_function_contractor:3 +#: tensorcircuit.experimental.hamiltonian_evol:4 +#: tensorcircuit.experimental.hamiltonian_evol:6 +#: tensorcircuit.experimental.hamiltonian_evol:8 tensorcircuit.gates.u_gate:16 +#: tensorcircuit.quantum.count_vector2dict:9 +#: tensorcircuit.quantum.sample2count:3 tensorcircuit.quantum.sample2count:5 +#: tensorcircuit.quantum.sample2count:9 +#: tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph:6 +#: tensorcircuit.translation.eqasm2tc:3 tensorcircuit.translation.eqasm2tc:9 +#: tensorcircuit.translation.qir2json:3 tensorcircuit.translation.qir2json:8 +#: tensorcircuit.utils.arg_alias:3 tensorcircuit.utils.arg_alias:5 +#: tensorcircuit.utils.benchmark:3 tensorcircuit.utils.benchmark:9 +msgid "_description_" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyswaplayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_json:5 +msgid "Extra circuit parameters in the format of ``__init__``, defaults to None" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyxxlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_json_file:1 +msgid "load json file and convert it to a circuit" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyxylayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_json_file:3 +msgid "filename" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyxzlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_json_file:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.initial_mapping:7 +#: tensorcircuit.experimental.hamiltonian_evol:10 +#: tensorcircuit.translation.eqasm2tc:5 +msgid "_description_, defaults to None" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyyxlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qir:1 +msgid "Restore the circuit from the quantum intermediate representation." msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyyylayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qir:21 +#: tensorcircuit.translation.qir2qiskit:14 +msgid "The quantum intermediate representation of a circuit." msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyyzlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qir:23 +msgid "Extra circuit parameters." msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyzxlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qir:25 +msgid "The circuit have same gates in the qir." msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyzylayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:1 +msgid "Import Qiskit QuantumCircuit object as a ``tc.Circuit`` object." msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 -msgid "anyzzlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:12 +msgid "Qiskit Circuit object" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "cnotlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:14 +msgid "The number of qubits for the circuit" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_gate_layer..f:1 -msgid "rxlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:16 +msgid "possible input wavefunction for ``tc.Circuit``, defaults to None" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_gate_layer..f:1 -msgid "rylayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:18 +#: tensorcircuit.translation.qiskit2tc:18 +msgid "kwargs given in Circuit.__init__ construction function, default to None." msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_gate_layer..f:1 -msgid "rzlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:20 +#: tensorcircuit.translation.qiskit2tc:20 +msgid "" +"(variational) parameters for the circuit. Could be either a sequence or " +"dictionary depending on the type of parameters in the Qiskit circuit. For" +" ``ParameterVectorElement`` use sequence. For ``Parameter`` use " +"dictionary" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "swaplayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:24 +msgid "The same circuit but as tensorcircuit object" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "xxgate" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.gate_count:1 +msgid "count the gate number of the circuit" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "xxlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.gate_count:14 +msgid "gate name list to be counted, defaults to None (counting all gates)" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "xygate" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.gate_count:16 +msgid "the total number of all gates or gates in the ``gate_list``" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "xylayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.gate_summary:1 +msgid "return the summary dictionary on gate type - gate count pair" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "xzgate" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.gate_summary:3 +msgid "the gate count dict by gate type" msgstr "" #: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "xzlayer" +#: tensorcircuit.abstractcircuit.AbstractCircuit.get_positional_logical_mapping:1 +msgid "" +"Get positional logical mapping dict based on measure instruction. This " +"function is useful when we only measure part of the qubits in the " +"circuit, to process the count result from partial measurement, we must be" +" aware of the mapping, i.e. for each position in the count bitstring, " +"what is the corresponding qubits (logical) defined on the circuit" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "yxgate" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.get_positional_logical_mapping:7 +msgid "``positional_logical_mapping``" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "yxlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.initial_mapping:1 +msgid "" +"generate a new circuit with the qubit mapping given by " +"``logical_physical_mapping``" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "yygate" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.initial_mapping:3 +msgid "how to map logical qubits to the physical qubits on the new circuit" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "yylayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.initial_mapping:5 +msgid "" +"number of qubit of the new circuit, can be different from the original " +"one, defaults to None" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "yzgate" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.inverse:1 +msgid "inverse the circuit, return a new inversed circuit" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "yzlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.inverse +msgid "EXAMPLE" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "zxgate" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.inverse:10 +msgid "keywords dict for initialization the new circuit, defaults to None" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "zxlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.inverse:12 +msgid "the inversed circuit" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "zygate" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.measure_instruction:1 +msgid "add a measurement instruction flag, no effect on numerical simulation" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "zylayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.measure_instruction:3 +#: tensorcircuit.abstractcircuit.AbstractCircuit.reset_instruction:3 +msgid "the corresponding qubit" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 -msgid "zzgate" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.prepend:1 +msgid "prepend circuit ``c`` before" msgstr "" -#: of -#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 -msgid "zzlayer" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.prepend:3 +msgid "The other circuit to be prepended" msgstr "" -#: of tensorcircuit.applications.layers.generate_any_gate_layer:1 -msgid "$$e^{-i heta_i \\sigma}$$" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.reset_instruction:1 +msgid "add a reset instruction flag, no effect on numerical simulation" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer:1 -msgid "" -"The following function should be used to generate layers with special " -"case. As its soundness depends on the nature of the task or problem, it " -"doesn't always make sense." +#: of tensorcircuit.abstractcircuit.AbstractCircuit.standardize_gate:1 +msgid "standardize the gate name to tc common gate sets" msgstr "" -#: of tensorcircuit.applications.layers.generate_cirq_any_gate_layer:1 -#: tensorcircuit.applications.layers.generate_cirq_gate_layer:1 -msgid "$$e^{-i heta \\sigma}$$" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.standardize_gate:3 +msgid "non-standard gate name" msgstr "" -#: of tensorcircuit.applications.layers.generate_gate_layer:1 -msgid "$$e^{-i heta \\sigma}$$" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.standardize_gate:5 +msgid "the standard gate name" msgstr "" -#: ../../source/api/applications/utils.rst:2 -msgid "tensorcircuit.applications.utils" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.vis_tex:1 +msgid "Generate latex string based on quantikz latex package" msgstr "" -#: of tensorcircuit.applications.utils:1 -msgid "" -"A collection of useful function snippets that irrelevant with the main " -"modules or await for further refactor" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.vis_tex:3 +msgid "Latex string that can be directly compiled via, e.g. latexit" msgstr "" -#: of tensorcircuit.applications.utils.FakeModule:1 -#: tensorcircuit.applications.vqes.VQNHE:1 -#: tensorcircuit.backends.jax_backend.optax_optimizer:1 -#: tensorcircuit.backends.pytorch_backend.torch_optimizer:1 -#: tensorcircuit.backends.tensorflow_backend.keras_optimizer:1 -#: tensorcircuit.circuit.Circuit:1 tensorcircuit.densitymatrix.DMCircuit:1 -#: tensorcircuit.gates.GateF:1 tensorcircuit.mpscircuit.MPSCircuit:1 -#: tensorcircuit.quantum.QuOperator:1 -#: tensorcircuit.templates.graphs.Grid2DCoord:1 -msgid "Bases: :py:class:`object`" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_json:1 +msgid "circuit dumps to json" msgstr "" -#: of tensorcircuit.applications.utils.color_svg:1 -msgid "color cirq circuit SVG for given gates, a small tool to hack the cirq SVG" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_json:3 +msgid "file str to dump the json to, defaults to None, return the json str" msgstr "" -#: of tensorcircuit.applications.utils.color_svg:5 -msgid "integer coordinate which gate is colored" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_json:5 +#: tensorcircuit.translation.qir2json:5 +msgid "" +"If False, keep all info for each gate, defaults to be False. If True, " +"suitable for IO since less information is required" msgstr "" -#: of tensorcircuit.applications.utils.repr2array:1 -msgid "transform repr form of an array to real numpy array" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_json:8 +msgid "None if dumps to file otherwise the json str" msgstr "" -#: ../../source/api/applications/vags.rst:2 -msgid "tensorcircuit.applications.vags" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_openqasm:1 +msgid "" +"transform circuit to openqasm via qiskit circuit, see " +"https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.qasm.html" +" for usage on possible options for ``kws``" msgstr "" -#: of tensorcircuit.applications.vags:1 -msgid "DQAS application kernels as vag functions" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_openqasm:5 +msgid "circuit representation in openqasm format" msgstr "" -#: of tensorcircuit.applications.vags.ave_func:1 -msgid "1D array for full wavefunction, the basis is in lexcical order" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_qir:1 +#: tensorcircuit.basecircuit.BaseCircuit.to_qir:1 +msgid "Return the quantum intermediate representation of the circuit." msgstr "" -#: of tensorcircuit.applications.vags.ave_func:2 -#: tensorcircuit.applications.vags.energy:5 -msgid "nx.Graph" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_qir:32 +#: tensorcircuit.basecircuit.BaseCircuit.to_qir:32 +msgid "The quantum intermediate representation of the circuit." msgstr "" -#: of tensorcircuit.applications.vags.ave_func:3 -msgid "transformation functions before averaged" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit:1 +msgid "Translate ``tc.Circuit`` to a qiskit QuantumCircuit object." msgstr "" -#: of tensorcircuit.applications.vags.cvar:1 -msgid "as f3" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit:3 +msgid "whether also export measurement and reset instructions" msgstr "" -#: of tensorcircuit.applications.vags.energy:1 -msgid "maxcut energy for n qubit wavefunction i-th basis" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit:5 +msgid "A qiskit object of this circuit." msgstr "" -#: of tensorcircuit.applications.vags.energy:3 -msgid "ranged from 0 to 2**n-1" +#: ../../source/api/applications.rst:2 +msgid "tensorcircuit.applications" msgstr "" -#: of tensorcircuit.applications.vags.energy:4 -#: tensorcircuit.applications.vags.unitary_design:4 -msgid "number of qubits" +#: ../../source/api/applications/dqas.rst:2 +msgid "tensorcircuit.applications.dqas" msgstr "" -#: of tensorcircuit.applications.vags.entanglement_entropy:1 -msgid "" -"deprecated as non tf and non flexible, use the combination of " -"``reduced_density_matrix`` and ``entropy`` instead." +#: of tensorcircuit.applications.dqas:1 +msgid "Modules for DQAS framework" msgstr "" -#: of tensorcircuit.applications.vags.entropy:1 -#: tensorcircuit.applications.vags.reduced_density_matrix:1 -msgid "deprecated, current version in tc.quantum" +#: of tensorcircuit.applications.dqas.DQAS_search:1 +msgid "DQAS framework entrypoint" msgstr "" -#: of tensorcircuit.applications.vags.evaluate_vag:1 +#: of tensorcircuit.applications.dqas.DQAS_search:3 msgid "" -"value and gradient, currently only tensorflow backend is supported jax " -"and numpy seems to be slow in circuit simulation anyhow. *deprecated*" +"function with input of data instance, circuit parameters theta and " +"structural paramter k, return tuple of objective value and gradient with " +"respect to theta" msgstr "" -#: of tensorcircuit.applications.vags.evaluate_vag:8 -msgid "if lbd=0, take energy as objective" +#: of tensorcircuit.applications.dqas.DQAS_search:5 +msgid "data generator as dataset" msgstr "" -#: of tensorcircuit.applications.vags.evaluate_vag:9 -msgid "if as default 0, overlap will not compute in the process" +#: of tensorcircuit.applications.dqas.DQAS_search:6 +msgid "list of operations as primitive operator pool" msgstr "" -#: of tensorcircuit.applications.vags.gapfilling:1 -msgid "Fill single qubit gates according to placeholder on circuit" +#: of tensorcircuit.applications.dqas.DQAS_search:7 +msgid "the default layer number of the circuit ansatz" msgstr "" -#: of tensorcircuit.applications.vags.heisenberg_measurements:1 -msgid "Hamiltonian measurements for Heisenberg model on graph lattice g" +#: of tensorcircuit.applications.dqas.DQAS_search:8 +msgid "" +"shape of circuit parameter pool, in general p_stp*l, where l is the max " +"number of circuit parameters for op in the operator pool" msgstr "" -#: of tensorcircuit.applications.vags.q:1 -msgid "short cut for ``cirq.LineQubit(i)``" +#: of tensorcircuit.applications.dqas.DQAS_search:10 +msgid "the same as p in the most times" msgstr "" -#: of tensorcircuit.applications.vags.qaoa_block_vag:1 -#: tensorcircuit.applications.vags.qaoa_block_vag_energy:1 -msgid "QAOA block encoding kernel, support 2 params in one op" +#: of tensorcircuit.applications.dqas.DQAS_search:11 +msgid "batch size of one epoch" msgstr "" -#: of tensorcircuit.applications.vags.qaoa_train:1 -msgid "" -"training QAOA with only optimizing circuit parameters, can be well " -"replaced with more general function `DQAS_search`" +#: of tensorcircuit.applications.dqas.DQAS_search:12 +msgid "prethermal update times" msgstr "" -#: of tensorcircuit.applications.vags.quantum_mp_qaoa_vag:1 -msgid "multi parameter for one layer" +#: of tensorcircuit.applications.dqas.DQAS_search:13 +msgid "training epochs" msgstr "" -#: of tensorcircuit.applications.vags.quantum_mp_qaoa_vag:7 -#: tensorcircuit.applications.vags.quantum_qaoa_vag:7 -msgid "kw arguments for measurements_func" +#: of tensorcircuit.applications.dqas.DQAS_search:14 +msgid "parallel thread number, 0 to disable multiprocessing model by default" msgstr "" -#: of tensorcircuit.applications.vags.quantum_mp_qaoa_vag:8 -msgid "loss function, gradient of nnp" +#: of tensorcircuit.applications.dqas.DQAS_search:15 +msgid "set verbose log to print" msgstr "" -#: of tensorcircuit.applications.vags.quantum_qaoa_vag:1 -msgid "" -"tensorflow quantum backend compare to qaoa_vag which is tensorcircuit " -"backend" +#: of tensorcircuit.applications.dqas.DQAS_search:16 +msgid "function to output verbose information" msgstr "" -#: of tensorcircuit.applications.vags.tfim_measurements:1 -msgid "Hamiltonian for tfim on lattice defined by graph g" +#: of tensorcircuit.applications.dqas.DQAS_search:17 +msgid "function return intermiediate result for final history list" msgstr "" -#: of tensorcircuit.applications.vags.tfim_measurements:8 -msgid "cirq.PauliSum as operators for tfq expectation layer" +#: of tensorcircuit.applications.dqas.DQAS_search:18 +msgid "cutoff probability to avoid peak distribution" msgstr "" -#: of tensorcircuit.applications.vags.unitary_design:1 +#: of tensorcircuit.applications.dqas.DQAS_search:19 msgid "" -"generate random wavefunction from approximately Haar measure, reference:" -" https://doi.org/10.1063/1.4983266" +"function accepting list of objective values and return the baseline value" +" used in the next round" msgstr "" -#: of tensorcircuit.applications.vags.unitary_design:5 -msgid "repetition of the blocks" +#: of tensorcircuit.applications.dqas.DQAS_search:21 +msgid "return noise with the same shape as circuit parameter pool" msgstr "" -#: of tensorcircuit.applications.vags.unitary_design_block:1 -msgid "random Haar measure approximation" +#: of tensorcircuit.applications.dqas.DQAS_search:22 +msgid "initial values for circuit parameter pool" msgstr "" -#: of tensorcircuit.applications.vags.unitary_design_block:3 -msgid "cirq.Circuit, empty circuit" +#: of tensorcircuit.applications.dqas.DQAS_search:23 +msgid "initial values for probabilistic model parameters" msgstr "" -#: of tensorcircuit.applications.vags.unitary_design_block:4 -msgid "# of qubit" +#: of tensorcircuit.applications.dqas.DQAS_search:24 +msgid "optimizer for circuit parameters theta" msgstr "" -#: ../../source/api/applications/van.rst:2 -msgid "tensorcircuit.applications.van" +#: of tensorcircuit.applications.dqas.DQAS_search:25 +msgid "optimizer for model parameters alpha" msgstr "" -#: of tensorcircuit.applications.van:1 -msgid "" -"One-hot variational autoregressive models for multiple categorical " -"choices beyond binary" +#: of tensorcircuit.applications.dqas.DQAS_search:26 +msgid "optimizer for circuit parameters in prethermal stage" msgstr "" -#: of tensorcircuit.applications.van.MADE:1 -#: tensorcircuit.applications.van.NMF:1 -#: tensorcircuit.applications.van.PixelCNN:1 -msgid "Bases: :py:class:`keras.engine.training.Model`" +#: of tensorcircuit.applications.dqas.DQAS_search:27 +msgid "fixed structural parameters for prethermal training" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:1 -#: tensorcircuit.applications.van.NMF.call:1 -#: tensorcircuit.applications.van.PixelCNN.call:1 -msgid "Calls the model on new inputs and returns the outputs as tensors." +#: of tensorcircuit.applications.dqas.DQAS_search:28 +msgid "regularization function for model parameters alpha" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:3 -#: tensorcircuit.applications.van.NMF.call:3 -#: tensorcircuit.applications.van.PixelCNN.call:3 -msgid "" -"In this case `call()` just reapplies all ops in the graph to the new " -"inputs (e.g. build a new computational graph from the provided inputs)." +#: of tensorcircuit.applications.dqas.DQAS_search:29 +msgid "regularization function for circuit parameters theta" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:7 -#: tensorcircuit.applications.van.NMF.call:7 -#: tensorcircuit.applications.van.PixelCNN.call:7 +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:1 msgid "" -"Note: This method should not be called directly. It is only meant to be " -"overridden when subclassing `tf.keras.Model`. To call a model on an " -"input, always use the `__call__()` method, i.e. `model(inputs)`, which " -"relies on the underlying `call()` method." -msgstr "" - -#: of tensorcircuit.applications.van.MADE.call:18 -#: tensorcircuit.applications.van.MaskedConv2D.build:11 -#: tensorcircuit.applications.van.MaskedConv2D.call:37 -#: tensorcircuit.applications.van.MaskedLinear.call:37 -#: tensorcircuit.applications.van.NMF.call:18 -#: tensorcircuit.applications.van.PixelCNN.call:18 -#: tensorcircuit.applications.van.ResidualBlock.call:37 -#: tensorcircuit.applications.vqes.Linear.call:37 -#: tensorcircuit.backends.jax_backend.JaxBackend.eye:8 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:8 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:8 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:8 -#: tensorcircuit.keras.QuantumLayer.build:11 -msgid "Args:" +"The probabilistic model based DQAS, can use extensively for DQAS case for" +" ``NMF`` probabilistic model." msgstr "" -#: of tensorcircuit.applications.van.MADE.call:13 -#: tensorcircuit.applications.van.NMF.call:13 -#: tensorcircuit.applications.van.PixelCNN.call:13 -msgid "" -"inputs: Input tensor, or dict/list/tuple of input tensors. training: " -"Boolean or boolean scalar tensor, indicating whether to run" +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:3 +msgid "vag func, return loss and nabla lnp" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:15 -#: tensorcircuit.applications.van.NMF.call:15 -#: tensorcircuit.applications.van.PixelCNN.call:15 -msgid "the `Network` in training mode or inference mode." +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:4 +msgid "keras model" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:18 -#: tensorcircuit.applications.van.NMF.call:18 -#: tensorcircuit.applications.van.PixelCNN.call:18 -msgid "mask: A mask or list of masks. A mask can be either a boolean tensor or" +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:5 +msgid "sample func of logic with keras model input" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:18 -#: tensorcircuit.applications.van.NMF.call:18 -#: tensorcircuit.applications.van.PixelCNN.call:18 -msgid "None (no mask). For more details, check the guide" +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:6 +msgid "input data pipeline generator" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:18 -#: tensorcircuit.applications.van.NMF.call:18 -#: tensorcircuit.applications.van.PixelCNN.call:18 -msgid "[here](https://www.tensorflow.org/guide/keras/masking_and_padding)." +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:7 +msgid "operation pool" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:21 -#: tensorcircuit.applications.van.MaskedConv2D.call:39 -#: tensorcircuit.applications.van.MaskedLinear.call:39 -#: tensorcircuit.applications.van.NMF.call:21 -#: tensorcircuit.applications.van.PixelCNN.call:21 -#: tensorcircuit.applications.van.ResidualBlock.call:39 -#: tensorcircuit.applications.vqes.Linear.call:39 -#: tensorcircuit.backends.jax_backend.JaxBackend.abs:4 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.abs:4 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs:4 -msgid "Returns:" +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:8 +msgid "depth for DQAS" msgstr "" -#: of tensorcircuit.applications.van.MADE.call:21 -#: tensorcircuit.applications.van.NMF.call:21 -#: tensorcircuit.applications.van.PixelCNN.call:21 -msgid "" -"A tensor if there is a single output, or a list of tensors if there are " -"more than one outputs." +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:12 +msgid "parallel kernels" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D:1 -#: tensorcircuit.applications.van.MaskedLinear:1 -#: tensorcircuit.applications.van.ResidualBlock:1 -#: tensorcircuit.applications.vqes.Linear:1 tensorcircuit.keras.QuantumLayer:1 -msgid "Bases: :py:class:`keras.engine.base_layer.Layer`" +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:23 +msgid "final loss function in terms of average of sub loss for each circuit" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.build:1 -#: tensorcircuit.keras.QuantumLayer.build:1 -msgid "Creates the variables of the layer (optional, for subclass implementers)." +#: of tensorcircuit.applications.dqas.DQAS_search_pmb:24 +msgid "derivative function for ``loss_func``" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.build:3 -#: tensorcircuit.keras.QuantumLayer.build:3 +#: of tensorcircuit.applications.dqas.get_var:1 msgid "" -"This is a method that implementers of subclasses of `Layer` or `Model` " -"can override if they need a state-creation step in-between layer " -"instantiation and layer call." +"Call in customized functions and grab variables within DQAS framework " +"function by var name str." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.build:7 -#: tensorcircuit.keras.QuantumLayer.build:7 -msgid "This is typically used to create the weights of `Layer` subclasses." +#: of tensorcircuit.applications.dqas.get_var:3 +msgid "The DQAS framework function" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.build:11 -#: tensorcircuit.keras.QuantumLayer.build:11 -msgid "input_shape: Instance of `TensorShape`, or list of instances of" +#: of tensorcircuit.applications.dqas.get_var:5 +msgid "Variables within the DQAS framework" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.build:11 -#: tensorcircuit.keras.QuantumLayer.build:11 +#: of tensorcircuit.applications.dqas.get_weights:1 msgid "" -"`TensorShape` if the layer expects a list of inputs (one instance per " -"input)." +"This function works only when nnp has the same shape as stp, i.e. one " +"parameter for each op." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:1 -#: tensorcircuit.applications.van.MaskedLinear.call:1 -#: tensorcircuit.applications.van.ResidualBlock.call:1 -#: tensorcircuit.applications.vqes.Linear.call:1 -msgid "This is where the layer's logic lives." +#: of tensorcircuit.applications.dqas.parallel_kernel:1 +msgid "The kernel for multiprocess to run parallel in DQAS function/" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:3 -#: tensorcircuit.applications.van.MaskedLinear.call:3 -#: tensorcircuit.applications.van.ResidualBlock.call:3 -#: tensorcircuit.applications.vqes.Linear.call:3 +#: of tensorcircuit.applications.dqas.parallel_qaoa_train:1 msgid "" -"Note here that `call()` method in `tf.keras` is little bit different from" -" `keras` API. In `keras` API, you can pass support masking for layers as " -"additional arguments. Whereas `tf.keras` has `compute_mask()` method to " -"support masking." +"parallel variational parameter training and search to avoid local minimum" +" not limited to qaoa setup as the function name indicates, as long as you" +" provided suitable `vag_func`" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:24 -#: tensorcircuit.applications.van.MaskedLinear.call:24 -#: tensorcircuit.applications.van.ResidualBlock.call:24 -#: tensorcircuit.applications.vqes.Linear.call:24 -msgid "inputs: Input tensor, or dict/list/tuple of input tensors." +#: of tensorcircuit.applications.dqas.parallel_qaoa_train:6 +msgid "data input generator for vag_func" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:10 -#: tensorcircuit.applications.van.MaskedLinear.call:10 -#: tensorcircuit.applications.van.ResidualBlock.call:10 -#: tensorcircuit.applications.vqes.Linear.call:10 -msgid "" -"The first positional `inputs` argument is subject to special rules: - " -"`inputs` must be explicitly passed. A layer cannot have zero" +#: of tensorcircuit.applications.dqas.parallel_qaoa_train:7 +msgid "vag_kernel" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:12 -#: tensorcircuit.applications.van.MaskedLinear.call:12 -#: tensorcircuit.applications.van.ResidualBlock.call:12 -#: tensorcircuit.applications.vqes.Linear.call:12 -msgid "" -"arguments, and `inputs` cannot be provided via the default value of a " -"keyword argument." -msgstr "" +#: of tensorcircuit.applications.dqas.parallel_qaoa_train:10 +msgid "number of tries" +msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:14 -#: tensorcircuit.applications.van.MaskedLinear.call:14 -#: tensorcircuit.applications.van.ResidualBlock.call:14 -#: tensorcircuit.applications.vqes.Linear.call:14 -msgid "NumPy array or Python scalar values in `inputs` get cast as tensors." +#: of tensorcircuit.applications.dqas.parallel_qaoa_train:11 +msgid "for optimization problem the input is in general fixed so batch is often 1" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:15 -#: tensorcircuit.applications.van.MaskedLinear.call:15 -#: tensorcircuit.applications.van.ResidualBlock.call:15 -#: tensorcircuit.applications.vqes.Linear.call:15 -msgid "Keras mask metadata is only collected from `inputs`." +#: of tensorcircuit.applications.dqas.parallel_qaoa_train:12 +msgid "number of parallel jobs" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:16 -#: tensorcircuit.applications.van.MaskedLinear.call:16 -#: tensorcircuit.applications.van.ResidualBlock.call:16 -#: tensorcircuit.applications.vqes.Linear.call:16 -msgid "" -"Layers are built (`build(input_shape)` method) using shape info from " -"`inputs` only." +#: of tensorcircuit.applications.dqas.parallel_qaoa_train:13 +msgid "mean value of normal distribution for nnp" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:18 -#: tensorcircuit.applications.van.MaskedLinear.call:18 -#: tensorcircuit.applications.van.ResidualBlock.call:18 -#: tensorcircuit.applications.vqes.Linear.call:18 -msgid "`input_spec` compatibility is only checked against `inputs`." +#: of tensorcircuit.applications.dqas.parallel_qaoa_train:14 +msgid "std deviation of normal distribution for nnp" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:19 -#: tensorcircuit.applications.van.MaskedLinear.call:19 -#: tensorcircuit.applications.van.ResidualBlock.call:19 -#: tensorcircuit.applications.vqes.Linear.call:19 -msgid "" -"Mixed precision input casting is only applied to `inputs`. If a layer has" -" tensor arguments in `*args` or `**kwargs`, their casting behavior in " -"mixed precision should be handled manually." +#: of tensorcircuit.applications.dqas.verbose_output:1 +msgid "Doesn't support prob model DQAS search." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:22 -#: tensorcircuit.applications.van.MaskedLinear.call:22 -#: tensorcircuit.applications.van.ResidualBlock.call:22 -#: tensorcircuit.applications.vqes.Linear.call:22 -msgid "The SavedModel input specification is generated using `inputs` only." +#: ../../source/api/applications/graphdata.rst:2 +msgid "tensorcircuit.applications.graphdata" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:23 -#: tensorcircuit.applications.van.MaskedLinear.call:23 -#: tensorcircuit.applications.van.ResidualBlock.call:23 -#: tensorcircuit.applications.vqes.Linear.call:23 -msgid "" -"Integration with various ecosystem packages like TFMOT, TFLite, TF.js, " -"etc is only supported for `inputs` and not for tensors in positional and " -"keyword arguments." +#: of tensorcircuit.applications.graphdata:1 +msgid "Modules for graph instance data and more" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:26 -#: tensorcircuit.applications.van.MaskedLinear.call:26 -#: tensorcircuit.applications.van.ResidualBlock.call:26 -#: tensorcircuit.applications.vqes.Linear.call:26 -msgid "*args: Additional positional arguments. May contain tensors, although" +#: of tensorcircuit.applications.graphdata.dict2graph:1 +msgid "```python d = nx.to_dict_of_dicts(g) ```" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:27 -#: tensorcircuit.applications.van.MaskedLinear.call:27 -#: tensorcircuit.applications.van.ResidualBlock.call:27 -#: tensorcircuit.applications.vqes.Linear.call:27 -msgid "this is not recommended, for the reasons above." +#: of tensorcircuit.applications.graphdata.graph1D:1 +msgid "1D PBC chain with n sites." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:37 -#: tensorcircuit.applications.van.MaskedLinear.call:37 -#: tensorcircuit.applications.van.ResidualBlock.call:37 -#: tensorcircuit.applications.vqes.Linear.call:37 -msgid "**kwargs: Additional keyword arguments. May contain tensors, although" +#: of tensorcircuit.applications.graphdata.graph1D:3 +msgid "The number of nodes" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:29 -#: tensorcircuit.applications.van.MaskedLinear.call:29 -#: tensorcircuit.applications.van.ResidualBlock.call:29 -#: tensorcircuit.applications.vqes.Linear.call:29 -msgid "" -"this is not recommended, for the reasons above. The following optional " -"keyword arguments are reserved: - `training`: Boolean scalar tensor of " -"Python boolean indicating" +#: of tensorcircuit.applications.graphdata.graph1D:5 +msgid "The resulted graph g" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:32 -#: tensorcircuit.applications.van.MaskedLinear.call:32 -#: tensorcircuit.applications.van.ResidualBlock.call:32 -#: tensorcircuit.applications.vqes.Linear.call:32 -msgid "whether the `call` is meant for training or inference." +#: of tensorcircuit.applications.graphdata.reduce_edges:3 +msgid "all graphs with m edge out from g" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:33 -#: tensorcircuit.applications.van.MaskedLinear.call:33 -#: tensorcircuit.applications.van.ResidualBlock.call:33 -#: tensorcircuit.applications.vqes.Linear.call:33 +#: of tensorcircuit.applications.graphdata.reduced_ansatz:1 msgid "" -"`mask`: Boolean input mask. If the layer's `call()` method takes a `mask`" -" argument, its default value will be set to the mask generated for " -"`inputs` by the previous layer (if `input` did come from a layer that " -"generated a corresponding mask, i.e. if it came from a Keras layer with " -"masking support)." +"Generate a reduced graph with given ratio of edges compared to the " +"original graph g." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:40 -#: tensorcircuit.applications.van.MaskedLinear.call:40 -#: tensorcircuit.applications.van.ResidualBlock.call:40 -#: tensorcircuit.applications.vqes.Linear.call:40 -msgid "A tensor or list/tuple of tensors." +#: of tensorcircuit.applications.graphdata.reduced_ansatz:3 +msgid "The base graph" msgstr "" -#: ../../source/api/applications/vqes.rst:2 -msgid "tensorcircuit.applications.vqes" +#: of tensorcircuit.applications.graphdata.reduced_ansatz:5 +msgid "number of edges kept, default half of the edges" msgstr "" -#: of tensorcircuit.applications.vqes:1 -msgid "VQNHE application" +#: of tensorcircuit.applications.graphdata.reduced_ansatz:6 +msgid "The resulted reduced graph" msgstr "" -#: of tensorcircuit.applications.vqes.JointSchedule:1 -msgid "" -"Bases: " -":py:class:`keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule`" +#: of tensorcircuit.applications.graphdata.split_ansatz:1 +msgid "Split the graph in exactly ``split`` piece evenly." msgstr "" -#: of tensorcircuit.applications.vqes.Linear:1 -msgid "Dense layer but with complex weights, used for building complex RBM" +#: of tensorcircuit.applications.graphdata.split_ansatz:3 +msgid "The mother graph" msgstr "" -#: of tensorcircuit.applications.vqes.VQNHE.evaluation:1 -msgid "VQNHE" +#: of tensorcircuit.applications.graphdata.split_ansatz:5 +msgid "The number of the graph we want to divide into, defaults to 2" msgstr "" -#: of tensorcircuit.applications.vqes.VQNHE.evaluation:3 -#: tensorcircuit.applications.vqes.VQNHE.evaluation:5 -#: tensorcircuit.applications.vqes.VQNHE.plain_evaluation:3 -#: tensorcircuit.applications.vqes.VQNHE.plain_evaluation:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.argmax:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.argmax:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.argmin:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.argmin:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.concat:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.cond:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.cond:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.cond:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.cond:9 -#: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:10 -#: tensorcircuit.backends.jax_backend.JaxBackend.cumsum:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.cumsum:8 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:11 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:11 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:11 -#: tensorcircuit.backends.jax_backend.JaxBackend.max:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.max:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.min:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.min:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.random_split:6 -#: tensorcircuit.backends.jax_backend.JaxBackend.random_split:8 -#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:9 -#: tensorcircuit.backends.jax_backend.JaxBackend.sigmoid:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.sigmoid:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:11 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:15 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:13 -#: tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.switch:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.switch:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.switch:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.tile:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.tile:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:29 -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:36 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.concat:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:10 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:8 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.max:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.max:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.min:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.min:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:11 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:15 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:13 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.unique_with_counts:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:29 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:36 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.concat:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:8 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.unique_with_counts:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:29 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:36 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.concat:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:10 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:8 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:11 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:15 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:13 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:29 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:36 -#: tensorcircuit.simplify.pseudo_contract_between:3 -#: tensorcircuit.simplify.pseudo_contract_between:5 -#: tensorcircuit.simplify.pseudo_contract_between:7 -#: tensorcircuit.templates.graphs.Line1D:3 -#: tensorcircuit.templates.graphs.Line1D:7 -msgid "[description]" -msgstr "" +#: of tensorcircuit.applications.graphdata.split_ansatz:7 +msgid "List of graph instance of size ``split``" +msgstr "" + +#: ../../source/api/applications/layers.rst:2 +msgid "tensorcircuit.applications.layers" +msgstr "" + +#: of tensorcircuit.applications.layers:1 +msgid "Module for functions adding layers of circuits" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_gate_layer..f:1 +msgid "Hlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_gate_layer..f:1 +msgid "anyrxlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_gate_layer..f:1 +msgid "anyrylayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_gate_layer..f:1 +msgid "anyrzlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyswaplayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyxxlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyxylayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyxzlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyyxlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyyylayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyyzlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyzxlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyzylayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer..f:1 +msgid "anyzzlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "cnotlayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_gate_layer..f:1 +msgid "rxlayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_gate_layer..f:1 +msgid "rylayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_gate_layer..f:1 +msgid "rzlayer" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "swaplayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "xxgate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "xxlayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "xygate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "xylayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "xzgate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "xzlayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "yxgate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "yxlayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "yygate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "yylayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "yzgate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "yzlayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "zxgate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "zxlayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "zygate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "zylayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_double_gate..f:1 +msgid "zzgate" +msgstr "" + +#: of +#: tensorcircuit.applications.layers.generate_cirq_double_gate_layer..f:1 +msgid "zzlayer" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_any_gate_layer:1 +msgid "$$e^{-i\\theta_i \\sigma}$$" +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_any_double_gate_layer:1 +msgid "" +"The following function should be used to generate layers with special " +"case. As its soundness depends on the nature of the task or problem, it " +"doesn't always make sense." +msgstr "" + +#: of tensorcircuit.applications.layers.generate_cirq_any_gate_layer:1 +#: tensorcircuit.applications.layers.generate_cirq_gate_layer:1 +#: tensorcircuit.applications.layers.generate_gate_layer:1 +msgid "$$e^{-i\\theta \\sigma}$$" +msgstr "" + +#: ../../source/api/applications/utils.rst:2 +msgid "tensorcircuit.applications.utils" +msgstr "" + +#: of tensorcircuit.applications.utils:1 +msgid "" +"A collection of useful function snippets that irrelevant with the main " +"modules or await for further refactor" +msgstr "" + +#: of tensorcircuit.applications.utils.color_svg:1 +msgid "color cirq circuit SVG for given gates, a small tool to hack the cirq SVG" +msgstr "" + +#: of tensorcircuit.applications.utils.color_svg:5 +msgid "integer coordinate which gate is colored" +msgstr "" + +#: of tensorcircuit.applications.utils.repr2array:1 +msgid "transform repr form of an array to real numpy array" +msgstr "" + +#: ../../source/api/applications/vags.rst:2 +msgid "tensorcircuit.applications.vags" +msgstr "" + +#: of tensorcircuit.applications.vags:1 +msgid "DQAS application kernels as vag functions" +msgstr "" + +#: of tensorcircuit.applications.vags.ave_func:1 +msgid "1D array for full wavefunction, the basis is in lexcical order" +msgstr "" + +#: of tensorcircuit.applications.vags.ave_func:2 +#: tensorcircuit.applications.vags.energy:5 +msgid "nx.Graph" +msgstr "" + +#: of tensorcircuit.applications.vags.ave_func:3 +msgid "transformation functions before averaged" +msgstr "" + +#: of tensorcircuit.applications.vags.cvar:1 +msgid "as f3" +msgstr "" + +#: of tensorcircuit.applications.vags.energy:1 +msgid "maxcut energy for n qubit wavefunction i-th basis" +msgstr "" + +#: of tensorcircuit.applications.vags.energy:3 +msgid "ranged from 0 to 2**n-1" +msgstr "" + +#: of tensorcircuit.applications.vags.energy:4 +#: tensorcircuit.applications.vags.unitary_design:4 +#: tensorcircuit.quantum.correlation_from_samples:8 +#: tensorcircuit.quantum.count_s2d:6 tensorcircuit.quantum.count_tuple2dict:5 +#: tensorcircuit.quantum.count_vector2dict:5 tensorcircuit.quantum.sample2all:5 +#: tensorcircuit.quantum.sample_bin2int:5 +#: tensorcircuit.quantum.sample_int2bin:5 +msgid "number of qubits" +msgstr "" + +#: of tensorcircuit.applications.vags.entanglement_entropy:1 +msgid "" +"deprecated as non tf and non flexible, use the combination of " +"``reduced_density_matrix`` and ``entropy`` instead." +msgstr "" + +#: of tensorcircuit.applications.vags.entropy:1 +#: tensorcircuit.applications.vags.reduced_density_matrix:1 +msgid "deprecated, current version in tc.quantum" +msgstr "" + +#: of tensorcircuit.applications.vags.evaluate_vag:1 +msgid "" +"value and gradient, currently only tensorflow backend is supported jax " +"and numpy seems to be slow in circuit simulation anyhow. *deprecated*" +msgstr "" + +#: of tensorcircuit.applications.vags.evaluate_vag:8 +msgid "if lbd=0, take energy as objective" +msgstr "" + +#: of tensorcircuit.applications.vags.evaluate_vag:9 +msgid "if as default 0, overlap will not compute in the process" +msgstr "" + +#: of tensorcircuit.applications.vags.gapfilling:1 +msgid "Fill single qubit gates according to placeholder on circuit" +msgstr "" + +#: of tensorcircuit.applications.vags.heisenberg_measurements:1 +msgid "Hamiltonian measurements for Heisenberg model on graph lattice g" +msgstr "" + +#: of tensorcircuit.applications.vags.q:1 +msgid "short cut for ``cirq.LineQubit(i)``" +msgstr "" + +#: of tensorcircuit.applications.vags.qaoa_block_vag:1 +#: tensorcircuit.applications.vags.qaoa_block_vag_energy:1 +msgid "QAOA block encoding kernel, support 2 params in one op" +msgstr "" + +#: of tensorcircuit.applications.vags.qaoa_train:1 +msgid "" +"training QAOA with only optimizing circuit parameters, can be well " +"replaced with more general function `DQAS_search`" +msgstr "" + +#: of tensorcircuit.applications.vags.quantum_mp_qaoa_vag:1 +msgid "multi parameter for one layer" +msgstr "" + +#: of tensorcircuit.applications.vags.quantum_mp_qaoa_vag:7 +#: tensorcircuit.applications.vags.quantum_qaoa_vag:7 +msgid "kw arguments for measurements_func" +msgstr "" + +#: of tensorcircuit.applications.vags.quantum_mp_qaoa_vag:8 +msgid "loss function, gradient of nnp" +msgstr "" + +#: of tensorcircuit.applications.vags.quantum_qaoa_vag:1 +msgid "" +"tensorflow quantum backend compare to qaoa_vag which is tensorcircuit " +"backend" +msgstr "" + +#: of tensorcircuit.applications.vags.tfim_measurements:1 +msgid "Hamiltonian for tfim on lattice defined by graph g" +msgstr "" + +#: of tensorcircuit.applications.vags.tfim_measurements:8 +msgid "cirq.PauliSum as operators for tfq expectation layer" +msgstr "" + +#: of tensorcircuit.applications.vags.unitary_design:1 +msgid "" +"generate random wavefunction from approximately Haar measure, reference:" +" https://doi.org/10.1063/1.4983266" +msgstr "" + +#: of tensorcircuit.applications.vags.unitary_design:5 +msgid "repetition of the blocks" +msgstr "" + +#: of tensorcircuit.applications.vags.unitary_design_block:1 +msgid "random Haar measure approximation" +msgstr "" + +#: of tensorcircuit.applications.vags.unitary_design_block:3 +msgid "cirq.Circuit, empty circuit" +msgstr "" + +#: of tensorcircuit.applications.vags.unitary_design_block:4 +msgid "# of qubit" +msgstr "" + +#: ../../source/api/applications/van.rst:2 +msgid "tensorcircuit.applications.van" +msgstr "" + +#: of tensorcircuit.applications.van:1 +msgid "" +"One-hot variational autoregressive models for multiple categorical " +"choices beyond binary" +msgstr "" + +#: of tensorcircuit.applications.van.MADE:1 +#: tensorcircuit.applications.van.NMF:1 +#: tensorcircuit.applications.van.PixelCNN:1 +msgid "Bases: :py:class:`keras.engine.training.Model`" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.activity_regularizer:1 +#: tensorcircuit.applications.van.MaskedConv2D.activity_regularizer:1 +#: tensorcircuit.applications.van.MaskedLinear.activity_regularizer:1 +#: tensorcircuit.applications.van.NMF.activity_regularizer:1 +#: tensorcircuit.applications.van.PixelCNN.activity_regularizer:1 +#: tensorcircuit.applications.van.ResidualBlock.activity_regularizer:1 +#: tensorcircuit.applications.vqes.Linear.activity_regularizer:1 +#: tensorcircuit.keras.QuantumLayer.activity_regularizer:1 +msgid "Optional regularizer function for the output of this layer." +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:1 of +msgid "Add loss tensor(s), potentially dependent on layer inputs." +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:3 of +msgid "" +"Some losses (for instance, activity regularization losses) may be " +"dependent on the inputs passed when calling a layer. Hence, when reusing " +"the same layer on different inputs `a` and `b`, some entries in " +"`layer.losses` may be dependent on `a` and some on `b`. This method " +"automatically keeps track of dependencies." +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:9 of +msgid "" +"This method can be used inside a subclassed layer or model's `call` " +"function, in which case `losses` should be a Tensor or list of Tensors." +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:12 +#: keras.engine.base_layer.Layer.add_loss:26 +#: keras.engine.base_layer.Layer.add_loss:42 +#: keras.engine.training.Model.compile:3 keras.engine.training.Model.save:28 of +#: tensorcircuit.applications.van.MaskedConv2D.metrics:3 +#: tensorcircuit.applications.van.MaskedLinear.metrics:3 +#: tensorcircuit.applications.van.ResidualBlock.metrics:3 +#: tensorcircuit.applications.vqes.Linear.metrics:3 +#: tensorcircuit.keras.QuantumLayer.metrics:3 +msgid "Example:" +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:14 of +msgid "```python class MyLayer(tf.keras.layers.Layer):" +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:17 +#: keras.engine.base_layer.Layer.add_metric:14 of +msgid "def call(self, inputs):" +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:17 of +msgid "self.add_loss(tf.abs(tf.reduce_mean(inputs))) return inputs" +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:19 +#: keras.engine.base_layer.Layer.add_metric:16 +#: keras.engine.training.Model.compile:10 of +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:21 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:35 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:21 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:35 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:19 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:33 +msgid "```" +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:21 of +msgid "" +"This method can also be called directly on a Functional Model during " +"construction. In this case, any loss Tensors passed to this Model must be" +" symbolic and be able to be traced back to the model's `Input`s. These " +"losses become part of the model's topology and are tracked in " +"`get_config`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:28 of +msgid "" +"```python inputs = tf.keras.Input(shape=(10,)) x = " +"tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Dense(1)(x) " +"model = tf.keras.Model(inputs, outputs) # Activity regularization. " +"model.add_loss(tf.abs(tf.reduce_mean(x))) ```" +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:37 of +msgid "" +"If this is not the case for your loss (if, for example, your loss " +"references a `Variable` of one of the model's layers), you can wrap your " +"loss in a zero-argument lambda. These losses are not tracked as part of " +"the model's topology since they can't be serialized." +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:44 of +msgid "" +"```python inputs = tf.keras.Input(shape=(10,)) d = " +"tf.keras.layers.Dense(10) x = d(inputs) outputs = " +"tf.keras.layers.Dense(1)(x) model = tf.keras.Model(inputs, outputs) # " +"Weight regularization. model.add_loss(lambda: tf.reduce_mean(d.kernel)) " +"```" +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:54 of +msgid "" +"Loss tensor, or list/tuple of tensors. Rather than tensors, losses may " +"also be zero-argument callables which create a loss tensor." +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:56 of +msgid "" +"Additional keyword arguments for backward compatibility. Accepted values:" +" inputs - Deprecated, will be automatically inferred." +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:56 of +msgid "Additional keyword arguments for backward compatibility. Accepted values:" +msgstr "" + +#: keras.engine.base_layer.Layer.add_loss:58 of +msgid "inputs - Deprecated, will be automatically inferred." +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:1 of +msgid "Adds metric tensor to the layer." +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:3 of +msgid "" +"This method can be used inside the `call()` method of a subclassed layer " +"or model." +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:6 of +msgid "```python class MyMetricLayer(tf.keras.layers.Layer):" +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:10 of +msgid "def __init__(self):" +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:9 of +msgid "" +"super(MyMetricLayer, self).__init__(name='my_metric_layer') self.mean = " +"tf.keras.metrics.Mean(name='metric_1')" +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:13 of +msgid "" +"self.add_metric(self.mean(inputs)) self.add_metric(tf.reduce_sum(inputs)," +" name='metric_2') return inputs" +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:18 of +msgid "" +"This method can also be called directly on a Functional Model during " +"construction. In this case, any tensor passed to this Model must be " +"symbolic and be able to be traced back to the model's `Input`s. These " +"metrics become part of the model's topology and are tracked when you save" +" the model via `save()`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:24 of +msgid "" +"```python inputs = tf.keras.Input(shape=(10,)) x = " +"tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Dense(1)(x) " +"model = tf.keras.Model(inputs, outputs) " +"model.add_metric(math_ops.reduce_sum(x), name='metric_1') ```" +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:32 of +msgid "" +"Note: Calling `add_metric()` with the result of a metric object on a " +"Functional Model, as shown in the example below, is not supported. This " +"is because we cannot trace the metric result tensor back to the model's " +"inputs." +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:36 of +msgid "" +"```python inputs = tf.keras.Input(shape=(10,)) x = " +"tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Dense(1)(x) " +"model = tf.keras.Model(inputs, outputs) " +"model.add_metric(tf.keras.metrics.Mean()(x), name='metric_1') ```" +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:44 of +msgid "Metric tensor." +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:45 of +msgid "String metric name." +msgstr "" + +#: keras.engine.base_layer.Layer.add_metric:46 of +msgid "" +"Additional keyword arguments for backward compatibility. Accepted values:" +" `aggregation` - When the `value` tensor provided is not the result of " +"calling a `keras.Metric` instance, it will be aggregated by default using" +" a `keras.Metric.Mean`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_update:1 of +msgid "Add update op(s), potentially dependent on layer inputs." +msgstr "" + +#: keras.engine.base_layer.Layer.add_update:3 of +msgid "" +"Weight updates (for instance, the updates of the moving mean and variance" +" in a BatchNormalization layer) may be dependent on the inputs passed " +"when calling a layer. Hence, when reusing the same layer on different " +"inputs `a` and `b`, some entries in `layer.updates` may be dependent on " +"`a` and some on `b`. This method automatically keeps track of " +"dependencies." +msgstr "" + +#: keras.engine.base_layer.Layer.add_update:10 of +msgid "" +"This call is ignored when eager execution is enabled (in that case, " +"variable updates are run on the fly and thus do not need to be tracked " +"for later execution)." +msgstr "" + +#: keras.engine.base_layer.Layer.add_update:14 of +msgid "" +"Update op, or list/tuple of update ops, or zero-arg callable that returns" +" an update op. A zero-arg callable should be passed in order to disable " +"running the updates by setting `trainable=False` on this Layer, when " +"executing in Eager mode." +msgstr "" + +#: keras.engine.base_layer.Layer.add_update:18 of +msgid "Deprecated, will be automatically inferred." +msgstr "" + +#: keras.engine.base_layer.Layer.add_variable:1 of +msgid "Deprecated, do NOT use! Alias for `add_weight`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:1 of +msgid "Adds a new variable to the layer." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:3 of +msgid "Variable name." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:4 of +msgid "Variable shape. Defaults to scalar if unspecified." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:5 of +msgid "The type of the variable. Defaults to `self.dtype`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:6 of +msgid "Initializer instance (callable)." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:7 of +msgid "Regularizer instance (callable)." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:8 of +msgid "" +"Boolean, whether the variable should be part of the layer's " +"\"trainable_variables\" (e.g. variables, biases) or " +"\"non_trainable_variables\" (e.g. BatchNorm mean and variance). Note that" +" `trainable` cannot be `True` if `synchronization` is set to `ON_READ`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:13 of +msgid "Constraint instance (callable)." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:14 of +msgid "Whether to use `ResourceVariable`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:15 of +msgid "" +"Indicates when a distributed a variable will be aggregated. Accepted " +"values are constants defined in the class `tf.VariableSynchronization`. " +"By default the synchronization is set to `AUTO` and the current " +"`DistributionStrategy` chooses when to synchronize. If `synchronization` " +"is set to `ON_READ`, `trainable` must not be set to `True`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:21 of +msgid "" +"Indicates how a distributed variable will be aggregated. Accepted values " +"are constants defined in the class `tf.VariableAggregation`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:24 of +msgid "" +"Additional keyword arguments. Accepted values are `getter`, " +"`collections`, `experimental_autocast` and `caching_device`." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:27 of +msgid "The variable created." +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight +#: keras.engine.base_layer.Layer.compute_output_signature +#: keras.engine.base_layer.Layer.count_params +#: keras.engine.base_layer.Layer.get_input_at +#: keras.engine.base_layer.Layer.get_input_shape_at +#: keras.engine.base_layer.Layer.get_output_at +#: keras.engine.base_layer.Layer.get_output_shape_at +#: keras.engine.base_layer.Layer.set_weights keras.engine.training.Model.build +#: keras.engine.training.Model.evaluate keras.engine.training.Model.fit +#: keras.engine.training.Model.load_weights keras.engine.training.Model.predict +#: keras.engine.training.Model.predict_on_batch +#: keras.engine.training.Model.save_weights keras.engine.training.Model.summary +#: keras.engine.training.Model.test_on_batch +#: keras.engine.training.Model.to_yaml +#: keras.engine.training.Model.train_on_batch of +#: tensorcircuit.applications.van.MADE.input +#: tensorcircuit.applications.van.MADE.input_mask +#: tensorcircuit.applications.van.MADE.input_shape +#: tensorcircuit.applications.van.MADE.output +#: tensorcircuit.applications.van.MADE.output_mask +#: tensorcircuit.applications.van.MADE.output_shape +#: tensorcircuit.applications.van.MaskedConv2D.input +#: tensorcircuit.applications.van.MaskedConv2D.input_mask +#: tensorcircuit.applications.van.MaskedConv2D.input_shape +#: tensorcircuit.applications.van.MaskedConv2D.output +#: tensorcircuit.applications.van.MaskedConv2D.output_mask +#: tensorcircuit.applications.van.MaskedConv2D.output_shape +#: tensorcircuit.applications.van.MaskedLinear.input +#: tensorcircuit.applications.van.MaskedLinear.input_mask +#: tensorcircuit.applications.van.MaskedLinear.input_shape +#: tensorcircuit.applications.van.MaskedLinear.output +#: tensorcircuit.applications.van.MaskedLinear.output_mask +#: tensorcircuit.applications.van.MaskedLinear.output_shape +#: tensorcircuit.applications.van.NMF.input +#: tensorcircuit.applications.van.NMF.input_mask +#: tensorcircuit.applications.van.NMF.input_shape +#: tensorcircuit.applications.van.NMF.output +#: tensorcircuit.applications.van.NMF.output_mask +#: tensorcircuit.applications.van.NMF.output_shape +#: tensorcircuit.applications.van.PixelCNN.input +#: tensorcircuit.applications.van.PixelCNN.input_mask +#: tensorcircuit.applications.van.PixelCNN.input_shape +#: tensorcircuit.applications.van.PixelCNN.output +#: tensorcircuit.applications.van.PixelCNN.output_mask +#: tensorcircuit.applications.van.PixelCNN.output_shape +#: tensorcircuit.applications.van.ResidualBlock.input +#: tensorcircuit.applications.van.ResidualBlock.input_mask +#: tensorcircuit.applications.van.ResidualBlock.input_shape +#: tensorcircuit.applications.van.ResidualBlock.output +#: tensorcircuit.applications.van.ResidualBlock.output_mask +#: tensorcircuit.applications.van.ResidualBlock.output_shape +#: tensorcircuit.applications.vqes.Linear.input +#: tensorcircuit.applications.vqes.Linear.input_mask +#: tensorcircuit.applications.vqes.Linear.input_shape +#: tensorcircuit.applications.vqes.Linear.output +#: tensorcircuit.applications.vqes.Linear.output_mask +#: tensorcircuit.applications.vqes.Linear.output_shape +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map +#: tensorcircuit.backends.backend_factory.get_backend +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_map +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map +#: tensorcircuit.basecircuit.BaseCircuit.expectation_before +#: tensorcircuit.circuit.Circuit.expectation tensorcircuit.circuit.expectation +#: tensorcircuit.cons.get_contractor tensorcircuit.cons.set_contractor +#: tensorcircuit.gates.bmatrix tensorcircuit.keras.QuantumLayer.input +#: tensorcircuit.keras.QuantumLayer.input_mask +#: tensorcircuit.keras.QuantumLayer.input_shape +#: tensorcircuit.keras.QuantumLayer.output +#: tensorcircuit.keras.QuantumLayer.output_mask +#: tensorcircuit.keras.QuantumLayer.output_shape tensorcircuit.keras.load_func +#: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate +#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate +#: tensorcircuit.quantum.QuOperator.__init__ +#: tensorcircuit.quantum.QuOperator.eval +#: tensorcircuit.quantum.QuOperator.eval_matrix +#: tensorcircuit.quantum.check_spaces +#: tensornetwork.backends.abstract_backend.AbstractBackend.gmres +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.position +#: tensornetwork.network_components.AbstractNode.add_axis_names +#: tensornetwork.network_components.AbstractNode.add_edge +#: tensornetwork.network_components.AbstractNode.get_dimension +#: tensornetwork.network_components.AbstractNode.reorder_axes +#: tensornetwork.network_components.AbstractNode.reorder_edges +#: tensornetwork.network_components.Node.__init__ +#: torch.nn.modules.module.Module.get_buffer +#: torch.nn.modules.module.Module.get_parameter +#: torch.nn.modules.module.Module.get_submodule +msgid "Raises" +msgstr "" + +#: keras.engine.base_layer.Layer.add_weight:29 of +msgid "" +"When giving unsupported dtype and no initializer or when trainable " +"has been set to True with synchronization set as `ON_READ`." +msgstr "" + +#: keras.engine.base_layer.Layer.apply:1 +#: keras.engine.base_layer.Layer.get_losses_for:1 +#: keras.engine.base_layer.Layer.get_updates_for:1 of +#: tensorcircuit.applications.van.MADE.state_updates:1 +#: tensorcircuit.applications.van.NMF.state_updates:1 +#: tensorcircuit.applications.van.PixelCNN.state_updates:1 +msgid "Deprecated, do NOT use!" +msgstr "" + +#: keras.engine.base_layer.Layer.apply:3 of +msgid "This is an alias of `self.__call__`." +msgstr "" + +#: keras.engine.base_layer.Layer.apply:5 of +msgid "Input tensor(s)." +msgstr "" + +#: keras.engine.base_layer.Layer.apply:6 of +msgid "additional positional arguments to be passed to `self.call`." +msgstr "" + +#: keras.engine.base_layer.Layer.apply:7 of +msgid "additional keyword arguments to be passed to `self.call`." +msgstr "" + +#: keras.engine.base_layer.Layer.apply:9 of +msgid "Output tensor(s)." +msgstr "" + +#: keras.engine.training.Model.build:1 of +msgid "Builds the model based on input shapes received." +msgstr "" + +#: keras.engine.training.Model.build:3 of +msgid "" +"This is to be used for subclassed models, which do not know at " +"instantiation time what their inputs look like." +msgstr "" + +#: keras.engine.training.Model.build:6 of +msgid "" +"This method only exists for users who want to call `model.build()` in a " +"standalone way (as a substitute for calling the model on real data to " +"build it). It will never be called by the framework (and thus it will " +"never throw unexpected errors in an unrelated workflow)." +msgstr "" + +#: keras.engine.training.Model.build:11 of +msgid "" +"Single tuple, `TensorShape` instance, or list/dict of shapes, where " +"shapes are tuples, integers, or `TensorShape` instances." +msgstr "" + +#: keras.engine.training.Model.build:14 of +msgid "" +"1. In case of invalid user-provided data (not of type tuple, list," +" `TensorShape`, or dict). 2. If the model requires call arguments " +"that are agnostic to the input shapes (positional or keyword arg " +"in call signature). 3. If not all layers were properly built. 4. " +"If float type inputs are not supported within the layers." +msgstr "" + +#: keras.engine.training.Model.build:14 of +msgid "" +"In case of invalid user-provided data (not of type tuple, list, " +"`TensorShape`, or dict). 2. If the model requires call arguments that" +" are agnostic to the input shapes (positional or keyword arg in " +"call signature). 3. If not all layers were properly built. 4. If " +"float type inputs are not supported within the layers." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:1 +#: tensorcircuit.applications.van.NMF.call:1 +#: tensorcircuit.applications.van.PixelCNN.call:1 +msgid "Calls the model on new inputs and returns the outputs as tensors." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:3 +#: tensorcircuit.applications.van.NMF.call:3 +#: tensorcircuit.applications.van.PixelCNN.call:3 +msgid "" +"In this case `call()` just reapplies all ops in the graph to the new " +"inputs (e.g. build a new computational graph from the provided inputs)." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:7 +#: tensorcircuit.applications.van.NMF.call:7 +#: tensorcircuit.applications.van.PixelCNN.call:7 +msgid "" +"Note: This method should not be called directly. It is only meant to be " +"overridden when subclassing `tf.keras.Model`. To call a model on an " +"input, always use the `__call__()` method, i.e. `model(inputs)`, which " +"relies on the underlying `call()` method." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:12 +#: tensorcircuit.applications.van.NMF.call:12 +#: tensorcircuit.applications.van.PixelCNN.call:12 +msgid "Input tensor, or dict/list/tuple of input tensors." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:13 +#: tensorcircuit.applications.van.NMF.call:13 +#: tensorcircuit.applications.van.PixelCNN.call:13 +msgid "" +"Boolean or boolean scalar tensor, indicating whether to run the `Network`" +" in training mode or inference mode." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:15 +#: tensorcircuit.applications.van.NMF.call:15 +#: tensorcircuit.applications.van.PixelCNN.call:15 +msgid "" +"A mask or list of masks. A mask can be either a boolean tensor or None " +"(no mask). For more details, check the guide " +"[here](https://www.tensorflow.org/guide/keras/masking_and_padding)." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:15 +#: tensorcircuit.applications.van.NMF.call:15 +#: tensorcircuit.applications.van.PixelCNN.call:15 +msgid "" +"A mask or list of masks. A mask can be either a boolean tensor or None " +"(no mask). For more details, check the guide" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:17 +#: tensorcircuit.applications.van.NMF.call:17 +#: tensorcircuit.applications.van.PixelCNN.call:17 +msgid "[here](https://www.tensorflow.org/guide/keras/masking_and_padding)." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.call:19 +#: tensorcircuit.applications.van.NMF.call:19 +#: tensorcircuit.applications.van.PixelCNN.call:19 +msgid "" +"A tensor if there is a single output, or a list of tensors if there are " +"more than one outputs." +msgstr "" + +#: keras.engine.training.Model.compile:1 of +msgid "Configures the model for training." +msgstr "" + +#: keras.engine.training.Model.compile:5 of +msgid "" +"```python " +"model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3)," +msgstr "" + +#: keras.engine.training.Model.compile:7 of +msgid "" +"loss=tf.keras.losses.BinaryCrossentropy(), " +"metrics=[tf.keras.metrics.BinaryAccuracy()," +msgstr "" + +#: keras.engine.training.Model.compile:9 of +msgid "tf.keras.metrics.FalseNegatives()])" +msgstr "" + +#: keras.engine.training.Model.compile:12 of +msgid "" +"String (name of optimizer) or optimizer instance. See " +"`tf.keras.optimizers`." +msgstr "" + +#: keras.engine.training.Model.compile:14 of +msgid "" +"Loss function. Maybe be a string (name of loss function), or a " +"`tf.keras.losses.Loss` instance. See `tf.keras.losses`. A loss function " +"is any callable with the signature `loss = fn(y_true, y_pred)`, where " +"`y_true` are the ground truth values, and `y_pred` are the model's " +"predictions. `y_true` should have shape `(batch_size, d0, .. dN)` (except" +" in the case of sparse loss functions such as sparse categorical " +"crossentropy which expects integer arrays of shape `(batch_size, d0, .. " +"dN-1)`). `y_pred` should have shape `(batch_size, d0, .. dN)`. The loss " +"function should return a float tensor. If a custom `Loss` instance is " +"used and reduction is set to `None`, return value has shape `(batch_size," +" d0, .. dN-1)` i.e. per-sample or per-timestep loss values; otherwise, it" +" is a scalar. If the model has multiple outputs, you can use a different " +"loss on each output by passing a dictionary or a list of losses. The loss" +" value that will be minimized by the model will then be the sum of all " +"individual losses, unless `loss_weights` is specified." +msgstr "" + +#: keras.engine.training.Model.compile:34 of +msgid "" +"List of metrics to be evaluated by the model during training and testing." +" Each of this can be a string (name of a built-in function), function or " +"a `tf.keras.metrics.Metric` instance. See `tf.keras.metrics`. Typically " +"you will use `metrics=['accuracy']`. A function is any callable with the " +"signature `result = fn(y_true, y_pred)`. To specify different metrics for" +" different outputs of a multi-output model, you could also pass a " +"dictionary, such as `metrics={'output_a': 'accuracy', 'output_b': " +"['accuracy', 'mse']}`. You can also pass a list to specify a metric or a " +"list of metrics for each output, such as `metrics=[['accuracy'], " +"['accuracy', 'mse']]` or `metrics=['accuracy', ['accuracy', 'mse']]`. " +"When you pass the strings 'accuracy' or 'acc', we convert this to one of " +"`tf.keras.metrics.BinaryAccuracy`, " +"`tf.keras.metrics.CategoricalAccuracy`, " +"`tf.keras.metrics.SparseCategoricalAccuracy` based on the loss function " +"used and the model output shape. We do a similar conversion for the " +"strings 'crossentropy' and 'ce' as well." +msgstr "" + +#: keras.engine.training.Model.compile:51 of +msgid "" +"Optional list or dictionary specifying scalar coefficients (Python " +"floats) to weight the loss contributions of different model outputs. The " +"loss value that will be minimized by the model will then be the *weighted" +" sum* of all individual losses, weighted by the `loss_weights` " +"coefficients. If a list, it is expected to have a 1:1 mapping to the " +"model's outputs. If a dict, it is expected to map output names " +"(strings) to scalar coefficients." +msgstr "" + +#: keras.engine.training.Model.compile:51 of +msgid "" +"Optional list or dictionary specifying scalar coefficients (Python " +"floats) to weight the loss contributions of different model outputs. The " +"loss value that will be minimized by the model will then be the *weighted" +" sum* of all individual losses, weighted by the `loss_weights` " +"coefficients." +msgstr "" + +#: keras.engine.training.Model.compile:57 of +msgid "If a list, it is expected to have a 1:1 mapping to the model's" +msgstr "" + +#: keras.engine.training.Model.compile:57 of +msgid "" +"outputs. If a dict, it is expected to map output names (strings) to " +"scalar coefficients." +msgstr "" + +#: keras.engine.training.Model.compile:59 of +msgid "" +"List of metrics to be evaluated and weighted by `sample_weight` or " +"`class_weight` during training and testing." +msgstr "" + +#: keras.engine.training.Model.compile:61 of +msgid "" +"Bool. Defaults to `False`. If `True`, this `Model`'s logic will not be " +"wrapped in a `tf.function`. Recommended to leave this as `None` unless " +"your `Model` cannot be run inside a `tf.function`. `run_eagerly=True` is " +"not supported when using " +"`tf.distribute.experimental.ParameterServerStrategy`." +msgstr "" + +#: keras.engine.training.Model.compile:66 of +msgid "" +"Int. Defaults to 1. The number of batches to run during each " +"`tf.function` call. Running multiple batches inside a single " +"`tf.function` call can greatly improve performance on TPUs or small " +"models with a large Python overhead. At most, one full epoch will be run " +"each execution. If a number larger than the size of the epoch is passed, " +"the execution will be truncated to the size of the epoch. Note that if " +"`steps_per_execution` is set to `N`, `Callback.on_batch_begin` and " +"`Callback.on_batch_end` methods will only be called every `N` batches " +"(i.e. before/after each `tf.function` execution)." +msgstr "" + +#: keras.engine.training.Model.compile:77 of +msgid "Arguments supported for backwards compatibility only." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.compute_dtype:1 +#: tensorcircuit.applications.van.MaskedConv2D.compute_dtype:1 +#: tensorcircuit.applications.van.MaskedLinear.compute_dtype:1 +#: tensorcircuit.applications.van.NMF.compute_dtype:1 +#: tensorcircuit.applications.van.PixelCNN.compute_dtype:1 +#: tensorcircuit.applications.van.ResidualBlock.compute_dtype:1 +#: tensorcircuit.applications.vqes.Linear.compute_dtype:1 +#: tensorcircuit.keras.QuantumLayer.compute_dtype:1 +msgid "The dtype of the layer's computations." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.compute_dtype:3 +#: tensorcircuit.applications.van.MaskedConv2D.compute_dtype:3 +#: tensorcircuit.applications.van.MaskedLinear.compute_dtype:3 +#: tensorcircuit.applications.van.NMF.compute_dtype:3 +#: tensorcircuit.applications.van.PixelCNN.compute_dtype:3 +#: tensorcircuit.applications.van.ResidualBlock.compute_dtype:3 +#: tensorcircuit.applications.vqes.Linear.compute_dtype:3 +#: tensorcircuit.keras.QuantumLayer.compute_dtype:3 +msgid "" +"This is equivalent to `Layer.dtype_policy.compute_dtype`. Unless mixed " +"precision is used, this is the same as `Layer.dtype`, the dtype of the " +"weights." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.compute_dtype:7 +#: tensorcircuit.applications.van.MaskedConv2D.compute_dtype:7 +#: tensorcircuit.applications.van.MaskedLinear.compute_dtype:7 +#: tensorcircuit.applications.van.NMF.compute_dtype:7 +#: tensorcircuit.applications.van.PixelCNN.compute_dtype:7 +#: tensorcircuit.applications.van.ResidualBlock.compute_dtype:7 +#: tensorcircuit.applications.vqes.Linear.compute_dtype:7 +#: tensorcircuit.keras.QuantumLayer.compute_dtype:7 +msgid "" +"Layers automatically cast their inputs to the compute dtype, which causes" +" computations and the output to be in the compute dtype as well. This is " +"done by the base Layer class in `Layer.__call__`, so you do not have to " +"insert these casts if implementing your own layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.compute_dtype:12 +#: tensorcircuit.applications.van.MaskedConv2D.compute_dtype:12 +#: tensorcircuit.applications.van.MaskedLinear.compute_dtype:12 +#: tensorcircuit.applications.van.NMF.compute_dtype:12 +#: tensorcircuit.applications.van.PixelCNN.compute_dtype:12 +#: tensorcircuit.applications.van.ResidualBlock.compute_dtype:12 +#: tensorcircuit.applications.vqes.Linear.compute_dtype:12 +#: tensorcircuit.keras.QuantumLayer.compute_dtype:12 +msgid "" +"Layers often perform certain internal computations in higher precision " +"when `compute_dtype` is float16 or bfloat16 for numeric stability. The " +"output will still typically be float16 or bfloat16 in such cases." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.compute_dtype:16 +#: tensorcircuit.applications.van.MaskedConv2D.compute_dtype:16 +#: tensorcircuit.applications.van.MaskedLinear.compute_dtype:16 +#: tensorcircuit.applications.van.NMF.compute_dtype:16 +#: tensorcircuit.applications.van.PixelCNN.compute_dtype:16 +#: tensorcircuit.applications.van.ResidualBlock.compute_dtype:16 +#: tensorcircuit.applications.vqes.Linear.compute_dtype:16 +#: tensorcircuit.keras.QuantumLayer.compute_dtype:16 +msgid "The layer's compute dtype." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_mask:1 of +msgid "Computes an output mask tensor." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_mask:3 +#: keras.engine.base_layer.Layer.compute_mask:4 of +msgid "Tensor or list of tensors." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_mask:6 of +msgid "" +"None or a tensor (or list of tensors, one per output tensor of the " +"layer)." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_mask:8 of +msgid "None or a tensor (or list of tensors," +msgstr "" + +#: keras.engine.base_layer.Layer.compute_mask:9 of +msgid "one per output tensor of the layer)." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_shape:1 of +msgid "Computes the output shape of the layer." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_shape:3 of +msgid "" +"If the layer has not been built, this method will call `build` on the " +"layer. This assumes that the layer will later be used with inputs that " +"match the input shape provided here." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_shape:7 of +msgid "" +"Shape tuple (tuple of integers) or list of shape tuples (one per output " +"tensor of the layer). Shape tuples can include None for free dimensions, " +"instead of an integer." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_shape:12 of +msgid "An input shape tuple." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_signature:1 of +msgid "Compute the output tensor signature of the layer based on the inputs." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_signature:3 of +msgid "" +"Unlike a TensorShape object, a TensorSpec object contains both shape and " +"dtype information for a tensor. This method allows layers to provide " +"output dtype information if it is different from the input dtype. For any" +" layer that doesn't implement this function, the framework will fall back" +" to use `compute_output_shape`, and will assume that the output dtype " +"matches the input dtype." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_signature:10 of +msgid "" +"Single TensorSpec or nested structure of TensorSpec objects, describing a" +" candidate input for the layer." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_signature:13 of +msgid "" +"Single TensorSpec or nested structure of TensorSpec objects, describing" +" how the layer would transform the provided input." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_signature:16 of +msgid "Single TensorSpec or nested structure of TensorSpec objects, describing" +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_signature:16 of +msgid "how the layer would transform the provided input." +msgstr "" + +#: keras.engine.base_layer.Layer.compute_output_signature:18 of +msgid "If input_signature contains a non-TensorSpec object." +msgstr "" + +#: keras.engine.base_layer.Layer.count_params:1 of +msgid "Count the total number of scalars composing the weights." +msgstr "" + +#: keras.engine.base_layer.Layer.count_params:3 of +msgid "An integer count." +msgstr "" + +#: keras.engine.base_layer.Layer.count_params:5 of +msgid "" +"if the layer isn't yet built (in which case its weights aren't yet " +"defined)." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.distribute_strategy:1 +#: tensorcircuit.applications.van.NMF.distribute_strategy:1 +#: tensorcircuit.applications.van.PixelCNN.distribute_strategy:1 +msgid "The `tf.distribute.Strategy` this model was created under." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.dtype:1 +#: tensorcircuit.applications.van.MaskedConv2D.dtype:1 +#: tensorcircuit.applications.van.MaskedLinear.dtype:1 +#: tensorcircuit.applications.van.NMF.dtype:1 +#: tensorcircuit.applications.van.PixelCNN.dtype:1 +#: tensorcircuit.applications.van.ResidualBlock.dtype:1 +#: tensorcircuit.applications.vqes.Linear.dtype:1 +#: tensorcircuit.keras.QuantumLayer.dtype:1 +msgid "The dtype of the layer weights." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.dtype:3 +#: tensorcircuit.applications.van.MaskedConv2D.dtype:3 +#: tensorcircuit.applications.van.MaskedLinear.dtype:3 +#: tensorcircuit.applications.van.NMF.dtype:3 +#: tensorcircuit.applications.van.PixelCNN.dtype:3 +#: tensorcircuit.applications.van.ResidualBlock.dtype:3 +#: tensorcircuit.applications.vqes.Linear.dtype:3 +#: tensorcircuit.keras.QuantumLayer.dtype:3 +msgid "" +"This is equivalent to `Layer.dtype_policy.variable_dtype`. Unless mixed " +"precision is used, this is the same as `Layer.compute_dtype`, the dtype " +"of the layer's computations." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.dtype_policy:1 +#: tensorcircuit.applications.van.MaskedConv2D.dtype_policy:1 +#: tensorcircuit.applications.van.MaskedLinear.dtype_policy:1 +#: tensorcircuit.applications.van.NMF.dtype_policy:1 +#: tensorcircuit.applications.van.PixelCNN.dtype_policy:1 +#: tensorcircuit.applications.van.ResidualBlock.dtype_policy:1 +#: tensorcircuit.applications.vqes.Linear.dtype_policy:1 +#: tensorcircuit.keras.QuantumLayer.dtype_policy:1 +msgid "The dtype policy associated with this layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.dtype_policy:3 +#: tensorcircuit.applications.van.MaskedConv2D.dtype_policy:3 +#: tensorcircuit.applications.van.MaskedLinear.dtype_policy:3 +#: tensorcircuit.applications.van.NMF.dtype_policy:3 +#: tensorcircuit.applications.van.PixelCNN.dtype_policy:3 +#: tensorcircuit.applications.van.ResidualBlock.dtype_policy:3 +#: tensorcircuit.applications.vqes.Linear.dtype_policy:3 +#: tensorcircuit.keras.QuantumLayer.dtype_policy:3 +msgid "This is an instance of a `tf.keras.mixed_precision.Policy`." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.dynamic:1 +#: tensorcircuit.applications.van.MaskedConv2D.dynamic:1 +#: tensorcircuit.applications.van.MaskedLinear.dynamic:1 +#: tensorcircuit.applications.van.NMF.dynamic:1 +#: tensorcircuit.applications.van.PixelCNN.dynamic:1 +#: tensorcircuit.applications.van.ResidualBlock.dynamic:1 +#: tensorcircuit.applications.vqes.Linear.dynamic:1 +#: tensorcircuit.keras.QuantumLayer.dynamic:1 +msgid "Whether the layer is dynamic (eager-only); set in the constructor." +msgstr "" + +#: keras.engine.training.Model.evaluate:1 of +msgid "Returns the loss value & metrics values for the model in test mode." +msgstr "" + +#: keras.engine.training.Model.evaluate:3 of +msgid "Computation is done in batches (see the `batch_size` arg.)" +msgstr "" + +#: keras.engine.training.Model.evaluate:5 of +msgid "" +"Input data. It could be: - A Numpy array (or array-like), or a list of " +"arrays (in case the model has multiple inputs). - A TensorFlow tensor, " +"or a list of tensors (in case the model has multiple inputs). - A dict " +"mapping input names to the corresponding array/tensors, if the model " +"has named inputs. - A `tf.data` dataset. Should return a tuple of " +"either `(inputs, targets)` or `(inputs, targets, sample_weights)`. - A " +"generator or `keras.utils.Sequence` returning `(inputs, targets)` or " +"`(inputs, targets, sample_weights)`. A more detailed description of " +"unpacking behavior for iterator types (Dataset, generator, Sequence) is " +"given in the `Unpacking behavior for iterator-like inputs` section of " +"`Model.fit`." +msgstr "" + +#: keras.engine.training.Model.evaluate:5 keras.engine.training.Model.fit:3 +#: keras.engine.training.Model.train_on_batch:3 of +msgid "" +"Input data. It could be: - A Numpy array (or array-like), or a list of " +"arrays" +msgstr "" + +#: keras.engine.training.Model.evaluate:7 keras.engine.training.Model.fit:5 +#: keras.engine.training.Model.predict:13 +#: keras.engine.training.Model.train_on_batch:5 +#: keras.engine.training.Model.train_on_batch:7 of +msgid "(in case the model has multiple inputs)." +msgstr "" + +#: keras.engine.training.Model.evaluate:8 keras.engine.training.Model.fit:6 +#: keras.engine.training.Model.predict:14 of +msgid "" +"A TensorFlow tensor, or a list of tensors (in case the model has multiple" +" inputs)." +msgstr "" + +#: keras.engine.training.Model.evaluate:10 keras.engine.training.Model.fit:8 of +msgid "" +"A dict mapping input names to the corresponding array/tensors, if the " +"model has named inputs." +msgstr "" + +#: keras.engine.training.Model.evaluate:12 keras.engine.training.Model.fit:10 +#: of +msgid "" +"A `tf.data` dataset. Should return a tuple of either `(inputs, targets)` " +"or `(inputs, targets, sample_weights)`." +msgstr "" + +#: keras.engine.training.Model.evaluate:15 keras.engine.training.Model.fit:13 +#: of +msgid "" +"A generator or `keras.utils.Sequence` returning `(inputs, targets)` or " +"`(inputs, targets, sample_weights)`." +msgstr "" + +#: keras.engine.training.Model.evaluate:17 +#: keras.engine.training.Model.predict:18 of +msgid "" +"A more detailed description of unpacking behavior for iterator types " +"(Dataset, generator, Sequence) is given in the `Unpacking behavior for " +"iterator-like inputs` section of `Model.fit`." +msgstr "" + +#: keras.engine.training.Model.evaluate:20 of +msgid "" +"Target data. Like the input data `x`, it could be either Numpy array(s) " +"or TensorFlow tensor(s). It should be consistent with `x` (you cannot " +"have Numpy inputs and tensor targets, or inversely). If `x` is a dataset," +" generator or `keras.utils.Sequence` instance, `y` should not be " +"specified (since targets will be obtained from the iterator/dataset)." +msgstr "" + +#: keras.engine.training.Model.evaluate:26 of +msgid "" +"Integer or `None`. Number of samples per batch of computation. If " +"unspecified, `batch_size` will default to 32. Do not specify the " +"`batch_size` if your data is in the form of a dataset, generators, or " +"`keras.utils.Sequence` instances (since they generate batches)." +msgstr "" + +#: keras.engine.training.Model.evaluate:31 of +msgid "0 or 1. Verbosity mode. 0 = silent, 1 = progress bar." +msgstr "" + +#: keras.engine.training.Model.evaluate:32 of +msgid "" +"Optional Numpy array of weights for the test samples, used for weighting " +"the loss function. You can either pass a flat (1D) Numpy array with the " +"same length as the input samples (1:1 mapping between weights and " +"samples), or in the case of temporal data, you can pass a 2D array " +"with shape `(samples, sequence_length)`, to apply a different weight " +"to every timestep of every sample. This argument is not supported " +"when `x` is a dataset, instead pass sample weights as the third " +"element of `x`." +msgstr "" + +#: keras.engine.training.Model.evaluate:32 of +msgid "" +"Optional Numpy array of weights for the test samples, used for weighting " +"the loss function. You can either pass a flat (1D) Numpy array with the " +"same length as the input samples" +msgstr "" + +#: keras.engine.training.Model.evaluate:38 of +msgid "(1:1 mapping between weights and samples), or in the case of" +msgstr "" + +#: keras.engine.training.Model.evaluate:36 of +msgid "" +"temporal data, you can pass a 2D array with shape `(samples, " +"sequence_length)`, to apply a different weight to every timestep of every" +" sample. This argument is not supported when `x` is a dataset, instead " +"pass sample weights as the third element of `x`." +msgstr "" + +#: keras.engine.training.Model.evaluate:40 of +msgid "" +"Integer or `None`. Total number of steps (batches of samples) before " +"declaring the evaluation round finished. Ignored with the default value " +"of `None`. If x is a `tf.data` dataset and `steps` is None, 'evaluate' " +"will run until the dataset is exhausted. This argument is not supported " +"with array inputs." +msgstr "" + +#: keras.engine.training.Model.evaluate:45 of +msgid "" +"List of `keras.callbacks.Callback` instances. List of callbacks to apply " +"during evaluation. See [callbacks](/api_docs/python/tf/keras/callbacks)." +msgstr "" + +#: keras.engine.training.Model.evaluate:48 keras.engine.training.Model.fit:160 +#: keras.engine.training.Model.predict:36 of +msgid "" +"Integer. Used for generator or `keras.utils.Sequence` input only. Maximum" +" size for the generator queue. If unspecified, `max_queue_size` will " +"default to 10." +msgstr "" + +#: keras.engine.training.Model.evaluate:51 keras.engine.training.Model.fit:163 +#: keras.engine.training.Model.predict:39 of +msgid "" +"Integer. Used for generator or `keras.utils.Sequence` input only. Maximum" +" number of processes to spin up when using process-based threading. If " +"unspecified, `workers` will default to 1." +msgstr "" + +#: keras.engine.training.Model.evaluate:54 keras.engine.training.Model.fit:167 +#: keras.engine.training.Model.predict:43 of +msgid "" +"Boolean. Used for generator or `keras.utils.Sequence` input only. If " +"`True`, use process-based threading. If unspecified, " +"`use_multiprocessing` will default to `False`. Note that because this " +"implementation relies on multiprocessing, you should not pass non-" +"picklable arguments to the generator as they can't be passed easily to " +"children processes." +msgstr "" + +#: keras.engine.training.Model.evaluate:60 +#: keras.engine.training.Model.test_on_batch:21 +#: keras.engine.training.Model.train_on_batch:25 of +msgid "" +"If `True`, loss and metric results are returned as a dict, with each key " +"being the name of the metric. If `False`, they are returned as a list." +msgstr "" + +#: keras.engine.training.Model.evaluate:63 of +msgid "Unused at this time." +msgstr "" + +#: keras.engine.training.Model.evaluate:65 of +msgid "" +"See the discussion of `Unpacking behavior for iterator-like inputs` for " +"`Model.fit`." +msgstr "" + +#: keras.engine.training.Model.evaluate:68 of +msgid "" +"`Model.evaluate` is not yet supported with " +"`tf.distribute.experimental.ParameterServerStrategy`." +msgstr "" + +#: keras.engine.training.Model.evaluate:71 +#: keras.engine.training.Model.test_on_batch:25 of +msgid "" +"Scalar test loss (if the model has a single output and no metrics) or " +"list of scalars (if the model has multiple outputs and/or metrics). The " +"attribute `model.metrics_names` will give you the display labels for the " +"scalar outputs." +msgstr "" + +#: keras.engine.training.Model.evaluate:76 of +msgid "If `model.evaluate` is wrapped in a `tf.function`." +msgstr "" + +#: keras.engine.training.Model.evaluate_generator:1 of +msgid "Evaluates the model on a data generator." +msgstr "" + +#: keras.engine.training.Model.evaluate_generator:4 +#: keras.engine.training.Model.fit_generator:4 +#: keras.engine.training.Model.predict_generator:4 of +msgid "DEPRECATED:" +msgstr "" + +#: keras.engine.training.Model.evaluate_generator:4 of +msgid "" +"`Model.evaluate` now supports generators, so there is no longer any need " +"to use this endpoint." +msgstr "" + +#: keras.engine.base_layer.Layer.finalize_state:1 of +msgid "Finalizes the layers state after updating layer weights." +msgstr "" + +#: keras.engine.base_layer.Layer.finalize_state:3 of +msgid "" +"This function can be subclassed in a layer and will be called after " +"updating a layer weights. It can be overridden to finalize any additional" +" layer state after a weight update." +msgstr "" + +#: keras.engine.training.Model.fit:1 of +msgid "Trains the model for a fixed number of epochs (iterations on a dataset)." +msgstr "" + +#: keras.engine.training.Model.fit:3 of +msgid "" +"Input data. It could be: - A Numpy array (or array-like), or a list of " +"arrays (in case the model has multiple inputs). - A TensorFlow tensor, " +"or a list of tensors (in case the model has multiple inputs). - A dict " +"mapping input names to the corresponding array/tensors, if the model " +"has named inputs. - A `tf.data` dataset. Should return a tuple of " +"either `(inputs, targets)` or `(inputs, targets, sample_weights)`. - A " +"generator or `keras.utils.Sequence` returning `(inputs, targets)` or " +"`(inputs, targets, sample_weights)`. - A " +"`tf.keras.utils.experimental.DatasetCreator`, which wraps a callable " +"that takes a single argument of type `tf.distribute.InputContext`, and " +"returns a `tf.data.Dataset`. `DatasetCreator` should be used when users" +" prefer to specify the per-replica batching and sharding logic for the " +"`Dataset`. See `tf.keras.utils.experimental.DatasetCreator` doc for " +"more information. A more detailed description of unpacking behavior for" +" iterator types (Dataset, generator, Sequence) is given below. If using " +"`tf.distribute.experimental.ParameterServerStrategy`, only " +"`DatasetCreator` type is supported for `x`." +msgstr "" + +#: keras.engine.training.Model.fit:15 of +msgid "" +"A `tf.keras.utils.experimental.DatasetCreator`, which wraps a callable " +"that takes a single argument of type `tf.distribute.InputContext`, and " +"returns a `tf.data.Dataset`. `DatasetCreator` should be used when users " +"prefer to specify the per-replica batching and sharding logic for the " +"`Dataset`. See `tf.keras.utils.experimental.DatasetCreator` doc for more " +"information." +msgstr "" + +#: keras.engine.training.Model.fit:22 of +msgid "" +"A more detailed description of unpacking behavior for iterator types " +"(Dataset, generator, Sequence) is given below. If using " +"`tf.distribute.experimental.ParameterServerStrategy`, only " +"`DatasetCreator` type is supported for `x`." +msgstr "" + +#: keras.engine.training.Model.fit:26 of +msgid "" +"Target data. Like the input data `x`, it could be either Numpy array(s) " +"or TensorFlow tensor(s). It should be consistent with `x` (you cannot " +"have Numpy inputs and tensor targets, or inversely). If `x` is a dataset," +" generator, or `keras.utils.Sequence` instance, `y` should not be " +"specified (since targets will be obtained from `x`)." +msgstr "" + +#: keras.engine.training.Model.fit:32 of +msgid "" +"Integer or `None`. Number of samples per gradient update. If unspecified," +" `batch_size` will default to 32. Do not specify the `batch_size` if your" +" data is in the form of datasets, generators, or `keras.utils.Sequence` " +"instances (since they generate batches)." +msgstr "" + +#: keras.engine.training.Model.fit:38 of +msgid "" +"Integer. Number of epochs to train the model. An epoch is an iteration " +"over the entire `x` and `y` data provided (unless the `steps_per_epoch` " +"flag is set to something other than None). Note that in conjunction with " +"`initial_epoch`, `epochs` is to be understood as \"final epoch\". The " +"model is not trained for a number of iterations given by `epochs`, but " +"merely until the epoch of index `epochs` is reached." +msgstr "" + +#: keras.engine.training.Model.fit:48 of +msgid "" +"'auto', 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = one" +" line per epoch. 'auto' defaults to 1 for most cases, but 2 when used " +"with `ParameterServerStrategy`. Note that the progress bar is not " +"particularly useful when logged to a file, so verbose=2 is recommended " +"when not running interactively (eg, in a production environment)." +msgstr "" + +#: keras.engine.training.Model.fit:55 of +msgid "" +"List of `keras.callbacks.Callback` instances. List of callbacks to apply " +"during training. See `tf.keras.callbacks`. Note " +"`tf.keras.callbacks.ProgbarLogger` and `tf.keras.callbacks.History` " +"callbacks are created automatically and need not be passed into " +"`model.fit`. `tf.keras.callbacks.ProgbarLogger` is created or not based " +"on `verbose` argument to `model.fit`. Callbacks with batch-level calls " +"are currently unsupported with " +"`tf.distribute.experimental.ParameterServerStrategy`, and users are " +"advised to implement epoch-level calls instead with an appropriate " +"`steps_per_epoch` value." +msgstr "" + +#: keras.engine.training.Model.fit:66 of +msgid "" +"Float between 0 and 1. Fraction of the training data to be used as " +"validation data. The model will set apart this fraction of the training " +"data, will not train on it, and will evaluate the loss and any model " +"metrics on this data at the end of each epoch. The validation data is " +"selected from the last samples in the `x` and `y` data provided, before " +"shuffling. This argument is not supported when `x` is a dataset, " +"generator or `keras.utils.Sequence` instance. `validation_split` is not " +"yet supported with `tf.distribute.experimental.ParameterServerStrategy`." +msgstr "" + +#: keras.engine.training.Model.fit:74 of +msgid "Float between 0 and 1." +msgstr "" + +#: keras.engine.training.Model.fit:68 of +msgid "" +"Fraction of the training data to be used as validation data. The model " +"will set apart this fraction of the training data, will not train on it, " +"and will evaluate the loss and any model metrics on this data at the end " +"of each epoch. The validation data is selected from the last samples in " +"the `x` and `y` data provided, before shuffling. This argument is not " +"supported when `x` is a dataset, generator or" +msgstr "" + +#: keras.engine.training.Model.fit:77 of +msgid "`keras.utils.Sequence` instance." +msgstr "" + +#: keras.engine.training.Model.fit:77 of +msgid "" +"`validation_split` is not yet supported with " +"`tf.distribute.experimental.ParameterServerStrategy`." +msgstr "" + +#: keras.engine.training.Model.fit:79 of +msgid "" +"Data on which to evaluate the loss and any model metrics at the end of " +"each epoch. The model will not be trained on this data. Thus, note the " +"fact that the validation loss of data provided using `validation_split` " +"or `validation_data` is not affected by regularization layers like noise " +"and dropout. `validation_data` will override `validation_split`. " +"`validation_data` could be: - A tuple `(x_val, y_val)` of Numpy arrays " +"or tensors. - A tuple `(x_val, y_val, val_sample_weights)` of NumPy " +"arrays. - A `tf.data.Dataset`. - A Python generator or " +"`keras.utils.Sequence` returning `(inputs, targets)` or `(inputs, " +"targets, sample_weights)`. `validation_data` is not yet supported with " +"`tf.distribute.experimental.ParameterServerStrategy`." +msgstr "" + +#: keras.engine.training.Model.fit:79 of +msgid "" +"Data on which to evaluate the loss and any model metrics at the end of " +"each epoch. The model will not be trained on this data. Thus, note the " +"fact that the validation loss of data provided using `validation_split` " +"or `validation_data` is not affected by regularization layers like noise " +"and dropout. `validation_data` will override `validation_split`. " +"`validation_data` could be:" +msgstr "" + +#: keras.engine.training.Model.fit:87 of +msgid "A tuple `(x_val, y_val)` of Numpy arrays or tensors." +msgstr "" + +#: keras.engine.training.Model.fit:88 of +msgid "A tuple `(x_val, y_val, val_sample_weights)` of NumPy arrays." +msgstr "" + +#: keras.engine.training.Model.fit:89 of +msgid "A `tf.data.Dataset`." +msgstr "" + +#: keras.engine.training.Model.fit:90 of +msgid "A Python generator or `keras.utils.Sequence` returning" +msgstr "" + +#: keras.engine.training.Model.fit:91 of +msgid "`(inputs, targets)` or `(inputs, targets, sample_weights)`." +msgstr "" + +#: keras.engine.training.Model.fit:92 of +msgid "" +"`validation_data` is not yet supported with " +"`tf.distribute.experimental.ParameterServerStrategy`." +msgstr "" + +#: keras.engine.training.Model.fit:94 of +msgid "" +"Boolean (whether to shuffle the training data before each epoch) or str " +"(for 'batch'). This argument is ignored when `x` is a generator or an " +"object of tf.data.Dataset. 'batch' is a special option for dealing with " +"the limitations of HDF5 data; it shuffles in batch-sized chunks. Has no " +"effect when `steps_per_epoch` is not `None`." +msgstr "" + +#: keras.engine.training.Model.fit:100 of +msgid "" +"Optional dictionary mapping class indices (integers) to a weight (float) " +"value, used for weighting the loss function (during training only). This " +"can be useful to tell the model to \"pay more attention\" to samples from" +" an under-represented class." +msgstr "" + +#: keras.engine.training.Model.fit:106 of +msgid "" +"Optional Numpy array of weights for the training samples, used for " +"weighting the loss function (during training only). You can either pass " +"a flat (1D) Numpy array with the same length as the input samples (1:1 " +"mapping between weights and samples), or in the case of temporal data, " +"you can pass a 2D array with shape `(samples, sequence_length)`, to " +"apply a different weight to every timestep of every sample. This " +"argument is not supported when `x` is a dataset, generator, or " +"`keras.utils.Sequence` instance, instead provide the sample_weights as " +"the third element of `x`." +msgstr "" + +#: keras.engine.training.Model.fit:115 of +msgid "Optional Numpy array of weights for" +msgstr "" + +#: keras.engine.training.Model.fit:108 of +msgid "" +"the training samples, used for weighting the loss function (during " +"training only). You can either pass a flat (1D) Numpy array with the same" +" length as the input samples (1:1 mapping between weights and samples), " +"or in the case of temporal data, you can pass a 2D array with shape " +"`(samples, sequence_length)`, to apply a different weight to every " +"timestep of every sample. This argument is not supported when `x` is a " +"dataset, generator, or" +msgstr "" + +#: keras.engine.training.Model.fit:117 of +msgid "`keras.utils.Sequence` instance, instead provide the sample_weights" +msgstr "" + +#: keras.engine.training.Model.fit:118 of +msgid "as the third element of `x`." +msgstr "" + +#: keras.engine.training.Model.fit:119 of +msgid "" +"Integer. Epoch at which to start training (useful for resuming a previous" +" training run)." +msgstr "" + +#: keras.engine.training.Model.fit:122 of +msgid "" +"Integer or `None`. Total number of steps (batches of samples) before " +"declaring one epoch finished and starting the next epoch. When training " +"with input tensors such as TensorFlow data tensors, the default `None` is" +" equal to the number of samples in your dataset divided by the batch " +"size, or 1 if that cannot be determined. If x is a `tf.data` dataset, and" +" 'steps_per_epoch' is None, the epoch will run until the input dataset is" +" exhausted. When passing an infinitely repeating dataset, you must " +"specify the `steps_per_epoch` argument. If `steps_per_epoch=-1` the " +"training will run indefinitely with an infinitely repeating dataset. This" +" argument is not supported with array inputs. When using " +"`tf.distribute.experimental.ParameterServerStrategy`: * " +"`steps_per_epoch=None` is not supported." +msgstr "" + +#: keras.engine.training.Model.fit:122 of +msgid "" +"Integer or `None`. Total number of steps (batches of samples) before " +"declaring one epoch finished and starting the next epoch. When training " +"with input tensors such as TensorFlow data tensors, the default `None` is" +" equal to the number of samples in your dataset divided by the batch " +"size, or 1 if that cannot be determined. If x is a `tf.data` dataset, and" +" 'steps_per_epoch' is None, the epoch will run until the input dataset is" +" exhausted. When passing an infinitely repeating dataset, you must " +"specify the `steps_per_epoch` argument. If `steps_per_epoch=-1` the " +"training will run indefinitely with an infinitely repeating dataset. This" +" argument is not supported with array inputs. When using " +"`tf.distribute.experimental.ParameterServerStrategy`:" +msgstr "" + +#: keras.engine.training.Model.fit:136 of +msgid "`steps_per_epoch=None` is not supported." +msgstr "" + +#: keras.engine.training.Model.fit:137 of +msgid "" +"Only relevant if `validation_data` is provided and is a `tf.data` " +"dataset. Total number of steps (batches of samples) to draw before " +"stopping when performing validation at the end of every epoch. If " +"'validation_steps' is None, validation will run until the " +"`validation_data` dataset is exhausted. In the case of an infinitely " +"repeated dataset, it will run into an infinite loop. If " +"'validation_steps' is specified and only part of the dataset will be " +"consumed, the evaluation will start from the beginning of the dataset at " +"each epoch. This ensures that the same validation samples are used every " +"time." +msgstr "" + +#: keras.engine.training.Model.fit:147 of +msgid "" +"Integer or `None`. Number of samples per validation batch. If " +"unspecified, will default to `batch_size`. Do not specify the " +"`validation_batch_size` if your data is in the form of datasets, " +"generators, or `keras.utils.Sequence` instances (since they generate " +"batches)." +msgstr "" + +#: keras.engine.training.Model.fit:153 of +msgid "" +"Only relevant if validation data is provided. Integer or " +"`collections.abc.Container` instance (e.g. list, tuple, etc.). If an " +"integer, specifies how many training epochs to run before a new " +"validation run is performed, e.g. `validation_freq=2` runs validation " +"every 2 epochs. If a Container, specifies the epochs on which to run " +"validation, e.g. `validation_freq=[1, 2, 10]` runs validation at the end " +"of the 1st, 2nd, and 10th epochs." +msgstr "" + +#: keras.engine.training.Model.fit:196 of +msgid "Unpacking behavior for iterator-like inputs:" +msgstr "" + +#: keras.engine.training.Model.fit:175 of +msgid "A common pattern is to pass a tf.data.Dataset, generator, or" +msgstr "" + +#: keras.engine.training.Model.fit:176 of +msgid "" +"tf.keras.utils.Sequence to the `x` argument of fit, which will in fact " +"yield not only features (x) but optionally targets (y) and sample " +"weights. Keras requires that the output of such iterator-likes be " +"unambiguous. The iterator should return a tuple of length 1, 2, or 3, " +"where the optional second and third elements will be used for y and " +"sample_weight respectively. Any other type provided will be wrapped in a " +"length one tuple, effectively treating everything as 'x'. When yielding " +"dicts, they should still adhere to the top-level tuple structure. e.g. " +"`({\"x0\": x0, \"x1\": x1}, y)`. Keras will not attempt to separate " +"features, targets, and weights from the keys of a single dict." +msgstr "" + +#: keras.engine.training.Model.fit:186 of +msgid "A notable unsupported data type is the namedtuple. The reason is that" +msgstr "" + +#: keras.engine.training.Model.fit:187 of +msgid "" +"it behaves like both an ordered datatype (tuple) and a mapping datatype " +"(dict). So given a namedtuple of the form:" +msgstr "" + +#: keras.engine.training.Model.fit:189 of +msgid "`namedtuple(\"example_tuple\", [\"y\", \"x\"])`" +msgstr "" + +#: keras.engine.training.Model.fit:190 of +msgid "" +"it is ambiguous whether to reverse the order of the elements when " +"interpreting the value. Even worse is a tuple of the form:" +msgstr "" + +#: keras.engine.training.Model.fit:192 of +msgid "`namedtuple(\"other_tuple\", [\"x\", \"y\", \"z\"])`" +msgstr "" + +#: keras.engine.training.Model.fit:193 of +msgid "" +"where it is unclear if the tuple was intended to be unpacked into x, y, " +"and sample_weight or passed through as a single element to `x`. As a " +"result the data processing code will simply raise a ValueError if it " +"encounters a namedtuple. (Along with instructions to remedy the issue.)" +msgstr "" + +#: keras.engine.training.Model.fit:198 of +msgid "" +"A `History` object. Its `History.history` attribute is a record of " +"training loss values and metrics values at successive epochs, as well as " +"validation loss values and validation metrics values (if applicable)." +msgstr "" + +#: keras.engine.training.Model.fit:203 of +msgid "1. If the model was never compiled or," +msgstr "" + +#: keras.engine.training.Model.fit:203 of +msgid "If the model was never compiled or," +msgstr "" + +#: keras.engine.training.Model.fit:205 of +msgid "" +"In case of mismatch between the provided input data and what the " +"model expects or when the input data is empty." +msgstr "" + +#: keras.engine.training.Model.fit_generator:1 of +msgid "Fits the model on data yielded batch-by-batch by a Python generator." +msgstr "" + +#: keras.engine.training.Model.fit_generator:4 of +msgid "" +"`Model.fit` now supports generators, so there is no longer any need to " +"use this endpoint." +msgstr "" + +#: keras.engine.base_layer.Layer.from_config:1 +#: keras.engine.training.Model.from_config:1 of +msgid "Creates a layer from its config." +msgstr "" + +#: keras.engine.base_layer.Layer.from_config:3 +#: keras.engine.training.Model.from_config:3 of +msgid "" +"This method is the reverse of `get_config`, capable of instantiating the " +"same layer from the config dictionary. It does not handle layer " +"connectivity (handled by Network), nor weights (handled by " +"`set_weights`)." +msgstr "" + +#: keras.engine.base_layer.Layer.from_config:8 +#: keras.engine.training.Model.from_config:8 of +msgid "A Python dictionary, typically the output of get_config." +msgstr "" + +#: keras.engine.base_layer.Layer.from_config:11 +#: keras.engine.training.Model.from_config:11 +#: keras.engine.training.Model.get_layer:9 of +msgid "A layer instance." +msgstr "" + +#: keras.engine.base_layer.Layer.get_config:1 +#: keras.engine.training.Model.get_config:1 of +msgid "Returns the config of the layer." +msgstr "" + +#: keras.engine.base_layer.Layer.get_config:3 +#: keras.engine.training.Model.get_config:3 of +msgid "" +"A layer config is a Python dictionary (serializable) containing the " +"configuration of a layer. The same layer can be reinstantiated later " +"(without its trained weights) from this configuration." +msgstr "" + +#: keras.engine.base_layer.Layer.get_config:8 +#: keras.engine.training.Model.get_config:8 of +msgid "" +"The config of a layer does not include connectivity information, nor the " +"layer class name. These are handled by `Network` (one layer of " +"abstraction above)." +msgstr "" + +#: keras.engine.base_layer.Layer.get_config:12 +#: keras.engine.training.Model.get_config:12 of +msgid "" +"Note that `get_config()` does not guarantee to return a fresh copy of " +"dict every time it is called. The callers should make a copy of the " +"returned dict if they want to modify it." +msgstr "" + +#: keras.engine.base_layer.Layer.get_config:16 +#: keras.engine.training.Model.get_config:16 of +msgid "Python dictionary." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_at:1 of +msgid "Retrieves the input tensor(s) of a layer at a given node." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_at:3 of +msgid "" +"Integer, index of the node from which to retrieve the attribute. E.g. " +"`node_index=0` will correspond to the first input node of the layer." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_at:8 of +msgid "A tensor (or list of tensors if the layer has multiple inputs)." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_at:10 +#: keras.engine.base_layer.Layer.get_input_shape_at:11 +#: keras.engine.base_layer.Layer.get_output_at:10 +#: keras.engine.base_layer.Layer.get_output_shape_at:11 of +#: tensorcircuit.applications.van.MADE.input:8 +#: tensorcircuit.applications.van.MaskedConv2D.input:8 +#: tensorcircuit.applications.van.MaskedLinear.input:8 +#: tensorcircuit.applications.van.NMF.input:8 +#: tensorcircuit.applications.van.PixelCNN.input:8 +#: tensorcircuit.applications.van.ResidualBlock.input:8 +#: tensorcircuit.applications.vqes.Linear.input:8 +#: tensorcircuit.keras.QuantumLayer.input:8 +msgid "If called in Eager mode." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_mask_at:1 of +msgid "Retrieves the input mask tensor(s) of a layer at a given node." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_mask_at:3 +#: keras.engine.base_layer.Layer.get_input_shape_at:3 +#: keras.engine.base_layer.Layer.get_output_mask_at:3 +#: keras.engine.base_layer.Layer.get_output_shape_at:3 of +msgid "" +"Integer, index of the node from which to retrieve the attribute. E.g. " +"`node_index=0` will correspond to the first time the layer was called." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_mask_at:8 of +msgid "A mask tensor (or list of tensors if the layer has multiple inputs)." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_shape_at:1 of +msgid "Retrieves the input shape(s) of a layer at a given node." +msgstr "" + +#: keras.engine.base_layer.Layer.get_input_shape_at:8 of +msgid "A shape tuple (or list of shape tuples if the layer has multiple inputs)." +msgstr "" + +#: keras.engine.training.Model.get_layer:1 of +msgid "Retrieves a layer based on either its name (unique) or index." +msgstr "" + +#: keras.engine.training.Model.get_layer:3 of +msgid "" +"If `name` and `index` are both provided, `index` will take precedence. " +"Indices are based on order of horizontal graph traversal (bottom-up)." +msgstr "" + +#: keras.engine.training.Model.get_layer:6 of +msgid "String, name of layer." +msgstr "" + +#: keras.engine.training.Model.get_layer:7 of +msgid "Integer, index of layer." +msgstr "" + +#: keras.engine.base_layer.Layer.get_losses_for:3 of +msgid "Retrieves losses relevant to a specific set of inputs." +msgstr "" + +#: keras.engine.base_layer.Layer.get_losses_for:5 +#: keras.engine.base_layer.Layer.get_updates_for:5 of +msgid "Input tensor or list/tuple of input tensors." +msgstr "" + +#: keras.engine.base_layer.Layer.get_losses_for:7 of +msgid "List of loss tensors of the layer that depend on `inputs`." +msgstr "" + +#: keras.engine.base_layer.Layer.get_output_at:1 of +msgid "Retrieves the output tensor(s) of a layer at a given node." +msgstr "" + +#: keras.engine.base_layer.Layer.get_output_at:3 of +msgid "" +"Integer, index of the node from which to retrieve the attribute. E.g. " +"`node_index=0` will correspond to the first output node of the layer." +msgstr "" + +#: keras.engine.base_layer.Layer.get_output_at:8 of +msgid "A tensor (or list of tensors if the layer has multiple outputs)." +msgstr "" + +#: keras.engine.base_layer.Layer.get_output_mask_at:1 of +msgid "Retrieves the output mask tensor(s) of a layer at a given node." +msgstr "" + +#: keras.engine.base_layer.Layer.get_output_mask_at:8 of +msgid "A mask tensor (or list of tensors if the layer has multiple outputs)." +msgstr "" + +#: keras.engine.base_layer.Layer.get_output_shape_at:1 of +msgid "Retrieves the output shape(s) of a layer at a given node." +msgstr "" + +#: keras.engine.base_layer.Layer.get_output_shape_at:8 of +msgid "A shape tuple (or list of shape tuples if the layer has multiple outputs)." +msgstr "" + +#: keras.engine.base_layer.Layer.get_updates_for:3 of +msgid "Retrieves updates relevant to a specific set of inputs." +msgstr "" + +#: keras.engine.base_layer.Layer.get_updates_for:7 of +msgid "List of update ops of the layer that depend on `inputs`." +msgstr "" + +#: keras.engine.training.Model.get_weights:1 of +msgid "Retrieves the weights of the model." +msgstr "" + +#: keras.engine.training.Model.get_weights:3 of +msgid "A flat list of Numpy arrays." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.inbound_nodes:1 +#: tensorcircuit.applications.van.MADE.outbound_nodes:1 +#: tensorcircuit.applications.van.MaskedConv2D.inbound_nodes:1 +#: tensorcircuit.applications.van.MaskedConv2D.outbound_nodes:1 +#: tensorcircuit.applications.van.MaskedLinear.inbound_nodes:1 +#: tensorcircuit.applications.van.MaskedLinear.outbound_nodes:1 +#: tensorcircuit.applications.van.NMF.inbound_nodes:1 +#: tensorcircuit.applications.van.NMF.outbound_nodes:1 +#: tensorcircuit.applications.van.PixelCNN.inbound_nodes:1 +#: tensorcircuit.applications.van.PixelCNN.outbound_nodes:1 +#: tensorcircuit.applications.van.ResidualBlock.inbound_nodes:1 +#: tensorcircuit.applications.van.ResidualBlock.outbound_nodes:1 +#: tensorcircuit.applications.vqes.Linear.inbound_nodes:1 +#: tensorcircuit.applications.vqes.Linear.outbound_nodes:1 +#: tensorcircuit.keras.QuantumLayer.inbound_nodes:1 +#: tensorcircuit.keras.QuantumLayer.outbound_nodes:1 +msgid "Deprecated, do NOT use! Only for compatibility with external Keras." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input:1 +#: tensorcircuit.applications.van.MaskedConv2D.input:1 +#: tensorcircuit.applications.van.MaskedLinear.input:1 +#: tensorcircuit.applications.van.NMF.input:1 +#: tensorcircuit.applications.van.PixelCNN.input:1 +#: tensorcircuit.applications.van.ResidualBlock.input:1 +#: tensorcircuit.applications.vqes.Linear.input:1 +#: tensorcircuit.keras.QuantumLayer.input:1 +msgid "Retrieves the input tensor(s) of a layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input:3 +#: tensorcircuit.applications.van.MaskedConv2D.input:3 +#: tensorcircuit.applications.van.MaskedLinear.input:3 +#: tensorcircuit.applications.van.NMF.input:3 +#: tensorcircuit.applications.van.PixelCNN.input:3 +#: tensorcircuit.applications.van.ResidualBlock.input:3 +#: tensorcircuit.applications.vqes.Linear.input:3 +#: tensorcircuit.keras.QuantumLayer.input:3 +msgid "" +"Only applicable if the layer has exactly one input, i.e. if it is " +"connected to one incoming layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input:6 +#: tensorcircuit.applications.van.MaskedConv2D.input:6 +#: tensorcircuit.applications.van.MaskedLinear.input:6 +#: tensorcircuit.applications.van.NMF.input:6 +#: tensorcircuit.applications.van.PixelCNN.input:6 +#: tensorcircuit.applications.van.ResidualBlock.input:6 +#: tensorcircuit.applications.vqes.Linear.input:6 +#: tensorcircuit.keras.QuantumLayer.input:6 +msgid "Input tensor or list of input tensors." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input:9 +#: tensorcircuit.applications.van.MaskedConv2D.input:9 +#: tensorcircuit.applications.van.MaskedLinear.input:9 +#: tensorcircuit.applications.van.NMF.input:9 +#: tensorcircuit.applications.van.PixelCNN.input:9 +#: tensorcircuit.applications.van.ResidualBlock.input:9 +#: tensorcircuit.applications.vqes.Linear.input:9 +#: tensorcircuit.keras.QuantumLayer.input:9 +msgid "If no inbound nodes are found." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_mask:1 +#: tensorcircuit.applications.van.MaskedConv2D.input_mask:1 +#: tensorcircuit.applications.van.MaskedLinear.input_mask:1 +#: tensorcircuit.applications.van.NMF.input_mask:1 +#: tensorcircuit.applications.van.PixelCNN.input_mask:1 +#: tensorcircuit.applications.van.ResidualBlock.input_mask:1 +#: tensorcircuit.applications.vqes.Linear.input_mask:1 +#: tensorcircuit.keras.QuantumLayer.input_mask:1 +msgid "Retrieves the input mask tensor(s) of a layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_mask:3 +#: tensorcircuit.applications.van.MADE.output_mask:3 +#: tensorcircuit.applications.van.MaskedConv2D.input_mask:3 +#: tensorcircuit.applications.van.MaskedConv2D.output_mask:3 +#: tensorcircuit.applications.van.MaskedLinear.input_mask:3 +#: tensorcircuit.applications.van.MaskedLinear.output_mask:3 +#: tensorcircuit.applications.van.NMF.input_mask:3 +#: tensorcircuit.applications.van.NMF.output_mask:3 +#: tensorcircuit.applications.van.PixelCNN.input_mask:3 +#: tensorcircuit.applications.van.PixelCNN.output_mask:3 +#: tensorcircuit.applications.van.ResidualBlock.input_mask:3 +#: tensorcircuit.applications.van.ResidualBlock.output_mask:3 +#: tensorcircuit.applications.vqes.Linear.input_mask:3 +#: tensorcircuit.applications.vqes.Linear.output_mask:3 +#: tensorcircuit.keras.QuantumLayer.input_mask:3 +#: tensorcircuit.keras.QuantumLayer.output_mask:3 +msgid "" +"Only applicable if the layer has exactly one inbound node, i.e. if it is " +"connected to one incoming layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_mask:6 +#: tensorcircuit.applications.van.MaskedConv2D.input_mask:6 +#: tensorcircuit.applications.van.MaskedLinear.input_mask:6 +#: tensorcircuit.applications.van.NMF.input_mask:6 +#: tensorcircuit.applications.van.PixelCNN.input_mask:6 +#: tensorcircuit.applications.van.ResidualBlock.input_mask:6 +#: tensorcircuit.applications.vqes.Linear.input_mask:6 +#: tensorcircuit.keras.QuantumLayer.input_mask:6 +msgid "Input mask tensor (potentially None) or list of input mask tensors." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_mask:9 +#: tensorcircuit.applications.van.MADE.output_mask:9 +#: tensorcircuit.applications.van.MaskedConv2D.input_mask:9 +#: tensorcircuit.applications.van.MaskedConv2D.output_mask:9 +#: tensorcircuit.applications.van.MaskedLinear.input_mask:9 +#: tensorcircuit.applications.van.MaskedLinear.output_mask:9 +#: tensorcircuit.applications.van.NMF.input_mask:9 +#: tensorcircuit.applications.van.NMF.output_mask:9 +#: tensorcircuit.applications.van.PixelCNN.input_mask:9 +#: tensorcircuit.applications.van.PixelCNN.output_mask:9 +#: tensorcircuit.applications.van.ResidualBlock.input_mask:9 +#: tensorcircuit.applications.van.ResidualBlock.output_mask:9 +#: tensorcircuit.applications.vqes.Linear.input_mask:9 +#: tensorcircuit.applications.vqes.Linear.output_mask:9 +#: tensorcircuit.keras.QuantumLayer.input_mask:9 +#: tensorcircuit.keras.QuantumLayer.output_mask:9 +msgid "if the layer is connected to" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_shape:1 +#: tensorcircuit.applications.van.MaskedConv2D.input_shape:1 +#: tensorcircuit.applications.van.MaskedLinear.input_shape:1 +#: tensorcircuit.applications.van.NMF.input_shape:1 +#: tensorcircuit.applications.van.PixelCNN.input_shape:1 +#: tensorcircuit.applications.van.ResidualBlock.input_shape:1 +#: tensorcircuit.applications.vqes.Linear.input_shape:1 +#: tensorcircuit.keras.QuantumLayer.input_shape:1 +msgid "Retrieves the input shape(s) of a layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_shape:3 +#: tensorcircuit.applications.van.MaskedConv2D.input_shape:3 +#: tensorcircuit.applications.van.MaskedLinear.input_shape:3 +#: tensorcircuit.applications.van.NMF.input_shape:3 +#: tensorcircuit.applications.van.PixelCNN.input_shape:3 +#: tensorcircuit.applications.van.ResidualBlock.input_shape:3 +#: tensorcircuit.applications.vqes.Linear.input_shape:3 +#: tensorcircuit.keras.QuantumLayer.input_shape:3 +msgid "" +"Only applicable if the layer has exactly one input, i.e. if it is " +"connected to one incoming layer, or if all inputs have the same shape." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_shape:7 +#: tensorcircuit.applications.van.MaskedConv2D.input_shape:7 +#: tensorcircuit.applications.van.MaskedLinear.input_shape:7 +#: tensorcircuit.applications.van.NMF.input_shape:7 +#: tensorcircuit.applications.van.PixelCNN.input_shape:7 +#: tensorcircuit.applications.van.ResidualBlock.input_shape:7 +#: tensorcircuit.applications.vqes.Linear.input_shape:7 +#: tensorcircuit.keras.QuantumLayer.input_shape:7 +msgid "" +"Input shape, as an integer shape tuple (or list of shape tuples, one " +"tuple per input tensor)." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_shape:10 +#: tensorcircuit.applications.van.MaskedConv2D.input_shape:10 +#: tensorcircuit.applications.van.MaskedLinear.input_shape:10 +#: tensorcircuit.applications.van.NMF.input_shape:10 +#: tensorcircuit.applications.van.PixelCNN.input_shape:10 +#: tensorcircuit.applications.van.ResidualBlock.input_shape:10 +#: tensorcircuit.applications.vqes.Linear.input_shape:10 +#: tensorcircuit.keras.QuantumLayer.input_shape:10 +msgid "if the layer has no defined input_shape." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_shape:11 +#: tensorcircuit.applications.van.MADE.output:9 +#: tensorcircuit.applications.van.MADE.output_shape:10 +#: tensorcircuit.applications.van.MaskedConv2D.input_shape:11 +#: tensorcircuit.applications.van.MaskedConv2D.output:9 +#: tensorcircuit.applications.van.MaskedConv2D.output_shape:10 +#: tensorcircuit.applications.van.MaskedLinear.input_shape:11 +#: tensorcircuit.applications.van.MaskedLinear.output:9 +#: tensorcircuit.applications.van.MaskedLinear.output_shape:10 +#: tensorcircuit.applications.van.NMF.input_shape:11 +#: tensorcircuit.applications.van.NMF.output:9 +#: tensorcircuit.applications.van.NMF.output_shape:10 +#: tensorcircuit.applications.van.PixelCNN.input_shape:11 +#: tensorcircuit.applications.van.PixelCNN.output:9 +#: tensorcircuit.applications.van.PixelCNN.output_shape:10 +#: tensorcircuit.applications.van.ResidualBlock.input_shape:11 +#: tensorcircuit.applications.van.ResidualBlock.output:9 +#: tensorcircuit.applications.van.ResidualBlock.output_shape:10 +#: tensorcircuit.applications.vqes.Linear.input_shape:11 +#: tensorcircuit.applications.vqes.Linear.output:9 +#: tensorcircuit.applications.vqes.Linear.output_shape:10 +#: tensorcircuit.keras.QuantumLayer.input_shape:11 +#: tensorcircuit.keras.QuantumLayer.output:9 +#: tensorcircuit.keras.QuantumLayer.output_shape:10 +msgid "if called in Eager mode." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_spec:1 +#: tensorcircuit.applications.van.MaskedConv2D.input_spec:1 +#: tensorcircuit.applications.van.MaskedLinear.input_spec:1 +#: tensorcircuit.applications.van.NMF.input_spec:1 +#: tensorcircuit.applications.van.PixelCNN.input_spec:1 +#: tensorcircuit.applications.van.ResidualBlock.input_spec:1 +#: tensorcircuit.applications.vqes.Linear.input_spec:1 +#: tensorcircuit.keras.QuantumLayer.input_spec:1 +msgid "`InputSpec` instance(s) describing the input format for this layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_spec:3 +#: tensorcircuit.applications.van.MaskedConv2D.input_spec:3 +#: tensorcircuit.applications.van.MaskedLinear.input_spec:3 +#: tensorcircuit.applications.van.NMF.input_spec:3 +#: tensorcircuit.applications.van.PixelCNN.input_spec:3 +#: tensorcircuit.applications.van.ResidualBlock.input_spec:3 +#: tensorcircuit.applications.vqes.Linear.input_spec:3 +#: tensorcircuit.keras.QuantumLayer.input_spec:3 +msgid "" +"When you create a layer subclass, you can set `self.input_spec` to enable" +" the layer to run input compatibility checks when it is called. Consider " +"a `Conv2D` layer: it can only be called on a single input tensor of rank " +"4. As such, you can set, in `__init__()`:" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_spec:8 +#: tensorcircuit.applications.van.MaskedConv2D.input_spec:8 +#: tensorcircuit.applications.van.MaskedLinear.input_spec:8 +#: tensorcircuit.applications.van.NMF.input_spec:8 +#: tensorcircuit.applications.van.PixelCNN.input_spec:8 +#: tensorcircuit.applications.van.ResidualBlock.input_spec:8 +#: tensorcircuit.applications.vqes.Linear.input_spec:8 +#: tensorcircuit.keras.QuantumLayer.input_spec:8 +msgid "```python self.input_spec = tf.keras.layers.InputSpec(ndim=4) ```" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_spec:12 +#: tensorcircuit.applications.van.MaskedConv2D.input_spec:12 +#: tensorcircuit.applications.van.MaskedLinear.input_spec:12 +#: tensorcircuit.applications.van.NMF.input_spec:12 +#: tensorcircuit.applications.van.PixelCNN.input_spec:12 +#: tensorcircuit.applications.van.ResidualBlock.input_spec:12 +#: tensorcircuit.applications.vqes.Linear.input_spec:12 +#: tensorcircuit.keras.QuantumLayer.input_spec:12 +msgid "" +"Now, if you try to call the layer on an input that isn't rank 4 (for " +"instance, an input of shape `(2,)`, it will raise a nicely-formatted " +"error:" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_spec:16 +#: tensorcircuit.applications.van.MaskedConv2D.input_spec:16 +#: tensorcircuit.applications.van.MaskedLinear.input_spec:16 +#: tensorcircuit.applications.van.NMF.input_spec:16 +#: tensorcircuit.applications.van.PixelCNN.input_spec:16 +#: tensorcircuit.applications.van.ResidualBlock.input_spec:16 +#: tensorcircuit.applications.vqes.Linear.input_spec:16 +#: tensorcircuit.keras.QuantumLayer.input_spec:16 +msgid "" +"``` ValueError: Input 0 of layer conv2d is incompatible with the layer: " +"expected ndim=4, found ndim=1. Full shape received: [2] ```" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_spec:21 +#: tensorcircuit.applications.van.MaskedConv2D.input_spec:21 +#: tensorcircuit.applications.van.MaskedLinear.input_spec:21 +#: tensorcircuit.applications.van.NMF.input_spec:21 +#: tensorcircuit.applications.van.PixelCNN.input_spec:21 +#: tensorcircuit.applications.van.ResidualBlock.input_spec:21 +#: tensorcircuit.applications.vqes.Linear.input_spec:21 +#: tensorcircuit.keras.QuantumLayer.input_spec:21 +msgid "" +"Input checks that can be specified via `input_spec` include: - Structure " +"(e.g. a single input, a list of 2 inputs, etc) - Shape - Rank (ndim) - " +"Dtype" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_spec:27 +#: tensorcircuit.applications.van.MaskedConv2D.input_spec:27 +#: tensorcircuit.applications.van.MaskedLinear.input_spec:27 +#: tensorcircuit.applications.van.NMF.input_spec:27 +#: tensorcircuit.applications.van.PixelCNN.input_spec:27 +#: tensorcircuit.applications.van.ResidualBlock.input_spec:27 +#: tensorcircuit.applications.vqes.Linear.input_spec:27 +#: tensorcircuit.keras.QuantumLayer.input_spec:27 +msgid "For more information, see `tf.keras.layers.InputSpec`." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.input_spec:29 +#: tensorcircuit.applications.van.MaskedConv2D.input_spec:29 +#: tensorcircuit.applications.van.MaskedLinear.input_spec:29 +#: tensorcircuit.applications.van.NMF.input_spec:29 +#: tensorcircuit.applications.van.PixelCNN.input_spec:29 +#: tensorcircuit.applications.van.ResidualBlock.input_spec:29 +#: tensorcircuit.applications.vqes.Linear.input_spec:29 +#: tensorcircuit.keras.QuantumLayer.input_spec:29 +msgid "A `tf.keras.layers.InputSpec` instance, or nested structure thereof." +msgstr "" + +#: keras.engine.training.Model.load_weights:1 of +msgid "Loads all layer weights, either from a TensorFlow or an HDF5 weight file." +msgstr "" + +#: keras.engine.training.Model.load_weights:3 of +msgid "" +"If `by_name` is False weights are loaded based on the network's topology." +" This means the architecture should be the same as when the weights were " +"saved. Note that layers that don't have weights are not taken into " +"account in the topological ordering, so adding or removing layers is fine" +" as long as they don't have weights." +msgstr "" + +#: keras.engine.training.Model.load_weights:9 of +msgid "" +"If `by_name` is True, weights are loaded into layers only if they share " +"the same name. This is useful for fine-tuning or transfer-learning models" +" where some of the layers have changed." +msgstr "" + +#: keras.engine.training.Model.load_weights:13 of +msgid "" +"Only topological loading (`by_name=False`) is supported when loading " +"weights from the TensorFlow format. Note that topological loading differs" +" slightly between TensorFlow and HDF5 formats for user-defined classes " +"inheriting from `tf.keras.Model`: HDF5 loads based on a flattened list of" +" weights, while the TensorFlow format loads based on the object-local " +"names of attributes to which layers are assigned in the `Model`'s " +"constructor." +msgstr "" + +#: keras.engine.training.Model.load_weights:20 of +msgid "" +"String, path to the weights file to load. For weight files in TensorFlow " +"format, this is the file prefix (the same as was passed to " +"`save_weights`). This can also be a path to a SavedModel saved from " +"`model.save`." +msgstr "" + +#: keras.engine.training.Model.load_weights:24 of +msgid "" +"Boolean, whether to load weights by name or by topological order. Only " +"topological loading is supported for weight files in TensorFlow format." +msgstr "" + +#: keras.engine.training.Model.load_weights:27 of +msgid "" +"Boolean, whether to skip loading of layers where there is a mismatch in " +"the number of weights, or a mismatch in the shape of the weight (only " +"valid when `by_name=True`)." +msgstr "" + +#: keras.engine.training.Model.load_weights:30 of +msgid "" +"Optional `tf.train.CheckpointOptions` object that specifies options for " +"loading weights." +msgstr "" + +#: keras.engine.training.Model.load_weights:33 of +msgid "" +"When loading a weight file in TensorFlow format, returns the same status " +"object as `tf.train.Checkpoint.restore`. When graph building, restore ops" +" are run automatically as soon as the network is built (on first call for" +" user-defined classes inheriting from `Model`, immediately if it is " +"already built). When loading weights in HDF5 format, returns `None`." +msgstr "" + +#: keras.engine.training.Model.load_weights:33 of +msgid "" +"When loading a weight file in TensorFlow format, returns the same status " +"object as `tf.train.Checkpoint.restore`. When graph building, restore ops" +" are run automatically as soon as the network is built (on first call for" +" user-defined classes inheriting from `Model`, immediately if it is " +"already built)." +msgstr "" + +#: keras.engine.training.Model.load_weights:39 of +msgid "When loading weights in HDF5 format, returns `None`." +msgstr "" + +#: keras.engine.training.Model.load_weights:41 of +msgid "If `h5py` is not available and the weight file is in HDF5 format." +msgstr "" + +#: keras.engine.training.Model.load_weights:42 of +msgid "If `skip_mismatch` is set to `True` when `by_name` is `False`." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.losses:1 +#: tensorcircuit.applications.van.MaskedConv2D.losses:1 +#: tensorcircuit.applications.van.MaskedLinear.losses:1 +#: tensorcircuit.applications.van.NMF.losses:1 +#: tensorcircuit.applications.van.PixelCNN.losses:1 +#: tensorcircuit.applications.van.ResidualBlock.losses:1 +#: tensorcircuit.applications.vqes.Linear.losses:1 +#: tensorcircuit.keras.QuantumLayer.losses:1 +msgid "List of losses added using the `add_loss()` API." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.losses:3 +#: tensorcircuit.applications.van.MaskedConv2D.losses:3 +#: tensorcircuit.applications.van.MaskedLinear.losses:3 +#: tensorcircuit.applications.van.NMF.losses:3 +#: tensorcircuit.applications.van.PixelCNN.losses:3 +#: tensorcircuit.applications.van.ResidualBlock.losses:3 +#: tensorcircuit.applications.vqes.Linear.losses:3 +#: tensorcircuit.keras.QuantumLayer.losses:3 +msgid "" +"Variable regularization tensors are created when this property is " +"accessed, so it is eager safe: accessing `losses` under a " +"`tf.GradientTape` will propagate gradients back to the corresponding " +"variables." +msgstr "" + +#: keras.engine.training.Model.reset_metrics:3 of +#: tensorcircuit.applications.van.MADE.losses:7 +#: tensorcircuit.applications.van.MADE.metrics:6 +#: tensorcircuit.applications.van.MADE.metrics_names:6 +#: tensorcircuit.applications.van.MaskedConv2D.losses:7 +#: tensorcircuit.applications.van.MaskedLinear.losses:7 +#: tensorcircuit.applications.van.NMF.losses:7 +#: tensorcircuit.applications.van.NMF.metrics:6 +#: tensorcircuit.applications.van.NMF.metrics_names:6 +#: tensorcircuit.applications.van.PixelCNN.losses:7 +#: tensorcircuit.applications.van.PixelCNN.metrics:6 +#: tensorcircuit.applications.van.PixelCNN.metrics_names:6 +#: tensorcircuit.applications.van.ResidualBlock.losses:7 +#: tensorcircuit.applications.vqes.Linear.losses:7 +#: tensorcircuit.keras.QuantumLayer.losses:7 +msgid "Examples:" +msgstr "" + +#: of tensorcircuit.applications.van.MADE.losses:39 +#: tensorcircuit.applications.van.MaskedConv2D.losses:39 +#: tensorcircuit.applications.van.MaskedLinear.losses:39 +#: tensorcircuit.applications.van.NMF.losses:39 +#: tensorcircuit.applications.van.PixelCNN.losses:39 +#: tensorcircuit.applications.van.ResidualBlock.losses:39 +#: tensorcircuit.applications.vqes.Linear.losses:39 +#: tensorcircuit.keras.QuantumLayer.losses:39 +msgid "A list of tensors." +msgstr "" + +#: keras.engine.training.Model.make_predict_function:1 of +msgid "Creates a function that executes one step of inference." +msgstr "" + +#: keras.engine.training.Model.make_predict_function:3 of +msgid "" +"This method can be overridden to support custom inference logic. This " +"method is called by `Model.predict` and `Model.predict_on_batch`." +msgstr "" + +#: keras.engine.training.Model.make_predict_function:6 of +msgid "" +"Typically, this method directly controls `tf.function` and " +"`tf.distribute.Strategy` settings, and delegates the actual evaluation " +"logic to `Model.predict_step`." +msgstr "" + +#: keras.engine.training.Model.make_predict_function:10 of +msgid "" +"This function is cached the first time `Model.predict` or " +"`Model.predict_on_batch` is called. The cache is cleared whenever " +"`Model.compile` is called. You can skip the cache and generate again the " +"function with `force=True`." +msgstr "" + +#: keras.engine.training.Model.make_predict_function:15 of +msgid "" +"Whether to regenerate the predict function and skip the cached function " +"if available." +msgstr "" + +#: keras.engine.training.Model.make_predict_function:18 of +msgid "" +"Function. The function created by this method should accept a " +"`tf.data.Iterator`, and return the outputs of the `Model`." +msgstr "" + +#: keras.engine.training.Model.make_test_function:1 of +msgid "Creates a function that executes one step of evaluation." +msgstr "" + +#: keras.engine.training.Model.make_test_function:3 of +msgid "" +"This method can be overridden to support custom evaluation logic. This " +"method is called by `Model.evaluate` and `Model.test_on_batch`." +msgstr "" + +#: keras.engine.training.Model.make_test_function:6 of +msgid "" +"Typically, this method directly controls `tf.function` and " +"`tf.distribute.Strategy` settings, and delegates the actual evaluation " +"logic to `Model.test_step`." +msgstr "" + +#: keras.engine.training.Model.make_test_function:10 of +msgid "" +"This function is cached the first time `Model.evaluate` or " +"`Model.test_on_batch` is called. The cache is cleared whenever " +"`Model.compile` is called. You can skip the cache and generate again the " +"function with `force=True`." +msgstr "" + +#: keras.engine.training.Model.make_test_function:15 of +msgid "" +"Whether to regenerate the test function and skip the cached function if " +"available." +msgstr "" + +#: keras.engine.training.Model.make_test_function:18 of +msgid "" +"Function. The function created by this method should accept a " +"`tf.data.Iterator`, and return a `dict` containing values that will be " +"passed to `tf.keras.Callbacks.on_test_batch_end`." +msgstr "" + +#: keras.engine.training.Model.make_train_function:1 of +msgid "Creates a function that executes one step of training." +msgstr "" + +#: keras.engine.training.Model.make_train_function:3 of +msgid "" +"This method can be overridden to support custom training logic. This " +"method is called by `Model.fit` and `Model.train_on_batch`." +msgstr "" + +#: keras.engine.training.Model.make_train_function:6 of +msgid "" +"Typically, this method directly controls `tf.function` and " +"`tf.distribute.Strategy` settings, and delegates the actual training " +"logic to `Model.train_step`." +msgstr "" + +#: keras.engine.training.Model.make_train_function:10 of +msgid "" +"This function is cached the first time `Model.fit` or " +"`Model.train_on_batch` is called. The cache is cleared whenever " +"`Model.compile` is called. You can skip the cache and generate again the " +"function with `force=True`." +msgstr "" + +#: keras.engine.training.Model.make_train_function:15 of +msgid "" +"Whether to regenerate the train function and skip the cached function if " +"available." +msgstr "" + +#: keras.engine.training.Model.make_train_function:18 of +msgid "" +"Function. The function created by this method should accept a " +"`tf.data.Iterator`, and return a `dict` containing values that will be " +"passed to `tf.keras.Callbacks.on_train_batch_end`, such as `{'loss': 0.2," +" 'accuracy': 0.7}`." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.metrics:1 +#: tensorcircuit.applications.van.NMF.metrics:1 +#: tensorcircuit.applications.van.PixelCNN.metrics:1 +msgid "Returns the model's metrics added using `compile()`, `add_metric()` APIs." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.metrics:3 +#: tensorcircuit.applications.van.NMF.metrics:3 +#: tensorcircuit.applications.van.PixelCNN.metrics:3 +msgid "" +"Note: Metrics passed to `compile()` are available only after a " +"`keras.Model` has been trained/evaluated on actual data." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.metrics_names:1 +#: tensorcircuit.applications.van.NMF.metrics_names:1 +#: tensorcircuit.applications.van.PixelCNN.metrics_names:1 +msgid "Returns the model's display labels for all outputs." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.metrics_names:3 +#: tensorcircuit.applications.van.NMF.metrics_names:3 +#: tensorcircuit.applications.van.PixelCNN.metrics_names:3 +msgid "" +"Note: `metrics_names` are available only after a `keras.Model` has been " +"trained/evaluated on actual data." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.name:1 +#: tensorcircuit.applications.van.MaskedConv2D.name:1 +#: tensorcircuit.applications.van.MaskedLinear.name:1 +#: tensorcircuit.applications.van.NMF.name:1 +#: tensorcircuit.applications.van.PixelCNN.name:1 +#: tensorcircuit.applications.van.ResidualBlock.name:1 +#: tensorcircuit.applications.vqes.Linear.name:1 +#: tensorcircuit.keras.QuantumLayer.name:1 +msgid "Name of the layer (string), set in the constructor." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.name_scope:1 +#: tensorcircuit.applications.van.MaskedConv2D.name_scope:1 +#: tensorcircuit.applications.van.MaskedLinear.name_scope:1 +#: tensorcircuit.applications.van.NMF.name_scope:1 +#: tensorcircuit.applications.van.PixelCNN.name_scope:1 +#: tensorcircuit.applications.van.ResidualBlock.name_scope:1 +#: tensorcircuit.applications.vqes.Linear.name_scope:1 +#: tensorcircuit.keras.QuantumLayer.name_scope:1 +msgid "Returns a `tf.name_scope` instance for this class." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.non_trainable_variables:1 +#: tensorcircuit.applications.van.MaskedConv2D.non_trainable_variables:1 +#: tensorcircuit.applications.van.MaskedLinear.non_trainable_variables:1 +#: tensorcircuit.applications.van.NMF.non_trainable_variables:1 +#: tensorcircuit.applications.van.PixelCNN.non_trainable_variables:1 +#: tensorcircuit.applications.van.ResidualBlock.non_trainable_variables:1 +#: tensorcircuit.applications.vqes.Linear.non_trainable_variables:1 +#: tensorcircuit.keras.QuantumLayer.non_trainable_variables:1 +msgid "" +"Sequence of non-trainable variables owned by this module and its " +"submodules." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.non_trainable_variables:3 +#: tensorcircuit.applications.van.MADE.trainable_variables:3 +#: tensorcircuit.applications.van.MaskedConv2D.non_trainable_variables:3 +#: tensorcircuit.applications.van.MaskedConv2D.trainable_variables:3 +#: tensorcircuit.applications.van.MaskedLinear.non_trainable_variables:3 +#: tensorcircuit.applications.van.MaskedLinear.trainable_variables:3 +#: tensorcircuit.applications.van.NMF.non_trainable_variables:3 +#: tensorcircuit.applications.van.NMF.trainable_variables:3 +#: tensorcircuit.applications.van.PixelCNN.non_trainable_variables:3 +#: tensorcircuit.applications.van.PixelCNN.trainable_variables:3 +#: tensorcircuit.applications.van.ResidualBlock.non_trainable_variables:3 +#: tensorcircuit.applications.van.ResidualBlock.trainable_variables:3 +#: tensorcircuit.applications.vqes.Linear.non_trainable_variables:3 +#: tensorcircuit.applications.vqes.Linear.trainable_variables:3 +#: tensorcircuit.keras.QuantumLayer.non_trainable_variables:3 +#: tensorcircuit.keras.QuantumLayer.trainable_variables:3 +msgid "" +"Note: this method uses reflection to find variables on the current " +"instance and submodules. For performance reasons you may wish to cache " +"the result of calling this method if you don't expect the return value to" +" change." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.non_trainable_variables:7 +#: tensorcircuit.applications.van.MADE.trainable_variables:7 +#: tensorcircuit.applications.van.MaskedConv2D.non_trainable_variables:7 +#: tensorcircuit.applications.van.MaskedConv2D.trainable_variables:7 +#: tensorcircuit.applications.van.MaskedLinear.non_trainable_variables:7 +#: tensorcircuit.applications.van.MaskedLinear.trainable_variables:7 +#: tensorcircuit.applications.van.NMF.non_trainable_variables:7 +#: tensorcircuit.applications.van.NMF.trainable_variables:7 +#: tensorcircuit.applications.van.PixelCNN.non_trainable_variables:7 +#: tensorcircuit.applications.van.PixelCNN.trainable_variables:7 +#: tensorcircuit.applications.van.ResidualBlock.non_trainable_variables:7 +#: tensorcircuit.applications.van.ResidualBlock.trainable_variables:7 +#: tensorcircuit.applications.vqes.Linear.non_trainable_variables:7 +#: tensorcircuit.applications.vqes.Linear.trainable_variables:7 +#: tensorcircuit.keras.QuantumLayer.non_trainable_variables:7 +#: tensorcircuit.keras.QuantumLayer.trainable_variables:7 +msgid "" +"A sequence of variables for the current module (sorted by attribute name)" +" followed by variables from all submodules recursively (breadth first)." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.non_trainable_weights:1 +#: tensorcircuit.applications.van.MaskedConv2D.non_trainable_weights:1 +#: tensorcircuit.applications.van.MaskedLinear.non_trainable_weights:1 +#: tensorcircuit.applications.van.NMF.non_trainable_weights:1 +#: tensorcircuit.applications.van.PixelCNN.non_trainable_weights:1 +#: tensorcircuit.applications.van.ResidualBlock.non_trainable_weights:1 +#: tensorcircuit.applications.vqes.Linear.non_trainable_weights:1 +#: tensorcircuit.keras.QuantumLayer.non_trainable_weights:1 +msgid "List of all non-trainable weights tracked by this layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.non_trainable_weights:3 +#: tensorcircuit.applications.van.MaskedConv2D.non_trainable_weights:3 +#: tensorcircuit.applications.van.MaskedLinear.non_trainable_weights:3 +#: tensorcircuit.applications.van.NMF.non_trainable_weights:3 +#: tensorcircuit.applications.van.PixelCNN.non_trainable_weights:3 +#: tensorcircuit.applications.van.ResidualBlock.non_trainable_weights:3 +#: tensorcircuit.applications.vqes.Linear.non_trainable_weights:3 +#: tensorcircuit.keras.QuantumLayer.non_trainable_weights:3 +msgid "" +"Non-trainable weights are *not* updated during training. They are " +"expected to be updated manually in `call()`." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.non_trainable_weights:6 +#: tensorcircuit.applications.van.MaskedConv2D.non_trainable_weights:6 +#: tensorcircuit.applications.van.MaskedLinear.non_trainable_weights:6 +#: tensorcircuit.applications.van.NMF.non_trainable_weights:6 +#: tensorcircuit.applications.van.PixelCNN.non_trainable_weights:6 +#: tensorcircuit.applications.van.ResidualBlock.non_trainable_weights:6 +#: tensorcircuit.applications.vqes.Linear.non_trainable_weights:6 +#: tensorcircuit.keras.QuantumLayer.non_trainable_weights:6 +msgid "A list of non-trainable variables." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output:1 +#: tensorcircuit.applications.van.MaskedConv2D.output:1 +#: tensorcircuit.applications.van.MaskedLinear.output:1 +#: tensorcircuit.applications.van.NMF.output:1 +#: tensorcircuit.applications.van.PixelCNN.output:1 +#: tensorcircuit.applications.van.ResidualBlock.output:1 +#: tensorcircuit.applications.vqes.Linear.output:1 +#: tensorcircuit.keras.QuantumLayer.output:1 +msgid "Retrieves the output tensor(s) of a layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output:3 +#: tensorcircuit.applications.van.MaskedConv2D.output:3 +#: tensorcircuit.applications.van.MaskedLinear.output:3 +#: tensorcircuit.applications.van.NMF.output:3 +#: tensorcircuit.applications.van.PixelCNN.output:3 +#: tensorcircuit.applications.van.ResidualBlock.output:3 +#: tensorcircuit.applications.vqes.Linear.output:3 +#: tensorcircuit.keras.QuantumLayer.output:3 +msgid "" +"Only applicable if the layer has exactly one output, i.e. if it is " +"connected to one incoming layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output:6 +#: tensorcircuit.applications.van.MaskedConv2D.output:6 +#: tensorcircuit.applications.van.MaskedLinear.output:6 +#: tensorcircuit.applications.van.NMF.output:6 +#: tensorcircuit.applications.van.PixelCNN.output:6 +#: tensorcircuit.applications.van.ResidualBlock.output:6 +#: tensorcircuit.applications.vqes.Linear.output:6 +#: tensorcircuit.keras.QuantumLayer.output:6 +msgid "Output tensor or list of output tensors." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output:8 +#: tensorcircuit.applications.van.MaskedConv2D.output:8 +#: tensorcircuit.applications.van.MaskedLinear.output:8 +#: tensorcircuit.applications.van.NMF.output:8 +#: tensorcircuit.applications.van.PixelCNN.output:8 +#: tensorcircuit.applications.van.ResidualBlock.output:8 +#: tensorcircuit.applications.vqes.Linear.output:8 +#: tensorcircuit.keras.QuantumLayer.output:8 +msgid "if the layer is connected to more than one incoming layers." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output_mask:1 +#: tensorcircuit.applications.van.MaskedConv2D.output_mask:1 +#: tensorcircuit.applications.van.MaskedLinear.output_mask:1 +#: tensorcircuit.applications.van.NMF.output_mask:1 +#: tensorcircuit.applications.van.PixelCNN.output_mask:1 +#: tensorcircuit.applications.van.ResidualBlock.output_mask:1 +#: tensorcircuit.applications.vqes.Linear.output_mask:1 +#: tensorcircuit.keras.QuantumLayer.output_mask:1 +msgid "Retrieves the output mask tensor(s) of a layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output_mask:6 +#: tensorcircuit.applications.van.MaskedConv2D.output_mask:6 +#: tensorcircuit.applications.van.MaskedLinear.output_mask:6 +#: tensorcircuit.applications.van.NMF.output_mask:6 +#: tensorcircuit.applications.van.PixelCNN.output_mask:6 +#: tensorcircuit.applications.van.ResidualBlock.output_mask:6 +#: tensorcircuit.applications.vqes.Linear.output_mask:6 +#: tensorcircuit.keras.QuantumLayer.output_mask:6 +msgid "Output mask tensor (potentially None) or list of output mask tensors." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output_shape:1 +#: tensorcircuit.applications.van.MaskedConv2D.output_shape:1 +#: tensorcircuit.applications.van.MaskedLinear.output_shape:1 +#: tensorcircuit.applications.van.NMF.output_shape:1 +#: tensorcircuit.applications.van.PixelCNN.output_shape:1 +#: tensorcircuit.applications.van.ResidualBlock.output_shape:1 +#: tensorcircuit.applications.vqes.Linear.output_shape:1 +#: tensorcircuit.keras.QuantumLayer.output_shape:1 +msgid "Retrieves the output shape(s) of a layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output_shape:3 +#: tensorcircuit.applications.van.MaskedConv2D.output_shape:3 +#: tensorcircuit.applications.van.MaskedLinear.output_shape:3 +#: tensorcircuit.applications.van.NMF.output_shape:3 +#: tensorcircuit.applications.van.PixelCNN.output_shape:3 +#: tensorcircuit.applications.van.ResidualBlock.output_shape:3 +#: tensorcircuit.applications.vqes.Linear.output_shape:3 +#: tensorcircuit.keras.QuantumLayer.output_shape:3 +msgid "" +"Only applicable if the layer has one output, or if all outputs have the " +"same shape." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output_shape:6 +#: tensorcircuit.applications.van.MaskedConv2D.output_shape:6 +#: tensorcircuit.applications.van.MaskedLinear.output_shape:6 +#: tensorcircuit.applications.van.NMF.output_shape:6 +#: tensorcircuit.applications.van.PixelCNN.output_shape:6 +#: tensorcircuit.applications.van.ResidualBlock.output_shape:6 +#: tensorcircuit.applications.vqes.Linear.output_shape:6 +#: tensorcircuit.keras.QuantumLayer.output_shape:6 +msgid "" +"Output shape, as an integer shape tuple (or list of shape tuples, one " +"tuple per output tensor)." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.output_shape:9 +#: tensorcircuit.applications.van.MaskedConv2D.output_shape:9 +#: tensorcircuit.applications.van.MaskedLinear.output_shape:9 +#: tensorcircuit.applications.van.NMF.output_shape:9 +#: tensorcircuit.applications.van.PixelCNN.output_shape:9 +#: tensorcircuit.applications.van.ResidualBlock.output_shape:9 +#: tensorcircuit.applications.vqes.Linear.output_shape:9 +#: tensorcircuit.keras.QuantumLayer.output_shape:9 +msgid "if the layer has no defined output shape." +msgstr "" + +#: keras.engine.training.Model.predict:1 of +msgid "Generates output predictions for the input samples." +msgstr "" + +#: keras.engine.training.Model.predict:3 of +msgid "" +"Computation is done in batches. This method is designed for performance " +"in large scale inputs. For small amount of inputs that fit in one batch, " +"directly using `__call__()` is recommended for faster execution, e.g., " +"`model(x)`, or `model(x, training=False)` if you have layers such as " +"`tf.keras.layers.BatchNormalization` that behaves differently during " +"inference. Also, note the fact that test loss is not affected by " +"regularization layers like noise and dropout." +msgstr "" + +#: keras.engine.training.Model.predict:11 of +msgid "" +"Input samples. It could be: - A Numpy array (or array-like), or a list of" +" arrays (in case the model has multiple inputs). - A TensorFlow tensor," +" or a list of tensors (in case the model has multiple inputs). - A " +"`tf.data` dataset. - A generator or `keras.utils.Sequence` instance. A " +"more detailed description of unpacking behavior for iterator types " +"(Dataset, generator, Sequence) is given in the `Unpacking behavior for " +"iterator-like inputs` section of `Model.fit`." +msgstr "" + +#: keras.engine.training.Model.predict:11 of +msgid "" +"Input samples. It could be: - A Numpy array (or array-like), or a list of" +" arrays" +msgstr "" + +#: keras.engine.training.Model.predict:16 of +msgid "A `tf.data` dataset." +msgstr "" + +#: keras.engine.training.Model.predict:17 of +msgid "A generator or `keras.utils.Sequence` instance." +msgstr "" + +#: keras.engine.training.Model.predict:21 of +msgid "" +"Integer or `None`. Number of samples per batch. If unspecified, " +"`batch_size` will default to 32. Do not specify the `batch_size` if your " +"data is in the form of dataset, generators, or `keras.utils.Sequence` " +"instances (since they generate batches)." +msgstr "" + +#: keras.engine.training.Model.predict:27 of +msgid "Verbosity mode, 0 or 1." +msgstr "" + +#: keras.engine.training.Model.predict:28 of +msgid "" +"Total number of steps (batches of samples) before declaring the " +"prediction round finished. Ignored with the default value of `None`. If x" +" is a `tf.data` dataset and `steps` is None, `predict()` will run until " +"the input dataset is exhausted." +msgstr "" + +#: keras.engine.training.Model.predict:33 of +msgid "" +"List of `keras.callbacks.Callback` instances. List of callbacks to apply " +"during prediction. See [callbacks](/api_docs/python/tf/keras/callbacks)." +msgstr "" + +#: keras.engine.training.Model.predict:50 of +msgid "" +"See the discussion of `Unpacking behavior for iterator-like inputs` for " +"`Model.fit`. Note that Model.predict uses the same interpretation rules " +"as `Model.fit` and `Model.evaluate`, so inputs must be unambiguous for " +"all three methods." +msgstr "" + +#: keras.engine.training.Model.predict:55 +#: keras.engine.training.Model.predict_on_batch:9 of +msgid "Numpy array(s) of predictions." +msgstr "" + +#: keras.engine.training.Model.predict:57 of +msgid "If `model.predict` is wrapped in a `tf.function`." +msgstr "" + +#: keras.engine.training.Model.predict:58 of +msgid "" +"In case of mismatch between the provided input data and the model's " +"expectations, or in case a stateful model receives a number of " +"samples that is not a multiple of the batch size." +msgstr "" + +#: keras.engine.training.Model.predict_generator:1 of +msgid "Generates predictions for the input samples from a data generator." +msgstr "" + +#: keras.engine.training.Model.predict_generator:4 of +msgid "" +"`Model.predict` now supports generators, so there is no longer any need " +"to use this endpoint." +msgstr "" + +#: keras.engine.training.Model.predict_on_batch:1 of +msgid "Returns predictions for a single batch of samples." +msgstr "" + +#: keras.engine.training.Model.predict_on_batch:3 of +msgid "" +"Input data. It could be: - A Numpy array (or array-like), or a list of " +"arrays (in case the model has multiple inputs). - A TensorFlow " +"tensor, or a list of tensors (in case the model has multiple inputs)." +msgstr "" + +#: keras.engine.training.Model.predict_on_batch:3 +#: keras.engine.training.Model.test_on_batch:3 of +msgid "" +"Input data. It could be: - A Numpy array (or array-like), or a list of " +"arrays (in case the" +msgstr "" + +#: keras.engine.training.Model.predict_on_batch:5 +#: keras.engine.training.Model.test_on_batch:5 of +msgid "model has multiple inputs)." +msgstr "" + +#: keras.engine.training.Model.predict_on_batch:7 +#: keras.engine.training.Model.test_on_batch:6 of +msgid "A TensorFlow tensor, or a list of tensors (in case the model has" +msgstr "" + +#: keras.engine.training.Model.predict_on_batch:7 +#: keras.engine.training.Model.test_on_batch:7 of +msgid "multiple inputs)." +msgstr "" + +#: keras.engine.training.Model.predict_on_batch:11 of +msgid "If `model.predict_on_batch` is wrapped in a `tf.function`." +msgstr "" + +#: keras.engine.training.Model.predict_step:1 of +msgid "The logic for one inference step." +msgstr "" + +#: keras.engine.training.Model.predict_step:3 of +msgid "" +"This method can be overridden to support custom inference logic. This " +"method is called by `Model.make_predict_function`." +msgstr "" + +#: keras.engine.training.Model.predict_step:6 of +msgid "" +"This method should contain the mathematical logic for one step of " +"inference. This typically includes the forward pass." +msgstr "" + +#: keras.engine.training.Model.predict_step:9 of +msgid "" +"Configuration details for *how* this logic is run (e.g. `tf.function` and" +" `tf.distribute.Strategy` settings), should be left to " +"`Model.make_predict_function`, which can also be overridden." +msgstr "" + +#: keras.engine.training.Model.predict_step:13 +#: keras.engine.training.Model.test_step:15 +#: keras.engine.training.Model.train_step:16 of +msgid "A nested structure of `Tensor`s." +msgstr "" + +#: keras.engine.training.Model.predict_step:15 of +msgid "" +"The result of one inference step, typically the output of calling the " +"`Model` on data." +msgstr "" + +#: keras.engine.training.Model.reset_metrics:1 of +msgid "Resets the state of all the metrics in the model." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.run_eagerly:1 +#: tensorcircuit.applications.van.NMF.run_eagerly:1 +#: tensorcircuit.applications.van.PixelCNN.run_eagerly:1 +msgid "Settable attribute indicating whether the model should run eagerly." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.run_eagerly:3 +#: tensorcircuit.applications.van.NMF.run_eagerly:3 +#: tensorcircuit.applications.van.PixelCNN.run_eagerly:3 +msgid "" +"Running eagerly means that your model will be run step by step, like " +"Python code. Your model might run slower, but it should become easier for" +" you to debug it by stepping into individual layer calls." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.run_eagerly:7 +#: tensorcircuit.applications.van.NMF.run_eagerly:7 +#: tensorcircuit.applications.van.PixelCNN.run_eagerly:7 +msgid "" +"By default, we will attempt to compile your model to a static graph to " +"deliver the best execution performance." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.run_eagerly:10 +#: tensorcircuit.applications.van.NMF.run_eagerly:10 +#: tensorcircuit.applications.van.PixelCNN.run_eagerly:10 +msgid "Boolean, whether the model should run eagerly." +msgstr "" + +#: keras.engine.training.Model.save:1 of +msgid "Saves the model to Tensorflow SavedModel or a single HDF5 file." +msgstr "" + +#: keras.engine.training.Model.save:3 of +msgid "" +"Please see `tf.keras.models.save_model` or the [Serialization and Saving " +"guide](https://keras.io/guides/serialization_and_saving/) for details." +msgstr "" + +#: keras.engine.training.Model.save:7 of +msgid "String, PathLike, path to SavedModel or H5 file to save the model." +msgstr "" + +#: keras.engine.training.Model.save:9 +#: keras.engine.training.Model.save_weights:47 of +msgid "" +"Whether to silently overwrite any existing file at the target location, " +"or provide the user with a manual prompt." +msgstr "" + +#: keras.engine.training.Model.save:11 of +msgid "If True, save optimizer's state together." +msgstr "" + +#: keras.engine.training.Model.save:12 of +msgid "" +"Either `'tf'` or `'h5'`, indicating whether to save the model to " +"Tensorflow SavedModel or HDF5. Defaults to 'tf' in TF 2.X, and 'h5' in TF" +" 1.X." +msgstr "" + +#: keras.engine.training.Model.save:15 of +msgid "" +"Signatures to save with the SavedModel. Applicable to the 'tf' format " +"only. Please see the `signatures` argument in `tf.saved_model.save` for " +"details." +msgstr "" + +#: keras.engine.training.Model.save:18 of +msgid "" +"(only applies to SavedModel format) `tf.saved_model.SaveOptions` object " +"that specifies options for saving to SavedModel." +msgstr "" + +#: keras.engine.training.Model.save:21 of +msgid "" +"(only applies to SavedModel format) When enabled, the SavedModel will " +"store the function traces for each layer. This can be disabled, so that " +"only the configs of each layer are stored. Defaults to `True`. Disabling " +"this will decrease serialization time and reduce file size, but it " +"requires that all custom layers/models implement a `get_config()` method." +msgstr "" + +#: keras.engine.training.Model.save:30 of +msgid "```python from keras.models import load_model" +msgstr "" + +#: keras.engine.training.Model.save:33 of +msgid "" +"model.save('my_model.h5') # creates a HDF5 file 'my_model.h5' del model" +" # deletes the existing model" +msgstr "" + +#: keras.engine.training.Model.save:36 of +msgid "" +"# returns a compiled model # identical to the previous one model = " +"load_model('my_model.h5') ```" +msgstr "" + +#: keras.engine.training.Model.save_spec:1 of +msgid "Returns the `tf.TensorSpec` of call inputs as a tuple `(args, kwargs)`." +msgstr "" + +#: keras.engine.training.Model.save_spec:3 of +msgid "" +"This value is automatically defined after calling the model for the first" +" time. Afterwards, you can use it when exporting the model for serving:" +msgstr "" + +#: keras.engine.training.Model.save_spec:6 of +msgid "```python model = tf.keras.Model(...)" +msgstr "" + +#: keras.engine.training.Model.save_spec:9 of +msgid "@tf.function def serve(*args, **kwargs):" +msgstr "" + +#: keras.engine.training.Model.save_spec:11 of +msgid "" +"outputs = model(*args, **kwargs) # Apply postprocessing steps, or add " +"additional outputs. ... return outputs" +msgstr "" + +#: keras.engine.training.Model.save_spec:16 of +msgid "" +"# arg_specs is `[tf.TensorSpec(...), ...]`. kwarg_specs, in this example," +" is # an empty dict since functional models do not use keyword arguments." +" arg_specs, kwarg_specs = model.save_spec()" +msgstr "" + +#: keras.engine.training.Model.save_spec:20 of +msgid "model.save(path, signatures={" +msgstr "" + +#: keras.engine.training.Model.save_spec:21 of +msgid "'serving_default': serve.get_concrete_function(*arg_specs, **kwarg_specs)" +msgstr "" + +#: keras.engine.training.Model.save_spec:25 of +msgid "" +"Whether to set the batch sizes of all the returned `tf.TensorSpec` to " +"`None`. (Note that when defining functional or Sequential models with " +"`tf.keras.Input([...], batch_size=X)`, the batch size will always be " +"preserved). Defaults to `True`." +msgstr "" + +#: keras.engine.training.Model.save_spec:30 of +msgid "" +"If the model inputs are defined, returns a tuple `(args, kwargs)`. All " +"elements in `args` and `kwargs` are `tf.TensorSpec`. If the model inputs " +"are not defined, returns `None`. The model inputs are automatically set " +"when calling the model, `model.fit`, `model.evaluate` or `model.predict`." +msgstr "" + +#: keras.engine.training.Model.save_weights:1 of +msgid "Saves all layer weights." +msgstr "" + +#: keras.engine.training.Model.save_weights:3 of +msgid "" +"Either saves in HDF5 or in TensorFlow format based on the `save_format` " +"argument." +msgstr "" + +#: keras.engine.training.Model.save_weights:14 of +msgid "When saving in HDF5 format, the weight file has:" +msgstr "" + +#: keras.engine.training.Model.save_weights:7 of +msgid "`layer_names` (attribute), a list of strings" +msgstr "" + +#: keras.engine.training.Model.save_weights:8 of +msgid "(ordered names of model layers)." +msgstr "" + +#: keras.engine.training.Model.save_weights:14 of +msgid "For every layer, a `group` named `layer.name`" +msgstr "" + +#: keras.engine.training.Model.save_weights:11 of +msgid "For every such layer group, a group attribute `weight_names`," +msgstr "" + +#: keras.engine.training.Model.save_weights:11 of +msgid "a list of strings (ordered names of weights tensor of the layer)." +msgstr "" + +#: keras.engine.training.Model.save_weights:14 of +msgid "For every weight in the layer, a dataset" +msgstr "" + +#: keras.engine.training.Model.save_weights:14 of +msgid "storing the weight value, named after the weight tensor." +msgstr "" + +#: keras.engine.training.Model.save_weights:16 of +msgid "" +"When saving in TensorFlow format, all objects referenced by the network " +"are saved in the same format as `tf.train.Checkpoint`, including any " +"`Layer` instances or `Optimizer` instances assigned to object attributes." +" For networks constructed from inputs and outputs using " +"`tf.keras.Model(inputs, outputs)`, `Layer` instances used by the network " +"are tracked/saved automatically. For user-defined classes which inherit " +"from `tf.keras.Model`, `Layer` instances must be assigned to object " +"attributes, typically in the constructor. See the documentation of " +"`tf.train.Checkpoint` and `tf.keras.Model` for details." +msgstr "" + +#: keras.engine.training.Model.save_weights:26 of +msgid "" +"While the formats are the same, do not mix `save_weights` and " +"`tf.train.Checkpoint`. Checkpoints saved by `Model.save_weights` should " +"be loaded using `Model.load_weights`. Checkpoints saved using " +"`tf.train.Checkpoint.save` should be restored using the corresponding " +"`tf.train.Checkpoint.restore`. Prefer `tf.train.Checkpoint` over " +"`save_weights` for training checkpoints." +msgstr "" + +#: keras.engine.training.Model.save_weights:33 of +msgid "" +"The TensorFlow format matches objects and variables by starting at a root" +" object, `self` for `save_weights`, and greedily matching attribute " +"names. For `Model.save` this is the `Model`, and for `Checkpoint.save` " +"this is the `Checkpoint` even if the `Checkpoint` has a model attached. " +"This means saving a `tf.keras.Model` using `save_weights` and loading " +"into a `tf.train.Checkpoint` with a `Model` attached (or vice versa) will" +" not match the `Model`'s variables. See the [guide to training " +"checkpoints](https://www.tensorflow.org/guide/checkpoint) for details on " +"the TensorFlow format." +msgstr "" + +#: keras.engine.training.Model.save_weights:43 of +msgid "" +"String or PathLike, path to the file to save the weights to. When saving " +"in TensorFlow format, this is the prefix used for checkpoint files " +"(multiple files are generated). Note that the '.h5' suffix causes weights" +" to be saved in HDF5 format." +msgstr "" + +#: keras.engine.training.Model.save_weights:49 of +msgid "" +"Either 'tf' or 'h5'. A `filepath` ending in '.h5' or '.keras' will " +"default to HDF5 if `save_format` is `None`. Otherwise `None` defaults to " +"'tf'." +msgstr "" + +#: keras.engine.training.Model.save_weights:52 of +msgid "" +"Optional `tf.train.CheckpointOptions` object that specifies options for " +"saving weights." +msgstr "" + +#: keras.engine.training.Model.save_weights:55 of +msgid "If `h5py` is not available when attempting to save in HDF5 format." +msgstr "" + +#: keras.engine.base_layer.Layer.set_weights:1 of +msgid "Sets the weights of the layer, from NumPy arrays." +msgstr "" + +#: keras.engine.base_layer.Layer.set_weights:3 of +msgid "" +"The weights of a layer represent the state of the layer. This function " +"sets the weight values from numpy arrays. The weight values should be " +"passed in the order they are created by the layer. Note that the layer's " +"weights must be instantiated before calling this function, by calling the" +" layer." +msgstr "" + +#: keras.engine.base_layer.Layer.get_weights:8 +#: keras.engine.base_layer.Layer.set_weights:9 of +msgid "" +"For example, a `Dense` layer returns a list of two values: the kernel " +"matrix and the bias vector. These can be used to set the weights of " +"another `Dense` layer:" +msgstr "" + +#: keras.engine.base_layer.Layer.set_weights:33 of +msgid "" +"a list of NumPy arrays. The number of arrays and their shape must match " +"number of the dimensions of the weights of the layer (i.e. it should " +"match the output of `get_weights`)." +msgstr "" + +#: keras.engine.base_layer.Layer.set_weights:39 of +msgid "" +"If the provided weights list does not match the layer's " +"specifications." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.state_updates:3 +#: tensorcircuit.applications.van.NMF.state_updates:3 +#: tensorcircuit.applications.van.PixelCNN.state_updates:3 +msgid "Returns the `updates` from all layers that are stateful." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.state_updates:5 +#: tensorcircuit.applications.van.NMF.state_updates:5 +#: tensorcircuit.applications.van.PixelCNN.state_updates:5 +msgid "" +"This is useful for separating training updates and state updates, e.g. " +"when we need to update a layer's internal state during prediction." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.state_updates:9 +#: tensorcircuit.applications.van.NMF.state_updates:9 +#: tensorcircuit.applications.van.PixelCNN.state_updates:9 +msgid "A list of update ops." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.submodules:1 +#: tensorcircuit.applications.van.MaskedConv2D.submodules:1 +#: tensorcircuit.applications.van.MaskedLinear.submodules:1 +#: tensorcircuit.applications.van.NMF.submodules:1 +#: tensorcircuit.applications.van.PixelCNN.submodules:1 +#: tensorcircuit.applications.van.ResidualBlock.submodules:1 +#: tensorcircuit.applications.vqes.Linear.submodules:1 +#: tensorcircuit.keras.QuantumLayer.submodules:1 +msgid "Sequence of all sub-modules." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.submodules:3 +#: tensorcircuit.applications.van.MaskedConv2D.submodules:3 +#: tensorcircuit.applications.van.MaskedLinear.submodules:3 +#: tensorcircuit.applications.van.NMF.submodules:3 +#: tensorcircuit.applications.van.PixelCNN.submodules:3 +#: tensorcircuit.applications.van.ResidualBlock.submodules:3 +#: tensorcircuit.applications.vqes.Linear.submodules:3 +#: tensorcircuit.keras.QuantumLayer.submodules:3 +msgid "" +"Submodules are modules which are properties of this module, or found as " +"properties of modules which are properties of this module (and so on)." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.submodules:18 +#: tensorcircuit.applications.van.MaskedConv2D.submodules:18 +#: tensorcircuit.applications.van.MaskedLinear.submodules:18 +#: tensorcircuit.applications.van.NMF.submodules:18 +#: tensorcircuit.applications.van.PixelCNN.submodules:18 +#: tensorcircuit.applications.van.ResidualBlock.submodules:18 +#: tensorcircuit.applications.vqes.Linear.submodules:18 +#: tensorcircuit.keras.QuantumLayer.submodules:18 +msgid "A sequence of all submodules." +msgstr "" + +#: keras.engine.training.Model.summary:1 of +msgid "Prints a string summary of the network." +msgstr "" + +#: keras.engine.training.Model.summary:3 of +msgid "" +"Total length of printed lines (e.g. set this to adapt the display to " +"different terminal window sizes)." +msgstr "" + +#: keras.engine.training.Model.summary:6 of +msgid "" +"Relative or absolute positions of log elements in each line. If not " +"provided, defaults to `[.33, .55, .67, 1.]`." +msgstr "" + +#: keras.engine.training.Model.summary:9 of +msgid "" +"Print function to use. Defaults to `print`. It will be called on each " +"line of the summary. You can set it to a custom function in order to " +"capture the string summary." +msgstr "" + +#: keras.engine.training.Model.summary:13 of +msgid "Whether to expand the nested models. If not provided, defaults to `False`." +msgstr "" + +#: keras.engine.training.Model.summary:16 of +msgid "if `summary()` is called before the model is built." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.supports_masking:1 +#: tensorcircuit.applications.van.MaskedConv2D.supports_masking:1 +#: tensorcircuit.applications.van.MaskedLinear.supports_masking:1 +#: tensorcircuit.applications.van.NMF.supports_masking:1 +#: tensorcircuit.applications.van.PixelCNN.supports_masking:1 +#: tensorcircuit.applications.van.ResidualBlock.supports_masking:1 +#: tensorcircuit.applications.vqes.Linear.supports_masking:1 +#: tensorcircuit.keras.QuantumLayer.supports_masking:1 +msgid "Whether this layer supports computing a mask using `compute_mask`." +msgstr "" + +#: keras.engine.training.Model.test_on_batch:1 of +msgid "Test the model on a single batch of samples." +msgstr "" + +#: keras.engine.training.Model.test_on_batch:3 of +msgid "" +"Input data. It could be: - A Numpy array (or array-like), or a list of " +"arrays (in case the model has multiple inputs). - A TensorFlow " +"tensor, or a list of tensors (in case the model has multiple inputs)." +" - A dict mapping input names to the corresponding array/tensors, if " +"the model has named inputs." +msgstr "" + +#: keras.engine.training.Model.test_on_batch:8 of +msgid "A dict mapping input names to the corresponding array/tensors, if" +msgstr "" + +#: keras.engine.training.Model.test_on_batch:9 of +msgid "the model has named inputs." +msgstr "" + +#: keras.engine.training.Model.test_on_batch:10 +#: keras.engine.training.Model.train_on_batch:10 of +msgid "" +"Target data. Like the input data `x`, it could be either Numpy array(s) " +"or TensorFlow tensor(s). It should be consistent with `x` (you cannot " +"have Numpy inputs and tensor targets, or inversely)." +msgstr "" + +#: keras.engine.training.Model.test_on_batch:13 +#: keras.engine.training.Model.train_on_batch:13 of +msgid "" +"Optional array of the same length as x, containing weights to apply to " +"the model's loss for each sample. In the case of temporal data, you can " +"pass a 2D array with shape (samples, sequence_length), to apply a " +"different weight to every timestep of every sample." +msgstr "" + +#: keras.engine.training.Model.test_on_batch:18 +#: keras.engine.training.Model.train_on_batch:22 of +msgid "" +"If `True`, the metrics returned will be only for this batch. If `False`, " +"the metrics will be statefully accumulated across batches." +msgstr "" + +#: keras.engine.training.Model.test_on_batch:30 of +msgid "If `model.test_on_batch` is wrapped in a `tf.function`." +msgstr "" + +#: keras.engine.training.Model.test_step:1 of +msgid "The logic for one evaluation step." +msgstr "" + +#: keras.engine.training.Model.test_step:3 of +msgid "" +"This method can be overridden to support custom evaluation logic. This " +"method is called by `Model.make_test_function`." +msgstr "" + +#: keras.engine.training.Model.test_step:6 of +msgid "" +"This function should contain the mathematical logic for one step of " +"evaluation. This typically includes the forward pass, loss calculation, " +"and metrics updates." +msgstr "" + +#: keras.engine.training.Model.test_step:11 of +msgid "" +"Configuration details for *how* this logic is run (e.g. `tf.function` and" +" `tf.distribute.Strategy` settings), should be left to " +"`Model.make_test_function`, which can also be overridden." +msgstr "" + +#: keras.engine.training.Model.test_step:17 of +msgid "" +"A `dict` containing values that will be passed to " +"`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the " +"values of the `Model`'s metrics are returned." +msgstr "" + +#: keras.engine.training.Model.to_json:1 of +msgid "Returns a JSON string containing the network configuration." +msgstr "" + +#: keras.engine.training.Model.to_json:3 of +msgid "" +"To load a network from a JSON save file, use " +"`keras.models.model_from_json(json_string, custom_objects={})`." +msgstr "" + +#: keras.engine.training.Model.to_json:6 of +msgid "Additional keyword arguments to be passed to `json.dumps()`." +msgstr "" + +#: keras.engine.training.Model.to_json:9 of +msgid "A JSON string." +msgstr "" + +#: keras.engine.training.Model.to_yaml:1 of +msgid "Returns a yaml string containing the network configuration." +msgstr "" + +#: keras.engine.training.Model.to_yaml:3 of +msgid "" +"Note: Since TF 2.6, this method is no longer supported and will raise a " +"RuntimeError." +msgstr "" + +#: keras.engine.training.Model.to_yaml:6 of +msgid "" +"To load a network from a yaml save file, use " +"`keras.models.model_from_yaml(yaml_string, custom_objects={})`." +msgstr "" + +#: keras.engine.training.Model.to_yaml:9 of +msgid "" +"`custom_objects` should be a dictionary mapping the names of custom " +"losses / layers / etc to the corresponding functions / classes." +msgstr "" + +#: keras.engine.training.Model.to_yaml:13 of +msgid "Additional keyword arguments to be passed to `yaml.dump()`." +msgstr "" + +#: keras.engine.training.Model.to_yaml:16 of +msgid "A YAML string." +msgstr "" + +#: keras.engine.training.Model.to_yaml:18 of +msgid "announces that the method poses a security risk" +msgstr "" + +#: keras.engine.training.Model.train_on_batch:1 of +msgid "Runs a single gradient update on a single batch of data." +msgstr "" + +#: keras.engine.training.Model.train_on_batch:3 of +msgid "" +"Input data. It could be: - A Numpy array (or array-like), or a list of " +"arrays (in case the model has multiple inputs). - A TensorFlow " +"tensor, or a list of tensors (in case the model has multiple inputs)." +" - A dict mapping input names to the corresponding array/tensors, if " +"the model has named inputs." +msgstr "" + +#: keras.engine.training.Model.train_on_batch:6 of +msgid "A TensorFlow tensor, or a list of tensors" +msgstr "" + +#: keras.engine.training.Model.train_on_batch:8 of +msgid "A dict mapping input names to the corresponding array/tensors," +msgstr "" + +#: keras.engine.training.Model.train_on_batch:9 of +msgid "if the model has named inputs." +msgstr "" + +#: keras.engine.training.Model.train_on_batch:18 of +msgid "" +"Optional dictionary mapping class indices (integers) to a weight (float) " +"to apply to the model's loss for the samples from this class during " +"training. This can be useful to tell the model to \"pay more attention\" " +"to samples from an under-represented class." +msgstr "" + +#: keras.engine.training.Model.train_on_batch:29 of +msgid "" +"Scalar training loss (if the model has a single output and no metrics) or" +" list of scalars (if the model has multiple outputs and/or metrics). The " +"attribute `model.metrics_names` will give you the display labels for the " +"scalar outputs." +msgstr "" + +#: keras.engine.training.Model.train_on_batch:35 of +msgid "If `model.train_on_batch` is wrapped in a `tf.function`." +msgstr "" + +#: keras.engine.training.Model.train_step:1 of +msgid "The logic for one training step." +msgstr "" + +#: keras.engine.training.Model.train_step:3 of +msgid "" +"This method can be overridden to support custom training logic. For " +"concrete examples of how to override this method see [Customizing what " +"happends in " +"fit](https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit)." +" This method is called by `Model.make_train_function`." +msgstr "" + +#: keras.engine.training.Model.train_step:8 of +msgid "" +"This method should contain the mathematical logic for one step of " +"training. This typically includes the forward pass, loss calculation, " +"backpropagation, and metric updates." +msgstr "" + +#: keras.engine.training.Model.train_step:12 of +msgid "" +"Configuration details for *how* this logic is run (e.g. `tf.function` and" +" `tf.distribute.Strategy` settings), should be left to " +"`Model.make_train_function`, which can also be overridden." +msgstr "" + +#: keras.engine.training.Model.train_step:18 of +msgid "" +"A `dict` containing values that will be passed to " +"`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the " +"values of the `Model`'s metrics are returned. Example: `{'loss': 0.2, " +"'accuracy': 0.7}`." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.trainable_variables:1 +#: tensorcircuit.applications.van.MaskedConv2D.trainable_variables:1 +#: tensorcircuit.applications.van.MaskedLinear.trainable_variables:1 +#: tensorcircuit.applications.van.NMF.trainable_variables:1 +#: tensorcircuit.applications.van.PixelCNN.trainable_variables:1 +#: tensorcircuit.applications.van.ResidualBlock.trainable_variables:1 +#: tensorcircuit.applications.vqes.Linear.trainable_variables:1 +#: tensorcircuit.keras.QuantumLayer.trainable_variables:1 +msgid "Sequence of trainable variables owned by this module and its submodules." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.trainable_weights:1 +#: tensorcircuit.applications.van.MaskedConv2D.trainable_weights:1 +#: tensorcircuit.applications.van.MaskedLinear.trainable_weights:1 +#: tensorcircuit.applications.van.NMF.trainable_weights:1 +#: tensorcircuit.applications.van.PixelCNN.trainable_weights:1 +#: tensorcircuit.applications.van.ResidualBlock.trainable_weights:1 +#: tensorcircuit.applications.vqes.Linear.trainable_weights:1 +#: tensorcircuit.keras.QuantumLayer.trainable_weights:1 +msgid "List of all trainable weights tracked by this layer." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.trainable_weights:3 +#: tensorcircuit.applications.van.MaskedConv2D.trainable_weights:3 +#: tensorcircuit.applications.van.MaskedLinear.trainable_weights:3 +#: tensorcircuit.applications.van.NMF.trainable_weights:3 +#: tensorcircuit.applications.van.PixelCNN.trainable_weights:3 +#: tensorcircuit.applications.van.ResidualBlock.trainable_weights:3 +#: tensorcircuit.applications.vqes.Linear.trainable_weights:3 +#: tensorcircuit.keras.QuantumLayer.trainable_weights:3 +msgid "Trainable weights are updated via gradient descent during training." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.trainable_weights:5 +#: tensorcircuit.applications.van.MaskedConv2D.trainable_weights:5 +#: tensorcircuit.applications.van.MaskedLinear.trainable_weights:5 +#: tensorcircuit.applications.van.NMF.trainable_weights:5 +#: tensorcircuit.applications.van.PixelCNN.trainable_weights:5 +#: tensorcircuit.applications.van.ResidualBlock.trainable_weights:5 +#: tensorcircuit.applications.vqes.Linear.trainable_weights:5 +#: tensorcircuit.keras.QuantumLayer.trainable_weights:5 +msgid "A list of trainable variables." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.variable_dtype:1 +#: tensorcircuit.applications.van.MaskedConv2D.variable_dtype:1 +#: tensorcircuit.applications.van.MaskedLinear.variable_dtype:1 +#: tensorcircuit.applications.van.NMF.variable_dtype:1 +#: tensorcircuit.applications.van.PixelCNN.variable_dtype:1 +#: tensorcircuit.applications.van.ResidualBlock.variable_dtype:1 +#: tensorcircuit.applications.vqes.Linear.variable_dtype:1 +#: tensorcircuit.keras.QuantumLayer.variable_dtype:1 +msgid "Alias of `Layer.dtype`, the dtype of the weights." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.variables:1 +#: tensorcircuit.applications.van.MADE.weights:1 +#: tensorcircuit.applications.van.MaskedConv2D.variables:1 +#: tensorcircuit.applications.van.MaskedConv2D.weights:1 +#: tensorcircuit.applications.van.MaskedLinear.variables:1 +#: tensorcircuit.applications.van.MaskedLinear.weights:1 +#: tensorcircuit.applications.van.NMF.variables:1 +#: tensorcircuit.applications.van.NMF.weights:1 +#: tensorcircuit.applications.van.PixelCNN.variables:1 +#: tensorcircuit.applications.van.PixelCNN.weights:1 +#: tensorcircuit.applications.van.ResidualBlock.variables:1 +#: tensorcircuit.applications.van.ResidualBlock.weights:1 +#: tensorcircuit.applications.vqes.Linear.variables:1 +#: tensorcircuit.applications.vqes.Linear.weights:1 +#: tensorcircuit.keras.QuantumLayer.variables:1 +#: tensorcircuit.keras.QuantumLayer.weights:1 +msgid "Returns the list of all layer variables/weights." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.variables:3 +#: tensorcircuit.applications.van.MaskedConv2D.variables:3 +#: tensorcircuit.applications.van.MaskedLinear.variables:3 +#: tensorcircuit.applications.van.NMF.variables:3 +#: tensorcircuit.applications.van.PixelCNN.variables:3 +#: tensorcircuit.applications.van.ResidualBlock.variables:3 +#: tensorcircuit.applications.vqes.Linear.variables:3 +#: tensorcircuit.keras.QuantumLayer.variables:3 +msgid "Alias of `self.weights`." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.variables:5 +#: tensorcircuit.applications.van.MADE.weights:3 +#: tensorcircuit.applications.van.MaskedConv2D.variables:5 +#: tensorcircuit.applications.van.MaskedLinear.variables:5 +#: tensorcircuit.applications.van.NMF.variables:5 +#: tensorcircuit.applications.van.NMF.weights:3 +#: tensorcircuit.applications.van.PixelCNN.variables:5 +#: tensorcircuit.applications.van.PixelCNN.weights:3 +#: tensorcircuit.applications.van.ResidualBlock.variables:5 +#: tensorcircuit.applications.vqes.Linear.variables:5 +#: tensorcircuit.keras.QuantumLayer.variables:5 +msgid "" +"Note: This will not track the weights of nested `tf.Modules` that are not" +" themselves Keras layers." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.variables:8 +#: tensorcircuit.applications.van.MADE.weights:6 +#: tensorcircuit.applications.van.MaskedConv2D.variables:8 +#: tensorcircuit.applications.van.MaskedConv2D.weights:3 +#: tensorcircuit.applications.van.MaskedLinear.variables:8 +#: tensorcircuit.applications.van.MaskedLinear.weights:3 +#: tensorcircuit.applications.van.NMF.variables:8 +#: tensorcircuit.applications.van.NMF.weights:6 +#: tensorcircuit.applications.van.PixelCNN.variables:8 +#: tensorcircuit.applications.van.PixelCNN.weights:6 +#: tensorcircuit.applications.van.ResidualBlock.variables:8 +#: tensorcircuit.applications.van.ResidualBlock.weights:3 +#: tensorcircuit.applications.vqes.Linear.variables:8 +#: tensorcircuit.applications.vqes.Linear.weights:3 +#: tensorcircuit.keras.QuantumLayer.variables:8 +#: tensorcircuit.keras.QuantumLayer.weights:3 +msgid "A list of variables." +msgstr "" + +#: of tensorflow.python.module.module.Module.with_name_scope:1 +msgid "Decorator to automatically enter the module name scope." +msgstr "" + +#: of tensorflow.python.module.module.Module.with_name_scope:10 +msgid "" +"Using the above module would produce `tf.Variable`s and `tf.Tensor`s " +"whose names included the module name:" +msgstr "" + +#: of tensorflow.python.module.module.Module.with_name_scope:20 +msgid "The method to wrap." +msgstr "" + +#: of tensorflow.python.module.module.Module.with_name_scope:22 +msgid "The original method wrapped such that it enters the module's name scope." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D:1 +#: tensorcircuit.applications.van.MaskedLinear:1 +#: tensorcircuit.applications.van.ResidualBlock:1 +#: tensorcircuit.applications.vqes.Linear:1 tensorcircuit.keras.QuantumLayer:1 +msgid "Bases: :py:class:`keras.engine.base_layer.Layer`" +msgstr "" + +#: keras.engine.base_layer.Layer.build:1 of +#: tensorcircuit.applications.van.MaskedConv2D.build:1 +#: tensorcircuit.keras.QuantumLayer.build:1 +msgid "Creates the variables of the layer (optional, for subclass implementers)." +msgstr "" + +#: keras.engine.base_layer.Layer.build:3 of +#: tensorcircuit.applications.van.MaskedConv2D.build:3 +#: tensorcircuit.keras.QuantumLayer.build:3 +msgid "" +"This is a method that implementers of subclasses of `Layer` or `Model` " +"can override if they need a state-creation step in-between layer " +"instantiation and layer call." +msgstr "" + +#: keras.engine.base_layer.Layer.build:7 of +#: tensorcircuit.applications.van.MaskedConv2D.build:7 +#: tensorcircuit.keras.QuantumLayer.build:7 +msgid "This is typically used to create the weights of `Layer` subclasses." +msgstr "" + +#: keras.engine.base_layer.Layer.build:9 of +#: tensorcircuit.applications.van.MaskedConv2D.build:9 +#: tensorcircuit.keras.QuantumLayer.build:9 +msgid "" +"Instance of `TensorShape`, or list of instances of `TensorShape` if the " +"layer expects a list of inputs (one instance per input)." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:1 +#: tensorcircuit.applications.van.MaskedLinear.call:1 +#: tensorcircuit.applications.van.ResidualBlock.call:1 +#: tensorcircuit.applications.vqes.Linear.call:1 +msgid "This is where the layer's logic lives." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:3 +#: tensorcircuit.applications.van.MaskedLinear.call:3 +#: tensorcircuit.applications.van.ResidualBlock.call:3 +#: tensorcircuit.applications.vqes.Linear.call:3 +msgid "" +"Note here that `call()` method in `tf.keras` is little bit different from" +" `keras` API. In `keras` API, you can pass support masking for layers as " +"additional arguments. Whereas `tf.keras` has `compute_mask()` method to " +"support masking." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:8 +#: tensorcircuit.applications.van.MaskedLinear.call:8 +#: tensorcircuit.applications.van.ResidualBlock.call:8 +#: tensorcircuit.applications.vqes.Linear.call:8 +msgid "" +"Input tensor, or dict/list/tuple of input tensors. The first positional " +"`inputs` argument is subject to special rules: - `inputs` must be " +"explicitly passed. A layer cannot have zero arguments, and `inputs` " +"cannot be provided via the default value of a keyword argument. - NumPy" +" array or Python scalar values in `inputs` get cast as tensors. - Keras " +"mask metadata is only collected from `inputs`. - Layers are built " +"(`build(input_shape)` method) using shape info from `inputs` only. - " +"`input_spec` compatibility is only checked against `inputs`. - Mixed " +"precision input casting is only applied to `inputs`. If a layer has " +"tensor arguments in `*args` or `**kwargs`, their casting behavior in " +"mixed precision should be handled manually. - The SavedModel input " +"specification is generated using `inputs` only. - Integration with " +"various ecosystem packages like TFMOT, TFLite, TF.js, etc is only " +"supported for `inputs` and not for tensors in positional and keyword " +"arguments." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:8 +#: tensorcircuit.applications.van.MaskedLinear.call:8 +#: tensorcircuit.applications.van.ResidualBlock.call:8 +#: tensorcircuit.applications.vqes.Linear.call:8 +msgid "" +"Input tensor, or dict/list/tuple of input tensors. The first positional " +"`inputs` argument is subject to special rules: - `inputs` must be " +"explicitly passed. A layer cannot have zero" +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:11 +#: tensorcircuit.applications.van.MaskedLinear.call:11 +#: tensorcircuit.applications.van.ResidualBlock.call:11 +#: tensorcircuit.applications.vqes.Linear.call:11 +msgid "" +"arguments, and `inputs` cannot be provided via the default value of a " +"keyword argument." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:13 +#: tensorcircuit.applications.van.MaskedLinear.call:13 +#: tensorcircuit.applications.van.ResidualBlock.call:13 +#: tensorcircuit.applications.vqes.Linear.call:13 +msgid "NumPy array or Python scalar values in `inputs` get cast as tensors." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:14 +#: tensorcircuit.applications.van.MaskedLinear.call:14 +#: tensorcircuit.applications.van.ResidualBlock.call:14 +#: tensorcircuit.applications.vqes.Linear.call:14 +msgid "Keras mask metadata is only collected from `inputs`." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:15 +#: tensorcircuit.applications.van.MaskedLinear.call:15 +#: tensorcircuit.applications.van.ResidualBlock.call:15 +#: tensorcircuit.applications.vqes.Linear.call:15 +msgid "" +"Layers are built (`build(input_shape)` method) using shape info from " +"`inputs` only." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:17 +#: tensorcircuit.applications.van.MaskedLinear.call:17 +#: tensorcircuit.applications.van.ResidualBlock.call:17 +#: tensorcircuit.applications.vqes.Linear.call:17 +msgid "`input_spec` compatibility is only checked against `inputs`." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:18 +#: tensorcircuit.applications.van.MaskedLinear.call:18 +#: tensorcircuit.applications.van.ResidualBlock.call:18 +#: tensorcircuit.applications.vqes.Linear.call:18 +msgid "" +"Mixed precision input casting is only applied to `inputs`. If a layer has" +" tensor arguments in `*args` or `**kwargs`, their casting behavior in " +"mixed precision should be handled manually." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:21 +#: tensorcircuit.applications.van.MaskedLinear.call:21 +#: tensorcircuit.applications.van.ResidualBlock.call:21 +#: tensorcircuit.applications.vqes.Linear.call:21 +msgid "The SavedModel input specification is generated using `inputs` only." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:22 +#: tensorcircuit.applications.van.MaskedLinear.call:22 +#: tensorcircuit.applications.van.ResidualBlock.call:22 +#: tensorcircuit.applications.vqes.Linear.call:22 +msgid "" +"Integration with various ecosystem packages like TFMOT, TFLite, TF.js, " +"etc is only supported for `inputs` and not for tensors in positional and " +"keyword arguments." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:25 +#: tensorcircuit.applications.van.MaskedLinear.call:25 +#: tensorcircuit.applications.van.ResidualBlock.call:25 +#: tensorcircuit.applications.vqes.Linear.call:25 +msgid "" +"Additional positional arguments. May contain tensors, although this is " +"not recommended, for the reasons above." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:27 +#: tensorcircuit.applications.van.MaskedLinear.call:27 +#: tensorcircuit.applications.van.ResidualBlock.call:27 +#: tensorcircuit.applications.vqes.Linear.call:27 +msgid "" +"Additional keyword arguments. May contain tensors, although this is not " +"recommended, for the reasons above. The following optional keyword " +"arguments are reserved: - `training`: Boolean scalar tensor of Python " +"boolean indicating whether the `call` is meant for training or " +"inference. - `mask`: Boolean input mask. If the layer's `call()` method " +"takes a `mask` argument, its default value will be set to the mask " +"generated for `inputs` by the previous layer (if `input` did come from " +"a layer that generated a corresponding mask, i.e. if it came from a " +"Keras layer with masking support)." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:27 +#: tensorcircuit.applications.van.MaskedLinear.call:27 +#: tensorcircuit.applications.van.ResidualBlock.call:27 +#: tensorcircuit.applications.vqes.Linear.call:27 +msgid "" +"Additional keyword arguments. May contain tensors, although this is not " +"recommended, for the reasons above. The following optional keyword " +"arguments are reserved: - `training`: Boolean scalar tensor of Python " +"boolean indicating" +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:31 +#: tensorcircuit.applications.van.MaskedLinear.call:31 +#: tensorcircuit.applications.van.ResidualBlock.call:31 +#: tensorcircuit.applications.vqes.Linear.call:31 +msgid "whether the `call` is meant for training or inference." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:32 +#: tensorcircuit.applications.van.MaskedLinear.call:32 +#: tensorcircuit.applications.van.ResidualBlock.call:32 +#: tensorcircuit.applications.vqes.Linear.call:32 +msgid "" +"`mask`: Boolean input mask. If the layer's `call()` method takes a `mask`" +" argument, its default value will be set to the mask generated for " +"`inputs` by the previous layer (if `input` did come from a layer that " +"generated a corresponding mask, i.e. if it came from a Keras layer with " +"masking support)." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:38 +#: tensorcircuit.applications.van.MaskedLinear.call:38 +#: tensorcircuit.applications.van.ResidualBlock.call:38 +#: tensorcircuit.applications.vqes.Linear.call:38 +msgid "A tensor or list/tuple of tensors." +msgstr "" + +#: keras.engine.base_layer.Layer.get_weights:1 of +msgid "Returns the current weights of the layer, as NumPy arrays." +msgstr "" + +#: keras.engine.base_layer.Layer.get_weights:3 of +msgid "" +"The weights of a layer represent the state of the layer. This function " +"returns both trainable and non-trainable weight values associated with " +"this layer as a list of NumPy arrays, which can in turn be used to load " +"state into similarly parameterized layers." +msgstr "" + +#: keras.engine.base_layer.Layer.get_weights:32 of +msgid "Weights values as a list of NumPy arrays." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.metrics:1 +#: tensorcircuit.applications.van.MaskedLinear.metrics:1 +#: tensorcircuit.applications.van.ResidualBlock.metrics:1 +#: tensorcircuit.applications.vqes.Linear.metrics:1 +#: tensorcircuit.keras.QuantumLayer.metrics:1 +msgid "List of metrics added using the `add_metric()` API." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.metrics:13 +#: tensorcircuit.applications.van.MaskedLinear.metrics:13 +#: tensorcircuit.applications.van.ResidualBlock.metrics:13 +#: tensorcircuit.applications.vqes.Linear.metrics:13 +#: tensorcircuit.keras.QuantumLayer.metrics:13 +msgid "A list of `Metric` objects." +msgstr "" + +#: ../../source/api/applications/vqes.rst:2 +msgid "tensorcircuit.applications.vqes" +msgstr "" + +#: of tensorcircuit.applications.vqes:1 +msgid "VQNHE application" +msgstr "" + +#: of tensorcircuit.applications.vqes.JointSchedule:1 +msgid "" +"Bases: " +":py:class:`keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule`" +msgstr "" + +#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config:1 +#: of +msgid "Instantiates a `LearningRateSchedule` from its config." +msgstr "" + +#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config:3 +#: of +msgid "Output of `get_config()`." +msgstr "" + +#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config:5 +#: of +msgid "A `LearningRateSchedule` instance." +msgstr "" + +#: of tensorcircuit.applications.vqes.Linear:1 +msgid "Dense layer but with complex weights, used for building complex RBM" +msgstr "" + +#: of tensorcircuit.applications.vqes.VQNHE.evaluation:1 +msgid "VQNHE" +msgstr "" + +#: of tensorcircuit.applications.vqes.VQNHE.evaluation:3 +#: tensorcircuit.applications.vqes.VQNHE.evaluation:5 +#: tensorcircuit.applications.vqes.VQNHE.plain_evaluation:3 +#: tensorcircuit.applications.vqes.VQNHE.plain_evaluation:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:10 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:11 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn:11 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu:11 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.random_split:6 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.random_split:8 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter:7 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter:9 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:11 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:15 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:13 +#: tensorcircuit.backends.jax_backend.JaxBackend.argmax:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.argmax:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.argmin:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.argmin:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.concat:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.cond:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.cond:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.cond:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.cond:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:10 +#: tensorcircuit.backends.jax_backend.JaxBackend.cumsum:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.cumsum:8 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:11 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:11 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:11 +#: tensorcircuit.backends.jax_backend.JaxBackend.max:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.max:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.min:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.min:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.random_split:6 +#: tensorcircuit.backends.jax_backend.JaxBackend.random_split:8 +#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.sigmoid:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.sigmoid:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:11 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:15 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:13 +#: tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.switch:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.switch:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.switch:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.tile:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.tile:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:29 +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:36 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.concat:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:10 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:8 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.max:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.max:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.min:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.min:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:11 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:15 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:13 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.unique_with_counts:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:29 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:36 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.concat:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:8 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.unique_with_counts:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:29 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:36 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.concat:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:10 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:8 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:11 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:15 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:13 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:29 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:36 +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:53 +#: tensorcircuit.quantum.count_d2s:10 tensorcircuit.quantum.count_d2s:14 +#: tensorcircuit.quantum.count_s2d:4 tensorcircuit.quantum.count_s2d:8 +#: tensorcircuit.simplify.pseudo_contract_between:3 +#: tensorcircuit.simplify.pseudo_contract_between:5 +#: tensorcircuit.simplify.pseudo_contract_between:7 +#: tensorcircuit.templates.graphs.Line1D:3 +#: tensorcircuit.templates.graphs.Line1D:7 +msgid "[description]" +msgstr "" + +#: of tensorcircuit.applications.vqes.VQNHE.plain_evaluation:1 +msgid "VQE" +msgstr "" + +#: ../../source/api/backends.rst:2 +msgid "tensorcircuit.backends" +msgstr "" + +#: ../../source/api/backends/backend_factory.rst:2 +msgid "tensorcircuit.backends.backend_factory" +msgstr "" + +#: of tensorcircuit.backends.backend_factory:1 +msgid "Backend register" +msgstr "" + +#: of tensorcircuit.backends.backend_factory.get_backend:1 +msgid "Get the `tc.backend` object." +msgstr "" + +#: of tensorcircuit.backends.backend_factory.get_backend:3 +msgid "\"numpy\", \"tensorflow\", \"jax\", \"pytorch\"" +msgstr "" + +#: of tensorcircuit.backends.backend_factory.get_backend:5 +msgid "Backend doesn't exist for `backend` argument." +msgstr "" + +#: of tensorcircuit.backends.backend_factory.get_backend:6 +#: tensorcircuit.cons.set_tensornetwork_backend:32 +msgid "The `tc.backend` object that with all registered universal functions." +msgstr "" + +#: ../../source/api/backends/jax_backend.rst:2 +msgid "tensorcircuit.backends.jax_backend" +msgstr "" + +#: of tensorcircuit.backends.jax_backend:1 +msgid "Backend magic inherited from tensornetwork: jax backend" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend:1 +msgid "" +"Bases: :py:class:`tensornetwork.backends.jax.jax_backend.JaxBackend`, " +":py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend:1 +msgid "" +"See the original backend API at `jax backend " +"`_" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.abs:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.abs:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.abs:1 +msgid "" +"Returns the elementwise absolute value of tensor. :param tensor: An input" +" tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.abs:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.abs:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs:4 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.abs:4 +msgid "Its elementwise absolute value." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.acos:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.asin:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.acos:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.asin:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asin:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asin:1 +msgid "Return the acos of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.sqrtmh:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.acos:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.acosh:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.asin:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.asinh:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.atan:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.atan2:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.atanh:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.copy:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.cosh:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.kron:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.kron:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.numpy:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.sinh:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.tan:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.tanh:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.acos:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.asin:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atanh:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.copy:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.numpy:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tan:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tanh:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asin:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atanh:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.numpy:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asin:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atanh:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.numpy:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh:3 +msgid "tensor in matrix form" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.acos:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.acos:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos:5 +msgid "acos of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.acosh:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh:1 +msgid "Return the acosh of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.acosh:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh:5 +msgid "acosh of ``a``" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.addition:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.addition:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.addition:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.addition:1 +msgid "" +"Return the default addition of `tensor`. A backend can override such " +"implementation. :param tensor1: A tensor. :param tensor2: A tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cos:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.expm:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.sin:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.softmax:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cos:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.expm:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sin:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos:4 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm:4 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin:4 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:9 +#: tensorcircuit.backends.pytorch_backend._conj_torch:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:9 +#: tensorcircuit.experimental.hamiltonian_evol:12 +#: tensornetwork.backends.abstract_backend.AbstractBackend.exp:4 +#: tensornetwork.backends.abstract_backend.AbstractBackend.log:4 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.addition:6 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.conj:4 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.divide:6 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.exp:4 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.log:4 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.multiply:7 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.subtraction:6 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.addition:6 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.conj:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.divide:6 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.exp:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.log:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.multiply:7 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.subtraction:6 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.addition:6 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.divide:6 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.multiply:7 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.subtraction:6 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.addition:6 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.conj:4 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.divide:6 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.exp:4 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.log:4 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.multiply:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.subtraction:6 +msgid "Tensor" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.adjoint:1 +msgid "Return the conjugate and transpose of a tensor ``a``" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.adjoint:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshape2:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshapem:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.relu:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:9 +msgid "Input tensor" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.adjoint:5 +msgid "adjoint tensor of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:1 +msgid "Values are generated within the half-open interval [start, stop)" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:3 +msgid "start index" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:5 +msgid "end index, defaults to None" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:7 +msgid "steps, defaults to 1" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.argmax:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:1 +msgid "Return the index of maximum of an array an axis." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.argmax:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.argmin:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:5 +msgid "[description], defaults to 0, different behavior from numpy defaults!" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.argmin:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:1 +msgid "Return the index of minimum of an array an axis." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.asin:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.asin:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asin:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asin:5 +msgid "asin of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.asinh:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh:1 +msgid "Return the asinh of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.asinh:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh:5 +msgid "asinh of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.atan:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan:1 +msgid "Return the atan of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.atan:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan:5 +msgid "atan of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.atan2:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2:1 +msgid "Return the atan of a tensor ``y``/``x``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.atan2:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2:5 +msgid "atan2 of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.atanh:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atanh:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atanh:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atanh:1 +msgid "Return the atanh of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.atanh:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.atanh:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atanh:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atanh:5 +msgid "atanh of ``a``" +msgstr "" + +#: of +#: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_left_multiplication:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_left_multiplication:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_left_multiplication:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.broadcast_left_multiplication:1 +msgid "" +"Perform broadcasting for multiplication of `tensor1` onto `tensor2`, i.e." +" `tensor1` * tensor2`, where `tensor2` is an arbitrary tensor and " +"`tensor1` is a one-dimensional tensor. The broadcasting is applied to the" +" first index of `tensor2`. :param tensor1: A tensor. :param tensor2: A " +"tensor." +msgstr "" + +#: of +#: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_left_multiplication:8 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_right_multiplication:8 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_left_multiplication:8 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_right_multiplication:8 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_left_multiplication:8 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_right_multiplication:8 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.broadcast_left_multiplication:8 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.broadcast_right_multiplication:8 +msgid "The result of multiplying `tensor1` onto `tensor2`." +msgstr "" + +#: of +#: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_right_multiplication:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_right_multiplication:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_right_multiplication:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.broadcast_right_multiplication:1 +msgid "" +"Perform broadcasting for multiplication of `tensor2` onto `tensor1`, i.e." +" `tensor1` * tensor2`, where `tensor1` is an arbitrary tensor and " +"`tensor2` is a one-dimensional tensor. The broadcasting is applied to the" +" last index of `tensor1`. :param tensor1: A tensor. :param tensor2: A " +"tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:1 +msgid "Cast the tensor dtype of a ``a``." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.sizen:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.cast:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.imag:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.real:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.size:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.imag:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.real:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.size:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.real:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.real:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size:3 +msgid "tensor" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:5 +msgid "\"float32\", \"float64\", \"complex64\", \"complex128\"" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:7 +msgid "``a`` of new dtype" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.concat:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.concat:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.concat:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.concat:1 +msgid "Join a sequence of arrays along an existing axis." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:9 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.concat:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:31 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.concat:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:31 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.concat:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:31 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.concat:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:31 +msgid "[description], defaults to 0" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cond:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:1 +msgid "" +"The native cond for XLA compiling, wrapper for ``tf.cond`` and limited " +"functionality of ``jax.lax.cond``." +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._conj_torch:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.conj:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.conj:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.conj:1 +msgid "Return the complex conjugate of `tensor` :param tensor: A tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.convert_to_tensor:1 +#: tensorcircuit.backends.numpy_backend._convert_to_tensor_numpy:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.convert_to_tensor:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.convert_to_tensor:1 +msgid "Convert a np.array or a tensor to a tensor type for the backend." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:1 +msgid "" +"Generate the coo format sparse matrix from indices and values, which is " +"the only sparse format supported in different ML backends." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:4 +msgid "shape [n, 2] for n non zero values in the returned matrix" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:6 +#: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:6 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:6 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:6 +msgid "shape [n]" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:8 +#: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:8 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:8 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:8 +msgid "Tuple[int, ...]" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix_from_numpy:1 +msgid "Generate the coo format sparse matrix from scipy coo sparse matrix." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix_from_numpy:3 +msgid "Scipy coo format sparse matrix" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix_from_numpy:5 +msgid "SparseTensor in backend format" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.copy:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.copy:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy:1 +msgid "Return the copy of ``a``, matrix exponential." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.copy:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.copy:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy:5 +msgid "matrix exponential of matrix ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cos:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cos:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos:1 +msgid "Return cos of `tensor`. :param tensor: A tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cosh:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh:1 +msgid "Return the cosh of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cosh:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh:5 +msgid "cosh of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cumsum:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:1 +msgid "Return the cumulative sum of the elements along a given axis." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.cumsum:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:5 +msgid "" +"The default behavior is the same as numpy, different from tf/torch as " +"cumsum of the flatten 1D array, defaults to None" +msgstr "" + +#: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.deserialize_tensor:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.deserialize_tensor:1 +msgid "Return a tensor given a serialized tensor string." +msgstr "" + +#: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.deserialize_tensor:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.deserialize_tensor:3 +msgid "The input string representing a serialized tensor." +msgstr "" + +#: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.deserialize_tensor:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.deserialize_tensor:5 +msgid "The tensor object represented by the string." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.device:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device:1 +msgid "get the universal device str for the tensor, in the format of tf" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.device:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.device_move:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move:3 +#: tensorcircuit.interfaces.tensortrans.which_backend:3 +msgid "the tensor" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.device:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device:5 +msgid "device str where the tensor lives on" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.device_move:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move:1 +msgid "move tensor ``a`` to device ``dev``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.device_move:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move:5 +msgid "device str or device obj in corresponding backend" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.device_move:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move:7 +msgid "the tensor on new device" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagflat:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagflat:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagflat:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagflat:1 +msgid "" +"Flattens tensor and creates a new matrix of zeros with its elements on " +"the k'th diagonal. :param tensor: A tensor. :param k: The diagonal upon " +"which to place its elements." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagflat:6 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagflat:6 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagflat:6 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagflat:6 +msgid "A new tensor with all zeros save the specified diagonal." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:1 +msgid "Return specified diagonals." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:3 +msgid "" +"If tensor is 2-D, returns the diagonal of tensor with the given offset, " +"i.e., the collection of elements of the form a[i, i+offset]. If a has " +"more than two dimensions, then the axes specified by axis1 and axis2 are " +"used to determine the 2-D sub-array whose diagonal is returned. The shape" +" of the resulting array can be determined by removing axis1 and axis2 and" +" appending an index to the right equal to the size of the resulting " +"diagonals." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:11 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:11 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:11 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:11 +msgid "" +"This function only extracts diagonals. If you wish to create diagonal " +"matrices from vectors, use diagflat." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._tensordot_tf:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:14 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.reshape:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.slice:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.tensordot:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:10 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:14 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.reshape:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tensor:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tuple:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.slice:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.tensordot:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:10 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:14 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.reshape:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tensor:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tuple:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.slice:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.tensordot:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:13 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:14 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.reshape:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tensor:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:10 +msgid "A tensor." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:15 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:11 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:11 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:15 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:15 +msgid "Offset of the diagonal from the main diagonal." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:16 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:19 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:12 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:15 +msgid "" +"Axis to be used as the first/second axis of the 2D sub-arrays from which " +"the diagonals should be taken. Defaults to second last/last axis." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:23 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:23 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:25 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:33 +msgid "" +"A dim = min(1, tensor.ndim - 2) tensor storing the " +"batched diagonals." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:25 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:25 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:27 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:35 +msgid "A dim = min(1, tensor.ndim - 2) tensor storing" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:26 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:26 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:28 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:36 +msgid "the batched diagonals." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.divide:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.divide:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.divide:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.divide:1 +msgid "" +"Return the default divide of `tensor`. A backend can override such " +"implementation. :param tensor1: A tensor. :param tensor2: A tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.dtype:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype:1 +msgid "Obtain dtype string for tensor ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.dtype:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype:3 +msgid "The tensor" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.dtype:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype:5 +msgid "dtype str, such as \"complex64\"" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh:1 +msgid "Compute eigenvectors and eigenvalues of a hermitian matrix." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh:3 +msgid "A symetric matrix." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh:5 +msgid "The eigenvalues in ascending order. Tensor: The eigenvectors." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:1 +msgid "" +"Implicitly restarted Arnoldi method for finding the lowest eigenvector-" +"eigenvalue pairs of a linear operator `A`. `A` is a function implementing" +" the matrix-vector product." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:6 +msgid "" +"WARNING: This routine uses jax.jit to reduce runtimes. jitting is " +"triggered at the first invocation of `eigs`, and on any subsequent calls " +"if the python `id` of `A` changes, even if the formal definition of `A` " +"stays the same. Example: the following will jit once at the beginning, " +"and then never again:" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:12 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:12 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:10 +msgid "```python import jax import numpy as np def A(H,x):" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:16 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:31 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:16 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:31 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:14 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:29 +msgid "return jax.np.dot(H,x)" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:19 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:19 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:17 +msgid "for n in range(100):" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:18 +msgid "" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigs(A, [H],x) #jitting is " +"triggerd only at `n=0`" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:23 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:23 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:21 +msgid "" +"The following code triggers jitting at every iteration, which results in " +"considerably reduced performance" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:26 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:26 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:24 +msgid "```python import jax import numpy as np for n in range(100):" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:30 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:30 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:28 +msgid "def A(H,x):" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:32 +msgid "" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigs(A, [H],x) #jitting is " +"triggerd at every step `n`" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:37 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:37 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:35 +msgid "" +"A (sparse) implementation of a linear operator. Call signature of `A` is " +"`res = A(vector, *args)`, where `vector` can be an arbitrary `Tensor`, " +"and `res.shape` has to be `vector.shape`." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:6 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:40 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:40 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:38 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:9 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:6 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:6 +msgid "" +"A list of arguments to `A`. `A` will be called as `res = " +"A(initial_state, *args)`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:42 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:42 +msgid "" +"An initial vector for the algorithm. If `None`, a random initial `Tensor`" +" is created using the `backend.randn` method" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:12 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:12 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:10 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:44 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:44 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:42 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:14 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:12 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:10 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:10 +msgid "The shape of the input-dimension of `A`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:45 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:45 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:43 +msgid "" +"The dtype of the input `A`. If no `initial_state` is provided, a random " +"initial state with shape `shape` and dtype `dtype` is created." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:15 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:15 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:13 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:47 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:47 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:45 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:17 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:13 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:13 +msgid "The number of iterations (number of krylov vectors)." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:48 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:48 +msgid "The number of eigenvector-eigenvalue pairs to be computed." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:49 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:49 +msgid "" +"The desired precision of the eigenvalues. For the jax backend this has " +"currently no effect, and precision of eigenvalues is not guaranteed. This" +" feature may be added at a later point. To increase precision the caller " +"can either increase `maxiter` or `num_krylov_vecs`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:53 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:53 +msgid "" +"Flag for targetting different types of eigenvalues. Currently supported " +"are `which = 'LR'` (larges real part) and `which = 'LM'` (larges " +"magnitude)." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:56 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:56 +msgid "" +"Maximum number of restarts. For `maxiter=0` the routine becomes " +"equivalent to a simple Arnoldi method." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:59 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:59 +msgid "" +"(eigvals, eigvecs) eigvals: A list of `numeig` eigenvalues eigvecs: A " +"list of `numeig` eigenvectors" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:33 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:62 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:62 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:66 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:33 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:33 +msgid "(eigvals, eigvecs)" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:62 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:62 +msgid "" +"eigvals: A list of `numeig` eigenvalues eigvecs: A list of `numeig` " +"eigenvectors" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:1 +msgid "" +"Implicitly restarted Lanczos method for finding the lowest eigenvector-" +"eigenvalue pairs of a symmetric (hermitian) linear operator `A`. `A` is a" +" function implementing the matrix-vector product." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:6 +msgid "" +"WARNING: This routine uses jax.jit to reduce runtimes. jitting is " +"triggered at the first invocation of `eigsh`, and on any subsequent calls" +" if the python `id` of `A` changes, even if the formal definition of `A` " +"stays the same. Example: the following will jit once at the beginning, " +"and then never again:" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:18 +msgid "" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigsh(A, [H],x) #jitting is " +"triggerd only at `n=0`" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:32 +msgid "" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigsh(A, [H],x) #jitting is " +"triggerd at every step `n`" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:1 +msgid "" +"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " +"hermitian linear operator `A`. `A` is a function implementing the matrix-" +"vector product. WARNING: This routine uses jax.jit to reduce runtimes. " +"jitting is triggered at the first invocation of `eigsh_lanczos`, and on " +"any subsequent calls if the python `id` of `A` changes, even if the " +"formal definition of `A` stays the same. Example: the following will jit " +"once at the beginning, and then never again:" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:16 +msgid "" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigsh_lanczos(A, [H],x) " +"#jitting is triggerd only at `n=0`" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:30 +msgid "" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigsh_lanczos(A, [H],x) " +"#jitting is triggerd at every step `n`" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:8 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:40 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:8 +msgid "" +"An initial vector for the Lanczos algorithm. If `None`, a random initial " +"`Tensor` is created using the `backend.randn` method" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:46 +msgid "" +"The number of eigenvector-eigenvalue pairs to be computed. If `numeig > " +"1`, `reorthogonalize` has to be `True`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:48 +msgid "" +"The desired precision of the eigenvalues. For the jax backend this has " +"currently no effect, and precision of eigenvalues is not guaranteed. This" +" feature may be added at a later point. To increase precision the caller " +"can increase `num_krylov_vecs`." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:20 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:52 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:20 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:20 +msgid "" +"Stopping criterion for Lanczos iteration. If a Krylov vector :math: `x_n`" +" has an L2 norm :math:`\\lVert x_n\\rVert < delta`, the iteration is " +"stopped. It means that an (approximate) invariant subspace has been " +"found." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:57 +msgid "" +"The tridiagonal Operator is diagonalized every `ndiag` iterations to " +"check convergence. This has currently no effect for the jax backend, but " +"may be added at a later point." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:27 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:60 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:27 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:27 +msgid "" +"If `True`, Krylov vectors are kept orthogonal by explicit " +"orthogonalization (more costly than `reorthogonalize=False`)" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:63 +msgid "" +"(eigvals, eigvecs) eigvals: A jax-array containing `numeig` lowest " +"eigenvalues eigvecs: A list of `numeig` lowest eigenvectors" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:66 +msgid "" +"eigvals: A jax-array containing `numeig` lowest eigenvalues eigvecs: A " +"list of `numeig` lowest eigenvectors" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh:1 +msgid "Get the eigenvalues of matrix ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh:5 +msgid "eigenvalues of ``a``" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.einsum:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.einsum:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.einsum:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.einsum:1 +msgid "Calculate sum of products of tensors according to expression." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eps:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps:1 +msgid "Return machine epsilon for given `dtype`" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eps:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps:3 +msgid "A dtype." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eps:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps:5 +msgid "Machine epsilon." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.exp:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.exp:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.exp:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.exp:1 +msgid "Return elementwise exp of `tensor`. :param tensor: A tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.expm:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.expm:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm:1 +msgid "Return expm log of `matrix`, matrix exponential. :param matrix: A tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:4 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:4 +msgid "Return an identity matrix of dimension `dim`" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:2 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:2 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:2 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:2 +msgid "" +"Depending on specific backends, `dim` has to be either an int (numpy, " +"torch, tensorflow) or a `ShapeType` object (for block-sparse backends). " +"Block-sparse behavior is currently not supported" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:6 +#: tensorcircuit.backends.jax_backend.JaxBackend.eye:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:6 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:6 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:6 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:9 +msgid "The dimension of the returned matrix." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:8 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:8 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:8 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:8 +msgid "The dtype of the returned matrix." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.from_dlpack:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.from_dlpack:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.from_dlpack:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.from_dlpack:1 +msgid "Transform a dlpack capsule to a tensor" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.from_dlpack:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.from_dlpack:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.from_dlpack:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.from_dlpack:3 +msgid "the dlpack capsule" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.gather1d:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d:1 +msgid "" +"Return ``operand[indices]``, both ``operand`` and ``indices`` are rank-1 " +"tensor." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.gather1d:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d:3 +msgid "rank-1 tensor" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.gather1d:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d:5 +msgid "rank-1 tensor with int dtype" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.gather1d:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d:7 +msgid "``operand[indices]``" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.get_random_state:1 +msgid "Get the backend specific random state object." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.get_random_state:3 +msgid "[description], defaults to be None" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.get_random_state:5 +msgid ":return:the backend specific random state object :rtype: Any" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:1 +msgid "" +"GMRES solves the linear system A @ x = b for x given a vector `b` and a " +"general (not necessarily symmetric/Hermitian) linear operator `A`." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:4 +msgid "" +"As a Krylov method, GMRES does not require a concrete matrix " +"representation of the n by n `A`, but only a function `vector1 = " +"A_mv(vector0, *A_args, **A_kwargs)` prescribing a one-to-one linear map " +"from vector0 to vector1 (that is, A must be square, and thus vector0 and " +"vector1 the same size). If `A` is a dense matrix, or if it is a " +"symmetric/Hermitian operator, a different linear solver will usually be " +"preferable." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:12 +msgid "" +"GMRES works by first constructing the Krylov basis K = (x0, A_mv@x0, " +"A_mv@A_mv@x0, ..., (A_mv^num_krylov_vectors)@x_0) and then solving a " +"certain dense linear system K @ q0 = q1 from whose solution x can be " +"approximated. For `num_krylov_vectors = n` the solution is provably exact" +" in infinite precision, but the expense is cubic in `num_krylov_vectors` " +"so one is typically interested in the `num_krylov_vectors << n` case. The" +" solution can in this case be repeatedly improved, to a point, by " +"restarting the Arnoldi iterations each time `num_krylov_vectors` is " +"reached. Unfortunately the optimal parameter choices balancing expense " +"and accuracy are difficult to predict in advance, so applying this " +"function requires a degree of experimentation." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:24 +msgid "" +"In a tensor network code one is typically interested in A_mv implementing" +" some tensor contraction. This implementation thus allows `b` and `x0` to" +" be of whatever arbitrary, though identical, shape `b = A_mv(x0, ...)` " +"expects. Reshaping to and from a matrix problem is handled internally." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:29 +msgid "" +"A function `v0 = A_mv(v, *A_args, **A_kwargs)` where `v0` and `v` have " +"the same shape." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:31 +msgid "The `b` in `A @ x = b`; it should be of the shape `A_mv` operates on." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:33 +msgid "" +"Positional arguments to `A_mv`, supplied to this interface as a list. " +"Default: None." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:36 +msgid "" +"Keyword arguments to `A_mv`, supplied to this interface as a dictionary. " +"Default: None." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:39 +msgid "" +"An optional guess solution. Zeros are used by default. If `x0` is " +"supplied, its shape and dtype must match those of `b`, or an error will " +"be thrown. Default: zeros." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:44 +#: tensornetwork.backends.abstract_backend.AbstractBackend.gmres:48 +msgid "" +"Solution tolerance to achieve, norm(residual) <= max(tol*norm(b), atol). " +"Default: tol=1E-05 atol=tol" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:44 +#: tensornetwork.backends.abstract_backend.AbstractBackend.gmres:48 +msgid "" +"Solution tolerance to achieve, norm(residual) <= max(tol*norm(b), atol). " +"Default: tol=1E-05" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:47 +#: tensornetwork.backends.abstract_backend.AbstractBackend.gmres:51 +msgid "atol=tol" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:52 +msgid "" +": Size of the Krylov space to build at each restart. Expense is cubic " +"in this parameter. It must be positive. If greater than b.size, it will" +" be set to b.size. Default: 20" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:55 +msgid ": Size of the Krylov space to build at each restart." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:54 +msgid "" +"Expense is cubic in this parameter. It must be positive. If greater than " +"b.size, it will be set to b.size. Default: 20" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:57 +msgid "" +"The Krylov space will be repeatedly rebuilt up to this many times. Large " +"values of this argument should be used only with caution, since " +"especially for nearly symmetric matrices and small `num_krylov_vectors` " +"convergence might well freeze at a value significantly larger than `tol`." +" Default: 1." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:63 +msgid "" +"Inverse of the preconditioner of A; see the docstring for " +"`scipy.sparse.linalg.gmres`. This is only supported in the numpy backend." +" Supplying this argument to other backends will trigger " +"NotImplementedError. Default: None." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:69 +msgid "" +"-if `x0` is supplied but its shape differs from that of `b`. -in " +"NumPy, if the ARPACK solver reports a breakdown (which usually " +"indicates some kind of floating point issue). -if num_krylov_vectors " +"is 0 or exceeds b.size. -if tol was negative. -if M was supplied " +"with any backend but NumPy." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.gmres:71 +msgid "" +"The converged solution. It has the same shape as `b`. info : 0 if " +"convergence was achieved, the number of restarts otherwise." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:1 +msgid "Return the function which is the grad function of input ``f``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:13 +#: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:13 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:13 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:13 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:13 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:13 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:13 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:13 +msgid "the function to be differentiated" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:15 +#: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:15 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:15 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:15 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:15 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:15 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:15 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:15 +msgid "" +"the position of args in ``f`` that are to be differentiated, defaults to " +"be 0" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:17 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:17 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:17 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:17 +msgid "the grad function of ``f`` with the same set of arguments as ``f``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.i:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.i:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:1 +msgid "Return 1.j in as a tensor compatible with the backend." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.i:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.i:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:3 +msgid "\"complex64\" or \"complex128\"" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.i:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.i:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:5 +msgid "1.j tensor" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.imag:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.imag:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag:1 +msgid "Return the elementwise imaginary value of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.imag:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.imag:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag:5 +msgid "imaginary value of ``a``" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:1 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:1 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:1 +msgid "[summary]" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:5 +msgid "The possible options" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:7 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:7 +msgid "Sampling output shape" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:9 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:9 +msgid "" +"probability for each option in a, defaults to None, as equal probability " +"distribution" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn:1 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:1 +msgid "" +"Call the random normal function with the random state management behind " +"the scene." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn:7 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu:7 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:11 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:11 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:11 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:11 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:9 +msgid "[description], defaults to 1" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randn:9 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:9 +msgid "[description], defaults to \"32\"" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update:1 +msgid "Update `tensor` at elements defined by `mask` with value `assignee`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update:3 +msgid "A `Tensor` object." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update:4 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update:4 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update:4 +msgid "A boolean mask." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update:5 +msgid "" +"A scalar `Tensor`. The values to assigned to `tensor` at positions where " +"`mask` is `True`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.inv:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv:1 +msgid "Compute the matrix inverse of `matrix`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.inv:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv:3 +msgid "A matrix." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.inv:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv:5 +msgid "The inverse of `matrix`" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:1 +msgid "Determine whether the type of input ``a`` is ``sparse``." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:3 +msgid "input matrix ``a``" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:5 +msgid "a bool indicating whether the matrix ``a`` is sparse" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:1 +msgid "Return a boolean on whether ``a`` is a tensor in backend package." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:3 +msgid "a tensor to be determined" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:5 +msgid "whether ``a`` is a tensor" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.item:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.item:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.item:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.item:1 +msgid "Return the item of a 1-element tensor." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.item:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.item:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.item:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.item:3 +msgid "A 1-element tensor" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.item:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.item:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.item:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.item:5 +msgid "The value in tensor." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.jacrev:1 +msgid "Compute the Jacobian of ``f`` using reverse mode AD." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.jacrev:3 +msgid "The function whose Jacobian is required" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.jacfwd:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.jacrev:5 +msgid "the position of the arg as Jacobian input, defaults to 0" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.jacrev:7 +msgid "outer tuple for output, inner tuple for input args" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.jacfwd:1 +msgid "Compute the Jacobian of ``f`` using the forward mode AD." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.jacfwd:3 +msgid "the function whose Jacobian is required" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.jacfwd:7 +msgid "outer tuple for input args, inner tuple for outputs" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:1 +msgid "" +"Return a jitted or graph-compiled version of `fun` for JAX backend. For " +"all other backends returns `fun`. :param fun: Callable :param args: " +"Arguments to `fun`. :param kwargs: Keyword arguments to `fun`." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:7 +msgid "jitted/graph-compiled version of `fun`, or just `fun`." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:1 +msgid "" +"Function that computes a (forward-mode) Jacobian-vector product of ``f``." +" Strictly speaking, this function is value_and_jvp." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:4 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:4 +msgid "The function to compute jvp" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:6 +#: tensorcircuit.backends.jax_backend.JaxBackend.vjp:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:6 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:6 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:6 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:7 +msgid "input for ``f``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:8 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:8 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:8 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:8 +msgid "tangents" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:10 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:10 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:10 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:10 +msgid "" +"(``f(*inputs)``, jvp_tensor), where jvp_tensor is the same shape as the " +"output of ``f``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.kron:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:1 +msgid "Return the kronecker product of two matrices ``a`` and ``b``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.kron:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:7 +msgid "kronecker product of ``a`` and ``b``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:1 +msgid "Shift the bits of an integer x to the left y bits." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.mod:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:3 +msgid "input values" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:5 +msgid "Number of bits shift to ``x``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:7 +msgid "result with the same shape as ``x``" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.log:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.log:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.log:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.log:1 +msgid "Return elementwise natural logarithm of `tensor`. :param tensor: A tensor." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._matmul_tf:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:1 +msgid "" +"Perform a possibly batched matrix-matrix multiplication between `tensor1`" +" and `tensor2`. The following behaviour is similar to `numpy.matmul`: - " +"If both arguments are 2-D they are multiplied like conventional" +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._matmul_tf:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:5 +msgid "matrices." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._matmul_tf:6 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:6 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:6 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:6 +msgid "" +"If either argument is N-D, N > 2, it is treated as a stack of matrices " +"residing in the last two indexes and broadcast accordingly." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._matmul_tf:8 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:8 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:8 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:8 +msgid "" +"Both arguments to `matmul` have to be tensors of order >= 2. :param " +"tensor1: An input tensor. :param tensor2: An input tensor." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._matmul_tf:12 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:12 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:12 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:12 +msgid "The result of performing the matmul." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.max:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.max:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:1 +msgid "Return the maximum of an array or maximum along an axis." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.max:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.min:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.max:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.min:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:5 +#: tensorcircuit.keras.QuantumLayer.__init__:11 +msgid "[description], defaults to None" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:1 +msgid "Compute the arithmetic mean for ``a`` along the specified ``axis``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:3 +msgid "tensor to take average" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:5 +msgid "the axis to take mean, defaults to None indicating sum over flatten array" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:7 +msgid "_description_, defaults to False" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.min:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.min:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:1 +msgid "Return the minimum of an array or minimum along an axis." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:1 +msgid "" +"Compute y-mod of x (negative number behavior is not guaranteed to be " +"consistent)" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:5 +msgid "mod ``y``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:7 +msgid "results" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.multiply:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.multiply:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.multiply:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.multiply:1 +msgid "Return the default multiplication of `tensor`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.multiply:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.multiply:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.multiply:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.multiply:3 +msgid "" +"A backend can override such implementation. :param tensor1: A tensor. " +":param tensor2: A tensor." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.norm:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.norm:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.norm:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.norm:1 +msgid "Calculate the L2-norm of the elements of `tensor`" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.numpy:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.numpy:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.numpy:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.numpy:1 +msgid "" +"Return the numpy array of a tensor ``a``, but may not work in a jitted " +"function." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.numpy:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.numpy:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.numpy:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.numpy:5 +msgid "numpy array of ``a``" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.one_hot:1 +msgid "See doc for :py:meth:`onehot`" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:1 +msgid "" +"One-hot encodes the given ``a``. Each index in the input ``a`` is encoded" +" as a vector of zeros of length ``num`` with the element at index set to " +"one:" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:5 +msgid "input tensor" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:7 +msgid "number of features in onehot dimension" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:9 +msgid "onehot tensor with the last extra dimension" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.ones:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.ones:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.ones:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.ones:1 +msgid "" +"Return an ones-matrix of dimension `dim` Depending on specific backends, " +"`dim` has to be either an int (numpy, torch, tensorflow) or a `ShapeType`" +" object (for block-sparse backends). Block-sparse behavior is currently " +"not supported :param shape: The dimension of the returned matrix. :type " +"shape: int :param dtype: The dtype of the returned matrix." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._outer_product_tf:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.outer_product:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.outer_product:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.outer_product:1 +msgid "Calculate the outer product of the two given tensors." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.pivot:1 +msgid "" +"Reshapes a tensor into a matrix, whose columns (rows) are the vectorized " +"dimensions to the left (right) of pivot_axis." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.pivot:4 +msgid "" +"In other words, with tensor.shape = (1, 2, 4, 5) and pivot_axis=2, this " +"function returns an (8, 5) matrix." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.pivot:7 +msgid "The tensor to pivot." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.pivot:8 +msgid "The axis about which to pivot." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.pivot:10 +msgid "The pivoted tensor." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:1 +msgid "" +"Returns the power of tensor a to the value of b. In the case b is a " +"tensor, then the power is by element" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:3 +msgid "with a as the base and b as the exponent." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:5 +msgid "In the case b is a scalar, then the power of each value in a" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:5 +msgid "is raised to the exponent of b." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:7 +msgid "The tensor that contains the base." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:8 +msgid "The tensor that contains the exponent or a single scalar." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample:1 +msgid "" +"Drawn ``shots`` samples from probability distribution p, given the " +"external randomness determined by uniform distributed ``status`` tensor " +"or backend random generator ``g``. This method is similar with " +"``stateful_randc``, but it supports ``status`` beyond ``g``, which is " +"convenient when jit or vmap" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample:6 +msgid "Number of samples to draw with replacement" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample:8 +msgid "prbability vector" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample:10 +msgid "" +"external randomness as a tensor with each element drawn uniformly from " +"[0, 1], defaults to None" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample:13 +msgid "backend random genrator, defaults to None" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.probability_sample:15 +msgid "The drawn sample as an int tensor" +msgstr "" + +#: of tensorcircuit.backends.jax_backend._qr_jax:1 +msgid "" +"Computes the QR decomposition of a tensor. See " +"tensornetwork.backends.tensorflow.decompositions for details." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.randn:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.randn:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.randn:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.randn:1 +msgid "" +"Return a random-normal-matrix of dimension `dim` Depending on specific " +"backends, `dim` has to be either an int (numpy, torch, tensorflow) or a " +"`ShapeType` object (for block-sparse backends)." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.randn:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.randn:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.randn:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.randn:5 +msgid "" +"Block-sparse behavior is currently not supported :param shape: The " +"dimension of the returned matrix. :type shape: int :param dtype: The " +"dtype of the returned matrix. :param seed: The seed for the random number" +" generator" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.random_split:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.random_split:1 +msgid "" +"A jax like split API, but it doesn't split the key generator for other " +"backends. It is just for a consistent interface of random code; make sure" +" you know what the function actually does. This function is mainly a " +"utility to write backend agnostic code instead of doing magic things." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.random_uniform:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.random_uniform:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform:1 +msgid "Return a random uniform matrix of dimension `dim`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.random_uniform:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.random_uniform:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform:3 +msgid "" +"Depending on specific backends, `dim` has to be either an int (numpy, " +"torch, tensorflow) or a `ShapeType` object (for block-sparse backends). " +"Block-sparse behavior is currently not supported :param shape: The " +"dimension of the returned matrix. :type shape: int :param boundaries: The" +" boundaries of the uniform distribution. :type boundaries: tuple :param " +"dtype: The dtype of the returned matrix. :param seed: The seed for the " +"random number generator" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:14 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.random_uniform:14 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.random_uniform:14 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform:14 +msgid "random uniform initialized tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.real:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.real:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.real:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.real:1 +msgid "Return the elementwise real value of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.real:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.real:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.real:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.real:5 +msgid "real value of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:1 +msgid "" +"Rectified linear unit activation function. Computes the element-wise " +"function:" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:4 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:4 +msgid "\\mathrm{relu}(x)=\\max(x,0)" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:11 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:11 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:11 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:11 +msgid "Tensor after relu" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.reshape:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.reshape:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.reshape:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.reshape:1 +msgid "Reshape tensor to the given shape." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.reshape:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.reshape:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.reshape:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.reshape:5 +msgid "The reshaped tensor." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.reshape2:1 +msgid "Reshape a tensor to the [2, 2, ...] shape." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.reshape2:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshapem:5 +msgid "the reshaped tensor" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.reshapem:1 +msgid "Reshape a tensor to the [l, l] shape." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.reverse:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse:1 +msgid "return ``a[::-1]``, only 1D tensor is guaranteed for consistent behavior" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.reverse:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse:3 +msgid "1D tensor" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.reverse:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse:5 +msgid "1D tensor in reverse order" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.right_shift:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:1 +msgid "Shift the bits of an integer x to the right y bits." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._rq_jax:1 +msgid "" +"Computes the RQ (reversed QR) decomposition of a tensor. See " +"tensornetwork.backends.tensorflow.decompositions for details." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.scatter:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:1 +msgid "" +"Roughly equivalent to operand[indices] = updates, indices only support " +"shape with rank 2 for now." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:1 +msgid "Find indices where elements should be inserted to maintain order." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:3 +msgid "input array sorted in ascending order" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:5 +msgid "value to inserted" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:7 +msgid "" +"If ‘left’, the index of the first suitable location found is given. If " +"‘right’, return the last such index. If there is no suitable index, " +"return either 0 or N (where N is the length of a), defaults to \"left\"" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:12 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:12 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:12 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:12 +msgid "" +"Array of insertion points with the same shape as v, or an integer if v is" +" a scalar." +msgstr "" + +#: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.serialize_tensor:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.serialize_tensor:1 +msgid "Return a string that serializes the given tensor." +msgstr "" + +#: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.serialize_tensor:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sign:7 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.serialize_tensor:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.sign:7 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.sign:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sign:7 +msgid "The input tensor." +msgstr "" + +#: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.serialize_tensor:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.serialize_tensor:5 +msgid "A string representing the serialized tensor." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.set_random_state:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:1 +msgid "Set the random state attached to the backend." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.set_random_state:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:3 +msgid "the random seed, defaults to be None" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.set_random_state:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:5 +msgid "" +"If set to be true, only get the random state in return instead of setting" +" the state on the backend" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_concat:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_concat:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_concat:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_concat:1 +msgid "Concatenate a sequence of tensors together about the given axis." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_prod:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_prod:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_prod:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_prod:1 +msgid "Take the product of all of the elements in values" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tensor:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tensor:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tensor:1 +msgid "Get the shape of a tensor." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tensor:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tensor:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tensor:5 +msgid "The shape of the input tensor returned as another tensor." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tuple:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tuple:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple:1 +msgid "Get the shape of a tensor as a tuple of integers." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tuple:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tuple:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple:5 +msgid "The shape of the input tensor returned as a tuple of ints." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.sigmoid:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid:1 +msgid "Compute sigmoid of input ``a``" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.sign:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.sign:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sign:1 +msgid "" +"Returns an elementwise tensor with entries y[i] = 1, 0, -1 where " +"tensor[i] > 0, == 0, and < 0 respectively." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.sign:4 +msgid "" +"For complex input the behaviour of this function may depend on the " +"backend. The Jax backend version returns y[i] = x[i]/sqrt(x[i]^2)." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.sin:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sin:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin:1 +msgid "Return sin of `tensor`. :param tensor: A tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.sinh:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh:1 +msgid "Return the sinh of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.sinh:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh:5 +msgid "sinh of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.size:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.size:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size:1 +msgid "Return the total number of elements in ``a`` in tensor form." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.size:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.size:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size:5 +msgid "the total number of elements in ``a``" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.sizen:1 +msgid "Return the total number of elements in tensor ``a``, but in integer form." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.sizen:5 +msgid "the total number of elements in tensor ``a``" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.slice:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.slice:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.slice:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice:1 +msgid "Obtains a slice of a tensor based on start_indices and slice_sizes." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.slice:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.slice:4 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.slice:4 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice:4 +msgid "Tuple of integers denoting start indices of slice." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.slice:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.slice:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.slice:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice:5 +msgid "Tuple of integers denoting size of slice along each axis." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:1 +msgid "" +"Softmax function. Computes the function which rescales elements to the " +"range [0,1] such that the elements along axis sum to 1." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:4 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:4 +msgid "\\mathrm{softmax}(x) = \\frac{\\exp(x_i)}{\\sum_j \\exp(x_j)}" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:11 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:11 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:11 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:11 +msgid "" +"A dimension along which Softmax will be computed , defaults to None for " +"all axis sum." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:13 +#: tensorcircuit.backends.jax_backend.JaxBackend.stack:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:13 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:13 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:13 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:7 +msgid "concatenated tensor" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:1 +msgid "Solve the linear system Ax=b and return the solution x." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:3 +msgid "The multiplied matrix." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:5 +msgid "The resulted matrix." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:7 +msgid "The solution of the linear system." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:1 +msgid "A sparse matrix multiplies a dense matrix." +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul:3 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dense:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.to_dense:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense:3 +msgid "a sparse matrix" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:5 +msgid "a dense matrix" +msgstr "" + +#: of +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:7 +msgid "dense matrix" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.sqrt:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.sqrt:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.sqrt:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sqrt:1 +msgid "Take the square root (element wise) of a given tensor." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.sqrtmh:1 +msgid "Return the sqrtm of a Hermitian matrix ``a``." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.sqrtmh:5 +msgid "sqrtm of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:1 +msgid "Concatenates a sequence of tensors ``a`` along a new dimension ``axis``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:3 +msgid "List of tensors in the same shape" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:5 +msgid "the stack axis, defaults to 0" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:5 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:3 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:3 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:3 +msgid "stateful register for each package" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:7 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:7 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:7 +msgid "shape of output sampling tensor" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:13 +#: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:11 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:13 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:11 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:13 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:11 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:13 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:11 +msgid "only real data type is supported, \"32\" or \"64\", defaults to \"32\"" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:1 +msgid "Uniform random sampler from ``low`` to ``high``." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:5 +msgid "shape of output sampling tensor, defaults to 1" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.std:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.std:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std:1 +msgid "Compute the standard deviation along the specified axis." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.std:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.std:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std:5 +msgid "" +"Axis or axes along which the standard deviation is computed, defaults to " +"None, implying all axis" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.std:8 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.std:8 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std:8 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std:8 +msgid "" +"If this is set to True, the axes which are reduced are left in the result" +" as dimensions with size one, defaults to False" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient:1 +msgid "Stop backpropagation from ``a``." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.subtraction:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.subtraction:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.subtraction:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.subtraction:1 +msgid "" +"Return the default substraction of `tensor`. A backend can override such " +"implementation. :param tensor1: A tensor. :param tensor2: A tensor." +msgstr "" + +#: of tensorcircuit.backends.numpy_backend._sum_numpy:1 +#: tensorcircuit.backends.pytorch_backend._sum_torch:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sum:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum:1 +msgid "" +"Sum elements of `tensor` along the specified `axis`. Results in a new " +"Tensor with the summed axis removed. :param tensor: An input tensor." +msgstr "" + +#: of tensorcircuit.backends.numpy_backend._sum_numpy:5 +#: tensorcircuit.backends.pytorch_backend._sum_torch:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sum:5 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum:5 +msgid "" +"The result of performing the summation. The order of the tensor will be" +" reduced by 1." +msgstr "" + +#: of tensorcircuit.backends.numpy_backend._sum_numpy:7 +#: tensorcircuit.backends.pytorch_backend._sum_torch:7 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sum:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum:7 +msgid "The result of performing the summation. The order of the tensor" +msgstr "" + +#: of tensorcircuit.backends.numpy_backend._sum_numpy:8 +#: tensorcircuit.backends.pytorch_backend._sum_torch:8 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sum:8 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum:8 +msgid "will be reduced by 1." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:1 +msgid "Computes the singular value decomposition (SVD) of a tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:3 +msgid "" +"The SVD is performed by treating the tensor as a matrix, with an " +"effective left (row) index resulting from combining the axes " +"`tensor.shape[:pivot_axis]` and an effective right (column) index " +"resulting from combining the axes `tensor.shape[pivot_axis:]`." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:8 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:8 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:8 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:8 +msgid "" +"For example, if `tensor` had a shape (2, 3, 4, 5) and `pivot_axis` was 2," +" then `u` would have shape (2, 3, 6), `s` would have shape (6), and `vh` " +"would have shape (6, 4, 5)." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:12 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:12 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:12 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:12 +msgid "" +"If `max_singular_values` is set to an integer, the SVD is truncated to " +"keep at most this many singular values." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:15 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:15 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:15 +msgid "" +"If `max_truncation_error > 0`, as many singular values will be truncated " +"as possible, so that the truncation error (the norm of discarded singular" +" values) is at most `max_truncation_error`. If `relative` is set `True` " +"then `max_truncation_err` is understood relative to the largest singular " +"value." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:21 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:21 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:21 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:21 +msgid "" +"If both `max_singular_values` and `max_truncation_error` are specified, " +"the number of retained singular values will be `min(max_singular_values, " +"nsv_auto_trunc)`, where `nsv_auto_trunc` is the number of singular values" +" that must be kept to maintain a truncation error smaller than " +"`max_truncation_error`." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:27 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:27 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:27 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:27 +msgid "The output consists of three tensors `u, s, vh` such that: ```python" +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:29 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:29 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:29 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:29 +msgid "u[i1,...,iN, j] * s[j] * vh[j, k1,...,kM] == tensor[i1,...,iN, k1,...,kM]" +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:30 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:30 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:30 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:30 +msgid "" +"``` Note that the output ordering matches numpy.linalg.svd rather than " +"tf.svd." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:33 +#: tensorcircuit.backends.pytorch_backend._qr_torch:18 +#: tensorcircuit.backends.pytorch_backend._rq_torch:18 +#: tensorcircuit.backends.tensorflow_backend._qr_tf:18 +#: tensorcircuit.backends.tensorflow_backend._rq_tf:18 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:33 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:33 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:33 +msgid "A tensor to be decomposed." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:34 +#: tensorcircuit.backends.pytorch_backend._qr_torch:20 +#: tensorcircuit.backends.pytorch_backend._rq_torch:20 +#: tensorcircuit.backends.tensorflow_backend._qr_tf:20 +#: tensorcircuit.backends.tensorflow_backend._rq_tf:20 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:34 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:34 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:34 +msgid "Where to split the tensor's axes before flattening into a matrix." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:36 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:36 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:36 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:36 +msgid "The number of singular values to keep, or `None` to keep them all." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:38 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:38 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:38 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:38 +msgid "The maximum allowed truncation error or `None` to not do any truncation." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:40 +#: tensorcircuit.cons.split_rules:7 +#: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:24 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:40 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:40 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:40 +msgid "Multiply `max_truncation_err` with the largest singular value." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:42 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:42 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:42 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:42 +msgid "" +"Left tensor factor. s: Vector of ordered singular values from largest to " +"smallest. vh: Right tensor factor. s_rest: Vector of discarded singular " +"values (length zero if no truncation)." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:42 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:42 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:42 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:42 +msgid "" +"Left tensor factor. s: Vector of ordered singular values from largest to " +"smallest. vh: Right tensor factor. s_rest: Vector of discarded singular " +"values (length zero if no" +msgstr "" + +#: of tensorcircuit.backends.jax_backend._svd_jax:46 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:46 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:46 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:46 +msgid "truncation)." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.switch:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:1 +msgid "``branches[index]()``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.tan:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tan:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan:1 +msgid "Return the tan of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.tan:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tan:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan:5 +msgid "tan of ``a``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.tanh:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tanh:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh:1 +msgid "Return the tanh of a tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.tanh:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tanh:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh:5 +msgid "tanh of ``a``" +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._tensordot_tf:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.tensordot:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.tensordot:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.tensordot:1 +msgid "Do a tensordot of tensors `a` and `b` over the given axes." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._tensordot_tf:4 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.tensordot:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.tensordot:4 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.tensordot:4 +msgid "Another tensor." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._tensordot_tf:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.tensordot:5 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.tensordot:5 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.tensordot:5 +msgid "Two lists of integers. These values are the contraction axes." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.tile:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:1 +msgid "Constructs a tensor by tiling a given tensor." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.tile:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:5 +msgid "1d tensor with length the same as the rank of ``a``" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dense:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.to_dense:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense:1 +msgid "Convert a sparse matrix to dense tensor." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dense:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.to_dense:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense:5 +msgid "the resulted dense matrix" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dlpack:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.to_dlpack:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.to_dlpack:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dlpack:1 +msgid "Transform the tensor ``a`` as a dlpack capsule" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.trace:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:1 +msgid "Return summed entries along diagonals." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.trace:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:3 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:3 +msgid "" +"If tensor is 2-D, the sum is over the diagonal of tensor with the given " +"offset, i.e., the collection of elements of the form a[i, i+offset]. If a" +" has more than two dimensions, then the axes specified by axis1 and axis2" +" are used to determine the 2-D sub-array whose diagonal is summed." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.trace:19 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:19 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:31 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:28 +msgid "The batched summed diagonals." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.transpose:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.transpose:1 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.transpose:1 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.transpose:1 +msgid "" +"Transpose a tensor according to a given permutation. By default the axes " +"are reversed. :param tensor: A tensor. :param perm: The permutation of " +"the axes." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.transpose:6 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.transpose:6 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.transpose:6 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.transpose:6 +msgid "The transposed tensor" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_flatten:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten:1 +msgid "Flatten python structure to 1D list" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_flatten:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten:3 +msgid "python structure to be flattened" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_flatten:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten:5 +msgid "" +"The 1D list of flattened structure and treedef which can be used for " +"later unflatten" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_map:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:1 +msgid "Return the new tree map with multiple arg function ``f`` through pytrees." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_map:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:3 +msgid "The function" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_map:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:5 +msgid "inputs as any python structure" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_map:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:7 +msgid "raise when neither tensorflow or jax is installed." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_map:8 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_map:8 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:8 +msgid "The new tree map with the same structure but different values." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_unflatten:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten:1 +msgid "Pack 1D list to pytree defined via ``treedef``" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_unflatten:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten:3 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten:3 +msgid "Def of pytree structure, the second return from ``tree_flatten``" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_unflatten:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten:5 +msgid "the 1D list of flattened data structure" +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.tree_unflatten:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten:7 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten:7 +msgid "Packed pytree" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.unique_with_counts:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.unique_with_counts:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts:1 +msgid "" +"Find the unique elements and their corresponding counts of the given " +"tensor ``a``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.unique_with_counts:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.unique_with_counts:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts:5 +msgid "Unique elements, corresponding counts" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:1 +msgid "Return the function which returns the value and grad of ``f``." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:17 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:17 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:17 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:17 +msgid "" +"the value and grad function of ``f`` with the same set of arguments as " +"``f``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:1 +msgid "" +"Return the VVAG function of ``f``. The inputs for ``f`` is (args[0], " +"args[1], args[2], ...), and the output of ``f`` is a scalar. Suppose " +"VVAG(f) is a function with inputs in the form (vargs[0], args[1], " +"args[2], ...), where vagrs[0] has one extra dimension than args[0] in the" +" first axis and consistent with args[0] in shape for remaining " +"dimensions, i.e. shape(vargs[0]) = [batch] + shape(args[0]). (We only " +"cover cases where ``vectorized_argnums`` defaults to 0 here for " +"demonstration). VVAG(f) returns a tuple as a value tensor with shape " +"[batch, 1] and a gradient tuple with shape: ([batch]+shape(args[argnum]) " +"for argnum in argnums). The gradient for argnums=k is defined as" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:9 +msgid "" +"g^k = \\frac{\\partial \\sum_{i\\in batch} f(vargs[0][i], args[1], " +"...)}{\\partial args[k]}" +msgstr "" + +#: of +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:13 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:13 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:13 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:13 +msgid "Therefore, if argnums=0, the gradient is reduced to" +msgstr "" + +#: of +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:15 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:15 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:15 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:15 +msgid "g^0_i = \\frac{\\partial f(vargs[0][i])}{\\partial vargs[0][i]}" +msgstr "" + +#: of +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:19 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:19 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:19 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:19 +msgid "" +", which is specifically suitable for batched VQE optimization, where " +"args[0] is the circuit parameters." +msgstr "" + +#: of +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:21 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:21 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:21 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:21 +msgid "And if argnums=1, the gradient is like" +msgstr "" + +#: of +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:23 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:23 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:23 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:23 +msgid "" +"g^1_i = \\frac{\\partial \\sum_j f(vargs[0][j], args[1])}{\\partial " +"args[1][i]}\n" +"\n" +msgstr "" + +#: of +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:26 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:26 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:26 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:26 +msgid "" +", which is suitable for quantum machine learning scenarios, where ``f`` " +"is the loss function, args[0] corresponds to the input data and args[1] " +"corresponds to the weights in the QML model." +msgstr "" + +#: of +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:33 +#: tensorcircuit.backends.jax_backend.JaxBackend.vmap:6 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:33 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:6 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:33 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:6 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:33 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:6 +msgid "" +"the args to be vectorized, these arguments should share the same batch " +"shape in the fist dimension" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:1 +msgid "" +"Function that computes the dot product between a vector v and the " +"Jacobian of the given function at the point given by the inputs. (reverse" +" mode AD relevant) Strictly speaking, this function is value_and_vjp." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:5 +msgid "the function to carry out vjp calculation" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:9 +msgid "" +"value vector or gradient from downstream in reverse mode AD the same " +"shape as return of function ``f``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:12 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:12 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:12 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:12 +msgid "(``f(*inputs)``, vjp_tensor), where vjp_tensor is the same shape as inputs" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:1 +msgid "" +"Return the vectorized map or batched version of ``f`` on the first extra " +"axis. The general interface supports ``f`` with multiple arguments and " +"broadcast in the fist dimension." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:4 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:4 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:4 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:4 +msgid "function to be broadcasted." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:9 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:9 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:9 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:9 +msgid "vmap version of ``f``" +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.zeros:1 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.zeros:1 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.zeros:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.zeros:1 +msgid "" +"Return a zeros-matrix of dimension `dim` Depending on specific backends, " +"`dim` has to be either an int (numpy, torch, tensorflow) or a `ShapeType`" +" object (for block-sparse backends)." +msgstr "" + +#: of tensorcircuit.backends.jax_backend.JaxBackend.zeros:5 +#: tensorcircuit.backends.numpy_backend.NumpyBackend.zeros:5 +#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.zeros:5 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.zeros:5 +msgid "" +"Block-sparse behavior is currently not supported :param shape: The " +"dimension of the returned matrix. :type shape: int :param dtype: The " +"dtype of the returned matrix." +msgstr "" + +#: ../../source/api/backends/numpy_backend.rst:2 +msgid "tensorcircuit.backends.numpy_backend" +msgstr "" + +#: of tensorcircuit.backends.numpy_backend:1 +msgid "Backend magic inherited from tensornetwork: numpy backend" +msgstr "" + +#: of tensorcircuit.backends.numpy_backend.NumpyBackend:1 +msgid "" +"Bases: " +":py:class:`tensornetwork.backends.numpy.numpy_backend.NumPyBackend`, " +":py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +msgstr "" + +#: of tensorcircuit.backends.numpy_backend.NumpyBackend:1 +msgid "" +"see the original backend API at `numpy backend " +"`_" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:16 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:19 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:12 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:15 +msgid "" +"Axis to be used as the first/second axis of the 2D sub-arrays from which " +"the diagonals should be taken. Defaults to second-last/last axis." +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:1 +msgid "" +"Arnoldi method for finding the lowest eigenvector-eigenvalue pairs of a " +"linear operator `A`. If no `initial_state` is provided then `shape` and " +"`dtype` are required so that a suitable initial state can be randomly " +"generated. This is a wrapper for scipy.sparse.linalg.eigs which only " +"supports a subset of the arguments of scipy.sparse.linalg.eigs." +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:8 +msgid "A (sparse) implementation of a linear operator" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:9 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:9 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:11 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:9 +msgid "" +"An initial vector for the algorithm. If `None`, a random initial `Tensor`" +" is created using the `numpy.random.randn` method." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:13 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:13 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:11 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:13 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:11 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:11 +msgid "" +"The dtype of the input `A`. If both no `initial_state` is provided, a " +"random initial state with shape `shape` and dtype `dtype` is created." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:16 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:16 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:14 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:18 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:16 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:14 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:14 +msgid "" +"The nummber of eigenvector-eigenvalue pairs to be computed. If `numeig > " +"1`, `reorthogonalize` has to be `True`." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:18 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:18 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:20 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:18 +msgid "The desired precision of the eigenvalus. Uses" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:21 +msgid "" +"['LM' | 'SM' | 'LR' | 'SR' | 'LI'] Which `k` eigenvectors and eigenvalues" +" to find: 'LM' : largest magnitude 'SM' : smallest magnitude " +"'LR' : largest real part 'SR' : smallest real part 'LI' : largest" +" imaginary part" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:21 +msgid "" +"['LM' | 'SM' | 'LR' | 'SR' | 'LI'] Which `k` eigenvectors and eigenvalues" +" to find:" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:23 +msgid "" +"'LM' : largest magnitude 'SM' : smallest magnitude 'LR' : largest real " +"part 'SR' : smallest real part 'LI' : largest imaginary part" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:28 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:28 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:28 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:28 +msgid "The maximum number of iterations." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:30 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:30 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:30 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:30 +msgid "" +"An array of `numeig` lowest eigenvalues `list`: A list of `numeig` lowest" +" eigenvectors" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:32 +msgid "`np.ndarray`" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:1 +msgid "" +"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " +"symmetric (hermitian) linear operator `A`. `A` is a callable implementing" +" the matrix-vector product. If no `initial_state` is provided then " +"`shape` and `dtype` have to be passed so that a suitable initial state " +"can be randomly generated. :param A: A (sparse) implementation of a " +"linear operator :param arsg: A list of arguments to `A`. `A` will be " +"called as" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:8 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:8 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:8 +msgid "`res = A(initial_state, *args)`." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:19 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:19 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:19 +msgid "" +"['LM' | 'SM' | 'LR' | 'SR' | 'LI' | 'SI'] Which `k` eigenvectors and " +"eigenvalues to find: 'LM' : largest magnitude 'SM' : smallest " +"magnitude 'LR' : largest real part 'SR' : smallest real part " +"'LI' : largest imaginary part 'SI' : smallest imaginary part Note " +"that not all of those might be supported by specialized backends." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:19 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:19 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:19 +msgid "" +"['LM' | 'SM' | 'LR' | 'SR' | 'LI' | 'SI'] Which `k` eigenvectors and " +"eigenvalues to find:" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:21 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:21 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:21 +msgid "" +"'LM' : largest magnitude 'SM' : smallest magnitude 'LR' : largest real " +"part 'SR' : smallest real part 'LI' : largest imaginary part 'SI' : " +"smallest imaginary part" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:27 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:27 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:27 +msgid "Note that not all of those might be supported by specialized backends." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:32 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:32 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:32 +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:12 +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor:10 +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.position:10 +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize:9 +msgid "`Tensor`" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:1 +msgid "" +"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " +"linear operator `A`. :param A: A (sparse) implementation of a linear " +"operator." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:4 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:4 +msgid "" +"Call signature of `A` is `res = A(vector, *args)`, where `vector` can be " +"an arbitrary `Tensor`, and `res.shape` has to be `vector.shape`." +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:16 +msgid "" +"The desired precision of the eigenvalus. Uses " +"`np.linalg.norm(eigvalsnew[0:numeig] - eigvalsold[0:numeig]) < tol` as " +"stopping criterion between two diagonalization steps of the tridiagonal " +"operator." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:25 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:25 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:25 +msgid "" +"The tridiagonal Operator is diagonalized every `ndiag` iterations to " +"check convergence." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:30 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:30 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:30 +msgid "" +"(eigvals, eigvecs) eigvals: A list of `numeig` lowest eigenvalues " +"eigvecs: A list of `numeig` lowest eigenvectors" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:33 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:33 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:33 +msgid "" +"eigvals: A list of `numeig` lowest eigenvalues eigvecs: A list of " +"`numeig` lowest eigenvectors" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 +msgid "Returns the exponentiation of tensor a raised to b." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:4 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:4 +msgid "If b is a tensor, then the exponentiation is element-wise" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:3 +msgid "" +"between the two tensors, with a as the base and b as the power. Note that" +" a and b must be broadcastable to the same shape if b is a tensor." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 +msgid "If b is a scalar, then the exponentiation is each value in a" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 +msgid "raised to the power of b." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:9 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:9 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:9 +msgid "The tensor containing the bases." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:10 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:10 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:10 +msgid "The tensor containing the powers; or a single scalar as the power." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:12 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:12 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:12 +msgid "" +"The tensor that is each element of a raised to the power of b. Note " +"that the shape of the returned tensor is that produced by the broadcast" +" of a and b." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:15 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:15 +msgid "The tensor that is each element of a raised to the" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:15 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:15 +msgid "" +"power of b. Note that the shape of the returned tensor is that produced " +"by the broadcast of a and b." +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.qr:1 +msgid "Computes the QR decomposition of a tensor." +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.rq:1 +msgid "Computes the RQ (reversed QR) decomposition of a tensor." +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.sign:1 +msgid "" +"Returns an elementwise tensor with entries y[i] = 1, 0, -1 tensor[i] > 0," +" == 0, and < 0 respectively." +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.sign:4 +msgid "" +"For complex input the behaviour of this function may depend on the " +"backend. The NumPy version returns y[i] = x[i]/sqrt(x[i]^2)." +msgstr "" + +#: ../../source/api/backends/pytorch_backend.rst:2 +msgid "tensorcircuit.backends.pytorch_backend" +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend:1 +msgid "Backend magic inherited from tensornetwork: pytorch backend" +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend:1 +msgid "" +"Bases: " +":py:class:`tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend`," +" :py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend:1 +msgid "" +"See the original backend API at `pytorch backend " +"`_" +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend:4 +msgid "" +"Note the functionality provided by pytorch backend is incomplete, it " +"currenly lacks native efficicent jit and vmap support." +msgstr "" + +#: of tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:16 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:20 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:16 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:24 +msgid "" +"Axis to be used as the first/second axis of the 2D sub-arrays from which " +"the diagonals should be taken. Defaults to second-last and last axis " +"(note this differs from the NumPy defaults)." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:1 +msgid "" +"Arnoldi method for finding the lowest eigenvector-eigenvalue pairs of a " +"linear operator `A`. `A` is a callable implementing the matrix-vector " +"product. If no `initial_state` is provided then `shape` and `dtype` have " +"to be passed so that a suitable initial state can be randomly generated." +" :param A: A (sparse) implementation of a linear operator :param arsg: A " +"list of arguments to `A`. `A` will be called as" +msgstr "" + +#: of +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:1 +msgid "" +"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " +"`LinearOperator` `A`. :param A: A (sparse) implementation of a linear " +"operator." +msgstr "" + +#: of +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:8 +msgid "" +"An initial vector for the Lanczos algorithm. If `None`, a random initial " +"`Tensor` is created using the `torch.randn` method" +msgstr "" + +#: of +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:16 +msgid "" +"The desired precision of the eigenvalus. Uses " +"`torch.norm(eigvalsnew[0:numeig] - eigvalsold[0:numeig]) < tol` as " +"stopping criterion between two diagonalization steps of the tridiagonal " +"operator." +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._qr_torch:1 +#: tensorcircuit.backends.tensorflow_backend._qr_tf:1 +msgid "" +"Computes the QR decomposition of a tensor. The QR decomposition is " +"performed by treating the tensor as a matrix, with an effective left " +"(row) index resulting from combining the axes `tensor.shape[:pivot_axis]`" +" and an effective right (column) index resulting from combining the axes " +"`tensor.shape[pivot_axis:]`." +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._qr_torch:9 +#: tensorcircuit.backends.tensorflow_backend._qr_tf:9 +msgid "" +"If `tensor` had a shape (2, 3, 4, 5) and `pivot_axis` was 2, then `q` " +"would have shape (2, 3, 6), and `r` would have shape (6, 4, 5). The " +"output consists of two tensors `Q, R` such that:" +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._qr_torch:14 +#: tensorcircuit.backends.pytorch_backend._rq_torch:14 +#: tensorcircuit.backends.tensorflow_backend._qr_tf:14 +#: tensorcircuit.backends.tensorflow_backend._rq_tf:14 +msgid "Q[i1,...,iN, j] * R[j, k1,...,kM] == tensor[i1,...,iN, k1,...,kM]" +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._qr_torch:16 +#: tensorcircuit.backends.pytorch_backend._rq_torch:16 +#: tensorcircuit.backends.tensorflow_backend._qr_tf:16 +#: tensorcircuit.backends.tensorflow_backend._rq_tf:16 +msgid "Note that the output ordering matches numpy.linalg.svd rather than tf.svd." +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._qr_torch:22 +#: tensorcircuit.backends.pytorch_backend._rq_torch:22 +#: tensorcircuit.backends.tensorflow_backend._qr_tf:22 +#: tensorcircuit.backends.tensorflow_backend._rq_tf:22 +msgid "a bool indicating whether the tenor is diagonal non-negative matrix." +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._qr_torch:24 +#: tensorcircuit.backends.pytorch_backend._rq_torch:24 +#: tensorcircuit.backends.tensorflow_backend._qr_tf:24 +#: tensorcircuit.backends.tensorflow_backend._rq_tf:24 +msgid "Q, the left tensor factor, and R, the right tensor factor." +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._rq_torch:1 +#: tensorcircuit.backends.tensorflow_backend._rq_tf:1 +msgid "" +"Computes the RQ decomposition of a tensor. The QR decomposition is " +"performed by treating the tensor as a matrix, with an effective left " +"(row) index resulting from combining the axes `tensor.shape[:pivot_axis]`" +" and an effective right (column) index resulting from combining the axes " +"`tensor.shape[pivot_axis:]`." +msgstr "" + +#: of tensorcircuit.backends.pytorch_backend._rq_torch:9 +#: tensorcircuit.backends.tensorflow_backend._rq_tf:9 +msgid "" +"If `tensor` had a shape (2, 3, 4, 5) and `pivot_axis` was 2, then `r` " +"would have shape (2, 3, 6), and `q` would have shape (6, 4, 5). The " +"output consists of two tensors `Q, R` such that:" +msgstr "" + +#: of tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.sign:4 +msgid "" +"For complex input the behaviour of this function may depend on the " +"backend. The PyTorch version is not implemented in this case." +msgstr "" + +#: of tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:10 +msgid "" +"In the PyTorch backend the trace is always over the main diagonal of the " +"last two entries." +msgstr "" + +#: of tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:14 +msgid "" +"Offset of the diagonal from the main diagonal. This argument is not " +"supported by the PyTorch backend and an error will be raised if they are" +" specified." +msgstr "" + +#: of tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:18 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:24 +msgid "" +"Axis to be used as the first/second axis of the 2D sub-arrays from which " +"the diagonals should be taken. Defaults to first/second axis. These " +"arguments are not supported by the PyTorch backend and an error will be " +"raised if they are specified." +msgstr "" + +#: ../../source/api/backends/tensorflow_backend.rst:2 +msgid "tensorcircuit.backends.tensorflow_backend" +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend:1 +msgid "Backend magic inherited from tensornetwork: tensorflow backend" +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend:1 +msgid "" +"Bases: " +":py:class:`tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend`," +" :py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend:1 +msgid "" +"See the original backend API at `tensorflow backend " +"`_" +msgstr "" + +#: of +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:16 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:24 +msgid "" +"Axis to be used as the first/second axis of the 2D sub-arrays from which " +"the diagonals should be taken. Defaults to second-last and last axis " +"(note this differs from the NumPy defaults). These arguments are not " +"supported in the TensorFlow backend and an error will be raised if they " +"are specified." +msgstr "" + +#: of +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:21 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:29 +msgid "" +"These arguments are not supported in the TensorFlow backend and an error " +"will be raised if they are specified." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:1 +msgid "" +"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of " +"`A`. :param A: A (sparse) implementation of a linear operator." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:16 +msgid "" +"The desired precision of the eigenvalus. Uses " +"`backend.norm(eigvalsnew[0:numeig] - eigvalsold[0:numeig]) < tol` as " +"stopping criterion between two diagonalization steps of the tridiagonal " +"operator." +msgstr "" + +#: of +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sign:4 +msgid "" +"For complex input the behaviour of this function may depend on the " +"backend. The TensorFlow version returns y[i] = x[i] / abs(x[i])." +msgstr "" + +#: of +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:11 +msgid "" +"Offset of the diagonal from the main diagonal. This argument is not " +"supported in the TensorFlow backend and an error will be raised if they " +"are specified." +msgstr "" + +#: of +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:15 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:21 +msgid "" +"Axis to be used as the first/second axis of the 2D sub-arrays from which " +"the diagonals should be taken. Defaults to first/second axis. These " +"arguments are not supported in the TensorFlow backend and an error will " +"be raised if they are specified." +msgstr "" + +#: ../../source/api/basecircuit.rst:2 +msgid "tensorcircuit.basecircuit" +msgstr "" + +#: of tensorcircuit.basecircuit:1 +msgid "Quantum circuit: common methods for all circuit classes as MixIn" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit:1 +#: tensorcircuit.mpscircuit.MPSCircuit:1 +msgid "Bases: :py:class:`tensorcircuit.abstractcircuit.AbstractCircuit`" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.amplitude:1 +msgid "" +"Returns the amplitude of the circuit given the bitstring l. For state " +"simulator, it computes :math:`\\langle l\\vert \\psi\\rangle`, for " +"density matrix simulator, it computes :math:`Tr(\\rho \\vert l\\rangle " +"\\langle 1\\vert)` Note how these two are different up to a square " +"operation." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.amplitude:16 +msgid "The bitstring of 0 and 1s." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.amplitude:18 +msgid "The amplitude of the circuit." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.copy:1 +msgid "copy all nodes and dangling edges correspondingly" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.expectation_before:1 +msgid "" +"Get the tensor network in the form of a list of nodes for the expectation" +" calculation before the real contraction" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.expectation_before:4 +#: tensorcircuit.quantum.sample2count:7 tensorcircuit.utils.benchmark:7 +msgid "_description_, defaults to True" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.get_quvector:1 +msgid "" +"Get the representation of the output state in the form of ``QuVector`` " +"while maintaining the circuit uncomputed" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.get_quvector:4 +#: tensorcircuit.mpscircuit.MPSCircuit.get_quvector:4 +msgid "``QuVector`` representation of the output state from the circuit" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.measure_jit:1 +msgid "" +"Take measurement to the given quantum lines. This method is jittable is " +"and about 100 times faster than unjit version!" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.measure_jit:4 +#: tensorcircuit.circuit.Circuit.measure_reference:16 +#: tensorcircuit.mpscircuit.MPSCircuit.measure:3 +msgid "Measure on which quantum line." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.measure_jit:6 +#: tensorcircuit.circuit.Circuit.measure_reference:17 +#: tensorcircuit.mpscircuit.MPSCircuit.measure:5 +msgid "If true, theoretical probability is also returned." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.measure_jit:8 +#: tensorcircuit.mpscircuit.MPSCircuit.measure:7 +msgid "external randomness, with shape [index], defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.measure_jit:10 +#: tensorcircuit.circuit.Circuit.measure_reference:18 +#: tensorcircuit.mpscircuit.MPSCircuit.measure:9 +msgid "The sample output and probability (optional) of the quantum line." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.perfect_sampling:1 +msgid "" +"Sampling bistrings from the circuit output based on quantum amplitudes. " +"Reference: arXiv:1201.3974." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.perfect_sampling:4 +msgid "external randomness, with shape [nqubits], defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.perfect_sampling:6 +msgid "Sampled bit string and the corresponding theoretical probability." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.probability:1 +msgid "get the 2^n length probability vector over computational basis" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.probability:3 +msgid "probability vector" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.readouterror_bs:1 +msgid "" +"Apply readout error to original probabilities of bit string and return " +"the noisy probabilities." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.readouterror_bs:10 +msgid "list of readout error for each qubits." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.readouterror_bs:12 +msgid "probabilities of bit string" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.replace_inputs:1 +msgid "Replace the input state with the circuit structure unchanged." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.replace_inputs:3 +msgid "Input wavefunction." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:1 +msgid "batched sampling from state or circuit tensor network directly" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:3 +msgid "number of samples, defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:5 +msgid "" +"if true, we sample from the final state if memory allows, True is " +"preferred, defaults to False" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:8 +msgid "readout_error, defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:10 +msgid "" +"sample format, defaults to None as backward compatibility check the doc " +"in :py:meth:`tensorcircuit.quantum.measurement_results`" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:13 +#: tensorcircuit.quantum.measurement_counts:45 +#: tensorcircuit.quantum.sample2all:10 +msgid "alias for the argument ``format``" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:15 +msgid "random generator, defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:17 +#: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:41 +#: tensorcircuit.quantum.measurement_counts:52 +msgid "" +"external randomness given by tensor uniformly from [0, 1], if set, can " +"overwrite random_generator" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample:20 +msgid "" +"List (if batch) of tuple (binary configuration tensor and corresponding " +"probability) if the format is None, and consistent with format when given" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:1 +msgid "" +"Compute the expectation with given Pauli string with measurement shots " +"numbers" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:31 +msgid "index for Pauli X, defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:33 +msgid "index for Pauli Y, defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:35 +msgid "index for Pauli Z, defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:37 +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy:15 +msgid "" +"number of measurement shots, defaults to None, indicating analytical " +"result" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:39 +#: tensorcircuit.quantum.measurement_counts:50 +msgid "random_generator, defaults to None" +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:44 +msgid "readout_error, defaults to None. Overrided if noise_conf is provided." +msgstr "" + +#: of tensorcircuit.basecircuit.BaseCircuit.to_graphviz:1 +msgid "" +"Not an ideal visualization for quantum circuit, but reserve here as a " +"general approach to show the tensornetwork [Deprecated, use " +"``Circuit.vis_tex`` or ``Circuit.draw`` instead]" +msgstr "" + +#: ../../source/api/channels.rst:2 +msgid "tensorcircuit.channels" +msgstr "" + +#: of tensorcircuit.channels:1 +msgid "Some common noise quantum channels." +msgstr "" + +#: of tensorcircuit.channels.KrausList:1 +msgid "Bases: :py:class:`list`" +msgstr "" + +#: of tensorcircuit.channels.KrausList.append:1 +msgid "Append object to the end of the list." +msgstr "" + +#: of tensorcircuit.channels.KrausList.clear:1 +msgid "Remove all items from list." +msgstr "" + +#: of tensorcircuit.channels.KrausList.copy:1 +msgid "Return a shallow copy of the list." +msgstr "" + +#: of tensorcircuit.channels.KrausList.count:1 +msgid "Return number of occurrences of value." +msgstr "" + +#: of tensorcircuit.channels.KrausList.extend:1 +msgid "Extend list by appending elements from the iterable." +msgstr "" + +#: of tensorcircuit.channels.KrausList.index:1 +msgid "Return first index of value." +msgstr "" + +#: of tensorcircuit.channels.KrausList.index:3 +#: tensorcircuit.channels.KrausList.remove:3 +msgid "Raises ValueError if the value is not present." +msgstr "" + +#: of tensorcircuit.channels.KrausList.insert:1 +msgid "Insert object before index." +msgstr "" + +#: of tensorcircuit.channels.KrausList.pop:1 +msgid "Remove and return item at index (default last)." +msgstr "" + +#: of tensorcircuit.channels.KrausList.pop:3 +msgid "Raises IndexError if list is empty or index is out of range." +msgstr "" + +#: of tensorcircuit.channels.KrausList.remove:1 +msgid "Remove first occurrence of value." +msgstr "" + +#: of tensorcircuit.channels.KrausList.reverse:1 +msgid "Reverse *IN PLACE*." +msgstr "" + +#: of tensorcircuit.channels.KrausList.sort:1 +msgid "Sort the list in ascending order and return None." +msgstr "" + +#: of tensorcircuit.channels.KrausList.sort:3 +msgid "" +"The sort is in-place (i.e. the list itself is modified) and stable (i.e. " +"the order of two equal elements is maintained)." +msgstr "" + +#: of tensorcircuit.channels.KrausList.sort:6 +msgid "" +"If a key function is given, apply it once to each list item and sort " +"them, ascending or descending, according to their function values." +msgstr "" + +#: of tensorcircuit.channels.KrausList.sort:9 +msgid "The reverse flag can be set to sort in descending order." +msgstr "" + +#: of tensorcircuit.channels.amplitudedampingchannel:1 +msgid "" +"Return an amplitude damping channel. Notice: Amplitude damping " +"corrspondings to p = 1." +msgstr "" + +#: of tensorcircuit.channels.amplitudedampingchannel:4 +msgid "" +"\\sqrt{p}\n" +"\\begin{bmatrix}\n" +" 1 & 0\\\\\n" +" 0 & \\sqrt{1-\\gamma}\\\\\n" +"\\end{bmatrix}\\qquad\n" +"\\sqrt{p}\n" +"\\begin{bmatrix}\n" +" 0 & \\sqrt{\\gamma}\\\\\n" +" 0 & 0\\\\\n" +"\\end{bmatrix}\\qquad\n" +"\\sqrt{1-p}\n" +"\\begin{bmatrix}\n" +" \\sqrt{1-\\gamma} & 0\\\\\n" +" 0 & 1\\\\\n" +"\\end{bmatrix}\\qquad\n" +"\\sqrt{1-p}\n" +"\\begin{bmatrix}\n" +" 0 & 0\\\\\n" +" \\sqrt{\\gamma} & 0\\\\\n" +"\\end{bmatrix}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.amplitudedampingchannel:31 +msgid "the damping parameter of amplitude (:math:`\\gamma`)" +msgstr "" + +#: of tensorcircuit.channels.amplitudedampingchannel:33 +msgid ":math:`p`" +msgstr "" + +#: of tensorcircuit.channels.amplitudedampingchannel:35 +msgid "An amplitude damping channel with given :math:`\\gamma` and :math:`p`" +msgstr "" + +#: of tensorcircuit.channels.check_rep_transformation:1 +msgid "Check the convertation between those representations." +msgstr "" + +#: of tensorcircuit.channels.check_rep_transformation:3 +#: tensorcircuit.channels.kraus_to_super:23 +#: tensorcircuit.channels.kraus_to_super_gate:6 +msgid "A sequence of Gate" +msgstr "" + +#: of tensorcircuit.channels.check_rep_transformation:5 +#: tensorcircuit.channels.evol_kraus:13 tensorcircuit.channels.evol_superop:11 +msgid "Initial density matrix" +msgstr "" + +#: of tensorcircuit.channels.check_rep_transformation:7 +msgid "Whether print Kraus and new Kraus operators, defaults to False" +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:1 +msgid "Convert the Choi matrix representation to Kraus operator representation." +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:3 +msgid "This can be done by firstly geting eigen-decomposition of Choi-matrix" +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:5 +msgid "" +"\\Lambda = \\sum_k \\gamma_k \\vert \\phi_k \\rangle \\langle \\phi_k " +"\\vert\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:8 +msgid "Then define Kraus operators" +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:10 +msgid "" +"K_k = \\sqrt{\\gamma_k} V_k\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:13 +msgid "" +"where :math:`\\gamma_k\\geq0` and :math:`\\phi_k` is the col-val " +"vectorization of :math:`V_k` ." +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus tensorcircuit.channels.evol_kraus +#: tensorcircuit.channels.evol_superop +#: tensorcircuit.channels.kraus_identity_check +#: tensorcircuit.channels.kraus_to_super tensorcircuit.channels.super_to_choi +msgid "Examples" +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:24 +#: tensorcircuit.channels.choi_to_super:3 +#: tensorcircuit.channels.kraus_to_choi:5 +#: tensorcircuit.channels.super_to_choi:28 +msgid "Choi matrix" +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:26 +msgid "" +"A dictionary to restrict the calculation of kraus matrices. The " +"restriction can be the number of kraus terms, which is jitable. It can " +"also be the truncattion error, which is not jitable." +msgstr "" + +#: of tensorcircuit.channels.choi_to_kraus:29 +#: tensorcircuit.channels.krausgate_to_krausmatrix:5 +#: tensorcircuit.channels.krausmatrix_to_krausgate:5 +msgid "A list of Kraus operators" +msgstr "" + +#: of tensorcircuit.channels.choi_to_super:1 +msgid "Convert from Choi representation to Superoperator representation." +msgstr "" + +#: of tensorcircuit.channels.choi_to_super:5 +#: tensorcircuit.channels.evol_superop:13 +#: tensorcircuit.channels.super_to_choi:26 +#: tensorcircuit.channels.super_to_kraus:3 +msgid "Superoperator" +msgstr "" + +#: of tensorcircuit.channels.composedkraus:1 +msgid "Compose the noise channels" +msgstr "" + +#: of tensorcircuit.channels.composedkraus:3 +msgid "One noise channel" +msgstr "" + +#: of tensorcircuit.channels.composedkraus:5 +msgid "Another noise channel" +msgstr "" + +#: of tensorcircuit.channels.composedkraus:7 +msgid "Composed nosie channel" +msgstr "" + +#: of tensorcircuit.channels.depolarizingchannel:1 +msgid "Return a Depolarizing Channel" +msgstr "" + +#: of tensorcircuit.channels.depolarizingchannel:3 +msgid "" +"\\sqrt{1-p_x-p_y-p_z}\n" +"\\begin{bmatrix}\n" +" 1 & 0\\\\\n" +" 0 & 1\\\\\n" +"\\end{bmatrix}\\qquad\n" +"\\sqrt{p_x}\n" +"\\begin{bmatrix}\n" +" 0 & 1\\\\\n" +" 1 & 0\\\\\n" +"\\end{bmatrix}\\qquad\n" +"\\sqrt{p_y}\n" +"\\begin{bmatrix}\n" +" 0 & -1j\\\\\n" +" 1j & 0\\\\\n" +"\\end{bmatrix}\\qquad\n" +"\\sqrt{p_z}\n" +"\\begin{bmatrix}\n" +" 1 & 0\\\\\n" +" 0 & -1\\\\\n" +"\\end{bmatrix}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.depolarizingchannel:30 +msgid ":math:`p_x`" +msgstr "" + +#: of tensorcircuit.channels.depolarizingchannel:32 +msgid ":math:`p_y`" +msgstr "" + +#: of tensorcircuit.channels.depolarizingchannel:34 +msgid ":math:`p_z`" +msgstr "" + +#: of tensorcircuit.channels.depolarizingchannel:36 +#: tensorcircuit.channels.generaldepolarizingchannel:15 +msgid "Sequences of Gates" +msgstr "" + +#: of tensorcircuit.channels.evol_kraus:1 +msgid "The dynamic evolution according to Kraus operators." +msgstr "" + +#: of tensorcircuit.channels.evol_kraus:3 +msgid "" +"\\rho' = \\sum_{k} K_k \\rho K_k^{\\dagger}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.evol_kraus:15 +#: tensorcircuit.channels.super_to_kraus:5 +msgid "A list of Kraus operator" +msgstr "" + +#: of tensorcircuit.channels.evol_kraus:17 +#: tensorcircuit.channels.evol_superop:15 +msgid "Final density matrix" +msgstr "" + +#: of tensorcircuit.channels.evol_superop:1 +msgid "The dynamic evolution according to Superoperator." +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:1 +msgid "Return a Depolarizing Channel for 1 qubit or 2 qubits" +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:11 +msgid "parameter for each Pauli channel" +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:13 +msgid "number of qubits, 1 and 2 are avaliable, defaults 1" +msgstr "" + +#: of tensorcircuit.channels.is_hermitian_matrix:1 +msgid "Test if an array is a Hermitian matrix" +msgstr "" + +#: of tensorcircuit.channels.is_hermitian_matrix:3 +msgid "Matrix" +msgstr "" + +#: of tensorcircuit.channels.is_hermitian_matrix:5 +msgid "_description_, defaults to 1e-8" +msgstr "" + +#: of tensorcircuit.channels.is_hermitian_matrix:7 +msgid "_description_, defaults to 1e-5" +msgstr "" + +#: of tensorcircuit.channels.kraus_identity_check:1 +msgid "Check identity of Kraus operators." +msgstr "" + +#: of tensorcircuit.channels.kraus_identity_check:3 +msgid "" +"\\sum_{k}^{} K_k^{\\dagger} K_k = I\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.kraus_identity_check:12 +msgid "List of Kraus operators." +msgstr "" + +#: of tensorcircuit.channels.kraus_to_choi:1 +msgid "Convert from Kraus representation to Choi representation." +msgstr "" + +#: of tensorcircuit.channels.kraus_to_choi:3 +msgid "A list Kraus operators" +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super:1 +msgid "" +"Convert Kraus operator representation to Louivile-Superoperator " +"representation." +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super:3 +msgid "" +"In the col-vec basis, the evolution of a state :math:`\\rho` in terms of " +"tensor components of superoperator :math:`\\varepsilon` can be expressed " +"as" +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super:6 +msgid "" +"\\rho'_{mn} = \\sum_{\\mu \\nu}^{} \\varepsilon_{nm,\\nu \\mu} " +"\\rho_{\\mu \\nu}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super:9 +msgid "" +"The superoperator :math:`\\varepsilon` must make the dynamic map from " +":math:`\\rho` to :math:`\\rho'` to satisfy hermitian-perserving (HP), " +"trace-preserving (TP), and completely positive (CP)." +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super:12 +msgid "We can construct the superoperator from Kraus operators by" +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super:14 +msgid "" +"\\varepsilon = \\sum_{k} K_k^{*} \\otimes K_k\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super:25 +msgid "The corresponding Tensor of Superoperator" +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super_gate:1 +msgid "Convert Kraus operators to one Tensor (as one Super Gate)." +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super_gate:3 +msgid "" +"\\sum_{k}^{} K_k \\otimes K_k^{*}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.kraus_to_super_gate:8 +msgid "The corresponding Tensor of the list of Kraus operators" +msgstr "" + +#: of tensorcircuit.channels.krausgate_to_krausmatrix:1 +msgid "Convert Kraus of Gate form to Matrix form." +msgstr "" + +#: of tensorcircuit.channels.krausgate_to_krausmatrix:3 +#: tensorcircuit.channels.krausmatrix_to_krausgate:3 +msgid "A list of Kraus" +msgstr "" + +#: of tensorcircuit.channels.krausmatrix_to_krausgate:1 +msgid "Convert Kraus of Matrix form to Gate form." +msgstr "" + +#: of tensorcircuit.channels.phasedampingchannel:1 +msgid "Return a phase damping channel with given :math:`\\gamma`" +msgstr "" + +#: of tensorcircuit.channels.phasedampingchannel:3 +msgid "" +"\\begin{bmatrix}\n" +" 1 & 0\\\\\n" +" 0 & \\sqrt{1-\\gamma}\\\\\n" +"\\end{bmatrix}\\qquad\n" +"\\begin{bmatrix}\n" +" 0 & 0\\\\\n" +" 0 & \\sqrt{\\gamma}\\\\\n" +"\\end{bmatrix}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.phasedampingchannel:18 +msgid "The damping parameter of phase (:math:`\\gamma`)" +msgstr "" + +#: of tensorcircuit.channels.phasedampingchannel:20 +msgid "A phase damping channel with given :math:`\\gamma`" +msgstr "" + +#: of tensorcircuit.channels.resetchannel:1 +#: tensorcircuit.channels.resetchannel:18 +msgid "Reset channel" +msgstr "" + +#: of tensorcircuit.channels.resetchannel:3 +msgid "" +"\\begin{bmatrix}\n" +" 1 & 0\\\\\n" +" 0 & 0\\\\\n" +"\\end{bmatrix}\\qquad\n" +"\\begin{bmatrix}\n" +" 0 & 1\\\\\n" +" 0 & 0\\\\\n" +"\\end{bmatrix}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.reshuffle:1 +msgid "Reshuffle the dimension index of a matrix." +msgstr "" + +#: of tensorcircuit.channels.reshuffle:3 +msgid "Input matrix" +msgstr "" + +#: of tensorcircuit.channels.reshuffle:5 +msgid "required order" +msgstr "" + +#: of tensorcircuit.channels.reshuffle:7 +msgid "Reshuffled matrix" +msgstr "" + +#: of tensorcircuit.channels.super_to_choi:1 +msgid "Convert Louivile-Superoperator representation to Choi representation." +msgstr "" + +#: of tensorcircuit.channels.super_to_choi:3 +msgid "" +"In the col-vec basis, the evolution of a state :math:`\\rho` in terms of " +"Choi matrix :math:`\\Lambda` can be expressed as" +msgstr "" + +#: of tensorcircuit.channels.super_to_choi:6 +msgid "" +"\\rho'_{mn} = \\sum_{\\mu,\\nu}^{} \\Lambda_{\\mu m,\\nu n} \\rho_{\\mu " +"\\nu}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.super_to_choi:9 +msgid "" +"The Choi matrix :math:`\\Lambda` must make the dynamic map from " +":math:`\\rho` to :math:`\\rho'` to satisfy hermitian-perserving (HP), " +"trace-preserving (TP), and completely positive (CP)." +msgstr "" + +#: of tensorcircuit.channels.super_to_choi:12 +msgid "" +"Interms of tensor components we have the relationship of Louivile-" +"Superoperator representation and Choi representation" +msgstr "" + +#: of tensorcircuit.channels.super_to_choi:15 +msgid "" +"\\Lambda_{mn,\\mu \\nu} = \\varepsilon_{\\nu n,\\mu m}\n" +"\n" +msgstr "" + +#: of tensorcircuit.channels.super_to_kraus:1 +msgid "Convert from Superoperator representation to Kraus representation." +msgstr "" + +#: of tensorcircuit.channels.thermalrelaxationchannel:1 +msgid "Return a thermal_relaxation_channel" +msgstr "" + +#: of tensorcircuit.channels.thermalrelaxationchannel:9 +msgid "the T1 relaxation time." +msgstr "" + +#: of tensorcircuit.channels.thermalrelaxationchannel:11 +msgid "the T2 dephasing time." +msgstr "" + +#: of tensorcircuit.channels.thermalrelaxationchannel:13 +msgid "gate time" +msgstr "" + +#: of tensorcircuit.channels.thermalrelaxationchannel:15 +msgid "" +"method to express error (default: \"ByChoi\"). When :math:`T1>T2`, choose" +" method \"ByKraus\" or \"ByChoi\" for jit. When :math:`T1.apply:1 +msgid "" +"Apply **ANY** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.any_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:4 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:5 +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:4 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:4 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:4 +msgid "Qubit number that the gate applies on." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:6 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:7 +msgid "Parameters for the gate." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **CNOT** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.cnot_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" +" 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & " +"1.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "Qubit number that the gate applies on. The matrix for the gate is" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\\\ " +"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **CPHASE** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.cphase_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **CR** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.cr_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **CRX** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.crx_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **CRY** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.cry_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **CRZ** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.crz_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **CU** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.cu_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **CY** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.cy_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" +" 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & " +"0.-1.j\\\\ 0.+0.j & 0.+0.j & 0.+1.j & 0.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.-1.j\\\\ " +"0.+0.j & 0.+0.j & 0.+1.j & 0.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **CZ** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.cz_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" +" 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & " +"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & -1.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " +"0.+0.j & 0.+0.j & 0.+0.j & -1.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **EXP** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.exp_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **EXP1** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.exp1_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **FREDKIN** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.fredkin_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & " +"1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" +" 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & " +"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & " +"0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j &" +" 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & " +"1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\" +" 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j" +" \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **H** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.h_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 0.70710677+0.j & 0.70710677+0.j\\\\ " +"0.70710677+0.j & -0.70710677+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 0.70710677+0.j & 0.70710677+0.j\\\\ 0.70710677+0.j" +" & -0.70710677+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **I** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.i_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j " +"\\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **ISWAP** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.iswap_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply mpo gate in MPO format on the circuit. See " +":py:meth:`tensorcircuit.gates.mpo_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply multicontrol gate in MPO format on the circuit. See " +":py:meth:`tensorcircuit.gates.multicontrol_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **ORX** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.orx_gate`." +msgstr "" -#: of tensorcircuit.applications.vqes.VQNHE.plain_evaluation:1 -msgid "VQE" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **ORY** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.ory_gate`." msgstr "" -#: ../../source/api/backends.rst:2 -msgid "tensorcircuit.backends" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **ORZ** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.orz_gate`." msgstr "" -#: ../../source/api/backends/backend_factory.rst:2 -msgid "tensorcircuit.backends.backend_factory" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **OX** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.ox_gate`." msgstr "" -#: of tensorcircuit.backends.backend_factory:1 -msgid "Backend register" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\" +" 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & " +"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.backend_factory.get_backend:1 -msgid "Get the `tc.backend` object." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 1.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " +"0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.backend_factory.get_backend:3 -msgid "\"numpy\", \"tensorflow\", \"jax\", \"pytorch\"" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **OY** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.oy_gate`." msgstr "" -#: of tensorcircuit.backends.backend_factory.get_backend -#: tensorcircuit.backends.jax_backend.JaxBackend.tree_map -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map -#: tensorcircuit.circuit.Circuit.expectation tensorcircuit.circuit.expectation -#: tensorcircuit.cons.get_contractor tensorcircuit.cons.set_contractor -#: tensorcircuit.gates.bmatrix tensorcircuit.keras.load_func -#: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate -#: tensorcircuit.quantum.QuOperator.__init__ -#: tensorcircuit.quantum.QuOperator.eval -#: tensorcircuit.quantum.QuOperator.eval_matrix -#: tensorcircuit.quantum.check_spaces -msgid "Raises" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 0.+0.j & 0.-1.j & 0.+0.j & 0.+0.j\\\\" +" 0.+1.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & " +"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.backend_factory.get_backend:5 -msgid "Backend doesn't exist for `backend` argument." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 0.+0.j & 0.-1.j & 0.+0.j & 0.+0.j\\\\ 0.+1.j & " +"0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " +"0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.backend_factory.get_backend:6 -#: tensorcircuit.cons.set_tensornetwork_backend:32 -msgid "The `tc.backend` object that with all registered universal functions." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **OZ** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.oz_gate`." msgstr "" -#: ../../source/api/backends/jax_backend.rst:2 -msgid "tensorcircuit.backends.jax_backend" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" +" 0.+0.j & -1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & " +"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend:1 -msgid "Backend magic inherited from tensornetwork: jax backend" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"-1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\" +" 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend:1 -msgid "Bases: :py:class:`tensornetwork.backends.jax.jax_backend.JaxBackend`" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **PHASE** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.phase_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend:1 +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 msgid "" -"See the original backend API at `jax backend " -"`_" +"Apply **R** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.r_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.abs:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.abs:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs:1 -msgid "Returns the elementwise absolute value of tensor. Args:" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **RX** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.rx_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.abs:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.abs:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs:3 -msgid "tensor: An input tensor." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **RXX** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.rxx_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.abs:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.abs:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs:5 -msgid "tensor: Its elementwise absolute value." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **RY** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.ry_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acos:1 -#: tensorcircuit.backends.jax_backend.JaxBackend.asin:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.acos:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.asin:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asin:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asin:1 -msgid "Return the acos of a tensor ``a``." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **RYY** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.ryy_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acos:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.acosh:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.asin:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.asinh:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.atan:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.atan2:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.copy:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.cos:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.cosh:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.expm:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.kron:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.kron:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.numpy:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.sin:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.sinh:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.tan:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.tanh:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.acos:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.asin:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.copy:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cos:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.expm:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.numpy:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sin:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tan:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tanh:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asin:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.numpy:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asin:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.numpy:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh:3 -msgid "tensor in matrix form" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **RZ** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.rz_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **RZZ** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.rzz_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **S** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.s_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+1.j " +"\\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+1.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **SD** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.sd_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.-1.j " +"\\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.-1.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **SWAP** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.swap_gate`." +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" +" 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & " +"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"0.+0.j & 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ " +"0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +msgstr "" + +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **T** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.t_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acos:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.acos:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos:5 -msgid "acos of ``a``" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j " +"& 0.70710677+0.70710677j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acosh:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh:1 -msgid "Return the acosh of a tensor ``a``." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j & " +"0.70710677+0.70710677j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acosh:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh:5 -msgid "acosh of ``a``" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **TD** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.td_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:1 -msgid "Values are generated within the half-open interval [start, stop)" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j " +"& 0.70710677-0.70710677j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:3 -msgid "start index" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j & " +"0.70710677-0.70710677j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:5 -msgid "end index, defaults to None" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **TOFFOLI** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.toffoli_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:7 -msgid "steps, defaults to 1" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & " +"1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" +" 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & " +"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " +"0.+0.j & 1.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " +"0.+0.j & 1.+0.j & 0.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:9 -#: tensorcircuit.backends.jax_backend.JaxBackend.mean:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:9 -#: tensorcircuit.cons.runtime_contractor:3 -#: tensorcircuit.cons.set_function_contractor:3 -#: tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph:6 -#: tensorcircuit.utils.benchmark:3 tensorcircuit.utils.benchmark:9 -msgid "_description_" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j &" +" 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & " +"1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & " +"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ " +"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\\\" +" 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j" +" \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.argmax:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:1 -msgid "Return the index of maximum of an array an axis." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +msgid "" +"Apply **U** gate with parameters on the circuit. See " +":py:meth:`tensorcircuit.gates.u_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.argmax:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.argmin:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:5 -msgid "[description], defaults to 0, different behavior from numpy defaults!" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **WROOT** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.wroot_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.argmin:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:1 -msgid "Return the index of minimum of an array an axis." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 0.70710677+0.j & -0.5 & -0.5j\\\\ " +"0.5 & -0.5j & 0.70710677+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.asin:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.asin:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asin:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asin:5 -msgid "asin of ``a``" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "" +"\\begin{bmatrix} 0.70710677+0.j & -0.5 & -0.5j\\\\ 0.5 & -0.5j & " +"0.70710677+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.asinh:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh:1 -msgid "Return the asinh of a tensor ``a``." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **X** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.x_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.asinh:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh:5 -msgid "asinh of ``a``" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 0.+0.j & 1.+0.j\\\\ 1.+0.j & 0.+0.j " +"\\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atan:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan:1 -msgid "Return the atan of a tensor ``a``." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "\\begin{bmatrix} 0.+0.j & 1.+0.j\\\\ 1.+0.j & 0.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atan:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan:5 -msgid "atan of ``a``" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **Y** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.y_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atan2:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2:1 -msgid "Return the atan of a tensor ``y``/``x``." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 0.+0.j & 0.-1.j\\\\ 0.+1.j & 0.+0.j " +"\\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atan2:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2:5 -msgid "atan2 of ``a``" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "\\begin{bmatrix} 0.+0.j & 0.-1.j\\\\ 0.+1.j & 0.+0.j \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:1 -msgid "Cast the tensor dtype of a ``a``." +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +msgid "" +"Apply **Z** gate on the circuit. See " +":py:meth:`tensorcircuit.gates.z_gate`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.imag:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.real:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.size:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.imag:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.real:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.size:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.real:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.real:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size:3 -msgid "tensor" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +msgid "" +"Qubit number that the gate applies on. The matrix for the gate is .. " +"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & -1.+0.j" +" \\end{bmatrix}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:5 -msgid "\"float32\", \"float64\", \"complex64\", \"complex128\"" +#: of +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & -1.+0.j \\end{bmatrix}" +msgstr "" + +#: of tensorcircuit.circuit.Circuit.__init__:1 +msgid "Circuit object based on state simulator." +msgstr "" + +#: of tensorcircuit.circuit.Circuit.__init__:3 +#: tensorcircuit.mpscircuit.MPSCircuit.__init__:3 +msgid "The number of qubits in the circuit." +msgstr "" + +#: of tensorcircuit.circuit.Circuit.__init__:5 +msgid "" +"If not None, the initial state of the circuit is taken as ``inputs`` " +"instead of :math:`\\vert 0\\rangle^n` qubits, defaults to None." +msgstr "" + +#: of tensorcircuit.circuit.Circuit.__init__:8 +msgid "QuVector for a MPS like initial wavefunction." +msgstr "" + +#: of tensorcircuit.circuit.Circuit.__init__:10 +#: tensorcircuit.densitymatrix.DMCircuit.__init__:15 +msgid "" +"dict if two qubit gate is ready for split, including parameters for at " +"least one of ``max_singular_values`` and ``max_truncation_err``." +msgstr "" + +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:1 +msgid "" +"Apply amplitudedamping quantum channel on the circuit. See " +":py:meth:`tensorcircuit.channels.amplitudedampingchannel`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:7 -msgid "``a`` of new dtype" +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:6 +msgid "uniform external random number between 0 and 1" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.concat:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.concat:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.concat:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.concat:1 -msgid "Join a sequence of arrays along an existing axis." +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:8 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:6 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:6 +msgid "Parameters for the channel." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.concat:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:9 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:31 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.concat:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:31 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.concat:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:31 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.concat:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:31 -msgid "[description], defaults to 0" +#: of tensorcircuit.circuit.Circuit.general_kraus:1 +msgid "" +"Monte Carlo trajectory simulation of general Kraus channel whose Kraus " +"operators cannot be amplified to unitary operators. For unitary operators" +" composed Kraus channel, :py:meth:`unitary_kraus` is much faster." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cond:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:1 +#: of tensorcircuit.circuit.Circuit.general_kraus:5 msgid "" -"The native cond for XLA compiling, wrapper for ``tf.cond`` and limited " -"functionality of ``jax.lax.cond``." +"This function is jittable in theory. But only jax+GPU combination is " +"recommended for jit since the graph building time is too long for other " +"backend options; though the running time of the function is very fast for" +" every case." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.convert_to_tensor:1 -msgid "Convert a np.array or a tensor to a tensor type for the backend." +#: of tensorcircuit.circuit.Circuit.general_kraus:9 +msgid "A list of ``tn.Node`` for Kraus operators." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:1 -msgid "" -"Generate the coo format sparse matrix from indices and values, which is " -"the only sparse format supported in different ML backends." +#: of tensorcircuit.circuit.Circuit.general_kraus:11 +msgid "The qubits index that Kraus channel is applied on." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:4 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:4 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:4 -msgid "shape [n, 2] for n non zero values in the returned matrix" +#: of tensorcircuit.circuit.Circuit.general_kraus:13 +msgid "" +"Random tensor uniformly between 0 or 1, defaults to be None, when the " +"random number will be generated automatically" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:6 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:6 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:6 -msgid "shape [n]" +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:1 +msgid "" +"Apply depolarizing quantum channel on the circuit. See " +":py:meth:`tensorcircuit.channels.depolarizingchannel`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:8 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:8 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:8 -msgid "Tuple[int, ...]" +#: of tensorcircuit.circuit.Circuit.depolarizing_reference:1 +msgid "" +"Apply depolarizing channel in a Monte Carlo way, i.e. for each call of " +"this method, one of gates from X, Y, Z, I are applied on the circuit " +"based on the probability indicated by ``px``, ``py``, ``pz``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.copy:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.copy:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy:1 -msgid "Return the expm of ``a``, matrix exponential." +#: of tensorcircuit.circuit.Circuit.depolarizing_reference:6 +msgid "The qubit that depolarizing channel is on" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.copy:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.expm:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.copy:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.expm:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm:5 -msgid "matrix exponential of matrix ``a``" +#: of tensorcircuit.circuit.Circuit.depolarizing_reference:8 +msgid "probability for X noise" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cos:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cos:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos:1 -msgid "Return the cosine of a tensor ``a``." +#: of tensorcircuit.circuit.Circuit.depolarizing_reference:10 +msgid "probability for Y noise" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cos:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cos:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos:5 -msgid "cosine of ``a``" +#: of tensorcircuit.circuit.Circuit.depolarizing_reference:12 +msgid "probability for Z noise" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cosh:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh:1 -msgid "Return the cosh of a tensor ``a``." +#: of tensorcircuit.circuit.Circuit.depolarizing_reference:14 +msgid "random seed uniformly from 0 to 1, defaults to None (generated implicitly)" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cosh:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh:5 -msgid "cosh of ``a``" +#: of tensorcircuit.circuit.Circuit.depolarizing_reference:16 +msgid "int Tensor, the element lookup: [0: x, 1: y, 2: z, 3: I]" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cumsum:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:1 -msgid "Return the cumulative sum of the elements along a given axis." +#: of tensorcircuit.circuit.Circuit.expectation:1 +#: tensorcircuit.densitymatrix.DMCircuit.expectation:1 +msgid "Compute the expectation of corresponding operators." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cumsum:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:5 +#: of tensorcircuit.circuit.Circuit.expectation:24 +#: tensorcircuit.densitymatrix.DMCircuit.expectation:3 msgid "" -"The default behavior is the same as numpy, different from tf/torch as " -"cumsum of the flatten 1D array, defaults to None" +"Operator and its position on the circuit, eg. ``(tc.gates.z(), [1, ]), " +"(tc.gates.x(), [2, ])`` is for operator :math:`Z_1X_2`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh:1 -msgid "Get the eigenvalues of matrix ``a``." +#: of tensorcircuit.circuit.Circuit.expectation:27 +#: tensorcircuit.mpscircuit.MPSCircuit.expectation:6 +msgid "" +"If True, then the wavefunction tensor is cached for further expectation " +"evaluation, defaults to be true." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh:5 -msgid "eigenvalues of ``a``" +#: of tensorcircuit.circuit.Circuit.expectation:30 +msgid "whether enable light cone simplification, defaults to False" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.expm:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.expm:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm:1 -msgid "Return the copy of tensor ''a''." +#: of tensorcircuit.circuit.Circuit.expectation:39 +#: tensorcircuit.circuit.expectation:50 +msgid "\"Cannot measure two operators in one index\"" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:4 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:4 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:4 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:4 -msgid "Return an identity matrix of dimension `dim`" +#: of tensorcircuit.circuit.Circuit.expectation:40 +#: tensorcircuit.densitymatrix.DMCircuit.expectation:13 +msgid "Tensor with one element" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:2 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:2 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:2 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:2 +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:1 msgid "" -"Depending on specific backends, `dim` has to be either an int (numpy, " -"torch, tensorflow) or a `ShapeType` object (for block-sparse backends). " -"Block-sparse behavior is currently not supported" +"Apply generaldepolarizing quantum channel on the circuit. See " +":py:meth:`tensorcircuit.channels.generaldepolarizingchannel`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:7 +#: of tensorcircuit.circuit.Circuit.get_quoperator:1 msgid "" -"N (int): The dimension of the returned matrix. dtype: The dtype of the " -"returned matrix. M (int): The dimension of the returned matrix." +"Get the ``QuOperator`` MPO like representation of the circuit unitary " +"without contraction." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:1 -msgid "Return the function which is the grad function of input ``f``." +#: of tensorcircuit.circuit.Circuit.get_quoperator:3 +msgid "" +"``QuOperator`` object for the circuit unitary (open indices for the input" +" state)" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad -#: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad -#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad -#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad -#: tensorcircuit.channels.amplitudedampingchannel -#: tensorcircuit.channels.depolarizingchannel -#: tensorcircuit.channels.phasedampingchannel -#: tensorcircuit.channels.resetchannel tensorcircuit.circuit.Circuit.amplitude -#: tensorcircuit.circuit.Circuit.append_from_qir -#: tensorcircuit.circuit.Circuit.apply_double_gate -#: tensorcircuit.circuit.Circuit.apply_single_gate -#: tensorcircuit.circuit.Circuit.cond_measurement -#: tensorcircuit.circuit.Circuit.draw tensorcircuit.circuit.Circuit.expectation -#: tensorcircuit.circuit.Circuit.from_qir -#: tensorcircuit.circuit.Circuit.from_qiskit -#: tensorcircuit.circuit.Circuit.measure_reference -#: tensorcircuit.circuit.Circuit.replace_mps_inputs -#: tensorcircuit.circuit.Circuit.to_qir tensorcircuit.circuit._expectation_ps -#: tensorcircuit.cons.set_tensornetwork_backend tensorcircuit.gates.bmatrix -#: tensorcircuit.gates.matrix_for_gate tensorcircuit.gates.num_to_tensor -#: tensorcircuit.interfaces.scipy_optimize_interface -#: tensorcircuit.interfaces.torch_interface tensorcircuit.keras.load_func -#: tensorcircuit.keras.save_func -#: tensorcircuit.quantum.QuAdjointVector.from_tensor -#: tensorcircuit.quantum.QuOperator.from_tensor -#: tensorcircuit.quantum.QuOperator.tensor_product -#: tensorcircuit.quantum.QuScalar.from_tensor -#: tensorcircuit.quantum.QuVector.from_tensor -#: tensorcircuit.quantum.correlation_from_counts tensorcircuit.quantum.entropy -#: tensorcircuit.quantum.free_energy -#: tensorcircuit.quantum.heisenberg_hamiltonian tensorcircuit.quantum.identity -#: tensorcircuit.quantum.measurement_counts -#: tensorcircuit.quantum.quantum_constructor -#: tensorcircuit.quantum.renyi_free_energy tensorcircuit.quantum.spin_by_basis -#: tensorcircuit.quantum.trace_product tensorcircuit.simplify.infer_new_shape -#: tensorcircuit.torchnn.QuantumNet.__init__ -#: tensorcircuit.translation.qir2qiskit tensorcircuit.translation.qiskit2tc -#: tensorcircuit.utils.append tensorcircuit.utils.return_partial -#: tensorcircuit.vis.gate_name_trans tensorcircuit.vis.qir2tex -#: tensorcircuit.vis.render_pdf -msgid "Example" +#: of tensorcircuit.circuit.Circuit.is_valid:1 +msgid "[WIP], check whether the circuit is legal." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:13 -#: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:13 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:13 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:13 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:13 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:13 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:13 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:13 -msgid "the function to be differentiated" +#: of tensorcircuit.circuit.Circuit.is_valid:3 +msgid "The bool indicating whether the circuit is legal" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:15 -#: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:15 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:15 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:15 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:15 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:15 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:15 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:15 +#: of tensorcircuit.circuit.Circuit.matrix:1 msgid "" -"the position of args in ``f`` that are to be differentiated, defaults to " -"be 0" +"Get the unitary matrix for the circuit irrespective with the circuit " +"input state." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:17 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:17 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:17 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:17 -msgid "the grad function of ``f`` with the same set of arguments as ``f``" +#: of tensorcircuit.circuit.Circuit.matrix:3 +msgid "The circuit unitary matrix" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.i:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.i:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:1 -msgid "Return 1.j in as a tensor compatible with the backend." +#: of tensorcircuit.circuit.Circuit.measure_reference:1 +msgid "Take measurement on the given quantum lines by ``index``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.i:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.i:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:3 -msgid "\"complex64\" or \"complex128\"" +#: of tensorcircuit.circuit.Circuit.mid_measurement:1 +msgid "" +"Middle measurement in z-basis on the circuit, note the wavefunction " +"output is not normalized with ``mid_measurement`` involved, one should " +"normalize the state manually if needed. This is a post-selection method " +"as keep is provided as a prior." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.i:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.i:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:5 -msgid "1.j tensor" +#: of tensorcircuit.circuit.Circuit.mid_measurement:5 +msgid "The index of qubit that the Z direction postselection applied on." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.imag:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.imag:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag:1 -msgid "Return the elementwise imaginary value of a tensor ``a``." +#: of tensorcircuit.circuit.Circuit.mid_measurement:7 +msgid "0 for spin up, 1 for spin down, defaults to be 0." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.imag:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.imag:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag:5 -msgid "imaginary value of ``a``" +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:1 +msgid "" +"Apply phasedamping quantum channel on the circuit. See " +":py:meth:`tensorcircuit.channels.phasedampingchannel`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:1 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:1 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:1 -msgid "[summary]" +#: of tensorcircuit.circuit.Circuit.replace_mps_inputs:1 +msgid "" +"Replace the input state in MPS representation while keep the circuit " +"structure unchanged." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:5 -msgid "The possible options" +#: of tensorcircuit.circuit.Circuit.replace_mps_inputs:18 +msgid "(Nodes, dangling Edges) for a MPS like initial wavefunction." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:7 -msgid "Sampling output shape" +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:1 +msgid "" +"Apply reset quantum channel on the circuit. See " +":py:meth:`tensorcircuit.channels.resetchannel`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:9 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randc:9 -msgid "" -"probability for each option in a, defaults to None, as equal probability " -"distribution" +#: of tensorcircuit.circuit.Circuit.wavefunction:1 +#: tensorcircuit.mpscircuit.MPSCircuit.wavefunction:1 +msgid "Compute the output wavefunction from the circuit." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:1 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:1 +#: of tensorcircuit.circuit.Circuit.wavefunction:3 msgid "" -"Call the random normal function with the random state management behind " -"the scene." +"The str indicating the form of the output wavefunction. \"default\": " +"[-1], \"ket\": [-1, 1], \"bra\": [1, -1]" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:11 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:11 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:11 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:9 -msgid "[description], defaults to 1" +#: of tensorcircuit.circuit.Circuit.wavefunction:6 +msgid "Tensor with the corresponding shape." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:9 -#: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:9 -msgid "[description], defaults to \"32\"" +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:1 +msgid "" +"Apply thermalrelaxation quantum channel on the circuit. See " +":py:meth:`tensorcircuit.channels.thermalrelaxationchannel`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:1 -msgid "Determine whether the type of input ``a`` is ``sparse``." +#: of tensorcircuit.circuit.Circuit.unitary_kraus:1 +msgid "" +"Apply unitary gates in ``kraus`` randomly based on corresponding " +"``prob``. If ``prob`` is ``None``, this is reduced to kraus channel " +"language." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:3 -msgid "input matrix ``a``" +#: of tensorcircuit.circuit.Circuit.unitary_kraus:4 +msgid "List of ``tc.gates.Gate`` or just Tensors" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:5 -msgid "a bool indicating whether the matrix ``a`` is sparse" +#: of tensorcircuit.circuit.Circuit.unitary_kraus:6 +msgid "prob list with the same size as ``kraus``, defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:1 -msgid "Return a boolean on whether ``a`` is a tensor in backend package." +#: of tensorcircuit.circuit.Circuit.unitary_kraus:8 +msgid "random seed between 0 to 1, defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:3 -msgid "a tensor to be determined" +#: of tensorcircuit.circuit.Circuit.unitary_kraus:10 +msgid "shape [] int dtype tensor indicates which kraus gate is actually applied" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:5 -msgid "whether ``a`` is a tensor" +#: of tensorcircuit.circuit.expectation:1 +msgid "Compute :math:`\\langle bra\\vert ops \\vert ket\\rangle`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:1 -msgid "Return the jitted version of function ``f``." +#: of tensorcircuit.circuit.expectation:3 +msgid "Example 1 (:math:`bra` is same as :math:`ket`)" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:3 -msgid "function to be jitted" +#: of tensorcircuit.circuit.expectation:24 +msgid "Example 2 (:math:`bra` is different from :math:`ket`)" +msgstr "" + +#: of tensorcircuit.circuit.expectation:42 +msgid ":math:`ket`. The state in tensor or ``QuVector`` format" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:5 -msgid "index of args that doesn't regarded as tensor, only work for jax backend" +#: of tensorcircuit.circuit.expectation:44 +msgid ":math:`bra`, defaults to None, which is the same as ``ket``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:8 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:8 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:8 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:8 +#: of tensorcircuit.circuit.expectation:46 msgid "" -"whether open XLA compilation, only works for tensorflow backend, defaults" -" False since several ops has no XLA correspondence" +":math:`bra` changes to the adjoint matrix of :math:`bra`, defaults to " +"True." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:11 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:11 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:11 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:11 -msgid "jitted version of ``f``" +#: of tensorcircuit.circuit.expectation:48 +msgid "Normalize the :math:`ket` and :math:`bra`, defaults to False." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:1 -msgid "" -"Function that computes a (forward-mode) Jacobian-vector product of ``f``." -" Strictly speaking, this function is value_and_jvp." +#: of tensorcircuit.circuit.expectation:51 +msgid "The result of :math:`\\langle bra\\vert ops \\vert ket\\rangle`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:4 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:4 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:4 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:4 -msgid "The function to compute jvp" +#: ../../source/api/cons.rst:2 +msgid "tensorcircuit.cons" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:6 -#: tensorcircuit.backends.jax_backend.JaxBackend.vjp:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:6 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:6 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:6 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:7 -msgid "input for ``f``" +#: of tensorcircuit.cons:1 +msgid "Constants and setups" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:8 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:8 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:8 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:8 -msgid "tangents" +#: of tensorcircuit.cons.get_contractor:1 tensorcircuit.cons.set_contractor:1 +msgid "" +"To set runtime contractor of the tensornetwork for a better contraction " +"path. For more information on the usage of contractor, please refer to " +"independent tutorial." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:10 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:10 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:10 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:10 +#: of tensorcircuit.cons.get_contractor:4 tensorcircuit.cons.set_contractor:4 msgid "" -"(``f(*inputs)``, jvp_tensor), where jvp_tensor is the same shape as the " -"output of ``f``" +"\"auto\", \"greedy\", \"branch\", \"plain\", \"tng\", \"custom\", " +"\"custom_stateful\". defaults to None (\"auto\")" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.kron:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:1 -msgid "Return the kronecker product of two matrices ``a`` and ``b``." +#: of tensorcircuit.cons.get_contractor:6 tensorcircuit.cons.set_contractor:6 +msgid "Valid for \"custom\" or \"custom_stateful\" as method, defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.kron:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:7 -msgid "kronecker product of ``a`` and ``b``" +#: of tensorcircuit.cons.get_contractor:8 tensorcircuit.cons.set_contractor:8 +msgid "" +"It is not very useful, as ``memory_limit`` leads to ``branch`` " +"contraction instead of ``greedy`` which is rather slow, defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:1 -msgid "Shift the bits of an integer x to the left y bits." +#: of tensorcircuit.cons.get_contractor:11 tensorcircuit.cons.set_contractor:11 +msgid "Tensornetwork version is too low to support some of the contractors." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.mod:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:3 -msgid "input values" +#: of tensorcircuit.cons.get_contractor:12 tensorcircuit.cons.set_contractor:12 +msgid "Unknown method options." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:5 -msgid "Number of bits shift to ``x``" +#: of tensorcircuit.cons.get_contractor:13 tensorcircuit.cons.set_contractor:13 +msgid "The new tensornetwork with its contractor set." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:7 -msgid "result with the same shape as ``x``" +#: of tensorcircuit.cons.get_dtype:1 tensorcircuit.cons.set_dtype:1 +msgid "Set the global runtime numerical dtype of tensors." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.max:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.max:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:1 -msgid "Return the maximum of an array or maximum along an axis." +#: of tensorcircuit.cons.get_dtype:3 tensorcircuit.cons.set_dtype:3 +msgid "" +"\"complex64\" or \"complex128\", defaults to None, which is equivalent to" +" \"complex64\"." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.max:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.min:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.max:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.min:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:5 -#: tensorcircuit.keras.QuantumLayer.__init__:10 -msgid "[description], defaults to None" +#: of tensorcircuit.cons.get_dtype:5 tensorcircuit.cons.set_dtype:5 +msgid "complex dtype str and the corresponding real dtype str" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:1 -msgid "Compute the arithmetic mean for ``a`` along the specified ``axis``." +#: of tensorcircuit.cons.plain_contractor:1 +msgid "The naive state-vector simulator contraction path." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:3 -msgid "tensor to take average" +#: of tensorcircuit.cons.plain_contractor:3 +msgid "The list of ``tn.Node``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:5 -msgid "the axis to take mean, defaults to None indicating sum over flatten array" +#: of tensorcircuit.cons.plain_contractor:5 +msgid "The list of dangling node edges, defaults to be None." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:7 -msgid "_description_, defaults to False" +#: of tensorcircuit.cons.plain_contractor:7 +msgid "The ``tn.Node`` after contraction" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.min:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.min:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:1 -msgid "Return the minimum of an array or minimum along an axis." +#: of tensorcircuit.cons.runtime_backend:1 +msgid "Context manager to set with-level runtime backend" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:1 -msgid "" -"Compute y-mod of x (negative number behavior is not guaranteed to be " -"consistent)" +#: of tensorcircuit.cons.runtime_backend:3 +#: tensorcircuit.cons.set_function_backend:3 +msgid "\"numpy\", \"tensorflow\", \"jax\", \"pytorch\", defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:5 -msgid "mod ``y``" +#: of tensorcircuit.cons.runtime_backend tensorcircuit.cons.runtime_contractor +#: tensorcircuit.cons.runtime_dtype +msgid "yield" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:7 -msgid "results" +#: of tensorcircuit.cons.runtime_backend:5 +msgid "the backend object" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.numpy:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.numpy:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.numpy:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.numpy:1 -msgid "" -"Return the numpy array of a tensor ``a``, but may not work in a jitted " -"function." +#: of tensorcircuit.cons.runtime_contractor:1 +msgid "Context manager to change with-levek contractor" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.numpy:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.numpy:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.numpy:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.numpy:5 -msgid "numpy array of ``a``" +#: of tensorcircuit.cons.runtime_dtype:1 +msgid "Context manager to set with-level runtime dtype" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:1 -msgid "" -"One-hot encodes the given ``a``. Each index in the input ``a`` is encoded" -" as a vector of zeros of length ``num`` with the element at index set to " -"one:" +#: of tensorcircuit.cons.runtime_dtype:3 +msgid "\"complex64\" or \"complex128\", defaults to None (\"complex64\")" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:5 -msgid "input tensor" +#: of tensorcircuit.cons.runtime_dtype:5 +msgid "complex dtype str and real dtype str" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:7 -msgid "number of features in onehot dimension" +#: of tensorcircuit.cons.set_tensornetwork_backend:1 +msgid "To set the runtime backend of tensorcircuit." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:9 -msgid "onehot tensor with the last extra dimension" +#: of tensorcircuit.cons.set_tensornetwork_backend:3 +msgid "" +"Note: ``tc.set_backend`` and ``tc.cons.set_tensornetwork_backend`` are " +"the same." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.ones:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.ones:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.ones:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.ones:1 +#: of tensorcircuit.cons.set_tensornetwork_backend:27 msgid "" -"Return an ones-matrix of dimension `dim` Depending on specific backends, " -"`dim` has to be either an int (numpy, torch, tensorflow) or a `ShapeType`" -" object (for block-sparse backends). Block-sparse behavior is currently " -"not supported Args:" +"\"numpy\", \"tensorflow\", \"jax\", \"pytorch\". defaults to None, which " +"gives the same behavior as " +"``tensornetwork.backend_contextmanager.get_default_backend()``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.ones:7 -#: tensorcircuit.backends.jax_backend.JaxBackend.zeros:8 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.ones:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.zeros:8 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.ones:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.zeros:8 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.ones:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.zeros:8 -msgid "" -"shape (int): The dimension of the returned matrix. dtype: The dtype of " -"the returned matrix." +#: of tensorcircuit.cons.set_tensornetwork_backend:30 +msgid "Whether the object should be set as global." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.random_split:1 -msgid "" -"A jax like split API, but it doesn't split the key generator for other " -"backends. It is just for a consistent interface of random code; make sure" -" you know what the function actually does. This function is mainly a " -"utility to write backend agnostic code instead of doing magic things." +#: of tensorcircuit.cons.set_function_backend:1 +msgid "Function decorator to set function-level runtime backend" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.real:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.real:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.real:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.real:1 -msgid "Return the elementwise real value of a tensor ``a``." +#: of tensorcircuit.cons.set_function_backend:5 +msgid "Decorated function" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.real:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.real:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.real:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.real:5 -msgid "real value of ``a``" +#: of tensorcircuit.cons.set_function_contractor:1 +msgid "Function decorate to change function-level contractor" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:1 -msgid "" -"Rectified linear unit activation function. Computes the element-wise " -"function:" +#: of tensorcircuit.cons.set_function_dtype:1 +msgid "Function decorator to set function-level numerical dtype" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:4 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:4 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:4 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:4 -msgid "\\mathrm{relu}(x)=\\max(x,0)" +#: of tensorcircuit.cons.set_function_dtype:3 +msgid "\"complex64\" or \"complex128\", defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:9 -msgid "Input tensor" +#: of tensorcircuit.cons.set_function_dtype:5 +msgid "The decorated function" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:11 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:11 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:11 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:11 -msgid "Tensor after relu" +#: of tensorcircuit.cons.split_rules:1 +msgid "Obtain the direcionary of truncation rules" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.right_shift:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:1 -msgid "Shift the bits of an integer x to the right y bits." +#: of tensorcircuit.cons.split_rules:3 +#: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:11 +msgid "The maximum number of singular values to keep." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.scatter:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:1 -msgid "" -"Roughly equivalent to operand[indices] = updates, indices only support " -"shape with rank 2 for now." +#: of tensorcircuit.cons.split_rules:5 +#: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:13 +msgid "The maximum allowed truncation error." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:1 -msgid "Set the random state attached to the backend." +#: ../../source/api/densitymatrix.rst:2 +msgid "tensorcircuit.densitymatrix" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:3 -msgid "the random seed, defaults to be None" +#: of tensorcircuit.densitymatrix:1 +msgid "Quantum circuit class but with density matrix simulator" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:5 -msgid "" -"If set to be true, only get the random state in return instead of setting" -" the state on the backend" +#: of tensorcircuit.densitymatrix.DMCircuit.__init__:1 +msgid "The density matrix simulator based on tensornetwork engine." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sigmoid:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid:1 -msgid "Compute sigmoid of input ``a``" +#: of tensorcircuit.densitymatrix.DMCircuit.__init__:3 +msgid "Number of qubits" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sin:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sin:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin:1 -msgid "Return the elementwise sine of a tensor ``a``." +#: of tensorcircuit.densitymatrix.DMCircuit.__init__:5 +msgid "if True, nothing initialized, only for internal use, defaults to False" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sin:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sin:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin:5 -msgid "sine of ``a``" +#: of tensorcircuit.densitymatrix.DMCircuit.__init__:7 +msgid "the state input for the circuit, defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sinh:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh:1 -msgid "Return the sinh of a tensor ``a``." +#: of tensorcircuit.densitymatrix.DMCircuit.__init__:9 +msgid "QuVector for a MPS like initial pure state." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sinh:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh:5 -msgid "sinh of ``a``" +#: of tensorcircuit.densitymatrix.DMCircuit.__init__:11 +msgid "the density matrix input for the circuit, defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.size:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.size:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size:1 -msgid "Return the total number of elements in ``a`` in tensor form." +#: of tensorcircuit.densitymatrix.DMCircuit.__init__:13 +msgid "QuOperator for a MPO like initial density matrix." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.size:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.size:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size:5 -msgid "the total number of elements in ``a``" +#: of tensorcircuit.densitymatrix.DMCircuit.densitymatrix:1 +msgid "Return the output density matrix of the circuit." +msgstr "" + +#: of tensorcircuit.densitymatrix.DMCircuit.densitymatrix:3 +msgid "" +"check whether the final return is a legal density matrix, defaults to " +"False" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:1 -msgid "" -"Softmax function. Computes the function which rescales elements to the " -"range [0,1] such that the elements along axis sum to 1." +#: of tensorcircuit.densitymatrix.DMCircuit.densitymatrix:5 +msgid "whether to reuse previous results, defaults to True" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:4 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:4 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:4 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:4 -msgid "\\mathrm{softmax}(x) = \\frac{\\exp(x_i)}{\\sum_j \\exp(x_j)}" +#: of tensorcircuit.densitymatrix.DMCircuit.densitymatrix:7 +msgid "The output densitymatrix in 2D shape tensor form" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:9 -msgid "Tensor" +#: of tensorcircuit.densitymatrix.DMCircuit.expectation:6 +msgid "whether contract the density matrix in advance, defaults to True" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:11 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:11 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:11 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:11 +#: of tensorcircuit.densitymatrix.DMCircuit.get_dm_as_quoperator:1 msgid "" -"A dimension along which Softmax will be computed , defaults to None for " -"all axis sum." +"Get the representation of the output state in the form of ``QuOperator`` " +"while maintaining the circuit uncomputed" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:13 -#: tensorcircuit.backends.jax_backend.JaxBackend.stack:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:13 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:13 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:13 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:7 -msgid "concatenated tensor" +#: of tensorcircuit.densitymatrix.DMCircuit.get_dm_as_quoperator:4 +msgid "``QuOperator`` representation of the output state from the circuit" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:1 -msgid "Solve the linear system Ax=b and return the solution x." +#: of tensorcircuit.densitymatrix.DMCircuit.to_circuit:1 +msgid "" +"convert into state simulator (current implementation ignores all noise " +"channels)" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:3 -msgid "The multiplied matrix." +#: of tensorcircuit.densitymatrix.DMCircuit.to_circuit:4 +msgid "kws to initialize circuit object, defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:5 -msgid "The resulted matrix." +#: of tensorcircuit.densitymatrix.DMCircuit.to_circuit:7 +msgid "Circuit with no noise" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:7 -msgid "The solution of the linear system." +#: of tensorcircuit.densitymatrix.DMCircuit.wavefunction:1 +msgid "" +"get the wavefunction of outputs, raise error if the final state is not " +"purified [Experimental: the phase factor is not fixed for different " +"backend]" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:1 -msgid "A sparse matrix multiplies a dense matrix." +#: of tensorcircuit.densitymatrix.DMCircuit.wavefunction:5 +msgid "wavefunction vector" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:3 -#: tensorcircuit.backends.jax_backend.JaxBackend.to_dense:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.to_dense:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense:3 -msgid "a sparse matrix" +#: of tensorcircuit.densitymatrix.DMCircuit2:1 +msgid "Bases: :py:class:`tensorcircuit.densitymatrix.DMCircuit`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:5 -msgid "a dense matrix" +#: ../../source/api/experimental.rst:2 +msgid "tensorcircuit.experimental" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:7 -msgid "dense matrix" +#: of tensorcircuit.experimental:1 +msgid "Experimental features" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:1 -msgid "Concatenates a sequence of tensors ``a`` along a new dimension ``axis``." +#: of tensorcircuit.experimental.hamiltonian_evol:1 +msgid "" +"Fast implementation of static full Hamiltonian evolution (default as " +"imaginary time)" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:3 -msgid "List of tensors in the same shape" +#: of tensorcircuit.experimental.hamiltonian_evol:13 +msgid "result dynamics on ``tlist``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:5 -msgid "the stack axis, defaults to 0" +#: of tensorcircuit.experimental.parameter_shift_grad:1 +msgid "" +"similar to `grad` function but using parameter shift internally instead " +"of AD, vmap is utilized for evaluation, so the speed is still ok" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:5 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:3 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:3 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:3 -msgid "stateful register for each package" +#: of tensorcircuit.experimental.parameter_shift_grad:4 +#: tensorcircuit.experimental.parameter_shift_grad_v2:6 +msgid "quantum function with weights in and expectation out" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:7 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:7 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:7 -msgid "shape of output sampling tensor" +#: of tensorcircuit.experimental.parameter_shift_grad:6 +#: tensorcircuit.experimental.parameter_shift_grad_v2:8 +msgid "label which args should be differentiated, defaults to 0" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:13 -#: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:11 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:13 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:11 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:13 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:11 -msgid "only real data type is supported, \"32\" or \"64\", defaults to \"32\"" +#: of tensorcircuit.experimental.parameter_shift_grad:9 +#: tensorcircuit.experimental.parameter_shift_grad_v2:11 +msgid "whether jit the original function `f` at the beginning, defaults to False" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:1 -msgid "Uniform random sampler from ``low`` to ``high``." +#: of tensorcircuit.experimental.parameter_shift_grad:12 +#: tensorcircuit.experimental.parameter_shift_grad_v2:14 +msgid "" +"two floats for the delta shift on the numerator and dominator, defaults " +"to (pi/2, 2) for parameter shift" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:5 -msgid "shape of output sampling tensor, defaults to 1" +#: of tensorcircuit.experimental.parameter_shift_grad:15 +#: tensorcircuit.experimental.parameter_shift_grad_v2:17 +msgid "the grad function" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient:1 -msgid "Stop backpropagation from ``a``." +#: of tensorcircuit.experimental.parameter_shift_grad_v2:1 +msgid "" +"similar to `grad` function but using parameter shift internally instead " +"of AD, vmap is utilized for evaluation, v2 also supports random generator" +" for finite measurememt shot, only jax backend is supported, since no " +"vmap randomness is available in tensorflow" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.switch:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:1 -msgid "``branches[index]()``" +#: ../../source/api/gates.rst:2 +msgid "tensorcircuit.gates" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tan:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tan:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan:1 -msgid "Return the tan of a tensor ``a``." +#: of tensorcircuit.gates:1 +msgid "" +"Declarations of single-qubit and two-qubit gates and their corresponding " +"matrix." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tan:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tan:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan:5 -msgid "tan of ``a``" +#: of tensorcircuit.gates.Gate:1 +msgid "Bases: :py:class:`tensornetwork.network_components.Node`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tanh:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tanh:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh:1 -msgid "Return the tanh of a tensor ``a``." +#: of tensorcircuit.gates.Gate:1 +msgid "Wrapper of tn.Node, quantum gate" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tanh:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tanh:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh:5 -msgid "tanh of ``a``" +#: of tensornetwork.network_components.Node.__init__:1 +msgid "Create a node." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tile:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:1 -msgid "Constructs a tensor by tiling a given tensor." +#: of tensornetwork.network_components.Node.__init__:3 +msgid "" +"The concrete that is represented by this node, or a `AbstractNode` " +"object. If a tensor is passed, it can be be either a numpy array or the " +"tensor-type of the used backend. If a `AbstractNode` is passed, the " +"passed node has to have the same backend as given by `backend`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tile:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:5 -msgid "1d tensor with length the same as the rank of ``a``" +#: of tensornetwork.network_components.Node.__init__:7 +msgid "Name of the node. Used primarily for debugging." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.to_dense:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.to_dense:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense:1 -msgid "Convert a sparse matrix to dense tensor." +#: of tensornetwork.network_components.AbstractNode.add_axis_names:3 +#: tensornetwork.network_components.Node.__init__:8 +msgid "List of names for each of the tensor's axes." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.to_dense:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.to_dense:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense:5 -msgid "the resulted dense matrix" +#: of tensornetwork.network_components.Node.__init__:9 +msgid "The name of the backend or an instance of a `AbstractBackend`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten:1 -msgid "Flatten python structure to 1D list" +#: of tensornetwork.network_components.AbstractNode.add_axis_names:5 +#: tensornetwork.network_components.Node.__init__:11 +msgid "" +"If there is a repeated name in `axis_names` or if the length doesn't " +"match the shape of the tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten:3 -msgid "python structure to be flattened" +#: of tensornetwork.network_components.AbstractNode.add_axis_names:1 +msgid "Add axis names to a Node." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_flatten:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_flatten:5 -msgid "" -"The 1D list of flattened structure and treedef which can be used for " -"later unflatten" +#: of tensornetwork.network_components.AbstractNode.add_edge:1 +msgid "Add an edge to the node on the given axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_map:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:1 -msgid "Return the new tree map with multiple arg function ``f`` through pytrees." +#: of tensornetwork.network_components.AbstractNode.add_edge:3 +msgid "The edge to add." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_map:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:3 -msgid "The function" +#: of tensornetwork.network_components.AbstractNode.add_edge:4 +msgid "The axis the edge points to." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_map:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:5 -msgid "inputs as any python structure" +#: of tensornetwork.network_components.AbstractNode.add_edge:5 +msgid "If true, replace the existing edge with the new one." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_map:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:7 -msgid "raise when neither tensorflow or jax is installed." +#: of tensornetwork.network_components.AbstractNode.add_edge:7 +msgid "If the edge on axis is not dangling." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_map:8 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_map:8 -msgid "The new tree map with the same structure but different values." +#: of tensornetwork.network_components.Node.from_serial_dict:1 +msgid "Return a node given a serialized dict representing it." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten:1 -msgid "Pack 1D list to pytree defined via ``treedef``" +#: of tensornetwork.network_components.Node.from_serial_dict:3 +msgid "A python dict representing a serialized node." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten:3 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten:3 -msgid "Def of pytree structure, the second return from ``tree_flatten``" +#: of tensornetwork.network_components.Node.from_serial_dict:5 +msgid "A node." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten:5 -msgid "the 1D list of flattened data structure" +#: of tensornetwork.network_components.AbstractNode.get_all_dangling:1 +msgid "Return the set of dangling edges connected to this node." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tree_unflatten:7 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tree_unflatten:7 -msgid "Packed pytree" +#: of tensornetwork.network_components.AbstractNode.get_all_nondangling:1 +msgid "Return the set of nondangling edges connected to this node." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.unique_with_counts:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.unique_with_counts:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts:1 -msgid "" -"Find the unique elements and their corresponding counts of the given " -"tensor ``a``." +#: of tensornetwork.network_components.AbstractNode.get_axis_number:1 +msgid "Get the axis number for a given axis name or value." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.unique_with_counts:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.unique_with_counts:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts:5 -msgid "Unique elements, corresponding counts" +#: of tensornetwork.network_components.AbstractNode.get_dimension:1 +msgid "Get the dimension of the given axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:1 -msgid "Return the function which returns the value and grad of ``f``." +#: of tensornetwork.network_components.AbstractNode.get_dimension:3 +msgid "The axis of the underlying tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:17 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:17 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:17 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:17 -msgid "" -"the value and grad function of ``f`` with the same set of arguments as " -"``f``" +#: of tensornetwork.network_components.AbstractNode.get_dimension:5 +msgid "The dimension of the given axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:1 -msgid "" -"Return the VVAG function of ``f``. The inputs for ``f`` is (args[0], " -"args[1], args[2], ...), and the output of ``f`` is a scalar. Suppose " -"VVAG(f) is a function with inputs in the form (vargs[0], args[1], " -"args[2], ...), where vagrs[0] has one extra dimension than args[0] in the" -" first axis and consistent with args[0] in shape for remaining " -"dimensions, i.e. shape(vargs[0]) = [batch] + shape(args[0]). (We only " -"cover cases where ``vectorized_argnums`` defaults to 0 here for " -"demonstration). VVAG(f) returns a tuple as a value tensor with shape " -"[batch, 1] and a gradient tuple with shape: ([batch]+shape(args[argnum]) " -"for argnum in argnums). The gradient for argnums=k is defined as" +#: of tensornetwork.network_components.AbstractNode.get_dimension:7 +msgid "if axis isn't an int or if axis is too large or small." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:9 -msgid "" -"g^k = \\frac{\\partial \\sum_{i\\in batch} f(vargs[0][i], args[1], " -"...)}{\\partial args[k]}" +#: of tensornetwork.network_components.AbstractNode.get_rank:1 +msgid "Return rank of tensor represented by self." msgstr "" -#: of -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:13 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:13 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:13 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:13 -msgid "Therefore, if argnums=0, the gradient is reduced to" +#: of tensornetwork.network_components.AbstractNode.reorder_axes:1 +msgid "Reorder axes of the node's tensor." +msgstr "" + +#: of tensornetwork.network_components.AbstractNode.reorder_axes:3 +msgid "This will also update all of the node's edges." msgstr "" -#: of -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:15 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:15 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:15 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:15 -msgid "g^0_i = \\frac{\\partial f(vargs[0][i])}{\\partial vargs[0][i]}" +#: of tensornetwork.network_components.AbstractNode.reorder_axes:5 +msgid "Permutation of the dimensions of the node's tensor." msgstr "" -#: of -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:19 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:19 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:19 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:19 -msgid "" -", which is specifically suitable for batched VQE optimization, where " -"args[0] is the circuit parameters." +#: of tensornetwork.network_components.AbstractNode.reorder_axes:7 +#: tensornetwork.network_components.AbstractNode.reorder_edges:9 +msgid "This node post reordering." msgstr "" -#: of -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:21 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:21 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:21 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:21 -msgid "And if argnums=1, the gradient is like" +#: of tensornetwork.network_components.AbstractNode.reorder_axes:9 +#: tensornetwork.network_components.AbstractNode.reorder_edges:12 +msgid "If the Node has no tensor." msgstr "" -#: of -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:23 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:23 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:23 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:23 -msgid "" -"g^1_i = \\frac{\\partial \\sum_j f(vargs[0][j], args[1])}{\\partial " -"args[1][i]}\n" -"\n" +#: of tensornetwork.network_components.AbstractNode.reorder_edges:1 +msgid "Reorder the edges for this given Node." msgstr "" -#: of -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:26 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:26 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:26 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:26 +#: of tensornetwork.network_components.AbstractNode.reorder_edges:3 msgid "" -", which is suitable for quantum machine learning scenarios, where ``f`` " -"is the loss function, args[0] corresponds to the input data and args[1] " -"corresponds to the weights in the QML model." +"This will reorder the node's edges and transpose the underlying tensor " +"accordingly." msgstr "" -#: of -#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:33 -#: tensorcircuit.backends.jax_backend.JaxBackend.vmap:6 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:33 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:6 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:33 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:6 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:33 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:6 -msgid "" -"the args to be vectorized, these arguments should share the same batch " -"shape in the fist dimension" +#: of tensornetwork.network_components.AbstractNode.reorder_edges:6 +msgid "List of edges. The order in the list determines the new edge ordering." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:1 +#: of tensornetwork.network_components.AbstractNode.reorder_edges:11 msgid "" -"Function that computes the dot product between a vector v and the " -"Jacobian of the given function at the point given by the inputs. (reverse" -" mode AD relevant) Strictly speaking, this function is value_and_vjp." +"If either the list of edges is not the same as expected or if you try" +" to reorder with a trace edge." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:5 -msgid "the function to carry out vjp calculation" +#: of tensornetwork.network_components.Node.to_serial_dict:1 +msgid "Return a serializable dict representing the node." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:9 -msgid "" -"value vector or gradient from downstream in reverse mode AD the same " -"shape as return of function ``f``" +#: of tensornetwork.network_components.Node.to_serial_dict:3 +msgid "Returns: A dict object." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:12 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:12 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:12 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:12 -msgid "(``f(*inputs)``, vjp_tensor), where vjp_tensor is the same shape as inputs" +#: of tensorcircuit.gates.GateVF:1 +msgid "Bases: :py:class:`tensorcircuit.gates.GateF`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:1 -msgid "" -"Return the vectorized map or batched version of ``f`` on the first extra " -"axis. The general interface supports ``f`` with multiple arguments and " -"broadcast in the fist dimension." +#: of tensorcircuit.gates.any_gate:1 +msgid "Note one should provide the gate with properly reshaped." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:4 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:4 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:4 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:4 -msgid "function to be broadcasted." +#: of tensorcircuit.gates.any_gate:3 +msgid "corresponding gate" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:9 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:9 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:9 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:9 -msgid "vmap version of ``f``" +#: of tensorcircuit.gates.any_gate:5 +msgid "The name of the gate." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.zeros:1 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.zeros:1 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.zeros:1 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.zeros:1 -msgid "" -"Return a zeros-matrix of dimension `dim` Depending on specific backends, " -"`dim` has to be either an int (numpy, torch, tensorflow) or a `ShapeType`" -" object (for block-sparse backends)." +#: of tensorcircuit.gates.any_gate:7 +msgid "the resulted gate" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.zeros:5 -#: tensorcircuit.backends.numpy_backend.NumpyBackend.zeros:5 -#: tensorcircuit.backends.pytorch_backend.PyTorchBackend.zeros:5 -#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.zeros:5 -msgid "Block-sparse behavior is currently not supported Args:" +#: of tensorcircuit.gates.num_to_tensor:1 +msgid "Convert the inputs to Tensor with specified dtype." msgstr "" -#: ../../source/api/backends/numpy_backend.rst:2 -msgid "tensorcircuit.backends.numpy_backend" +#: of tensorcircuit.gates.num_to_tensor:35 +msgid "inputs" msgstr "" -#: of tensorcircuit.backends.numpy_backend:1 -msgid "Backend magic inherited from tensornetwork: numpy backend" +#: of tensorcircuit.gates.num_to_tensor:37 +msgid "dtype of the output Tensors" msgstr "" -#: of tensorcircuit.backends.numpy_backend.NumpyBackend:1 -msgid "Bases: :py:class:`tensornetwork.backends.numpy.numpy_backend.NumPyBackend`" +#: of tensorcircuit.gates.num_to_tensor:39 +msgid "List of Tensors" msgstr "" -#: of tensorcircuit.backends.numpy_backend.NumpyBackend:1 +#: of tensorcircuit.gates.bmatrix:1 +msgid "Returns a :math:`\\LaTeX` bmatrix." +msgstr "" + +#: of tensorcircuit.gates.bmatrix:13 +msgid "Formatted Display:" +msgstr "" + +#: of tensorcircuit.gates.bmatrix:15 msgid "" -"see the original backend API at `numpy backend " -"`_" +"\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j \\end{bmatrix}" +"\n" +"\n" msgstr "" -#: ../../source/api/backends/pytorch_backend.rst:2 -msgid "tensorcircuit.backends.pytorch_backend" +#: of tensorcircuit.gates.bmatrix:18 +msgid "2D numpy array" msgstr "" -#: of tensorcircuit.backends.pytorch_backend:1 -msgid "Backend magic inherited from tensornetwork: pytorch backend" +#: of tensorcircuit.gates.bmatrix:20 +msgid "ValueError(\"bmatrix can at most display two dimensions\")" msgstr "" -#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend:1 +#: of tensorcircuit.gates.bmatrix:21 +msgid ":math:`\\LaTeX`-formatted string for bmatrix of the array a" +msgstr "" + +#: of tensorcircuit.gates.cr_gate:1 msgid "" -"Bases: " -":py:class:`tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend`" +"Controlled rotation gate. When the control qubit is 1, `rgate` is applied" +" to the target qubit." msgstr "" -#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend:1 +#: of tensorcircuit.gates.cr_gate:3 tensorcircuit.gates.cr_gate:5 +#: tensorcircuit.gates.cr_gate:7 tensorcircuit.gates.exponential_gate:12 +#: tensorcircuit.gates.exponential_gate_unity:13 +#: tensorcircuit.gates.iswap_gate:12 tensorcircuit.gates.r_gate:9 +#: tensorcircuit.gates.r_gate:11 tensorcircuit.gates.r_gate:13 +#: tensorcircuit.gates.rgate_theoretical:8 +#: tensorcircuit.gates.rgate_theoretical:10 +#: tensorcircuit.gates.rgate_theoretical:12 tensorcircuit.gates.rx_gate:6 +#: tensorcircuit.gates.rxx_gate:13 tensorcircuit.gates.ry_gate:6 +#: tensorcircuit.gates.ryy_gate:13 tensorcircuit.gates.rz_gate:6 +#: tensorcircuit.gates.rzz_gate:13 +msgid "angle in radians" +msgstr "" + +#: of tensorcircuit.gates.cr_gate:10 +msgid "CR Gate" +msgstr "" + +#: of tensorcircuit.gates.exponential_gate_unity:1 +#: tensorcircuit.gates.rxx_gate:1 tensorcircuit.gates.ryy_gate:1 +#: tensorcircuit.gates.rzz_gate:1 msgid "" -"See the original backend API at `pytorch backend " -"`_" +"Faster exponential gate directly implemented based on RHS. Only works " +"when :math:`U^2 = I` is an identity matrix." msgstr "" -#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend:4 +#: of tensorcircuit.gates.exponential_gate_unity:3 +#: tensorcircuit.gates.rxx_gate:3 tensorcircuit.gates.ryy_gate:3 +#: tensorcircuit.gates.rzz_gate:3 msgid "" -"Note the functionality provided by pytorch backend is incomplete, it " -"currenly lacks native efficicent jit and vmap support." +"\\textrm{exp}(U) &= e^{-j \\theta U} \\\\\n" +" &= \\cos(\\theta) I - j \\sin(\\theta) U \\\\\n" +"\n" msgstr "" -#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse:1 -msgid "return ``a[::-1]``, only 1D tensor is guaranteed for consistent behavior" +#: of tensorcircuit.gates.exponential_gate:6 +#: tensorcircuit.gates.exponential_gate_unity:7 +#: tensorcircuit.gates.multicontrol_gate:7 tensorcircuit.gates.rxx_gate:7 +#: tensorcircuit.gates.ryy_gate:7 tensorcircuit.gates.rzz_gate:7 +msgid "input unitary :math:`U`" msgstr "" -#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse:3 -msgid "1D tensor" +#: of tensorcircuit.gates.exponential_gate:8 +#: tensorcircuit.gates.exponential_gate:10 +#: tensorcircuit.gates.exponential_gate_unity:9 +#: tensorcircuit.gates.exponential_gate_unity:11 tensorcircuit.gates.rxx_gate:9 +#: tensorcircuit.gates.rxx_gate:11 tensorcircuit.gates.ryy_gate:9 +#: tensorcircuit.gates.ryy_gate:11 tensorcircuit.gates.rzz_gate:9 +#: tensorcircuit.gates.rzz_gate:11 +msgid "alias for the argument ``unitary``" msgstr "" -#: of tensorcircuit.backends.pytorch_backend.PyTorchBackend.reverse:5 -msgid "1D tensor in reverse order" +#: of tensorcircuit.gates.exponential_gate_unity:15 +#: tensorcircuit.gates.rxx_gate:15 tensorcircuit.gates.ryy_gate:15 +#: tensorcircuit.gates.rzz_gate:15 +msgid "if True, the angel theta is mutiplied by 1/2, defaults to False" msgstr "" -#: ../../source/api/backends/tensorflow_backend.rst:2 -msgid "tensorcircuit.backends.tensorflow_backend" +#: of tensorcircuit.gates.exponential_gate:14 +#: tensorcircuit.gates.exponential_gate_unity:18 +#: tensorcircuit.gates.rxx_gate:18 tensorcircuit.gates.ryy_gate:18 +#: tensorcircuit.gates.rzz_gate:18 +msgid "suffix of Gate name" msgstr "" -#: of tensorcircuit.backends.tensorflow_backend:1 -msgid "Backend magic inherited from tensornetwork: tensorflow backend" +#: of tensorcircuit.gates.exponential_gate:15 +#: tensorcircuit.gates.exponential_gate_unity:20 +#: tensorcircuit.gates.rxx_gate:20 tensorcircuit.gates.ryy_gate:20 +#: tensorcircuit.gates.rzz_gate:20 +msgid "Exponential Gate" msgstr "" -#: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend:1 +#: of tensorcircuit.gates.exponential_gate:1 +msgid "Exponential gate." +msgstr "" + +#: of tensorcircuit.gates.exponential_gate:3 msgid "" -"Bases: " -":py:class:`tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend`" +"\\textrm{exp}(U) = e^{-j \\theta U}\n" +"\n" msgstr "" -#: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend:1 +#: of tensorcircuit.gates.get_u_parameter:1 +msgid "From the single qubit unitary to infer three angles of IBMUgate," +msgstr "" + +#: of tensorcircuit.gates.get_u_parameter:3 +msgid "numpy array, no backend agnostic version for now" +msgstr "" + +#: of tensorcircuit.gates.get_u_parameter:5 +msgid "theta, phi, lbd" +msgstr "" + +#: of tensorcircuit.gates.iswap_gate:1 +msgid "iSwap gate." +msgstr "" + +#: of tensorcircuit.gates.iswap_gate:3 msgid "" -"See the original backend API at `tensorflow backend " -"`_" +"\\textrm{iSwap}(\\theta) =\n" +"\\begin{pmatrix}\n" +" 1 & 0 & 0 & 0\\\\\n" +" 0 & \\cos(\\frac{\\pi}{2} \\theta ) & j \\sin(\\frac{\\pi}{2} \\theta" +" ) & 0\\\\\n" +" 0 & j \\sin(\\frac{\\pi}{2} \\theta ) & \\cos(\\frac{\\pi}{2} \\theta" +" ) & 0\\\\\n" +" 0 & 0 & 0 & 1\\\\\n" +"\\end{pmatrix}\n" +"\n" +msgstr "" + +#: of tensorcircuit.gates.iswap_gate:14 +msgid "iSwap Gate" +msgstr "" + +#: of tensorcircuit.gates.matrix_for_gate:1 +msgid "Convert Gate to numpy array." +msgstr "" + +#: of tensorcircuit.gates.matrix_for_gate:10 +msgid "input Gate" +msgstr "" + +#: of tensorcircuit.gates.matrix_for_gate:12 +msgid "Corresponding Tensor" msgstr "" -#: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d:1 +#: of tensorcircuit.gates.meta_gate:1 msgid "" -"Return ``operand[indices]``, both ``operand`` and ``indices`` are rank-1 " -"tensor." +"Inner helper function to generate gate functions, such as ``z()`` from " +"``_z_matrix``" msgstr "" -#: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d:3 -msgid "rank-1 tensor" +#: of tensorcircuit.gates.multicontrol_gate:1 +msgid "" +"Multicontrol gate. If the control qubits equal to ``ctrl``, :math:`U` is " +"applied to the target qubits." msgstr "" -#: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d:5 -msgid "rank-1 tensor with int dtype" +#: of tensorcircuit.gates.multicontrol_gate:5 +msgid "" +"E.g., ``multicontrol_gate(tc.gates._zz_matrix, [1, 0, 1])`` returns a " +"gate of 5 qubits," msgstr "" -#: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.gather1d:7 -msgid "``operand[indices]``" +#: of tensorcircuit.gates.multicontrol_gate:4 +msgid "" +"where the last 2 qubits are applied :math:`ZZ` gate, if the first 3 " +"qubits are :math:`\\ket{101}`." msgstr "" -#: ../../source/api/channels.rst:2 -msgid "tensorcircuit.channels" +#: of tensorcircuit.gates.multicontrol_gate:9 +msgid "control bit sequence" msgstr "" -#: of tensorcircuit.channels:1 -msgid "Some common noise quantum channels." +#: of tensorcircuit.gates.multicontrol_gate:11 +msgid "Multicontrol Gate" msgstr "" -#: of tensorcircuit.channels.amplitudedampingchannel:1 -msgid "" -"Return an amplitude damping channel. Notice: Amplitude damping " -"corrspondings to p = 1." +#: of tensorcircuit.gates.phase_gate:1 +msgid "The phase gate" msgstr "" -#: of tensorcircuit.channels.amplitudedampingchannel:4 +#: of tensorcircuit.gates.phase_gate:3 msgid "" -"\\sqrt{p}\n" -"\\begin{bmatrix}\n" -" 1 & 0\\\\\n" -" 0 & \\sqrt{1-\\gamma}\\\\\n" -"\\end{bmatrix}\\qquad\n" -"\\sqrt{p}\n" -"\\begin{bmatrix}\n" -" 0 & \\sqrt{\\gamma}\\\\\n" -" 0 & 0\\\\\n" -"\\end{bmatrix}\\qquad\n" -"\\sqrt{1-p}\n" -"\\begin{bmatrix}\n" -" \\sqrt{1-\\gamma} & 0\\\\\n" -" 0 & 1\\\\\n" -"\\end{bmatrix}\\qquad\n" -"\\sqrt{1-p}\n" -"\\begin{bmatrix}\n" -" 0 & 0\\\\\n" -" \\sqrt{\\gamma} & 0\\\\\n" -"\\end{bmatrix}\n" +"\\textrm{phase}(\\theta) =\n" +"\\begin{pmatrix}\n" +" 1 & 0 \\\\\n" +" 0 & e^{i\\theta} \\\\\n" +"\\end{pmatrix}\n" "\n" msgstr "" -#: of tensorcircuit.channels.amplitudedampingchannel:31 -msgid "the damping parameter of amplitude (:math:`\\gamma`)" -msgstr "" - -#: of tensorcircuit.channels.amplitudedampingchannel:33 -msgid ":math:`p`" +#: of tensorcircuit.gates.phase_gate:10 +msgid "angle in radians, defaults to 0" msgstr "" -#: of tensorcircuit.channels.amplitudedampingchannel:35 -msgid "An amplitude damping channel with given :math:`\\gamma` and :math:`p`" +#: of tensorcircuit.gates.phase_gate:12 +msgid "phase gate" msgstr "" -#: of tensorcircuit.channels.depolarizingchannel:1 -msgid "Return a Depolarizing Channel" +#: of tensorcircuit.gates.r_gate:1 +msgid "General single qubit rotation gate" msgstr "" -#: of tensorcircuit.channels.depolarizingchannel:3 +#: of tensorcircuit.gates.r_gate:3 msgid "" -"\\sqrt{1-p_x-p_y-p_z}\n" -"\\begin{bmatrix}\n" -" 1 & 0\\\\\n" -" 0 & 1\\\\\n" -"\\end{bmatrix}\\qquad\n" -"\\sqrt{p_x}\n" -"\\begin{bmatrix}\n" -" 0 & 1\\\\\n" -" 1 & 0\\\\\n" -"\\end{bmatrix}\\qquad\n" -"\\sqrt{p_y}\n" -"\\begin{bmatrix}\n" -" 0 & -1j\\\\\n" -" 1j & 0\\\\\n" -"\\end{bmatrix}\\qquad\n" -"\\sqrt{p_z}\n" -"\\begin{bmatrix}\n" -" 1 & 0\\\\\n" -" 0 & -1\\\\\n" -"\\end{bmatrix}\n" +"R(\\theta, \\alpha, \\phi) = j \\cos(\\theta) I\n" +"- j \\cos(\\phi) \\sin(\\alpha) \\sin(\\theta) X\n" +"- j \\sin(\\phi) \\sin(\\alpha) \\sin(\\theta) Y\n" +"- j \\sin(\\theta) \\cos(\\alpha) Z\n" "\n" msgstr "" -#: of tensorcircuit.channels.depolarizingchannel:30 -msgid ":math:`p_x`" +#: of tensorcircuit.gates.r_gate:16 +msgid "R Gate" msgstr "" -#: of tensorcircuit.channels.depolarizingchannel:32 -msgid ":math:`p_y`" +#: of tensorcircuit.gates.random_single_qubit_gate:1 +msgid "Random single qubit gate described in https://arxiv.org/abs/2002.07730." msgstr "" -#: of tensorcircuit.channels.depolarizingchannel:34 -msgid ":math:`p_z`" +#: of tensorcircuit.gates.random_single_qubit_gate:3 +msgid "A random single-qubit gate" msgstr "" -#: of tensorcircuit.channels.depolarizingchannel:36 -msgid "Sequences of Gates" +#: of tensorcircuit.gates.random_two_qubit_gate:1 +msgid "Returns a random two-qubit gate." msgstr "" -#: of tensorcircuit.channels.kraus_to_super_gate:1 -msgid "Convert Kraus operators to one Tensor (as one Super Gate)." +#: of tensorcircuit.gates.random_two_qubit_gate:3 +msgid "A random two-qubit gate" msgstr "" -#: of tensorcircuit.channels.kraus_to_super_gate:3 +#: of tensorcircuit.gates.rgate_theoretical:1 msgid "" -"\\sum_{k}^{} K_k \\otimes K_k^{\\dagger}\n" -"\n" +"Rotation gate implemented by matrix exponential. The output is the same " +"as `rgate`." msgstr "" -#: of tensorcircuit.channels.kraus_to_super_gate:6 -msgid "A sequence of Gate" +#: of tensorcircuit.gates.rgate_theoretical:3 +msgid "" +"R(\\theta, \\alpha, \\phi) = e^{-j \\theta \\left[\\sin(\\alpha) " +"\\cos(\\phi) X\n" +" + \\sin(\\alpha) \\sin(\\phi) " +"Y\n" +" + \\cos(\\alpha) Z\\right]}\n" +"\n" msgstr "" -#: of tensorcircuit.channels.kraus_to_super_gate:8 -msgid "The corresponding Tensor of the list of Kraus operators" +#: of tensorcircuit.gates.rgate_theoretical:14 +msgid "Rotation Gate" msgstr "" -#: of tensorcircuit.channels.phasedampingchannel:1 -msgid "Return a phase damping channel with given :math:`\\gamma`" +#: of tensorcircuit.gates.rx_gate:1 +msgid "Rotation gate along :math:`x` axis." msgstr "" -#: of tensorcircuit.channels.phasedampingchannel:3 +#: of tensorcircuit.gates.rx_gate:3 msgid "" -"\\begin{bmatrix}\n" -" 1 & 0\\\\\n" -" 0 & \\sqrt{1-\\gamma}\\\\\n" -"\\end{bmatrix}\\qquad\n" -"\\begin{bmatrix}\n" -" 0 & 0\\\\\n" -" 0 & \\sqrt{\\gamma}\\\\\n" -"\\end{bmatrix}\n" +"RX(\\theta) = e^{-j\\frac{\\theta}{2}X}\n" "\n" msgstr "" -#: of tensorcircuit.channels.phasedampingchannel:18 -msgid "The damping parameter of phase (:math:`\\gamma`)" -msgstr "" - -#: of tensorcircuit.channels.phasedampingchannel:20 -msgid "A phase damping channel with given :math:`\\gamma`" +#: of tensorcircuit.gates.rx_gate:8 +msgid "RX Gate" msgstr "" -#: of tensorcircuit.channels.resetchannel:1 -#: tensorcircuit.channels.resetchannel:18 -msgid "Reset channel" +#: of tensorcircuit.gates.ry_gate:1 +msgid "Rotation gate along :math:`y` axis." msgstr "" -#: of tensorcircuit.channels.resetchannel:3 +#: of tensorcircuit.gates.ry_gate:3 msgid "" -"\\begin{bmatrix}\n" -" 1 & 0\\\\\n" -" 0 & 0\\\\\n" -"\\end{bmatrix}\\qquad\n" -"\\begin{bmatrix}\n" -" 0 & 1\\\\\n" -" 0 & 0\\\\\n" -"\\end{bmatrix}\n" +"RY(\\theta) = e^{-j\\frac{\\theta}{2}Y}\n" "\n" msgstr "" -#: of tensorcircuit.channels.single_qubit_kraus_identity_check:1 -msgid "Check identity of a single qubit Kraus operators." +#: of tensorcircuit.gates.ry_gate:8 +msgid "RY Gate" msgstr "" -#: of tensorcircuit.channels.single_qubit_kraus_identity_check -msgid "Examples" +#: of tensorcircuit.gates.rz_gate:1 +msgid "Rotation gate along :math:`z` axis." msgstr "" -#: of tensorcircuit.channels.single_qubit_kraus_identity_check:8 +#: of tensorcircuit.gates.rz_gate:3 msgid "" -"\\sum_{k}^{} K_k^{\\dagger} K_k = I\n" +"RZ(\\theta) = e^{-j\\frac{\\theta}{2}Z}\n" "\n" msgstr "" -#: of tensorcircuit.channels.single_qubit_kraus_identity_check:11 -msgid "List of Kraus operators." +#: of tensorcircuit.gates.rz_gate:8 +msgid "RZ Gate" msgstr "" -#: ../../source/api/circuit.rst:2 -msgid "tensorcircuit.circuit" +#: of tensorcircuit.gates.u_gate:1 +msgid "" +"IBMQ U gate following the converntion of OpenQASM3.0. See `OpenQASM doc " +"`_" msgstr "" -#: of tensorcircuit.circuit:1 -msgid "Quantum circuit: the state simulator" +#: of tensorcircuit.gates.u_gate:4 +msgid "" +"\\begin{split}U(\\theta,\\phi,\\lambda) := \\left(\\begin{array}{cc}\n" +"\\cos(\\theta/2) & -e^{i\\lambda}\\sin(\\theta/2) \\\\\n" +"e^{i\\phi}\\sin(\\theta/2) & e^{i(\\phi+\\lambda)}\\cos(\\theta/2) " +"\\end{array}\\right).\\end{split}" msgstr "" -#: of tensorcircuit.circuit.Circuit:1 -msgid "``Circuit`` class. Simple usage demo below." +#: of tensorcircuit.gates.u_gate:10 tensorcircuit.gates.u_gate:12 +#: tensorcircuit.gates.u_gate:14 +msgid "_description_, defaults to 0" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **ANY** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.any_gate`." +#: ../../source/api/interfaces.rst:2 +msgid "tensorcircuit.interfaces" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:3 -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:4 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix2.DMCircuit2.apply_general_kraus_delayed..apply:4 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:3 -msgid "Qubit number that the gate applies on." +#: ../../source/api/interfaces/numpy.rst:2 +msgid "tensorcircuit.interfaces.numpy" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:5 -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:7 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:7 -msgid "Parameters for the gate." +#: of tensorcircuit.interfaces.numpy:1 +msgid "Interface wraps quantum function as a numpy function" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **CNOT** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.cnot_gate`." +#: of tensorcircuit.interfaces.numpy.numpy_interface:1 +msgid "Convert ``fun`` on ML backend into a numpy function" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & " -"1.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.numpy.numpy_interface:23 +msgid "The quantum function" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 -msgid "Qubit number that the gate applies on. The matrix for the gate is" +#: of tensorcircuit.interfaces.numpy.numpy_interface:25 +#: tensorcircuit.interfaces.scipy.scipy_optimize_interface:39 +msgid "whether to jit ``fun``, defaults to True" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\\\ " -"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.numpy.numpy_interface:27 +msgid "The numpy interface compatible version of ``fun``" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **CR** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.cr_gate`." +#: ../../source/api/interfaces/scipy.rst:2 +msgid "tensorcircuit.interfaces.scipy" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **CRX** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.crx_gate`." +#: of tensorcircuit.interfaces.scipy:1 +msgid "Interface wraps quantum function as a scipy function for optimization" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **CRY** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.cry_gate`." +#: of tensorcircuit.interfaces.scipy.scipy_optimize_interface:1 +msgid "Convert ``fun`` into a scipy optimize interface compatible version" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **CRZ** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.crz_gate`." +#: of tensorcircuit.interfaces.scipy.scipy_optimize_interface:35 +msgid "The quantum function with scalar out that to be optimized" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **CY** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.cy_gate`." +#: of tensorcircuit.interfaces.scipy.scipy_optimize_interface:37 +msgid "the shape of parameters that ``fun`` accepts, defaults to None" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 +#: of tensorcircuit.interfaces.scipy.scipy_optimize_interface:41 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & " -"0.-1.j\\\\ 0.+0.j & 0.+0.j & 0.+1.j & 0.+0.j \\end{bmatrix}" +"whether using gradient-based or gradient free scipy optimize interface, " +"defaults to True" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.-1.j\\\\ " -"0.+0.j & 0.+0.j & 0.+1.j & 0.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.scipy.scipy_optimize_interface:44 +msgid "The scipy interface compatible version of ``fun``" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **CZ** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.cz_gate`." +#: ../../source/api/interfaces/tensorflow.rst:2 +msgid "tensorcircuit.interfaces.tensorflow" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & " -"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & -1.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.tensorflow:1 +msgid "Interface wraps quantum function as a tensorflow function" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 +#: of tensorcircuit.interfaces.tensorflow.tensorflow_interface:1 msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & -1.+0.j \\end{bmatrix}" +"Wrap a quantum function on different ML backend with a tensorflow " +"interface." msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **EXP** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.exp_gate`." +#: of tensorcircuit.interfaces.tensorflow.tensorflow_interface:22 +#: tensorcircuit.interfaces.torch.torch_interface:28 +msgid "The quantum function with tensor in and tensor out" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **EXP1** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.exp1_gate`." +#: of tensorcircuit.interfaces.tensorflow.tensorflow_interface:24 +msgid "output tf dtype or in str" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **FREDKIN** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.fredkin_gate`." +#: of tensorcircuit.interfaces.tensorflow.tensorflow_interface:26 +#: tensorcircuit.interfaces.torch.torch_interface:30 +msgid "whether to jit ``fun``, defaults to False" +msgstr "" + +#: of tensorcircuit.interfaces.tensorflow.tensorflow_interface:28 +#: tensorcircuit.interfaces.torch.torch_interface:32 +msgid "whether transform tensor backend via dlpack, defaults to False" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 +#: of tensorcircuit.interfaces.tensorflow.tensorflow_interface:30 +#: tensorcircuit.interfaces.torch.torch_interface:34 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & " -"1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & " -"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & " -"0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +"The same quantum function but now with torch tensor in and torch tensor " +"out while AD is also supported" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j &" -" 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & " -"1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j" -" \\end{bmatrix}" +#: ../../source/api/interfaces/tensortrans.rst:2 +msgid "tensorcircuit.interfaces.tensortrans" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **H** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.h_gate`." +#: of tensorcircuit.interfaces.tensortrans:1 +msgid "general function for interfaces transformation" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:1 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 0.70710677+0.j & 0.70710677+0.j\\\\ " -"0.70710677+0.j & -0.70710677+0.j \\end{bmatrix}" +"Function decorator that automatically convert inputs to tensors on " +"current backend" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:63 msgid "" -"\\begin{bmatrix} 0.70710677+0.j & 0.70710677+0.j\\\\ 0.70710677+0.j" -" & -0.70710677+0.j \\end{bmatrix}" +"the wrapped function whose arguments in ``argnums`` position are expected" +" to be tensor format" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **I** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.i_gate`." +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:66 +msgid "position of args under the auto conversion, defaults to 0" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:68 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j " -"\\end{bmatrix}" +"try reshape all input tensor as matrix with shape rank 2, defaults to " +"False" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:71 +msgid "convert ``Gate`` to tensor, defaults to False" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **ISWAP** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.iswap_gate`." +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:73 +msgid "reshape tensor from ``Gate`` input as matrix, defaults to True" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & 0.+0.j & 0.+1.j & 0.+0.j\\\\ 0.+0.j & 0.+1.j & 0.+0.j & " -"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:75 +msgid "convert ``QuOperator`` to tensor, defaults to False" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"0.+0.j & 0.+1.j & 0.+0.j\\\\ 0.+0.j & 0.+1.j & 0.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:77 +msgid "reshape tensor from ``QuOperator`` input as matrix, defaults to True" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply mpo gate in MPO format on the circuit." +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:79 +msgid "whether cast to backend dtype, defaults to True" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply multicontrol gate in MPO format on the circuit." +#: of tensorcircuit.interfaces.tensortrans.args_to_tensor:81 +msgid "The wrapped function" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **ORX** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.orx_gate`." +#: of tensorcircuit.interfaces.tensortrans.general_args_to_numpy:1 +msgid "Given a pytree, get the corresponding numpy array pytree" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **ORY** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.ory_gate`." +#: of tensorcircuit.interfaces.tensortrans.general_args_to_numpy:3 +msgid "pytree" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **ORZ** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.orz_gate`." +#: of tensorcircuit.interfaces.tensortrans.general_args_to_numpy:5 +msgid "the same format pytree with all tensor replaced by numpy array" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **OX** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.ox_gate`." +#: of tensorcircuit.interfaces.tensortrans.numpy_args_to_backend:1 +msgid "Given a pytree of numpy arrays, get the corresponding tensor pytree" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\" -" 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & " -"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.tensortrans.numpy_args_to_backend:3 +msgid "pytree of numpy arrays" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -msgid "" -"\\begin{bmatrix} 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 1.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.tensortrans.numpy_args_to_backend:5 +msgid "str of str of the same pytree shape as args, defaults to None" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 +#: of tensorcircuit.interfaces.tensortrans.numpy_args_to_backend:7 msgid "" -"Apply **OY** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.oy_gate`." +"str or backend object, defaults to None, indicating the current default " +"backend" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 +#: of tensorcircuit.interfaces.tensortrans.numpy_args_to_backend:10 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 0.+0.j & 0.-1.j & 0.+0.j & 0.+0.j\\\\" -" 0.+1.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & " -"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +"the same format pytree with all numpy array replaced by the tensors in " +"the target backend" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -msgid "" -"\\begin{bmatrix} 0.+0.j & 0.-1.j & 0.+0.j & 0.+0.j\\\\ 0.+1.j & " -"0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.tensortrans.which_backend:1 +msgid "Given a tensor ``a``, return the corresponding backend" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 +#: of tensorcircuit.interfaces.tensortrans.which_backend:5 msgid "" -"Apply **OZ** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.oz_gate`." +"if true, return backend object, if false, return backend str, defaults to" +" True" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & -1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & " -"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.interfaces.tensortrans.which_backend:8 +msgid "the backend object or backend str" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"-1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\" -" 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: ../../source/api/interfaces/torch.rst:2 +msgid "tensorcircuit.interfaces.torch" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **R** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.r_gate`." +#: of tensorcircuit.interfaces.torch:1 +msgid "Interface wraps quantum function as a torch function" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **RX** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.rx_gate`." +#: of tensorcircuit.interfaces.torch.torch_interface:1 +msgid "Wrap a quantum function on different ML backend with a pytorch interface." msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **RXX** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.rxx_gate`." +#: ../../source/api/keras.rst:2 +msgid "tensorcircuit.keras" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **RY** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.ry_gate`." +#: of tensorcircuit.keras:1 +msgid "Keras layer for tc quantum function" msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 +#: of tensorcircuit.keras.QuantumLayer.__init__:1 msgid "" -"Apply **RYY** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.ryy_gate`." +"`QuantumLayer` wraps the quantum function `f` as a `keras.Layer` so that " +"tensorcircuit is better integrated with tensorflow. Note that the input " +"of the layer can be tensors or even list/dict of tensors." msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **RZ** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.rz_gate`." +#: of tensorcircuit.keras.QuantumLayer.__init__:5 +msgid "Callabel function." msgstr "" -#: of -#: tensorcircuit.circuit.Circuit.apply_general_variable_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "" -"Apply **RZZ** gate with parameters on the circuit. See " -":py:meth:`tensorcircuit.gates.rzz_gate`." +#: of tensorcircuit.keras.QuantumLayer.__init__:7 +msgid "The shape of the weights." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **S** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.s_gate`." +#: of tensorcircuit.keras.QuantumLayer.__init__:9 +msgid "The initializer of the weights, defaults to \"glorot_uniform\"" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 +#: of tensorcircuit.keras.load_func:1 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+1.j " -"\\end{bmatrix}" +"Load function from the files in the ``tf.savedmodel`` format. We can load" +" several functions at the same time, as they can be the same function of " +"different input shapes." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+1.j \\end{bmatrix}" +#: of tensorcircuit.keras.load_func:24 +msgid "" +"The fallback function when all functions loaded are failed, defaults to " +"None" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 +#: of tensorcircuit.keras.load_func:26 msgid "" -"Apply **SD** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.sd_gate`." +"When there is not legal loaded function of the input shape and no " +"fallback callable." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 +#: of tensorcircuit.keras.load_func:27 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.-1.j " -"\\end{bmatrix}" +"A function that tries all loaded function against the input until the " +"first success one." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.-1.j \\end{bmatrix}" +#: of tensorcircuit.keras.output_asis_loss:1 +msgid "The keras loss function that directly taking the model output as the loss." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **SWAP** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.swap_gate`." +#: of tensorcircuit.keras.output_asis_loss:3 +msgid "Ignoring this parameter." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & " -"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.keras.output_asis_loss:5 +msgid "Model output." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"0.+0.j & 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j \\end{bmatrix}" +#: of tensorcircuit.keras.output_asis_loss:7 +msgid "Model output, which is y_pred." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **T** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.t_gate`." +#: of tensorcircuit.keras.save_func:1 +msgid "Save tf function in the file (``tf.savedmodel`` format)." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j " -"& 0.70710677+0.70710677j \\end{bmatrix}" +#: of tensorcircuit.keras.save_func:30 +msgid "``tf.function`` ed function with graph building" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "" -"\\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j & " -"0.70710677+0.70710677j \\end{bmatrix}" +#: of tensorcircuit.keras.save_func:32 +msgid "the dir path to save the function" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **TD** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.td_gate`." +#: ../../source/api/mps_base.rst:2 +msgid "tensorcircuit.mps_base" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j " -"& 0.70710677-0.70710677j \\end{bmatrix}" +#: of tensorcircuit.mps_base:1 +msgid "FiniteMPS from tensornetwork with bug fixed" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -msgid "" -"\\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j & " -"0.70710677-0.70710677j \\end{bmatrix}" +#: of tensorcircuit.mps_base.FiniteMPS:1 +msgid "Bases: :py:class:`tensornetwork.matrixproductstates.finite_mps.FiniteMPS`" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **TOFFOLI** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.toffoli_gate`." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.__init__:4 +msgid "Initialize a `FiniteMPS`. If `canonicalize` is `True` the state" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.__init__:2 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & " -"1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" -" 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & " -"0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " -"0.+0.j & 1.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " -"0.+0.j & 1.+0.j & 0.+0.j \\end{bmatrix}" +"is brought into canonical form, with `BaseMPS.center_position` at " +"`center_position`. if `center_position` is `None` and `canonicalize = " +"True`, `BaseMPS.center_position` is set to 0." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j &" -" 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & " -"1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & " -"0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ " -"0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\\\" -" 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j" -" \\end{bmatrix}" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.__init__:6 +msgid "A list of `Tensor` objects." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **WROOT** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.wroot_gate`." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.__init__:7 +msgid "The initial position of the center site." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 0.70710677+0.j & -0.5 & -0.5j\\\\ " -"0.5 & -0.5j & 0.70710677+0.j \\end{bmatrix}" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.__init__:8 +msgid "If `True` the mps is canonicalized at initialization." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.__init__:9 msgid "" -"\\begin{bmatrix} 0.70710677+0.j & -0.5 & -0.5j\\\\ 0.5 & -0.5j & " -"0.70710677+0.j \\end{bmatrix}" +"The name of the backend that should be used to perform contractions. " +"Available backends are currently 'numpy', 'tensorflow', 'pytorch', 'jax'" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_one_site_gate:1 msgid "" -"Apply **X** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.x_gate`." +"Apply a one-site gate to an MPS. This routine will in general destroy any" +" canonical form of the state. If a canonical form is needed, the user can" +" restore it using `FiniteMPS.position` :param gate: a one-body gate " +":param site: the site where the gate should be applied" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 0.+0.j & 1.+0.j\\\\ 1.+0.j & 0.+0.j " -"\\end{bmatrix}" +#: of +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:1 +msgid "Compute the action of the MPS transfer-operator at site `site`." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "\\begin{bmatrix} 0.+0.j & 1.+0.j\\\\ 1.+0.j & 0.+0.j \\end{bmatrix}" +#: of +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:3 +msgid "A site of the MPS" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 +#: of +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:4 msgid "" -"Apply **Y** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.y_gate`." +"* if `1, 'l'` or `'left'`: compute the left-action of the MPS transfer-" +"operator at `site` on the input `matrix`. * if `-1, 'r'` or `'right'`: " +"compute the right-action of the MPS transfer-operator at `site` on the " +"input `matrix`" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 +#: of +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:5 msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 0.+0.j & 0.-1.j\\\\ 0.+1.j & 0.+0.j " -"\\end{bmatrix}" +"if `1, 'l'` or `'left'`: compute the left-action of the MPS transfer-" +"operator at `site` on the input `matrix`." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "\\begin{bmatrix} 0.+0.j & 0.-1.j\\\\ 0.+1.j & 0.+0.j \\end{bmatrix}" +#: of +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:7 +msgid "" +"if `-1, 'r'` or `'right'`: compute the right-action of the MPS transfer-" +"operator at `site` on the input `matrix`" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:1 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:1 -msgid "" -"Apply **Z** gate on the circuit. See " -":py:meth:`tensorcircuit.gates.z_gate`." +#: of +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:9 +msgid "A rank-2 tensor or matrix." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:5 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:3 -msgid "" -"Qubit number that the gate applies on. The matrix for the gate is .. " -"math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & -1.+0.j" -" \\end{bmatrix}" +#: of +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:11 +msgid "The result of applying the MPS transfer-operator to `matrix`" msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_gate_delayed..apply:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:6 -msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & -1.+0.j \\end{bmatrix}" +#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:1 +msgid "" +"Apply a two-site gate to an MPS. This routine will in general destroy any" +" canonical form of the state. If a canonical form is needed, the user can" +" restore it using `FiniteMPS.position`." msgstr "" -#: of tensorcircuit.circuit.Circuit.__init__:1 -msgid "Circuit object based on state simulator." +#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:5 +msgid "A two-body gate." msgstr "" -#: of tensorcircuit.circuit.Circuit.__init__:3 -#: tensorcircuit.mpscircuit.MPSCircuit.__init__:3 -msgid "The number of qubits in the circuit." +#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:7 +msgid "The first site where the gate acts." msgstr "" -#: of tensorcircuit.circuit.Circuit.__init__:5 -msgid "" -"If not None, the initial state of the circuit is taken as ``inputs`` " -"instead of :math:`\\vert 0\\rangle^n` qubits, defaults to None." +#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:9 +msgid "The second site where the gate acts." msgstr "" -#: of tensorcircuit.circuit.Circuit.__init__:8 -#: tensorcircuit.circuit.Circuit.replace_mps_inputs:18 -msgid "(Nodes, dangling Edges) for a MPS like initial wavefunction." +#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:15 +msgid "" +"An optional value to choose the MPS tensor at `center_position` to be " +"isometric after the application of the gate. Defaults to `site1`. If the " +"MPS is canonical (i.e.`BaseMPS.center_position != None`), and if the " +"orthogonality center coincides with either `site1` or `site2`, the " +"orthogonality center will be shifted to `center_position` (`site1` by " +"default). If the orthogonality center does not coincide with `(site1, " +"site2)` then `MPS.center_position` is set to `None`." msgstr "" -#: of tensorcircuit.circuit.Circuit.__init__:10 +#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:26 msgid "" -"dict if two qubit gate is ready for split, including parameters for at " -"least one of ``max_singular_values`` and ``max_truncation_err``." +"\"rank of gate is {} but has to be 4\", \"site1 = {} is not between 0 <= " +"site < N - 1 = {}\", \"site2 = {} is not between 1 <= site < N = " +"{}\",\"Found site2 ={}, site1={}. Only nearest neighbor gates are " +"currently supported\", \"f center_position = {center_position} not f in " +"{(site1, site2)} \", or \"center_position = {}, but gate is applied at " +"sites {}, {}. Truncation should only be done if the gate is applied at " +"the center position of the MPS.\"" msgstr "" -#: of tensorcircuit.circuit.Circuit.amplitude:1 -msgid "Returns the amplitude of the circuit given the bitstring l." +#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:32 +msgid "A scalar tensor containing the truncated weight of the truncation." msgstr "" -#: of tensorcircuit.circuit.Circuit.amplitude:13 -msgid "The bitstring of 0 and 1s." +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.bond_dimension:1 +msgid "The bond dimension of `bond`" msgstr "" -#: of tensorcircuit.circuit.Circuit.amplitude:15 -msgid "The amplitude of the circuit." +#: of tensorcircuit.mps_base.FiniteMPS.bond_dimensions:1 +msgid "A list of bond dimensions of `BaseMPS`" msgstr "" -#: of tensorcircuit.circuit.Circuit.append_from_qir:1 +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize:1 msgid "" -"Apply the ciurict in form of quantum intermediate representation after " -"the current cirucit." +"Bring the MPS into canonical form according to `center_position`. If " +"`center_position` is `None`, the MPS is canonicalized with " +"`center_position = 0`." msgstr "" -#: of tensorcircuit.circuit.Circuit.append_from_qir:18 -msgid "The quantum intermediate representation." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize:5 +msgid "If `True`, normalize matrices when shifting the orthogonality center." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_double_gate:1 -msgid "Apply the gate to two bits with given indexes." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize:8 +msgid "The norm of the MPS." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_double_gate:11 -msgid "The Gate applied on bits." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.check_canonical:1 +msgid "Check whether the MPS is in the expected canonical form." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_double_gate:13 -#: tensorcircuit.circuit.Circuit.apply_double_gate:15 -#: tensorcircuit.circuit.Circuit.apply_single_gate:13 -msgid "The index of the bit to apply the Gate." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.check_canonical:3 +msgid "The L2 norm of the vector of local deviations." msgstr "" -#: of tensorcircuit.circuit.Circuit.general_kraus:1 -msgid "" -"Monte Carlo trajectory simulation of general Kraus channel whose Kraus " -"operators cannot be amplified to unitary operators. For unitary operators" -" composed Kraus channel, :py:meth:`unitary_kraus` is much faster." +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality:1 +msgid "Check orthonormality of tensor at site `site`." msgstr "" -#: of tensorcircuit.circuit.Circuit.general_kraus:5 +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality:3 msgid "" -"This function is jittable in theory. But only jax+GPU combination is " -"recommended for jit since the graph building time is too long for other " -"backend options; though the running time of the function is very fast for" -" every case." +"* if `'l'` or `'left'`: check left orthogonality * if `'r`' or `'right'`:" +" check right orthogonality" msgstr "" -#: of tensorcircuit.circuit.Circuit.general_kraus:9 -msgid "A list of ``tn.Node`` for Kraus operators." +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality:4 +msgid "if `'l'` or `'left'`: check left orthogonality" msgstr "" -#: of tensorcircuit.circuit.Circuit.general_kraus:11 -msgid "The qubits index that Kraus channel is applied on." +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality:5 +msgid "if `'r`' or `'right'`: check right orthogonality" msgstr "" -#: of tensorcircuit.circuit.Circuit.general_kraus:13 -msgid "" -"Random tensor uniformly between 0 or 1, defaults to be None, when the " -"random number will be generated automatically" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality:6 +msgid "The site of the tensor." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_single_gate:1 -msgid "Apply the gate to the bit with the given index." +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality:8 +msgid "The L2 norm of the deviation from identity." msgstr "" -#: of tensorcircuit.circuit.Circuit.apply_single_gate:11 -msgid "The Gate applied on the bit." +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality:9 +msgid "scalar `Tensor`" msgstr "" -#: of tensorcircuit.circuit.Circuit.cond_measurement:1 -msgid "" -"Measurement on z basis at ``index`` qubit based on quantum amplitude (not" -" post-selection). The highlight is that this method can return the " -"measured result as a int Tensor and thus maintained a jittable pipeline." +#: of +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality:11 +msgid "If which is different from 'l','left', 'r' or 'right'." msgstr "" -#: of tensorcircuit.circuit.Circuit.cond_measurement:14 -msgid "the qubit for the z-basis measurement" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor:1 +msgid "Returns the `Tensor` object at `site`." msgstr "" -#: of tensorcircuit.circuit.Circuit.cond_measurement:16 -msgid "0 or 1 for z measurement on up and down freedom" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor:3 +msgid "" +"If `site==len(self) - 1` `BaseMPS.connector_matrix` is absorbed fromt the" +" right-hand side into the returned `Tensor` object." msgstr "" -#: of tensorcircuit.circuit.Circuit.select_gate:1 -msgid "Apply ``which``-th gate from ``kraus`` list, i.e. apply kraus[which]" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor:7 +msgid "The site for which to return the `Node`." msgstr "" -#: of tensorcircuit.circuit.Circuit.select_gate:3 -msgid "Tensor of shape [] and dtype int" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor:9 +msgid "The tensor at `site`." msgstr "" -#: of tensorcircuit.circuit.Circuit.select_gate:5 -msgid "A list of gate in the form of ``tc.gate`` or Tensor" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs:1 +msgid "" +"Compute left reduced density matrices for site `sites`. This returns a " +"dict `left_envs` mapping sites (int) to Tensors. `left_envs[site]` is the" +" left-reduced density matrix to the left of site `site`." msgstr "" -#: of tensorcircuit.circuit.Circuit.select_gate:7 -msgid "the qubit lines the gate applied on" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs:5 +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs:5 +msgid "A list of sites of the MPS." msgstr "" -#: of tensorcircuit.circuit.Circuit.depolarizing:1 -msgid "" -"Apply depolarizing channel in a Monte Carlo way, i.e. for each call of " -"this method, one of gates from X, Y, Z, I are applied on the circuit " -"based on the probability indicated by ``px``, ``py``, ``pz``." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs:8 +msgid "The left-reduced density matrices at each site in `sites`." msgstr "" -#: of tensorcircuit.circuit.Circuit.depolarizing:6 -msgid "The qubit that depolarizing channel is on" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs:10 +msgid "The left-reduced density matrices" msgstr "" -#: of tensorcircuit.circuit.Circuit.depolarizing:8 -msgid "probability for X noise" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs:11 +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs:11 +msgid "at each site in `sites`." msgstr "" -#: of tensorcircuit.circuit.Circuit.depolarizing:10 -msgid "probability for Y noise" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.left_envs:12 +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs:12 +msgid "`dict` mapping `int` to `Tensor`" msgstr "" -#: of tensorcircuit.circuit.Circuit.depolarizing:12 -msgid "probability for Z noise" +#: of tensorcircuit.mps_base.FiniteMPS.measure_local_operator:1 +msgid "Measure the expectation value of local operators `ops` site `sites`." msgstr "" -#: of tensorcircuit.circuit.Circuit.depolarizing:14 -msgid "random seed uniformly from 0 to 1, defaults to None (generated implicitly)" +#: of tensorcircuit.mps_base.FiniteMPS.measure_local_operator:3 +msgid "A list Tensors of rank 2; the local operators to be measured." msgstr "" -#: of tensorcircuit.circuit.Circuit.depolarizing:16 -msgid "int Tensor, the element lookup: [0: x, 1: y, 2: z, 3: I]" +#: of tensorcircuit.mps_base.FiniteMPS.measure_local_operator:5 +msgid "Sites where `ops` act." +msgstr "" + +#: of tensorcircuit.mps_base.FiniteMPS.measure_local_operator:7 +msgid "measurements :math:`\\langle` `ops[n]`:math:`\\rangle` for n in `sites`" msgstr "" -#: of tensorcircuit.circuit.Circuit.draw:1 +#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:1 msgid "" -"Visualise the circuit. This method recevies the keywords as same as " -"qiskit.circuit.QuantumCircuit.draw. More details can be found here: " -"https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.draw.html." +"Compute the correlator :math:`\\langle` `op1[site1], " +"op2[s]`:math:`\\rangle` between `site1` and all sites `s` in `sites2`. If" +" `s == site1`, `op2[s]` will be applied first." msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation:1 -#: tensorcircuit.densitymatrix.DMCircuit.expectation:1 -msgid "Compute the expectation of corresponding operators." +#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:6 +msgid "Tensor of rank 2; the local operator at `site1`." msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation:10 -#: tensorcircuit.densitymatrix.DMCircuit.expectation:3 -msgid "" -"Operator and its position on the circuit, eg. ``(tc.gates.z(), [1, ]), " -"(tc.gates.x(), [2, ])`` is for operator :math:`Z_1X_2`." +#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:8 +msgid "Tensor of rank 2; the local operator at `sites2`." msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation:13 -msgid "" -"If True, then the wavefunction tensor is cached for further expectation " -"evaluation, defaults to be true." +#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:10 +msgid "The site where `op1` acts" msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation:16 -msgid "whether enable light cone simplification, defaults to False" +#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:12 +msgid "Sites where operator `op2` acts." msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation:18 -#: tensorcircuit.circuit.expectation:50 -msgid "\"Cannot measure two operators in one index\"" +#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:14 +msgid "" +"Correlator :math:`\\langle` `op1[site1], op2[s]`:math:`\\rangle` for `s` " +":math:`\\in` `sites2`." msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation:19 -#: tensorcircuit.densitymatrix.DMCircuit.expectation:6 -msgid "Tensor with one element" +#: of tensorcircuit.mps_base.FiniteMPS.physical_dimensions:1 +msgid "A list of physical Hilbert-space dimensions of `BaseMPS`" msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation_before:1 -msgid "" -"Return the list of nodes that consititues the expectation value just " -"before the contraction." +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.position:1 +msgid "Shift `center_position` to `site`." msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation_before:3 -msgid "whether contract the output state firstly, defaults to True" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.position:3 +msgid "The site to which FiniteMPS.center_position should be shifted" msgstr "" -#: of tensorcircuit.circuit.Circuit.expectation_before:5 -msgid "The tensor network for the expectation" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.position:4 +msgid "If `True`, normalize matrices when shifting." msgstr "" -#: of tensorcircuit.circuit._expectation_ps:1 +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.position:5 +msgid "If not `None`, truncate the MPS bond dimensions to `D`." +msgstr "" + +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.position:6 msgid "" -"Shortcut for Pauli string expectation. x, y, z list are for X, Y, Z " -"positions" +"if not `None`, truncate each bond dimension, but keeping the truncation " +"error below `max_truncation_err`." msgstr "" -#: of tensorcircuit.circuit._expectation_ps:12 -#: tensorcircuit.circuit._expectation_ps:14 -#: tensorcircuit.circuit._expectation_ps:16 -msgid "_description_, defaults to None" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.position:9 +msgid "The norm of the tensor at `FiniteMPS.center_position`" msgstr "" -#: of tensorcircuit.circuit._expectation_ps:18 -msgid "whether to cache and reuse the wavefunction, defaults to True" +#: of tensornetwork.matrixproductstates.base_mps.BaseMPS.position:12 +msgid "If `center_position` is `None`." msgstr "" -#: of tensorcircuit.circuit._expectation_ps:20 -msgid "Expectation value" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.random:1 +msgid "" +"Initialize a random `FiniteMPS`. The resulting state is normalized. Its " +"center-position is at 0." msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qir:1 -msgid "Restore the circuit from the quantum intermediate representation." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.random:4 +msgid "A list of physical dimensions." msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qir:21 -#: tensorcircuit.translation.qir2qiskit:14 -msgid "The quantum intermediate representation of a circuit." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.random:5 +msgid "A list of bond dimensions." msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qir:23 -msgid "Extra circuit parameters." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.random:6 +msgid "A numpy dtype." msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qir:25 -msgid "The circuit have same gates in the qir." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.random:7 +msgid "An optional backend." msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qiskit:1 -msgid "Import Qiskit QuantumCircuit object as a ``tc.Circuit`` object." +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.random:9 +msgid "`FiniteMPS`" msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qiskit:12 -msgid "Qiskit Circuit object" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs:1 +msgid "" +"Compute right reduced density matrices for site `sites. This returns a " +"dict `right_envs` mapping sites (int) to Tensors. `right_envs[site]` is " +"the right-reduced density matrix to the right of site `site`." msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qiskit:14 -msgid "The number of qubits for the circuit" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs:8 +msgid "The right-reduced density matrices at each site in `sites`." msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qiskit:16 -msgid "possible input wavefunction for ``tc.Circuit``, defaults to None" +#: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.right_envs:10 +msgid "The right-reduced density matrices" msgstr "" -#: of tensorcircuit.circuit.Circuit.from_qiskit:18 -msgid "The same circuit but as tensorcircuit object" +#: ../../source/api/mpscircuit.rst:2 +msgid "tensorcircuit.mpscircuit" msgstr "" -#: of tensorcircuit.circuit.Circuit.get_quoperator:1 -msgid "" -"Get the ``QuOperator`` MPO like representation of the circuit unitary " -"without contraction." +#: of tensorcircuit.mpscircuit:1 +msgid "Quantum circuit: MPS state simulator" msgstr "" -#: of tensorcircuit.circuit.Circuit.get_quoperator:3 -msgid "" -"``QuOperator`` object for the circuit unitary (open indices for the input" -" state)" +#: of tensorcircuit.mpscircuit.MPSCircuit:1 +msgid "``MPSCircuit`` class. Simple usage demo below." msgstr "" -#: of tensorcircuit.circuit.Circuit.get_quvector:1 -msgid "" -"Get the representation of the output state in the form of ``QuVector`` " -"while maintaining the circuit uncomputed" +#: of tensorcircuit.mpscircuit.MPSCircuit.MPO_to_gate:1 +msgid "Convert MPO to gate" msgstr "" -#: of tensorcircuit.circuit.Circuit.get_quvector:4 -msgid "``QuVector`` representation of the output state from the circuit" +#: of tensorcircuit.mpscircuit.MPSCircuit.__init__:1 +msgid "MPSCircuit object based on state simulator." msgstr "" -#: of tensorcircuit.circuit.Circuit.is_valid:1 -msgid "[WIP], check whether the circuit is legal." +#: of tensorcircuit.mpscircuit.MPSCircuit.__init__:5 +msgid "The center position of MPS, default to 0" msgstr "" -#: of tensorcircuit.circuit.Circuit.is_valid:3 -msgid "The bool indicating whether the circuit is legal" +#: of tensorcircuit.mpscircuit.MPSCircuit.__init__:7 +msgid "" +"If not None, the initial state of the circuit is taken as ``tensors`` " +"instead of :math:`\\vert 0\\rangle^n` qubits, defaults to None. When " +"``tensors`` are specified, if ``center_position`` is None, then the " +"tensors are canonicalized, otherwise it is assumed the tensors are " +"already canonicalized at the ``center_position``" msgstr "" -#: of tensorcircuit.circuit.Circuit.matrix:1 +#: of tensorcircuit.mpscircuit.MPSCircuit.__init__:12 msgid "" -"Get the unitary matrix for the circuit irrespective with the circuit " -"input state." +"If not None, it is transformed to the MPS form according to the split " +"rules" msgstr "" -#: of tensorcircuit.circuit.Circuit.matrix:3 -msgid "The circuit unitary matrix" +#: of tensorcircuit.mpscircuit.MPSCircuit.__init__:14 +msgid "Split rules" msgstr "" -#: of tensorcircuit.circuit.Circuit.measure_jit:1 -msgid "" -"Take measurement to the given quantum lines. This method is jittable is " -"and about 100 times faster than unjit version!" +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate:1 +msgid "Apply a general qubit gate on MPS." msgstr "" -#: of tensorcircuit.circuit.Circuit.measure_jit:4 -#: tensorcircuit.circuit.Circuit.measure_reference:16 -#: tensorcircuit.densitymatrix.DMCircuit.measure_jit:3 -msgid "Measure on which quantum line." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:3 +#: tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate:3 +#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate:3 +msgid "The Gate to be applied" msgstr "" -#: of tensorcircuit.circuit.Circuit.measure_jit:6 -#: tensorcircuit.circuit.Circuit.measure_reference:17 -#: tensorcircuit.densitymatrix.DMCircuit.measure_jit:5 -msgid "If true, theoretical probability is also returned." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate:6 +msgid "Qubit indices of the gate" msgstr "" -#: of tensorcircuit.circuit.Circuit.measure_jit:8 -#: tensorcircuit.circuit.Circuit.measure_reference:18 -#: tensorcircuit.densitymatrix.DMCircuit.measure_jit:7 -msgid "The sample output and probability (optional) of the quantum line." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate:5 +msgid "\"MPS does not support application of gate on > 2 qubits.\"" msgstr "" -#: of tensorcircuit.circuit.Circuit.measure_reference:1 -msgid "Take measurement on the given quantum lines by ``index``." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_MPO:1 +msgid "Apply a MPO to the MPS" msgstr "" -#: of tensorcircuit.circuit.Circuit.mid_measurement:1 +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:1 msgid "" -"Middle measurement in z-basis on the circuit, note the wavefunction " -"output is not normalized with ``mid_measurement`` involved, one should " -"normalize the state manually if needed. This is a post-selection method " -"as keep is provided as a prior." +"Apply a double qubit gate on adjacent qubits of Matrix Product States " +"(MPS)." msgstr "" -#: of tensorcircuit.circuit.Circuit.mid_measurement:5 -msgid "The index of qubit that the Z direction postselection applied on." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:5 +#: tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate:5 +msgid "The first qubit index of the gate" msgstr "" -#: of tensorcircuit.circuit.Circuit.mid_measurement:7 -msgid "0 for spin up, 1 for spin down, defaults to be 0." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:7 +#: tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate:7 +msgid "The second qubit index of the gate" msgstr "" -#: of tensorcircuit.circuit.Circuit.perfect_sampling:1 -msgid "" -"Sampling bistrings from the circuit output based on quantum amplitudes. " -"Reference: arXiv:1201.3974." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:9 +msgid "Center position of MPS, default is None" msgstr "" -#: of tensorcircuit.circuit.Circuit.perfect_sampling:4 -#: tensorcircuit.densitymatrix.DMCircuit.perfect_sampling:3 -msgid "Sampled bit string and the corresponding theoretical probability." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate:1 +msgid "Apply a double qubit gate on MPS." msgstr "" -#: of tensorcircuit.circuit.Circuit.replace_inputs:1 -msgid "Replace the input state with the circuit structure unchanged." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_nqubit_gate:1 +msgid "Apply a n-qubit gate by transforming the gate to MPO" msgstr "" -#: of tensorcircuit.circuit.Circuit.replace_inputs:3 -msgid "Input wavefunction." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_single_gate:1 +msgid "Apply a single qubit gate on MPS; no truncation is needed." msgstr "" -#: of tensorcircuit.circuit.Circuit.replace_mps_inputs:1 -msgid "" -"Replace the input state in MPS representation while keep the circuit " -"structure unchanged." +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_single_gate:3 +msgid "gate to be applied" msgstr "" -#: of tensorcircuit.circuit.Circuit.sample:1 -msgid "batched sampling from state or circuit tensor network directly" +#: of tensorcircuit.mpscircuit.MPSCircuit.apply_single_gate:5 +msgid "Qubit index of the gate" msgstr "" -#: of tensorcircuit.circuit.Circuit.sample:3 -msgid "number of samples, defaults to None" +#: of tensorcircuit.mpscircuit.MPSCircuit.conj:1 +msgid "Compute the conjugate of the current MPS." msgstr "" -#: of tensorcircuit.circuit.Circuit.sample:5 -msgid "" -"if true, we sample from the final state if memory allsows, True is " -"prefered, defaults to False" +#: of tensorcircuit.mpscircuit.MPSCircuit.conj:3 +#: tensorcircuit.mpscircuit.MPSCircuit.copy:3 +#: tensorcircuit.mpscircuit.MPSCircuit.copy_without_tensor:3 +msgid "The constructed MPS" msgstr "" -#: of tensorcircuit.circuit.Circuit.sample:8 -msgid "random generator, defaults to None" +#: of tensorcircuit.mpscircuit.MPSCircuit.copy:1 +msgid "Copy the current MPS." msgstr "" -#: of tensorcircuit.circuit.Circuit.sample:10 -msgid "" -"List (if batch) of tuple (binary configuration tensor and correponding " -"probability)" +#: of tensorcircuit.mpscircuit.MPSCircuit.copy_without_tensor:1 +msgid "Copy the current MPS without the tensors." msgstr "" -#: of tensorcircuit.circuit.Circuit.wavefunction:1 -#: tensorcircuit.mpscircuit.MPSCircuit.wavefunction:1 -msgid "Compute the output wavefunction from the circuit." +#: of tensorcircuit.mpscircuit.MPSCircuit.expectation:1 +msgid "Compute the expectation of corresponding operators in the form of tensor." msgstr "" -#: of tensorcircuit.circuit.Circuit.wavefunction:3 +#: of tensorcircuit.mpscircuit.MPSCircuit.expectation:3 msgid "" -"The str indicating the form of the output wavefunction. \"default\": " -"[-1], \"ket\": [-1, 1], \"bra\": [1, -1]" +"Operator and its position on the circuit, eg. ``(gates.Z(), [1]), " +"(gates.X(), [2])`` is for operator :math:`Z_1X_2`" msgstr "" -#: of tensorcircuit.circuit.Circuit.wavefunction:6 -msgid "Tensor with the corresponding shape." +#: of tensorcircuit.mpscircuit.MPSCircuit.expectation:9 +msgid "If not None, will be used as bra" msgstr "" -#: of tensorcircuit.circuit.Circuit.vis_tex:1 -msgid "Generate latex string based on quantikz latex package" +#: of tensorcircuit.mpscircuit.MPSCircuit.expectation:11 +msgid "Whether to conjugate the bra state" msgstr "" -#: of tensorcircuit.circuit.Circuit.vis_tex:3 -msgid "Latex string that can be directly compiled via, e.g. latexit" +#: of tensorcircuit.mpscircuit.MPSCircuit.expectation:13 +msgid "Whether to normalize the MPS" msgstr "" -#: of tensorcircuit.circuit.Circuit.to_qir:1 -msgid "Return the quantum intermediate representation of the circuit." +#: of tensorcircuit.mpscircuit.MPSCircuit.expectation:15 +#: tensorcircuit.mpscircuit.MPSCircuit.set_split_rules:5 +#: tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors:5 +msgid "Truncation split" msgstr "" -#: of tensorcircuit.circuit.Circuit.to_qir:32 -msgid "The quantum intermediate representation of the circuit." +#: of tensorcircuit.mpscircuit.MPSCircuit.expectation:17 +msgid "The expectation of corresponding operators" msgstr "" -#: of tensorcircuit.circuit.Circuit.to_qiskit:1 -msgid "Translate ``tc.Circuit`` to a qiskit QuantumCircuit object." +#: of tensorcircuit.mpscircuit.MPSCircuit.gate_to_MPO:1 +msgid "Convert gate to MPO form with identities at empty sites" msgstr "" -#: of tensorcircuit.circuit.Circuit.to_qiskit:3 -msgid "A qiskit object of this circuit." +#: of tensorcircuit.mpscircuit.MPSCircuit.get_bond_dimensions:1 +msgid "Get the MPS bond dimensions" msgstr "" -#: of tensorcircuit.circuit.Circuit.unitary_kraus:1 -msgid "" -"Apply unitary gates in ``kraus`` randomly based on corresponding " -"``prob``. If ``prob`` is ``None``, this is reduced to kraus channel " -"language." +#: of tensorcircuit.mpscircuit.MPSCircuit.get_bond_dimensions:3 +#: tensorcircuit.mpscircuit.MPSCircuit.get_tensors:3 +msgid "MPS tensors" msgstr "" -#: of tensorcircuit.circuit.Circuit.unitary_kraus:4 -msgid "List of ``tc.gates.Gate`` or just Tensors" +#: of tensorcircuit.mpscircuit.MPSCircuit.get_center_position:1 +msgid "Get the center position of the MPS" msgstr "" -#: of tensorcircuit.circuit.Circuit.unitary_kraus:6 -msgid "prob list with the same size as ``kraus``, defaults to None" +#: of tensorcircuit.mpscircuit.MPSCircuit.get_center_position:3 +msgid "center position" msgstr "" -#: of tensorcircuit.circuit.Circuit.unitary_kraus:8 -msgid "random seed between 0 to 1, defaults to None" +#: of tensorcircuit.mpscircuit.MPSCircuit.get_norm:1 +msgid "Get the normalized Center Position." msgstr "" -#: of tensorcircuit.circuit.Circuit.unitary_kraus:10 -msgid "shape [] int dtype tensor indicates which kraus gate is actually applied" +#: of tensorcircuit.mpscircuit.MPSCircuit.get_norm:3 +msgid "Normalized Center Position." msgstr "" -#: of tensorcircuit.circuit.expectation:1 -msgid "Compute :math:`\\langle bra\\vert ops \\vert ket\\rangle`." +#: of tensorcircuit.mpscircuit.MPSCircuit.get_quvector:2 +msgid "Get the representation of the output state in the form of ``QuVector``" msgstr "" -#: of tensorcircuit.circuit.expectation:3 -msgid "Example 1 (:math:`bra` is same as :math:`ket`)" +#: of tensorcircuit.mpscircuit.MPSCircuit.get_quvector:2 +msgid "has to be full contracted in MPS" msgstr "" -#: of tensorcircuit.circuit.expectation:24 -msgid "Example 2 (:math:`bra` is different from :math:`ket`)" +#: of tensorcircuit.mpscircuit.MPSCircuit.get_tensors:1 +msgid "Get the MPS tensors" msgstr "" -#: of tensorcircuit.circuit.expectation:42 -msgid ":math:`ket`. The state in tensor or ``QuVector`` format" +#: of tensorcircuit.mpscircuit.MPSCircuit.is_valid:1 +msgid "Check whether the circuit is legal." msgstr "" -#: of tensorcircuit.circuit.expectation:44 -msgid ":math:`bra`, defaults to None, which is the same as ``ket``." +#: of tensorcircuit.mpscircuit.MPSCircuit.is_valid:3 +msgid "Whether the circuit is legal." msgstr "" -#: of tensorcircuit.circuit.expectation:46 +#: of tensorcircuit.mpscircuit.MPSCircuit.measure:1 +msgid "Take measurement to the given quantum lines." +msgstr "" + +#: of tensorcircuit.mpscircuit.MPSCircuit.mid_measurement:1 msgid "" -":math:`bra` changes to the adjoint matrix of :math:`bra`, defaults to " -"True." +"Middle measurement in the z-basis on the circuit, note the wavefunction " +"output is not normalized with ``mid_measurement`` involved, one should " +"normalized the state manually if needed." msgstr "" -#: of tensorcircuit.circuit.expectation:48 -msgid "Normalize the :math:`ket` and :math:`bra`, defaults to False." +#: of tensorcircuit.mpscircuit.MPSCircuit.mid_measurement:4 +msgid "The index of qubit that the Z direction postselection applied on" msgstr "" -#: of tensorcircuit.circuit.expectation:51 -msgid "The result of :math:`\\langle bra\\vert ops \\vert ket\\rangle`." +#: of tensorcircuit.mpscircuit.MPSCircuit.mid_measurement:6 +msgid "0 for spin up, 1 for spin down, defaults to 0" msgstr "" -#: of tensorcircuit.circuit.to_graphviz:1 -msgid "" -"Not an ideal visualization for quantum circuit, but reserve here as a " -"general approach to show the tensornetwork [Deprecated, use " -"``Circuit.vis_tex`` or ``Circuit.draw`` instead]" +#: of tensorcircuit.mpscircuit.MPSCircuit.normalize:1 +msgid "Normalize MPS Circuit according to the center position." msgstr "" -#: ../../source/api/cons.rst:2 -msgid "tensorcircuit.cons" +#: of tensorcircuit.mpscircuit.MPSCircuit.position:1 +msgid "Wrapper of tn.FiniteMPS.position. Set orthogonality center." msgstr "" -#: of tensorcircuit.cons:1 -msgid "Constants and setups" +#: of tensorcircuit.mpscircuit.MPSCircuit.position:4 +msgid "The orthogonality center" msgstr "" -#: of tensorcircuit.cons.get_contractor:1 tensorcircuit.cons.set_contractor:1 -msgid "" -"To set runtime contractor of the tensornetwork for a better contraction " -"path. For more information on the usage of contractor, please refer to " -"independent tutorial." +#: of tensorcircuit.mpscircuit.MPSCircuit.proj_with_mps:1 +msgid "Compute the projection between `other` as bra and `self` as ket." msgstr "" -#: of tensorcircuit.cons.get_contractor:4 tensorcircuit.cons.set_contractor:4 -msgid "" -"\"auto\", \"greedy\", \"branch\", \"plain\", \"tng\", \"custom\", " -"\"custom_stateful\". defaults to None (\"auto\")" +#: of tensorcircuit.mpscircuit.MPSCircuit.proj_with_mps:3 +msgid "ket of the other MPS, which will be converted to bra automatically" msgstr "" -#: of tensorcircuit.cons.get_contractor:6 tensorcircuit.cons.set_contractor:6 -msgid "Valid for \"custom\" or \"custom_stateful\" as method, defaults to None" +#: of tensorcircuit.mpscircuit.MPSCircuit.proj_with_mps:5 +msgid "The projection in form of tensor" msgstr "" -#: of tensorcircuit.cons.get_contractor:8 tensorcircuit.cons.set_contractor:8 -msgid "" -"It is not very useful, as ``memory_limit`` leads to ``branch`` " -"contraction instead of ``greedy`` which is rather slow, defaults to None" +#: of tensorcircuit.mpscircuit.MPSCircuit.reduce_dimension:1 +msgid "Reduce the bond dimension between two adjacent sites by SVD" msgstr "" -#: of tensorcircuit.cons.get_contractor:11 tensorcircuit.cons.set_contractor:11 -msgid "Tensornetwork version is too low to support some of the contractors." +#: of tensorcircuit.mpscircuit.MPSCircuit.reduce_tensor_dimension:1 +msgid "Reduce the bond dimension between two general tensors by SVD" msgstr "" -#: of tensorcircuit.cons.get_contractor:12 tensorcircuit.cons.set_contractor:12 -msgid "Unknown method options." +#: of tensorcircuit.mpscircuit.MPSCircuit.set_split_rules:1 +msgid "" +"Set truncation split when double qubit gates are applied. If nothing is " +"specified, no truncation will take place and the bond dimension will keep" +" growing. For more details, refer to `split_tensor`." msgstr "" -#: of tensorcircuit.cons.get_contractor:13 tensorcircuit.cons.set_contractor:13 -msgid "The new tensornetwork with its contractor set." +#: of tensorcircuit.mpscircuit.MPSCircuit.slice:1 +msgid "Get a slice of the MPS (only for internal use)" msgstr "" -#: of tensorcircuit.cons.get_dtype:1 tensorcircuit.cons.set_dtype:1 -msgid "Set the global runtime numerical dtype of tensors." +#: of tensorcircuit.mpscircuit.MPSCircuit.wavefunction:3 +msgid "the str indicating the form of the output wavefunction" msgstr "" -#: of tensorcircuit.cons.get_dtype:3 tensorcircuit.cons.set_dtype:3 -msgid "" -"\"complex64\" or \"complex128\", defaults to None, which is equivalent to" -" \"complex64\"." +#: of tensorcircuit.mpscircuit.MPSCircuit.wavefunction:5 +msgid "Tensor with shape [1, -1]" msgstr "" -#: of tensorcircuit.cons.get_dtype:5 tensorcircuit.cons.set_dtype:5 -msgid "complex dtype str and the corresponding real dtype str" +#: of tensorcircuit.mpscircuit.MPSCircuit.wavefunction:9 +msgid "i--A--B--j -> i--XX--j" msgstr "" -#: of tensorcircuit.cons.plain_contractor:1 -msgid "The naive state-vector simulator contraction path." +#: of tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors:1 +msgid "Construct the MPS tensors from a given wavefunction." msgstr "" -#: of tensorcircuit.cons.plain_contractor:3 -msgid "The list of ``tn.Node``." +#: of tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors:3 +msgid "The given wavefunction (any shape is OK)" msgstr "" -#: of tensorcircuit.cons.plain_contractor:5 -msgid "The list of dangling node edges, defaults to be None." +#: of tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors:7 +msgid "Physical dimension, 2 for MPS and 4 for MPO" msgstr "" -#: of tensorcircuit.cons.plain_contractor:7 -msgid "The ``tn.Node`` after contraction" +#: of tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors:9 +msgid "Whether to normalize the wavefunction" msgstr "" -#: of tensorcircuit.cons.runtime_backend:1 -msgid "Context manager to set with-level runtime backend" +#: of tensorcircuit.mpscircuit.MPSCircuit.wavefunction_to_tensors:11 +msgid "The tensors" msgstr "" -#: of tensorcircuit.cons.runtime_backend:3 -#: tensorcircuit.cons.set_function_backend:3 -msgid "\"numpy\", \"tensorflow\", \"jax\", \"pytorch\", defaults to None" +#: of tensorcircuit.mpscircuit.split_tensor:1 +msgid "Split the tensor by SVD or QR depends on whether a truncation is required." msgstr "" -#: of tensorcircuit.cons.runtime_backend tensorcircuit.cons.runtime_contractor -#: tensorcircuit.cons.runtime_dtype -msgid "yield" +#: of tensorcircuit.mpscircuit.split_tensor:3 +msgid "The input tensor to split." msgstr "" -#: of tensorcircuit.cons.runtime_backend:5 -msgid "the backend object" +#: of tensorcircuit.mpscircuit.split_tensor:5 +msgid "Determine the orthogonal center is on the left tensor or the right tensor." msgstr "" -#: of tensorcircuit.cons.runtime_contractor:1 -msgid "Context manager to change with-levek contractor" +#: of tensorcircuit.mpscircuit.split_tensor:7 +msgid "Two tensors after splitting" msgstr "" -#: of tensorcircuit.cons.runtime_dtype:1 -msgid "Context manager to set with-level runtime dtype" +#: ../../source/api/noisemodel.rst:2 +msgid "tensorcircuit.noisemodel" msgstr "" -#: of tensorcircuit.cons.runtime_dtype:3 -msgid "\"complex64\" or \"complex128\", defaults to None (\"complex64\")" +#: of tensorcircuit.noisemodel:1 +msgid "General Noise Model Construction." msgstr "" -#: of tensorcircuit.cons.runtime_dtype:5 -msgid "complex dtype str and real dtype str" +#: of tensorcircuit.noisemodel.NoiseConf:1 +msgid "``Noise Configuration`` class." msgstr "" -#: of tensorcircuit.cons.set_tensornetwork_backend:1 -msgid "To set the runtime backend of tensorcircuit." +#: of tensorcircuit.noisemodel.NoiseConf.__init__:1 +msgid "Establish a noise configuration." msgstr "" -#: of tensorcircuit.cons.set_tensornetwork_backend:3 +#: of tensorcircuit.noisemodel.NoiseConf.add_noise:1 msgid "" -"Note: ``tc.set_backend`` and ``tc.cons.set_tensornetwork_backend`` are " -"the same." +"Add noise channels on specific gates and specific qubits in form of Kraus" +" operators." msgstr "" -#: of tensorcircuit.cons.set_tensornetwork_backend:27 -msgid "" -"\"numpy\", \"tensorflow\", \"jax\", \"pytorch\". defaults to None, which " -"gives the same behavior as " -"``tensornetwork.backend_contextmanager.get_default_backend()``." +#: of tensorcircuit.noisemodel.NoiseConf.add_noise:3 +msgid "noisy gate" msgstr "" -#: of tensorcircuit.cons.set_tensornetwork_backend:30 -msgid "Whether the object should be set as global." +#: of tensorcircuit.noisemodel.NoiseConf.add_noise:5 +msgid "noise channel" msgstr "" -#: of tensorcircuit.cons.set_function_backend:1 -msgid "Function decorator to set function-level runtime backend" +#: of tensorcircuit.noisemodel.NoiseConf.add_noise:7 +msgid "" +"the list of noisy qubit, defaults to None, indicating applying the noise " +"channel on all qubits" msgstr "" -#: of tensorcircuit.cons.set_function_backend:5 -msgid "Decorated function" +#: of tensorcircuit.noisemodel.apply_qir_with_noise:1 +msgid "A newly defined circuit" msgstr "" -#: of tensorcircuit.cons.set_function_contractor:1 -msgid "Function decorate to change function-level contractor" +#: of tensorcircuit.noisemodel.apply_qir_with_noise:3 +msgid "The qir of the clean circuit" msgstr "" -#: of tensorcircuit.cons.set_function_dtype:1 -msgid "Function decorator to set function-level numerical dtype" +#: of tensorcircuit.noisemodel.apply_qir_with_noise:5 +#: tensorcircuit.noisemodel.circuit_with_noise:5 +msgid "Noise Configuration" msgstr "" -#: of tensorcircuit.cons.set_function_dtype:3 -msgid "\"complex64\" or \"complex128\", defaults to None" +#: of tensorcircuit.noisemodel.apply_qir_with_noise:7 +#: tensorcircuit.noisemodel.circuit_with_noise:7 +msgid "The status for Monte Carlo sampling, defaults to None" msgstr "" -#: of tensorcircuit.cons.set_function_dtype:5 -msgid "The decorated function" +#: of tensorcircuit.noisemodel.apply_qir_with_noise:9 +#: tensorcircuit.noisemodel.circuit_with_noise:9 +msgid "A newly constructed circuit with noise" msgstr "" -#: ../../source/api/densitymatrix.rst:2 -msgid "tensorcircuit.densitymatrix" +#: of tensorcircuit.noisemodel.circuit_with_noise:1 +msgid "Noisify a clean circuit." msgstr "" -#: of tensorcircuit.densitymatrix:1 -msgid "Quantum circuit class but with density matrix simulator" +#: of tensorcircuit.noisemodel.circuit_with_noise:3 +msgid "A clean circuit" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.__init__:1 -msgid "The density matrix simulator based on tensornetwork engine." +#: of tensorcircuit.noisemodel.expectation_noisfy:1 +msgid "Calculate expectation value with noise configuration." msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.__init__:3 -msgid "Number of qubits" +#: of tensorcircuit.noisemodel.expectation_noisfy:3 +#: tensorcircuit.noisemodel.sample_expectation_ps_noisfy:3 +msgid "The clean circuit" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.__init__:5 -msgid "if True, nothing initialized, only for internal use, defaults to False" +#: of tensorcircuit.noisemodel.expectation_noisfy:12 +msgid "expectation value with noise" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.__init__:7 -msgid "the state input for the circuit, defaults to None" +#: of tensorcircuit.noisemodel.sample_expectation_ps_noisfy:1 +msgid "Calculate sample_expectation_ps with noise configuration." msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.__init__:9 -msgid "the density matrix input for the circuit, defaults to None" +#: of tensorcircuit.noisemodel.sample_expectation_ps_noisfy:13 +msgid "" +"repetition time for Monte Carlo sampling for noisfy calculation, " +"defaults to 1000" msgstr "" -#: of -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 -#: tensorcircuit.densitymatrix2.DMCircuit2.apply_general_kraus_delayed..apply:1 +#: of tensorcircuit.noisemodel.sample_expectation_ps_noisfy:20 msgid "" -"Apply amplitudedamping quantum channel on the circuit. See " -":py:meth:`tensorcircuit.channels.amplitudedampingchannel`" +"external randomness given by tensor uniformly from [0, 1], defaults to " +"None, used for measurement sampling" msgstr "" -#: of -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:6 -#: tensorcircuit.densitymatrix2.DMCircuit2.apply_general_kraus_delayed..apply:6 -msgid "Parameters for the channel." +#: of tensorcircuit.noisemodel.sample_expectation_ps_noisfy:23 +msgid "sample expectation value with noise" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.densitymatrix:1 -msgid "Return the output density matrix of the circuit." +#: ../../source/api/quantum.rst:2 +msgid "tensorcircuit.quantum" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.densitymatrix:3 -msgid "" -"check whether the final return is a legal density matrix, defaults to " -"False" +#: of tensorcircuit.quantum:1 +msgid "Quantum state and operator class backend by tensornetwork" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.densitymatrix:5 -msgid "whether to reuse previous results, defaults to True" +#: of tensorcircuit.quantum +msgid "IMPORT" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.densitymatrix:7 -msgid "The output densitymatrix in 2D shape tensor form" +#: of tensorcircuit.quantum.PauliString2COO:1 +#: tensorcircuit.quantum.PauliStringSum2COO_tf:1 +msgid "Generate tensorflow sparse matrix from Pauli string sum" msgstr "" -#: of -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 -#: tensorcircuit.densitymatrix2.DMCircuit2.apply_general_kraus_delayed..apply:1 +#: of tensorcircuit.quantum.PauliString2COO:3 msgid "" -"Apply depolarizing quantum channel on the circuit. See " -":py:meth:`tensorcircuit.channels.depolarizingchannel`" +"1D Tensor representing for a Pauli string, e.g. [1, 0, 0, 3, 2] is for " +":math:`X_0Z_3Y_4`" +msgstr "" + +#: of tensorcircuit.quantum.PauliString2COO:6 +msgid "" +"the weight for the Pauli string defaults to None (all Pauli strings " +"weight 1.0)" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.measure_jit:1 -msgid "Take measurement to the given quantum lines." +#: of tensorcircuit.quantum.PauliString2COO:9 +msgid "the tensorflow sparse matrix" msgstr "" -#: of tensorcircuit.densitymatrix.DMCircuit.perfect_sampling:1 -msgid "Sampling bistrings from the circuit output based on quantum amplitudes." +#: of tensorcircuit.quantum.PauliStringSum2COO:1 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:1 +msgid "Generate sparse tensor from Pauli string sum" msgstr "" -#: of -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 -#: tensorcircuit.densitymatrix2.DMCircuit2.apply_general_kraus_delayed..apply:1 +#: of tensorcircuit.quantum.PauliStringSum2COO:3 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:3 +#: tensorcircuit.quantum.PauliStringSum2COO_tf:3 +#: tensorcircuit.quantum.PauliStringSum2Dense:3 msgid "" -"Apply phasedamping quantum channel on the circuit. See " -":py:meth:`tensorcircuit.channels.phasedampingchannel`" +"2D Tensor, each row is for a Pauli string, e.g. [1, 0, 0, 3, 2] is for " +":math:`X_0Z_3Y_4`" msgstr "" -#: of -#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 -#: tensorcircuit.densitymatrix2.DMCircuit2.apply_general_kraus_delayed..apply:1 +#: of tensorcircuit.quantum.PauliStringSum2COO:6 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:6 +#: tensorcircuit.quantum.PauliStringSum2COO_tf:6 +#: tensorcircuit.quantum.PauliStringSum2Dense:6 msgid "" -"Apply reset quantum channel on the circuit. See " -":py:meth:`tensorcircuit.channels.resetchannel`" +"1D Tensor, each element corresponds the weight for each Pauli string " +"defaults to None (all Pauli strings weight 1.0)" msgstr "" -#: ../../source/api/densitymatrix2.rst:2 -msgid "tensorcircuit.densitymatrix2" +#: of tensorcircuit.quantum.PauliStringSum2COO:9 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:9 +#: tensorcircuit.quantum.PauliStringSum2Dense:9 +msgid "" +"default False. If True, return numpy coo else return backend compatible " +"sparse tensor" msgstr "" -#: of tensorcircuit.densitymatrix2:1 -msgid "Quantum circuit class but with density matrix simulator: v2" +#: of tensorcircuit.quantum.PauliStringSum2COO:12 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:12 +msgid "the scipy coo sparse matrix" msgstr "" -#: of tensorcircuit.densitymatrix2.DMCircuit2:1 -msgid "Bases: :py:class:`tensorcircuit.densitymatrix.DMCircuit`" +#: of tensorcircuit.quantum.PauliStringSum2COO_tf:9 +msgid "the tensorflow coo sparse matrix" msgstr "" -#: ../../source/api/experimental.rst:2 -msgid "tensorcircuit.experimental" +#: of tensorcircuit.quantum.PauliStringSum2Dense:1 +msgid "Generate dense matrix from Pauli string sum" msgstr "" -#: of tensorcircuit.experimental:1 -msgid "Experimental features" +#: of tensorcircuit.quantum.PauliStringSum2Dense:12 +msgid "the tensorflow dense matrix" msgstr "" -#: ../../source/api/gates.rst:2 -msgid "tensorcircuit.gates" +#: of tensorcircuit.quantum.QuAdjointVector:1 tensorcircuit.quantum.QuScalar:1 +#: tensorcircuit.quantum.QuVector:1 +msgid "Bases: :py:class:`tensorcircuit.quantum.QuOperator`" msgstr "" -#: of tensorcircuit.gates:1 -msgid "" -"Declarations of single-qubit and two-qubit gates and their corresponding " -"matrix." +#: of tensorcircuit.quantum.QuAdjointVector:1 +msgid "Represents an adjoint (row) vector via a tensor network." msgstr "" -#: of tensorcircuit.gates.Gate:1 -msgid "Bases: :py:class:`tensornetwork.network_components.Node`" +#: of tensorcircuit.quantum.QuAdjointVector.__init__:1 +msgid "" +"Constructs a new `QuAdjointVector` from a tensor network. This " +"encapsulates an existing tensor network, interpreting it as an adjoint " +"vector (row vector)." msgstr "" -#: of tensorcircuit.gates.Gate:1 -msgid "Wrapper of tn.Node, quantum gate" +#: of tensorcircuit.quantum.QuAdjointVector.__init__:5 +#: tensorcircuit.quantum.QuOperator.__init__:9 +msgid "The edges of the network to be used as the input edges." msgstr "" -#: of tensorcircuit.gates.GateVF:1 -msgid "Bases: :py:class:`tensorcircuit.gates.GateF`" +#: of tensorcircuit.quantum.QuAdjointVector.__init__:7 +#: tensorcircuit.quantum.QuOperator.__init__:11 +#: tensorcircuit.quantum.QuVector.__init__:6 +msgid "" +"Nodes used to refer to parts of the tensor network that are not connected" +" to any input or output edges (for example: a scalar factor)." msgstr "" -#: of tensorcircuit.gates.any_gate:1 -msgid "Note one should provide the gate with properly reshaped." +#: of tensorcircuit.quantum.QuAdjointVector.__init__:10 +#: tensorcircuit.quantum.QuScalar.__init__:7 +#: tensorcircuit.quantum.QuVector.__init__:9 +msgid "Optional collection of edges to ignore when performing consistency checks." msgstr "" -#: of tensorcircuit.gates.any_gate:3 -msgid "corresponding gate" +#: of tensorcircuit.quantum.QuOperator.adjoint:1 +msgid "" +"The adjoint of the operator. This creates a new `QuOperator` with " +"complex-conjugate copies of all tensors in the network and with the input" +" and output edges switched." msgstr "" -#: of tensorcircuit.gates.any_gate:5 -msgid "The name of the gate." +#: of tensorcircuit.quantum.QuOperator.adjoint:5 +msgid "The adjoint of the operator." msgstr "" -#: of tensorcircuit.gates.any_gate:7 -msgid "the resulted gate" +#: of tensorcircuit.quantum.QuOperator.check_network:1 +msgid "" +"Check that the network has the expected dimensionality. This checks that " +"all input and output edges are dangling and that there are no other " +"dangling edges (except any specified in `ignore_edges`). If not, an " +"exception is raised." msgstr "" -#: of tensorcircuit.gates.num_to_tensor:1 -msgid "Convert the inputs to Tensor with specified dtype." +#: of tensorcircuit.quantum.QuOperator.contract:1 +msgid "" +"Contract the tensor network in place. This modifies the tensor network " +"representation of the operator (or vector, or scalar), reducing it to a " +"single tensor, without changing the value." msgstr "" -#: of tensorcircuit.gates.num_to_tensor:35 -msgid "inputs" +#: of tensorcircuit.quantum.QuOperator.contract:5 +msgid "Manually specify the axis ordering of the final tensor." msgstr "" -#: of tensorcircuit.gates.num_to_tensor:37 -msgid "dtype of the output Tensors" +#: of tensorcircuit.quantum.QuOperator.contract:7 +msgid "The present object." msgstr "" -#: of tensorcircuit.gates.num_to_tensor:39 -msgid "List of Tensors" +#: of tensorcircuit.quantum.QuOperator.copy:1 +msgid "The deep copy of the operator." msgstr "" -#: of tensorcircuit.gates.bmatrix:1 -msgid "Returns a :math:`\\LaTeX` bmatrix." +#: of tensorcircuit.quantum.QuOperator.copy:3 +msgid "The new copy of the operator." msgstr "" -#: of tensorcircuit.gates.bmatrix:13 -msgid "Formatted Display:" +#: of tensorcircuit.quantum.QuOperator.eval:1 +msgid "" +"Contracts the tensor network in place and returns the final tensor. Note " +"that this modifies the tensor network representing the operator. The " +"default ordering for the axes of the final tensor is: `*out_edges, " +"*in_edges`. If there are any \"ignored\" edges, their axes come first: " +"`*ignored_edges, *out_edges, *in_edges`." msgstr "" -#: of tensorcircuit.gates.bmatrix:15 +#: of tensorcircuit.quantum.QuOperator.eval:8 +#: tensorcircuit.quantum.QuOperator.eval_matrix:6 msgid "" -"\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j \\end{bmatrix}" -"\n" -"\n" +"Manually specify the axis ordering of the final tensor. The default " +"ordering is determined by `out_edges` and `in_edges` (see above)." msgstr "" -#: of tensorcircuit.gates.bmatrix:18 -msgid "2D numpy array" +#: of tensorcircuit.quantum.QuOperator.eval:11 +#: tensorcircuit.quantum.QuOperator.eval_matrix:9 +msgid "Node count '{}' > 1 after contraction!" msgstr "" -#: of tensorcircuit.gates.bmatrix:20 -msgid "ValueError(\"bmatrix can at most display two dimensions\")" +#: of tensorcircuit.quantum.QuOperator.eval:12 +msgid "The final tensor representing the operator." msgstr "" -#: of tensorcircuit.gates.bmatrix:21 -msgid ":math:`\\LaTeX`-formatted string for bmatrix of the array a" +#: of tensorcircuit.quantum.QuOperator.eval_matrix:1 +msgid "" +"Contracts the tensor network in place and returns the final tensor in two" +" dimentional matrix. The default ordering for the axes of the final " +"tensor is: (:math:`\\prod` dimension of out_edges, :math:`\\prod` " +"dimension of in_edges)" msgstr "" -#: of tensorcircuit.gates.cr_gate:1 -msgid "" -"Controlled rotation gate. When the control qubit is 1, `rgate` is applied" -" to the target qubit." +#: of tensorcircuit.quantum.QuOperator.eval_matrix:10 +msgid "The two-dimentional tensor representing the operator." msgstr "" -#: of tensorcircuit.gates.cr_gate:3 tensorcircuit.gates.cr_gate:5 -#: tensorcircuit.gates.cr_gate:7 tensorcircuit.gates.exponential_gate:8 -#: tensorcircuit.gates.exponential_gate_unity:9 -#: tensorcircuit.gates.iswap_gate:12 tensorcircuit.gates.r_gate:9 -#: tensorcircuit.gates.r_gate:11 tensorcircuit.gates.r_gate:13 -#: tensorcircuit.gates.rgate_theoretical:8 -#: tensorcircuit.gates.rgate_theoretical:10 -#: tensorcircuit.gates.rgate_theoretical:12 tensorcircuit.gates.rx_gate:6 -#: tensorcircuit.gates.rxx_gate:9 tensorcircuit.gates.ry_gate:6 -#: tensorcircuit.gates.ryy_gate:9 tensorcircuit.gates.rz_gate:6 -#: tensorcircuit.gates.rzz_gate:9 -msgid "angle in radians" +#: of tensorcircuit.quantum.QuAdjointVector.from_tensor:1 +msgid "" +"Construct a `QuAdjointVector` directly from a single tensor. This first " +"wraps the tensor in a `Node`, then constructs the `QuAdjointVector` from " +"that `Node`." msgstr "" -#: of tensorcircuit.gates.cr_gate:10 -msgid "CR Gate" +#: of tensorcircuit.quantum.QuAdjointVector.from_tensor:27 +msgid "The tensor for constructing an QuAdjointVector." msgstr "" -#: of tensorcircuit.gates.exponential_gate_unity:1 -#: tensorcircuit.gates.rxx_gate:1 tensorcircuit.gates.ryy_gate:1 -#: tensorcircuit.gates.rzz_gate:1 +#: of tensorcircuit.quantum.QuAdjointVector.from_tensor:29 msgid "" -"Faster exponential gate directly implemented based on RHS. Only works " -"when :math:`U^2 = I` is an identity matrix." +"Sequence of integer indices specifying the order in which to interpret " +"the axes as subsystems (input edges). If not specified, the axes are " +"taken in ascending order." msgstr "" -#: of tensorcircuit.gates.exponential_gate_unity:3 -#: tensorcircuit.gates.rxx_gate:3 tensorcircuit.gates.ryy_gate:3 -#: tensorcircuit.gates.rzz_gate:3 +#: of tensorcircuit.quantum.QuAdjointVector.from_tensor:33 +msgid "The new constructed QuAdjointVector give from the given tensor." +msgstr "" + +#: of tensorcircuit.quantum.QuOperator.is_adjoint_vector:1 msgid "" -"\\textrm{exp}(U) &= e^{-j \\theta U} \\\\\n" -" &= \\cos(\\theta) I - j \\sin(\\theta) U \\\\\n" -"\n" +"Returns a bool indicating if QuOperator is an adjoint vector. Examples " +"can be found in the `QuOperator.from_tensor`." msgstr "" -#: of tensorcircuit.gates.exponential_gate:6 -#: tensorcircuit.gates.exponential_gate_unity:7 tensorcircuit.gates.rxx_gate:7 -#: tensorcircuit.gates.ryy_gate:7 tensorcircuit.gates.rzz_gate:7 -msgid "input unitary :math:`U`" +#: of tensorcircuit.quantum.QuOperator.is_scalar:1 +msgid "" +"Returns a bool indicating if QuOperator is a scalar. Examples can be " +"found in the `QuOperator.from_tensor`." msgstr "" -#: of tensorcircuit.gates.exponential_gate:10 -#: tensorcircuit.gates.exponential_gate_unity:11 -#: tensorcircuit.gates.rxx_gate:11 tensorcircuit.gates.ryy_gate:11 -#: tensorcircuit.gates.rzz_gate:11 -msgid "suffix of Gate name" +#: of tensorcircuit.quantum.QuOperator.is_vector:1 +msgid "" +"Returns a bool indicating if QuOperator is a vector. Examples can be " +"found in the `QuOperator.from_tensor`." msgstr "" -#: of tensorcircuit.gates.exponential_gate:11 -#: tensorcircuit.gates.exponential_gate_unity:13 -#: tensorcircuit.gates.rxx_gate:13 tensorcircuit.gates.ryy_gate:13 -#: tensorcircuit.gates.rzz_gate:13 -msgid "Exponential Gate" +#: of tensorcircuit.quantum.QuAdjointVector.nodes:1 +#: tensorcircuit.quantum.QuOperator.nodes:1 +#: tensorcircuit.quantum.QuScalar.nodes:1 +#: tensorcircuit.quantum.QuVector.nodes:1 +msgid "All tensor-network nodes involved in the operator." msgstr "" -#: of tensorcircuit.gates.exponential_gate:1 -msgid "Exponential gate." +#: of tensorcircuit.quantum.QuOperator.norm:1 +msgid "" +"The norm of the operator. This is the 2-norm (also known as the Frobenius" +" or Hilbert-Schmidt norm)." msgstr "" -#: of tensorcircuit.gates.exponential_gate:3 +#: of tensorcircuit.quantum.QuOperator.partial_trace:1 msgid "" -"\\textrm{exp}(U) = e^{-j \\theta U}\n" -"\n" +"The partial trace of the operator. Subsystems to trace out are supplied " +"as indices, so that dangling edges are connected to each other as: " +"`out_edges[i] ^ in_edges[i] for i in subsystems_to_trace_out` This does " +"not modify the original network. The original ordering of the remaining " +"subsystems is maintained." msgstr "" -#: of tensorcircuit.gates.iswap_gate:1 -msgid "iSwap gate." +#: of tensorcircuit.quantum.QuAdjointVector.reduced_density:16 +#: tensorcircuit.quantum.QuOperator.partial_trace:8 +#: tensorcircuit.quantum.QuVector.reduced_density:16 +msgid "Indices of subsystems to trace out." msgstr "" -#: of tensorcircuit.gates.iswap_gate:3 -msgid "" -"\\textrm{iSwap}(\\theta) =\n" -"\\begin{pmatrix}\n" -" 1 & 0 & 0 & 0\\\\\n" -" 0 & \\cos(\\frac{\\pi}{2} \\theta ) & j \\sin(\\frac{\\pi}{2} \\theta" -" ) & 0\\\\\n" -" 0 & j \\sin(\\frac{\\pi}{2} \\theta ) & \\cos(\\frac{\\pi}{2} \\theta" -" ) & 0\\\\\n" -" 0 & 0 & 0 & 1\\\\\n" -"\\end{pmatrix}\n" -"\n" +#: of tensorcircuit.quantum.QuOperator.partial_trace:10 +msgid "A new QuOperator or QuScalar representing the result." msgstr "" -#: of tensorcircuit.gates.iswap_gate:14 -msgid "iSwap Gate" +#: of tensorcircuit.quantum.QuAdjointVector.projector:1 +#: tensorcircuit.quantum.QuVector.projector:1 +msgid "" +"The projector of the operator. The operator, as a linear operator, on the" +" adjoint of the operator." msgstr "" -#: of tensorcircuit.gates.matrix_for_gate:1 -msgid "Convert Gate to numpy array." +#: of tensorcircuit.quantum.QuAdjointVector.projector:4 +msgid "" +"Set :math:`A` is the operator in matrix form, then the projector of " +"operator is defined as: :math:`A^\\dagger A`" msgstr "" -#: of tensorcircuit.gates.matrix_for_gate:10 -msgid "input Gate" +#: of tensorcircuit.quantum.QuAdjointVector.projector:6 +#: tensorcircuit.quantum.QuVector.projector:6 +msgid "The projector of the operator." msgstr "" -#: of tensorcircuit.gates.matrix_for_gate:12 -msgid "Corresponding Tensor" +#: of tensorcircuit.quantum.QuAdjointVector.reduced_density:1 +#: tensorcircuit.quantum.QuVector.reduced_density:1 +msgid "The reduced density of the operator." msgstr "" -#: of tensorcircuit.gates.meta_gate:1 +#: of tensorcircuit.quantum.QuAdjointVector.reduced_density:3 +#: tensorcircuit.quantum.QuVector.reduced_density:3 msgid "" -"Inner helper function to generate gate functions, such as ``z()`` from " -"``_z_matrix``" +"Set :math:`A` is the matrix of the operator, then the reduced density is " +"defined as:" msgstr "" -#: of tensorcircuit.gates.r_gate:1 -msgid "General single qubit rotation gate" +#: of tensorcircuit.quantum.QuAdjointVector.reduced_density:5 +msgid "\\mathrm{Tr}_{subsystems}(A^\\dagger A)" msgstr "" -#: of tensorcircuit.gates.r_gate:3 +#: of tensorcircuit.quantum.QuAdjointVector.reduced_density:9 +#: tensorcircuit.quantum.QuVector.reduced_density:9 msgid "" -"R(\\theta, \\alpha, \\phi) = j \\cos(\\theta) I\n" -"- j \\cos(\\phi) \\sin(\\alpha) \\sin(\\theta) X\n" -"- j \\sin(\\phi) \\sin(\\alpha) \\sin(\\theta) Y\n" -"- j \\sin(\\theta) \\cos(\\alpha) Z\n" -"\n" +"Firstly, take the projector of the operator, then trace out the " +"subsystems to trace out are supplied as indices, so that dangling edges " +"are connected to each other as: `out_edges[i] ^ in_edges[i] for i in " +"subsystems_to_trace_out` This does not modify the original network. The " +"original ordering of the remaining subsystems is maintained." msgstr "" -#: of tensorcircuit.gates.r_gate:16 -msgid "R Gate" +#: of tensorcircuit.quantum.QuAdjointVector.reduced_density:18 +#: tensorcircuit.quantum.QuVector.reduced_density:18 +msgid "" +"The QuOperator of the reduced density of the operator with given " +"subsystems." msgstr "" -#: of tensorcircuit.gates.random_single_qubit_gate:1 -msgid "Random single qubit gate described in https://arxiv.org/abs/2002.07730." +#: of tensorcircuit.quantum.QuOperator.tensor_product:1 +msgid "" +"Tensor product with another operator. Given two operators `A` and `B`, " +"produces a new operator `AB` representing :math:`A ⊗ B`. The `out_edges` " +"(`in_edges`) of `AB` is simply the concatenation of the `out_edges` " +"(`in_edges`) of `A.copy()` with that of `B.copy()`: `new_out_edges = " +"[*out_edges_A_copy, *out_edges_B_copy]` `new_in_edges = " +"[*in_edges_A_copy, *in_edges_B_copy]`" msgstr "" -#: of tensorcircuit.gates.random_single_qubit_gate:3 -msgid "A random single-qubit gate" +#: of tensorcircuit.quantum.QuOperator.tensor_product:20 +msgid "The other operator (`B`)." msgstr "" -#: of tensorcircuit.gates.random_two_qubit_gate:1 -msgid "Returns a random two-qubit gate." +#: of tensorcircuit.quantum.QuOperator.tensor_product:22 +msgid "The result (`AB`)." msgstr "" -#: of tensorcircuit.gates.random_two_qubit_gate:3 -msgid "A random two-qubit gate" +#: of tensorcircuit.quantum.QuOperator.trace:1 +msgid "The trace of the operator." msgstr "" -#: of tensorcircuit.gates.rgate_theoretical:1 +#: of tensorcircuit.quantum.QuOperator:1 msgid "" -"Rotation gate implemented by matrix exponential. The output is the same " -"as `rgate`." +"Represents a linear operator via a tensor network. To interpret a tensor " +"network as a linear operator, some of the dangling edges must be " +"designated as `out_edges` (output edges) and the rest as `in_edges` " +"(input edges). Considered as a matrix, the `out_edges` represent the row " +"index and the `in_edges` represent the column index. The (right) action " +"of the operator on another then consists of connecting the `in_edges` of " +"the first operator to the `out_edges` of the second. Can be used to do " +"simple linear algebra with tensor networks." msgstr "" -#: of tensorcircuit.gates.rgate_theoretical:3 +#: of tensorcircuit.quantum.QuOperator.__init__:1 msgid "" -"R(\\theta, \\alpha, \\phi) = e^{-j \\theta \\left[\\sin(\\alpha) " -"\\cos(\\phi) X\n" -" + \\sin(\\alpha) \\sin(\\phi) " -"Y\n" -" + \\cos(\\alpha) Z\\right]}\n" -"\n" +"Creates a new `QuOperator` from a tensor network. This encapsulates an " +"existing tensor network, interpreting it as a linear operator. The " +"network is checked for consistency: All dangling edges must either be in " +"`out_edges`, `in_edges`, or `ignore_edges`." msgstr "" -#: of tensorcircuit.gates.rgate_theoretical:14 -msgid "Rotation Gate" +#: of tensorcircuit.quantum.QuOperator.__init__:7 +#: tensorcircuit.quantum.QuVector.__init__:4 +msgid "The edges of the network to be used as the output edges." msgstr "" -#: of tensorcircuit.gates.rx_gate:1 -msgid "Rotation gate along :math:`x` axis." +#: of tensorcircuit.quantum.QuOperator.__init__:15 +msgid "" +"Optional collection of dangling edges to ignore when performing " +"consistency checks." msgstr "" -#: of tensorcircuit.gates.rx_gate:3 +#: of tensorcircuit.quantum.QuOperator.__init__:18 msgid "" -"RX(\\theta) = e^{-j\\frac{\\theta}{2}X}\n" -"\n" +"At least one reference node is required to specify a scalar. None " +"provided!" msgstr "" -#: of tensorcircuit.gates.rx_gate:8 -msgid "RX Gate" +#: of tensorcircuit.quantum.QuOperator.from_tensor:1 +msgid "" +"Construct a `QuOperator` directly from a single tensor. This first wraps " +"the tensor in a `Node`, then constructs the `QuOperator` from that " +"`Node`." msgstr "" -#: of tensorcircuit.gates.ry_gate:1 -msgid "Rotation gate along :math:`y` axis." +#: of tensorcircuit.quantum.QuOperator.from_tensor:28 +msgid "The tensor." msgstr "" -#: of tensorcircuit.gates.ry_gate:3 -msgid "" -"RY(\\theta) = e^{-j\\frac{\\theta}{2}Y}\n" -"\n" +#: of tensorcircuit.quantum.QuOperator.from_tensor:30 +msgid "The axis indices of `tensor` to use as `out_edges`." msgstr "" -#: of tensorcircuit.gates.ry_gate:8 -msgid "RY Gate" +#: of tensorcircuit.quantum.QuOperator.from_tensor:32 +msgid "The axis indices of `tensor` to use as `in_edges`." msgstr "" -#: of tensorcircuit.gates.rz_gate:1 -msgid "Rotation gate along :math:`z` axis." +#: of tensorcircuit.quantum.QuOperator.from_tensor:34 +msgid "The new operator." msgstr "" -#: of tensorcircuit.gates.rz_gate:3 -msgid "" -"RZ(\\theta) = e^{-j\\frac{\\theta}{2}Z}\n" -"\n" +#: of tensorcircuit.quantum.QuScalar:1 +msgid "Represents a scalar via a tensor network." msgstr "" -#: of tensorcircuit.gates.rz_gate:8 -msgid "RZ Gate" +#: of tensorcircuit.quantum.QuScalar.__init__:1 +msgid "" +"Constructs a new `QuScalar` from a tensor network. This encapsulates an " +"existing tensor network, interpreting it as a scalar." msgstr "" -#: ../../source/api/interfaces.rst:2 -msgid "tensorcircuit.interfaces" +#: of tensorcircuit.quantum.QuScalar.__init__:4 +msgid "" +"Nodes used to refer to the tensor network (need not be exhaustive - one " +"node from each disconnected subnetwork is sufficient)." msgstr "" -#: of tensorcircuit.interfaces:1 -msgid "Interfaces bridging different backends" +#: of tensorcircuit.quantum.QuScalar.from_tensor:1 +msgid "" +"Construct a `QuScalar` directly from a single tensor. This first wraps " +"the tensor in a `Node`, then constructs the `QuScalar` from that `Node`." msgstr "" -#: of tensorcircuit.interfaces.scipy_optimize_interface:1 -msgid "Convert ``fun`` into a scipy optimize interface compatible version" +#: of tensorcircuit.quantum.QuScalar.from_tensor:22 +msgid "The tensor for constructing a new QuScalar." msgstr "" -#: of tensorcircuit.interfaces.scipy_optimize_interface:35 -msgid "The quantum function with scalar out that to be optimized" +#: of tensorcircuit.quantum.QuScalar.from_tensor:24 +msgid "The new constructed QuScalar from the given tensor." msgstr "" -#: of tensorcircuit.interfaces.scipy_optimize_interface:37 -msgid "the shape of parameters that ``fun`` accepts, defaults to None" +#: of tensorcircuit.quantum.QuVector:1 +msgid "Represents a (column) vector via a tensor network." msgstr "" -#: of tensorcircuit.interfaces.scipy_optimize_interface:39 -msgid "whether to jit ``fun``, defaults to True" +#: of tensorcircuit.quantum.QuVector.__init__:1 +msgid "" +"Constructs a new `QuVector` from a tensor network. This encapsulates an " +"existing tensor network, interpreting it as a (column) vector." msgstr "" -#: of tensorcircuit.interfaces.scipy_optimize_interface:41 +#: of tensorcircuit.quantum.QuVector.from_tensor:1 msgid "" -"whether using gradient-based or gradient free scipy optimize interface, " -"defaults to True" +"Construct a `QuVector` directly from a single tensor. This first wraps " +"the tensor in a `Node`, then constructs the `QuVector` from that `Node`." msgstr "" -#: of tensorcircuit.interfaces.scipy_optimize_interface:44 -msgid "The scipy interface compatible version of ``fun``" +#: of tensorcircuit.quantum.QuVector.from_tensor:28 +msgid "The tensor for constructing a \"QuVector\"." msgstr "" -#: of tensorcircuit.interfaces.torch_interface:1 -msgid "Wrap a quantum function on different ML backend with a pytorch interface." +#: of tensorcircuit.quantum.QuVector.from_tensor:30 +msgid "" +"Sequence of integer indices specifying the order in which to interpret " +"the axes as subsystems (output edges). If not specified, the axes are " +"taken in ascending order." msgstr "" -#: of tensorcircuit.interfaces.torch_interface:28 -msgid "The quantum function with tensor in and tensor out" +#: of tensorcircuit.quantum.QuVector.from_tensor:34 +msgid "The new constructed QuVector from the given tensor." msgstr "" -#: of tensorcircuit.interfaces.torch_interface:30 -msgid "whether to jit ``fun``, defaults to False" +#: of tensorcircuit.quantum.QuVector.projector:4 +msgid "" +"Set :math:`A` is the operator in matrix form, then the projector of " +"operator is defined as: :math:`A A^\\dagger`" msgstr "" -#: of tensorcircuit.interfaces.torch_interface:32 +#: of tensorcircuit.quantum.QuVector.reduced_density:5 +msgid "\\mathrm{Tr}_{subsystems}(A A^\\dagger)" +msgstr "" + +#: of tensorcircuit.quantum.check_spaces:1 msgid "" -"The same quantum function but now with torch tensor in and torch tensor " -"out while AD is also supported" +"Check the vector spaces represented by two lists of edges are compatible." +" The number of edges must be the same and the dimensions of each pair of " +"edges must match. Otherwise, an exception is raised." msgstr "" -#: ../../source/api/keras.rst:2 -msgid "tensorcircuit.keras" +#: of tensorcircuit.quantum.check_spaces:5 tensorcircuit.quantum.check_spaces:7 +msgid "List of edges representing a many-body Hilbert space." msgstr "" -#: of tensorcircuit.keras:1 -msgid "Keras layer for tc quantum function" +#: of tensorcircuit.quantum.check_spaces:10 +msgid "" +"Hilbert-space mismatch: \"Cannot connect {} subsystems with {} " +"subsystems\", or \"Input dimension {} != output dimension {}.\"" msgstr "" -#: of tensorcircuit.keras.QuantumLayer.__init__:1 +#: of tensorcircuit.quantum.correlation_from_counts:1 msgid "" -"`QuantumLayer` wraps the quantum function `f` as a `keras.Layer` so that " -"tensorcircuit is better integrated with tensorflow." +"Compute :math:`\\prod_{i\\in \\\\text{index}} s_i`, where the probability" +" for each bitstring is given as a vector ``results``. Results is in the " +"format of \"count_vector\"" msgstr "" -#: of tensorcircuit.keras.QuantumLayer.__init__:4 -msgid "Callabel function." +#: of tensorcircuit.quantum.correlation_from_counts:13 +#: tensorcircuit.quantum.correlation_from_samples:4 +msgid "list of int, indicating the position in the bitstring" msgstr "" -#: of tensorcircuit.keras.QuantumLayer.__init__:6 -msgid "The shape of the weights." +#: of tensorcircuit.quantum.correlation_from_counts:15 +msgid "probability vector of shape 2^n" msgstr "" -#: of tensorcircuit.keras.QuantumLayer.__init__:8 -msgid "The initializer of the weights, defaults to \"glorot_uniform\"" +#: of tensorcircuit.quantum.correlation_from_counts:17 +msgid "Correlation expectation from measurement shots." msgstr "" -#: of tensorcircuit.keras.load_func:1 +#: of tensorcircuit.quantum.correlation_from_samples:1 msgid "" -"Load function from the files in the ``tf.savedmodel`` format. We can load" -" several functions at the same time, as they can be the same function of " -"different input shapes." +"Compute :math:`\\prod_{i\\in \\\\text{index}} s_i (s=\\pm 1)`, Results is" +" in the format of \"sample_int\" or \"sample_bin\"" msgstr "" -#: of tensorcircuit.keras.load_func:24 -msgid "" -"The fallback function when all functions loaded are failed, defaults to " -"None" +#: of tensorcircuit.quantum.correlation_from_samples:6 +msgid "sample tensor" msgstr "" -#: of tensorcircuit.keras.load_func:26 +#: of tensorcircuit.quantum.correlation_from_samples:10 +msgid "Correlation expectation from measurement shots" +msgstr "" + +#: of tensorcircuit.quantum.count_d2s:1 msgid "" -"When there is not legal loaded function of the input shape and no " -"fallback callable." +"measurement shots results, dense representation to sparse tuple " +"representation non-jittable due to the non fixed return shape count_tuple" +" to count_vector" msgstr "" -#: of tensorcircuit.keras.load_func:27 +#: of tensorcircuit.quantum.count_d2s:12 +msgid "cutoff to determine nonzero elements, defaults to 1e-7" +msgstr "" + +#: of tensorcircuit.quantum.count_s2d:1 msgid "" -"A function that tries all loaded function against the input until the " -"first success one." +"measurement shots results, sparse tuple representation to dense " +"representation count_vector to count_tuple" msgstr "" -#: of tensorcircuit.keras.output_asis_loss:1 -msgid "The keras loss function that directly taking the model output as the loss." +#: of tensorcircuit.quantum.count_tuple2dict:1 +msgid "count_tuple to count_dict_bin or count_dict_int" msgstr "" -#: of tensorcircuit.keras.output_asis_loss:3 -msgid "Ignoring this parameter." +#: of tensorcircuit.quantum.count_tuple2dict:3 +msgid "count_tuple format" msgstr "" -#: of tensorcircuit.keras.output_asis_loss:5 -msgid "Model output." +#: of tensorcircuit.quantum.count_tuple2dict:7 +#: tensorcircuit.quantum.count_vector2dict:7 +msgid "can be \"int\" or \"bin\", defaults to \"bin\"" +msgstr "" + +#: of tensorcircuit.quantum.count_tuple2dict:9 +msgid "count_dict" +msgstr "" + +#: of tensorcircuit.quantum.count_vector2dict:1 +msgid "convert_vector to count_dict_bin or count_dict_int" msgstr "" -#: of tensorcircuit.keras.output_asis_loss:7 -msgid "Model output, which is y_pred." +#: of tensorcircuit.quantum.count_vector2dict:3 +msgid "tensor in shape [2**n]" msgstr "" -#: of tensorcircuit.keras.save_func:1 -msgid "Save tf function in the file (``tf.savedmodel`` format)." +#: of tensorcircuit.quantum.double_state:1 +msgid "Compute the double state of the given Hamiltonian operator ``h``." msgstr "" -#: of tensorcircuit.keras.save_func:30 -msgid "``tf.function`` ed function with graph building" +#: of tensorcircuit.quantum.double_state:3 tensorcircuit.quantum.gibbs_state:3 +#: tensorcircuit.quantum.truncated_free_energy:5 +msgid "Hamiltonian operator in form of Tensor." msgstr "" -#: of tensorcircuit.keras.save_func:32 -msgid "the dir path to save the function" +#: of tensorcircuit.quantum.double_state:5 tensorcircuit.quantum.free_energy:17 +#: tensorcircuit.quantum.gibbs_state:5 +#: tensorcircuit.quantum.renyi_free_energy:16 +#: tensorcircuit.quantum.truncated_free_energy:7 +msgid "Constant for the optimization, default is 1." msgstr "" -#: ../../source/api/mps_base.rst:2 -msgid "tensorcircuit.mps_base" +#: of tensorcircuit.quantum.double_state:7 +msgid "The double state of ``h`` with the given ``beta``." msgstr "" -#: of tensorcircuit.mps_base:1 -msgid "FiniteMPS from tensornetwork with bug fixed" +#: of tensorcircuit.quantum.eliminate_identities:1 +msgid "" +"Eliminates any connected CopyNodes that are identity matrices. This will " +"modify the network represented by `nodes`. Only identities that are " +"connected to other nodes are eliminated." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS:1 -msgid "Bases: :py:class:`tensornetwork.matrixproductstates.finite_mps.FiniteMPS`" +#: of tensorcircuit.quantum.eliminate_identities:5 +msgid "Collection of nodes to search." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:1 +#: of tensorcircuit.quantum.eliminate_identities:7 msgid "" -"Apply a two-site gate to an MPS. This routine will in general destroy any" -" canonical form of the state. If a canonical form is needed, the user can" -" restore it using `FiniteMPS.position`." +"The Dictionary mapping remaining Nodes to any replacements, Dictionary " +"specifying all dangling-edge replacements." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:5 -msgid "A two-body gate." +#: of tensorcircuit.quantum.entropy:1 +msgid "Compute the entropy from the given density matrix ``rho``." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:7 -msgid "The first site where the gate acts." +#: of tensorcircuit.quantum.entropy:30 tensorcircuit.quantum.free_energy:13 +#: tensorcircuit.quantum.renyi_entropy:3 +#: tensorcircuit.quantum.renyi_free_energy:12 +msgid "The density matrix in form of Tensor or QuOperator." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:9 -msgid "The second site where the gate acts." +#: of tensorcircuit.quantum.entropy:32 tensorcircuit.quantum.free_energy:19 +msgid "Epsilon, default is 1e-12." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:11 -#: tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction:5 -#: tensorcircuit.mpscircuit.MPSCircuit.set_truncation_rule:5 -#: tensorcircuit.mpscircuit.split_tensor:7 -msgid "The maximum number of singular values to keep." +#: of tensorcircuit.quantum.entropy:34 +msgid "Entropy on the given density matrix." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:13 -#: tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction:7 -#: tensorcircuit.mpscircuit.MPSCircuit.set_truncation_rule:7 -#: tensorcircuit.mpscircuit.split_tensor:9 -msgid "The maximum allowed truncation error." +#: of tensorcircuit.quantum.fidelity:1 +msgid "Return fidelity scalar between two states rho and rho0." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:15 -msgid "" -"An optional value to choose the MPS tensor at `center_position` to be " -"isometric after the application of the gate. Defaults to `site1`. If the " -"MPS is canonical (i.e.`BaseMPS.center_position != None`), and if the " -"orthogonality center coincides with either `site1` or `site2`, the " -"orthogonality center will be shifted to `center_position` (`site1` by " -"default). If the orthogonality center does not coincide with `(site1, " -"site2)` then `MPS.center_position` is set to `None`." +#: of tensorcircuit.quantum.fidelity:3 +msgid "\\operatorname{Tr}(\\sqrt{\\sqrt{rho} rho_0 \\sqrt{rho}})" msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:24 -#: tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction:9 -#: tensorcircuit.mpscircuit.MPSCircuit.set_truncation_rule:9 -#: tensorcircuit.mpscircuit.split_tensor:11 -msgid "Multiply `max_truncation_err` with the largest singular value." +#: of tensorcircuit.quantum.fidelity:7 tensorcircuit.quantum.fidelity:9 +#: tensorcircuit.quantum.mutual_information:3 tensorcircuit.quantum.taylorlnm:3 +#: tensorcircuit.quantum.trace_distance:3 +#: tensorcircuit.quantum.trace_distance:5 +#: tensorcircuit.quantum.truncated_free_energy:3 +msgid "The density matrix in form of Tensor." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:26 -msgid "" -"\"rank of gate is {} but has to be 4\", \"site1 = {} is not between 0 <= " -"site < N - 1 = {}\", \"site2 = {} is not between 1 <= site < N = " -"{}\",\"Found site2 ={}, site1={}. Only nearest neighbor gates are " -"currently supported\", \"f center_position = {center_position} not f in " -"{(site1, site2)} \", or \"center_position = {}, but gate is applied at " -"sites {}, {}. Truncation should only be done if the gate is applied at " -"the center position of the MPS.\"" +#: of tensorcircuit.quantum.fidelity:11 +msgid "The sqrtm of a Hermitian matrix ``a``." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:32 -msgid "A scalar tensor containing the truncated weight of the truncation." +#: of tensorcircuit.quantum.free_energy:1 +msgid "Compute the free energy of the given density matrix." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_local_operator:1 -msgid "Measure the expectation value of local operators `ops` site `sites`." +#: of tensorcircuit.quantum.free_energy:15 +#: tensorcircuit.quantum.renyi_free_energy:14 +msgid "Hamiltonian operator in form of Tensor or QuOperator." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_local_operator:3 -msgid "A list Tensors of rank 2; the local operators to be measured." +#: of tensorcircuit.quantum.free_energy:22 +msgid "The free energy of the given density matrix with the Hamiltonian operator." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_local_operator:5 -msgid "Sites where `ops` act." +#: of tensorcircuit.quantum.generate_local_hamiltonian:1 +msgid "" +"Generate a local Hamiltonian operator based on the given sequence of " +"Tensor. Note: further jit is recommended. For large Hilbert space, sparse" +" Hamiltonian is recommended" msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_local_operator:7 -msgid "measurements :math:`\\langle` `ops[n]`:math:`\\rangle` for n in `sites`" +#: of tensorcircuit.quantum.generate_local_hamiltonian:5 +msgid "A sequence of Tensor." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:1 -msgid "" -"Compute the correlator :math:`\\langle` `op1[site1], " -"op2[s]`:math:`\\rangle` between `site1` and all sites `s` in `sites2`. If" -" `s == site1`, `op2[s]` will be applied first." +#: of tensorcircuit.quantum.generate_local_hamiltonian:7 +msgid "Return Hamiltonian operator in form of matrix, defaults to True." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:6 -msgid "Tensor of rank 2; the local operator at `site1`." +#: of tensorcircuit.quantum.generate_local_hamiltonian:9 +msgid "The Hamiltonian operator in form of QuOperator or matrix." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:8 -msgid "Tensor of rank 2; the local operator at `sites2`." +#: of tensorcircuit.quantum.gibbs_state:1 +msgid "Compute the Gibbs state of the given Hamiltonian operator ``h``." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:10 -msgid "The site where `op1` acts" +#: of tensorcircuit.quantum.gibbs_state:7 +msgid "The Gibbs state of ``h`` with the given ``beta``." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:12 -msgid "Sites where operator `op2` acts." +#: of tensorcircuit.quantum.heisenberg_hamiltonian:1 +msgid "Generate Heisenberg Hamiltonian with possible external fields." msgstr "" -#: of tensorcircuit.mps_base.FiniteMPS.measure_two_body_correlator:14 -msgid "" -"Correlator :math:`\\langle` `op1[site1], op2[s]`:math:`\\rangle` for `s` " -":math:`\\in` `sites2`." +#: of tensorcircuit.quantum.heisenberg_hamiltonian:12 +msgid "input circuit graph" msgstr "" -#: ../../source/api/mpscircuit.rst:2 -msgid "tensorcircuit.mpscircuit" +#: of tensorcircuit.quantum.heisenberg_hamiltonian:14 +msgid "zz coupling, default is 1.0" msgstr "" -#: of tensorcircuit.mpscircuit:1 -msgid "Quantum circuit: MPS state simulator" +#: of tensorcircuit.quantum.heisenberg_hamiltonian:16 +msgid "xx coupling, default is 1.0" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit:1 -msgid "``MPSCircuit`` class. Simple usage demo below." +#: of tensorcircuit.quantum.heisenberg_hamiltonian:18 +msgid "yy coupling, default is 1.0" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply any gate with parameters on the circuit." +#: of tensorcircuit.quantum.heisenberg_hamiltonian:20 +msgid "External field on z direction, default is 0.0" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:5 -msgid "Parameters for the gate" +#: of tensorcircuit.quantum.heisenberg_hamiltonian:22 +msgid "External field on y direction, default is 0.0" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **CNOT** gate on the circuit." +#: of tensorcircuit.quantum.heisenberg_hamiltonian:24 +msgid "External field on x direction, default is 0.0" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply cr gate with parameters on the circuit." +#: of tensorcircuit.quantum.heisenberg_hamiltonian:26 +msgid "Whether to return sparse Hamiltonian operator, default is True." msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **CY** gate on the circuit." +#: of tensorcircuit.quantum.heisenberg_hamiltonian:28 +msgid "whether return the matrix in numpy or tensorflow form" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **CZ** gate on the circuit." +#: of tensorcircuit.quantum.heisenberg_hamiltonian:31 +msgid "Hamiltonian measurements" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply exp gate with parameters on the circuit." +#: of tensorcircuit.quantum.identity:1 +msgid "" +"Construct a 'QuOperator' representing the identity on a given space. " +"Internally, this is done by constructing 'CopyNode's for each edge, with " +"dimension according to 'space'." msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply exp1 gate with parameters on the circuit." +#: of tensorcircuit.quantum.identity:26 +msgid "" +"A sequence of integers for the dimensions of the tensor product factors " +"of the space (the edges in the tensor network)." msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **H** gate on the circuit." +#: of tensorcircuit.quantum.identity:29 +msgid "" +"The data type by np.* (for conversion to dense). defaults None to tc " +"dtype." msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **I** gate on the circuit." +#: of tensorcircuit.quantum.identity:31 +msgid "The desired identity operator." msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply r gate with parameters on the circuit." +#: of tensorcircuit.quantum.measurement_counts:1 +msgid "" +"Simulate the measuring of each qubit of ``p`` in the computational basis," +" thus producing output like that of ``qiskit``." msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply rx gate with parameters on the circuit." +#: of tensorcircuit.quantum.measurement_counts:4 +msgid "Six formats of measurement counts results:" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply ry gate with parameters on the circuit." +#: of tensorcircuit.quantum.measurement_counts:6 +msgid "\"sample_int\": # np.array([0, 0])" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_variable_gate_delayed..apply:1 -msgid "Apply rz gate with parameters on the circuit." +#: of tensorcircuit.quantum.measurement_counts:8 +msgid "\"sample_bin\": # [np.array([1, 0]), np.array([1, 0])]" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **S** gate on the circuit." +#: of tensorcircuit.quantum.measurement_counts:10 +msgid "\"count_vector\": # np.array([2, 0, 0, 0])" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **SWAP** gate on the circuit." +#: of tensorcircuit.quantum.measurement_counts:12 +msgid "\"count_tuple\": # (np.array([0]), np.array([2]))" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **T** gate on the circuit." +#: of tensorcircuit.quantum.measurement_counts:14 +msgid "\"count_dict_bin\": # {\"00\": 2, \"01\": 0, \"10\": 0, \"11\": 0}" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **WROOT** gate on the circuit." +#: of tensorcircuit.quantum.measurement_counts:16 +msgid "\"count_dict_int\": # {0: 2, 1: 0, 2: 0, 3: 0}" msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **X** gate on the circuit." +#: of tensorcircuit.quantum.measurement_counts:37 +msgid "" +"The quantum state, assumed to be normalized, as either a ket or density " +"operator." msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **Y** gate on the circuit." +#: of tensorcircuit.quantum.measurement_counts:39 +msgid "The number of counts to perform." msgstr "" -#: of -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate_delayed..apply:1 -msgid "Apply **Z** gate on the circuit." +#: of tensorcircuit.quantum.measurement_counts:41 +msgid "alias for the argument ``counts``" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.__init__:1 -msgid "MPSCircuit object based on state simulator." +#: of tensorcircuit.quantum.measurement_counts:43 +msgid "defaults to be \"direct\", see supported format above" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.__init__:5 +#: of tensorcircuit.quantum.measurement_counts:47 msgid "" -"If not None, the initial state of the circuit is taken as ``tensors`` " -"instead of :math:`\\vert 0\\rangle^n` qubits, defaults to None" +"if True, the `state` is directly regarded as a probability list, defaults" +" to be False" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.__init__:8 -msgid "The center position of MPS, default to 0" +#: of tensorcircuit.quantum.measurement_counts:55 +msgid "if True, jax backend try using a jittable count, defaults to False" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate:1 -msgid "Apply a general qubit gate on MPS." +#: of tensorcircuit.quantum.measurement_counts:57 +msgid "The counts for each bit string measured." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:4 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate:3 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate:3 -msgid "The Gate to be applied" +#: of tensorcircuit.quantum.mutual_information:1 +msgid "Mutual information between AB subsystem described by ``cut``." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate:6 -msgid "Qubit indices of the gate" +#: of tensorcircuit.quantum.mutual_information:5 +msgid "The AB subsystem." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_general_gate:5 -msgid "\"MPS does not support application of gate on > 2 qubits.\"" +#: of tensorcircuit.quantum.mutual_information:7 +msgid "The mutual information between AB subsystem described by ``cut``." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:1 +#: of tensorcircuit.quantum.quantum_constructor:1 msgid "" -"Apply a double qubit gate on adjacent qubits of Matrix Product States " -"(MPS). Truncation rule is specified by `set_truncation_rule`." +"Constructs an appropriately specialized QuOperator. If there are no " +"edges, creates a QuScalar. If the are only output (input) edges, creates " +"a QuVector (QuAdjointVector). Otherwise creates a QuOperator." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:6 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate:5 -msgid "The first qubit index of the gate" +#: of tensorcircuit.quantum.quantum_constructor:48 +msgid "A list of output edges." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:8 -#: tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate:7 -msgid "The second qubit index of the gate" +#: of tensorcircuit.quantum.quantum_constructor:50 +msgid "A list of input edges." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_adjacent_double_gate:10 -msgid "Center position of MPS, default is None" +#: of tensorcircuit.quantum.quantum_constructor:52 +msgid "" +"Reference nodes for the tensor network (needed if there is a. scalar " +"component)." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_double_gate:1 -msgid "" -"Apply a double qubit gate on MPS. Truncation rule is specified by " -"`set_truncation_rule`." +#: of tensorcircuit.quantum.quantum_constructor:55 +msgid "Edges to ignore when checking the dimensionality of the tensor network." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_single_gate:1 -msgid "" -"Apply a single qubit gate on MPS, and the gate must be unitary; no " -"truncation is needed." +#: of tensorcircuit.quantum.quantum_constructor:58 +msgid "The new created QuOperator object." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_single_gate:3 -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_double_gates:3 -msgid "gate to be applied" +#: of tensorcircuit.quantum.quimb2qop:1 +msgid "Convert MPO in Quimb package to QuOperator." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.apply_single_gate:5 -#: tensorcircuit.mpscircuit.MPSCircuit.expectation_single_gate:5 -msgid "Qubit index of the gate" +#: of tensorcircuit.quantum.quimb2qop:3 +msgid "MPO in the form of Quimb package" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.conj:1 -msgid "Compute the conjugate of the current MPS." +#: of tensorcircuit.quantum.quimb2qop:5 tensorcircuit.quantum.tn2qop:5 +msgid "MPO in the form of QuOperator" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.conj:3 -#: tensorcircuit.mpscircuit.MPSCircuit.copy:3 -#: tensorcircuit.mpscircuit.MPSCircuit.copy_without_tensor:3 -#: tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction:11 -msgid "The constructed MPS" +#: of tensorcircuit.quantum.reduced_density_matrix:1 +msgid "Compute the reduced density matrix from the quantum state ``state``." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.copy:1 -msgid "Copy the current MPS." +#: of tensorcircuit.quantum.reduced_density_matrix:3 +msgid "The quantum state in form of Tensor or QuOperator." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.copy_without_tensor:1 -msgid "Copy the current MPS without the tensors." +#: of tensorcircuit.quantum.reduced_density_matrix:5 +msgid "" +"the index list that is traced out, if cut is a int, it indicates [0, cut]" +" as the traced out region" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_double_gates:1 -msgid "Compute the expectation of the corresponding double qubit gate." +#: of tensorcircuit.quantum.reduced_density_matrix:8 +msgid "probability decoration, default is None." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_double_gates:5 -msgid "qubit index of the gate" +#: of tensorcircuit.quantum.reduced_density_matrix:10 +msgid "The reduced density matrix." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_single_gate:1 -msgid "" -"Compute the expectation of the corresponding single qubit gate in the " -"form of tensor." +#: of tensorcircuit.quantum.renyi_entropy:1 +msgid "Compute the Rényi entropy of order :math:`k` by given density matrix." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_single_gate:3 -msgid "Gate to be applied" +#: of tensorcircuit.quantum.renyi_entropy:5 +#: tensorcircuit.quantum.renyi_free_energy:18 +msgid "The order of Rényi entropy, default is 2." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_single_gate:7 -msgid "The expectation of the corresponding single qubit gate" +#: of tensorcircuit.quantum.renyi_entropy:7 +#: tensorcircuit.quantum.renyi_free_energy:20 +msgid "The :math:`k` th order of Rényi entropy." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product:1 +#: of tensorcircuit.quantum.renyi_free_energy:1 msgid "" -"Compute the expectation of the direct product of the corresponding two " -"gates." +"Compute the Rényi free energy of the corresponding density matrix and " +"Hamiltonian." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product:3 -msgid "First gate to be applied" +#: of tensorcircuit.quantum.sample2all:1 +msgid "" +"transform ``sample_int`` or ``sample_bin`` form results to other forms " +"specified by ``format``" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product:5 -msgid "Second gate to be applied" +#: of tensorcircuit.quantum.sample2all:3 +msgid "measurement shots results in ``sample_int`` or ``sample_bin`` format" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product:7 -msgid "Qubit index of the first gate" +#: of tensorcircuit.quantum.sample2all:7 +msgid "" +"see the doc in the doc in " +":py:meth:`tensorcircuit.quantum.measurement_results`, defaults to " +"\"count_vector\"" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product:9 -msgid "Qubit index of the second gate" +#: of tensorcircuit.quantum.sample2all:12 +msgid "only applicable to count transformation in jax backend, defaults to False" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.expectation_two_gates_product:11 -msgid "The correlation of the corresponding two qubit gates" +#: of tensorcircuit.quantum.sample2all:14 +msgid "measurement results specified as ``format``" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction:1 -msgid "Construct the MPS from a given wavefunction." +#: of tensorcircuit.quantum.sample2count:1 +msgid "sample_int to count_tuple" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.from_wavefunction:3 -msgid "The given wavefunction (any shape is OK)" +#: of tensorcircuit.quantum.sample_bin2int:1 +msgid "bin sample to int sample" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.general_expectation:1 -msgid "Compute the expectation of corresponding operators in the form of tensor." +#: of tensorcircuit.quantum.sample_bin2int:3 +msgid "in shape [trials, n] of elements (0, 1)" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.general_expectation:3 -msgid "" -"Operator and its position on the circuit, eg. ``(gates.Z(), [1]), " -"(gates.X(), [2])`` is for operator :math:`Z_1X_2`" +#: of tensorcircuit.quantum.sample_bin2int:7 +msgid "in shape [trials]" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.general_expectation:6 -msgid "The expectation of corresponding operators" +#: of tensorcircuit.quantum.sample_int2bin:1 +msgid "int sample to bin sample" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.get_norm:1 -msgid "Get the normalized Center Position." +#: of tensorcircuit.quantum.sample_int2bin:3 +msgid "in shape [trials] of int elements in the range [0, 2**n)" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.get_norm:3 -msgid "Normalized Center Position." +#: of tensorcircuit.quantum.sample_int2bin:7 +msgid "in shape [trials, n] of element (0, 1)" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.is_valid:1 -msgid "Check whether the circuit is legal." +#: of tensorcircuit.quantum.spin_by_basis:1 +msgid "" +"Generate all n-bitstrings as an array, each row is a bitstring basis. " +"Return m-th col." msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.is_valid:3 -msgid "Whether the circuit is legal." +#: of tensorcircuit.quantum.spin_by_basis:9 +msgid "length of a bitstring" msgstr "" -#: of tensorcircuit.mpscircuit.MPSCircuit.measure:1 -msgid "integer indicating the measure on which quantum line" +#: of tensorcircuit.quantum.spin_by_basis:11 +msgid "m 1 after contraction!" +#: of tensorcircuit.results.readout_mitigation.ReadoutMit.ubs:1 +msgid "Help omit calibration results that not in used qubit list." msgstr "" -#: of tensorcircuit.quantum.QuOperator.eval:12 -msgid "The final tensor representing the operator." +#: of tensorcircuit.results.readout_mitigation.ReadoutMit.ubs:7 +msgid "omitation related value" msgstr "" -#: of tensorcircuit.quantum.QuOperator.eval_matrix:1 -msgid "" -"Contracts the tensor network in place and returns the final tensor in two" -" dimentional matrix. The default ordering for the axes of the final " -"tensor is: (:math:`\\prod` dimension of out_edges, :math:`\\prod` " -"dimension of in_edges)" +#: ../../source/api/simplify.rst:2 +msgid "tensorcircuit.simplify" msgstr "" -#: of tensorcircuit.quantum.QuOperator.eval_matrix:10 -msgid "The two-dimentional tensor representing the operator." +#: of tensorcircuit.simplify:1 +msgid "Tensornetwork Simplification" msgstr "" -#: of tensorcircuit.quantum.QuOperator.from_tensor:1 +#: of tensorcircuit.simplify.infer_new_shape:1 msgid "" -"Construct a `QuOperator` directly from a single tensor. This first wraps " -"the tensor in a `Node`, then constructs the `QuOperator` from that " -"`Node`." +"Get the new shape of two nodes, also supporting to return original shapes" +" of two nodes." msgstr "" -#: of tensorcircuit.quantum.QuOperator.from_tensor:28 -msgid "The tensor." +#: of tensorcircuit.simplify.infer_new_shape:13 +msgid "node one" msgstr "" -#: of tensorcircuit.quantum.QuOperator.from_tensor:30 -msgid "The axis indices of `tensor` to use as `out_edges`." +#: of tensorcircuit.simplify.infer_new_shape:15 +msgid "node two" msgstr "" -#: of tensorcircuit.quantum.QuOperator.from_tensor:32 -msgid "The axis indices of `tensor` to use as `in_edges`." +#: of tensorcircuit.simplify.infer_new_shape:17 +msgid "Whether to include original shape of two nodes, default is True." msgstr "" -#: of tensorcircuit.quantum.QuOperator.from_tensor:34 -msgid "The new operator." +#: of tensorcircuit.simplify.infer_new_shape:19 +msgid "The new shape of the two nodes." msgstr "" -#: of tensorcircuit.quantum.QuOperator.is_adjoint_vector:1 +#: of tensorcircuit.simplify.pseudo_contract_between:1 msgid "" -"Returns a bool indicating if QuOperator is an adjoint vector. Examples " -"can be found in the `QuOperator.from_tensor`." +"Contract between Node ``a`` and ``b``, with correct shape only and no " +"calculation" msgstr "" -#: of tensorcircuit.quantum.QuOperator.is_scalar:1 -msgid "" -"Returns a bool indicating if QuOperator is a scalar. Examples can be " -"found in the `QuOperator.from_tensor`." +#: ../../source/api/templates.rst:2 +msgid "tensorcircuit.templates" msgstr "" -#: of tensorcircuit.quantum.QuOperator.is_vector:1 -msgid "" -"Returns a bool indicating if QuOperator is a vector. Examples can be " -"found in the `QuOperator.from_tensor`." +#: ../../source/api/templates/blocks.rst:2 +msgid "tensorcircuit.templates.blocks" msgstr "" -#: of tensorcircuit.quantum.QuOperator.nodes:1 -msgid "All tensor-network nodes involved in the operator." +#: of tensorcircuit.templates.blocks:1 tensorcircuit.templates.measurements:1 +msgid "Shortcuts for measurement patterns on circuit" msgstr "" -#: of tensorcircuit.quantum.QuOperator.norm:1 +#: of tensorcircuit.templates.blocks.Bell_pair_block:1 msgid "" -"The norm of the operator. This is the 2-norm (also known as the Frobenius" -" or Hilbert-Schmidt norm)." +"For each pair in links, the input product state |00> is transformed as " +"(01>-|10>)" msgstr "" -#: of tensorcircuit.quantum.QuOperator.partial_trace:1 +#: of tensorcircuit.templates.blocks.Bell_pair_block:3 +msgid "Circuit in" +msgstr "" + +#: of tensorcircuit.templates.blocks.Bell_pair_block:5 msgid "" -"The partial trace of the operator. Subsystems to trace out are supplied " -"as indices, so that dangling edges are connected to each other as: " -"`out_edges[i] ^ in_edges[i] for i in subsystems_to_trace_out` This does " -"not modify the original network. The original ordering of the remaining " -"subsystems is maintained." +"pairs indices for Bell pairs, defaults to None, corresponds to neighbor " +"links" msgstr "" -#: of tensorcircuit.quantum.QuOperator.partial_trace:10 -msgid "A new QuOperator or QuScalar representing the result." +#: of tensorcircuit.templates.blocks.Bell_pair_block:7 +msgid "Circuit out" msgstr "" -#: of tensorcircuit.quantum.QuOperator.tensor_product:1 +#: of tensorcircuit.templates.blocks.example_block:1 msgid "" -"Tensor product with another operator. Given two operators `A` and `B`, " -"produces a new operator `AB` representing :math:`A ⊗ B`. The `out_edges` " -"(`in_edges`) of `AB` is simply the concatenation of the `out_edges` " -"(`in_edges`) of `A.copy()` with that of `B.copy()`: `new_out_edges = " -"[*out_edges_A_copy, *out_edges_B_copy]` `new_in_edges = " -"[*in_edges_A_copy, *in_edges_B_copy]`" +"The circuit ansatz is firstly one layer of Hadamard gates and then we " +"have ``nlayers`` blocks of :math:`e^{i\\theta Z_iZ_{i+1}}` two-qubit gate" +" in ladder layout, following rx gate." msgstr "" -#: of tensorcircuit.quantum.QuOperator.tensor_product:20 -msgid "The other operator (`B`)." +#: of tensorcircuit.templates.blocks.example_block:5 +msgid "The circuit" msgstr "" -#: of tensorcircuit.quantum.QuOperator.tensor_product:22 -msgid "The result (`AB`)." +#: of tensorcircuit.templates.blocks.example_block:7 +msgid "paramter tensor with 2*nlayer*n elements" msgstr "" -#: of tensorcircuit.quantum.QuOperator.trace:1 -msgid "The trace of the operator." +#: of tensorcircuit.templates.blocks.example_block:9 +msgid "number of ZZ+RX blocks, defaults to 2" msgstr "" -#: of tensorcircuit.quantum.QuScalar:1 -msgid "Represents a scalar via a tensor network." +#: of tensorcircuit.templates.blocks.example_block:11 +msgid "whether use SVD split to reduce ZZ gate bond dimension, defaults to False" msgstr "" -#: of tensorcircuit.quantum.QuScalar.__init__:1 +#: of tensorcircuit.templates.blocks.example_block:14 +msgid "The circuit with example ansatz attached" +msgstr "" + +#: of tensorcircuit.templates.blocks.state_centric:1 msgid "" -"Constructs a new `QuScalar` from a tensor network. This encapsulates an " -"existing tensor network, interpreting it as a scalar." +"Function decorator wraps the function with the first input and output in " +"the format of circuit, the wrapped function has the first input and the " +"output as the state tensor." msgstr "" -#: of tensorcircuit.quantum.QuScalar.__init__:4 +#: of tensorcircuit.templates.blocks.state_centric:4 +msgid "Function with the fist input and the output as ``Circuit`` object." +msgstr "" + +#: of tensorcircuit.templates.blocks.state_centric:6 msgid "" -"Nodes used to refer to the tensor network (need not be exhaustive - one " -"node from each disconnected subnetwork is sufficient)." +"Wrapped function with the first input and the output as the state tensor " +"correspondingly." msgstr "" -#: of tensorcircuit.quantum.QuScalar.from_tensor:1 +#: ../../source/api/templates/chems.rst:2 +msgid "tensorcircuit.templates.chems" +msgstr "" + +#: of tensorcircuit.templates.chems:1 +msgid "Useful utilities for quantum chemistry related task" +msgstr "" + +#: of tensorcircuit.templates.chems.get_ps:1 msgid "" -"Construct a `QuScalar` directly from a single tensor. This first wraps " -"the tensor in a `Node`, then constructs the `QuScalar` from that `Node`." +"Get Pauli string array and weights array for a qubit Hamiltonian as a sum" +" of Pauli strings defined in openfermion ``QubitOperator``." msgstr "" -#: of tensorcircuit.quantum.QuScalar.from_tensor:22 -msgid "The tensor for constructing a new QuScalar." +#: of tensorcircuit.templates.chems.get_ps:4 +msgid "``openfermion.ops.operators.qubit_operator.QubitOperator``" msgstr "" -#: of tensorcircuit.quantum.QuScalar.from_tensor:24 -msgid "The new constructed QuScalar from the given tensor." +#: of tensorcircuit.templates.chems.get_ps:6 +msgid "The number of qubits" +msgstr "" + +#: of tensorcircuit.templates.chems.get_ps:8 +msgid "Pauli String array and weights array" +msgstr "" + +#: ../../source/api/templates/dataset.rst:2 +msgid "tensorcircuit.templates.dataset" +msgstr "" + +#: of tensorcircuit.templates.dataset:1 +msgid "Quantum machine learning related data preprocessing and embedding" msgstr "" -#: of tensorcircuit.quantum.QuVector:1 -msgid "Represents a (column) vector via a tensor network." +#: ../../source/api/templates/graphs.rst:2 +msgid "tensorcircuit.templates.graphs" msgstr "" -#: of tensorcircuit.quantum.QuVector.__init__:1 -msgid "" -"Constructs a new `QuVector` from a tensor network. This encapsulates an " -"existing tensor network, interpreting it as a (column) vector." +#: of tensorcircuit.templates.graphs:1 +msgid "Some common graphs and lattices" msgstr "" -#: of tensorcircuit.quantum.QuVector.from_tensor:1 -msgid "" -"Construct a `QuVector` directly from a single tensor. This first wraps " -"the tensor in a `Node`, then constructs the `QuVector` from that `Node`." +#: of tensorcircuit.templates.graphs.Grid2DCoord:1 +msgid "Two-dimensional grid lattice" msgstr "" -#: of tensorcircuit.quantum.QuVector.from_tensor:28 -msgid "The tensor for constructing a \"QuVector\"." +#: of tensorcircuit.templates.graphs.Grid2DCoord.__init__:1 +msgid "number of rows" msgstr "" -#: of tensorcircuit.quantum.QuVector.from_tensor:30 -msgid "" -"Sequence of integer indices specifying the order in which to interpret " -"the axes as subsystems (output edges). If not specified, the axes are " -"taken in ascending order." +#: of tensorcircuit.templates.graphs.Grid2DCoord.__init__:3 +msgid "number of cols" msgstr "" -#: of tensorcircuit.quantum.QuVector.from_tensor:34 -msgid "The new constructed QuVector from the given tensor." +#: of tensorcircuit.templates.graphs.Grid2DCoord.all_cols:1 +msgid "return all col edge with 1d index encoding" msgstr "" -#: of tensorcircuit.quantum.QuVector.projector:4 +#: of tensorcircuit.templates.graphs.Grid2DCoord.all_cols:3 +#: tensorcircuit.templates.graphs.Grid2DCoord.all_rows:3 msgid "" -"Set :math:`A` is the operator in matrix form, then the projector of " -"operator is defined as: :math:`A A^\\dagger`" +"whether to include pbc edges (periodic boundary condition), defaults to " +"False" msgstr "" -#: of tensorcircuit.quantum.QuVector.reduced_density:5 -msgid "\\mathrm{Tr}_{subsystems}(A A^\\dagger)" +#: of tensorcircuit.templates.graphs.Grid2DCoord.all_cols:6 +msgid "list of col edge" msgstr "" -#: of tensorcircuit.quantum.check_spaces:1 -msgid "" -"Check the vector spaces represented by two lists of edges are compatible." -" The number of edges must be the same and the dimensions of each pair of " -"edges must match. Otherwise, an exception is raised." +#: of tensorcircuit.templates.graphs.Grid2DCoord.all_rows:1 +msgid "return all row edge with 1d index encoding" msgstr "" -#: of tensorcircuit.quantum.check_spaces:5 tensorcircuit.quantum.check_spaces:7 -msgid "List of edges representing a many-body Hilbert space." +#: of tensorcircuit.templates.graphs.Grid2DCoord.all_rows:6 +msgid "list of row edge" msgstr "" -#: of tensorcircuit.quantum.check_spaces:10 -msgid "" -"Hilbert-space mismatch: \"Cannot connect {} subsystems with {} " -"subsystems\", or \"Input dimension {} != output dimension {}.\"" +#: of tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph:1 +msgid "Get the 2D grid lattice in ``nx.Graph`` format" msgstr "" -#: of tensorcircuit.quantum.correlation_from_counts:1 +#: of tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph:3 msgid "" -"Compute :math:`\\prod_{i\\in \\text{index}} s_i`, where the probability " -"for each bitstring is given as a vector ``results``." +"whether to include pbc edges (periodic boundary condition), defaults to " +"True" msgstr "" -#: of tensorcircuit.quantum.correlation_from_counts:12 -msgid "list of int, indicating the position in the bitstring" +#: of tensorcircuit.templates.graphs.Line1D:1 +msgid "1D chain with ``n`` sites" msgstr "" -#: of tensorcircuit.quantum.correlation_from_counts:14 -msgid "probability vector of shape 2^n" +#: of tensorcircuit.templates.graphs.Line1D:5 +#: tensorcircuit.templates.measurements.heisenberg_measurements:34 +msgid "[description], defaults to True" msgstr "" -#: of tensorcircuit.quantum.correlation_from_counts:16 -msgid "Correlation expectation from measurement shots." +#: ../../source/api/templates/measurements.rst:2 +msgid "tensorcircuit.templates.measurements" msgstr "" -#: of tensorcircuit.quantum.double_state:1 -msgid "Compute the double state of the given Hamiltonian operator ``h``." +#: of tensorcircuit.templates.measurements.any_local_measurements:1 +msgid "" +"This measurements pattern is specifically suitable for vmap. Parameterize" +" the local Pauli string to be measured." msgstr "" -#: of tensorcircuit.quantum.double_state:3 tensorcircuit.quantum.gibbs_state:3 -#: tensorcircuit.quantum.truncated_free_energy:5 -msgid "Hamiltonian operator in form of Tensor." +#: of tensorcircuit.templates.measurements.any_local_measurements:19 +#: tensorcircuit.templates.measurements.any_measurements:26 +msgid "The circuit to be measured" msgstr "" -#: of tensorcircuit.quantum.double_state:5 tensorcircuit.quantum.free_energy:17 -#: tensorcircuit.quantum.gibbs_state:5 -#: tensorcircuit.quantum.renyi_free_energy:16 -#: tensorcircuit.quantum.truncated_free_energy:7 -msgid "Constant for the optimization, default is 1." +#: of tensorcircuit.templates.measurements.any_local_measurements:21 +#: tensorcircuit.templates.measurements.any_measurements:28 +msgid "" +"parameter tensors determines what Pauli string to be measured, shape is " +"[nwires, 4] if ``onehot`` is False and [nwires] if ``onehot`` is True." msgstr "" -#: of tensorcircuit.quantum.double_state:7 -msgid "The double state of ``h`` with the given ``beta``." +#: of tensorcircuit.templates.measurements.any_local_measurements:24 +#: tensorcircuit.templates.measurements.any_measurements:31 +msgid "" +"defaults to False. If set to be True, structures will first go through " +"onehot procedure." msgstr "" -#: of tensorcircuit.quantum.eliminate_identities:1 +#: of tensorcircuit.templates.measurements.any_local_measurements:27 msgid "" -"Eliminates any connected CopyNodes that are identity matrices. This will " -"modify the network represented by `nodes`. Only identities that are " -"connected to other nodes are eliminated." +"reuse the wavefunction when computing the expectations, defaults to be " +"True" msgstr "" -#: of tensorcircuit.quantum.eliminate_identities:5 -msgid "Collection of nodes to search." +#: of tensorcircuit.templates.measurements.any_local_measurements:29 +#: tensorcircuit.templates.measurements.any_measurements:36 +msgid "The expectation value of given Pauli string by the tensor ``structures``." msgstr "" -#: of tensorcircuit.quantum.eliminate_identities:7 +#: of tensorcircuit.templates.measurements.any_measurements:1 msgid "" -"The Dictionary mapping remaining Nodes to any replacements, Dictionary " -"specifying all dangling-edge replacements." +"This measurements pattern is specifically suitable for vmap. Parameterize" +" the Pauli string to be measured." msgstr "" -#: of tensorcircuit.quantum.entropy:1 -msgid "Compute the entropy from the given density matrix ``rho``." +#: of tensorcircuit.templates.measurements.any_measurements:34 +msgid "" +"reuse the wavefunction when computing the expectations, defaults to be " +"False" msgstr "" -#: of tensorcircuit.quantum.entropy:30 tensorcircuit.quantum.free_energy:13 -#: tensorcircuit.quantum.renyi_entropy:3 -#: tensorcircuit.quantum.renyi_free_energy:12 -msgid "The density matrix in form of Tensor or QuOperator." +#: of tensorcircuit.templates.measurements.heisenberg_measurements:1 +msgid "" +"Evaluate Heisenberg energy expectation, whose Hamiltonian is defined on " +"the lattice graph ``g`` as follows: (e are edges in graph ``g`` where e1 " +"and e2 are two nodes for edge e and v are nodes in graph ``g``)" msgstr "" -#: of tensorcircuit.quantum.entropy:32 tensorcircuit.quantum.free_energy:19 -msgid "Epsilon, default is 1e-12." +#: of tensorcircuit.templates.measurements.heisenberg_measurements:4 +msgid "" +"H = \\sum_{e\\in g} w_e (h_{xx} X_{e1}X_{e2} + h_{yy} Y_{e1}Y_{e2} + " +"h_{zz} Z_{e1}Z_{e2})\n" +" + \\sum_{v\\in g} (h_x X_v + h_y Y_v + h_z Z_v)" msgstr "" -#: of tensorcircuit.quantum.entropy:34 -msgid "Entropy on the given density matrix." +#: of tensorcircuit.templates.measurements.heisenberg_measurements:18 +msgid "Circuit to be measured" msgstr "" -#: of tensorcircuit.quantum.fidelity:1 -msgid "Return fidelity scalar between two states rho and rho0." +#: of tensorcircuit.templates.measurements.heisenberg_measurements:20 +msgid "Lattice graph defining Heisenberg Hamiltonian" msgstr "" -#: of tensorcircuit.quantum.fidelity:3 -msgid "\\operatorname{Tr}(\\sqrt{\\sqrt{rho} rho_0 \\sqrt{rho}})" +#: of tensorcircuit.templates.measurements.heisenberg_measurements:22 +#: tensorcircuit.templates.measurements.heisenberg_measurements:24 +#: tensorcircuit.templates.measurements.heisenberg_measurements:26 +msgid "[description], defaults to 1.0" msgstr "" -#: of tensorcircuit.quantum.fidelity:7 tensorcircuit.quantum.fidelity:9 -#: tensorcircuit.quantum.mutual_information:3 tensorcircuit.quantum.taylorlnm:3 -#: tensorcircuit.quantum.trace_distance:3 -#: tensorcircuit.quantum.trace_distance:5 -#: tensorcircuit.quantum.truncated_free_energy:3 -msgid "The density matrix in form of Tensor." +#: of tensorcircuit.templates.measurements.heisenberg_measurements:28 +#: tensorcircuit.templates.measurements.heisenberg_measurements:30 +#: tensorcircuit.templates.measurements.heisenberg_measurements:32 +msgid "[description], defaults to 0.0" msgstr "" -#: of tensorcircuit.quantum.fidelity:11 -msgid "The sqrtm of a Hermitian matrix ``a``." +#: of tensorcircuit.templates.measurements.heisenberg_measurements:36 +msgid "Value of Heisenberg energy" msgstr "" -#: of tensorcircuit.quantum.free_energy:1 -msgid "Compute the free energy of the given density matrix." +#: of tensorcircuit.templates.measurements.mpo_expectation:1 +msgid "" +"Evaluate expectation of operator ``mpo`` defined in ``QuOperator`` MPO " +"format with the output quantum state from circuit ``c``." msgstr "" -#: of tensorcircuit.quantum.free_energy:15 -#: tensorcircuit.quantum.renyi_free_energy:14 -msgid "Hamiltonian operator in form of Tensor or QuOperator." +#: of tensorcircuit.templates.measurements.mpo_expectation:4 +msgid "The circuit for the output state" msgstr "" -#: of tensorcircuit.quantum.free_energy:22 -msgid "The free energy of the given density matrix with the Hamiltonian operator." +#: of tensorcircuit.templates.measurements.mpo_expectation:6 +msgid "MPO operator" msgstr "" -#: of tensorcircuit.quantum.generate_local_hamiltonian:1 +#: of tensorcircuit.templates.measurements.mpo_expectation:8 +#: tensorcircuit.templates.measurements.operator_expectation:7 +#: tensorcircuit.templates.measurements.sparse_expectation:7 +msgid "a real and scalar tensor of shape [] as the expectation value" +msgstr "" + +#: of tensorcircuit.templates.measurements.operator_expectation:1 msgid "" -"Generate a local Hamiltonian operator based on the given sequence of " -"Tensor. Note: further jit is recommended. For large Hilbert space, sparse" -" Hamiltonian is recommended" +"Evaluate Hamiltonian expectation where ``hamiltonian`` can be dense " +"matrix, sparse matrix or MPO." msgstr "" -#: of tensorcircuit.quantum.generate_local_hamiltonian:5 -msgid "A sequence of Tensor." +#: of tensorcircuit.templates.measurements.operator_expectation:3 +#: tensorcircuit.templates.measurements.sparse_expectation:3 +msgid "The circuit whose output state is used to evaluate the expectation" msgstr "" -#: of tensorcircuit.quantum.generate_local_hamiltonian:7 -msgid "Return Hamiltonian operator in form of matrix, defaults to True." +#: of tensorcircuit.templates.measurements.operator_expectation:5 +#: tensorcircuit.templates.measurements.sparse_expectation:5 +msgid "Hamiltonian matrix in COO_sparse_matrix form" msgstr "" -#: of tensorcircuit.quantum.generate_local_hamiltonian:9 -msgid "The Hamiltonian operator in form of QuOperator or matrix." +#: of tensorcircuit.templates.measurements.sparse_expectation:1 +msgid "" +"Evaluate Hamiltonian expectation where ``hamiltonian`` is kept in sparse " +"matrix form to save space" msgstr "" -#: of tensorcircuit.quantum.gibbs_state:1 -msgid "Compute the Gibbs state of the given Hamiltonian operator ``h``." +#: of tensorcircuit.templates.measurements.spin_glass_measurements:1 +msgid "" +"Compute spin glass energy defined on graph ``g`` expectation for output " +"state of the circuit ``c``. The Hamiltonian to be evaluated is defined as" +" (first term is determined by node weights while the second term is " +"determined by edge weights of the graph):" msgstr "" -#: of tensorcircuit.quantum.gibbs_state:7 -msgid "The Gibbs state of ``h`` with the given ``beta``." +#: of tensorcircuit.templates.measurements.spin_glass_measurements:5 +msgid "H = \\sum_{v\\in g} w_v Z_v + \\sum_{e\\in g} w_e Z_{e1} Z_{e2}" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:1 -msgid "Generate Heisenberg Hamiltonian with possible external fields." +#: of tensorcircuit.templates.measurements.spin_glass_measurements:28 +msgid "The quantum circuit" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:12 -msgid "input circuit graph" +#: of tensorcircuit.templates.measurements.spin_glass_measurements:30 +msgid "The graph for spin glass Hamiltonian definition" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:14 -msgid "zz coupling, default is 1.0" +#: of tensorcircuit.templates.measurements.spin_glass_measurements:32 +msgid "" +"Whether measure the circuit with reusing the wavefunction, defaults to " +"True" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:16 -msgid "xx coupling, default is 1.0" +#: of tensorcircuit.templates.measurements.spin_glass_measurements:34 +msgid "The spin glass energy expectation value" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:18 -msgid "yy coupling, default is 1.0" +#: ../../source/api/torchnn.rst:2 +msgid "tensorcircuit.torchnn" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:20 -msgid "External field on z direction, default is 0.0" +#: of tensorcircuit.torchnn:1 +msgid "PyTorch nn Module wrapper for quantum function" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:22 -msgid "External field on y direction, default is 0.0" +#: of tensorcircuit.torchnn.QuantumNet:1 +msgid "Bases: :py:class:`torch.nn.modules.module.Module`" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:24 -msgid "External field on x direction, default is 0.0" +#: of tensorcircuit.torchnn.QuantumNet.__init__:1 +msgid "PyTorch nn Module wrapper on quantum function ``f``." msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:26 -msgid "Whether to return sparse Hamiltonian operator, default is True." +#: of tensorcircuit.torchnn.QuantumNet.__init__:32 +msgid "Quantum function with tensor in (input and weights) and tensor out." msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:28 -msgid "whether return the matrix in numpy or tensorflow form" +#: of tensorcircuit.torchnn.QuantumNet.__init__:34 +msgid "" +"list of shape tuple for different weights as the non-first parameters for" +" ``f``" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:31 -msgid "Hamiltonian measurements" +#: of tensorcircuit.torchnn.QuantumNet.__init__:36 +msgid "function that gives the shape tuple returns torch tensor, defaults to None" msgstr "" -#: of tensorcircuit.quantum.identity:1 -msgid "" -"Construct a 'QuOperator' representing the identity on a given space. " -"Internally, this is done by constructing 'CopyNode's for each edge, with " -"dimension according to 'space'." +#: of tensorcircuit.torchnn.QuantumNet.__init__:38 +msgid "whether apply vmap (batch input) on ``f``, defaults to True" msgstr "" -#: of tensorcircuit.quantum.identity:26 +#: of tensorcircuit.torchnn.QuantumNet.__init__:40 msgid "" -"A sequence of integers for the dimensions of the tensor product factors " -"of the space (the edges in the tensor network)." +"which position of input should be batched, need to be customized when " +"multiple inputs for the torch model, defaults to be 0." msgstr "" -#: of tensorcircuit.quantum.identity:29 -msgid "" -"The data type by np.* (for conversion to dense). defaults None to tc " -"dtype." +#: of tensorcircuit.torchnn.QuantumNet.__init__:43 +msgid "whether transform ``f`` with torch interface, defaults to True" msgstr "" -#: of tensorcircuit.quantum.identity:31 -msgid "The desired identity operator." +#: of tensorcircuit.torchnn.QuantumNet.__init__:45 +msgid "whether jit ``f``, defaults to True" msgstr "" -#: of tensorcircuit.quantum.measurement_counts:1 -msgid "" -"Simulate the measuring of each qubit of ``p`` in the computational basis," -" thus producing output like that of ``qiskit``." +#: of tensorcircuit.torchnn.QuantumNet.__init__:47 +msgid "whether enbale dlpack in interfaces, defaults to False" msgstr "" -#: of tensorcircuit.quantum.measurement_counts:14 -msgid "" -"The quantum state, assumed to be normalized, as either a ket or density " -"operator." +#: of torch.nn.modules.module.Module.add_module:1 +msgid "Adds a child module to the current module." msgstr "" -#: of tensorcircuit.quantum.measurement_counts:16 -msgid "The number of counts to perform." +#: of torch.nn.modules.module.Module.add_module:3 +msgid "The module can be accessed as an attribute using the given name." msgstr "" -#: of tensorcircuit.quantum.measurement_counts:18 +#: of torch.nn.modules.module.Module.add_module:5 msgid "" -"Defaults True. The bool indicating whether the return form is in the form" -" of two array or one of the same length as the ``state`` (if " -"``sparse=False``)." +"name of the child module. The child module can be accessed from this " +"module using the given name" msgstr "" -#: of tensorcircuit.quantum.measurement_counts:21 -msgid "The counts for each bit string measured." +#: of torch.nn.modules.module.Module.add_module:8 +msgid "child module to be added to the module." msgstr "" -#: of tensorcircuit.quantum.mutual_information:1 -msgid "Mutual information between AB subsystem described by ``cut``." +#: of torch.nn.modules.module.Module.apply:1 +msgid "" +"Applies ``fn`` recursively to every submodule (as returned by " +"``.children()``) as well as self. Typical use includes initializing the " +"parameters of a model (see also :ref:`nn-init-doc`)." msgstr "" -#: of tensorcircuit.quantum.mutual_information:5 -msgid "The AB subsystem." +#: of torch.nn.modules.module.Module.apply:5 +msgid "function to be applied to each submodule" msgstr "" -#: of tensorcircuit.quantum.mutual_information:7 -msgid "The mutual information between AB subsystem described by ``cut``." +#: of torch.nn.modules.module.Module.apply:8 +#: torch.nn.modules.module.Module.bfloat16:6 +#: torch.nn.modules.module.Module.cpu:6 torch.nn.modules.module.Module.cuda:14 +#: torch.nn.modules.module.Module.double:6 +#: torch.nn.modules.module.Module.eval:13 +#: torch.nn.modules.module.Module.float:6 torch.nn.modules.module.Module.half:6 +#: torch.nn.modules.module.Module.requires_grad_:17 +#: torch.nn.modules.module.Module.to:45 +#: torch.nn.modules.module.Module.to_empty:7 +#: torch.nn.modules.module.Module.train:12 +#: torch.nn.modules.module.Module.type:9 torch.nn.modules.module.Module.xpu:14 +msgid "self" msgstr "" -#: of tensorcircuit.quantum.quantum_constructor:1 -msgid "" -"Constructs an appropriately specialized QuOperator. If there are no " -"edges, creates a QuScalar. If the are only output (input) edges, creates " -"a QuVector (QuAdjointVector). Otherwise creates a QuOperator." +#: of torch.nn.modules.module.Module.apply:11 +#: torch.nn.modules.module.Module.buffers:10 +#: torch.nn.modules.module.Module.modules:10 +#: torch.nn.modules.module.Module.named_buffers:13 +#: torch.nn.modules.module.Module.named_children:6 +#: torch.nn.modules.module.Module.named_modules:16 +#: torch.nn.modules.module.Module.named_parameters:13 +#: torch.nn.modules.module.Module.parameters:12 +#: torch.nn.modules.module.Module.register_buffer:25 +#: torch.nn.modules.module.Module.state_dict:10 +msgid "Example::" msgstr "" -#: of tensorcircuit.quantum.quantum_constructor:48 -msgid "A list of output edges." +#: of torch.nn.modules.module.Module.bfloat16:1 +msgid "Casts all floating point parameters and buffers to ``bfloat16`` datatype." msgstr "" -#: of tensorcircuit.quantum.quantum_constructor:50 -msgid "A list of input edges." +#: of torch.nn.modules.module.Module.bfloat16:4 +#: torch.nn.modules.module.Module.cpu:4 torch.nn.modules.module.Module.cuda:8 +#: torch.nn.modules.module.Module.double:4 +#: torch.nn.modules.module.Module.float:4 torch.nn.modules.module.Module.half:4 +#: torch.nn.modules.module.Module.to:29 torch.nn.modules.module.Module.type:4 +#: torch.nn.modules.module.Module.xpu:8 +msgid "This method modifies the module in-place." msgstr "" -#: of tensorcircuit.quantum.quantum_constructor:52 -msgid "" -"Reference nodes for the tensor network (needed if there is a. scalar " -"component)." +#: of torch.nn.modules.module.Module.buffers:1 +msgid "Returns an iterator over module buffers." msgstr "" -#: of tensorcircuit.quantum.quantum_constructor:55 -msgid "Edges to ignore when checking the dimensionality of the tensor network." +#: of torch.nn.modules.module.Module.buffers:3 +#: torch.nn.modules.module.Module.named_buffers:6 +msgid "" +"if True, then yields buffers of this module and all submodules. " +"Otherwise, yields only buffers that are direct members of this module." msgstr "" -#: of tensorcircuit.quantum.quantum_constructor:58 -msgid "The new created QuOperator object." +#: of torch.nn.modules.module.Module.buffers +#: torch.nn.modules.module.Module.children +#: torch.nn.modules.module.Module.modules +#: torch.nn.modules.module.Module.named_buffers +#: torch.nn.modules.module.Module.named_children +#: torch.nn.modules.module.Module.named_modules +#: torch.nn.modules.module.Module.named_parameters +#: torch.nn.modules.module.Module.parameters +msgid "Yields" msgstr "" -#: of tensorcircuit.quantum.quimb2qop:1 -msgid "Convert MPO in Quimb package to QuOperator." +#: of torch.nn.modules.module.Module.buffers:8 +msgid "*torch.Tensor* -- module buffer" msgstr "" -#: of tensorcircuit.quantum.quimb2qop:3 -msgid "MPO in the form of Quimb package" +#: of torch.nn.modules.module.Module.children:1 +msgid "Returns an iterator over immediate children modules." msgstr "" -#: of tensorcircuit.quantum.quimb2qop:5 tensorcircuit.quantum.tn2qop:5 -msgid "MPO in the form of QuOperator" +#: of torch.nn.modules.module.Module.children:3 +msgid "*Module* -- a child module" msgstr "" -#: of tensorcircuit.quantum.reduced_density_matrix:1 -msgid "Compute the reduced density matrix from the quantum state ``state``." +#: of torch.nn.modules.module.Module.cpu:1 +msgid "Moves all model parameters and buffers to the CPU." msgstr "" -#: of tensorcircuit.quantum.reduced_density_matrix:3 -msgid "The quantum state in form of Tensor or QuOperator." +#: of torch.nn.modules.module.Module.cuda:1 +msgid "Moves all model parameters and buffers to the GPU." msgstr "" -#: of tensorcircuit.quantum.reduced_density_matrix:5 +#: of torch.nn.modules.module.Module.cuda:3 msgid "" -"the index list that is traced out, if cut is a int, it indicates [0, cut]" -" as the traced out region" -msgstr "" - -#: of tensorcircuit.quantum.reduced_density_matrix:8 -msgid "probability decoration, default is None." +"This also makes associated parameters and buffers different objects. So " +"it should be called before constructing optimizer if the module will live" +" on GPU while being optimized." msgstr "" -#: of tensorcircuit.quantum.reduced_density_matrix:10 -msgid "The reduced density matrix." +#: of torch.nn.modules.module.Module.cuda:10 +#: torch.nn.modules.module.Module.xpu:10 +msgid "if specified, all parameters will be copied to that device" msgstr "" -#: of tensorcircuit.quantum.renyi_entropy:1 -msgid "Compute the Rényi entropy of order :math:`k` by given density matrix." +#: of torch.nn.modules.module.Module.double:1 +msgid "Casts all floating point parameters and buffers to ``double`` datatype." msgstr "" -#: of tensorcircuit.quantum.renyi_entropy:5 -#: tensorcircuit.quantum.renyi_free_energy:18 -msgid "The order of Rényi entropy, default is 2." +#: ../../docstring of tensorcircuit.torchnn.QuantumNet.dump_patches:1 +msgid "" +"This allows better BC support for :meth:`load_state_dict`. In " +":meth:`state_dict`, the version number will be saved as in the attribute " +"`_metadata` of the returned state dict, and thus pickled. `_metadata` is " +"a dictionary with keys that follow the naming convention of state dict. " +"See ``_load_from_state_dict`` on how to use this information in loading." msgstr "" -#: of tensorcircuit.quantum.renyi_entropy:7 -#: tensorcircuit.quantum.renyi_free_energy:20 -msgid "The :math:`k` th order of Rényi entropy." +#: ../../docstring of tensorcircuit.torchnn.QuantumNet.dump_patches:7 +msgid "" +"If new parameters/buffers are added/removed from a module, this number " +"shall be bumped, and the module's `_load_from_state_dict` method can " +"compare the version number and do appropriate changes if the state dict " +"is from before the change." msgstr "" -#: of tensorcircuit.quantum.renyi_free_energy:1 -msgid "" -"Compute the Rényi free energy of the corresponding density matrix and " -"Hamiltonian." +#: of torch.nn.modules.module.Module.eval:1 +msgid "Sets the module in evaluation mode." msgstr "" -#: of tensorcircuit.quantum.spin_by_basis:1 +#: of torch.nn.modules.module.Module.eval:3 +#: torch.nn.modules.module.Module.train:3 msgid "" -"Generate all n-bitstrings as an array, each row is a bitstring basis. " -"Return m-th col." +"This has any effect only on certain modules. See documentations of " +"particular modules for details of their behaviors in training/evaluation " +"mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`, " +"etc." msgstr "" -#: of tensorcircuit.quantum.spin_by_basis:9 -msgid "length of a bitstring" +#: of torch.nn.modules.module.Module.eval:8 +msgid "This is equivalent with :meth:`self.train(False) `." msgstr "" -#: of tensorcircuit.quantum.spin_by_basis:11 -msgid "m is transformed as " -"(01>-|10>)" +"Copies parameters and buffers from :attr:`state_dict` into this module " +"and its descendants. If :attr:`strict` is ``True``, then the keys of " +":attr:`state_dict` must exactly match the keys returned by this module's " +":meth:`~torch.nn.Module.state_dict` function." msgstr "" -#: of tensorcircuit.templates.blocks.Bell_pair_block:3 -msgid "Circuit in" +#: of torch.nn.modules.module.Module.load_state_dict:6 +msgid "a dict containing parameters and persistent buffers." msgstr "" -#: of tensorcircuit.templates.blocks.Bell_pair_block:5 +#: of torch.nn.modules.module.Module.load_state_dict:9 msgid "" -"pairs indices for Bell pairs, defaults to None, corresponds to neighbor " -"links" +"whether to strictly enforce that the keys in :attr:`state_dict` match the" +" keys returned by this module's :meth:`~torch.nn.Module.state_dict` " +"function. Default: ``True``" msgstr "" -#: of tensorcircuit.templates.blocks.Bell_pair_block:7 -msgid "Circuit out" +#: of torch.nn.modules.module.Module.load_state_dict:14 +msgid "" +"* **missing_keys** is a list of str containing the missing keys * " +"**unexpected_keys** is a list of str containing the unexpected keys" msgstr "" -#: of tensorcircuit.templates.blocks.example_block:1 -msgid "" -"The circuit ansatz is firstly one layer of Hadamard gates and then we " -"have ``nlayers`` blocks of :math:`e^{i\\theta Z_iZ_{i+1}}` two-qubit gate" -" in ladder layout, following rx gate." +#: of torch.nn.modules.module.Module.load_state_dict:14 +msgid "**missing_keys** is a list of str containing the missing keys" msgstr "" -#: of tensorcircuit.templates.blocks.example_block:5 -msgid "The circuit" +#: of torch.nn.modules.module.Module.load_state_dict:15 +msgid "**unexpected_keys** is a list of str containing the unexpected keys" msgstr "" -#: of tensorcircuit.templates.blocks.example_block:7 -msgid "paramter tensor with 2*nlayer*n elements" +#: of torch.nn.modules.module.Module.load_state_dict:16 +msgid "``NamedTuple`` with ``missing_keys`` and ``unexpected_keys`` fields" msgstr "" -#: of tensorcircuit.templates.blocks.example_block:9 -msgid "number of ZZ+RX blocks, defaults to 2" +#: of torch.nn.modules.module.Module.load_state_dict:20 +msgid "" +"If a parameter or buffer is registered as ``None`` and its corresponding " +"key exists in :attr:`state_dict`, :meth:`load_state_dict` will raise a " +"``RuntimeError``." msgstr "" -#: of tensorcircuit.templates.blocks.example_block:11 -msgid "whether use SVD split to reduce ZZ gate bond dimension, defaults to False" +#: of torch.nn.modules.module.Module.modules:1 +msgid "Returns an iterator over all modules in the network." msgstr "" -#: of tensorcircuit.templates.blocks.example_block:14 -msgid "The circuit with example ansatz attached" +#: of torch.nn.modules.module.Module.modules:3 +msgid "*Module* -- a module in the network" msgstr "" -#: of tensorcircuit.templates.blocks.state_centric:1 +#: of torch.nn.modules.module.Module.modules:7 +#: torch.nn.modules.module.Module.named_modules:13 msgid "" -"Function decorator wraps the function with the first input and output in " -"the format of circuit, the wrapped function has the first input and the " -"output as the state tensor." +"Duplicate modules are returned only once. In the following example, ``l``" +" will be returned only once." msgstr "" -#: of tensorcircuit.templates.blocks.state_centric:4 -msgid "Function with the fist input and the output as ``Circuit`` object." +#: of torch.nn.modules.module.Module.named_buffers:1 +msgid "" +"Returns an iterator over module buffers, yielding both the name of the " +"buffer as well as the buffer itself." msgstr "" -#: of tensorcircuit.templates.blocks.state_centric:6 -msgid "" -"Wrapped function with the first input and the output as the state tensor " -"correspondingly." +#: of torch.nn.modules.module.Module.named_buffers:4 +msgid "prefix to prepend to all buffer names." msgstr "" -#: ../../source/api/templates/chems.rst:2 -msgid "tensorcircuit.templates.chems" +#: of torch.nn.modules.module.Module.named_buffers:11 +msgid "*(string, torch.Tensor)* -- Tuple containing the name and buffer" msgstr "" -#: of tensorcircuit.templates.chems:1 -msgid "Useful utilities for quantum chemistry related task" +#: of torch.nn.modules.module.Module.named_children:1 +msgid "" +"Returns an iterator over immediate children modules, yielding both the " +"name of the module as well as the module itself." msgstr "" -#: of tensorcircuit.templates.chems.get_ps:1 +#: of torch.nn.modules.module.Module.named_children:4 +msgid "*(string, Module)* -- Tuple containing a name and child module" +msgstr "" + +#: of torch.nn.modules.module.Module.named_modules:1 msgid "" -"Get Pauli string array and weights array for a qubit Hamiltonian as a sum" -" of Pauli strings defined in openfermion ``QubitOperator``." +"Returns an iterator over all modules in the network, yielding both the " +"name of the module as well as the module itself." msgstr "" -#: of tensorcircuit.templates.chems.get_ps:4 -msgid "``openfermion.ops.operators.qubit_operator.QubitOperator``" +#: of torch.nn.modules.module.Module.named_modules:4 +msgid "a memo to store the set of modules already added to the result" msgstr "" -#: of tensorcircuit.templates.chems.get_ps:6 -msgid "The number of qubits" +#: of torch.nn.modules.module.Module.named_modules:5 +msgid "a prefix that will be added to the name of the module" msgstr "" -#: of tensorcircuit.templates.chems.get_ps:8 -msgid "Pauli String array and weights array" +#: of torch.nn.modules.module.Module.named_modules:6 +msgid "whether to remove the duplicated module instances in the result or not" msgstr "" -#: ../../source/api/templates/dataset.rst:2 -msgid "tensorcircuit.templates.dataset" +#: of torch.nn.modules.module.Module.named_modules:9 +msgid "*(string, Module)* -- Tuple of name and module" msgstr "" -#: of tensorcircuit.templates.dataset:1 -msgid "Quantum machine learning related data preprocessing and embedding" +#: of torch.nn.modules.module.Module.named_parameters:1 +msgid "" +"Returns an iterator over module parameters, yielding both the name of the" +" parameter as well as the parameter itself." msgstr "" -#: ../../source/api/templates/graphs.rst:2 -msgid "tensorcircuit.templates.graphs" +#: of torch.nn.modules.module.Module.named_parameters:4 +msgid "prefix to prepend to all parameter names." msgstr "" -#: of tensorcircuit.templates.graphs:1 -msgid "Some common graphs and lattices" +#: of torch.nn.modules.module.Module.named_parameters:6 +#: torch.nn.modules.module.Module.parameters:5 +msgid "" +"if True, then yields parameters of this module and all submodules. " +"Otherwise, yields only parameters that are direct members of this module." msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord:1 -msgid "Two-dimensional grid lattice" +#: of torch.nn.modules.module.Module.named_parameters:11 +msgid "*(string, Parameter)* -- Tuple containing the name and parameter" msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.__init__:1 -msgid "number of rows" +#: of torch.nn.modules.module.Module.parameters:1 +msgid "Returns an iterator over module parameters." msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.__init__:3 -msgid "number of cols" +#: of torch.nn.modules.module.Module.parameters:3 +msgid "This is typically passed to an optimizer." +msgstr "" + +#: of torch.nn.modules.module.Module.parameters:10 +msgid "*Parameter* -- module parameter" +msgstr "" + +#: of torch.nn.modules.module.Module.register_backward_hook:1 +#: torch.nn.modules.module.Module.register_full_backward_hook:1 +msgid "Registers a backward hook on the module." msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.all_cols:1 -msgid "return all col edge with 1d index encoding" +#: of torch.nn.modules.module.Module.register_backward_hook:3 +msgid "" +"This function is deprecated in favor of " +":meth:`~torch.nn.Module.register_full_backward_hook` and the behavior of " +"this function will change in future versions." msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.all_cols:3 -#: tensorcircuit.templates.graphs.Grid2DCoord.all_rows:3 +#: of torch.nn.modules.module.Module.register_backward_hook:6 +#: torch.nn.modules.module.Module.register_forward_hook:14 +#: torch.nn.modules.module.Module.register_forward_pre_hook:14 +#: torch.nn.modules.module.Module.register_full_backward_hook:25 msgid "" -"whether to include pbc edges (periodic boundary condition), defaults to " -"False" +"a handle that can be used to remove the added hook by calling " +"``handle.remove()``" msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.all_cols:6 -msgid "list of col edge" +#: of torch.nn.modules.module.Module.register_backward_hook:8 +#: torch.nn.modules.module.Module.register_forward_hook:16 +#: torch.nn.modules.module.Module.register_forward_pre_hook:16 +#: torch.nn.modules.module.Module.register_full_backward_hook:27 +msgid ":class:`torch.utils.hooks.RemovableHandle`" msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.all_rows:1 -msgid "return all row edge with 1d index encoding" +#: of torch.nn.modules.module.Module.register_buffer:1 +msgid "Adds a buffer to the module." msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.all_rows:6 -msgid "list of row edge" +#: of torch.nn.modules.module.Module.register_buffer:3 +msgid "" +"This is typically used to register a buffer that should not to be " +"considered a model parameter. For example, BatchNorm's ``running_mean`` " +"is not a parameter, but is part of the module's state. Buffers, by " +"default, are persistent and will be saved alongside parameters. This " +"behavior can be changed by setting :attr:`persistent` to ``False``. The " +"only difference between a persistent buffer and a non-persistent buffer " +"is that the latter will not be a part of this module's " +":attr:`state_dict`." msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph:1 -msgid "Get the 2D grid lattice in ``nx.Graph`` format" +#: of torch.nn.modules.module.Module.register_buffer:12 +msgid "Buffers can be accessed as attributes using given names." msgstr "" -#: of tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph:3 +#: of torch.nn.modules.module.Module.register_buffer:14 msgid "" -"whether to include pbc edges (periodic boundary condition), defaults to " -"True" +"name of the buffer. The buffer can be accessed from this module using the" +" given name" msgstr "" -#: of tensorcircuit.templates.graphs.Line1D:1 -msgid "1D chain with ``n`` sites" +#: of torch.nn.modules.module.Module.register_buffer:17 +msgid "" +"buffer to be registered. If ``None``, then operations that run on " +"buffers, such as :attr:`cuda`, are ignored. If ``None``, the buffer is " +"**not** included in the module's :attr:`state_dict`." msgstr "" -#: of tensorcircuit.templates.graphs.Line1D:5 -#: tensorcircuit.templates.measurements.heisenberg_measurements:34 -msgid "[description], defaults to True" +#: of torch.nn.modules.module.Module.register_buffer:21 +msgid "whether the buffer is part of this module's :attr:`state_dict`." msgstr "" -#: ../../source/api/templates/measurements.rst:2 -msgid "tensorcircuit.templates.measurements" +#: of torch.nn.modules.module.Module.register_forward_hook:1 +msgid "Registers a forward hook on the module." msgstr "" -#: of tensorcircuit.templates.measurements.any_measurements:1 +#: of torch.nn.modules.module.Module.register_forward_hook:3 msgid "" -"This measurements pattern is specifically suitable for vmap. Parameterize" -" the Pauli string to be measured." +"The hook will be called every time after :func:`forward` has computed an " +"output. It should have the following signature::" msgstr "" -#: of tensorcircuit.templates.measurements.any_measurements -#: tensorcircuit.templates.measurements.heisenberg_measurements -#: tensorcircuit.templates.measurements.spin_glass_measurements -msgid "example" +#: of torch.nn.modules.module.Module.register_forward_hook:8 +msgid "" +"The input contains only the positional arguments given to the module. " +"Keyword arguments won't be passed to the hooks and only to the " +"``forward``. The hook can modify the output. It can modify the input " +"inplace but it will not have effect on forward since this is called after" +" :func:`forward` is called." msgstr "" -#: of tensorcircuit.templates.measurements.any_measurements:26 -msgid "The circuit to be measured" +#: of torch.nn.modules.module.Module.register_forward_pre_hook:1 +msgid "Registers a forward pre-hook on the module." msgstr "" -#: of tensorcircuit.templates.measurements.any_measurements:28 +#: of torch.nn.modules.module.Module.register_forward_pre_hook:3 msgid "" -"parameter tensors determines what Pauli string to be measured, shape is " -"[nwires, 4] if ``onehot`` is False and [nwires] if ``onehot`` is True." +"The hook will be called every time before :func:`forward` is invoked. It " +"should have the following signature::" msgstr "" -#: of tensorcircuit.templates.measurements.any_measurements:31 +#: of torch.nn.modules.module.Module.register_forward_pre_hook:8 msgid "" -"defaults to False. If set to be True, structures will first go through " -"onehot procedure." +"The input contains only the positional arguments given to the module. " +"Keyword arguments won't be passed to the hooks and only to the " +"``forward``. The hook can modify the input. User can either return a " +"tuple or a single modified value in the hook. We will wrap the value into" +" a tuple if a single value is returned(unless that value is already a " +"tuple)." msgstr "" -#: of tensorcircuit.templates.measurements.any_measurements:34 -msgid "The expectation value of given Pauli string by the tensor ``structures``." +#: of torch.nn.modules.module.Module.register_full_backward_hook:3 +msgid "" +"The hook will be called every time the gradients with respect to module " +"inputs are computed. The hook should have the following signature::" msgstr "" -#: of tensorcircuit.templates.measurements.heisenberg_measurements:1 +#: of torch.nn.modules.module.Module.register_full_backward_hook:8 msgid "" -"Evaluate Heisenberg energy expectation, whose Hamiltonian is defined on " -"the lattice graph ``g`` as follows: (e are edges in graph ``g`` where e1 " -"and e2 are two nodes for edge e and v are nodes in graph ``g``)" +"The :attr:`grad_input` and :attr:`grad_output` are tuples that contain " +"the gradients with respect to the inputs and outputs respectively. The " +"hook should not modify its arguments, but it can optionally return a new " +"gradient with respect to the input that will be used in place of " +":attr:`grad_input` in subsequent computations. :attr:`grad_input` will " +"only correspond to the inputs given as positional arguments and all kwarg" +" arguments are ignored. Entries in :attr:`grad_input` and " +":attr:`grad_output` will be ``None`` for all non-Tensor arguments." msgstr "" -#: of tensorcircuit.templates.measurements.heisenberg_measurements:4 +#: of torch.nn.modules.module.Module.register_full_backward_hook:17 msgid "" -"H = \\sum_{e\\in g} w_e (h_{xx} X_{e1}X_{e2} + h_{yy} Y_{e1}Y_{e2} + " -"h_{zz} Z_{e1}Z_{e2})\n" -" + \\sum_{v\\in g} (h_x X_v + h_y Y_v + h_z Z_v)" +"For technical reasons, when this hook is applied to a Module, its forward" +" function will receive a view of each Tensor passed to the Module. " +"Similarly the caller will receive a view of each Tensor returned by the " +"Module's forward function." msgstr "" -#: of tensorcircuit.templates.measurements.heisenberg_measurements:18 -msgid "Circuit to be measured" +#: of torch.nn.modules.module.Module.register_full_backward_hook:22 +msgid "" +"Modifying inputs or outputs inplace is not allowed when using backward " +"hooks and will raise an error." msgstr "" -#: of tensorcircuit.templates.measurements.heisenberg_measurements:20 -msgid "Lattice graph defining Heisenberg Hamiltonian" +#: of torch.nn.modules.module.Module.register_module:1 +msgid "Alias for :func:`add_module`." msgstr "" -#: of tensorcircuit.templates.measurements.heisenberg_measurements:22 -#: tensorcircuit.templates.measurements.heisenberg_measurements:24 -#: tensorcircuit.templates.measurements.heisenberg_measurements:26 -msgid "[description], defaults to 1.0" +#: of torch.nn.modules.module.Module.register_parameter:1 +msgid "Adds a parameter to the module." msgstr "" -#: of tensorcircuit.templates.measurements.heisenberg_measurements:28 -#: tensorcircuit.templates.measurements.heisenberg_measurements:30 -#: tensorcircuit.templates.measurements.heisenberg_measurements:32 -msgid "[description], defaults to 0.0" +#: of torch.nn.modules.module.Module.register_parameter:3 +msgid "The parameter can be accessed as an attribute using given name." msgstr "" -#: of tensorcircuit.templates.measurements.heisenberg_measurements:36 -msgid "Value of Heisenberg energy" +#: of torch.nn.modules.module.Module.register_parameter:5 +msgid "" +"name of the parameter. The parameter can be accessed from this module " +"using the given name" msgstr "" -#: of tensorcircuit.templates.measurements.mpo_expectation:1 +#: of torch.nn.modules.module.Module.register_parameter:8 msgid "" -"Evaluate expectation of operator ``mpo`` defined in ``QuOperator`` MPO " -"format with the output quantum state from circuit ``c``." +"parameter to be added to the module. If ``None``, then operations that " +"run on parameters, such as :attr:`cuda`, are ignored. If ``None``, the " +"parameter is **not** included in the module's :attr:`state_dict`." msgstr "" -#: of tensorcircuit.templates.measurements.mpo_expectation:4 -msgid "The circuit for the output state" +#: of torch.nn.modules.module.Module.requires_grad_:1 +msgid "Change if autograd should record operations on parameters in this module." msgstr "" -#: of tensorcircuit.templates.measurements.mpo_expectation:6 -msgid "MPO operator" +#: of torch.nn.modules.module.Module.requires_grad_:4 +msgid "" +"This method sets the parameters' :attr:`requires_grad` attributes in-" +"place." msgstr "" -#: of tensorcircuit.templates.measurements.mpo_expectation:8 -#: tensorcircuit.templates.measurements.operator_expectation:7 -#: tensorcircuit.templates.measurements.sparse_expectation:7 -msgid "a real and scalar tensor of shape [] as the expectation value" +#: of torch.nn.modules.module.Module.requires_grad_:7 +msgid "" +"This method is helpful for freezing part of the module for finetuning or " +"training parts of a model individually (e.g., GAN training)." msgstr "" -#: of tensorcircuit.templates.measurements.operator_expectation:1 +#: of torch.nn.modules.module.Module.requires_grad_:10 msgid "" -"Evaluate Hamiltonian expectation where ``hamiltonian`` can be dense " -"matrix, sparse matrix or MPO." +"See :ref:`locally-disable-grad-doc` for a comparison between " +"`.requires_grad_()` and several similar mechanisms that may be confused " +"with it." msgstr "" -#: of tensorcircuit.templates.measurements.operator_expectation:3 -#: tensorcircuit.templates.measurements.sparse_expectation:3 -msgid "The circuit whose output state is used to evaluate the expectation" +#: of torch.nn.modules.module.Module.requires_grad_:13 +msgid "" +"whether autograd should record operations on parameters in this module. " +"Default: ``True``." msgstr "" -#: of tensorcircuit.templates.measurements.operator_expectation:5 -#: tensorcircuit.templates.measurements.sparse_expectation:5 -msgid "Hamiltonian matrix in COO_sparse_matrix form" +#: of torch.nn.modules.module.Module.set_extra_state:1 +msgid "" +"This function is called from :func:`load_state_dict` to handle any extra " +"state found within the `state_dict`. Implement this function and a " +"corresponding :func:`get_extra_state` for your module if you need to " +"store extra state within its `state_dict`." msgstr "" -#: of tensorcircuit.templates.measurements.sparse_expectation:1 -msgid "" -"Evaluate Hamiltonian expectation where ``hamiltonian`` is kept in sparse " -"matrix form to save space" +#: of torch.nn.modules.module.Module.set_extra_state:6 +msgid "Extra state from the `state_dict`" msgstr "" -#: of tensorcircuit.templates.measurements.spin_glass_measurements:1 +#: of torch.nn.modules.module.Module.share_memory:1 +msgid "See :meth:`torch.Tensor.share_memory_`" +msgstr "" + +#: of torch.nn.modules.module.Module.state_dict:1 +msgid "Returns a dictionary containing a whole state of the module." +msgstr "" + +#: of torch.nn.modules.module.Module.state_dict:3 msgid "" -"Compute spin glass energy defined on graph ``g`` expectation for output " -"state of the circuit ``c``. The Hamiltonian to be evaluated is defined as" -" (first term is determined by node weights while the second term is " -"determined by edge weights of the graph):" +"Both parameters and persistent buffers (e.g. running averages) are " +"included. Keys are corresponding parameter and buffer names. Parameters " +"and buffers set to ``None`` are not included." msgstr "" -#: of tensorcircuit.templates.measurements.spin_glass_measurements:5 -msgid "H = \\sum_{v\\in g} w_v Z_v + \\sum_{e\\in g} w_e Z_{e1} Z_{e2}" +#: of torch.nn.modules.module.Module.state_dict:7 +msgid "a dictionary containing a whole state of the module" msgstr "" -#: of tensorcircuit.templates.measurements.spin_glass_measurements:28 -msgid "The quantum circuit" +#: of torch.nn.modules.module.Module.to:1 +msgid "Moves and/or casts the parameters and buffers." msgstr "" -#: of tensorcircuit.templates.measurements.spin_glass_measurements:30 -msgid "The graph for spin glass Hamiltonian definition" +#: of torch.nn.modules.module.Module.to:3 +msgid "This can be called as" msgstr "" -#: of tensorcircuit.templates.measurements.spin_glass_measurements:32 +#: of torch.nn.modules.module.Module.to:17 msgid "" -"Whether measure the circuit with reusing the wavefunction, defaults to " -"True" +"Its signature is similar to :meth:`torch.Tensor.to`, but only accepts " +"floating point or complex :attr:`dtype`\\ s. In addition, this method " +"will only cast the floating point or complex parameters and buffers to " +":attr:`dtype` (if given). The integral parameters and buffers will be " +"moved :attr:`device`, if that is given, but with dtypes unchanged. When " +":attr:`non_blocking` is set, it tries to convert/move asynchronously with" +" respect to the host if possible, e.g., moving CPU Tensors with pinned " +"memory to CUDA devices." msgstr "" -#: of tensorcircuit.templates.measurements.spin_glass_measurements:34 -msgid "The spin glass energy expectation value" +#: of torch.nn.modules.module.Module.to:26 +msgid "See below for examples." msgstr "" -#: ../../source/api/torchnn.rst:2 -msgid "tensorcircuit.torchnn" +#: of torch.nn.modules.module.Module.to:31 +msgid "the desired device of the parameters and buffers in this module" msgstr "" -#: of tensorcircuit.torchnn:1 -msgid "PyTorch nn Module wrapper for quantum function" +#: of torch.nn.modules.module.Module.to:34 +msgid "" +"the desired floating point or complex dtype of the parameters and buffers" +" in this module" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet:1 -msgid "Bases: :py:class:`torch.nn.modules.module.Module`" +#: of torch.nn.modules.module.Module.to:37 +msgid "" +"Tensor whose dtype and device are the desired dtype and device for all " +"parameters and buffers in this module" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:1 -msgid "PyTorch nn Module wrapper on quantum function ``f``." +#: of torch.nn.modules.module.Module.to:40 +msgid "" +"the desired memory format for 4D parameters and buffers in this module " +"(keyword only argument)" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:32 -msgid "Quantum function with tensor in (input and weights) and tensor out." +#: of torch.nn.modules.module.Module.to:48 +msgid "Examples::" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:34 +#: of torch.nn.modules.module.Module.to_empty:1 msgid "" -"list of shape tuple for different weights as the non-first parameters for" -" ``f``" +"Moves the parameters and buffers to the specified device without copying " +"storage." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:36 -msgid "function that gives the shape tuple returns torch tensor, defaults to None" +#: of torch.nn.modules.module.Module.to_empty:3 +msgid "The desired device of the parameters and buffers in this module." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:38 -msgid "whether apply vmap (batch input) on ``f``, defaults to True" +#: of torch.nn.modules.module.Module.train:1 +msgid "Sets the module in training mode." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:40 -msgid "whether transform ``f`` with torch interface, defaults to True" +#: of torch.nn.modules.module.Module.train:8 +msgid "" +"whether to set training mode (``True``) or evaluation mode (``False``). " +"Default: ``True``." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:42 -msgid "whether jit ``f``, defaults to True" +#: of torch.nn.modules.module.Module.type:1 +msgid "Casts all parameters and buffers to :attr:`dst_type`." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.forward:1 -msgid "Defines the computation performed at every call." +#: of torch.nn.modules.module.Module.type:6 +msgid "the desired type" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.forward:3 -msgid "Should be overridden by all subclasses." +#: of torch.nn.modules.module.Module.xpu:1 +msgid "Moves all model parameters and buffers to the XPU." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.forward:6 +#: of torch.nn.modules.module.Module.xpu:3 msgid "" -"Although the recipe for forward pass needs to be defined within this " -"function, one should call the :class:`Module` instance afterwards instead" -" of this since the former takes care of running the registered hooks " -"while the latter silently ignores them." +"This also makes associated parameters and buffers different objects. So " +"it should be called before constructing optimizer if the module will live" +" on XPU while being optimized." +msgstr "" + +#: of torch.nn.modules.module.Module.zero_grad:1 +msgid "" +"Sets gradients of all model parameters to zero. See similar function " +"under :class:`torch.optim.Optimizer` for more context." +msgstr "" + +#: of torch.nn.modules.module.Module.zero_grad:4 +msgid "" +"instead of setting to zero, set the grads to None. See " +":meth:`torch.optim.Optimizer.zero_grad` for details." msgstr "" #: ../../source/api/translation.rst:2 @@ -7931,6 +17274,14 @@ msgstr "" msgid "Circuit object translation in different packages" msgstr "" +#: of tensorcircuit.translation.eqasm2tc:1 +msgid "Translation qexe/eqasm instruction to tensorcircuit Circuit object" +msgstr "" + +#: of tensorcircuit.translation.eqasm2tc:7 +msgid "lines of ignored code at the head and the tail, defaults to (6, 1)" +msgstr "" + #: of tensorcircuit.translation.perm_matrix:1 msgid "" "Generate a permutation matrix P. Due to the different convention or " @@ -7949,6 +17300,12 @@ msgstr "" msgid "The permutation matrix P" msgstr "" +#: of tensorcircuit.translation.qir2json:1 +msgid "" +"transform qir to json compatible list of dict where array is replaced by " +"real and imaginary list" +msgstr "" + #: of tensorcircuit.translation.qir2qiskit:1 msgid "" "Generate a qiskit quantum circuit using the quantum intermediate " @@ -7956,6 +17313,12 @@ msgid "" msgstr "" #: of tensorcircuit.translation.qir2qiskit:18 +msgid "" +"The extra quantum IR of tc circuit including measure and reset on " +"hardware, defaults to None" +msgstr "" + +#: of tensorcircuit.translation.qir2qiskit:21 msgid "qiskit QuantumCircuit object" msgstr "" @@ -7971,10 +17334,25 @@ msgstr "" msgid "Input state of the circuit. Default is None." msgstr "" -#: of tensorcircuit.translation.qiskit2tc:18 +#: of tensorcircuit.translation.qiskit2tc:24 msgid "A quantum circuit in tensorcircuit" msgstr "" +#: of tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure:1 +msgid "" +"qiskit ``from_qasm_str`` method cannot keep the order of measure as the " +"qasm file, we provide this alternative function in case the order of " +"measure instruction matters" +msgstr "" + +#: of tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure:4 +msgid "open qasm str" +msgstr "" + +#: of tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure:6 +msgid "``qiskit.circuit.QuantumCircuit``" +msgstr "" + #: ../../source/api/utils.rst:2 msgid "tensorcircuit.utils" msgstr "" @@ -7999,6 +17377,18 @@ msgstr "" msgid "The final results after function pipeline" msgstr "" +#: of tensorcircuit.utils.arg_alias:1 +msgid "function argument alias decorator with new docstring" +msgstr "" + +#: of tensorcircuit.utils.arg_alias:7 +msgid "whether to add doc for these new alias arguments, defaults True" +msgstr "" + +#: of tensorcircuit.utils.arg_alias:9 +msgid "the decorated function" +msgstr "" + #: of tensorcircuit.utils.benchmark:1 msgid "benchmark jittable function with staging time and running time" msgstr "" @@ -8007,10 +17397,6 @@ msgstr "" msgid "_description_, defaults to 5" msgstr "" -#: of tensorcircuit.utils.benchmark:7 -msgid "_description_, defaults to True" -msgstr "" - #: of tensorcircuit.utils.is_m1mac:1 msgid "check whether the running platform is MAC with M1 chip" msgstr "" @@ -8074,26 +17460,48 @@ msgid "Initial state, default is an all zero state '000...000'." msgstr "" #: of tensorcircuit.vis.qir2tex:16 -msgid "Measurement Basis, default is None which means no" +msgid "" +"Measurement Basis, default is None which means no measurement in the end " +"of the circuit." +msgstr "" + +#: of tensorcircuit.vis.qir2tex:19 +msgid "" +"If true, a right compression of the circuit will be conducted. A right " +"compression means we will try to shift gates from right to left if " +"possible." msgstr "" -#: of tensorcircuit.vis.qir2tex:17 +#: of tensorcircuit.vis.qir2tex:21 +msgid "" +"Default is false. :type rcompress: bool :param lcompress: If true, a left" +" compression of the circuit will be conducted." +msgstr "" + +#: of tensorcircuit.vis.qir2tex:24 +msgid "" +"A left compression means we will try to shift gates from left to right if" +" possible. Default is false." +msgstr "" + +#: of tensorcircuit.vis.qir2tex:27 msgid "" -"measurement in the end of the circuit. :type measure: Optional[List[str]]" -" :param rcompress: If true, a right compression of the circuit will be " -"conducted. A right compression means we will try to shift gates from " -"right to left if possible. Default is false. :type rcompress: bool :param" -" lcompress: If true, a left compression of the circuit will be conducted." -" A left compression means we will try to shift gates from left to right " -"if possible. Default is false. :type lcompress: bool :param standalone: " "If true, the tex code will be designed to generate a standalone document." " Default is false which means the generated tex code is just a quantikz " -"code block. :type standalone: bool :param return_string_table: If true, a" -" string table of tex code will also be returned. Default is false. :type " -"return_string_table: bool :return: Tex code of circuit visualization " -"based on quantikz package. If return_string_table is true, a string table" -" of tex code will also be returned. :rtype: Union[str, Tuple[str, " -"List[List[str]]]]" +"code block." +msgstr "" + +#: of tensorcircuit.vis.qir2tex:30 +msgid "" +"If true, a string table of tex code will also be returned. Default is " +"false." +msgstr "" + +#: of tensorcircuit.vis.qir2tex:33 +msgid "" +"Tex code of circuit visualization based on quantikz package. If " +"return_string_table is true, a string table of tex code will also be " +"returned." msgstr "" #: of tensorcircuit.vis.render_pdf:1 @@ -12482,3 +21890,100 @@ msgstr "" #~ "openfermion QubitOperator." #~ msgstr "" +#~ msgid "Apply mpo gate in MPO format on the circuit." +#~ msgstr "" + +#~ msgid "Apply multicontrol gate in MPO format on the circuit." +#~ msgstr "" + +#~ msgid "Returns the amplitude of the circuit given the bitstring l." +#~ msgstr "" + +#~ msgid "Apply the gate to two bits with given indexes." +#~ msgstr "" + +#~ msgid "The Gate applied on bits." +#~ msgstr "" + +#~ msgid "The index of the bit to apply the Gate." +#~ msgstr "" + +#~ msgid "Apply the gate to the bit with the given index." +#~ msgstr "" + +#~ msgid "The Gate applied on the bit." +#~ msgstr "" + +#~ msgid "" +#~ "Return the list of nodes that " +#~ "consititues the expectation value just " +#~ "before the contraction." +#~ msgstr "" + +#~ msgid "whether contract the output state firstly, defaults to True" +#~ msgstr "" + +#~ msgid "The tensor network for the expectation" +#~ msgstr "" + +#~ msgid "" +#~ "if true, we sample from the final" +#~ " state if memory allsows, True is " +#~ "prefered, defaults to False" +#~ msgstr "" + +#~ msgid "" +#~ "List (if batch) of tuple (binary " +#~ "configuration tensor and correponding " +#~ "probability)" +#~ msgstr "" + +#~ msgid "Sampling bistrings from the circuit output based on quantum amplitudes." +#~ msgstr "" + +#~ msgid "tensorcircuit.densitymatrix2" +#~ msgstr "" + +#~ msgid "Apply **CNOT** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **CY** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **CZ** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **H** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **I** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **S** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **SWAP** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **T** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **WROOT** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **X** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **Y** gate on the circuit." +#~ msgstr "" + +#~ msgid "Apply **Z** gate on the circuit." +#~ msgstr "" + +#~ msgid "" +#~ "Compute :math:`\\prod_{i\\in \\text{index}} s_i`," +#~ " where the probability for each " +#~ "bitstring is given as a vector " +#~ "``results``." +#~ msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/contribs.po b/docs/source/locale/zh/LC_MESSAGES/contribs.po index 232ced74..f59a61f1 100644 --- a/docs/source/locale/zh/LC_MESSAGES/contribs.po +++ b/docs/source/locale/zh/LC_MESSAGES/contribs.po @@ -9,7 +9,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit \n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2022-05-16 15:04+0800\n" +"POT-Creation-Date: 2023-01-13 11:04+0800\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" @@ -18,6 +18,111 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.9.1\n" +#: ../../source/contribs/development_MacM1.rst:2 +msgid "Run TensorCircuit on TensorlowBackend with Apple M1" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:3 +msgid "Contributed by (Yuqin Chen)" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:6 +msgid "Why We Can't Run TensorCircuit on TensorlowBackend with Apple M1" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:7 +msgid "" +"TensorCircuit requires Tensorflow to support TensorflowBackend. However " +"for Apple M1, Tensorflow package cannot be properly installed by a usual " +"method like \"pip install tensorflow\". As well, the TensorCircuit " +"package cannot be properly installed by a usual method \"pip install " +"tensorcircuit\" All we need is to properly install tensorflow on Apple M1" +" Pro and then download the TensorCircuit package to the local and install" +" it." +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:11 +msgid "Install tensorflow on Apple M1" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:12 +msgid "" +"According to the instructions below or the installation manual on Apple's" +" official website `tensorflow-metal PluggableDevice " +"`_, you can install" +" tensorflow step by step." +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:14 +msgid "**Step1: Environment setup**" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:16 +msgid "x86 : AMD Create virtual environment (recommended):" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:27 +msgid "NOTE: python version 3.8 required" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:29 +msgid "arm64 : Apple Silicon" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:31 +msgid "Download and install Conda env:" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:41 +msgid "Install the TensorFlow dependencies:" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:47 +msgid "When upgrading to new base TensorFlow version, recommend:" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:65 +msgid "tensorflow-deps versions are following base TensorFlow versions so:" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:67 +msgid "for v2.5" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:75 +msgid "for v2.6" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:82 +msgid "**Step2: Install base TensorFlow**" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:88 +msgid "**Step3: Install tensorflow-metal plugin**" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:96 +msgid "Install TensorCircuit on Apple M1" +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:97 +msgid "" +"After properly install tensorflow, you can continue install " +"TensorCircuit. Up to now, for Apple M1, the Tensorcircuit package can not" +" be installed by simply conducting \"pip install tensorcircuit\", which " +"will lead to improper way for Tensorflow installation. One need to " +"download the installation package to the local, only in this way the " +"installation proceess can recognize the Apple M1 environment." +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:102 +msgid "One should download the TensorCircuit package to local at first." +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:109 +msgid "Then unpackage it, and cd into the folder with \"setup.py\". Conducting" +msgstr "" + #: ../../source/contribs/development_windows.rst:2 msgid "Run TensorCircuit on Windows Machine with Docker" msgstr "" @@ -270,3 +375,142 @@ msgid "" "problems or have anything for discussion with other contributors*" msgstr "" +#: ../../source/contribs/development_wsl2.rst:2 +msgid "Run TensorCirit on Windows with WSL2 (Windows Subsystem for Linux 2)" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:4 +msgid "Contributed by `YHPeter `_ (Peter Yu)" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:6 +msgid "" +"Reminder, if you are not supposed to use JAX, you can still use " +"Numpy/Tensorflow/Pytorch backend to run demonstrations." +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:8 +msgid "" +"Step 1. Install WSL2, follow the official installation instruction: " +"https://docs.microsoft.com/en-us/windows/wsl/install" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:11 +msgid "" +"Step 2. Install CUDA for GPU support, if you want to used GPU " +"accelerator. The official CUDA installation for WSL2: " +"https://docs.nvidia.com/cuda/wsl-user-guide/index.html#ch02-getting-" +"started" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:15 +msgid "Step 3. Follow the Linux Installation Instructions to finish installing." +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:18 +msgid "**System Support Summary**" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:21 +msgid "Backend" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:22 +msgid "Numpy" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:23 +msgid "TensorFlow" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:24 +msgid "JAX" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:25 +msgid "Pytorch" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:26 +msgid "Suggested Package Version" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:27 +msgid ">= 1.20.0" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:28 +msgid ">= 2.7.0" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:29 +msgid ">= 0.3.0" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:30 +msgid ">= 1.12" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:31 +msgid "OS Support without GPU Accelerator" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:32 +#: ../../source/contribs/development_wsl2.rst:33 +#: ../../source/contribs/development_wsl2.rst:34 +#: ../../source/contribs/development_wsl2.rst:35 +msgid "Windows/MacOS/Linux" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:36 +msgid "OS Support with GPU Accelerator" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:37 +msgid "No Support for GPU" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:38 +msgid "" +"Windows(WSL2, docker)/`MacOS `_/Linux" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:39 +msgid "Windows(WSL2, docker)/MacOS/Linux" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:40 +msgid "Windows(WSL2, docker)/MacOS(torch>=1.12)/Linux" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:41 +msgid "Platform with TPU Accelerator" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:42 +msgid "No Support for TPU" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:43 +msgid "" +"`GCP - Tensorflow with TPU `_" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:44 +msgid "" +"`GCP - JAX with TPU `_" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:45 +msgid "" +"`GCP - Pytorch with TPU `_" +msgstr "" + +#: ../../source/contribs/development_wsl2.rst:47 +msgid "Tips: Currently, we don't suggest you to use TPU accelerator." +msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/faq.po b/docs/source/locale/zh/LC_MESSAGES/faq.po index d7eb9c4b..768580a2 100644 --- a/docs/source/locale/zh/LC_MESSAGES/faq.po +++ b/docs/source/locale/zh/LC_MESSAGES/faq.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2022-05-17 16:24+0800\n" +"POT-Creation-Date: 2023-01-13 11:04+0800\n" "PO-Revision-Date: 2022-05-11 17:52+0800\n" "Last-Translator: Xinghan Yang \n" "Language: cn\n" @@ -190,16 +190,12 @@ msgid "" "backend for quantum-classical hybrid machine learning tasks, where " "``QuantumLayer`` plays an important role. For PyTorch, we can in " "principle wrap the corresponding quantum function into a PyTorch module, " -"but we currently have no built-in support for this wrapper. In terms of " -"the Jax backend, we highly suggested keeping the functional programming " -"paradigm for such machine learning tasks. Besides, it is worth noting " -"that, jit and vmap are automatically taken care of in ``QuantumLayer``." +"we currently have the built-in support for this wrapper as " +"``tc.TorchLayer``. In terms of the Jax backend, we highly suggested " +"keeping the functional programming paradigm for such machine learning " +"tasks. Besides, it is worth noting that, jit and vmap are automatically " +"taken care of in ``QuantumLayer``." msgstr "" -"由于 PyTorch 没有成熟的 vmap 和 jit 支持，而且 Jax 没有原生的经典 ML 层，我们强烈推荐 TensorFlow " -"作为量子经典混合机器学习任务的后端，其中 QuantumLayer 起着重要作用。 对于 PyTorch，我们原则上可以将相应的量子函数包装到 " -"PyTorch 模块中，但我们目前没有内置支持这个包装器。在 Jax " -"后端方面，我们强烈建议保留函数式编程范式来处理此类机器学习任务。此外，值得注意的是，jit 和 vmap 在 QuantumLayer " -"中是自动处理的。" #: ../../source/faq.rst:74 msgid "When do I need to customize the contractor and how?" @@ -346,29 +342,47 @@ msgstr "" #: ../../source/faq.rst:155 msgid "" +"How to understand difference between ``tc.array_to_tensor`` and " +"``tc.backend.convert_to_tensor``?" +msgstr "" + +#: ../../source/faq.rst:157 +msgid "" +"``tc.array_to_tensor`` convert array to tensor as well as automatically " +"cast the type to the default dtype of TensorCircuit, i.e. ``tc.dtypestr``" +" and it also support to specify dtype as ``tc.array_to_tensor( , " +"dtype=\"complex128\")``. Instead, ``tc.backend.convert_to_tensor`` keeps " +"the dtype of the input array, and to cast it as complex dtype, we have to" +" explicitly call ``tc.backend.cast`` after conversion. Besides, " +"``tc.array_to_tensor`` also accepts multiple inputs as ``a_tensor, " +"b_tensor = tc.array_to_tensor(a_array, b_array)``." +msgstr "" + +#: ../../source/faq.rst:165 +msgid "" "How to arrange the circuit gate placement in the visualization from " "``c.tex()``?" msgstr "" -#: ../../source/faq.rst:157 +#: ../../source/faq.rst:167 msgid "" "Try ``lcompress=True`` or ``rcompress=True`` option in " ":py:meth:`tensorcircuit.circuit.Circuit.tex` API to make the circuit " "align from the left or from the right." msgstr "" -#: ../../source/faq.rst:159 +#: ../../source/faq.rst:169 msgid "" "Or try ``c.unitary(0, unitary=tc.backend.eye(2), name=\"invisible\")`` to" " add placeholder on the circuit which is invisible for circuit " "visualization." msgstr "" -#: ../../source/faq.rst:162 +#: ../../source/faq.rst:172 msgid "How to get the entanglement entropy from the circuit output?" msgstr "" -#: ../../source/faq.rst:164 +#: ../../source/faq.rst:174 msgid "Try the following:" msgstr "" @@ -535,3 +549,30 @@ msgstr "" #~ msgid "Try the following:" #~ msgstr "尝试以下方法：" +#~ msgid "" +#~ "Since PyTorch doesn't have mature vmap" +#~ " and jit support and Jax doesn't " +#~ "have native classical ML layers, we " +#~ "highly recommend TensorFlow as the " +#~ "backend for quantum-classical hybrid " +#~ "machine learning tasks, where ``QuantumLayer``" +#~ " plays an important role. For " +#~ "PyTorch, we can in principle wrap " +#~ "the corresponding quantum function into " +#~ "a PyTorch module, but we currently " +#~ "have no built-in support for this" +#~ " wrapper. In terms of the Jax " +#~ "backend, we highly suggested keeping the" +#~ " functional programming paradigm for such" +#~ " machine learning tasks. Besides, it " +#~ "is worth noting that, jit and vmap" +#~ " are automatically taken care of in" +#~ " ``QuantumLayer``." +#~ msgstr "" +#~ "由于 PyTorch 没有成熟的 vmap 和 jit 支持，而且" +#~ " Jax 没有原生的经典 ML 层，我们强烈推荐 TensorFlow " +#~ "作为量子经典混合机器学习任务的后端，其中 QuantumLayer 起着重要作用。 对于 " +#~ "PyTorch，我们原则上可以将相应的量子函数包装到 PyTorch 模块中，但我们目前没有内置支持这个包装器。在" +#~ " Jax 后端方面，我们强烈建议保留函数式编程范式来处理此类机器学习任务。此外，值得注意的是，jit 和" +#~ " vmap 在 QuantumLayer 中是自动处理的。" + diff --git a/docs/source/locale/zh/LC_MESSAGES/index.po b/docs/source/locale/zh/LC_MESSAGES/index.po index e9fd014b..763e7130 100644 --- a/docs/source/locale/zh/LC_MESSAGES/index.po +++ b/docs/source/locale/zh/LC_MESSAGES/index.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2022-07-01 10:20+0800\n" +"POT-Creation-Date: 2023-01-13 11:04+0800\n" "PO-Revision-Date: 2022-04-16 22:37+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -85,55 +85,58 @@ msgstr "PyPI 页面: https://pypi.org/project/tensorcircuit" msgid "" "DockerHub page: " "https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit" -msgstr "DockerHub 页面: https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit" - -#: ../../source/index.rst:36 -msgid "" -"Binder online: https://mybinder.org/v2/gh/refraction-ray/tc-" -"env/master?urlpath=git-pull?repo=https://github.com/tencent-quantum-" -"lab/tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" msgstr "" -"在线 Binder Jupyter: https://mybinder.org/v2/gh/refraction-ray/tc-" -"env/master?urlpath=git-pull?repo=https://github.com/tencent-quantum-" -"lab/tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" +"DockerHub 页面: " +"https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit" -#: ../../source/index.rst:41 +#: ../../source/index.rst:39 msgid "Reference Documentation" msgstr "参考文档" -#: ../../source/index.rst:43 +#: ../../source/index.rst:41 msgid "" "The following documentation sections briefly introduce TensorCircuit to " "the users and developpers." msgstr "以下文档向用户和开发者简要介绍了 TensorCircuit 软件。" -#: ../../source/index.rst:56 +#: ../../source/index.rst:54 msgid "Tutorials" msgstr "教程" -#: ../../source/index.rst:58 +#: ../../source/index.rst:56 msgid "" "The following documentation sections include integrated examples in the " "form of Jupyter Notebook." msgstr "以下 Jupyter Notebook 格式的文档包括了一系列使用 TensorCircuit 的集成案例。" -#: ../../source/index.rst:72 +#: ../../source/index.rst:70 msgid "API References" msgstr "API 参考" -#: ../../source/index.rst:81 +#: ../../source/index.rst:79 msgid "Indices and Tables" msgstr "索引和表格" -#: ../../source/index.rst:83 +#: ../../source/index.rst:81 msgid ":ref:`genindex`" msgstr ":ref:`genindex`" -#: ../../source/index.rst:84 +#: ../../source/index.rst:82 msgid ":ref:`modindex`" msgstr ":ref:`modindex`" -#: ../../source/index.rst:85 +#: ../../source/index.rst:83 msgid ":ref:`search`" msgstr ":ref:`search`" +#~ msgid "" +#~ "Binder online: https://mybinder.org/v2/gh/refraction-" +#~ "ray/tc-env/master?urlpath=git-pull?repo=https://github.com" +#~ "/tencent-quantum-" +#~ "lab/tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" +#~ msgstr "" +#~ "在线 Binder Jupyter: https://mybinder.org/v2/gh" +#~ "/refraction-ray/tc-env/master?urlpath=git-" +#~ "pull?repo=https://github.com/tencent-quantum-" +#~ "lab/tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" + diff --git a/docs/source/locale/zh/LC_MESSAGES/infras.po b/docs/source/locale/zh/LC_MESSAGES/infras.po index 89bd7dcc..6a2077b5 100644 --- a/docs/source/locale/zh/LC_MESSAGES/infras.po +++ b/docs/source/locale/zh/LC_MESSAGES/infras.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2022-06-27 20:10+0800\n" +"POT-Creation-Date: 2023-01-13 11:04+0800\n" "PO-Revision-Date: 2022-04-18 20:44+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -39,6 +39,13 @@ msgstr "**核心模块：**" #: ../../source/infras.rst:13 msgid "" +":py:mod:`tensorcircuit.abstractcircuit` and " +":py:mod:`tensorcircuit.basecircuit`: Hierarchical abstraction of circuit " +"class." +msgstr "" + +#: ../../source/infras.rst:15 +msgid "" ":py:mod:`tensorcircuit.circuit`: The core object " ":py:obj:`tensorcircuit.circuit.Circuit`. It supports circuit " "construction, simulation, representation, and visualization without noise" @@ -47,7 +54,7 @@ msgstr "" ":py:mod:`tensorcircuit.circuit`: 核心对象 " ":py:obj:`tensorcircuit.circuit.Circuit`.它支持使用蒙特卡洛轨迹方法的无噪声或有噪声的电路构建、仿真、表示和可视化。" -#: ../../source/infras.rst:15 +#: ../../source/infras.rst:17 msgid "" ":py:mod:`tensorcircuit.cons`: Runtime ML backend, dtype and contractor " "setups. We provide three sets of set methods for global setup, function " @@ -59,7 +66,7 @@ msgstr "" "我们为全局设置、使用函数装饰器的函数级别设置和使用 ``with`` 上下文管理器的上下文设置提供了三组设置方法.我们还在此模块中提供了定制的 " "contractor 基础设施。" -#: ../../source/infras.rst:17 +#: ../../source/infras.rst:19 msgid "" ":py:mod:`tensorcircuit.gates`: Definition of quantum gates, either fixed " "ones or parameterized ones, as well as " @@ -68,11 +75,11 @@ msgstr "" ":py:mod:`tensorcircuit.gates`: 固定或参数化的量子门的定义，以及用于门的 " ":py:obj:`tensorcircuit.gates.GateF` 类。" -#: ../../source/infras.rst:19 +#: ../../source/infras.rst:21 msgid "**Backend Agnostic Abstraction:**" msgstr "**后端无关抽象：**" -#: ../../source/infras.rst:21 +#: ../../source/infras.rst:23 msgid "" ":py:mod:`tensorcircuit.backends` provides a set of backend API and the " "corresponding implementation on Numpy, Jax, TensorFlow, and PyTorch " @@ -82,37 +89,37 @@ msgstr "" ":py:mod:`tensorcircuit.backends` 提供了一组后端 API 以及在 Numpy、Jax、TensorFlow 和 " "PyTorch 后端上的对应实现。这些后端继承自 TensorNetwork 包并且是高度定制的。" -#: ../../source/infras.rst:23 +#: ../../source/infras.rst:25 msgid "**Noisy Simulation Related Modules:**" msgstr "**噪声模拟相关模块：**" -#: ../../source/infras.rst:25 +#: ../../source/infras.rst:27 msgid ":py:mod:`tensorcircuit.channels`: Definition of quantum noise channels." msgstr ":py:mod:`tensorcircuit.channels`: 量子噪声通道的定义。" -#: ../../source/infras.rst:27 +#: ../../source/infras.rst:29 +#, fuzzy msgid "" -":py:mod:`tensorcircuit.densitymatrix`: Referenced implementation of " -"``tc.DMCircuit`` class, with similar set API of ``tc.Circuit`` while " -"simulating the noise in the full form of the density matrix." +":py:mod:`tensorcircuit.densitymatrix`: Referenced and highly efficient " +"implementation of ``tc.DMCircuit`` class, with similar set API of " +"``tc.Circuit`` while simulating the noise in the full form of the density" +" matrix." msgstr "" ":py:mod:`tensorcircuit.densitymatrix`: Referenced implementation of " "``tc.DMCircuit`` 类的引用实现，具有 ``tc.Circuit`` 的类似集合 API，同时以密度矩阵的完整形式模拟噪声。" -#: ../../source/infras.rst:29 +#: ../../source/infras.rst:31 +#, fuzzy msgid "" -":py:mod:`tensorcircuit.densitymatrix2`: Highly efficient implementation " -"of :py:obj:`tensorcircuit.densitymatrix2.DMCircuit2` class, always " -"preferred than the referenced implementation." -msgstr "" -":py:mod:`tensorcircuit.densitymatrix2`: " -":py:obj:`tensorcircuit.densitymatrix2.DMCircuit2` 类的高效实现，总是比参考的实现更适用。" +":py:mod:`tensorcircuit.noisemodel`: The global noise configuration and " +"circuit noisy method APIs" +msgstr ":py:mod:`tensorcircuit.vis`: 用于电路可视化的代码" -#: ../../source/infras.rst:31 +#: ../../source/infras.rst:33 msgid "**ML Interfaces Related Modules:**" msgstr "**机器学习接口相关模块：**" -#: ../../source/infras.rst:33 +#: ../../source/infras.rst:35 msgid "" ":py:mod:`tensorcircuit.interfaces`: Provide interfaces when quantum " "simulation backend is different from neural libraries. Currently include " @@ -121,7 +128,7 @@ msgstr "" ":py:mod:`tensorcircuit.interfaces`: 当量子模拟后端与神经库不同时提供接口。 目前包括 PyTorch 和 " "scipy 优化器接口。" -#: ../../source/infras.rst:35 +#: ../../source/infras.rst:37 msgid "" ":py:mod:`tensorcircuit.keras`: Provide TensorFlow Keras layers, as well " "as wrappers of jitted function, save/load from tf side." @@ -129,15 +136,15 @@ msgstr "" ":py:mod:`tensorcircuit.keras`: 提供 TensorFlow Keras 层，以及可及时编译函数的包装器，从 " "TensorFlow 端保存/加载." -#: ../../source/infras.rst:37 +#: ../../source/infras.rst:39 msgid ":py:mod:`tensorcircuit.torchnn`: Provide PyTorch nn Modules." msgstr "" -#: ../../source/infras.rst:39 +#: ../../source/infras.rst:41 msgid "**MPS and MPO Utiliy Modules:**" msgstr "**MPS 和 MPO 实用模块：**" -#: ../../source/infras.rst:41 +#: ../../source/infras.rst:43 msgid "" ":py:mod:`tensorcircuit.quantum`: Provide definition and classes for " "Matrix Product States as well as Matrix Product Operators, we also " @@ -147,11 +154,11 @@ msgstr "" ":py:mod:`tensorcircuit.quantum`: " "提供矩阵乘积状态以及矩阵乘积算子的定义和类，我们还在这个模块中包含了各种量子物理和量子信息量。" -#: ../../source/infras.rst:43 +#: ../../source/infras.rst:45 msgid "**MPS Based Simulator Modules:**" msgstr "**基于 MPS 的模拟器模块：**" -#: ../../source/infras.rst:45 +#: ../../source/infras.rst:47 msgid "" ":py:mod:`tensorcircuit.mps_base`: Customized and jit/AD compatible MPS " "class from TensorNetwork package." @@ -159,7 +166,7 @@ msgstr "" ":py:mod:`tensorcircuit.mps_base`: 来自 TensorNetwork 包的自定义并且即时编译/自动微分兼容的 " "MPS 类。" -#: ../../source/infras.rst:47 +#: ../../source/infras.rst:49 msgid "" ":py:mod:`tensorcircuit.mpscircuit`: " ":py:obj:`tensorcircuit.mpscircuit.MPSCircuit` class with similar (but " @@ -170,59 +177,69 @@ msgstr "" ":py:obj:`tensorcircuit.mpscircuit.MPSCircuit` 类具有与 " "``tc.Circuit``，类似（但略有不同）的 API，其中仿真引擎基于 MPS TEBD。" -#: ../../source/infras.rst:49 +#: ../../source/infras.rst:51 msgid "**Supplemental Modules:**" msgstr "**支持模块：**" -#: ../../source/infras.rst:51 +#: ../../source/infras.rst:53 msgid "" ":py:mod:`tensorcircuit.simplify`: Provide tools and utility functions to " "simplify the tensornetworks before the real contractions." msgstr ":py:mod:`tensorcircuit.simplify`: 提供工具和实用函数以在真正收缩之前简化张量网络。" -#: ../../source/infras.rst:53 +#: ../../source/infras.rst:55 msgid "" ":py:mod:`tensorcircuit.experimental`: Experimental functions, long and " "stable support is not guaranteed." msgstr ":py:mod:`tensorcircuit.experimental`: 实验函数，不保证有持久且稳定的支持。" -#: ../../source/infras.rst:55 +#: ../../source/infras.rst:57 msgid "" ":py:mod:`tensorcircuit.utils`: Some general function tools that are not " "quantum at all." msgstr ":py:mod:`tensorcircuit.utils`: 一些与量子完全无关的通用工具函数。" -#: ../../source/infras.rst:57 +#: ../../source/infras.rst:59 msgid ":py:mod:`tensorcircuit.vis`: Visualization code for circuit drawing." msgstr ":py:mod:`tensorcircuit.vis`: 用于电路可视化的代码" -#: ../../source/infras.rst:59 +#: ../../source/infras.rst:61 msgid "" ":py:mod:`tensorcircuit.translation`: Translate circuit object to circuit " "object in other quantum packages." msgstr ":py:mod:`tensorcircuit.translation`: 将电路对象转换为其他量子包中的电路对象。" -#: ../../source/infras.rst:61 +#: ../../source/infras.rst:63 +msgid "**Processing and error mitigation on sample results:**" +msgstr "" + +#: ../../source/infras.rst:65 +msgid "" +":py:mod:`tensorcircuit.results`: Provide tools to process count dict and " +"to apply error mitigation" +msgstr "" + +#: ../../source/infras.rst:67 msgid "**Shortcuts and Templates for Circuit Manipulation:**" msgstr "**电路操作的快捷方式和模板：**" -#: ../../source/infras.rst:63 +#: ../../source/infras.rst:69 msgid "" ":py:mod:`tensorcircuit.templates`: provide handy shortcuts functions for " "expectation or circuit building patterns." msgstr ":py:mod:`tensorcircuit.templates`: 为期望或电路构建模式提供方便的快捷函数。" -#: ../../source/infras.rst:65 +#: ../../source/infras.rst:71 msgid "**Applications:**" msgstr "**应用：**" -#: ../../source/infras.rst:67 +#: ../../source/infras.rst:73 msgid "" ":py:mod:`tensorcircuit.applications`: most code here is not maintained " "and deprecated, use at your own risk." msgstr ":py:mod:`tensorcircuit.applications`: 这里的大多数代码都没有维护并且被弃用了，使用风险自负。" -#: ../../source/infras.rst:71 +#: ../../source/infras.rst:77 msgid "" "Recommend reading order -- only read the part of code you care about for " "your purpose. If you want to get an overview of the codebase, please read" @@ -231,11 +248,11 @@ msgstr "" "推荐阅读顺序——只阅读你关心的部分代码。如果您想了解代码库的概述，之后可以阅读 ``tc.circuit`` 后面的 ``tc.cons`` 和 " "``tc.gates``。" -#: ../../source/infras.rst:76 +#: ../../source/infras.rst:82 msgid "Relation between TensorCircuit and TensorNetwork" msgstr "TensorCircuit 和 TensorNetwork 之间的关系" -#: ../../source/infras.rst:78 +#: ../../source/infras.rst:84 msgid "" "TensorCircuit has a strong connection with the `TensorNetwork package " "`_ released by Google. Since the" @@ -249,7 +266,7 @@ msgstr "" "包的文档和教程很差，大多数时候，我们需要深入研究 TensorNetwork 的代码库来弄清楚发生了什么。换句话说，要阅读 " "TensorCircuit 代码库，可能需要经常参考 TensorNetwork 代码库。" -#: ../../source/infras.rst:80 +#: ../../source/infras.rst:86 msgid "" "Inside TensorCircuit, we heavily utilize TensorNetwork-related APIs from " "the TensorNetwork package and highly customized several modules from " @@ -258,7 +275,7 @@ msgstr "" "在 TensorCircuit 内部，我们大量使用了 TensorNetwork 包中与 TensorNetwork 相关的 " "API，并通过继承和重写从 TensorNetwork 中高度定制了几个模块：" -#: ../../source/infras.rst:82 +#: ../../source/infras.rst:88 msgid "" "We implement our own /backends from TensorNetwork's /backends by adding " "much more APIs and fixing lots of bugs in TensorNetwork's implementations" @@ -268,7 +285,7 @@ msgstr "" "我们从 TensorNetwork 的后端实现我们自己的后端，方法是添加更多 API，并通过猴子补丁修复 TensorNetwork " "在某些后端的实现中的许多错误。（上游是不活跃的，反馈不够灵敏）" -#: ../../source/infras.rst:84 +#: ../../source/infras.rst:90 msgid "" "We borrow TensorNetwork's code in /quantum to our ``tc.quantum`` module, " "since TensorNetwork has no ``__init__.py`` file to export these MPO and " @@ -279,7 +296,7 @@ msgstr "" "TensorNetwork 没有 ``__init__.py`` 文件来导出这些 MPO 和 MPS " "相关对象。当然，从那时起，我们已经取得了实质性的代码改进。" -#: ../../source/infras.rst:86 +#: ../../source/infras.rst:92 msgid "" "We borrow the TensorNetwork's code in /matrixproductstates as " "``tc.mps_base`` for bug fixing and jit/AD compatibility, so that we have " @@ -288,11 +305,15 @@ msgstr "" "我们借用 /matrixproductstates 中 TensorNetwork 的代码作为 ``tc.mps_base`` " "用于错误修复和即时编译/自动微分兼容性，以便我们更好地支持基于 MPS 的量子电路模拟器。" -#: ../../source/infras.rst:90 +#: ../../source/infras.rst:96 +msgid "Relations of Circuit-like classes" +msgstr "" + +#: ../../source/infras.rst:108 msgid "QuOperator/QuVector and MPO/MPS" msgstr "QuOperator/QuVector 和 MPO/MPS" -#: ../../source/infras.rst:92 +#: ../../source/infras.rst:110 msgid "" ":py:class:`tensorcircuit.quantum.QuOperator`, " ":py:class:`tensorcircuit.quantum.QuVector` and " @@ -306,19 +327,19 @@ msgstr "" ":py:class:`tensorcircuit.quantum.QuAdjointVector` 是从 TensorNetwork " "包中采用的类。它们的行为类似于与其他成分交互时的矩阵/向量（列或行），而内部结构由张量网络维护以提高效率和紧凑性。" -#: ../../source/infras.rst:95 +#: ../../source/infras.rst:113 msgid "" "We use code examples and associated tensor diagrams to illustrate these " "object abstractions." msgstr "我们使用代码示例和相关的张量图来说明这些对象抽象。" -#: ../../source/infras.rst:99 +#: ../../source/infras.rst:117 msgid "" "``QuOperator`` can express MPOs and ``QuVector`` can express MPSs, but " "they can express more than these fixed structured tensor networks." msgstr "``QuOperator`` 可以表达 MPO，``QuVector`` 可以表达 MPS，但它们可以表达的不仅仅是这些固定的结构化张量网络。" -#: ../../source/infras.rst:127 +#: ../../source/infras.rst:145 msgid "" "Note how in this example, ``matrix`` is not a typical MPO but still can " "be expressed as ``QuOperator``. Indeed, any tensor network with two sets " @@ -330,7 +351,7 @@ msgstr "" "``QuOperator``。事实上，任何具有两组相同维度的悬边的张量网络都可以被视为 `` QuOperator``。``QuVector`` " "更加灵活，因为我们可以将所有悬空边视为向量维度。" -#: ../../source/infras.rst:129 +#: ../../source/infras.rst:147 msgid "" "Also, note how ``^`` is overloaded as ``tn.connect`` to connect edges " "between different nodes in TensorNetwork. And indexing the node gives the" @@ -339,7 +360,7 @@ msgstr "" "还要注意 ``^`` 是如何被重载为 ``tn.connect`` 以连接 TensorNetwork " "中不同节点之间的边。索引节点给出了节点的边，例如 ``n1[0]`` 意味着 ``节点 n1`` 的第一条边。" -#: ../../source/infras.rst:131 +#: ../../source/infras.rst:149 msgid "" "The convention to define the ``QuOperator`` is firstly giving " "``out_edges`` (left index or row index of the matrix) and then giving " @@ -349,7 +370,7 @@ msgstr "" "定义 ``QuOperator`` 的惯例是首先给出 ``out_edges``（矩阵的左索引或行索引），然后给出 " "``in_edges``（矩阵的右索引或列索引)。边列表包含来自 TensorNetwork 库的边对象。" -#: ../../source/infras.rst:133 +#: ../../source/infras.rst:151 msgid "" "Such QuOperator/QuVector abstraction support various calculations only " "possible on matrix/vectors, such as matmul (``@``), adjoint " @@ -365,3 +386,14 @@ msgstr "" "(``*``)、张量乘积（``|``）和偏迹（``.partial_trace(subsystems_to_trace_out)``）。要提取这些对象的矩阵信息，我们可以使用" " ``.eval()`` 或 ``.eval_matrix() ``，前者保留了张量网络的形状信息，而后者给出了形状秩为2的矩阵表示。" +#~ msgid "" +#~ ":py:mod:`tensorcircuit.densitymatrix2`: Highly efficient" +#~ " implementation of " +#~ ":py:obj:`tensorcircuit.densitymatrix2.DMCircuit2` class, " +#~ "always preferred than the referenced " +#~ "implementation." +#~ msgstr "" +#~ ":py:mod:`tensorcircuit.densitymatrix2`: " +#~ ":py:obj:`tensorcircuit.densitymatrix2.DMCircuit2` " +#~ "类的高效实现，总是比参考的实现更适用。" + diff --git a/docs/source/locale/zh/LC_MESSAGES/quickstart.po b/docs/source/locale/zh/LC_MESSAGES/quickstart.po index 9e6e65f7..6290e6dc 100644 --- a/docs/source/locale/zh/LC_MESSAGES/quickstart.po +++ b/docs/source/locale/zh/LC_MESSAGES/quickstart.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2022-05-16 15:04+0800\n" +"POT-Creation-Date: 2023-01-13 11:04+0800\n" "PO-Revision-Date: 2022-04-11 08:23+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -115,9 +115,9 @@ msgid "" "``c.measure(0, 1, with_prob=True)``. The measure API is by default non-" "jittable, but we also have a jittable version as ``c.measure_jit(0, 1)``." msgstr "" -"要测量部分量子比特，我们可以使用 ``c.measure(0, 1)``，如果我们想知道测量的结果的对应概率，可以尝试 ``c.measure(0, 1, " -"with_prob=True)``。 测量 API 在默认情况下是不可即时编译的 ，但我们也有一个可即时编译的版本，如 " -"``c.measure_jit(0, 1)``。" +"要测量部分量子比特，我们可以使用 ``c.measure(0, 1)``，如果我们想知道测量的结果的对应概率，可以尝试 " +"``c.measure(0, 1, with_prob=True)``。 测量 API 在默认情况下是不可即时编译的 " +"，但我们也有一个可即时编译的版本，如 ``c.measure_jit(0, 1)``。" #: ../../source/quickstart.rst:41 msgid "" @@ -171,14 +171,18 @@ msgid "" msgstr "导出到 Qiskit（可能用于进一步的硬件实验、编译和可视化）：``c.to_qiskit()``。" #: ../../source/quickstart.rst:84 -msgid "Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``" -msgstr "从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``" +msgid "" +"Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``. " +"Parameterized Qiskit circuit is supported by passing the parameters to " +"the ``binding_parameters`` argument of the ``from_qiskit`` function, " +"similar to the ``assign_parameters`` function in Qiskit." +msgstr "" -#: ../../source/quickstart.rst:86 +#: ../../source/quickstart.rst:88 msgid "**Circuit Visualization:**" msgstr "**电路可视化**" -#: ../../source/quickstart.rst:88 +#: ../../source/quickstart.rst:90 msgid "" "``c.vis_tex()`` can generate tex code for circuit visualization based on " "LaTeX `quantikz `__ package." @@ -186,14 +190,14 @@ msgstr "" "``c.vis_tex()`` 可以基于 `quantikz `__ " "package 生成用于电路可视化的 tex 代码。" -#: ../../source/quickstart.rst:90 +#: ../../source/quickstart.rst:92 msgid "" "There are also some automatic pipeline helper functions to directly " "generate figures from tex code, but they require extra installations in " "the environment." msgstr "还有一些自动辅助函数可以直接从 tex 代码生成图形，但它们需要在环境中进行额外安装。" -#: ../../source/quickstart.rst:92 +#: ../../source/quickstart.rst:94 msgid "" "``render_pdf(tex)`` function requires full installation of LaTeX locally." " And in the Jupyter environment, we may prefer ``render_pdf(tex, " @@ -205,29 +209,29 @@ msgstr "" "``render_pdf(tex, notebook=True)`` 来返回 jpg 图形，这需要安装 wand magicwand 库，请参阅 " "`这里 `__ 。" -#: ../../source/quickstart.rst:94 +#: ../../source/quickstart.rst:96 msgid "" "Or since we can transform ``tc.Circuit`` into QuantumCircuit easily, we " "have a simple pipeline to first transform ``tc.Circuit`` into Qiskit and " "then call the visualization built in Qiskit. Namely, we have ``c.draw()``" " API." msgstr "" -"从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)`` 或者因为我们可以轻松地将 " -"``tc.Circuit`` 转换为 QuantumCircuit，我们有一个简单的管道来首先转换 ``tc.Circuit`` 为 " -"Qiskit，然后调用 Qiskit 中内置的可视化。 也就是说，我们有 ``c.draw()`` API。" +"从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)`` " +"或者因为我们可以轻松地将 ``tc.Circuit`` 转换为 QuantumCircuit，我们有一个简单的管道来首先转换 " +"``tc.Circuit`` 为 Qiskit，然后调用 Qiskit 中内置的可视化。 也就是说，我们有 ``c.draw()`` API。" -#: ../../source/quickstart.rst:96 +#: ../../source/quickstart.rst:98 msgid "**Circuit Intermediate Representation:**" msgstr "**电路中间表示:**" -#: ../../source/quickstart.rst:98 +#: ../../source/quickstart.rst:100 msgid "" "TensorCircuit provides its own circuit IR as a python list of dicts. This" " IR can be further utilized to run compiling, generate serialization " "qasm, or render circuit figures." msgstr "TensorCircuit 提供自己的中间表示是元素是字典的列表。此中间表示可进一步用于运行编译、生成序列化 qasm 或渲染电路图。" -#: ../../source/quickstart.rst:100 +#: ../../source/quickstart.rst:102 msgid "" "The IR is given as a list, each element is a dict containing information " "on one gate that is applied to the circuit. Note gate attr in the dict is" @@ -236,18 +240,18 @@ msgstr "" "中间表示以列表形式给出，每个元素都是一个字典，其中包含应用于电路的一个量子门的信息。 注意字典中的 gate atrr " "实际上是一个返回此量子门的节点的 python 函数。" -#: ../../source/quickstart.rst:112 +#: ../../source/quickstart.rst:114 msgid "Programming Paradigm" msgstr "编程范式" -#: ../../source/quickstart.rst:114 +#: ../../source/quickstart.rst:116 msgid "" "The most common case and the most typical programming paradigm for " "TensorCircuit are to evaluate the circuit output and the corresponding " "quantum gradients, which is common in variational quantum algorithms." msgstr "TensorCircuit 最常见的情况和最典型的编程范式是评估电路的输出以及相应的量子梯度，这在变分量子算法中很常见。" -#: ../../source/quickstart.rst:141 +#: ../../source/quickstart.rst:143 #, fuzzy msgid "" "Also for a non-quantum example (linear regression) demonstrating the " @@ -264,7 +268,7 @@ msgstr "" "dev/blob/master/examples/universal_lr.py>`_ 。 " "这个例子可能对机器学习的用户更友好，因为它纯粹是经典的，同时也展示了 TensorCircuit 的主要特征和范式。" -#: ../../source/quickstart.rst:144 +#: ../../source/quickstart.rst:146 msgid "" "If the user has no intention to maintain the application code in a " "backend agnostic fashion, the API for ML frameworks can be more handily " @@ -273,11 +277,11 @@ msgstr "" "如果用户无意以与后端无关的方式维护应用程序代码，则可以更方便地使用用于机器学习框架的 API 并将其与 TensorCircuit API " "交替使用。" -#: ../../source/quickstart.rst:179 +#: ../../source/quickstart.rst:181 msgid "Automatic Differentiation, JIT, and Vectorized Parallelism" msgstr "自动微分、即时编译和矢量化并行 " -#: ../../source/quickstart.rst:181 +#: ../../source/quickstart.rst:183 msgid "" "For concepts of AD, JIT and VMAP, please refer to `Jax documentation " "`__ ." @@ -285,7 +289,7 @@ msgstr "" "关于自动微分、即时编译和向量并行化，请参考 `Jax 文档 " "`__ 。" -#: ../../source/quickstart.rst:183 +#: ../../source/quickstart.rst:185 msgid "" "The related API design in TensorCircuit closely follows the functional " "programming design pattern in Jax with some slight differences. So we " @@ -295,21 +299,21 @@ msgstr "" "TensorCircuit 中的相关 API 设计与 Jax 中的函数式编程的设计模式密切相关，但是略有不同。因此，我们强烈建议用户学习一些有关 " "Jax 的基础知识，无论他们打算使用哪种机器学习后端。" -#: ../../source/quickstart.rst:185 +#: ../../source/quickstart.rst:187 msgid "**AD Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:187 +#: ../../source/quickstart.rst:189 msgid "" "Gradients, vjps, jvps, natural gradients, Jacobians, and Hessians. AD is " "the base for all modern machine learning libraries." msgstr "梯度、矢量雅可比乘积、自然梯度、 Jacobian 矩阵和 Hessian 矩阵。自动微分是所有现代机器学习库的基础。" -#: ../../source/quickstart.rst:191 +#: ../../source/quickstart.rst:193 msgid "**JIT Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:193 +#: ../../source/quickstart.rst:195 msgid "" "Parameterized quantum circuits can run in a blink. Always use jit if the " "circuit will get evaluations multiple times, it can greatly boost the " @@ -324,11 +328,11 @@ msgstr "" " 即时编译，否则，即时编译的函数可能会返回意外结果或每次在点击时都重新编译（浪费大量时间）。要了解更多关于即时编译机制的信息，可以参考关于 " "``tf.function`` 或 ``jax.jit`` 的文档或博客，即使这两者仍然存在细微差别。" -#: ../../source/quickstart.rst:197 +#: ../../source/quickstart.rst:199 msgid "**VMAP Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:199 +#: ../../source/quickstart.rst:201 msgid "" "Inputs, parameters, measurements, circuit structures, and Monte Carlo " "noise can all be evaluated in parallel. To learn more about vmap " @@ -338,11 +342,11 @@ msgstr "" "输入、参数、测量、电路结构、蒙特卡洛噪声都可以并行测算。 要了解有关矢量并行化机制的更多信息，可以参考 ``tf.vectorized_map``" " 或 ``jax.vmap`` 上的文档或博客。" -#: ../../source/quickstart.rst:204 +#: ../../source/quickstart.rst:206 msgid "Backend Agnosticism" msgstr "后端无关特性" -#: ../../source/quickstart.rst:206 +#: ../../source/quickstart.rst:208 msgid "" "TensorCircuit supports TensorFlow, Jax, and PyTorch backends. We " "recommend using TensorFlow or Jax backend since PyTorch lacks advanced " @@ -351,16 +355,16 @@ msgstr "" "TensorCircuit 支持 TensorFlow、Jax 和 PyTorch 后端。 我们建议使用 TensorFlow 或 Jax " "后端，因为 PyTorch 缺乏高级 jit 和 vmap 功能。" -#: ../../source/quickstart.rst:208 +#: ../../source/quickstart.rst:210 msgid "" "The backend can be set as ``K=tc.set_backend(\"jax\")`` and ``K`` is the " "backend with a full set of APIs as a conventional ML framework, which can" " also be accessed by ``tc.backend``." msgstr "" -"后端可以设置为 ``K=tc.set_backend(\"jax\")`` ，``K``作为常规机器学习框架的全套API的后端，也可以通过``tc " -".backend`` 被访问。" +"后端可以设置为 ``K=tc.set_backend(\"jax\")`` ，``K``作为常规机器学习框架的全套API的后端，也可以通过``tc" +" .backend`` 被访问。" -#: ../../source/quickstart.rst:231 +#: ../../source/quickstart.rst:233 #, fuzzy msgid "" "The supported APIs in the backend come from two sources, one part is " @@ -375,11 +379,11 @@ msgstr "" " 另一个来自 `TensorCircuit package `__。" -#: ../../source/quickstart.rst:371 +#: ../../source/quickstart.rst:387 msgid "Switch the Dtype" msgstr "转换 dtype" -#: ../../source/quickstart.rst:373 +#: ../../source/quickstart.rst:389 msgid "" "TensorCircuit supports simulation using 32/64 bit precession. The default" " dtype is 32-bit as \"complex64\". Change this by " @@ -389,24 +393,24 @@ msgstr "" "\"complex64\"。可以通过 ``tc.set_dtype(\"complex128\")`` 把 dtype 改为 \"complex" " 128\" 。" -#: ../../source/quickstart.rst:376 +#: ../../source/quickstart.rst:392 msgid "" "``tc.dtypestr`` always returns the current dtype string: either " "\"complex64\" or \"complex128\"." msgstr "``tc.dtypestr`` 总会返回当前的 dtype 字符串: 不是 \"complex64\" 就是 \"complex128\"." -#: ../../source/quickstart.rst:380 +#: ../../source/quickstart.rst:396 msgid "Setup the Contractor" msgstr "设置 contractor" -#: ../../source/quickstart.rst:382 +#: ../../source/quickstart.rst:398 msgid "" "TensorCircuit is a tensornetwork contraction-based quantum circuit " "simulator. A contractor is for searching for the optimal contraction path" " of the circuit tensornetwork." msgstr "TensorCircuit 是一个基于张量网络收缩的量子电路模拟器。 contractor 用于搜索电路张量网络的最佳收缩路径。" -#: ../../source/quickstart.rst:384 +#: ../../source/quickstart.rst:400 msgid "" "There are various advanced contractors provided by third-party packages, " "such as `opt-einsum `__ and " @@ -416,7 +420,7 @@ msgstr "" "`__ 和 `cotengra " "`__ 。" -#: ../../source/quickstart.rst:386 +#: ../../source/quickstart.rst:402 msgid "" "`opt-einsum` is shipped with TensorNetwork package. To use cotengra, one " "needs to pip install it; kahypar is also recommended to install with " @@ -425,11 +429,11 @@ msgstr "" "`opt-einsum` 随 TensorNetwork 软件包一起。如要使用 cotengra，则需要 pip 安装它； 还建议安装 " "cotengra 随 kahypar 一起使用。" -#: ../../source/quickstart.rst:388 +#: ../../source/quickstart.rst:404 msgid "Some setup cases:" msgstr "一些设置案例：" -#: ../../source/quickstart.rst:414 +#: ../../source/quickstart.rst:430 #, fuzzy msgid "" "For advanced configurations on cotengra contractors, please refer to " @@ -444,25 +448,25 @@ msgstr "" "`contractor 教程 `__." -#: ../../source/quickstart.rst:416 +#: ../../source/quickstart.rst:432 msgid "**Setup in Function or Context Level**" msgstr "**函数和上下文级别的设置**" -#: ../../source/quickstart.rst:418 +#: ../../source/quickstart.rst:434 msgid "" "Beside global level setup, we can also setup the backend, the dtype, and " "the contractor at the function level or context manager level:" msgstr "除了全局级别设置，我们还可以在函数级别或上下文管理器级别设置后端、dtype 和contractor：" -#: ../../source/quickstart.rst:436 +#: ../../source/quickstart.rst:452 msgid "Noisy Circuit Simulation" msgstr "噪声电路模拟" -#: ../../source/quickstart.rst:438 +#: ../../source/quickstart.rst:454 msgid "**Monte Carlo State Simulator:**" msgstr "**蒙特卡洛态模拟器**" -#: ../../source/quickstart.rst:440 +#: ../../source/quickstart.rst:456 msgid "" "For the Monte Carlo trajectory noise simulator, the unitary Kraus channel" " can be handled easily. TensorCircuit also supports fully jittable and " @@ -471,22 +475,40 @@ msgstr "" "对于蒙特卡洛轨迹噪声模拟器，可以轻松处理幺正的 Kraus 通道。 不过，TensorCircuit 还支持完全可即时编译和可微分的通用 " "Kraus 通道蒙特卡罗模拟。" -#: ../../source/quickstart.rst:452 +#: ../../source/quickstart.rst:483 msgid "**Density Matrix Simulator:**" msgstr "**密度矩阵模拟器**" -#: ../../source/quickstart.rst:454 +#: ../../source/quickstart.rst:485 msgid "" "Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full " "form, but takes twice qubits to do noiseless simulation. The API is the " "same as ``tc.Circuit``." msgstr "密度矩阵模拟器``tc.DMCircuit`` 以完整形式模拟噪声，但需要两倍的量子比特。API 与 ``tc.Circuit`` 基本相同。" -#: ../../source/quickstart.rst:458 +#: ../../source/quickstart.rst:504 +msgid "**Experiment with quantum errors:**" +msgstr "" + +#: ../../source/quickstart.rst:506 +msgid "Multiple quantum errors can be added on circuit." +msgstr "" + +#: ../../source/quickstart.rst:522 +msgid "**Experiment with readout error:**" +msgstr "" + +#: ../../source/quickstart.rst:524 +msgid "" +"Readout error can be added in experiments for sampling and expectation " +"value calculation." +msgstr "" + +#: ../../source/quickstart.rst:550 msgid "MPS and MPO" msgstr "矩阵乘积状态和矩阵乘积算子" -#: ../../source/quickstart.rst:460 +#: ../../source/quickstart.rst:552 msgid "" "TensorCircuit has its class for MPS and MPO originally defined in " "TensorNetwork as ``tc.QuVector``, ``tc.QuOperator``." @@ -494,7 +516,7 @@ msgstr "" "TensorCircuit 有自己的 MPS 和 MPO 类，起初在 TensorNetwork 中定义为“tc.QuVector” 和 " "“tc.QuOperator”。" -#: ../../source/quickstart.rst:462 +#: ../../source/quickstart.rst:554 msgid "" "``tc.QuVector`` can be extracted from ``tc.Circuit`` as the tensor " "network form for the output state (uncontracted) by ``c.quvector()``." @@ -502,7 +524,7 @@ msgstr "" "作为``c.quvector()`` 的输出状态（未收缩）的张量网络形式，``tc.QuVector`` 可以从``tc.Circuit`` " "中提取。" -#: ../../source/quickstart.rst:464 +#: ../../source/quickstart.rst:556 msgid "" "The QuVector forms a wavefunction w, which can also be fed into Circuit " "as the inputs state as ``c=tc.Circuit(n, mps_inputs=w)``." @@ -510,61 +532,61 @@ msgstr "" "QuVector 形成一个波函数 w，它也可以作为 ``c=tc.Circuit(n, mps_inputs=w)`` 的输入状态输入到 " "Circuit 中。" -#: ../../source/quickstart.rst:466 +#: ../../source/quickstart.rst:558 msgid "MPS as input state for circuit" msgstr "MPS 作为电路的输入状态" -#: ../../source/quickstart.rst:468 +#: ../../source/quickstart.rst:560 msgid "" "The MPS/QuVector representation of the input state has a more efficient " "and compact form." msgstr "输入状态的 MPS/QuVector 表示具有更高效和紧凑的形式。" -#: ../../source/quickstart.rst:480 +#: ../../source/quickstart.rst:572 msgid "MPS as (uncomputed) output state for circuit" msgstr "MPS 作为电路的（未计算的）输出状态" -#: ../../source/quickstart.rst:482 +#: ../../source/quickstart.rst:574 msgid "" "For example, a quick way to calculate the wavefunction overlap without " "explicitly computing the state amplitude is given as below:" msgstr "例如，在不显式计算状态幅度的情况下，计算波函数重叠的快速方法如下：" -#: ../../source/quickstart.rst:499 +#: ../../source/quickstart.rst:591 msgid "MPO as the gate on the circuit" msgstr "MPO 作为电路上的门" -#: ../../source/quickstart.rst:501 +#: ../../source/quickstart.rst:593 msgid "" "Instead of a common quantum gate in matrix/node format, we can directly " "apply a gate in MPO/QuOperator format." msgstr "代替矩阵/节点格式的普通量子门，我们可以直接应用 MPO/QuOperator 格式的门。" -#: ../../source/quickstart.rst:512 +#: ../../source/quickstart.rst:604 msgid "" "The representative gate defined in MPO format is the ``multicontrol`` " "gate." msgstr "以 MPO 格式定义的代表门是 ``multicontrol`` 门。" -#: ../../source/quickstart.rst:514 +#: ../../source/quickstart.rst:606 msgid "MPO as the operator for expectation evaluation on a circuit" msgstr "MPO作为电路期望估测算子" -#: ../../source/quickstart.rst:516 +#: ../../source/quickstart.rst:608 msgid "" "We can also measure operator expectation on the circuit output state " "where the operator is in MPO/QuOperator format." msgstr "我们还可以测量运算符对 MPO/QuOperator 格式的电路输出状态的期望。" -#: ../../source/quickstart.rst:528 +#: ../../source/quickstart.rst:620 msgid "Interfaces" msgstr "接口" -#: ../../source/quickstart.rst:530 +#: ../../source/quickstart.rst:622 msgid "**PyTorch Interface to Hybrid with PyTorch Modules:**" msgstr "**与 PyTorch 模块混合的 PyTorch 接口：**" -#: ../../source/quickstart.rst:532 +#: ../../source/quickstart.rst:624 msgid "" "As we have mentioned in the backend section, the PyTorch backend may lack" " advanced features. This doesn't mean we cannot hybrid the advanced " @@ -575,45 +597,104 @@ msgstr "" "正如我们在后端部分提到的，PyTorch 后端可能缺少高级功能。 这并不意味着我们不能将高级量子电路模块与 PyTorch 神经模块混合。 " "我们可以在 TensorFlow 或 Jax 后端运行量子函数，同时使用 Torch 接口包装它。 " -#: ../../source/quickstart.rst:560 +#: ../../source/quickstart.rst:651 +msgid "" +"For a GPU/CPU, torch/tensorflow, quantum/classical hybrid machine " +"learning pipeline enabled by tensorcircuit, see `example script " +"`__." +msgstr "" + +#: ../../source/quickstart.rst:653 +msgid "" +"We also provider wrapper of quantum function for torch module as " +":py:meth:`tensorcircuit.TorchLayer` alias to " +":py:meth:`tensorcircuit.torchnn.QuantumNet`." +msgstr "" + +#: ../../source/quickstart.rst:655 +msgid "" +"For ``TorchLayer``, ``use_interface=True`` is by default, which natively " +"allow the quantum function defined on other tensorcircuit backends, such " +"as jax or tf for speed consideration." +msgstr "" + +#: ../../source/quickstart.rst:657 +msgid "" +"``TorchLayer`` can process multiple input arguments as multiple function " +"inputs, following torch practice." +msgstr "" + +#: ../../source/quickstart.rst:685 +msgid "**TensorFlow interfaces:**" +msgstr "" + +#: ../../source/quickstart.rst:687 +msgid "" +"Similar rules apply similar as torch interface. The interface can even be" +" used within jit environment outside. See " +":py:meth:`tensorcircuit.interfaces.tensorflow.tensorflow_interface`." +msgstr "" + +#: ../../source/quickstart.rst:690 +msgid "" +"We also provider ``enable_dlpack=True`` option in torch and tf " +"interfaces, which allow the tensor transformation happen without memory " +"transfer via dlpack, higher version of tf or torch package required." +msgstr "" + +#: ../../source/quickstart.rst:693 +msgid "" +"We also provider wrapper of quantum function for keras layer as " +":py:meth:`tensorcircuit.KerasLayer` alias to " +":py:meth:`tensorcircuit.keras.KerasLayer`." +msgstr "" + +#: ../../source/quickstart.rst:695 +msgid "" +"``KerasLayer`` can process multiple input arguments with the input as a " +"dict, following the common keras practice, see example below." +msgstr "" + +#: ../../source/quickstart.rst:717 msgid "**Scipy Interface to Utilize Scipy Optimizers:**" msgstr "**使用 scipy接口使用scipy优化器：**" -#: ../../source/quickstart.rst:562 +#: ../../source/quickstart.rst:719 msgid "" "Automatically transform quantum functions as scipy-compatible values and " "grad functions as provided for scipy interface with ``jac=True``." msgstr "为带有 jac=True 的 scipy 接口自动将量子函数转换为与 scipy 兼容的 value 和 grad 函数。" -#: ../../source/quickstart.rst:588 +#: ../../source/quickstart.rst:745 msgid "Templates as Shortcuts" msgstr "捷径模板" -#: ../../source/quickstart.rst:590 +#: ../../source/quickstart.rst:747 msgid "**Measurements:**" msgstr "**测量**" -#: ../../source/quickstart.rst:592 +#: ../../source/quickstart.rst:749 msgid "Ising type Hamiltonian defined on a general graph" msgstr "在一般图上定义的伊辛型哈密顿量" -#: ../../source/quickstart.rst:594 +#: ../../source/quickstart.rst:751 msgid "" "See " ":py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" msgstr "参考 :py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" -#: ../../source/quickstart.rst:596 +#: ../../source/quickstart.rst:753 msgid "Heisenberg Hamiltonian on a general graph with possible external fields" msgstr "具有可能存在的外场的一般图上的海森堡哈密顿量" -#: ../../source/quickstart.rst:598 +#: ../../source/quickstart.rst:755 msgid "" "See " ":py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" msgstr "参考 :py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" -#: ../../source/quickstart.rst:600 +#: ../../source/quickstart.rst:757 msgid "**Circuit Blocks:**" msgstr "**电路块**" @@ -682,3 +763,6 @@ msgstr "**电路块**" #~ "`wand `__ " #~ "及其二进制绑定以及 LaTeX 的安装。" +#~ msgid "Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``" +#~ msgstr "从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``" + diff --git a/docs/source/modules.rst b/docs/source/modules.rst index 33ae1cb2..c6478c09 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -7,6 +7,7 @@ tensorcircuit ./api/basecircuit.rst ./api/channels.rst ./api/circuit.rst + ./api/cloud.rst ./api/cons.rst ./api/densitymatrix.rst ./api/experimental.rst @@ -15,7 +16,9 @@ tensorcircuit ./api/keras.rst ./api/mps_base.rst ./api/mpscircuit.rst + ./api/noisemodel.rst ./api/quantum.rst + ./api/results.rst ./api/simplify.rst ./api/templates.rst ./api/torchnn.rst From 8c04a3452108cd46867923a60bd3bfa06e3fe07e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 13 Jan 2023 14:52:11 +0800 Subject: [PATCH 178/725] add circuit_constructor option in qiskit translation --- CHANGELOG.md | 2 ++ tensorcircuit/abstractcircuit.py | 3 +-- tensorcircuit/gates.py | 7 ++++++- tensorcircuit/translation.py | 7 ++++++- 4 files changed, 15 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 275ca2bc..4fb69947 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -41,6 +41,8 @@ - Add Chinese translation for doc Sharpbit +- Add `circuit_constructor` argument for `qiskit2tc` method, so that we can support more circuit class than circuit and dmcircuit + ### Fixed - Fix adjoint possible bug with agnostic backend diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 578de7d7..51889e83 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -71,7 +71,6 @@ class AbstractCircuit: inputs: Tensor circuit_param: Dict[str, Any] is_mps: bool - is_dm: bool sgates = sgates vgates = vgates @@ -753,7 +752,7 @@ def from_qiskit( qc.data, n, inputs, - is_dm=cls.is_dm, + circuit_constructor=cls, circuit_params=circuit_params, binding_params=binding_params, ) diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index 5c0fae4b..60d8e1b7 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -7,6 +7,7 @@ from functools import reduce, partial from typing import Any, Callable, Optional, Sequence, List, Union, Tuple from operator import mul +import warnings import numpy as np import tensornetwork as tn @@ -893,7 +894,11 @@ def multicontrol_gate(unitary: Tensor, ctrl: Union[int, Sequence[int]] = 1) -> O eps = 1e-5 if isinstance(ctrl, int): ctrl = [ctrl] - if int(ctrl[0] + eps) == 1: + with warnings.catch_warnings(): + warnings.simplefilter("ignore", np.ComplexWarning) + print(ctrl) + ctrl0_int = int(ctrl[0] + eps) + if ctrl0_int == 1: leftend = np.zeros([2, 2, 2]) leftend[1, 1, 0] = 1 leftend[0, 0, 1] = 1 diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index f3db6c0c..ed128132 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -273,6 +273,7 @@ def qiskit2tc( n: int, inputs: Optional[List[float]] = None, is_dm: bool = False, + circuit_constructor: Any = None, circuit_params: Optional[Dict[str, Any]] = None, binding_params: Optional[Union[Sequence[float], Dict[Any, float]]] = None, ) -> Any: @@ -294,6 +295,8 @@ def qiskit2tc( :type n: int :param inputs: Input state of the circuit. Default is None. :type inputs: Optional[List[float]] + :param circuit_constructor: ``Circuit``, ``DMCircuit`` or ``MPSCircuit`` + :type circuit_contructor: Any :param circuit_params: kwargs given in Circuit.__init__ construction function, default to None. :type circuit_params: Optional[Dict[str, Any]] :param binding_params: (variational) parameters for the circuit. @@ -303,7 +306,9 @@ def qiskit2tc( :return: A quantum circuit in tensorcircuit :rtype: Any """ - if is_dm: + if circuit_constructor is not None: + Circ = circuit_constructor + elif is_dm: Circ = DMCircuit2 else: Circ = Circuit # type: ignore From 86246762ae246c69feeb15fbc8f47a4239e669ac Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 13 Jan 2023 22:03:55 +0800 Subject: [PATCH 179/725] update device property related api --- tensorcircuit/cloud/abstraction.py | 70 +++++++++++++++++++++++++++++- tensorcircuit/cloud/tencent.py | 32 +++++++++++++- tensorcircuit/cloud/utils.py | 1 + 3 files changed, 101 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 73eebfd4..24a5e465 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -2,10 +2,12 @@ Abstraction for Provider, Device and Task """ -from typing import Any, Dict, List, Optional, Union +from typing import Any, Dict, List, Optional, Union, Tuple from functools import partial import time +import networkx as nx + from ..results import readout_mitigation as rem from ..results import counts from ..utils import arg_alias @@ -174,10 +176,76 @@ def get_token(self) -> Optional[str]: return get_token(provider=self.provider) def list_properties(self) -> Dict[str, Any]: + """ + List all device properties in as dict + + :return: [description] + :rtype: Dict[str, Any] + """ from .apis import list_properties return list_properties(self.provider, self) + def topology(self) -> List[Tuple[int, int]]: + """ + Get the bidirectional topology link list of the device + + :return: [description] + :rtype: List[Tuple[int, int]] + """ + properties = self.list_properties() + if "links" not in properties: + return # type: ignore + links = [] + for link in properties["links"]: + links.append((link[0], link[1])) + links.append((link[1], link[0])) + links = list(set(links)) + return links + + def topology_graph(self, visualize: bool = False) -> nx.Graph: + """ + Get the qubit topology in ``nx.Graph`` or directly visualize it + + :param visualize: [description], defaults to False + :type visualize: bool, optional + :return: [description] + :rtype: nx.Graph + """ + pro = self.list_properties() + if not ("links" in pro and "bits" in pro): + return # type: ignore + g = nx.Graph() + node_color = [] + edge_color = [] + for i in pro["bits"]: + g.add_node(i) + node_color.append(pro["bits"][i]["T1"]) + for e1, e2 in pro["links"]: + g.add_edge(e1, e2) + edge_color.append(pro["links"][(e1, e2)]["CZErrRate"]) + if visualize is False: + return g + from matplotlib import colormaps + + # pos1 = nx.planar_layout(g) + # pos2 = nx.spring_layout(g, pos=pos1, k=2) + pos = nx.kamada_kawai_layout(g) + return nx.draw( + g, + pos=pos, + with_labels=True, + node_size=600, + node_color=node_color, + cmap=colormaps["Wistia"], + vmin=max(min(node_color) - 5, 0), + width=2.5, + edge_color=edge_color, + edge_cmap=colormaps["gray"], + edge_vmin=0, + edge_vmax=max(edge_color) * 1.2, + ) + def get_task(self, taskid: str) -> "Task": from .apis import get_task diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 82716c75..6a72503e 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -55,10 +55,40 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An ) r = error_handling(r) if "device" in r: - return r["device"] # type: ignore + r = r["device"] + if "links" in r: + links_dict = {} + for link in r["links"]: + links_dict[(link["A"], link["B"])] = link + r["links"] = links_dict + if "bits" in r: + bits_dict = {} + for bit in r["bits"]: + bits_dict[bit["Qubit"]] = bit + r["bits"] = bits_dict + return r # type: ignore else: raise ValueError("No device with the name: %s" % device) + # list properties should at least contain the following items + """ + {'id': '20xmon', + 'type': 'CHIP', + 'state': 'on', + 'links': {(0, 1): { 'CZErrRate': 0.03, 'at': 1673605888}, + ...}, + 'bits': {0: { 'At': 1673605888, + 'Freqency': 4420, + 'ReadoutF0Err': 0.0415, + 'ReadoutF1Err': 0.1006, + 'SingleQubitErrRate': 0.00095, + 'SingleQubitGateLenInNs': 30, + 'T1': 35.5, + 'T2': 5.4}, + ...,}, + 'langs': ['tQASM', 'eQASM']} + """ + def _free_pi(s: str) -> str: # dirty trick to get rid of pi in openqasm from qiskit diff --git a/tensorcircuit/cloud/utils.py b/tensorcircuit/cloud/utils.py index 1b88e5fa..296e66df 100644 --- a/tensorcircuit/cloud/utils.py +++ b/tensorcircuit/cloud/utils.py @@ -32,6 +32,7 @@ class HttpStatusError(Exception): requests.exceptions.RequestException, requests.exceptions.ConnectionError, requests.exceptions.SSLError, + ValueError, # JSONDecodeError, ) From 2ca6335764dfe67eb986456d49f28ebb07dbcf6c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 15 Jan 2023 10:11:54 +0800 Subject: [PATCH 180/725] add cal_from_api method for mit --- CHANGELOG.md | 2 + tensorcircuit/quantum.py | 8 +++- tensorcircuit/results/readout_mitigation.py | 47 +++++++++++++++++++-- 3 files changed, 52 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4fb69947..facf037a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,8 @@ - Add an example script demonstrating how tc can use external contraction path finder wirtten in Julia +- Add `cals_from_api` method for `ReadoutMit` class which can acquire the readout error information from the api + ### Fixed - Circuit nosify in noise model now support all circuit attributs apart from qubit number diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index d8ba38f9..a1d8ea32 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1127,6 +1127,7 @@ def heisenberg_hamiltonian( ) -> Tensor: """ Generate Heisenberg Hamiltonian with possible external fields. + Currently requires tensorflow installed :Example: @@ -1214,7 +1215,9 @@ def PauliStringSum2Dense( numpy: bool = False, ) -> Tensor: """ - Generate dense matrix from Pauli string sum + Generate dense matrix from Pauli string sum. + Currently requires tensorflow installed. + :param ls: 2D Tensor, each row is for a Pauli string, e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` @@ -1257,7 +1260,8 @@ def PauliStringSum2COO( numpy: bool = False, ) -> Tensor: """ - Generate sparse tensor from Pauli string sum + Generate sparse tensor from Pauli string sum. + Currently requires tensorflow installed :param ls: 2D Tensor, each row is for a Pauli string, e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 4f458a6b..9551810a 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -57,9 +57,11 @@ def __init__(self, execute: Callable[..., List[ct]], iter_threshold: int = 4096) # execute is a device name str from ..cloud.wrapper import batch_submit_template + self.devstr: Optional[str] = execute self.execute_fun: Callable[..., List[ct]] = batch_submit_template(execute) else: self.execute_fun = execute + self.devstr = None def ubs(self, i: int, qubits: Optional[Sequence[Any]]) -> int: """ @@ -206,17 +208,56 @@ def global_miti_readout_circ(self) -> List[Circuit]: miticirc.append(c) return miticirc - def cals_from_system( # type: ignore + def cals_from_api( + self, qubits: Union[int, List[int]], device: Optional[str] = None + ) -> None: + """ + Get local calibriation matrix from cloud API from tc supported providers + + :param qubits: list of physical qubits to be calibriated + :type qubits: Union[int, List[int]] + :param device: the device str to qurey for the info, defaults to None + :type device: Optional[str], optional + """ + if device is None and self.devstr is None: + raise ValueError("device argument cannot be None") + if device is None: + device = self.devstr.split("?")[0] # type: ignore + + if isinstance(qubits, int): + qubits = list(range(qubits)) + + self.cal_qubits = qubits # type: ignore + self.local = True # type: ignore + self.single_qubit_cals = [None] * (max(self.cal_qubits) + 1) # type: ignore + + from ..cloud.apis import list_properties + + pro = list_properties(device) + + for q in qubits: + error01 = pro["bits"][q]["ReadoutF0Err"] + error10 = pro["bits"][q]["ReadoutF1Err"] + readout_single = np.array( + [ + [1 - error01, error10], + [error01, 1 - error10], + ] + ) + self.single_qubit_cals[q] = readout_single # type: ignore + # only works in zero based qubit information + + def cals_from_system( self, qubits: Union[int, List[int]], shots: int = 8192, method: str = "local", masks: Optional[List[str]] = None, - ): + ) -> None: """ Get calibrattion information from system. - :param qubits: calibration qubit list + :param qubits: calibration qubit list (physical qubits on device) :type qubits: Sequence[Any] :param shots: shots used for runing the circuit, defaults to 8192 :type shots: int, optional From 5b1f41aa692b9fd93f4411060fbcbff86e482f2c Mon Sep 17 00:00:00 2001 From: xptree Date: Sun, 15 Jan 2023 22:49:12 +0800 Subject: [PATCH 181/725] add subprocess for omeinsum, put it to a new subdir --- .../circuit_n12_m14_s0_e0_pEFGH.qsim | 0 examples/omeinsum_julia/omeinsum.jl | 76 ++++++++++ .../omeinsum_contractor_juliacall.py} | 40 ++---- .../omeinsum_contractor_subprocess.py | 135 ++++++++++++++++++ .../omeinsum_treesa_optimizer.py | 50 +++++++ 5 files changed, 271 insertions(+), 30 deletions(-) rename examples/{ => omeinsum_julia}/circuit_n12_m14_s0_e0_pEFGH.qsim (100%) create mode 100644 examples/omeinsum_julia/omeinsum.jl rename examples/{omeinsum_contractor.py => omeinsum_julia/omeinsum_contractor_juliacall.py} (79%) create mode 100644 examples/omeinsum_julia/omeinsum_contractor_subprocess.py create mode 100644 examples/omeinsum_julia/omeinsum_treesa_optimizer.py diff --git a/examples/circuit_n12_m14_s0_e0_pEFGH.qsim b/examples/omeinsum_julia/circuit_n12_m14_s0_e0_pEFGH.qsim similarity index 100% rename from examples/circuit_n12_m14_s0_e0_pEFGH.qsim rename to examples/omeinsum_julia/circuit_n12_m14_s0_e0_pEFGH.qsim diff --git a/examples/omeinsum_julia/omeinsum.jl b/examples/omeinsum_julia/omeinsum.jl new file mode 100644 index 00000000..991f4f6f --- /dev/null +++ b/examples/omeinsum_julia/omeinsum.jl @@ -0,0 +1,76 @@ +import OMEinsum +import ArgParse +import JSON + +function parse_commandline() + s = ArgParse.ArgParseSettings() + + @ArgParse.add_arg_table s begin + "--einsum_json" + arg_type = String + default = "einsum.json" + "--result_json" + arg_type = String + default = "opteinsum.json" + "--sc_target" + arg_type = Float64 + default = 20.0 + "--beta_start" + arg_type = Float64 + default = 0.01 + "--beta_step" + arg_type = Float64 + default = 0.01 + "--beta_stop" + arg_type = Float64 + default = 15.0 + "--ntrials" + arg_type = Int + default = 10 + "--niters" + arg_type = Int + default = 50 + "--sc_weight" + arg_type = Float64 + default = 1.0 + "--rw_weight" + arg_type = Float64 + default = 0.2 + end + + return ArgParse.parse_args(s) +end + +function main() + parsed_args = parse_commandline() + # println("Parsed args:") + # for (arg,val) in parsed_args + # println(" $arg => $val") + # end + # println(Threads.nthreads()) + contraction_args = JSON.parsefile(parsed_args["einsum_json"]) + + inputs = map(Tuple, contraction_args["inputs"]) + output = contraction_args["output"] + + eincode = OMEinsum.EinCode(Tuple(inputs), Tuple(output)) + + size_dict = OMEinsum.uniformsize(eincode, 2) + for (k, v) in contraction_args["size"] + size_dict[k] = v + end + algorithm = OMEinsum.TreeSA( + sc_target=parsed_args["sc_target"], + βs=parsed_args["beta_start"]:parsed_args["beta_step"]:parsed_args["beta_stop"], + ntrials=parsed_args["ntrials"], + niters=parsed_args["niters"], + sc_weight=parsed_args["sc_weight"], + rw_weight=parsed_args["rw_weight"] + ) + # println(parsed_args["beta_start"]:parsed_args["beta_step"]:parsed_args["beta_stop"]) + # println(algorithm) + optcode = OMEinsum.optimize_code(eincode, size_dict, algorithm) + OMEinsum.writejson(parsed_args["result_json"], optcode) +end + +main() diff --git a/examples/omeinsum_contractor.py b/examples/omeinsum_julia/omeinsum_contractor_juliacall.py similarity index 79% rename from examples/omeinsum_contractor.py rename to examples/omeinsum_julia/omeinsum_contractor_juliacall.py index 60043025..e2701016 100644 --- a/examples/omeinsum_contractor.py +++ b/examples/omeinsum_julia/omeinsum_contractor_juliacall.py @@ -1,5 +1,6 @@ import os import json +import time from typing import List, Set, Dict, Tuple import tempfile import warnings @@ -21,12 +22,13 @@ jl.seval("using OMEinsum") +from omeinsum_treesa_optimizer import OMEinsumTreeSAOptimizer import tensorcircuit as tc tc.set_backend("tensorflow") -class OMEinsumTreeSAOptimizer(object): +class OMEinsumTreeSAOptimizerJuliaCall(OMEinsumTreeSAOptimizer): def __init__( self, sc_target: float = 20, @@ -36,34 +38,7 @@ def __init__( sc_weight: float = 1.0, rw_weight: float = 0.2, ): - self.sc_target = sc_target - self.betas = betas - self.ntrials = ntrials - self.niters = niters - self.sc_weight = sc_weight - self.rw_weight = rw_weight - - def _contraction_tree_to_contraction_path(self, ei, queue, path, idx): - if ei["isleaf"]: - # OMEinsum provide 1-based index - # but in contraction path we want 0-based index - ei["tensorindex"] -= 1 - return idx - assert len(ei["args"]) == 2, "must be a binary tree" - for child in ei["args"]: - idx = self._contraction_tree_to_contraction_path(child, queue, path, idx) - assert "tensorindex" in child - - lhs_args = sorted( - [queue.index(child["tensorindex"]) for child in ei["args"]], reverse=True - ) - for arg in lhs_args: - queue.pop(arg) - - ei["tensorindex"] = idx - path.append(lhs_args) - queue.append(idx) - return idx + 1 + super().__init__(sc_target, betas, ntrials, niters, sc_weight, rw_weight) def __call__( self, @@ -101,7 +76,10 @@ def __call__( "for more details.".format(nthreads) ) jl.GC.enable(False) + t0 = time.time() optcode = jl.OMEinsum.optimize_code(eincode, size_dict, algorithm) + running_time = time.time() - t0 + print(f"running_time: {running_time}") if nthreads > 1: jl.GC.enable(True) # jl.println("time and space complexity computed by OMEinsum: ", @@ -144,7 +122,9 @@ def __call__( c.expectation_ps(z=[0], reuse=False) print("OMEinsum contractor") -opt_treesa = OMEinsumTreeSAOptimizer(sc_target=30, sc_weight=0.0, rw_weight=0.0) +opt_treesa = OMEinsumTreeSAOptimizerJuliaCall( + sc_target=30, sc_weight=0.0, rw_weight=0.0 +) tc.set_contractor( "custom", optimizer=opt_treesa, diff --git a/examples/omeinsum_julia/omeinsum_contractor_subprocess.py b/examples/omeinsum_julia/omeinsum_contractor_subprocess.py new file mode 100644 index 00000000..470a616b --- /dev/null +++ b/examples/omeinsum_julia/omeinsum_contractor_subprocess.py @@ -0,0 +1,135 @@ +# Prerequisites for running this example: +# Step 1: install julia, see https://julialang.org/download/, +# Please install julia >= 1.8.5, the 1.6.7 LTS version raises: +# `Error in python: free(): invalid pointer` +# Step 2: add julia path to the PATH env variable so that we can find it +# Step 4: install julia package `OMEinsum`, `ArgParse` and `JSON`, this example was tested with OMEinsum v0.7.2, +# see https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager + +import os +import json +import time +from typing import List, Set, Dict, Tuple +import tempfile +import subprocess +import cotengra as ctg +from omeinsum_treesa_optimizer import OMEinsumTreeSAOptimizer +import tensorcircuit as tc + +tc.set_backend("tensorflow") + + +class OMEinsumTreeSAOptimizerSubprocess(OMEinsumTreeSAOptimizer): + def __init__( + self, + sc_target: float = 20, + betas: Tuple[float, float, float] = (0.01, 0.01, 15), + ntrials: int = 10, + niters: int = 50, + sc_weight: float = 1.0, + rw_weight: float = 0.2, + ): + super().__init__(sc_target, betas, ntrials, niters, sc_weight, rw_weight) + + def __call__( + self, + inputs: List[Set[str]], + output: Set[str], + size: Dict[str, int], + memory_limit=None, + ) -> List[Tuple[int, int]]: + inputs_omeinsum = list(map(list, inputs)) + output_omeinsum = list(output) + + fin = tempfile.NamedTemporaryFile(suffix=".json", delete=False) + fout = tempfile.NamedTemporaryFile(suffix=".json", delete=False) + fin.close() + fout.close() + einsum_json = { + "inputs": inputs_omeinsum, + "output": output_omeinsum, + "size": list(size.items()), + } + with open(fin.name, "w") as fp: + json.dump(einsum_json, fp) + + cmd = ( + "julia omeinsum.jl --einsum_json {0} " + "--result_json {1} --sc_target {2} " + "--beta_start {3} --beta_step {4} " + "--beta_stop {5} --ntrials {6} " + "--niters {7} --sc_weight {8} " + "--rw_weight {9}".format( + fin.name, + fout.name, + self.sc_target, + self.betas[0], + self.betas[1], + self.betas[2], + self.ntrials, + self.niters, + self.sc_weight, + self.rw_weight, + ) + ) + + print(cmd) + p = subprocess.Popen( + cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE + ) + t0 = time.time() + _, stderr = p.communicate() + running_time = time.time() - t0 + print(f"running_time: {running_time}") + retcode = p.wait() + if retcode: + os.unlink(fin.name) + os.unlink(fout.name) + raise Exception("julia failed\nstderr:\n%s\n" % stderr.decode("utf-8")) + + with open(fout.name, "r") as f: + contraction_tree = json.load(f) + os.unlink(fin.name) + os.unlink(fout.name) + + num_tensors = len(contraction_tree["inputs"]) + assert num_tensors == len( + inputs + ), "should have the same number of input tensors" + queue = list(range(num_tensors)) + path = [] + self._contraction_tree_to_contraction_path( + contraction_tree["tree"], queue, path, num_tensors + ) + return path + + +# For more random circuits, please refer to +# https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8 +c = tc.Circuit.from_qsim_file("circuit_n12_m14_s0_e0_pEFGH.qsim") + +opt = ctg.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel=True, + minimize="flops", + max_repeats=1024, + progbar=False, +) +print("cotengra contractor") +tc.set_contractor( + "custom", optimizer=opt, preprocessing=True, contraction_info=True, debug_level=2 +) +c.expectation_ps(z=[0], reuse=False) + +print("OMEinsum contractor") +opt_treesa = OMEinsumTreeSAOptimizerSubprocess( + sc_target=30, sc_weight=0.0, rw_weight=0.0 +) +tc.set_contractor( + "custom", + optimizer=opt_treesa, + preprocessing=True, + contraction_info=True, + debug_level=2, +) +c.expectation_ps(z=[0], reuse=False) diff --git a/examples/omeinsum_julia/omeinsum_treesa_optimizer.py b/examples/omeinsum_julia/omeinsum_treesa_optimizer.py new file mode 100644 index 00000000..c43dc439 --- /dev/null +++ b/examples/omeinsum_julia/omeinsum_treesa_optimizer.py @@ -0,0 +1,50 @@ +from typing import List, Set, Dict, Tuple + + +class OMEinsumTreeSAOptimizer(object): + def __init__( + self, + sc_target: float = 20, + betas: Tuple[float, float, float] = (0.01, 0.01, 15), + ntrials: int = 10, + niters: int = 50, + sc_weight: float = 1.0, + rw_weight: float = 0.2, + ): + self.sc_target = sc_target + self.betas = betas + self.ntrials = ntrials + self.niters = niters + self.sc_weight = sc_weight + self.rw_weight = rw_weight + + def _contraction_tree_to_contraction_path(self, ei, queue, path, idx): + if ei["isleaf"]: + # OMEinsum provide 1-based index + # but in contraction path we want 0-based index + ei["tensorindex"] -= 1 + return idx + assert len(ei["args"]) == 2, "must be a binary tree" + for child in ei["args"]: + idx = self._contraction_tree_to_contraction_path(child, queue, path, idx) + assert "tensorindex" in child + + lhs_args = sorted( + [queue.index(child["tensorindex"]) for child in ei["args"]], reverse=True + ) + for arg in lhs_args: + queue.pop(arg) + + ei["tensorindex"] = idx + path.append(lhs_args) + queue.append(idx) + return idx + 1 + + def __call__( + self, + inputs: List[Set[str]], + output: Set[str], + size: Dict[str, int], + memory_limit=None, + ) -> List[Tuple[int, int]]: + raise NotImplementedError From 5194a4d5fdb379cf5de116e9045fbb163e44c7b4 Mon Sep 17 00:00:00 2001 From: xptree Date: Sun, 15 Jan 2023 23:13:06 +0800 Subject: [PATCH 182/725] add README, fix typo --- examples/omeinsum_julia/README.md | 45 +++++++++++++++++++ .../omeinsum_contractor_juliacall.py | 4 +- .../omeinsum_contractor_subprocess.py | 4 +- 3 files changed, 49 insertions(+), 4 deletions(-) create mode 100644 examples/omeinsum_julia/README.md diff --git a/examples/omeinsum_julia/README.md b/examples/omeinsum_julia/README.md new file mode 100644 index 00000000..7768953c --- /dev/null +++ b/examples/omeinsum_julia/README.md @@ -0,0 +1,45 @@ +# Use OMEinsum in TensorCircuit + +This example introduces how to use OMEinsum, a julia-based einsum package, to contract a circuit in TensorCircuit. + +We provide two solutions + +* use subprocess to call a stand-alone julia script (recommended) +* use juliacall to integrate julia script into python (seems to be more elegant, but not recommended) + +## Subprocess solution (Recommended) + +This solution calls a stand-alone julia script `omeinsum.jl` for tensor network contraction. + +### Setup + +* Step 1: install julia, see https://julialang.org/download/. Please install julia >= 1.8.5, the 1.6.7 LTS version raises: `Error in python: free(): invalid pointer` +* Step 2: add julia path to the PATH env variable so that we can find it +* Step 3: install julia package `OMEinsum`, `ArgParse` and `JSON`, this example was tested with OMEinsum v0.7.2, ArgParse v1.1.4 and JSON v0.21.3. See https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager + +### How to run + +Run +`JULIA_NUM_THREADS=N python omeinsum_contractor_subprocess.py`. The env variable `JULIA_NUM_THREADS=N` will be passed to the julia script, so that you can enjoy the accelaration brought by julia multi-threading. + + +## JuliaCall solution (Not Recommended) + +JuliaCall seems to be a more elegant solution because all related code are integrated into a single python script. +However, in order to use julia multi-threading in juliacall, we have to turn off julia GC at the risk of OOM. See see https://github.com/cjdoris/PythonCall.jl/issues/219 for more details. + + +### Setup + +* Step 1: install julia, see https://julialang.org/download/. Please install julia >= 1.8.5, the 1.6.7 LTS version raises: `Error in python: free(): invalid pointer` +* Step 2: add julia path to the PATH env variable so that juliacall can find it +* Step 3: install juliacall via `pip install juliacall`, this example was tested with juliacall 0.9.9 +* Step 4: install julia package `OMEinsum`, this example was tested with OMEinsum v0.7.2, see https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager +* Step 5: for julia multi-threading, set env variable `PYTHON_JULIACALL_THREADS=`. + +### How to run + +Run +`PYTHON_JULIACALL_THREADS= python omeinsum_contractor_juliacall.py`. + + diff --git a/examples/omeinsum_julia/omeinsum_contractor_juliacall.py b/examples/omeinsum_julia/omeinsum_contractor_juliacall.py index e2701016..958f3477 100644 --- a/examples/omeinsum_julia/omeinsum_contractor_juliacall.py +++ b/examples/omeinsum_julia/omeinsum_contractor_juliacall.py @@ -7,14 +7,14 @@ import cotengra as ctg # Prerequisites for running this example: -# Step 1: install julia, see https://julialang.org/download/, +# Step 1: install julia, see https://julialang.org/download/. # Please install julia >= 1.8.5, the 1.6.7 LTS version raises: # `Error in python: free(): invalid pointer` # Step 2: add julia path to the PATH env variable so that juliacall can find it # Step 3: install juliacall via `pip install juliacall`, this example was tested with juliacall 0.9.9 # Step 4: install julia package `OMEinsum`, this example was tested with OMEinsum v0.7.2, # see https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager -# Step 5: for julia multi-threading, set env variable PYTHON_JULIACALL_THREADS=. +# Step 5: for julia multi-threading, set env variable `PYTHON_JULIACALL_THREADS=`. # However, in order to use julia multi-threading in juliacall, # we have to turn off julia GC at the risk of OOM. # See see https://github.com/cjdoris/PythonCall.jl/issues/219 for more details. diff --git a/examples/omeinsum_julia/omeinsum_contractor_subprocess.py b/examples/omeinsum_julia/omeinsum_contractor_subprocess.py index 470a616b..e115de4b 100644 --- a/examples/omeinsum_julia/omeinsum_contractor_subprocess.py +++ b/examples/omeinsum_julia/omeinsum_contractor_subprocess.py @@ -1,9 +1,9 @@ # Prerequisites for running this example: -# Step 1: install julia, see https://julialang.org/download/, +# Step 1: install julia, see https://julialang.org/download/. # Please install julia >= 1.8.5, the 1.6.7 LTS version raises: # `Error in python: free(): invalid pointer` # Step 2: add julia path to the PATH env variable so that we can find it -# Step 4: install julia package `OMEinsum`, `ArgParse` and `JSON`, this example was tested with OMEinsum v0.7.2, +# Step 3: install julia package `OMEinsum`, `ArgParse` and `JSON`, this example was tested with OMEinsum v0.7.2, # see https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager import os From 451f2cddac004664f241240672cc29297e7321c0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 16 Jan 2023 11:29:34 +0800 Subject: [PATCH 183/725] update sdk doc --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 185 +++++++++++++++++++--- 1 file changed, 165 insertions(+), 20 deletions(-) diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb index 444b6028..2680dac9 100644 --- a/docs/source/tutorials/tc_qcloud_sdk.ipynb +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -5,7 +5,7 @@ "id": "38c73e8c", "metadata": {}, "source": [ - "# tensorcircuit SDK for QCloud（230109 ver）" + "# tensorcircuit SDK for QCloud（230116 ver）" ] }, { @@ -83,7 +83,9 @@ "cell_type": "code", "execution_count": null, "id": "e2ab9a2c", - "metadata": {}, + "metadata": { + "scrolled": false + }, "outputs": [], "source": [ "apis.list_properties(device=\"9gmon\")" @@ -96,7 +98,37 @@ "metadata": {}, "outputs": [], "source": [ - "apis.list_properties(device=\"simulator:tcn1\")" + "d = apis.get_device(\"9gmon\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f57b5239", + "metadata": {}, + "outputs": [], + "source": [ + "d.list_properties()[\"usage\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6470346", + "metadata": {}, + "outputs": [], + "source": [ + "d.topology()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e407e5c7", + "metadata": {}, + "outputs": [], + "source": [ + "d.topology_graph(visualize=True)" ] }, { @@ -157,7 +189,7 @@ "metadata": {}, "outputs": [], "source": [ - "# resubmit a job\n", + "# resubmit a job with the same source and command\n", "t1 = t.resubmit()\n", "t1.details(blocked=True, prettify=True)" ] @@ -314,7 +346,7 @@ "ReadoutMit = tc.results.readout_mitigation.ReadoutMit\n", "mit = ReadoutMit(\"9gmon?o=0\")\n", "mit.cals_from_system(nqubit, shots, method=\"local\")\n", - "miti_count = mit.apply_correction(raw_count, nqubit, \"square\")" + "miti_count = mit.apply_correction(raw_count, nqubit, method=\"square\")" ] }, { @@ -380,6 +412,129 @@ " print(m)" ] }, + { + "cell_type": "markdown", + "id": "422d0a1b", + "metadata": {}, + "source": [ + "## Abstraction of three layers of qubits and the mappings\n", + "\n", + "New abstraction on qubits: positional qubits, logical qubits, physical qubits, we need two more mappings: ``positional_logical_mapping`` and ``logical_physical_mapping``.\n", + "\n", + "The separation between positional and logical qubits is due to partial measurement, while the seperation between logical and physical qubits are from circuit compiling onto hardware, including swap inserting (where the last swap is omitted, current qos behavior), qubit routing (i.e. initial mapping).\n", + "\n", + "Now we do the GHZ preparation on another chip, but use mapping and partial measurement abstraction" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a12dd32", + "metadata": {}, + "outputs": [], + "source": [ + "c = tc.Circuit(5)\n", + "c.h(0)\n", + "for i in range(4):\n", + " c.cx(i, i + 1)\n", + "for i in range(5):\n", + " c.measure_instruction(i)\n", + "\n", + "# We map the circuit on the physical qubits\n", + "\n", + "c1 = c.initial_mapping({i: 12 + i for i in range(5)}, n=20)\n", + "positional_logical_mapping = c1.get_positional_logical_mapping()\n", + "positional_logical_mapping" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39d0c16c", + "metadata": {}, + "outputs": [], + "source": [ + "t = apis.submit_task(\n", + " circuit=c1, shots=shots, device=\"20xmon\", enable_qos_qubit_mapping=False\n", + ")\n", + "raw_count = t.results(blocked=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2bbecbd", + "metadata": {}, + "outputs": [], + "source": [ + "logical_physical_mapping = t.details()[\"optimization\"][\"pairs\"]\n", + "logical_physical_mapping = {int(k): int(v) for k, v in logical_physical_mapping.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d59fa9b0", + "metadata": {}, + "outputs": [], + "source": [ + "mit = ReadoutMit(\"20xmon?o=0\")\n", + "mit.cals_from_system(20, shots, method=\"local\")\n", + "miti_count = mit.apply_correction(\n", + " raw_count,\n", + " [12, 13, 14, 15, 16],\n", + " positional_logical_mapping=positional_logical_mapping,\n", + " logical_physical_mapping=logical_physical_mapping,\n", + " method=\"square\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "07d7acfd", + "metadata": {}, + "outputs": [], + "source": [ + "plot_histogram([raw_count, miti_count])" + ] + }, + { + "cell_type": "markdown", + "id": "03d5c6cf", + "metadata": {}, + "source": [ + "We can have another way to understand logical qubits: we could treat 0-4 in the original circuit as logical qubits, then we will have the following convention" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad81141a", + "metadata": {}, + "outputs": [], + "source": [ + "miti_count = mit.apply_correction(\n", + " raw_count,\n", + " [0, 1, 2, 3, 4],\n", + " positional_logical_mapping=None,\n", + " logical_physical_mapping={0: 12, 1: 13, 2: 14, 3: 15, 4: 16},\n", + " method=\"square\",\n", + ")\n", + "# note how the None by default implies an identity mapping" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f564d224", + "metadata": {}, + "outputs": [], + "source": [ + "plot_histogram([raw_count, miti_count])\n", + "# the results should be exactly the same" + ] + }, { "cell_type": "markdown", "id": "f13baa43", @@ -416,7 +571,7 @@ "source": [ "## three approaches for measure on partial of the qubits\n", "\n", - "Note the return order should ideally follow the measure order in the instructions (wait to be fixed both on simulator backend and on the return from the real chips, can skip this section for now)" + "Note the return order should ideally follow the measure order in the instructions" ] }, { @@ -428,7 +583,7 @@ "source": [ "# directly partial measure\n", "\n", - "# approach 1\n", + "# approach 1: this approach is deprecated and not recommend\n", "nqubit = 9\n", "shots = 4096\n", "c = tc.Circuit(nqubit)\n", @@ -495,13 +650,11 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "2f9a47c6", + "cell_type": "markdown", + "id": "e431f862", "metadata": {}, - "outputs": [], "source": [ - "# partial measurment also supported via the simulator" + "partial measurment also supported via the simulator" ] }, { @@ -919,14 +1072,6 @@ "source": [ "t.results()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b9ea323f", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 65ffe5cfafddcb7e907548a2f96af74a2b1128fb Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 17 Jan 2023 16:08:13 +0800 Subject: [PATCH 184/725] list in list for link, remove barries when transpile --- tensorcircuit/cloud/abstraction.py | 1 + tensorcircuit/cloud/tencent.py | 21 ++++++++++++++++++--- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 24a5e465..a7a3f5a3 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -201,6 +201,7 @@ def topology(self) -> List[Tuple[int, int]]: links.append((link[0], link[1])) links.append((link[1], link[0])) links = list(set(links)) + links = [list(link) for link in links] # compatible with coupling_map in qiskit return links def topology_graph(self, visualize: bool = False) -> nx.Graph: diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 6a72503e..6863810e 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -127,7 +127,9 @@ def submit_task( qos_dry_run: bool = False, ) -> List[Task]: """ - Submit task via tencent provider + Submit task via tencent provider, we suggest to enable one of the compiling functionality: + either in tc: frontend or in qos: backend. If both are enabled, try on your own risk, some + qubit mapping may fail silently. :param device: [description] :type device: Device @@ -153,7 +155,7 @@ def submit_task( :param compiled_options: compiling options for qiskit ``transpile`` method, defaults to None :type compiled_options: Optional[Dict[str, Any]], optional - :param measure: which group of qubit to measure, + :param measure: [deprecated] which group of qubit to measure, defaults to None, the measure result is in the order of qubit index instead of the ``measure`` list :type measure: Optional[Sequence[int]], optional @@ -180,6 +182,7 @@ def submit_task( def c2qasm(c: Any, compiling: bool) -> str: from qiskit.compiler import transpile from qiskit.circuit import QuantumCircuit + from qiskit.transpiler.passes import RemoveBarriers if compiling is True: if not isinstance(c, QuantumCircuit): @@ -187,6 +190,8 @@ def c2qasm(c: Any, compiling: bool) -> str: nq = c.num_qubits c1 = transpile(c, **compiled_options) + c1 = RemoveBarriers()(c1) + # initial_mapping introduce barrier in the qiskit circuit s = c1.qasm() else: if isinstance(c, QuantumCircuit): @@ -264,7 +269,8 @@ def c2qasm(c: Any, compiling: bool) -> str: if "err" in t: logger.warning(t["err"]) else: - rtn.append(Task(id_=t["id"], device=device)) + ti = Task(id_=t["id"], device=device) + rtn.append(ti) if len(rtn) == 1: return rtn[0] # type: ignore else: @@ -335,6 +341,15 @@ def get_task_details( r["task"]["results"] = r["task"]["result"]["counts"] else: r["task"]["results"] = r["task"]["result"] + if "optimization" in r["task"]: + if ( + "pairs" in r["task"]["optimization"] + and r["task"]["optimization"]["pairs"] is not None + ): + r["task"]["optimization"]["pairs"] = { + int(k): int(v) + for k, v in r["task"]["optimization"]["pairs"].items() + } if prettify is False: return r["task"] # type: ignore # make the results more readable From 2a4f892e23559d4c221529c768bccb5be3e50a6c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 17 Jan 2023 16:08:50 +0800 Subject: [PATCH 185/725] add get_logical_physical_mapping from qiskit circuit --- tensorcircuit/translation.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index ed128132..fce1cf70 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -603,3 +603,19 @@ def qiskit_from_qasm_str_ordered_measure(qasm_str: str) -> Any: for qid, cid in measure_sequence: qc.measure(qid, cid) return qc + + +def get_logical_physical_mapping(qc: Any) -> Dict[int, int]: + """ + get the ``logical_physical_mapping`` from qiskit Circuit + + :param qc: qiskit ``QuantumCircuit`` + :type qc: Any + :return: _description_ + :rtype: Dict[int, int] + """ + logical_physical_mapping = {} + for inst in qc.data: + if inst[0].name == "measure": + logical_physical_mapping[inst[2][0].index] = inst[1][0].index + return logical_physical_mapping From 3c635711fa33ca02e1303c32407e98c3a08e7bec Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 17 Jan 2023 16:28:37 +0800 Subject: [PATCH 186/725] fix black --- tensorcircuit/cloud/abstraction.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index a7a3f5a3..3eec9a5d 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -201,7 +201,8 @@ def topology(self) -> List[Tuple[int, int]]: links.append((link[0], link[1])) links.append((link[1], link[0])) links = list(set(links)) - links = [list(link) for link in links] # compatible with coupling_map in qiskit + links = [list(link) for link in links] # type: ignore + # compatible with coupling_map in qiskit return links def topology_graph(self, visualize: bool = False) -> nx.Graph: From 12bed4a55da85ea4a0cef1aef2706271c3d6fbcf Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 17 Jan 2023 17:17:50 +0800 Subject: [PATCH 187/725] add more details for task --- tensorcircuit/cloud/abstraction.py | 8 +++++++- tensorcircuit/cloud/tencent.py | 8 +++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 3eec9a5d..eba86ebc 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -275,6 +275,7 @@ class Task: def __init__(self, id_: str, device: Optional[Device] = None): self.id_ = id_ self.device = device + self.more_details: Dict[str, Any] = {} def __repr__(self) -> str: return self.device.__repr__() + sep2 + self.id_ @@ -306,7 +307,9 @@ def details(self, blocked: bool = False, **kws: Any) -> Dict[str, Any]: from .apis import get_task_details if blocked is False: - return get_task_details(self, **kws) + dt = get_task_details(self, **kws) + dt.update(self.more_details) + return dt s = self.state() tries = 0 while s == "pending": @@ -315,6 +318,9 @@ def details(self, blocked: bool = False, **kws: Any) -> Dict[str, Any]: s = self.state() return self.details(**kws) + def add_details(self, **kws: Any) -> None: + self.more_details.update(kws) + def state(self) -> str: """ Query the current task status diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 6863810e..5497e976 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -129,7 +129,8 @@ def submit_task( """ Submit task via tencent provider, we suggest to enable one of the compiling functionality: either in tc: frontend or in qos: backend. If both are enabled, try on your own risk, some - qubit mapping may fail silently. + qubit mapping may fail silently. If the user directly provide ``source`` or qiskit Circuit in ``circuit``, + the qubit mapping should be taken care of by the users. :param device: [description] :type device: Device @@ -350,6 +351,11 @@ def get_task_details( int(k): int(v) for k, v in r["task"]["optimization"]["pairs"].items() } + # r["logical_physical_mapping"] = r["task"]["optimization"]["pairs"] + + # if not "logical_physical_mapping" in r["task"]: + # r["task"]["logical_physical_mapping"] = None + if prettify is False: return r["task"] # type: ignore # make the results more readable From 2b0081501c5e16c99ef3c99b8073c30bcc5d616f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 17 Jan 2023 17:18:06 +0800 Subject: [PATCH 188/725] get both mapping from qiskit --- tensorcircuit/translation.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index fce1cf70..6b5fa3bf 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -605,17 +605,21 @@ def qiskit_from_qasm_str_ordered_measure(qasm_str: str) -> Any: return qc -def get_logical_physical_mapping(qc: Any) -> Dict[int, int]: +def get_mappings_from_qiskit(qc: Any) -> Tuple[Dict[int, int], Dict[int, int]]: """ - get the ``logical_physical_mapping`` from qiskit Circuit + get the ``positional_logical_mapping`` and ``logical_physical_mapping`` from qiskit Circuit :param qc: qiskit ``QuantumCircuit`` :type qc: Any :return: _description_ - :rtype: Dict[int, int] + :rtype: Tuple[Dict[int, int], Dict[int, int]] """ logical_physical_mapping = {} + positional_logical_mapping = {} + i = 0 for inst in qc.data: if inst[0].name == "measure": logical_physical_mapping[inst[2][0].index] = inst[1][0].index - return logical_physical_mapping + positional_logical_mapping[i] = inst[2][0].index + i += 1 + return positional_logical_mapping, logical_physical_mapping From c1bd9483730268f8a5e1c337833fff30bdce845e Mon Sep 17 00:00:00 2001 From: Erertertet Date: Thu, 19 Jan 2023 00:08:53 +0000 Subject: [PATCH 189/725] fix encoding problem --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 1c5dfcd1..d170afc8 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ from tensorcircuit import __version__, __author__ -with open("README.md", "r") as fh: +with open("README.md", "r", encoding = "utf-8") as fh: long_description = fh.read() From 05538e96c51cddad0b4f708ccef2d3cb1df422d2 Mon Sep 17 00:00:00 2001 From: Erertertet Date: Thu, 19 Jan 2023 00:28:19 +0000 Subject: [PATCH 190/725] A version that passed some of the basic tests --- tensorcircuit/abstractcircuit.py | 15 +++++ tensorcircuit/translation.py | 76 +++++++++++++++++++++++++ tests/test_circuit.py | 98 ++++++++++++++++++++++++++++++++ 3 files changed, 189 insertions(+) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 51889e83..de40cc27 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -622,6 +622,21 @@ def barrier_instruction(self, *index: List[int]) -> None: } self._extra_qir.append(d) + def to_cirq(self, enable_instruction: bool = False) -> Any: + """ + Translate ``tc.Circuit`` to a cirq circuit object. + + :param enable_instruction: whether also export measurement and reset instructions + :type enable_instruction: bool, defaults to False + :return: A cirq circuit of this circuit. + """ + from .translation import qir2cirq + + qir = self.to_qir() + if enable_instruction is False: + return qir2cirq(qir, n=self._nqubits) + return qir2cirq(qir, n=self._nqubits, extra_qir=self._extra_qir) + def to_qiskit(self, enable_instruction: bool = False) -> Any: """ Translate ``tc.Circuit`` to a qiskit QuantumCircuit object. diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 6b5fa3bf..30efd631 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -18,6 +18,7 @@ from qiskit.circuit.quantumcircuitdata import CircuitInstruction from qiskit.circuit.parametervector import ParameterVectorElement from qiskit.circuit import Parameter, ParameterExpression + import cirq except ImportError: logger.warning( "Please first ``pip install -U qiskit`` to enable related functionality in translation module" @@ -81,6 +82,81 @@ def _merge_extra_qir( nqir += inds[k] return nqir +class CustomizedCirqGate(cirq.Gate): + def __init__(self, uMatrix, name, nqubit): + super(CustomizedCirqGate, self) + self.uMatrix = uMatrix + self.name = name + self.nqubit = nqubit + + def _num_qubits_(self): + return self.nqubit + + def _unitary_(self): + return self.uMatrix + + def _circuit_diagram_info_(self, args): + return [self.name] * self.nqubit + +def qir2cirq( + qir: List[Dict[str, Any]], n: int, extra_qir: Optional[List[Dict[str, Any]]] = None +) -> Any: + r""" + Generate a cirq circuit using the quantum intermediate + representation (qir) in tensorcircuit. + + :Example: + + >>> c = tc.Circuit(2) + >>> c.H(1) + >>> c.X(1) + >>> cisc = tc.translation.qir2cirq(c.to_qir(), 2) + >>> print(cisc) + 1: ───H───X─── + + :param qir: The quantum intermediate representation of a circuit. + :type qir: List[Dict[str, Any]] + :param n: # of qubits + :type n: int + :param extra_qir: The extra quantum IR of tc circuit including measure and reset on hardware, + defaults to None + :type extra_qir: Optional[List[Dict[str, Any]]] + :return: qiskit cirq object + :rtype: Any + """ + if extra_qir is not None and len(extra_qir) > 0: + qir = _merge_extra_qir(qir, extra_qir) + qbits = cirq.LineQubit.range(n) + cmd = [] + for gate_info in qir: + # print(gate_info) + index = [qbits[i] for i in gate_info["index"]] + gate_name = str(gate_info["gatef"]) + if "parameters" in gate_info: + parameters = gate_info["parameters"] + # print(parameters) + # if gate_name in ["h","i","x","y","z","s","t","swap","cnot","fredkin","toffoli","iswap"]: + # cmd.append(getattr(cirq, gate_name.upper())(*index)) + if gate_name in ["h","i","x","y","z","s","fredkin","toffoli","cnot","iswap"]: + cmd.append(getattr(cirq, gate_name.upper())(*index)) + elif gate_name in ["rx", "ry", "rz"]: + cmd.append(getattr(cirq, gate_name)(_get_float(parameters, "theta")).on(*index)) + else: + # Add Customized Gate if there is no match + gatem = np.reshape(gate_info["gate"].tensor,[2 ** len(index), 2 ** len(index)], + ) + # Note: unitary test is not working for some of the generated matrix, probably add tolerance test later + # if not cirq.is_unitary(gatem): + # logger.warning( + # "omit non unitary gate in tensorcircuit when transforming to cirq: %s" + # % gate_name + # ) + # cmd.append(cirq.identity_each(*index)) + # continue + cgate = CustomizedCirqGate(gatem, gate_name, len(index)) + cmd.append(cgate.on(*index)) + cirq_circuit = cirq.Circuit(*cmd) + return cirq_circuit def qir2qiskit( qir: List[Dict[str, Any]], n: int, extra_qir: Optional[List[Dict[str, Any]]] = None diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 11ae59c0..985b37e7 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -857,6 +857,104 @@ def test_circuit_quoperator(backend): qo = c.quoperator() np.testing.assert_allclose(qo.eval_matrix(), c.matrix(), atol=1e-5) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_qir2cirq(backend): + try: + import cirq + from tensorcircuit.translation import perm_matrix + except ImportError: + pytest.skip("cirq is not installed") + n = 6 + c = tc.Circuit(n) + for i in range(n): + c.H(i) + zz = np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]]) + # for i in range(n): + # c.exp( + # i, + # (i + 1) % n, + # theta=tc.array_to_tensor(np.random.uniform()), + # unitary=tc.array_to_tensor(zz), + # name="zz", + # ) + # c.exp1( + # 1, 3, theta=tc.array_to_tensor(0.0j), unitary=tc.array_to_tensor(zz), name="zz" + # ) + c.fredkin(0, 1, 2) + c.cswap(1, 2, 3) + c.ccnot(1, 2, 3) + c.cx(2, 3) + c.swap(0, 1) + c.iswap(0, 1) + c.iswap(1, 3, theta=-1.9) + c.toffoli(0, 1, 2) + c.s(1) + c.t(1) + c.sd(1) + c.td(1) + c.x(2) + c.y(2) + c.z(2) + c.wroot(3) + c.cnot(0, 1) + c.cy(0, 1) + c.cz(0, 1) + c.oy(4, 3) + c.oz(4, 3) + c.ox(4, 3) + c.oy(4, 3) + c.oz(4, 3) + c.ox(3, 4) + c.phase(2, theta=0.3) + c.cphase(1, 0, theta=-1.2) + c.rxx(0, 2, theta=0.9) + c.ryy(1, 4, theta=-2.0) + c.rzz(1, 3, theta=0.5) + c.u(2, theta=0, lbd=4.6, phi=-0.3) + # c.cu(4, 1, theta=1.2) + c.rx(1, theta=tc.array_to_tensor(np.random.uniform())) + c.r(5, theta=tc.array_to_tensor(np.random.uniform())) + c.cr( + 1, + 2, + theta=tc.array_to_tensor(np.random.uniform()), + alpha=tc.array_to_tensor(np.random.uniform()), + phi=tc.array_to_tensor(np.random.uniform()), + ) + c.ry(1, theta=tc.array_to_tensor(np.random.uniform())) + c.rz(1, theta=tc.array_to_tensor(np.random.uniform())) + c.crz(2, 3, theta=tc.array_to_tensor(np.random.uniform())) + c.crx(5, 3, theta=tc.array_to_tensor(np.random.uniform())) + c.cry(1, 3, theta=tc.array_to_tensor(np.random.uniform())) + c.orx(5, 3, theta=tc.array_to_tensor(np.random.uniform())) + c.ory(5, 3, theta=tc.array_to_tensor(np.random.uniform())) + c.orz(5, 3, theta=tc.array_to_tensor(np.random.uniform())) + + c.any(1, 3, unitary=tc.array_to_tensor(np.reshape(zz, [2, 2, 2, 2]))) + + # gate = tc.gates.multicontrol_gate( + # tc.array_to_tensor(tc.gates._x_matrix), ctrl=[1, 0] + # ) + # c.mpo(0, 1, 2, mpo=gate.copy()) + # c.multicontrol( + # 0, + # 2, + # 4, + # 1, + # 5, + # ctrl=[0, 1, 0], + # unitary=tc.array_to_tensor(tc.gates._zz_matrix), + # name="zz", + # ) + tc_unitary = c.matrix() + tc_unitary = np.reshape(tc_unitary, [2**n, 2**n]) + + cirq = c.to_cirq() + cirq_unitary = cirq.unitary() + cirq_unitary = np.reshape(cirq_unitary, [2**n, 2**n]) + + np.testing.assert_allclose(tc_unitary, cirq_unitary, atol = 1e-5) + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_qir2qiskit(backend): From 5f7b9bb229aab897857475598c79c7b652f83a09 Mon Sep 17 00:00:00 2001 From: Erertertet Date: Thu, 19 Jan 2023 02:58:27 +0000 Subject: [PATCH 191/725] passed all the test in qir2cirq, added to-do list --- tensorcircuit/translation.py | 36 ++++++++++++++++++++----- tests/test_circuit.py | 52 ++++++++++++++++++------------------ 2 files changed, 55 insertions(+), 33 deletions(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 30efd631..6f110157 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -123,24 +123,46 @@ def qir2cirq( :type extra_qir: Optional[List[Dict[str, Any]]] :return: qiskit cirq object :rtype: Any + + todo: + add default theta to iswap gate + add more cirq built-in gate instead of customized + add unitary test with tolerance + add support of cirq built-in ControlledGate for multiplecontroll + support more element in qir, e.g. barrier, measure... + disable outputting controlled bit when creating controlled gate """ if extra_qir is not None and len(extra_qir) > 0: qir = _merge_extra_qir(qir, extra_qir) - qbits = cirq.LineQubit.range(n) - cmd = [] + qbits = cirq.LineQubit.range(n) + cmd = [] for gate_info in qir: - # print(gate_info) index = [qbits[i] for i in gate_info["index"]] gate_name = str(gate_info["gatef"]) if "parameters" in gate_info: parameters = gate_info["parameters"] - # print(parameters) - # if gate_name in ["h","i","x","y","z","s","t","swap","cnot","fredkin","toffoli","iswap"]: - # cmd.append(getattr(cirq, gate_name.upper())(*index)) - if gate_name in ["h","i","x","y","z","s","fredkin","toffoli","cnot","iswap"]: + if gate_name in ["h","i","x","y","z","s","t","fredkin","toffoli","cnot","swap"]: cmd.append(getattr(cirq, gate_name.upper())(*index)) elif gate_name in ["rx", "ry", "rz"]: cmd.append(getattr(cirq, gate_name)(_get_float(parameters, "theta")).on(*index)) + elif gate_name == "iswap": + if "theta" not in parameters: + cmd.append(cirq.ISWAP(*index)) + # when ISWAP theta is not specified, _get_float will return default value of 0.0 instead of 1.0 + else: + cmd.append(cirq.ISwapPowGate(exponent = _get_float(parameters, "theta")).on(*index)) + # elif gate_name in ["exp", "exp1"]: + # print(gate_info) + elif gate_name in ["mpo", "multicontrol"]: + gatem = np.reshape( + backend.numpy(gate_info["gatef"](**parameters).eval_matrix()), + [2 ** len(index), 2 ** len(index)], + ) + ci_name = gate_info["name"] + # qiskit_circ.unitary(qop, index[::-1], label=qis_name) + cgate = CustomizedCirqGate(gatem, ci_name, len(index)) + # cgate = CustomizedCirqGate(gatem, gate_name, len(index)) + cmd.append(cgate.on(*index)) else: # Add Customized Gate if there is no match gatem = np.reshape(gate_info["gate"].tensor,[2 ** len(index), 2 ** len(index)], diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 985b37e7..59850c85 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -869,17 +869,17 @@ def test_qir2cirq(backend): for i in range(n): c.H(i) zz = np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]]) - # for i in range(n): - # c.exp( - # i, - # (i + 1) % n, - # theta=tc.array_to_tensor(np.random.uniform()), - # unitary=tc.array_to_tensor(zz), - # name="zz", - # ) - # c.exp1( - # 1, 3, theta=tc.array_to_tensor(0.0j), unitary=tc.array_to_tensor(zz), name="zz" - # ) + for i in range(n): + c.exp( + i, + (i + 1) % n, + theta=tc.array_to_tensor(np.random.uniform()), + unitary=tc.array_to_tensor(zz), + name="zz", + ) + c.exp1( + 1, 3, theta=tc.array_to_tensor(0.0j), unitary=tc.array_to_tensor(zz), name="zz" + ) c.fredkin(0, 1, 2) c.cswap(1, 2, 3) c.ccnot(1, 2, 3) @@ -911,7 +911,7 @@ def test_qir2cirq(backend): c.ryy(1, 4, theta=-2.0) c.rzz(1, 3, theta=0.5) c.u(2, theta=0, lbd=4.6, phi=-0.3) - # c.cu(4, 1, theta=1.2) + c.cu(4, 1, theta=1.2) c.rx(1, theta=tc.array_to_tensor(np.random.uniform())) c.r(5, theta=tc.array_to_tensor(np.random.uniform())) c.cr( @@ -932,20 +932,20 @@ def test_qir2cirq(backend): c.any(1, 3, unitary=tc.array_to_tensor(np.reshape(zz, [2, 2, 2, 2]))) - # gate = tc.gates.multicontrol_gate( - # tc.array_to_tensor(tc.gates._x_matrix), ctrl=[1, 0] - # ) - # c.mpo(0, 1, 2, mpo=gate.copy()) - # c.multicontrol( - # 0, - # 2, - # 4, - # 1, - # 5, - # ctrl=[0, 1, 0], - # unitary=tc.array_to_tensor(tc.gates._zz_matrix), - # name="zz", - # ) + gate = tc.gates.multicontrol_gate( + tc.array_to_tensor(tc.gates._x_matrix), ctrl=[1, 0] + ) + c.mpo(0, 1, 2, mpo=gate.copy()) + c.multicontrol( + 0, + 2, + 4, + 1, + 5, + ctrl=[0, 1, 0], + unitary=tc.array_to_tensor(tc.gates._zz_matrix), + name="zz", + ) tc_unitary = c.matrix() tc_unitary = np.reshape(tc_unitary, [2**n, 2**n]) From 8ffc993f620cded7694159d0d959394bdb86fd1f Mon Sep 17 00:00:00 2001 From: Erertertet Date: Thu, 19 Jan 2023 06:09:09 +0000 Subject: [PATCH 192/725] Clean inactive code --- tensorcircuit/translation.py | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 6f110157..6b0b94e1 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -151,30 +151,19 @@ def qir2cirq( # when ISWAP theta is not specified, _get_float will return default value of 0.0 instead of 1.0 else: cmd.append(cirq.ISwapPowGate(exponent = _get_float(parameters, "theta")).on(*index)) - # elif gate_name in ["exp", "exp1"]: - # print(gate_info) elif gate_name in ["mpo", "multicontrol"]: gatem = np.reshape( backend.numpy(gate_info["gatef"](**parameters).eval_matrix()), [2 ** len(index), 2 ** len(index)], ) ci_name = gate_info["name"] - # qiskit_circ.unitary(qop, index[::-1], label=qis_name) cgate = CustomizedCirqGate(gatem, ci_name, len(index)) - # cgate = CustomizedCirqGate(gatem, gate_name, len(index)) cmd.append(cgate.on(*index)) else: # Add Customized Gate if there is no match gatem = np.reshape(gate_info["gate"].tensor,[2 ** len(index), 2 ** len(index)], ) - # Note: unitary test is not working for some of the generated matrix, probably add tolerance test later - # if not cirq.is_unitary(gatem): - # logger.warning( - # "omit non unitary gate in tensorcircuit when transforming to cirq: %s" - # % gate_name - # ) - # cmd.append(cirq.identity_each(*index)) - # continue + # Note: unitary test is not working for some of the generated matrix, probably add tolerance unitary test later cgate = CustomizedCirqGate(gatem, gate_name, len(index)) cmd.append(cgate.on(*index)) cirq_circuit = cirq.Circuit(*cmd) From f84e7eeb323c0b10e1837761c5dd65a20d77ee9e Mon Sep 17 00:00:00 2001 From: xptree Date: Thu, 19 Jan 2023 21:26:00 +0800 Subject: [PATCH 193/725] implement KaHyPar initialization --- examples/omeinsum_julia/README.md | 13 ++- examples/omeinsum_julia/omeinsum.jl | 17 +++- .../omeinsum_contractor_juliacall.py | 63 +++++++------- .../omeinsum_contractor_subprocess.py | 85 ++++++++++++------- 4 files changed, 114 insertions(+), 64 deletions(-) diff --git a/examples/omeinsum_julia/README.md b/examples/omeinsum_julia/README.md index 7768953c..86e39c05 100644 --- a/examples/omeinsum_julia/README.md +++ b/examples/omeinsum_julia/README.md @@ -2,11 +2,14 @@ This example introduces how to use OMEinsum, a julia-based einsum package, to contract a circuit in TensorCircuit. -We provide two solutions +We provide two solutions: * use subprocess to call a stand-alone julia script (recommended) * use juliacall to integrate julia script into python (seems to be more elegant, but not recommended) +We highly recommend use the first solution based on subprocess, not only due to its compatibility to julia multi-threading, but also because the experimental KaHyPar-based initialization is developed based on it. + + ## Subprocess solution (Recommended) This solution calls a stand-alone julia script `omeinsum.jl` for tensor network contraction. @@ -15,7 +18,7 @@ This solution calls a stand-alone julia script `omeinsum.jl` for tensor network * Step 1: install julia, see https://julialang.org/download/. Please install julia >= 1.8.5, the 1.6.7 LTS version raises: `Error in python: free(): invalid pointer` * Step 2: add julia path to the PATH env variable so that we can find it -* Step 3: install julia package `OMEinsum`, `ArgParse` and `JSON`, this example was tested with OMEinsum v0.7.2, ArgParse v1.1.4 and JSON v0.21.3. See https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager +* Step 3: install julia package `OMEinsum`, `ArgParse`, `JSON` and `KaHyPar`, this example was tested with OMEinsum v0.7.2, ArgParse v1.1.4, JSON v0.21.3 and KaHyPar v0.3.0. See https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager ### How to run @@ -23,6 +26,12 @@ Run `JULIA_NUM_THREADS=N python omeinsum_contractor_subprocess.py`. The env variable `JULIA_NUM_THREADS=N` will be passed to the julia script, so that you can enjoy the accelaration brought by julia multi-threading. +### KaHyPar initialization + +The choice of initial status plays an important role in simulated annealing. +In a discussion with the author of OMEinsum https://github.com/TensorBFS/OMEinsumContractionOrders.jl/issues/35, we +found that there was a way to run TreeSA with initialzier other than greedy or random. We demo how KaHyPar can be used to produce the initial status of simulated annealing. Although we haven't seen significant improvement by using KaHyPar initialization, we believe it is a interesting topic to explore. + ## JuliaCall solution (Not Recommended) JuliaCall seems to be a more elegant solution because all related code are integrated into a single python script. diff --git a/examples/omeinsum_julia/omeinsum.jl b/examples/omeinsum_julia/omeinsum.jl index 991f4f6f..627bffaa 100644 --- a/examples/omeinsum_julia/omeinsum.jl +++ b/examples/omeinsum_julia/omeinsum.jl @@ -1,6 +1,7 @@ import OMEinsum import ArgParse import JSON +using KaHyPar function parse_commandline() s = ArgParse.ArgParseSettings() @@ -13,8 +14,8 @@ function parse_commandline() arg_type = String default = "opteinsum.json" "--sc_target" - arg_type = Float64 - default = 20.0 + arg_type = Int + default = 20 "--beta_start" arg_type = Float64 default = 0.01 @@ -36,6 +37,8 @@ function parse_commandline() "--rw_weight" arg_type = Float64 default = 0.2 + "--kahypar_init" + action = :store_true end return ArgParse.parse_args(s) @@ -59,13 +62,21 @@ function main() for (k, v) in contraction_args["size"] size_dict[k] = v end + + if parsed_args["kahypar_init"] + eincode = OMEinsum.optimize_code(eincode, size_dict, OMEinsum.KaHyParBipartite( + sc_target=parsed_args["sc_target"], + max_group_size=50)) + end + algorithm = OMEinsum.TreeSA( sc_target=parsed_args["sc_target"], βs=parsed_args["beta_start"]:parsed_args["beta_step"]:parsed_args["beta_stop"], ntrials=parsed_args["ntrials"], niters=parsed_args["niters"], sc_weight=parsed_args["sc_weight"], - rw_weight=parsed_args["rw_weight"] + rw_weight=parsed_args["rw_weight"], + initializer=parsed_args["kahypar_init"] ? :specified : :greedy ) # println(parsed_args["beta_start"]:parsed_args["beta_step"]:parsed_args["beta_stop"]) # println(algorithm) diff --git a/examples/omeinsum_julia/omeinsum_contractor_juliacall.py b/examples/omeinsum_julia/omeinsum_contractor_juliacall.py index 958f3477..361f2d22 100644 --- a/examples/omeinsum_julia/omeinsum_contractor_juliacall.py +++ b/examples/omeinsum_julia/omeinsum_contractor_juliacall.py @@ -104,32 +104,37 @@ def __call__( return path -# For more random circuits, please refer to -# https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8 -c = tc.Circuit.from_qsim_file("circuit_n12_m14_s0_e0_pEFGH.qsim") - -opt = ctg.ReusableHyperOptimizer( - methods=["greedy", "kahypar"], - parallel=True, - minimize="flops", - max_repeats=1024, - progbar=False, -) -print("cotengra contractor") -tc.set_contractor( - "custom", optimizer=opt, preprocessing=True, contraction_info=True, debug_level=2 -) -c.expectation_ps(z=[0], reuse=False) - -print("OMEinsum contractor") -opt_treesa = OMEinsumTreeSAOptimizerJuliaCall( - sc_target=30, sc_weight=0.0, rw_weight=0.0 -) -tc.set_contractor( - "custom", - optimizer=opt_treesa, - preprocessing=True, - contraction_info=True, - debug_level=2, -) -c.expectation_ps(z=[0], reuse=False) +if __name__ == "__main__": + # For more random circuits, please refer to + # https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8 + c = tc.Circuit.from_qsim_file("circuit_n12_m14_s0_e0_pEFGH.qsim") + + opt = ctg.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel=True, + minimize="flops", + max_repeats=1024, + progbar=False, + ) + print("cotengra contractor") + tc.set_contractor( + "custom", + optimizer=opt, + preprocessing=True, + contraction_info=True, + debug_level=2, + ) + c.expectation_ps(z=[0], reuse=False) + + print("OMEinsum contractor") + opt_treesa = OMEinsumTreeSAOptimizerJuliaCall( + sc_target=30, sc_weight=0.0, rw_weight=0.0 + ) + tc.set_contractor( + "custom", + optimizer=opt_treesa, + preprocessing=True, + contraction_info=True, + debug_level=2, + ) + c.expectation_ps(z=[0], reuse=False) diff --git a/examples/omeinsum_julia/omeinsum_contractor_subprocess.py b/examples/omeinsum_julia/omeinsum_contractor_subprocess.py index e115de4b..a204ce63 100644 --- a/examples/omeinsum_julia/omeinsum_contractor_subprocess.py +++ b/examples/omeinsum_julia/omeinsum_contractor_subprocess.py @@ -7,6 +7,7 @@ # see https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager import os +import sys import json import time from typing import List, Set, Dict, Tuple @@ -16,20 +17,23 @@ from omeinsum_treesa_optimizer import OMEinsumTreeSAOptimizer import tensorcircuit as tc +sys.setrecursionlimit(10000) tc.set_backend("tensorflow") class OMEinsumTreeSAOptimizerSubprocess(OMEinsumTreeSAOptimizer): def __init__( self, - sc_target: float = 20, + sc_target: int = 20, betas: Tuple[float, float, float] = (0.01, 0.01, 15), ntrials: int = 10, niters: int = 50, sc_weight: float = 1.0, rw_weight: float = 0.2, + kahypar_init: bool = False, ): super().__init__(sc_target, betas, ntrials, niters, sc_weight, rw_weight) + self.kahypar_init = kahypar_init def __call__( self, @@ -73,6 +77,9 @@ def __call__( ) ) + if self.kahypar_init: + cmd += " --kahypar_init" + print(cmd) p = subprocess.Popen( cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE @@ -104,32 +111,50 @@ def __call__( return path -# For more random circuits, please refer to -# https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8 -c = tc.Circuit.from_qsim_file("circuit_n12_m14_s0_e0_pEFGH.qsim") - -opt = ctg.ReusableHyperOptimizer( - methods=["greedy", "kahypar"], - parallel=True, - minimize="flops", - max_repeats=1024, - progbar=False, -) -print("cotengra contractor") -tc.set_contractor( - "custom", optimizer=opt, preprocessing=True, contraction_info=True, debug_level=2 -) -c.expectation_ps(z=[0], reuse=False) - -print("OMEinsum contractor") -opt_treesa = OMEinsumTreeSAOptimizerSubprocess( - sc_target=30, sc_weight=0.0, rw_weight=0.0 -) -tc.set_contractor( - "custom", - optimizer=opt_treesa, - preprocessing=True, - contraction_info=True, - debug_level=2, -) -c.expectation_ps(z=[0], reuse=False) +if __name__ == "__main__": + # For more random circuits, please refer to + # https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8 + c = tc.Circuit.from_qsim_file("circuit_n12_m14_s0_e0_pEFGH.qsim") + + opt = ctg.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel=True, + minimize="flops", + max_repeats=1024, + progbar=False, + ) + print("cotengra contractor") + tc.set_contractor( + "custom", + optimizer=opt, + preprocessing=True, + contraction_info=True, + debug_level=2, + ) + c.expectation_ps(z=[0], reuse=False) + + print("OMEinsum contractor") + opt_treesa = OMEinsumTreeSAOptimizerSubprocess( + sc_target=30, sc_weight=0.0, rw_weight=0.0 + ) + tc.set_contractor( + "custom", + optimizer=opt_treesa, + preprocessing=True, + contraction_info=True, + debug_level=2, + ) + c.expectation_ps(z=[0], reuse=False) + + print("OMEinsum contractor with kahypar init") + opt_treesa = OMEinsumTreeSAOptimizerSubprocess( + sc_target=30, sc_weight=0.0, rw_weight=0.0, kahypar_init=True + ) + tc.set_contractor( + "custom", + optimizer=opt_treesa, + preprocessing=True, + contraction_info=True, + debug_level=2, + ) + c.expectation_ps(z=[0], reuse=False) From 8e825112a0bee0197db1d045beb81d727bc4be0a Mon Sep 17 00:00:00 2001 From: xptree Date: Thu, 19 Jan 2023 21:37:34 +0800 Subject: [PATCH 194/725] fix sc_target data type --- examples/omeinsum_julia/omeinsum_contractor_juliacall.py | 2 +- examples/omeinsum_julia/omeinsum_treesa_optimizer.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/omeinsum_julia/omeinsum_contractor_juliacall.py b/examples/omeinsum_julia/omeinsum_contractor_juliacall.py index 361f2d22..377e871c 100644 --- a/examples/omeinsum_julia/omeinsum_contractor_juliacall.py +++ b/examples/omeinsum_julia/omeinsum_contractor_juliacall.py @@ -31,7 +31,7 @@ class OMEinsumTreeSAOptimizerJuliaCall(OMEinsumTreeSAOptimizer): def __init__( self, - sc_target: float = 20, + sc_target: int = 20, betas: Tuple[float, float, float] = (0.01, 0.01, 15), ntrials: int = 10, niters: int = 50, diff --git a/examples/omeinsum_julia/omeinsum_treesa_optimizer.py b/examples/omeinsum_julia/omeinsum_treesa_optimizer.py index c43dc439..5637e2ea 100644 --- a/examples/omeinsum_julia/omeinsum_treesa_optimizer.py +++ b/examples/omeinsum_julia/omeinsum_treesa_optimizer.py @@ -4,7 +4,7 @@ class OMEinsumTreeSAOptimizer(object): def __init__( self, - sc_target: float = 20, + sc_target: int = 20, betas: Tuple[float, float, float] = (0.01, 0.01, 15), ntrials: int = 10, niters: int = 50, From 8d57eeb5083b59e3fc591f647630d2c8a7a5a356 Mon Sep 17 00:00:00 2001 From: Mark Song <78847784+MarkSong535@users.noreply.github.com> Date: Thu, 19 Jan 2023 22:38:32 +0800 Subject: [PATCH 195/725] Fixed typo that would cause incorrect Latex redering --- docs/source/whitepaper/5-density-matrix.ipynb | 6 ++---- docs/source/whitepaper/5-density-matrix_cn.ipynb | 6 ++---- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/docs/source/whitepaper/5-density-matrix.ipynb b/docs/source/whitepaper/5-density-matrix.ipynb index df67b438..023e6644 100644 --- a/docs/source/whitepaper/5-density-matrix.ipynb +++ b/docs/source/whitepaper/5-density-matrix.ipynb @@ -364,9 +364,7 @@ "metadata": {}, "source": [ "In this framework though, the output of a channel acting on $\\vert{\\psi}\\rangle$ , i.e.\n", - "$\n", - "\\mathcal{E} ( \\vert{\\psi}\\rangle\\langle{\\psi}\\vert) = \\sum_i K_i \\vert{\\psi}\\rangle\\langle{\\psi}\\vert K_i^ \\dagger\n", - "$\n", + "$\\mathcal{E} ( \\vert{\\psi}\\rangle\\langle{\\psi}\\vert) = \\sum_i K_i \\vert{\\psi}\\rangle\\langle{\\psi}\\vert K_i^ \\dagger$\n", "is viewed as an ensemble of states $\\frac{K_i\\vert{\\psi}\\rangle}{\\sqrt{\\langle{\\psi}\\vert K_i^\\dagger K_i \\vert{\\psi}\\rangle}}$ that each occur with probability $p_i = \\langle{\\psi}\\vert K_i^\\dagger K_i \\vert{\\psi}\\rangle$. Thus, the code above stochastically produces the output of a single qubit initialized in state $\\vert{\\psi}\\rangle=\\frac{\\vert{0}\\rangle+\\vert{1}\\rangle}{\\sqrt{2}}$ being passed through a phase damping channel with parameter $\\gamma=0.5$. \n", "\n", "The Monte Carlo simulation of channels where the Kraus operators are all unitary matrices (up to a constant factor) can be handled with additional efficiency by using ``unitary_kraus`` instead of ``general_kraus``." @@ -502,4 +500,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/docs/source/whitepaper/5-density-matrix_cn.ipynb b/docs/source/whitepaper/5-density-matrix_cn.ipynb index b6ea47c0..a1f8cd1e 100644 --- a/docs/source/whitepaper/5-density-matrix_cn.ipynb +++ b/docs/source/whitepaper/5-density-matrix_cn.ipynb @@ -368,9 +368,7 @@ "metadata": {}, "source": [ "不过，在这个框架中，作用于 $\\vert{\\psi}\\rangle$ 的通道的输出，即\n", - "$\n", - "\\mathcal{E} ( \\vert{\\psi}\\rangle\\langle{\\psi}\\vert) = \\sum_i K_i \\vert{\\psi}\\rangle\\langle{\\psi}\\vert K_i^ \\dagger\n", - "$\n", + "$\\mathcal{E} ( \\vert{\\psi}\\rangle\\langle{\\psi}\\vert) = \\sum_i K_i \\vert{\\psi}\\rangle\\langle{\\psi}\\vert K_i^ \\dagger$\n", "被视为状态的集合 $\\frac{K_i\\vert{\\psi}\\rangle}{\\sqrt{\\langle{\\psi}\\vert K_i^\\dagger K_i \\vert{\\psi}\\rangle}}$\n", "每个发生的概率为 $p_i = \\langle{\\psi}\\vert K_i^\\dagger K_i \\vert{\\psi}\\rangle$.\n", "因此，上面的代码随机产生在状态 $\\vert{\\psi}\\rangle=\\frac{\\vert{0}\\rangle+\\vert{1}\\rangle}{\\sqrt{2} }$\n", @@ -513,4 +511,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From 34a51da0c955594fc656cc1215044806d4269f1b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 20 Jan 2023 14:33:08 +0800 Subject: [PATCH 196/725] introduce initial mapping --- tensorcircuit/cloud/tencent.py | 56 +++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 5497e976..10f9e8fe 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -107,7 +107,49 @@ def _free_pi(s: str) -> str: return "\n".join(rs) -@partial(arg_alias, alias_dict={"compiling": ["compiled"]}) +def _comment_qasm(s: str) -> str: + """ + return the qasm str in comment format + + :param s: _description_ + :type s: str + :return: _description_ + :rtype: str + """ + nslist = [] + nslist.append("//circuit begins") + for line in s.split("\n"): + nslist.append("//" + line) + nslist.append("//circuit ends") + return "\n".join(nslist) + + +def _comment_dict(d: Dict[int, int], name: str = "logical_physical_mapping") -> str: + """ + save a dict in commented qasm + + :param d: _description_ + :type d: Dict[int, int] + :param name: _description_, defaults to "logical_physical_mapping" + :type name: str, optional + :return: _description_ + :rtype: str + """ + nslist = [] + nslist.append("//%s begins" % name) + for k, v in d.items(): + nslist.append("// " + str(k) + " : " + str(v)) + nslist.append("//%s ends" % name) + return "\n".join(nslist) + + +@partial( + arg_alias, + alias_dict={ + "compiling": ["compiled"], + "compiled_options": ["qiskit_compiled_options"], + }, +) def submit_task( device: Device, token: str, @@ -120,6 +162,7 @@ def submit_task( remarks: Optional[str] = None, compiling: bool = False, compiled_options: Optional[Dict[str, Any]] = None, + enable_qiskit_initial_mapping: bool = False, measure: Optional[Sequence[int]] = None, enable_qos_qubit_mapping: bool = True, enable_qos_gate_decomposition: bool = True, @@ -175,9 +218,20 @@ def submit_task( """ if source is None: if compiled_options is None: + links = device.topology() + if ( + enable_qiskit_initial_mapping is True + and isinstance(links, list) + and len(links) > 1 + and isinstance(links[0], list) + ): + coupling_map = links + else: + coupling_map = None compiled_options = { "basis_gates": ["h", "rz", "x", "y", "z", "cx", "cz"], "optimization_level": 2, + "coupling_map": coupling_map, } def c2qasm(c: Any, compiling: bool) -> str: From 44acbdc48f4cbd585a7afa869c84ca2b00cc3872 Mon Sep 17 00:00:00 2001 From: Erertertet Date: Fri, 20 Jan 2023 18:46:47 +0000 Subject: [PATCH 197/725] change of formatting and better compatibility --- setup.py | 2 +- tensorcircuit/translation.py | 83 +++++++++++++++++++++++------------- tests/test_circuit.py | 4 +- 3 files changed, 57 insertions(+), 32 deletions(-) diff --git a/setup.py b/setup.py index d170afc8..84be50d3 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ from tensorcircuit import __version__, __author__ -with open("README.md", "r", encoding = "utf-8") as fh: +with open("README.md", "r", encoding="utf-8") as fh: long_description = fh.read() diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 6b0b94e1..391b1d9f 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -18,12 +18,18 @@ from qiskit.circuit.quantumcircuitdata import CircuitInstruction from qiskit.circuit.parametervector import ParameterVectorElement from qiskit.circuit import Parameter, ParameterExpression - import cirq except ImportError: logger.warning( "Please first ``pip install -U qiskit`` to enable related functionality in translation module" ) +try: + import cirq +except ImportError: + logger.warning( + "Please first ``pip install -U cirq`` to enable related functionality in translation module" + ) + from . import gates from .circuit import Circuit from .densitymatrix import DMCircuit2 @@ -82,21 +88,6 @@ def _merge_extra_qir( nqir += inds[k] return nqir -class CustomizedCirqGate(cirq.Gate): - def __init__(self, uMatrix, name, nqubit): - super(CustomizedCirqGate, self) - self.uMatrix = uMatrix - self.name = name - self.nqubit = nqubit - - def _num_qubits_(self): - return self.nqubit - - def _unitary_(self): - return self.uMatrix - - def _circuit_diagram_info_(self, args): - return [self.name] * self.nqubit def qir2cirq( qir: List[Dict[str, Any]], n: int, extra_qir: Optional[List[Dict[str, Any]]] = None @@ -124,7 +115,7 @@ def qir2cirq( :return: qiskit cirq object :rtype: Any - todo: + #TODO(@erertertet): add default theta to iswap gate add more cirq built-in gate instead of customized add unitary test with tolerance @@ -132,36 +123,69 @@ def qir2cirq( support more element in qir, e.g. barrier, measure... disable outputting controlled bit when creating controlled gate """ + + class CustomizedCirqGate(cirq.Gate): + def __init__(self, uMatrix: Any, name: str, nqubit: int): + super(CustomizedCirqGate, self) + self.uMatrix = uMatrix + self.name = name + self.nqubit = nqubit + + def _num_qubits_(self) -> int: + return self.nqubit + + def _unitary_(self) -> Any: + return self.uMatrix + + def _circuit_diagram_info_(self) -> List[str]: + return [self.name] * self.nqubit + if extra_qir is not None and len(extra_qir) > 0: qir = _merge_extra_qir(qir, extra_qir) qbits = cirq.LineQubit.range(n) - cmd = [] + cmd = [] for gate_info in qir: index = [qbits[i] for i in gate_info["index"]] gate_name = str(gate_info["gatef"]) if "parameters" in gate_info: parameters = gate_info["parameters"] - if gate_name in ["h","i","x","y","z","s","t","fredkin","toffoli","cnot","swap"]: + if gate_name in [ + "h", + "i", + "x", + "y", + "z", + "s", + "t", + "fredkin", + "toffoli", + "cnot", + "swap", + ]: cmd.append(getattr(cirq, gate_name.upper())(*index)) elif gate_name in ["rx", "ry", "rz"]: - cmd.append(getattr(cirq, gate_name)(_get_float(parameters, "theta")).on(*index)) + cmd.append( + getattr(cirq, gate_name)(_get_float(parameters, "theta")).on(*index) + ) elif gate_name == "iswap": - if "theta" not in parameters: - cmd.append(cirq.ISWAP(*index)) - # when ISWAP theta is not specified, _get_float will return default value of 0.0 instead of 1.0 - else: - cmd.append(cirq.ISwapPowGate(exponent = _get_float(parameters, "theta")).on(*index)) + cmd.append( + cirq.ISwapPowGate( + exponent=_get_float(parameters, "theta", default=1) + ).on(*index) + ) elif gate_name in ["mpo", "multicontrol"]: gatem = np.reshape( - backend.numpy(gate_info["gatef"](**parameters).eval_matrix()), - [2 ** len(index), 2 ** len(index)], - ) + backend.numpy(gate_info["gatef"](**parameters).eval_matrix()), + [2 ** len(index), 2 ** len(index)], + ) ci_name = gate_info["name"] cgate = CustomizedCirqGate(gatem, ci_name, len(index)) cmd.append(cgate.on(*index)) else: # Add Customized Gate if there is no match - gatem = np.reshape(gate_info["gate"].tensor,[2 ** len(index), 2 ** len(index)], + gatem = np.reshape( + gate_info["gate"].tensor, + [2 ** len(index), 2 ** len(index)], ) # Note: unitary test is not working for some of the generated matrix, probably add tolerance unitary test later cgate = CustomizedCirqGate(gatem, gate_name, len(index)) @@ -169,6 +193,7 @@ def qir2cirq( cirq_circuit = cirq.Circuit(*cmd) return cirq_circuit + def qir2qiskit( qir: List[Dict[str, Any]], n: int, extra_qir: Optional[List[Dict[str, Any]]] = None ) -> Any: diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 59850c85..a8bf5cd1 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -857,11 +857,11 @@ def test_circuit_quoperator(backend): qo = c.quoperator() np.testing.assert_allclose(qo.eval_matrix(), c.matrix(), atol=1e-5) + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_qir2cirq(backend): try: import cirq - from tensorcircuit.translation import perm_matrix except ImportError: pytest.skip("cirq is not installed") n = 6 @@ -953,7 +953,7 @@ def test_qir2cirq(backend): cirq_unitary = cirq.unitary() cirq_unitary = np.reshape(cirq_unitary, [2**n, 2**n]) - np.testing.assert_allclose(tc_unitary, cirq_unitary, atol = 1e-5) + np.testing.assert_allclose(tc_unitary, cirq_unitary, atol=1e-5) @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) From b25f17d0e9f7630c701e096882c24e39386248f9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 21 Jan 2023 08:54:05 +0800 Subject: [PATCH 198/725] fix print and pylint --- tensorcircuit/gates.py | 1 - tensorcircuit/translation.py | 4 ++-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index 60d8e1b7..b348c922 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -896,7 +896,6 @@ def multicontrol_gate(unitary: Tensor, ctrl: Union[int, Sequence[int]] = 1) -> O ctrl = [ctrl] with warnings.catch_warnings(): warnings.simplefilter("ignore", np.ComplexWarning) - print(ctrl) ctrl0_int = int(ctrl[0] + eps) if ctrl0_int == 1: leftend = np.zeros([2, 2, 2]) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 391b1d9f..5fa39dd0 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -121,7 +121,6 @@ def qir2cirq( add unitary test with tolerance add support of cirq built-in ControlledGate for multiplecontroll support more element in qir, e.g. barrier, measure... - disable outputting controlled bit when creating controlled gate """ class CustomizedCirqGate(cirq.Gate): @@ -187,7 +186,8 @@ def _circuit_diagram_info_(self) -> List[str]: gate_info["gate"].tensor, [2 ** len(index), 2 ** len(index)], ) - # Note: unitary test is not working for some of the generated matrix, probably add tolerance unitary test later + # Note: unitary test is not working for some of the generated matrix, + # probably add tolerance unitary test later cgate = CustomizedCirqGate(gatem, gate_name, len(index)) cmd.append(cgate.on(*index)) cirq_circuit = cirq.Circuit(*cmd) From 0c62cd029863e174f28421f9862e22f418b18cd9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 22 Jan 2023 16:39:25 +0800 Subject: [PATCH 199/725] remove unsused part to compiler module --- tensorcircuit/cloud/tencent.py | 54 ---------------------------------- 1 file changed, 54 deletions(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 10f9e8fe..060ea364 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -7,7 +7,6 @@ from json import dumps import logging from functools import partial -import re from .config import tencent_base_url from .utils import rpost_json @@ -90,59 +89,6 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An """ -def _free_pi(s: str) -> str: - # dirty trick to get rid of pi in openqasm from qiskit - rs = [] - pistr = "3.141592653589793" - s = s.replace("pi", pistr) - for r in s.split("\n"): - inc = re.search(r"\(.*\)", r) - if inc is None: - rs.append(r) - else: - v = r[inc.start() : inc.end()] - v = eval(v) - r = r[: inc.start()] + "(" + str(v) + ")" + r[inc.end() :] - rs.append(r) - return "\n".join(rs) - - -def _comment_qasm(s: str) -> str: - """ - return the qasm str in comment format - - :param s: _description_ - :type s: str - :return: _description_ - :rtype: str - """ - nslist = [] - nslist.append("//circuit begins") - for line in s.split("\n"): - nslist.append("//" + line) - nslist.append("//circuit ends") - return "\n".join(nslist) - - -def _comment_dict(d: Dict[int, int], name: str = "logical_physical_mapping") -> str: - """ - save a dict in commented qasm - - :param d: _description_ - :type d: Dict[int, int] - :param name: _description_, defaults to "logical_physical_mapping" - :type name: str, optional - :return: _description_ - :rtype: str - """ - nslist = [] - nslist.append("//%s begins" % name) - for k, v in d.items(): - nslist.append("// " + str(k) + " : " + str(v)) - nslist.append("//%s ends" % name) - return "\n".join(nslist) - - @partial( arg_alias, alias_dict={ From 27782fcdb4062d30ce7ae9282c69a950a9e55bac Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 22 Jan 2023 16:40:40 +0800 Subject: [PATCH 200/725] add compiler module --- CHANGELOG.md | 2 + tensorcircuit/compiler/__init__.py | 4 + tensorcircuit/compiler/qiskit_compiler.py | 138 ++++++++++++++++++++++ tensorcircuit/translation.py | 20 ---- tests/test_compiler.py | 60 ++++++++++ 5 files changed, 204 insertions(+), 20 deletions(-) create mode 100644 tensorcircuit/compiler/__init__.py create mode 100644 tensorcircuit/compiler/qiskit_compiler.py create mode 100644 tests/test_compiler.py diff --git a/CHANGELOG.md b/CHANGELOG.md index facf037a..beb088d7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,8 @@ - Add `cals_from_api` method for `ReadoutMit` class which can acquire the readout error information from the api +- Add experimental compiler module + ### Fixed - Circuit nosify in noise model now support all circuit attributs apart from qubit number diff --git a/tensorcircuit/compiler/__init__.py b/tensorcircuit/compiler/__init__.py new file mode 100644 index 00000000..4dbf1ada --- /dev/null +++ b/tensorcircuit/compiler/__init__.py @@ -0,0 +1,4 @@ +""" +Experimental module, no software agnostic unified interface for now, +only reserve for internal use +""" diff --git a/tensorcircuit/compiler/qiskit_compiler.py b/tensorcircuit/compiler/qiskit_compiler.py new file mode 100644 index 00000000..dc76cb17 --- /dev/null +++ b/tensorcircuit/compiler/qiskit_compiler.py @@ -0,0 +1,138 @@ +""" +compiler interface via qiskit +""" + +from typing import Any, Dict, Tuple, Optional +import re + +from ..abstractcircuit import AbstractCircuit +from ..circuit import Circuit + + +def _free_pi(s: str) -> str: + # dirty trick to get rid of pi in openqasm from qiskit + rs = [] + pistr = "3.141592653589793" + s = s.replace("pi", pistr) + for r in s.split("\n"): + inc = re.search(r"\(.*\)", r) + if inc is None: + rs.append(r) + else: + v = r[inc.start() : inc.end()] + v = eval(v) + r = r[: inc.start()] + "(" + str(v) + ")" + r[inc.end() :] + rs.append(r) + return "\n".join(rs) + + +def _comment_qasm(s: str) -> str: + """ + return the qasm str in comment format + + :param s: _description_ + :type s: str + :return: _description_ + :rtype: str + """ + nslist = [] + nslist.append("//circuit begins") + for line in s.split("\n"): + nslist.append("//" + line) + nslist.append("//circuit ends") + return "\n".join(nslist) + + +def _comment_dict(d: Dict[int, int], name: str = "logical_physical_mapping") -> str: + """ + save a dict in commented qasm + + :param d: _description_ + :type d: Dict[int, int] + :param name: _description_, defaults to "logical_physical_mapping" + :type name: str, optional + :return: _description_ + :rtype: str + """ + nslist = [] + nslist.append("//%s begins" % name) + for k, v in d.items(): + nslist.append("// " + str(k) + " : " + str(v)) + nslist.append("//%s ends" % name) + return "\n".join(nslist) + + +def _get_mappings_from_qiskit(qc: Any) -> Tuple[Dict[int, int], Dict[int, int]]: + """ + get the ``positional_logical_mapping`` and ``logical_physical_mapping`` from qiskit Circuit + + :param qc: qiskit ``QuantumCircuit`` + :type qc: Any + :return: _description_ + :rtype: Tuple[Dict[int, int], Dict[int, int]] + """ + logical_physical_mapping = {} + positional_logical_mapping = {} + i = 0 + for inst in qc.data: + if inst[0].name == "measure": + logical_physical_mapping[inst[2][0].index] = inst[1][0].index + positional_logical_mapping[i] = inst[2][0].index + i += 1 + return positional_logical_mapping, logical_physical_mapping + + +def _add_measure_all_if_none(qc: Any) -> Any: + for inst in qc.data: + if inst[0].name == "measure": + break + else: + qc.measure_all() + return qc + + +def qiskit_compile( + circuit: Any, + output: str = "tc", + info: bool = False, + compiled_options: Optional[Dict[str, Any]] = None, +) -> Any: + from qiskit.compiler import transpile + from qiskit.transpiler.passes import RemoveBarriers + + if isinstance(circuit, AbstractCircuit): + circuit = circuit.to_qiskit(enable_instruction=True) + # else qiskit circuit + circuit = _add_measure_all_if_none(circuit) + if compiled_options is None: + compiled_options = { + "basis_gates": ["h", "rz", "cx"], + "optimization_level": 2, + } + ncircuit = transpile(circuit, **compiled_options) + ncircuit = RemoveBarriers()(ncircuit) + + if output.lower() in ["qasm", "openqasm"]: + r0 = ncircuit.qasm() + + elif output.lower() in ["qiskit", "ibm"]: + r0 = ncircuit + + elif output.lower() in ["tc", "tensorcircuit"]: + r0 = Circuit.from_qiskit(ncircuit) + + else: + raise ValueError("Unknown output format: %s" % output) + + if info is False: + return r0 + + r1 = {} + + ( + r1["positional_logical_mapping"], + r1["logical_physical_mapping"], + ) = _get_mappings_from_qiskit(ncircuit) + # TODO(@refraction-ray): more info to be added into r1 dict + + return (r0, r1) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 5fa39dd0..b10a573f 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -715,23 +715,3 @@ def qiskit_from_qasm_str_ordered_measure(qasm_str: str) -> Any: for qid, cid in measure_sequence: qc.measure(qid, cid) return qc - - -def get_mappings_from_qiskit(qc: Any) -> Tuple[Dict[int, int], Dict[int, int]]: - """ - get the ``positional_logical_mapping`` and ``logical_physical_mapping`` from qiskit Circuit - - :param qc: qiskit ``QuantumCircuit`` - :type qc: Any - :return: _description_ - :rtype: Tuple[Dict[int, int], Dict[int, int]] - """ - logical_physical_mapping = {} - positional_logical_mapping = {} - i = 0 - for inst in qc.data: - if inst[0].name == "measure": - logical_physical_mapping[inst[2][0].index] = inst[1][0].index - positional_logical_mapping[i] = inst[2][0].index - i += 1 - return positional_logical_mapping, logical_physical_mapping diff --git a/tests/test_compiler.py b/tests/test_compiler.py new file mode 100644 index 00000000..648a4413 --- /dev/null +++ b/tests/test_compiler.py @@ -0,0 +1,60 @@ +import sys +import os +import pytest + +# from pytest_lazyfixture import lazy_fixture as lf + + +thisfile = os.path.abspath(__file__) +modulepath = os.path.dirname(os.path.dirname(thisfile)) + +sys.path.insert(0, modulepath) +import tensorcircuit as tc + + +def test_qsikit_compiler(): + try: + import qiskit as _ + except ImportError: + pytest.skip("qiskit is not installed") + + from tensorcircuit.compiler.qiskit_compiler import qiskit_compile + + c = tc.Circuit(2) + c.x(1) + c.cx(0, 1) + + c1, info = qiskit_compile( + c, + info=True, + output="qasm", + compiled_options={ + "basis_gates": ["cz", "rz", "h"], + "optimization_level": 3, + "coupling_map": [[0, 2], [2, 0], [1, 0], [0, 1]], + }, + ) + assert "cz" in c1 + print(info["logical_physical_mapping"]) + + c = tc.Circuit(2) + c.x(1) + c.cx(0, 1) + c.measure_instruction(1) + c1, info = qiskit_compile( + c, + info=True, + output="tc", + compiled_options={ + "basis_gates": ["cx", "rz", "h"], + "optimization_level": 3, + "coupling_map": [[0, 2], [2, 0], [1, 0], [0, 1]], + "initial_layout": [1, 2], + }, + ) + for inst in c1.to_qir(): + if inst["name"] == "h": + assert inst["index"][0] == 2 + print(c1.draw()) + assert info["logical_physical_mapping"][1] in [0, 2] + print(info) From 984730230ae0df604c7d8ee3fcae4222362b0795 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 22 Jan 2023 17:01:01 +0800 Subject: [PATCH 201/725] submit task logic: simplified --- tensorcircuit/cloud/tencent.py | 44 +++++++++++++++------------------- 1 file changed, 19 insertions(+), 25 deletions(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 060ea364..1e15e78c 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -109,7 +109,7 @@ def submit_task( compiling: bool = False, compiled_options: Optional[Dict[str, Any]] = None, enable_qiskit_initial_mapping: bool = False, - measure: Optional[Sequence[int]] = None, + # measure: Optional[Sequence[int]] = None, enable_qos_qubit_mapping: bool = True, enable_qos_gate_decomposition: bool = True, enable_qos_initial_mapping: bool = False, @@ -145,10 +145,6 @@ def submit_task( :param compiled_options: compiling options for qiskit ``transpile`` method, defaults to None :type compiled_options: Optional[Dict[str, Any]], optional - :param measure: [deprecated] which group of qubit to measure, - defaults to None, the measure result is in the order of qubit index - instead of the ``measure`` list - :type measure: Optional[Sequence[int]], optional :param enable_qos_qubit_mapping: whether to insert swap if necessary in qos, defaults to True :type enable_qos_qubit_mapping: bool, optional :param enable_qos_gate_decomposition: whether to compile the gate in qos, defaults to True @@ -162,6 +158,10 @@ def submit_task( :return: Task object or List of Task for batch submission :rtype: List[Task] """ + # :param measure: [deprecated] which group of qubit to measure, + # defaults to None, the measure result is in the order of qubit index + # instead of the ``measure`` list + # :type measure: Optional[Sequence[int]], optional if source is None: if compiled_options is None: links = device.topology() @@ -181,35 +181,29 @@ def submit_task( } def c2qasm(c: Any, compiling: bool) -> str: - from qiskit.compiler import transpile + from ..compiler.qiskit_compiler import qiskit_compile from qiskit.circuit import QuantumCircuit - from qiskit.transpiler.passes import RemoveBarriers if compiling is True: - if not isinstance(c, QuantumCircuit): - c = c.to_qiskit() - - nq = c.num_qubits - c1 = transpile(c, **compiled_options) - c1 = RemoveBarriers()(c1) - # initial_mapping introduce barrier in the qiskit circuit - s = c1.qasm() + s = qiskit_compile( + c, output="qasm", info=True, compiled_options=compiled_options + ) else: if isinstance(c, QuantumCircuit): s = c.qasm() - nq = c.num_qubits + # nq = c.num_qubits else: s = c.to_openqasm() - nq = c._nqubits + # nq = c._nqubits # s = _free_pi(s) # tQuk translation now supports this - if measure is not None: # ad hoc partial measurement - slist = s.split("\n")[:-1] - if len(slist) > 3 and not slist[3].startswith("creg"): - slist.insert(3, "creg c[%s];" % nq) - for m in measure: - slist.append("measure q[%s]->c[%s];" % (m, m)) - slist.append("") - s = "\n".join(slist) + # if measure is not None: # ad hoc partial measurement + # slist = s.split("\n")[:-1] + # if len(slist) > 3 and not slist[3].startswith("creg"): + # slist.insert(3, "creg c[%s];" % nq) + # for m in measure: + # slist.append("measure q[%s]->c[%s];" % (m, m)) + # slist.append("") + # s = "\n".join(slist) return s # type: ignore if is_sequence(circuit): From b39ca7fc053d3bfe68c1fe30da1068e2a064f7f0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 22 Jan 2023 19:10:47 +0800 Subject: [PATCH 202/725] fix some bug in submit task --- tensorcircuit/cloud/tencent.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 1e15e78c..51276ab1 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -163,7 +163,7 @@ def submit_task( # instead of the ``measure`` list # :type measure: Optional[Sequence[int]], optional if source is None: - if compiled_options is None: + if compiled_options is None and compiling is True: links = device.topology() if ( enable_qiskit_initial_mapping is True @@ -186,7 +186,7 @@ def c2qasm(c: Any, compiling: bool) -> str: if compiling is True: s = qiskit_compile( - c, output="qasm", info=True, compiled_options=compiled_options + c, output="qasm", info=False, compiled_options=compiled_options ) else: if isinstance(c, QuantumCircuit): From d5674946dd5e49634fb30b06b1656a6276cf77fb Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 22 Jan 2023 23:15:01 +0800 Subject: [PATCH 203/725] built in rem support qubit mapping --- tensorcircuit/cloud/abstraction.py | 15 +++++++-------- tensorcircuit/cloud/tencent.py | 19 ++++++++++++++++++- 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index eba86ebc..31cbd3ad 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -397,6 +397,9 @@ def results( nqubit = len(list(r.keys())[0]) # mitigated is True: + device = self.get_device() + if device.provider.name != "tencent": + raise ValueError("Only tencent provider supports auto readout mitigation") if readout_mit is None and getattr(self, "readout_mit", None) is None: def run(cs: Any, shots: Any) -> Any: @@ -405,13 +408,7 @@ def run(cs: Any, shots: Any) -> Any: """ from .apis import submit_task - # ts = [] - # for c in cs: - # ts.append( - # submit_task(circuit=c, shots=shots, device=self.get_device()) - # ) - # time.sleep(0.3) - ts = submit_task(circuit=cs, shots=shots, device=self.get_device()) + ts = submit_task(circuit=cs, shots=shots, device=device.name + "?o=0") return [t.results(blocked=True) for t in ts] # type: ignore shots = self.details()["shots"] @@ -426,7 +423,9 @@ def run(cs: Any, shots: Any) -> Any: readout_mit = self.readout_mit if mitigation_options is None: - mitigation_options = {} + mitigation_options = { + "logical_physical_mapping": self.details()["optimization"]["pairs"] + } miti_count = readout_mit.apply_correction( r, list(range(nqubit)), **mitigation_options ) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 51276ab1..cdeb6510 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -89,6 +89,22 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An """ +def _replace_rz_to_st(qasm: str) -> str: + nqasm = [] + for line in qasm.split("\n"): + if line.startswith("rz(pi/2)") or line.startswith("rz(5*pi/2)"): + line = " ".join(["s"] + line.split(" ")[1:]) + elif line.startswith("rz(-pi/2)") or line.startswith("rz(3*pi/2)"): + line = " ".join(["sdg"] + line.split(" ")[1:]) + elif line.startswith("rz(pi/4)"): + line = " ".join(["t"] + line.split(" ")[1:]) + elif line.startswith("rz(-pi/4)"): + line = " ".join(["tdg"] + line.split(" ")[1:]) + + nqasm.append(line) + return "\n".join(nqasm) + + @partial( arg_alias, alias_dict={ @@ -175,7 +191,7 @@ def submit_task( else: coupling_map = None compiled_options = { - "basis_gates": ["h", "rz", "x", "y", "z", "cx", "cz"], + "basis_gates": ["h", "x", "y", "z", "s", "t", "rz", "cx", "cz"], "optimization_level": 2, "coupling_map": coupling_map, } @@ -204,6 +220,7 @@ def c2qasm(c: Any, compiling: bool) -> str: # slist.append("measure q[%s]->c[%s];" % (m, m)) # slist.append("") # s = "\n".join(slist) + s = _replace_rz_to_st(s) return s # type: ignore if is_sequence(circuit): From a7866b62b46f44297e9f2a9e655a1d8a58b24ffc Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 22 Jan 2023 23:15:28 +0800 Subject: [PATCH 204/725] sort the result of apply_correction --- tensorcircuit/results/readout_mitigation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 9551810a..33ef1241 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -555,7 +555,7 @@ def apply_correction( return r # type: ignore # return quasi_out[0] # type: ignore mitcounts = QuasiCollection(quasi_out) - return mitcounts.nearest_probability_distribution() # type: ignore + return sort_count(mitcounts.nearest_probability_distribution()) # type: ignore def _apply_correction( # type: ignore self, From da5cb5040ed966ab5dfbfe951019c7eadb96e964 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 09:25:26 +0800 Subject: [PATCH 205/725] update readme --- README.md | 13 ++++++++++++- README_cn.md | 2 +- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index bb4c1ad8..182ff6f3 100644 --- a/README.md +++ b/README.md @@ -121,7 +121,7 @@ We also have [Docker support](/docker). ## Citing TensorCircuit -This project is released by [Tencent Quantum Lab](https://quantum.tencent.com/) and is currently maintained by [Shi-Xin Zhang](https://github.com/refraction-ray) with contributions from the lab and the open source community. +This project is released by [Tencent Quantum Lab](https://quantum.tencent.com/) and is created and maintained by [Shi-Xin Zhang](https://github.com/refraction-ray) with current core authors [Shi-Xin Zhang](https://github.com/refraction-ray) and [Yu-Qin Chen](https://github.com/yutuer21). We also thank [contributions](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors) from the lab and the open source community. If this project helps in your research, please cite our software whitepaper: @@ -135,6 +135,17 @@ For contribution guidelines and notes, see [CONTRIBUTING](/CONTRIBUTING.md). We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues), [PRs](https://github.com/tencent-quantum-lab/tensorcircuit/pulls), and [discussions](https://github.com/tencent-quantum-lab/tensorcircuit/discussions) from everyone, and these are all hosted on GitHub. +## Contributors + + + + + + + + + + ## Research and Applications ### DQAS diff --git a/README_cn.md b/README_cn.md index 6f74966a..0d45b52b 100644 --- a/README_cn.md +++ b/README_cn.md @@ -117,7 +117,7 @@ pip install tensorcircuit-nightly ## 引用 -该项目由[腾讯量子实验室](https://quantum.tencent.com/)发布，现阶段由 [Shi-Xin Zhang](https://github.com/refraction-ray) 维护。 +该项目由[腾讯量子实验室](https://quantum.tencent.com/)发布，由 [Shi-Xin Zhang](https://github.com/refraction-ray) 创造并维护。当前核心作者包括 [Shi-Xin Zhang](https://github.com/refraction-ray) 和 [Yu-Qin Chen](https://github.com/yutuer21)。我们也感谢来自实验室和开源社区的[贡献](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors)。 如果该软件对您的研究有帮助, 请引用我们的白皮书文章: From 70a2c887c1707efa33569ef525d489fadef15059 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 01:31:11 +0000 Subject: [PATCH 206/725] docs: update README.md [skip ci] --- README.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/README.md b/README.md index 182ff6f3..966d146e 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,7 @@

+ +[![All Contributors](https://img.shields.io/badge/all_contributors-1-orange.svg?style=flat-square)](#contributors-) + @@ -140,6 +143,20 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) + + + + + + +
Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢
+ + + + + + + From 54485ba63793791de4ee4358c715f419f78e7b86 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 01:31:12 +0000 Subject: [PATCH 207/725] docs: create .all-contributorsrc [skip ci] --- .all-contributorsrc | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 .all-contributorsrc diff --git a/.all-contributorsrc b/.all-contributorsrc new file mode 100644 index 00000000..97e61540 --- /dev/null +++ b/.all-contributorsrc @@ -0,0 +1,36 @@ +{ + "files": [ + "README.md" + ], + "imageSize": 100, + "commit": false, + "commitConvention": "angular", + "contributors": [ + { + "login": "refraction-ray", + "name": "Shixin Zhang", + "avatar_url": "https://avatars.githubusercontent.com/u/35157286?v=4", + "profile": "https://re-ra.xyz", + "contributions": [ + "code", + "doc", + "example", + "ideas", + "infra", + "maintenance", + "research", + "review", + "translation", + "test", + "tutorial", + "talk" + ] + } + ], + "contributorsPerLine": 7, + "skipCi": true, + "repoType": "github", + "repoHost": "https://github.com", + "projectName": "tensorcircuit-dev", + "projectOwner": "refraction-ray" +} From 526372bf32ef5524a6d0ac95c4698635f872c4a0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 09:53:32 +0800 Subject: [PATCH 208/725] delete all contributor badge --- README.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/README.md b/README.md index 966d146e..9f302a80 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,4 @@

- -[![All Contributors](https://img.shields.io/badge/all_contributors-1-orange.svg?style=flat-square)](#contributors-) - From 0d1168b6115cc43d74e0a3d3373dc8c42e6fdea4 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 01:55:03 +0000 Subject: [PATCH 209/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9f302a80..c97dd79d 100644 --- a/README.md +++ b/README.md @@ -144,6 +144,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢 + yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ From d7f1729fa9725a86505f32f3e86b348699ae8b8b Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 01:55:04 +0000 Subject: [PATCH 210/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 97e61540..7214e9ae 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -25,6 +25,21 @@ "tutorial", "talk" ] + }, + { + "login": "yutuer21", + "name": "yutuer", + "avatar_url": "https://avatars.githubusercontent.com/u/83822724?v=4", + "profile": "https://github.com/yutuer21", + "contributions": [ + "code", + "doc", + "example", + "ideas", + "research", + "test", + "tutorial" + ] } ], "contributorsPerLine": 7, From c73d457089d5ea77946df338ec6714dce43f3651 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 01:56:32 +0000 Subject: [PATCH 211/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index c97dd79d..d1b883da 100644 --- a/README.md +++ b/README.md @@ -145,6 +145,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢 yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ + Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬 From 357dc785e0b753479465b173c91392e175e3f00e Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 01:56:33 +0000 Subject: [PATCH 212/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 7214e9ae..f13e4025 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -40,6 +40,18 @@ "test", "tutorial" ] + }, + { + "login": "xptree", + "name": "Jiezhong Qiu", + "avatar_url": "https://avatars.githubusercontent.com/u/3853009?v=4", + "profile": "http://jiezhongqiu.com", + "contributions": [ + "code", + "example", + "ideas", + "research" + ] } ], "contributorsPerLine": 7, From 1386e49f889918569e2f45d60cba697e9bc4ad79 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 01:58:10 +0000 Subject: [PATCH 213/725] docs: update README.md [skip ci] --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d1b883da..0aa2614d 100644 --- a/README.md +++ b/README.md @@ -144,7 +144,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢 - yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ + yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢 Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬 From daa5aaaae278a34e461d13de7b78c90c2d061554 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 01:58:11 +0000 Subject: [PATCH 214/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index f13e4025..2024bd7f 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -38,7 +38,8 @@ "ideas", "research", "test", - "tutorial" + "tutorial", + "talk" ] }, { From b32f9ae11bcc0cbb99bab487178208e2373b8f8c Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:00:59 +0000 Subject: [PATCH 215/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 0aa2614d..6d3648e1 100644 --- a/README.md +++ b/README.md @@ -146,6 +146,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢 yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢 Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬 + Weitang Li
Weitang Li
💻 📖 🤔 ⚠️ 📢 From 619b4e0f81a2ae104f9178e69710cad851efb939 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:01:00 +0000 Subject: [PATCH 216/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 2024bd7f..dd4313f2 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -53,6 +53,19 @@ "ideas", "research" ] + }, + { + "login": "liwt31", + "name": "Weitang Li", + "avatar_url": "https://avatars.githubusercontent.com/u/22628546?v=4", + "profile": "http://liwt31.github.io", + "contributions": [ + "code", + "doc", + "ideas", + "test", + "talk" + ] } ], "contributorsPerLine": 7, From 435eea037444a18c36783e99cd40db798efb93f7 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:02:49 +0000 Subject: [PATCH 217/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 6d3648e1..3ee22e43 100644 --- a/README.md +++ b/README.md @@ -147,6 +147,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢 Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬 Weitang Li
Weitang Li
💻 📖 🤔 ⚠️ 📢 + Jiace Sun
Jiace Sun
💻 📖 💡 🤔 🔬 ⚠️ From d4fec8cc4e3a330103cf2c6b28ea4e815b8c3a49 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:02:50 +0000 Subject: [PATCH 218/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index dd4313f2..a917a05d 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -66,6 +66,20 @@ "test", "talk" ] + }, + { + "login": "SUSYUSTC", + "name": "Jiace Sun", + "avatar_url": "https://avatars.githubusercontent.com/u/30529122?v=4", + "profile": "https://github.com/SUSYUSTC", + "contributions": [ + "code", + "doc", + "example", + "ideas", + "research", + "test" + ] } ], "contributorsPerLine": 7, From 0a9d70c8cc2dd668833df92a0ca2ca986ff3b604 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:04:14 +0000 Subject: [PATCH 219/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 3ee22e43..5e47b8cd 100644 --- a/README.md +++ b/README.md @@ -148,6 +148,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬 Weitang Li
Weitang Li
💻 📖 🤔 ⚠️ 📢 Jiace Sun
Jiace Sun
💻 📖 💡 🤔 🔬 ⚠️ + Zhouquan-Wan
Zhouquan-Wan
💻 📖 💡 🤔 ⚠️ ✅ From 10ee47d70b4837f54c32f4a26e68e2c368337b90 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:04:15 +0000 Subject: [PATCH 220/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index a917a05d..8d6ad9bd 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -80,6 +80,20 @@ "research", "test" ] + }, + { + "login": "Zhouquan-Wan", + "name": "Zhouquan-Wan", + "avatar_url": "https://avatars.githubusercontent.com/u/54523490?v=4", + "profile": "https://github.com/Zhouquan-Wan", + "contributions": [ + "code", + "doc", + "example", + "ideas", + "test", + "tutorial" + ] } ], "contributorsPerLine": 7, From 1d775b2559b710dcda5bb84f628cc171462ee765 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 10:05:44 +0800 Subject: [PATCH 221/725] number of contributors each line --- .all-contributorsrc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index 8d6ad9bd..31343e06 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -96,7 +96,7 @@ ] } ], - "contributorsPerLine": 7, + "contributorsPerLine": 6, "skipCi": true, "repoType": "github", "repoHost": "https://github.com", From 56393bf366907d66141ef02b4e0bbdecda9f4311 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:07:27 +0000 Subject: [PATCH 222/725] docs: update README.md [skip ci] --- README.md | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 5e47b8cd..f3a33455 100644 --- a/README.md +++ b/README.md @@ -143,12 +143,15 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) - - - - - - + + + + + + + + +
Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢		yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢		Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬		Weitang Li
Weitang Li
💻 📖 🤔 ⚠️ 📢		Jiace Sun
Jiace Sun
💻 📖 💡 🤔 🔬 ⚠️		Zhouquan-Wan
Zhouquan-Wan
💻 📖 💡 🤔 ⚠️ ✅		Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢		yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢		Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬		Weitang Li
Weitang Li
💻 📖 🤔 ⚠️ 📢		Jiace Sun
Jiace Sun
💻 📖 💡 🤔 🔬 ⚠️		Zhouquan-Wan
Zhouquan-Wan
💻 📖 💡 🤔 ⚠️ ✅
ls-iastu
ls-iastu
💡 ✅
From 98450195ba67d2cb919a31866f69ed38ae89f693 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:07:28 +0000 Subject: [PATCH 223/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 31343e06..f8a61159 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -94,6 +94,16 @@ "test", "tutorial" ] + }, + { + "login": "ls-iastu", + "name": "ls-iastu", + "avatar_url": "https://avatars.githubusercontent.com/u/70554346?v=4", + "profile": "https://github.com/ls-iastu", + "contributions": [ + "example", + "tutorial" + ] } ], "contributorsPerLine": 6, From dae122c5eb9e45522ccef6ae51e76c6d990586f4 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 10:19:00 +0800 Subject: [PATCH 224/725] add research --- .all-contributorsrc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index f8a61159..a5ab4f7d 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -63,6 +63,7 @@ "code", "doc", "ideas", + "research", "test", "talk" ] @@ -91,6 +92,7 @@ "doc", "example", "ideas", + "research", "test", "tutorial" ] @@ -102,6 +104,7 @@ "profile": "https://github.com/ls-iastu", "contributions": [ "example", + "research", "tutorial" ] } From e85d66461bad24efa7624f46b74760a9d30ac22b Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:23:58 +0000 Subject: [PATCH 225/725] docs: update README.md [skip ci] --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index f3a33455..e8c99efd 100644 --- a/README.md +++ b/README.md @@ -146,12 +146,13 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢 yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢 Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬 - Weitang Li
Weitang Li
💻 📖 🤔 ⚠️ 📢 + Weitang Li
Weitang Li
💻 📖 🤔 🔬 ⚠️ 📢 Jiace Sun
Jiace Sun
💻 📖 💡 🤔 🔬 ⚠️ - Zhouquan-Wan
Zhouquan-Wan
💻 📖 💡 🤔 ⚠️ ✅ + Zhouquan-Wan
Zhouquan-Wan
💻 📖 💡 🤔 🔬 ⚠️ ✅ - ls-iastu
ls-iastu
💡 ✅ + ls-iastu
ls-iastu
💡 🔬 ✅ + YHPeter
YHPeter
💻 📖 🚇 ⚠️ ✅ From d76c7bb3291cae8c6643fde059bbb4189039790f Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 02:23:59 +0000 Subject: [PATCH 226/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index a5ab4f7d..d9b45f8c 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -107,6 +107,19 @@ "research", "tutorial" ] + }, + { + "login": "YHPeter", + "name": "YHPeter", + "avatar_url": "https://avatars.githubusercontent.com/u/44126839?v=4", + "profile": "https://github.com/YHPeter", + "contributions": [ + "code", + "doc", + "infra", + "test", + "tutorial" + ] } ], "contributorsPerLine": 6, From 1c9d494d9bcd792880121e243c272ea8907ecda9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 12:43:52 +0800 Subject: [PATCH 227/725] update full name --- .all-contributorsrc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index d9b45f8c..c6ef8ec2 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -28,7 +28,7 @@ }, { "login": "yutuer21", - "name": "yutuer", + "name": "Yu-Qin Chen", "avatar_url": "https://avatars.githubusercontent.com/u/83822724?v=4", "profile": "https://github.com/yutuer21", "contributions": [ @@ -84,7 +84,7 @@ }, { "login": "Zhouquan-Wan", - "name": "Zhouquan-Wan", + "name": "Zhouquan Wan", "avatar_url": "https://avatars.githubusercontent.com/u/54523490?v=4", "profile": "https://github.com/Zhouquan-Wan", "contributions": [ @@ -99,7 +99,7 @@ }, { "login": "ls-iastu", - "name": "ls-iastu", + "name": "Shuo Liu", "avatar_url": "https://avatars.githubusercontent.com/u/70554346?v=4", "profile": "https://github.com/ls-iastu", "contributions": [ @@ -110,7 +110,7 @@ }, { "login": "YHPeter", - "name": "YHPeter", + "name": "Hao Yu", "avatar_url": "https://avatars.githubusercontent.com/u/44126839?v=4", "profile": "https://github.com/YHPeter", "contributions": [ From 10f89b539a24cb4114beaafb5e63e6f06f2766a3 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:46:52 +0000 Subject: [PATCH 228/725] docs: update README.md [skip ci] --- README.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index e8c99efd..5d76401d 100644 --- a/README.md +++ b/README.md @@ -144,15 +144,16 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢 - yutuer
yutuer
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢 + Yu-Qin Chen
Yu-Qin Chen
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢 Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬 Weitang Li
Weitang Li
💻 📖 🤔 🔬 ⚠️ 📢 Jiace Sun
Jiace Sun
💻 📖 💡 🤔 🔬 ⚠️ - Zhouquan-Wan
Zhouquan-Wan
💻 📖 💡 🤔 🔬 ⚠️ ✅ + Zhouquan Wan
Zhouquan Wan
💻 📖 💡 🤔 🔬 ⚠️ ✅ - ls-iastu
ls-iastu
💡 🔬 ✅ - YHPeter
YHPeter
💻 📖 🚇 ⚠️ ✅ + Shuo Liu
Shuo Liu
💡 🔬 ✅ + Hao Yu
Hao Yu
💻 📖 🚇 ⚠️ ✅ + Xinghan Yang
Xinghan Yang
📖 🌍 ✅ From 8ca0688a7b998d230fb6d83a2e85b945bd165471 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:46:53 +0000 Subject: [PATCH 229/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index c6ef8ec2..d1e5d838 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -120,6 +120,17 @@ "test", "tutorial" ] + }, + { + "login": "SexyCarrots", + "name": "Xinghan Yang", + "avatar_url": "https://avatars.githubusercontent.com/u/63588721?v=4", + "profile": "https://github.com/SexyCarrots", + "contributions": [ + "doc", + "translation", + "tutorial" + ] } ], "contributorsPerLine": 6, From abd8f17ed7925fcdcb577687eb7d56033657e89f Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:50:54 +0000 Subject: [PATCH 230/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 5d76401d..c78a6afd 100644 --- a/README.md +++ b/README.md @@ -154,6 +154,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Shuo Liu
Shuo Liu
💡 🔬 ✅ Hao Yu
Hao Yu
💻 📖 🚇 ⚠️ ✅ Xinghan Yang
Xinghan Yang
📖 🌍 ✅ + JachyMeow
JachyMeow
✅ 🌍 From f72a05d78c2d42907efc0b0a30cab21194925fc3 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:50:55 +0000 Subject: [PATCH 231/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index d1e5d838..4cc26b97 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -131,6 +131,16 @@ "translation", "tutorial" ] + }, + { + "login": "JachyMeow", + "name": "JachyMeow", + "avatar_url": "https://avatars.githubusercontent.com/u/114171061?v=4", + "profile": "https://github.com/JachyMeow", + "contributions": [ + "tutorial", + "translation" + ] } ], "contributorsPerLine": 6, From ad7346918b5a7f4d6261ea047ebe79c88b3b7b1d Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:52:43 +0000 Subject: [PATCH 232/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index c78a6afd..ac8d4070 100644 --- a/README.md +++ b/README.md @@ -155,6 +155,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Hao Yu
Hao Yu
💻 📖 🚇 ⚠️ ✅ Xinghan Yang
Xinghan Yang
📖 🌍 ✅ JachyMeow
JachyMeow
✅ 🌍 + Mzye21
Mzye21
🎨 From 28ed2fb9ec676b767756576f08aa0d495e87005e Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:52:44 +0000 Subject: [PATCH 233/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 4cc26b97..06e01395 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -141,6 +141,15 @@ "tutorial", "translation" ] + }, + { + "login": "Mzye21", + "name": "Mzye21", + "avatar_url": "https://avatars.githubusercontent.com/u/86239031?v=4", + "profile": "https://github.com/Mzye21", + "contributions": [ + "design" + ] } ], "contributorsPerLine": 6, From 6412589a0c7b7e7591889444d025278287dd5672 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:56:56 +0000 Subject: [PATCH 234/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ac8d4070..716d0aaf 100644 --- a/README.md +++ b/README.md @@ -156,6 +156,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Xinghan Yang
Xinghan Yang
📖 🌍 ✅ JachyMeow
JachyMeow
✅ 🌍 Mzye21
Mzye21
🎨 + erertertet
erertertet
💻 📖 ⚠️ From 9440017217a0c2a837d0bf0beea2c7bd8e10ae8c Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:56:57 +0000 Subject: [PATCH 235/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 06e01395..da26b570 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -150,6 +150,17 @@ "contributions": [ "design" ] + }, + { + "login": "erertertet", + "name": "erertertet", + "avatar_url": "https://avatars.githubusercontent.com/u/41342153?v=4", + "profile": "https://github.com/erertertet", + "contributions": [ + "code", + "doc", + "test" + ] } ], "contributorsPerLine": 6, From a4416570681b672fdc6c32c84abe1035e0abf960 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:59:37 +0000 Subject: [PATCH 236/725] docs: update README.md [skip ci] --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 716d0aaf..8b3f06ee 100644 --- a/README.md +++ b/README.md @@ -158,6 +158,9 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Mzye21
Mzye21
🎨 erertertet
erertertet
💻 📖 ⚠️ + + yicongzheng
yicongzheng
✅ + From 6f4f30c12782c56a64efb02ae475b162a9aa61ad Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 04:59:38 +0000 Subject: [PATCH 237/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index da26b570..3ebb0e73 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -161,6 +161,15 @@ "doc", "test" ] + }, + { + "login": "yicongzheng", + "name": "yicongzheng", + "avatar_url": "https://avatars.githubusercontent.com/u/107173985?v=4", + "profile": "https://github.com/yicongzheng", + "contributions": [ + "tutorial" + ] } ], "contributorsPerLine": 6, From 6578e1e0d1149dd45563ba3f5ecb7e020055d761 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:06:40 +0000 Subject: [PATCH 238/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 8b3f06ee..fbe53cac 100644 --- a/README.md +++ b/README.md @@ -160,6 +160,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) yicongzheng
yicongzheng
✅ + Zixuan Song
Zixuan Song
📖 🌍 From be1cd6a296430f2c42eb90d8a2ac56ebed0ff077 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:06:41 +0000 Subject: [PATCH 239/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 3ebb0e73..4047a93e 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -170,6 +170,16 @@ "contributions": [ "tutorial" ] + }, + { + "login": "MarkSong535", + "name": "Zixuan Song", + "avatar_url": "https://avatars.githubusercontent.com/u/78847784?v=4", + "profile": "https://marksong.tech", + "contributions": [ + "doc", + "translation" + ] } ], "contributorsPerLine": 6, From b33e063623f9ae6fb3ef450389697993ade0d253 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:08:21 +0000 Subject: [PATCH 240/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index fbe53cac..4e1abd64 100644 --- a/README.md +++ b/README.md @@ -161,6 +161,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) yicongzheng
yicongzheng
✅ Zixuan Song
Zixuan Song
📖 🌍 + Hao Xie
Hao Xie
📖 From 53bad6eb7dba6208d278a404e61749ffb4a6d7a3 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:08:22 +0000 Subject: [PATCH 241/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 4047a93e..6c0a71db 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -180,6 +180,15 @@ "doc", "translation" ] + }, + { + "login": "buwantaiji", + "name": "Hao Xie", + "avatar_url": "https://avatars.githubusercontent.com/u/25216189?v=4", + "profile": "https://github.com/buwantaiji", + "contributions": [ + "doc" + ] } ], "contributorsPerLine": 6, From fc8cc72c128d0b6c7451f29bb494eae440cf6318 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:09:03 +0000 Subject: [PATCH 242/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 4e1abd64..a3548773 100644 --- a/README.md +++ b/README.md @@ -162,6 +162,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) yicongzheng
yicongzheng
✅ Zixuan Song
Zixuan Song
📖 🌍 Hao Xie
Hao Xie
📖 + Pramit Singh
Pramit Singh
⚠️ From 9b70ee39c3b9d43148f857945c2b42759975ab69 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:09:04 +0000 Subject: [PATCH 243/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 6c0a71db..6b172b2c 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -189,6 +189,15 @@ "contributions": [ "doc" ] + }, + { + "login": "pramitsingh0", + "name": "Pramit Singh", + "avatar_url": "https://avatars.githubusercontent.com/u/52959209?v=4", + "profile": "https://github.com/pramitsingh0", + "contributions": [ + "test" + ] } ], "contributorsPerLine": 6, From 9b28c409b69f5bf8f4e59ad95c8ef7aa9112f1ec Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:10:39 +0000 Subject: [PATCH 244/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index a3548773..e9bfa75e 100644 --- a/README.md +++ b/README.md @@ -163,6 +163,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Zixuan Song
Zixuan Song
📖 🌍 Hao Xie
Hao Xie
📖 Pramit Singh
Pramit Singh
⚠️ + JAllcock
JAllcock
📖 🤔 📢 From 3e2d3f2af2b1034e324f1c9339931046ddaf1c39 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:10:40 +0000 Subject: [PATCH 245/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 6b172b2c..a3feaadb 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -198,6 +198,17 @@ "contributions": [ "test" ] + }, + { + "login": "JAllcock", + "name": "JAllcock", + "avatar_url": "https://avatars.githubusercontent.com/u/26302022?v=4", + "profile": "https://github.com/JAllcock", + "contributions": [ + "doc", + "ideas", + "talk" + ] } ], "contributorsPerLine": 6, From d77b48192963dec5dc9155503946132d39652447 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 13:14:48 +0800 Subject: [PATCH 246/725] update name --- .all-contributorsrc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index a3feaadb..0a6783d4 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -28,7 +28,7 @@ }, { "login": "yutuer21", - "name": "Yu-Qin Chen", + "name": "Yuqin Chen", "avatar_url": "https://avatars.githubusercontent.com/u/83822724?v=4", "profile": "https://github.com/yutuer21", "contributions": [ @@ -134,7 +134,7 @@ }, { "login": "JachyMeow", - "name": "JachyMeow", + "name": "Jiaqi Miu", "avatar_url": "https://avatars.githubusercontent.com/u/114171061?v=4", "profile": "https://github.com/JachyMeow", "contributions": [ @@ -144,7 +144,7 @@ }, { "login": "Mzye21", - "name": "Mzye21", + "name": "Zhaofeng Ye", "avatar_url": "https://avatars.githubusercontent.com/u/86239031?v=4", "profile": "https://github.com/Mzye21", "contributions": [ @@ -164,7 +164,7 @@ }, { "login": "yicongzheng", - "name": "yicongzheng", + "name": "Yicong Zheng", "avatar_url": "https://avatars.githubusercontent.com/u/107173985?v=4", "profile": "https://github.com/yicongzheng", "contributions": [ @@ -201,7 +201,7 @@ }, { "login": "JAllcock", - "name": "JAllcock", + "name": "Jonathan Allcock", "avatar_url": "https://avatars.githubusercontent.com/u/26302022?v=4", "profile": "https://github.com/JAllcock", "contributions": [ @@ -215,6 +215,6 @@ "skipCi": true, "repoType": "github", "repoHost": "https://github.com", - "projectName": "tensorcircuit-dev", - "projectOwner": "refraction-ray" + "projectName": "tensorcircuit", + "projectOwner": "tencent-quantum-lab" } From fabeb2b4b6de8ab321b83d9ef6f533bbc952a7e4 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:20:11 +0000 Subject: [PATCH 247/725] docs: update README.md [skip ci] --- README.md | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index e9bfa75e..5706a6e5 100644 --- a/README.md +++ b/README.md @@ -143,27 +143,28 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) - - - - - - + + + + + + - - - - - + + + + + - - - - - + + + + + +
Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢		Yu-Qin Chen
Yu-Qin Chen
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢		Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬		Weitang Li
Weitang Li
💻 📖 🤔 🔬 ⚠️ 📢		Jiace Sun
Jiace Sun
💻 📖 💡 🤔 🔬 ⚠️		Zhouquan Wan
Zhouquan Wan
💻 📖 💡 🤔 🔬 ⚠️ ✅		Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢		Yuqin Chen
Yuqin Chen
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢		Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬		Weitang Li
Weitang Li
💻 📖 🤔 🔬 ⚠️ 📢		Jiace Sun
Jiace Sun
💻 📖 💡 🤔 🔬 ⚠️		Zhouquan Wan
Zhouquan Wan
💻 📖 💡 🤔 🔬 ⚠️ ✅
Shuo Liu
Shuo Liu
💡 🔬 ✅		Hao Yu
Hao Yu
💻 📖 🚇 ⚠️ ✅		Xinghan Yang
Xinghan Yang
📖 🌍 ✅		JachyMeow
JachyMeow
✅ 🌍		Mzye21
Mzye21
🎨		erertertet
erertertet
💻 📖 ⚠️		Hao Yu
Hao Yu
💻 📖 🚇 ⚠️ ✅		Xinghan Yang
Xinghan Yang
📖 🌍 ✅		Jiaqi Miu
Jiaqi Miu
✅ 🌍		Zhaofeng Ye
Zhaofeng Ye
🎨		erertertet
erertertet
💻 📖 ⚠️
yicongzheng
yicongzheng
✅		Zixuan Song
Zixuan Song
📖 🌍		Hao Xie
Hao Xie
📖		Pramit Singh
Pramit Singh
⚠️		JAllcock
JAllcock
📖 🤔 📢		Yicong Zheng
Yicong Zheng
✅		Zixuan Song
Zixuan Song
📖 🌍		Hao Xie
Hao Xie
📖		Pramit Singh
Pramit Singh
⚠️		Jonathan Allcock
Jonathan Allcock
📖 🤔 📢		nealchen2003
nealchen2003
📖
From ce2cdcd1e82468261250345a6ddcda23396d3af8 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 05:20:12 +0000 Subject: [PATCH 248/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 0a6783d4..9989e78c 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -209,6 +209,15 @@ "ideas", "talk" ] + }, + { + "login": "nealchen2003", + "name": "nealchen2003", + "avatar_url": "https://avatars.githubusercontent.com/u/45502551?v=4", + "profile": "https://github.com/nealchen2003", + "contributions": [ + "doc" + ] } ], "contributorsPerLine": 6, From 4f6f5093aa6f57f1cd3d84f758309f6f64e9e089 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 13:34:48 +0800 Subject: [PATCH 249/725] update readme --- README.md | 10 +++++++--- README_cn.md | 8 ++++++-- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 5706a6e5..f4cf7054 100644 --- a/README.md +++ b/README.md @@ -119,23 +119,27 @@ We also have [Docker support](/docker). - API design: quantum for humans, less code, more power -## Citing TensorCircuit +## Contributing + +### Status This project is released by [Tencent Quantum Lab](https://quantum.tencent.com/) and is created and maintained by [Shi-Xin Zhang](https://github.com/refraction-ray) with current core authors [Shi-Xin Zhang](https://github.com/refraction-ray) and [Yu-Qin Chen](https://github.com/yutuer21). We also thank [contributions](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors) from the lab and the open source community. +### Citation + If this project helps in your research, please cite our software whitepaper: [TensorCircuit: a Quantum Software Framework for the NISQ Era](https://arxiv.org/abs/2205.10091) which is also a good introduction to the software. -## Contributing +### Guidelines For contribution guidelines and notes, see [CONTRIBUTING](/CONTRIBUTING.md). We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues), [PRs](https://github.com/tencent-quantum-lab/tensorcircuit/pulls), and [discussions](https://github.com/tencent-quantum-lab/tensorcircuit/discussions) from everyone, and these are all hosted on GitHub. -## Contributors +### Contributors diff --git a/README_cn.md b/README_cn.md index 0d45b52b..1fe018e7 100644 --- a/README_cn.md +++ b/README_cn.md @@ -115,15 +115,19 @@ pip install tensorcircuit-nightly - API 设计：人类可理解的量子，更少的代码，更多的可能 -## 引用 +## 贡献 + +### 现况 该项目由[腾讯量子实验室](https://quantum.tencent.com/)发布，由 [Shi-Xin Zhang](https://github.com/refraction-ray) 创造并维护。当前核心作者包括 [Shi-Xin Zhang](https://github.com/refraction-ray) 和 [Yu-Qin Chen](https://github.com/yutuer21)。我们也感谢来自实验室和开源社区的[贡献](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors)。 +### 引用 + 如果该软件对您的研究有帮助, 请引用我们的白皮书文章: [TensorCircuit: a Quantum Software Framework for the NISQ Era](https://arxiv.org/abs/2205.10091). -## 贡献 +### 说明 有关贡献指南和说明，请参阅 [贡献](/CONTRIBUTING.md)。 From 9923f1372a72184c12029f399830821692bb71d4 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 13:50:57 +0800 Subject: [PATCH 250/725] update doc --- docs/source/api/compiler.rst | 4 + docs/source/api/compiler/qiskit_compiler.rst | 7 + docs/source/index.rst | 4 + docs/source/locale/zh/LC_MESSAGES/api.po | 182 ++++++++++++++----- docs/source/locale/zh/LC_MESSAGES/index.po | 44 +++-- docs/source/modules.rst | 1 + 6 files changed, 179 insertions(+), 63 deletions(-) create mode 100644 docs/source/api/compiler.rst create mode 100644 docs/source/api/compiler/qiskit_compiler.rst diff --git a/docs/source/api/compiler.rst b/docs/source/api/compiler.rst new file mode 100644 index 00000000..8c7f091b --- /dev/null +++ b/docs/source/api/compiler.rst @@ -0,0 +1,4 @@ +tensorcircuit.compiler +================================================== +.. toctree:: + compiler/qiskit_compiler.rst \ No newline at end of file diff --git a/docs/source/api/compiler/qiskit_compiler.rst b/docs/source/api/compiler/qiskit_compiler.rst new file mode 100644 index 00000000..369b4740 --- /dev/null +++ b/docs/source/api/compiler/qiskit_compiler.rst @@ -0,0 +1,7 @@ +tensorcircuit.compiler.qiskit_compiler +================================================== +.. automodule:: tensorcircuit.compiler.qiskit_compiler + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index e8121a26..b99dac19 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -19,6 +19,10 @@ TensorCircuit is an open source quantum circuit and algorithm simulation framewo Links ---------- +This project is released by `Tencent Quantum Lab `_ and is created and maintained by `Shi-Xin Zhang `_. +The current core authors are `Shi-Xin Zhang `_ and `Yu-Qin Chen `_. +We also thank `contributions `_ from the lab and the open source community. + * Source code: https://github.com/tencent-quantum-lab/tensorcircuit * Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues diff --git a/docs/source/locale/zh/LC_MESSAGES/api.po b/docs/source/locale/zh/LC_MESSAGES/api.po index e46120b1..18d69e91 100644 --- a/docs/source/locale/zh/LC_MESSAGES/api.po +++ b/docs/source/locale/zh/LC_MESSAGES/api.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-01-13 11:04+0800\n" +"POT-Creation-Date: 2023-01-24 13:45+0800\n" "PO-Revision-Date: 2022-04-13 14:58+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -106,6 +106,7 @@ msgstr "" #: tensorcircuit.abstractcircuit.AbstractCircuit.reset_instruction #: tensorcircuit.abstractcircuit.AbstractCircuit.select_gate #: tensorcircuit.abstractcircuit.AbstractCircuit.standardize_gate +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_cirq #: tensorcircuit.abstractcircuit.AbstractCircuit.to_json #: tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit #: tensorcircuit.applications.dqas.DQAS_search @@ -591,6 +592,7 @@ msgstr "" #: tensorcircuit.results.readout_mitigation.ReadoutMit.__init__ #: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_correction #: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_readout_mitigation +#: tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_api #: tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_system #: tensorcircuit.results.readout_mitigation.ReadoutMit.expectation #: tensorcircuit.results.readout_mitigation.ReadoutMit.get_matrix @@ -617,8 +619,9 @@ msgstr "" #: tensorcircuit.templates.measurements.sparse_expectation #: tensorcircuit.templates.measurements.spin_glass_measurements #: tensorcircuit.torchnn.QuantumNet.__init__ tensorcircuit.translation.eqasm2tc -#: tensorcircuit.translation.perm_matrix tensorcircuit.translation.qir2json -#: tensorcircuit.translation.qir2qiskit tensorcircuit.translation.qiskit2tc +#: tensorcircuit.translation.perm_matrix tensorcircuit.translation.qir2cirq +#: tensorcircuit.translation.qir2json tensorcircuit.translation.qir2qiskit +#: tensorcircuit.translation.qiskit2tc #: tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure #: tensorcircuit.utils.append tensorcircuit.utils.arg_alias #: tensorcircuit.utils.benchmark tensorcircuit.utils.return_partial @@ -794,6 +797,7 @@ msgstr "" #: tensorcircuit.abstractcircuit.AbstractCircuit.inverse #: tensorcircuit.abstractcircuit.AbstractCircuit.prepend #: tensorcircuit.abstractcircuit.AbstractCircuit.standardize_gate +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_cirq #: tensorcircuit.abstractcircuit.AbstractCircuit.to_json #: tensorcircuit.abstractcircuit.AbstractCircuit.to_openqasm #: tensorcircuit.abstractcircuit.AbstractCircuit.to_qir @@ -1449,8 +1453,8 @@ msgstr "" #: tensorcircuit.templates.measurements.sparse_expectation #: tensorcircuit.templates.measurements.spin_glass_measurements #: tensorcircuit.translation.eqasm2tc tensorcircuit.translation.perm_matrix -#: tensorcircuit.translation.qir2json tensorcircuit.translation.qir2qiskit -#: tensorcircuit.translation.qiskit2tc +#: tensorcircuit.translation.qir2cirq tensorcircuit.translation.qir2json +#: tensorcircuit.translation.qir2qiskit tensorcircuit.translation.qiskit2tc #: tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure #: tensorcircuit.utils.append tensorcircuit.utils.arg_alias #: tensorcircuit.utils.benchmark tensorcircuit.utils.is_m1mac @@ -2089,8 +2093,8 @@ msgstr "" #: tensorcircuit.templates.measurements.sparse_expectation #: tensorcircuit.templates.measurements.spin_glass_measurements #: tensorcircuit.translation.eqasm2tc tensorcircuit.translation.perm_matrix -#: tensorcircuit.translation.qir2json tensorcircuit.translation.qir2qiskit -#: tensorcircuit.translation.qiskit2tc +#: tensorcircuit.translation.qir2cirq tensorcircuit.translation.qir2json +#: tensorcircuit.translation.qir2qiskit tensorcircuit.translation.qiskit2tc #: tensorcircuit.translation.qiskit_from_qasm_str_ordered_measure #: tensorcircuit.utils.append tensorcircuit.utils.arg_alias #: tensorcircuit.utils.benchmark tensorcircuit.utils.is_m1mac @@ -2235,7 +2239,7 @@ msgstr "" #: tensorcircuit.quantum.quantum_constructor #: tensorcircuit.quantum.renyi_free_energy tensorcircuit.quantum.spin_by_basis #: tensorcircuit.quantum.trace_product tensorcircuit.simplify.infer_new_shape -#: tensorcircuit.torchnn.QuantumNet.__init__ +#: tensorcircuit.torchnn.QuantumNet.__init__ tensorcircuit.translation.qir2cirq #: tensorcircuit.translation.qir2qiskit tensorcircuit.translation.qiskit2tc #: tensorcircuit.utils.append tensorcircuit.utils.return_partial #: tensorcircuit.vis.gate_name_trans tensorcircuit.vis.qir2tex @@ -2448,6 +2452,7 @@ msgid "Restore the circuit from the quantum intermediate representation." msgstr "" #: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qir:21 +#: tensorcircuit.translation.qir2cirq:13 #: tensorcircuit.translation.qir2qiskit:14 msgid "The quantum intermediate representation of a circuit." msgstr "" @@ -2477,12 +2482,12 @@ msgid "possible input wavefunction for ``tc.Circuit``, defaults to None" msgstr "" #: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:18 -#: tensorcircuit.translation.qiskit2tc:18 +#: tensorcircuit.translation.qiskit2tc:20 msgid "kwargs given in Circuit.__init__ construction function, default to None." msgstr "" #: of tensorcircuit.abstractcircuit.AbstractCircuit.from_qiskit:20 -#: tensorcircuit.translation.qiskit2tc:20 +#: tensorcircuit.translation.qiskit2tc:22 msgid "" "(variational) parameters for the circuit. Could be either a sequence or " "dictionary depending on the type of parameters in the Qiskit circuit. For" @@ -2602,6 +2607,19 @@ msgstr "" msgid "Latex string that can be directly compiled via, e.g. latexit" msgstr "" +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_cirq:1 +msgid "Translate ``tc.Circuit`` to a cirq circuit object." +msgstr "" + +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_cirq:3 +#: tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit:3 +msgid "whether also export measurement and reset instructions" +msgstr "" + +#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_cirq:5 +msgid "A cirq circuit of this circuit." +msgstr "" + #: of tensorcircuit.abstractcircuit.AbstractCircuit.to_json:1 msgid "circuit dumps to json" msgstr "" @@ -2646,10 +2664,6 @@ msgstr "" msgid "Translate ``tc.Circuit`` to a qiskit QuantumCircuit object." msgstr "" -#: of tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit:3 -msgid "whether also export measurement and reset instructions" -msgstr "" - #: of tensorcircuit.abstractcircuit.AbstractCircuit.to_qiskit:5 msgid "A qiskit object of this circuit." msgstr "" @@ -12832,6 +12846,26 @@ msgstr "" msgid "The result of :math:`\\langle bra\\vert ops \\vert ket\\rangle`." msgstr "" +#: ../../source/api/cloud.rst:2 +msgid "tensorcircuit.cloud" +msgstr "" + +#: ../../source/api/cloud/config.rst:2 +msgid "tensorcircuit.cloud.config" +msgstr "" + +#: ../../source/api/compiler.rst:2 +msgid "tensorcircuit.compiler" +msgstr "" + +#: ../../source/api/compiler/qiskit_compiler.rst:2 +msgid "tensorcircuit.compiler.qiskit_compiler" +msgstr "" + +#: of tensorcircuit.compiler.qiskit_compiler:1 +msgid "compiler interface via qiskit" +msgstr "" + #: ../../source/api/cons.rst:2 msgid "tensorcircuit.cons" msgstr "" @@ -14802,37 +14836,39 @@ msgstr "" #: of tensorcircuit.quantum.PauliStringSum2COO:1 #: tensorcircuit.quantum.PauliStringSum2COO_numpy:1 -msgid "Generate sparse tensor from Pauli string sum" +msgid "" +"Generate sparse tensor from Pauli string sum. Currently requires " +"tensorflow installed" msgstr "" -#: of tensorcircuit.quantum.PauliStringSum2COO:3 -#: tensorcircuit.quantum.PauliStringSum2COO_numpy:3 +#: of tensorcircuit.quantum.PauliStringSum2COO:4 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:4 #: tensorcircuit.quantum.PauliStringSum2COO_tf:3 -#: tensorcircuit.quantum.PauliStringSum2Dense:3 +#: tensorcircuit.quantum.PauliStringSum2Dense:5 msgid "" "2D Tensor, each row is for a Pauli string, e.g. [1, 0, 0, 3, 2] is for " ":math:`X_0Z_3Y_4`" msgstr "" -#: of tensorcircuit.quantum.PauliStringSum2COO:6 -#: tensorcircuit.quantum.PauliStringSum2COO_numpy:6 +#: of tensorcircuit.quantum.PauliStringSum2COO:7 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:7 #: tensorcircuit.quantum.PauliStringSum2COO_tf:6 -#: tensorcircuit.quantum.PauliStringSum2Dense:6 +#: tensorcircuit.quantum.PauliStringSum2Dense:8 msgid "" "1D Tensor, each element corresponds the weight for each Pauli string " "defaults to None (all Pauli strings weight 1.0)" msgstr "" -#: of tensorcircuit.quantum.PauliStringSum2COO:9 -#: tensorcircuit.quantum.PauliStringSum2COO_numpy:9 -#: tensorcircuit.quantum.PauliStringSum2Dense:9 +#: of tensorcircuit.quantum.PauliStringSum2COO:10 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:10 +#: tensorcircuit.quantum.PauliStringSum2Dense:11 msgid "" "default False. If True, return numpy coo else return backend compatible " "sparse tensor" msgstr "" -#: of tensorcircuit.quantum.PauliStringSum2COO:12 -#: tensorcircuit.quantum.PauliStringSum2COO_numpy:12 +#: of tensorcircuit.quantum.PauliStringSum2COO:13 +#: tensorcircuit.quantum.PauliStringSum2COO_numpy:13 msgid "the scipy coo sparse matrix" msgstr "" @@ -14841,10 +14877,12 @@ msgid "the tensorflow coo sparse matrix" msgstr "" #: of tensorcircuit.quantum.PauliStringSum2Dense:1 -msgid "Generate dense matrix from Pauli string sum" +msgid "" +"Generate dense matrix from Pauli string sum. Currently requires " +"tensorflow installed." msgstr "" -#: of tensorcircuit.quantum.PauliStringSum2Dense:12 +#: of tensorcircuit.quantum.PauliStringSum2Dense:14 msgid "the tensorflow dense matrix" msgstr "" @@ -15447,46 +15485,48 @@ msgid "The Gibbs state of ``h`` with the given ``beta``." msgstr "" #: of tensorcircuit.quantum.heisenberg_hamiltonian:1 -msgid "Generate Heisenberg Hamiltonian with possible external fields." +msgid "" +"Generate Heisenberg Hamiltonian with possible external fields. Currently " +"requires tensorflow installed" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:12 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:13 msgid "input circuit graph" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:14 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:15 msgid "zz coupling, default is 1.0" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:16 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:17 msgid "xx coupling, default is 1.0" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:18 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:19 msgid "yy coupling, default is 1.0" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:20 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:21 msgid "External field on z direction, default is 0.0" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:22 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:23 msgid "External field on y direction, default is 0.0" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:24 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:25 msgid "External field on x direction, default is 0.0" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:26 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:27 msgid "Whether to return sparse Hamiltonian operator, default is True." msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:28 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:29 msgid "whether return the matrix in numpy or tensorflow form" msgstr "" -#: of tensorcircuit.quantum.heisenberg_hamiltonian:31 +#: of tensorcircuit.quantum.heisenberg_hamiltonian:32 msgid "Hamiltonian measurements" msgstr "" @@ -15937,12 +15977,24 @@ msgstr "" msgid "mitigated count" msgstr "" +#: of tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_api:1 +msgid "Get local calibriation matrix from cloud API from tc supported providers" +msgstr "" + +#: of tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_api:3 +msgid "list of physical qubits to be calibriated" +msgstr "" + +#: of tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_api:5 +msgid "the device str to qurey for the info, defaults to None" +msgstr "" + #: of tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_system:1 msgid "Get calibrattion information from system." msgstr "" #: of tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_system:3 -msgid "calibration qubit list" +msgid "calibration qubit list (physical qubits on device)" msgstr "" #: of tensorcircuit.results.readout_mitigation.ReadoutMit.cals_from_system:5 @@ -17291,6 +17343,7 @@ msgid "" msgstr "" #: of tensorcircuit.translation.perm_matrix:7 +#: tensorcircuit.translation.qir2cirq:15 #: tensorcircuit.translation.qir2qiskit:16 #: tensorcircuit.translation.qiskit2tc:14 tensorcircuit.vis.qir2tex:12 msgid "# of qubits" @@ -17300,6 +17353,31 @@ msgstr "" msgid "The permutation matrix P" msgstr "" +#: of tensorcircuit.translation.qir2cirq:1 +msgid "" +"Generate a cirq circuit using the quantum intermediate representation " +"(qir) in tensorcircuit." +msgstr "" + +#: of tensorcircuit.translation.qir2cirq:17 +#: tensorcircuit.translation.qir2qiskit:18 +msgid "" +"The extra quantum IR of tc circuit including measure and reset on " +"hardware, defaults to None" +msgstr "" + +#: of tensorcircuit.translation.qir2cirq:20 +msgid "qiskit cirq object" +msgstr "" + +#: of tensorcircuit.translation.qir2cirq:23 +msgid "" +"#TODO(@erertertet): add default theta to iswap gate add more cirq built-" +"in gate instead of customized add unitary test with tolerance add support" +" of cirq built-in ControlledGate for multiplecontroll support more " +"element in qir, e.g. barrier, measure..." +msgstr "" + #: of tensorcircuit.translation.qir2json:1 msgid "" "transform qir to json compatible list of dict where array is replaced by " @@ -17312,12 +17390,6 @@ msgid "" "representation (qir) in tensorcircuit." msgstr "" -#: of tensorcircuit.translation.qir2qiskit:18 -msgid "" -"The extra quantum IR of tc circuit including measure and reset on " -"hardware, defaults to None" -msgstr "" - #: of tensorcircuit.translation.qir2qiskit:21 msgid "qiskit QuantumCircuit object" msgstr "" @@ -17334,7 +17406,11 @@ msgstr "" msgid "Input state of the circuit. Default is None." msgstr "" -#: of tensorcircuit.translation.qiskit2tc:24 +#: of tensorcircuit.translation.qiskit2tc:18 +msgid "``Circuit``, ``DMCircuit`` or ``MPSCircuit``" +msgstr "" + +#: of tensorcircuit.translation.qiskit2tc:26 msgid "A quantum circuit in tensorcircuit" msgstr "" @@ -21987,3 +22063,15 @@ msgstr "" #~ "``results``." #~ msgstr "" +#~ msgid "Generate sparse tensor from Pauli string sum" +#~ msgstr "" + +#~ msgid "Generate dense matrix from Pauli string sum" +#~ msgstr "" + +#~ msgid "Generate Heisenberg Hamiltonian with possible external fields." +#~ msgstr "" + +#~ msgid "calibration qubit list" +#~ msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/index.po b/docs/source/locale/zh/LC_MESSAGES/index.po index 763e7130..681cb7ec 100644 --- a/docs/source/locale/zh/LC_MESSAGES/index.po +++ b/docs/source/locale/zh/LC_MESSAGES/index.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-01-13 11:04+0800\n" +"POT-Creation-Date: 2023-01-24 13:45+0800\n" "PO-Revision-Date: 2022-04-16 22:37+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -58,30 +58,42 @@ msgid "Links" msgstr "重要链接" #: ../../source/index.rst:22 +msgid "" +"This project is released by `Tencent Quantum Lab " +"`_ and is created and maintained by `Shi-" +"Xin Zhang `_ The current core authors " +"are `Shi-Xin Zhang `_ and `Yu-Qin Chen" +" `_. We also thank `contributions " +"`_ from the lab and the open source" +" community." +msgstr "" + +#: ../../source/index.rst:26 msgid "Source code: https://github.com/tencent-quantum-lab/tensorcircuit" msgstr "源代码: https://github.com/tencent-quantum-lab/tensorcircuit" -#: ../../source/index.rst:24 +#: ../../source/index.rst:28 msgid "Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues" msgstr "问题跟踪: https://github.com/tencent-quantum-lab/tensorcircuit/issues" -#: ../../source/index.rst:26 +#: ../../source/index.rst:30 msgid "Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" msgstr "论坛社区: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" -#: ../../source/index.rst:28 +#: ../../source/index.rst:32 msgid "Documentation: https://tensorcircuit.readthedocs.io" msgstr "文档: https://tensorcircuit.readthedocs.io" -#: ../../source/index.rst:30 +#: ../../source/index.rst:34 msgid "Whitepaper: https://arxiv.org/abs/2205.10091" msgstr "白皮书文章: https://arxiv.org/abs/2205.10091" -#: ../../source/index.rst:32 +#: ../../source/index.rst:36 msgid "PyPI page: https://pypi.org/project/tensorcircuit" msgstr "PyPI 页面: https://pypi.org/project/tensorcircuit" -#: ../../source/index.rst:34 +#: ../../source/index.rst:38 msgid "" "DockerHub page: " "https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit" @@ -89,43 +101,43 @@ msgstr "" "DockerHub 页面: " "https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit" -#: ../../source/index.rst:39 +#: ../../source/index.rst:43 msgid "Reference Documentation" msgstr "参考文档" -#: ../../source/index.rst:41 +#: ../../source/index.rst:45 msgid "" "The following documentation sections briefly introduce TensorCircuit to " "the users and developpers." msgstr "以下文档向用户和开发者简要介绍了 TensorCircuit 软件。" -#: ../../source/index.rst:54 +#: ../../source/index.rst:58 msgid "Tutorials" msgstr "教程" -#: ../../source/index.rst:56 +#: ../../source/index.rst:60 msgid "" "The following documentation sections include integrated examples in the " "form of Jupyter Notebook." msgstr "以下 Jupyter Notebook 格式的文档包括了一系列使用 TensorCircuit 的集成案例。" -#: ../../source/index.rst:70 +#: ../../source/index.rst:74 msgid "API References" msgstr "API 参考" -#: ../../source/index.rst:79 +#: ../../source/index.rst:83 msgid "Indices and Tables" msgstr "索引和表格" -#: ../../source/index.rst:81 +#: ../../source/index.rst:85 msgid ":ref:`genindex`" msgstr ":ref:`genindex`" -#: ../../source/index.rst:82 +#: ../../source/index.rst:86 msgid ":ref:`modindex`" msgstr ":ref:`modindex`" -#: ../../source/index.rst:83 +#: ../../source/index.rst:87 msgid ":ref:`search`" msgstr ":ref:`search`" diff --git a/docs/source/modules.rst b/docs/source/modules.rst index c6478c09..05ea1cc3 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -8,6 +8,7 @@ tensorcircuit ./api/channels.rst ./api/circuit.rst ./api/cloud.rst + ./api/compiler.rst ./api/cons.rst ./api/densitymatrix.rst ./api/experimental.rst From 28aad77b99edc5683b3f1d9740a3b2eaa4f5a73d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 13:52:25 +0800 Subject: [PATCH 251/725] update copyright in sphnix --- docs/source/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/conf.py b/docs/source/conf.py index a52a2176..963e52b7 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -21,7 +21,7 @@ # -- Project information ----------------------------------------------------- project = "tensorcircuit" -copyright = "2020, The TensorCircuit Authors" +copyright = "2020, created by Shi-Xin Zhang" author = "refraction-ray" # The short X.Y version From e6e9df966d52cee1d0c7aae9da49750d94638a48 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 14:13:19 +0800 Subject: [PATCH 252/725] update contributor info --- .all-contributorsrc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index 9989e78c..004d000d 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -134,7 +134,7 @@ }, { "login": "JachyMeow", - "name": "Jiaqi Miu", + "name": "JachyMeow", "avatar_url": "https://avatars.githubusercontent.com/u/114171061?v=4", "profile": "https://github.com/JachyMeow", "contributions": [ From 7ec421be935bc84108978b91da46cf8e10b635f0 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 06:17:16 +0000 Subject: [PATCH 253/725] docs: update README.md [skip ci] --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index f4cf7054..a559f65d 100644 --- a/README.md +++ b/README.md @@ -147,7 +147,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) - + @@ -158,7 +158,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) - + From 0f67732e169e2cfecd8f95346715f1e85a4d3052 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 24 Jan 2023 06:17:17 +0000 Subject: [PATCH 254/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index 004d000d..56d27e15 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -23,7 +23,8 @@ "translation", "test", "tutorial", - "talk" + "talk", + "question" ] }, { From f87b758879003820e392aa4104ec157503313e93 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 24 Jan 2023 23:37:59 +0800 Subject: [PATCH 255/725] update docs --- HISTORY.md | 2 +- docs/source/conf.py | 2 +- docs/source/index.rst | 12 ++++++------ 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/HISTORY.md b/HISTORY.md index 64f28080..77f61e28 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1 +1 @@ -TensorCircuit is initially a personal project by @refraction-ray (Shi-Xin Zhang). He began this project in April 2020, inspired by the MPS quantum simulator [mpsim](https://github.com/grmlarose/mpsim) and the introduction of the Google [TensorNetwork](https://github.com/google/TensorNetwork) package. This project is further developed by him during 2020 and the first half of 2021 when he was a Ph.D. candidate at Tsinghua University, with multiple new features and applications added for his research purpose. The original TensorCircuit project is archived now on [GitHub](https://github.com/refraction-ray/tensorcircuit/). He decided to make this project an official open-source product after he joined Tencent in July 2021. And he has extensively refactored and optimized the codebase since then. As the lead author for this project, he thanks all the contributors who have made TensorCircuit and the ecosystem better. +TensorCircuit is initially a personal project created by @refraction-ray (Shi-Xin Zhang). He began this project in April 2020, inspired by the MPS quantum simulator [mpsim](https://github.com/grmlarose/mpsim) and the introduction of the Google [TensorNetwork](https://github.com/google/TensorNetwork) package. This project is further developed by him during 2020 and the first half of 2021 when he was a Ph.D. candidate at Tsinghua University, with multiple new features and applications added for his research purpose. The original TensorCircuit project is archived now on [GitHub](https://github.com/refraction-ray/tensorcircuit/). He decided to make this project a more universal open-source framework after he joined Tencent in July 2021. And he has extensively refactored and optimized the codebase since then. As the creator and the lead author of TensorCircuit, he thanks all the [contributors](https://github.com/tencent-quantum-lab/tensorcircuit#contributors) who have made TensorCircuit and the ecosystem better. diff --git a/docs/source/conf.py b/docs/source/conf.py index 963e52b7..1688127c 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -21,7 +21,7 @@ # -- Project information ----------------------------------------------------- project = "tensorcircuit" -copyright = "2020, created by Shi-Xin Zhang" +copyright = "2020, TensorCircuit Development Team. Created by Shi-Xin Zhang" author = "refraction-ray" # The short X.Y version diff --git a/docs/source/index.rst b/docs/source/index.rst index b99dac19..26707cd1 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -19,19 +19,19 @@ TensorCircuit is an open source quantum circuit and algorithm simulation framewo Links ---------- -This project is released by `Tencent Quantum Lab `_ and is created and maintained by `Shi-Xin Zhang `_. -The current core authors are `Shi-Xin Zhang `_ and `Yu-Qin Chen `_. +TensorCircuit is created and maintained by `Shi-Xin Zhang `_ and this version of the software is released by `Tencent Quantum Lab `_. +The current core authors of TensorCircuit are `Shi-Xin Zhang `_ and `Yu-Qin Chen `_. We also thank `contributions `_ from the lab and the open source community. * Source code: https://github.com/tencent-quantum-lab/tensorcircuit -* Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues - -* Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions +* Software Whitepaper: https://arxiv.org/abs/2205.10091 * Documentation: https://tensorcircuit.readthedocs.io -* Whitepaper: https://arxiv.org/abs/2205.10091 +* Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues + +* Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions * PyPI page: https://pypi.org/project/tensorcircuit From 64e2d7c7a4f27ccd08543c0d48918415d09acaf3 Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Thu, 26 Jan 2023 03:40:29 -0600 Subject: [PATCH 256/725] added qft --- tensorcircuit/templates/blocks.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 59850ef5..13925cd8 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -149,3 +149,30 @@ def example_block( for i in range(n): c.rx(i, theta=param[2 * j + 1, i]) return c + +#import matplotlib +#import qiskit +# import tensorcircuit as tc +# from tensorcircuit import Circuit + + +def qft(c, *index): + index = sorted(list(set(index))) + + for i in range(len(index)): + c.H(index[i]) + rotation = np.pi/2 + for j in range(i + 1, len(index)): + c.cphase(index[j], index[i], theta=rotation) #control bit, target bit, degree of control + rotation/=2 + c.barrier_instruction() + + for i in range(len(index)//2): + c.swap(index[i],index[len(index)-1-i]) + + #c.draw(output='mpl') +###test +# total = 7 +# qc = Circ(total) +# qft(qc,2,4,3,5) +# qc.draw(output='mpl') \ No newline at end of file From 59b6c5b68bcd4c17222538a831af946830936ed8 Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Thu, 26 Jan 2023 12:34:43 -0600 Subject: [PATCH 257/725] tst --- tensorcircuit/templates/blocks.py | 30 ++++++++++-------------------- 1 file changed, 10 insertions(+), 20 deletions(-) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 13925cd8..8c6bf60a 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -149,30 +149,20 @@ def example_block( for i in range(n): c.rx(i, theta=param[2 * j + 1, i]) return c - -#import matplotlib -#import qiskit -# import tensorcircuit as tc -# from tensorcircuit import Circuit + def qft(c, *index): - index = sorted(list(set(index))) - + index = list(index) + for q in index: + if index.count(q) > 1: + raise TypeError("There should not be any repetitive qubits") for i in range(len(index)): c.H(index[i]) - rotation = np.pi/2 + rotation = np.pi / 2 for j in range(i + 1, len(index)): - c.cphase(index[j], index[i], theta=rotation) #control bit, target bit, degree of control - rotation/=2 + c.cphase(index[j], index[i], theta=rotation) + rotation /= 2 c.barrier_instruction() - - for i in range(len(index)//2): - c.swap(index[i],index[len(index)-1-i]) - - #c.draw(output='mpl') -###test -# total = 7 -# qc = Circ(total) -# qft(qc,2,4,3,5) -# qc.draw(output='mpl') \ No newline at end of file + for i in range(len(index) // 2): + c.swap(index[i], index[len(index) - 1 - i]) From d2717770fc2cf04fbd82d9d4fc70da7b45f4d3e8 Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Thu, 26 Jan 2023 12:44:28 -0600 Subject: [PATCH 258/725] tst --- tensorcircuit/templates/blocks.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 8c6bf60a..2be28649 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -151,7 +151,6 @@ def example_block( return c - def qft(c, *index): index = list(index) for q in index: From 06ce7820ca1b4da265534b7c326b68e1465bbf39 Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Thu, 26 Jan 2023 21:50:12 -0600 Subject: [PATCH 259/725] add anotation --- tensorcircuit/templates/blocks.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 2be28649..a03cf745 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -151,8 +151,7 @@ def example_block( return c -def qft(c, *index): - index = list(index) +def qft(c: Circuit, *index: int) -> None: for q in index: if index.count(q) > 1: raise TypeError("There should not be any repetitive qubits") From 6899ad994da1a69acd3661c80303a610e8f1f356 Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Thu, 26 Jan 2023 23:41:52 -0600 Subject: [PATCH 260/725] add test, slight change --- tensorcircuit/templates/blocks.py | 15 +++++++++++---- tests/test_templates.py | 7 +++++++ 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index a03cf745..66745fb9 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -152,15 +152,22 @@ def example_block( def qft(c: Circuit, *index: int) -> None: - for q in index: - if index.count(q) > 1: - raise TypeError("There should not be any repetitive qubits") + """ + This function applies quantum fourier transformation (QFT) to the selected circuit lines + + :param c: Circuit in + :type c: Circuit + :param *index: the indices of the circuit lines to apply QFT + :type *index: Tuple[int, int] + :return: None + :rtype: None + """ + assert len(set(index)) == len(index), "There should not be any repetitive qubits" for i in range(len(index)): c.H(index[i]) rotation = np.pi / 2 for j in range(i + 1, len(index)): c.cphase(index[j], index[i], theta=rotation) rotation /= 2 - c.barrier_instruction() for i in range(len(index) // 2): c.swap(index[i], index[len(index) - 1 - i]) diff --git a/tests/test_templates.py b/tests/test_templates.py index 0174deac..0fc7d5dd 100644 --- a/tests/test_templates.py +++ b/tests/test_templates.py @@ -63,6 +63,13 @@ def test_bell_block(): assert s[0] != s[1] assert s[2] != s[3] +def test_qft_block(): + c = tc.Circuit(4) + tc.templates.blocks.qft(c, 0, 1, 2, 3) + s = c.perfect_sampling() + assert s[1] - 0.0624999 < 10e-6 + + def test_grid_coord(): cd = tc.templates.graphs.Grid2DCoord(3, 2) From e7273db7b25643293462d945b51ede5bf5c00864 Mon Sep 17 00:00:00 2001 From: weitang li Date: Mon, 30 Jan 2023 18:09:28 +0800 Subject: [PATCH 261/725] allow float type in set_dtype --- tensorcircuit/cons.py | 33 ++++++++++++++++++++++++--------- 1 file changed, 24 insertions(+), 9 deletions(-) diff --git a/tensorcircuit/cons.py b/tensorcircuit/cons.py index 844606bf..4442128c 100644 --- a/tensorcircuit/cons.py +++ b/tensorcircuit/cons.py @@ -128,24 +128,39 @@ def set_dtype(dtype: Optional[str] = None, set_global: bool = True) -> Tuple[str """ Set the global runtime numerical dtype of tensors. - :param dtype: "complex64" or "complex128", defaults to None, which is equivalent to "complex64". + :param dtype: "complex64"/"float32" or "complex128"/"float64", + defaults to None, which is equivalent to "complex64". :type dtype: Optional[str], optional :return: complex dtype str and the corresponding real dtype str :rtype: Tuple[str, str] """ if not dtype: dtype = "complex64" + if dtype == "complex64": rdtype = "float32" - else: + elif dtype == "complex128": + rdtype = "float64" + elif dtype == "float32": + dtype = "complex64" + rdtype = "float32" + elif dtype == "float64": + dtype = "complex128" rdtype = "float64" - if backend.name == "jax": + else: + raise ValueError(f"Unsupported data type: {dtype}") + + try: from jax.config import config + except ImportError: + config = None # type: ignore + if config is not None: if dtype == "complex128": config.update("jax_enable_x64", True) elif dtype == "complex64": config.update("jax_enable_x64", False) + if set_global: npdtype = getattr(np, dtype) for module in sys.modules: @@ -620,7 +635,7 @@ def custom( memory_limit: Optional[int] = None, output_edge_order: Optional[List[Any]] = None, ignore_edge_order: bool = False, - **kws: Any + **kws: Any, ) -> Any: if len(nodes) < 5: alg = opt_einsum.paths.optimal @@ -653,7 +668,7 @@ def custom_stateful( opt_conf: Optional[Dict[str, Any]] = None, output_edge_order: Optional[List[Any]] = None, ignore_edge_order: bool = False, - **kws: Any + **kws: Any, ) -> Any: if len(nodes) < 5: alg = opt_einsum.paths.optimal @@ -690,7 +705,7 @@ def new_algorithm( input_sets: Dict[Any, int], output_set: Dict[Any, int], size_dict: Dict[Any, int], - **kws: Any + **kws: Any, ) -> Any: path = algorithm(input_sets, output_set, size_dict, **kws) tree = ContractionTree.from_path(input_sets, output_set, size_dict, path=path) @@ -716,7 +731,7 @@ def set_contractor( set_global: bool = True, contraction_info: bool = False, debug_level: int = 0, - **kws: Any + **kws: Any, ) -> Callable[..., Any]: """ To set runtime contractor of the tensornetwork for a better contraction path. @@ -757,7 +772,7 @@ def set_contractor( opt_conf=opt_conf, contraction_info=contraction_info, debug_level=debug_level, - **kws + **kws, ) else: @@ -774,7 +789,7 @@ def set_contractor( optimizer=optimizer, memory_limit=memory_limit, debug_level=debug_level, - **kws + **kws, ) if set_global: for module in sys.modules: From d8f47a39ecc86146713f3f864e150955ff17c6e9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 31 Jan 2023 12:35:47 +0800 Subject: [PATCH 262/725] add todo --- tensorcircuit/abstractcircuit.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index de40cc27..6c2f4349 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -350,6 +350,7 @@ def from_qir( :return: The circuit have same gates in the qir. :rtype: Circuit """ + # TODO(@refraction-ray): add extra_qir support if circuit_params is None: circuit_params = {} if "nqubits" not in circuit_params: From ecad10cac533b57bfbef49dab6948a340e6174e8 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 31 Jan 2023 14:08:02 +0800 Subject: [PATCH 263/725] sort apply correction --- tensorcircuit/results/readout_mitigation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 33ef1241..e2d6dbf1 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -552,7 +552,7 @@ def apply_correction( r = quasi_out[0] r = sort_count(r) r = {k: v * shots for k, v in r.items()} - return r # type: ignore + return sort_count(r) # type: ignore # return quasi_out[0] # type: ignore mitcounts = QuasiCollection(quasi_out) return sort_count(mitcounts.nearest_probability_distribution()) # type: ignore From 874035eaacc30286c3790cea7e25be7d2fbee24e Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Tue, 31 Jan 2023 00:42:30 -0600 Subject: [PATCH 264/725] add inverse, add barrier indices, etc. --- tensorcircuit/templates/blocks.py | 49 +++++++++++++++++++++++-------- tests/test_templates.py | 4 +-- 2 files changed, 39 insertions(+), 14 deletions(-) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 66745fb9..a9cba0ef 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -151,23 +151,48 @@ def example_block( return c -def qft(c: Circuit, *index: int) -> None: +def qft( + c: Circuit, *index: int, do_swaps: bool, inverse: bool, insert_barriers: bool +) -> Circuit: """ This function applies quantum fourier transformation (QFT) to the selected circuit lines :param c: Circuit in :type c: Circuit :param *index: the indices of the circuit lines to apply QFT - :type *index: Tuple[int, int] - :return: None - :rtype: None + :type *index: List[int] + :param do_swaps: Whether to include the final swaps in the QFT + :type do_swaps: bool + :param inverse: If True, the inverse Fourier transform is constructed + :type inverse: bool + :param insert_barriers: If True, barriers are inserted as visualization improvement + :type insert_barriers: bool + :return: Circuit c + :rtype: Circuit """ assert len(set(index)) == len(index), "There should not be any repetitive qubits" - for i in range(len(index)): - c.H(index[i]) - rotation = np.pi / 2 - for j in range(i + 1, len(index)): - c.cphase(index[j], index[i], theta=rotation) - rotation /= 2 - for i in range(len(index) // 2): - c.swap(index[i], index[len(index) - 1 - i]) + if inverse: + if do_swaps: + for i in range(len(index) // 2): + c.swap(index[i], index[len(index) - 1 - i]) + for i in range(len(index) - 1, -1, -1): + rotation = -np.pi / 2 + for j in range(len(index) - 1, i, -1): + c.cphase(index[j], index[i], theta=rotation) + rotation /= 2 + c.H(index[i]) + if insert_barriers: + c.barrier_instruction(range(min(index), max(index) + 1)) + else: + for i in range(len(index)): + c.H(index[i]) + rotation = np.pi / 2 + for j in range(i + 1, len(index)): + c.cphase(index[j], index[i], theta=rotation) + rotation /= 2 + if insert_barriers: + c.barrier_instruction(range(min(index), max(index) + 1)) + if do_swaps: + for i in range(len(index) // 2): + c.swap(index[i], index[len(index) - 1 - i]) + return c diff --git a/tests/test_templates.py b/tests/test_templates.py index 0fc7d5dd..0791173c 100644 --- a/tests/test_templates.py +++ b/tests/test_templates.py @@ -63,14 +63,14 @@ def test_bell_block(): assert s[0] != s[1] assert s[2] != s[3] -def test_qft_block(): + +def test_qft_block() -> None: c = tc.Circuit(4) tc.templates.blocks.qft(c, 0, 1, 2, 3) s = c.perfect_sampling() assert s[1] - 0.0624999 < 10e-6 - def test_grid_coord(): cd = tc.templates.graphs.Grid2DCoord(3, 2) assert cd.all_cols() == [(0, 3), (1, 4), (2, 5)] From 149ec9b8b23d386c9fe8d6b3edea5cb2c3e6ea11 Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Tue, 31 Jan 2023 00:46:39 -0600 Subject: [PATCH 265/725] small change to test --- tests/test_templates.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_templates.py b/tests/test_templates.py index 0791173c..40ae739c 100644 --- a/tests/test_templates.py +++ b/tests/test_templates.py @@ -66,7 +66,7 @@ def test_bell_block(): def test_qft_block() -> None: c = tc.Circuit(4) - tc.templates.blocks.qft(c, 0, 1, 2, 3) + c = tc.templates.blocks.qft(c, 0, 1, 2, 3, False, False, False) s = c.perfect_sampling() assert s[1] - 0.0624999 < 10e-6 From b9ac2eaca1c667a80dcdd7bcbd030103aa62f2a4 Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Tue, 31 Jan 2023 00:55:46 -0600 Subject: [PATCH 266/725] add defalt values for bools --- tensorcircuit/templates/blocks.py | 6 +++++- tests/test_templates.py | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index a9cba0ef..3c1a393f 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -152,7 +152,11 @@ def example_block( def qft( - c: Circuit, *index: int, do_swaps: bool, inverse: bool, insert_barriers: bool + c: Circuit, + *index: int, + do_swaps: bool = False, + inverse: bool = False, + insert_barriers: bool = False ) -> Circuit: """ This function applies quantum fourier transformation (QFT) to the selected circuit lines diff --git a/tests/test_templates.py b/tests/test_templates.py index 40ae739c..c22b6a73 100644 --- a/tests/test_templates.py +++ b/tests/test_templates.py @@ -66,7 +66,7 @@ def test_bell_block(): def test_qft_block() -> None: c = tc.Circuit(4) - c = tc.templates.blocks.qft(c, 0, 1, 2, 3, False, False, False) + c = tc.templates.blocks.qft(c, 0, 1, 2, 3) s = c.perfect_sampling() assert s[1] - 0.0624999 < 10e-6 From 0daf9b9fa003e7091eac7f32752121b585220030 Mon Sep 17 00:00:00 2001 From: eurethia <3366841721@qq.com> Date: Tue, 31 Jan 2023 01:02:45 -0600 Subject: [PATCH 267/725] change swap true --- tensorcircuit/templates/blocks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 3c1a393f..eacc2b42 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -154,7 +154,7 @@ def example_block( def qft( c: Circuit, *index: int, - do_swaps: bool = False, + do_swaps: bool = True, inverse: bool = False, insert_barriers: bool = False ) -> Circuit: From 3934fb0d704aab73b3d0513ac8fdb8dd246cc292 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 31 Jan 2023 07:15:06 +0000 Subject: [PATCH 268/725] docs: update README.md [skip ci] --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index a559f65d..bc28341f 100644 --- a/README.md +++ b/README.md @@ -170,6 +170,9 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) + + +
Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢		Shixin Zhang
Shixin Zhang
💻 📖 💡 🤔 🚇 🚧 🔬 👀 🌍 ⚠️ ✅ 📢 💬		 Yuqin Chen
Yuqin Chen
💻 📖 💡 🤔 🔬 ⚠️ ✅ 📢		 Jiezhong Qiu
Jiezhong Qiu
💻 💡 🤔 🔬		 Weitang Li
Weitang Li
💻 📖 🤔 🔬 ⚠️ 📢		Shuo Liu
Shuo Liu
💡 🔬 ✅		 Hao Yu
Hao Yu
💻 📖 🚇 ⚠️ ✅		 Xinghan Yang
Xinghan Yang
📖 🌍 ✅		Jiaqi Miu
Jiaqi Miu
✅ 🌍		JachyMeow
JachyMeow
✅ 🌍		 Zhaofeng Ye
Zhaofeng Ye
🎨		 erertertet
erertertet
💻 📖 ⚠️
Jonathan Allcock
Jonathan Allcock
📖 🤔 📢		 nealchen2003
nealchen2003
📖
隐公观鱼
隐公观鱼
💻 ⚠️
From 9201eb119d3fe78f58ec6aa8641ab82eaf0c149e Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 31 Jan 2023 07:15:07 +0000 Subject: [PATCH 269/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 56d27e15..8ba87a4b 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -219,6 +219,16 @@ "contributions": [ "doc" ] + }, + { + "login": "eurethia", + "name": "隐公观鱼", + "avatar_url": "https://avatars.githubusercontent.com/u/84611606?v=4", + "profile": "https://github.com/eurethia", + "contributions": [ + "code", + "test" + ] } ], "contributorsPerLine": 6, From 510c6cba5b4bd795504c5d75cdd1a1d92a128033 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 31 Jan 2023 21:00:12 +0800 Subject: [PATCH 270/725] fix quimb2qop bug --- CHANGELOG.md | 2 ++ tensorcircuit/quantum.py | 29 +++++++++++++++++++---------- tests/test_quantum.py | 12 ++++++++++-- 3 files changed, 31 insertions(+), 12 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index beb088d7..bf820773 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,8 @@ - Some string warnings are fixed by using r-string +- Fix bug in `tc.quantum.quimb2qop` when mps is the input + ## 0.7.0 ### Added diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index a1d8ea32..8b195678 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1085,19 +1085,28 @@ def quimb2qop(qb_mpo: Any) -> QuOperator: nwires = len(qb_mpo) assert nwires >= 3, "number of tensors must be larger than 2" mpo = [] + edges = [] for i in range(nwires): mpo.append(Node(qb_mpo[i].data)) - pbc = len(qb_mpo[0].shape) == 4 - if pbc: - for i in range(nwires): - connect(mpo[i][1], mpo[(i + 1) % nwires][0]) - else: - for i in range(1, nwires - 1): - connect(mpo[i][1], mpo[i + 1][0]) - connect(mpo[0][0], mpo[1][0]) + for j, ind in enumerate(qb_mpo[i].inds): + edges.append((i, j, ind)) + + out_edges = [] + in_edges = [] + + for i, e1 in enumerate(edges): + if e1[2].startswith("k"): + out_edges.append(mpo[e1[0]][e1[1]]) + elif e1[2].startswith("b"): + in_edges.append(mpo[e1[0]][e1[1]]) + else: + for j, e2 in enumerate(edges[i + 1 :]): + if e2[2] == e1[2]: + connect(mpo[e1[0]][e1[1]], mpo[e2[0]][e2[1]]) + qop = quantum_constructor( - [mpo[i][-2] for i in range(nwires)], # out_edges - [mpo[i][-1] for i in range(nwires)], # in_edges + out_edges, # out_edges + in_edges, # in_edges [], [], # ignore_edges ) diff --git a/tests/test_quantum.py b/tests/test_quantum.py index f2969f76..3fcf1de8 100644 --- a/tests/test_quantum.py +++ b/tests/test_quantum.py @@ -389,7 +389,7 @@ def test_qb2qop(backend): except ImportError: pytest.skip("quimb is not installed") nwires = 6 - qb_mpo = quimb.tensor.tensor_gen.MPO_ham_ising(nwires, 4, 2, cyclic=True) + qb_mpo = quimb.tensor.tensor_builder.MPO_ham_ising(nwires, 4, 2, cyclic=True) qu_mpo = tc.quantum.quimb2qop(qb_mpo) h1 = qu_mpo.eval_matrix() g = tc.templates.graphs.Line1D(nwires, pbc=True) @@ -399,7 +399,7 @@ def test_qb2qop(backend): np.testing.assert_allclose(h1, h2, atol=1e-5) # in out edge order test - builder = quimb.tensor.tensor_gen.SpinHam() + builder = quimb.tensor.tensor_builder.SpinHam1D() # new version quimb breaking API change: SpinHam1D -> SpinHam builder += 1, "Y" builder += 1, "X" @@ -412,6 +412,14 @@ def test_qb2qop(backend): ) np.testing.assert_allclose(m1, m2, atol=1e-5) + # test mps case + + s1 = quimb.tensor.tensor_builder.MPS_rand_state(3, 4) + s2 = tc.quantum.quimb2qop(s1) + m1 = s1.to_dense() + m2 = s2.eval_matrix() + np.testing.assert_allclose(m1, m2, atol=1e-5) + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_counts_2(backend): From 1205ba9f457cfe62dab8bc5a7a6c0865be25acbd Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 31 Jan 2023 21:01:06 +0800 Subject: [PATCH 271/725] add mera mpo example --- examples/mera_extra_mpo.py | 117 +++++++++++++++++++++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 examples/mera_extra_mpo.py diff --git a/examples/mera_extra_mpo.py b/examples/mera_extra_mpo.py new file mode 100644 index 00000000..5d80770a --- /dev/null +++ b/examples/mera_extra_mpo.py @@ -0,0 +1,117 @@ +import time +import logging +import numpy as np +import tensornetwork as tn +import optax +import cotengra +import tensorflow as tf +import tensorcircuit as tc + +logger = logging.getLogger("tensorcircuit") +logger.setLevel(logging.INFO) +ch = logging.StreamHandler() +ch.setLevel(logging.DEBUG) +logger.addHandler(ch) + + +K = tc.set_backend("tensorflow") +tc.set_dtype("complex128") + + +optc = cotengra.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel="ray", + minimize="combo", + max_time=90, + max_repeats=1024, + progbar=True, +) + +tc.set_contractor("custom", optimizer=optc, preprocessing=True) + + +def MERA_circuit(params, n, d): + c = tc.Circuit(n) + + idx = 0 + + for i in range(n): + c.rx(i, theta=params[2 * i]) + c.rz(i, theta=params[2 * i + 1]) + idx += 2 * n + + for n_layer in range(1, int(np.log2(n)) + 1): + n_qubit = 2**n_layer + step = int(n / n_qubit) + + for _ in range(d): + # even + for i in range(step, n - step, 2 * step): + c.exp1(i, i + step, theta=params[idx], unitary=tc.gates._xx_matrix) + c.exp1(i, i + step, theta=params[idx + 1], unitary=tc.gates._zz_matrix) + idx += 2 + + # odd + for i in range(0, n, 2 * step): + c.exp1(i, i + step, theta=params[idx], unitary=tc.gates._xx_matrix) + c.exp1(i, i + step, theta=params[idx + 1], unitary=tc.gates._zz_matrix) + idx += 2 + + for i in range(0, n, step): + c.rx(i, theta=params[idx]) + c.rz(i, theta=params[idx + 1]) + idx += 2 + + return c, idx + + +def MERA(params, n, d, hamiltonian_mpo): + c, _ = MERA_circuit(params, n, d) + return tc.templates.measurements.mpo_expectation(c, hamiltonian_mpo) + + +MERA_vvag = K.jit(K.vectorized_value_and_grad(MERA), static_argnums=(1, 2, 3)) + + +def train(opt, j, b, n, d, batch, maxiter): + Jx = j * np.ones([n - 1]) # strength of xx interaction (OBC) + Bz = -b * np.ones([n]) # strength of transverse field + hamiltonian_mpo = tn.matrixproductstates.mpo.FiniteTFI(Jx, Bz, dtype=np.complex128) + # matrix product operator + hamiltonian_mpo = tc.quantum.tn2qop(hamiltonian_mpo) + _, idx = MERA_circuit(K.ones([int(1e6)]), n, d) + params = K.implicit_randn([batch, idx], 0, 0.05) + times = [] + times.append(time.time()) + for i in range(maxiter): + e, g = MERA_vvag(params, n, d, hamiltonian_mpo) + params = opt.update(g, params) + times.append(time.time()) + if i % 100 == 99: + print("energy: ", e) + print( + "time analysis: ", + times[1] - times[0], + (times[-1] - times[1]) / (len(times) - 2), + ) + return K.min(e) + + +if __name__ == "__main__": + if K.name == "jax": + exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 + ) + opt = K.optimizer(optax.adam(exponential_decay_scheduler)) + elif K.name == "tensorflow": + exponential_decay_scheduler = tf.keras.optimizers.schedules.ExponentialDecay( + initial_learning_rate=1e-2, decay_steps=500, decay_rate=0.9 + ) + opt = K.optimizer(tf.keras.optimizers.Adam(exponential_decay_scheduler)) + e = train(opt, 1, -1, 64, 2, 2, 5000) + print("optimized energy:", e) + +# backend: n, d, batch: compiling time, running time +# jax: 16, 2, 8: 730s, 0.033s +# tf: 16, 2, 8: 140s, 0.043s +# tf: 32, 2, 2: 251s, 0.9s From bc44b2660f9a0fb0e34af359d4f8be61f54b4703 Mon Sep 17 00:00:00 2001 From: weitang li Date: Tue, 31 Jan 2023 20:08:08 +0800 Subject: [PATCH 272/725] enhance translation of multicontrol gate --- tensorcircuit/translation.py | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index b10a573f..368cc8c3 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -13,6 +13,7 @@ try: from qiskit import QuantumCircuit from qiskit.circuit.library import XXPlusYYGate + from qiskit.extensions import UnitaryGate import qiskit.quantum_info as qi from qiskit.extensions.exceptions import ExtensionError from qiskit.circuit.quantumcircuitdata import CircuitInstruction @@ -300,7 +301,14 @@ def qir2qiskit( qiskit_circ.hamiltonian( exp_op, time=theta, qubits=index_reversed, label=qis_name ) - elif gate_name in ["mpo", "multicontrol"]: + elif gate_name == "multicontrol": + unitary = backend.numpy(backend.convert_to_tensor(parameters["unitary"])) + ctrl_str = "".join(map(str, parameters["ctrl"]))[::-1] + gate = UnitaryGate(unitary, label=qis_name).control( + len(ctrl_str), ctrl_state=ctrl_str + ) + qiskit_circ.append(gate, gate_info["index"]) + elif gate_name == "mpo": qop = qi.Operator( np.reshape( backend.numpy(gate_info["gatef"](**parameters).eval_matrix()), @@ -550,14 +558,21 @@ def tensor_to_json(a: Any) -> Any: a = tensor_to_numpy(a) ar = np.real(a) - ai = np.imag(a) - return [ar.tolist(), ai.tolist()] + if np.iscomplexobj(a): + ai = np.imag(a) + return [ar.tolist(), ai.tolist()] + else: + return [ar.tolist()] def json_to_tensor(a: Any) -> Any: ar = np.array(a[0]) - ai = np.array(a[1]) - return ar + 1.0j * ai + if len(a) == 1: + return ar + else: + assert len(a) == 2 + ai = np.array(a[1]) + return ar + 1.0j * ai def qir2json( From ab6c12e14a19aaa13e4f485170663b7739d21d2e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 1 Feb 2023 12:15:53 +0800 Subject: [PATCH 273/725] rm .code.yml --- .code.yml | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 .code.yml diff --git a/.code.yml b/.code.yml deleted file mode 100644 index 1e158629..00000000 --- a/.code.yml +++ /dev/null @@ -1,8 +0,0 @@ -source: - # internal usage to filter code scan - test_source: - filepath_regex: [".*/examples/.*", ".*/benchmarks/scripts/.*"] - auto_generate_source: - filepath_regex: [".*/setup.py"] - third_party_source: - filepath_regex: [".*/tensorcircuit/applications/.*", ".*/docs/.*"] From a5906af09d69f5c39a9dcc5a09a02a4a6d5ed8ef Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 1 Feb 2023 17:14:22 +0800 Subject: [PATCH 274/725] fix qiskit leakage in translation --- tensorcircuit/translation.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 368cc8c3..bf9a7420 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -23,6 +23,7 @@ logger.warning( "Please first ``pip install -U qiskit`` to enable related functionality in translation module" ) + CircuitInstruction = Any try: import cirq From a401b26c8ff3cc111c89c9979ea710ab9653a82e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 1 Feb 2023 20:17:41 +0800 Subject: [PATCH 275/725] more pipeline ready compiler infras --- tensorcircuit/compiler/qiskit_compiler.py | 79 ++++++++++++++++------- tests/test_compiler.py | 16 ++++- 2 files changed, 69 insertions(+), 26 deletions(-) diff --git a/tensorcircuit/compiler/qiskit_compiler.py b/tensorcircuit/compiler/qiskit_compiler.py index dc76cb17..31e1cde8 100644 --- a/tensorcircuit/compiler/qiskit_compiler.py +++ b/tensorcircuit/compiler/qiskit_compiler.py @@ -2,11 +2,12 @@ compiler interface via qiskit """ -from typing import Any, Dict, Tuple, Optional +from typing import Any, Dict, Optional import re from ..abstractcircuit import AbstractCircuit from ..circuit import Circuit +from ..translation import qiskit_from_qasm_str_ordered_measure def _free_pi(s: str) -> str: @@ -62,24 +63,46 @@ def _comment_dict(d: Dict[int, int], name: str = "logical_physical_mapping") -> return "\n".join(nslist) -def _get_mappings_from_qiskit(qc: Any) -> Tuple[Dict[int, int], Dict[int, int]]: - """ - get the ``positional_logical_mapping`` and ``logical_physical_mapping`` from qiskit Circuit - - :param qc: qiskit ``QuantumCircuit`` - :type qc: Any - :return: _description_ - :rtype: Tuple[Dict[int, int], Dict[int, int]] - """ - logical_physical_mapping = {} - positional_logical_mapping = {} +def _get_positional_logical_mapping_from_qiskit(qc: Any) -> Dict[int, int]: i = 0 + positional_logical_mapping = {} for inst in qc.data: if inst[0].name == "measure": - logical_physical_mapping[inst[2][0].index] = inst[1][0].index - positional_logical_mapping[i] = inst[2][0].index + positional_logical_mapping[i] = inst[1][0].index i += 1 - return positional_logical_mapping, logical_physical_mapping + + return positional_logical_mapping + + +def _get_logical_physical_mapping_from_qiskit( + qc_after: Any, qc_before: Any = None +) -> Dict[int, int]: + """ + get ``logical_physical_mapping`` from qiskit Circuit by comparing the circuit after and before compiling + + :param qc_after: qiskit ``QuantumCircuit`` after compiling + :type qc_after: Any + :param qc_before: qiskit ``QuantumCircuit`` before compiling, + if None, measure(q, q) is assumed + :type qc_before: Any + :return: logical_physical_mapping + :rtype: Dict[int, int] + """ + logical_physical_mapping = {} + for inst in qc_after.data: + if inst[0].name == "measure": + if qc_before is None: + logical_q = inst[2][0].index + else: + for instb in qc_before.data: + if ( + instb[0].name == "measure" + and instb[2][0].index == inst[2][0].index + ): + logical_q = instb[1][0].index + break + logical_physical_mapping[logical_q] = inst[1][0].index + return logical_physical_mapping def _add_measure_all_if_none(qc: Any) -> Any: @@ -93,8 +116,8 @@ def _add_measure_all_if_none(qc: Any) -> Any: def qiskit_compile( circuit: Any, + info: Optional[Dict[str, Any]] = None, output: str = "tc", - info: bool = False, compiled_options: Optional[Dict[str, Any]] = None, ) -> Any: from qiskit.compiler import transpile @@ -102,6 +125,8 @@ def qiskit_compile( if isinstance(circuit, AbstractCircuit): circuit = circuit.to_qiskit(enable_instruction=True) + elif isinstance(circuit, str): + circuit = qiskit_from_qasm_str_ordered_measure(circuit) # else qiskit circuit circuit = _add_measure_all_if_none(circuit) if compiled_options is None: @@ -124,15 +149,21 @@ def qiskit_compile( else: raise ValueError("Unknown output format: %s" % output) - if info is False: - return r0 - r1 = {} - - ( - r1["positional_logical_mapping"], - r1["logical_physical_mapping"], - ) = _get_mappings_from_qiskit(ncircuit) + nlpm = _get_logical_physical_mapping_from_qiskit(ncircuit, circuit) + # new_logical_physical_mapping + if info is not None and "logical_physical_mapping" in info: + r1["logical_physical_mapping"] = { + k: nlpm[v] for k, v in info["logical_physical_mapping"].items() + } + else: + r1["logical_physical_mapping"] = nlpm + if info is not None and "positional_logical_mapping" in info: + r1["positional_logical_mapping"] = info["positional_logical_mapping"] + else: # info is none, assume circuit is the logical circuit + r1["positional_logical_mapping"] = _get_positional_logical_mapping_from_qiskit( + circuit + ) # TODO(@refraction-ray): more info to be added into r1 dict return (r0, r1) diff --git a/tests/test_compiler.py b/tests/test_compiler.py index 648a4413..17f59112 100644 --- a/tests/test_compiler.py +++ b/tests/test_compiler.py @@ -26,7 +26,7 @@ def test_qsikit_compiler(): c1, info = qiskit_compile( c, - info=True, + info=None, output="qasm", compiled_options={ "basis_gates": ["cz", "rz", "h"], @@ -43,7 +43,7 @@ def test_qsikit_compiler(): c.measure_instruction(1) c1, info = qiskit_compile( c, - info=True, + info=None, output="tc", compiled_options={ "basis_gates": ["cx", "rz", "h"], @@ -58,3 +58,15 @@ def test_qsikit_compiler(): print(c1.draw()) assert info["logical_physical_mapping"][1] in [0, 2] print(info) + c2, info2 = qiskit_compile( + c1, + info=info, + output="tc", + compiled_options={ + "basis_gates": ["cx", "rz", "h"], + "optimization_level": 3, + "coupling_map": [[0, 2], [2, 0], [1, 0], [0, 1]], + }, + ) + assert info2["positional_logical_mapping"] == {0: 1} + print(c2.draw()) From b89d1757ee0228d68228520d6d4cc3d13de013c6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 2 Feb 2023 11:22:06 +0800 Subject: [PATCH 276/725] fix some bugs on cloud part --- tensorcircuit/cloud/abstraction.py | 22 +++++++++++++++++++--- tensorcircuit/cloud/tencent.py | 6 ++++-- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 31cbd3ad..d145faf7 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -186,6 +186,19 @@ def list_properties(self) -> Dict[str, Any]: return list_properties(self.provider, self) + def native_gates(self) -> List[str]: + """ + List native gates supported for the device, str conforms qiskit convention + + :return: _description_ + :rtype: List[str] + """ + properties = self.list_properties() + + if "native_gates" in properties: + return properties["native_gates"] # type: ignore + return [] + def topology(self) -> List[Tuple[int, int]]: """ Get the bidirectional topology link list of the device @@ -423,9 +436,12 @@ def run(cs: Any, shots: Any) -> Any: readout_mit = self.readout_mit if mitigation_options is None: - mitigation_options = { - "logical_physical_mapping": self.details()["optimization"]["pairs"] - } + try: + mitigation_options = { + "logical_physical_mapping": self.details()["optimization"]["pairs"] + } + except KeyError: + mitigation_options = {} miti_count = readout_mit.apply_correction( r, list(range(nqubit)), **mitigation_options ) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index cdeb6510..55ac9ce8 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -65,6 +65,7 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An for bit in r["bits"]: bits_dict[bit["Qubit"]] = bit r["bits"] = bits_dict + r["native_gates"] = ["h", "rz", "x", "y", "z", "cx", "cz"] # handcoded return r # type: ignore else: raise ValueError("No device with the name: %s" % device) @@ -74,6 +75,7 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An {'id': '20xmon', 'type': 'CHIP', 'state': 'on', + 'native_gates': ["rz"] 'links': {(0, 1): { 'CZErrRate': 0.03, 'at': 1673605888}, ...}, 'bits': {0: { 'At': 1673605888, @@ -201,8 +203,8 @@ def c2qasm(c: Any, compiling: bool) -> str: from qiskit.circuit import QuantumCircuit if compiling is True: - s = qiskit_compile( - c, output="qasm", info=False, compiled_options=compiled_options + s, _ = qiskit_compile( + c, output="qasm", info=None, compiled_options=compiled_options ) else: if isinstance(c, QuantumCircuit): From b21194f05831ad89beb0b3a33261eb7d839fa10f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 2 Feb 2023 11:29:00 +0800 Subject: [PATCH 277/725] fix translation bug from eqasm --- CHANGELOG.md | 10 ++++++++++ tensorcircuit/translation.py | 5 +++++ 2 files changed, 15 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index bf820773..92ff354e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,12 @@ - Add experimental compiler module +- Make the compiler infra more ready for a pipeline compling + +- When translating to qiskit, multicontrol gate is manipulated specifically instead of a general unitary + +- Add qft blocks in template module + ### Fixed - Circuit nosify in noise model now support all circuit attributs apart from qubit number @@ -24,6 +30,10 @@ - Fix bug in `tc.quantum.quimb2qop` when mps is the input +- Fix bug in translation.py when qiskit is not installed + +- Rem results after `apply_correction` is now sorted + ## 0.7.0 ### Added diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index bf9a7420..72f73506 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -693,6 +693,11 @@ def eqasm2tc( exponent = int(inst_list[2][3:]) index = (int(inst_list[3][1:]),) c.rz(*index, theta=2 * np.pi / 2**exponent) # type: ignore + elif inst_list[2] == "Z/2": + c.rz(*index, theta=-np.pi / 2) # type: ignore + elif inst_list[2] == "-Z/2": + c.rz(*index, theta=np.pi / 2) # type: ignore + # TODO(@refraction-ray): Z/2 convention to be double checked else: gate_name = inst_list[2].lower() if len(inst_list) == 4: From 9bc9d2b80a8a24f35bde2b04c9f10f5c1939954b Mon Sep 17 00:00:00 2001 From: Zixuan Song <78847784+MarkSong535@users.noreply.github.com> Date: Thu, 2 Feb 2023 04:03:32 +0000 Subject: [PATCH 278/725] Add Tensorcircuit MacOS installation guide --- CHANGELOG.md | 2 + docs/source/cnconf.py | 1 + docs/source/conf.py | 1 + docs/source/contribs/development_MacARM.md | 71 ++++++++++++++++++++++ docs/source/contribs/development_MacM1.rst | 3 + requirements/requirements-dev.txt | 3 +- 6 files changed, 80 insertions(+), 1 deletion(-) create mode 100644 docs/source/contribs/development_MacARM.md diff --git a/CHANGELOG.md b/CHANGELOG.md index bf820773..6063f502 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,8 @@ - Add experimental compiler module +- Add Tensorcircuit MacOS (univerisal) installation guide + ### Fixed - Circuit nosify in noise model now support all circuit attributs apart from qubit number diff --git a/docs/source/cnconf.py b/docs/source/cnconf.py index 5c861ba1..627d69ff 100644 --- a/docs/source/cnconf.py +++ b/docs/source/cnconf.py @@ -48,6 +48,7 @@ "sphinx_copybutton", "nbsphinx", "toctree_filter", + 'myst_parser', ] autosectionlabel_prefix_document = True diff --git a/docs/source/conf.py b/docs/source/conf.py index 1688127c..1adf0dc9 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -49,6 +49,7 @@ "nbsphinx", "toctree_filter", "sphinx.ext.napoleon", + 'myst_parser', ] autosectionlabel_prefix_document = True diff --git a/docs/source/contribs/development_MacARM.md b/docs/source/contribs/development_MacARM.md new file mode 100644 index 00000000..080fb1f8 --- /dev/null +++ b/docs/source/contribs/development_MacARM.md @@ -0,0 +1,71 @@ +# Tensorcircuit Installation Guide on MacOS + +Contributed by Mark Song + +## Starting From Scratch +For completely new macos or macos without xcode and brew +### Install Xcode Command Line Tools +Need graphical access to the machine. + +Run `xcode-select --install` to install if on optimal internet. + +Or Download from [Apple](https://developer.apple.com/download/more/) Command Line Tools installation image then install if internet connection is weak. +## Install Miniconda +Due to the limitation of MacOS and packages, the lastest version of python does not always function as desired, thus miniconda installation is advised to solve the issues. +``` +curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh +bash ~/miniconda.sh -b -p $HOME/miniconda +source ~/miniconda/bin/activate +conda install -c apple tensorflow-deps +``` +## Install TC Prerequisites +``` +pip install numpy scipy tensornetwork networkx +``` +## Install TC Backends +There are four backends to choose from, Tensorflow, Jax, Torch. +### Install Jax, Pytorch, Qiskit, Cirq (Optional) +``` +pip install [Package Name] +``` +### Install Tensorflow (Optional) +#### Install Tensorflow +❗️ Tensorflow with MacOS optimization would not function correctly in version 2.11.0 and before. Do not use this version of tensorflow if you intented to train any machine learning model. + +FYI: Error can occur when machine learning training or gpu related code is involved + +⚠️ Tensorflow without macos optimization does not support Metal API and utilizing GPU (both intel chips and M-series chips) until at least tensorflow 2.11. +``` +conda config --add channels conda-forge +conda config --set channel_priority strict +conda create -n tc_venv python tensorflow=2.7 +``` +#### Verify Tensorflow Installation +``` +import tensorflow as tf + +cifar = tf.keras.datasets.cifar100 +(x_train, y_train), (x_test, y_test) = cifar.load_data() +model = tf.keras.applications.ResNet50( + include_top=True, + weights=None, + input_shape=(32, 32, 3), + classes=100,) + +loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) +model.compile(optimizer="adam", loss=loss_fn, metrics=["accuracy"]) +model.fit(x_train, y_train, epochs=5, batch_size=64) +``` +## Install Tensorcircuit +``` +pip install tensorcircuit +``` + +Comments: +Testing Platform +- Platform 1: + - MacOS Ventura 13.1 (Build version 22C65) + - M1 Ultra +- Platform 2: + - MacOS Ventura 13.2 (Build version 22D49) + - M1 Ultra (Virtual) \ No newline at end of file diff --git a/docs/source/contribs/development_MacM1.rst b/docs/source/contribs/development_MacM1.rst index e7a54454..7971e157 100644 --- a/docs/source/contribs/development_MacM1.rst +++ b/docs/source/contribs/development_MacM1.rst @@ -2,6 +2,9 @@ Run TensorCircuit on TensorlowBackend with Apple M1 ======================================================== Contributed by (Yuqin Chen) +This page is deprecated. Please visit `this page `_ for latest information. +-------------------------------------------------------------------------------------------------------------- + Why We Can't Run TensorCircuit on TensorlowBackend with Apple M1 ----------------------------------------------------------------------- TensorCircuit requires Tensorflow to support TensorflowBackend. However for Apple M1, Tensorflow package cannot be properly installed by a usual method like "pip install tensorflow". As well, the TensorCircuit package cannot be properly installed by a usual method "pip install tensorcircuit" diff --git a/requirements/requirements-dev.txt b/requirements/requirements-dev.txt index 7c7a73ed..5929ef0c 100644 --- a/requirements/requirements-dev.txt +++ b/requirements/requirements-dev.txt @@ -10,4 +10,5 @@ pylint==2.11.1 numpy==1.21.5 furo sphinx-copybutton -nbsphinx \ No newline at end of file +nbsphinx +myst-parser \ No newline at end of file From 002c9a8ded3f7b69a8a0603a50c744f2a58c923f Mon Sep 17 00:00:00 2001 From: Zixuan Song <78847784+MarkSong535@users.noreply.github.com> Date: Thu, 2 Feb 2023 04:54:01 +0000 Subject: [PATCH 279/725] Typo fix to the MacOS Installation guide --- docs/source/cnconf.py | 2 +- docs/source/conf.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/cnconf.py b/docs/source/cnconf.py index 627d69ff..8b01d026 100644 --- a/docs/source/cnconf.py +++ b/docs/source/cnconf.py @@ -48,7 +48,7 @@ "sphinx_copybutton", "nbsphinx", "toctree_filter", - 'myst_parser', + "myst_parser", ] autosectionlabel_prefix_document = True diff --git a/docs/source/conf.py b/docs/source/conf.py index 1adf0dc9..4f8e644e 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -49,7 +49,7 @@ "nbsphinx", "toctree_filter", "sphinx.ext.napoleon", - 'myst_parser', + "myst_parser", ] autosectionlabel_prefix_document = True From 8671134651be2cdc177259738fd78995538b0e16 Mon Sep 17 00:00:00 2001 From: Zixuan Song <78847784+MarkSong535@users.noreply.github.com> Date: Thu, 2 Feb 2023 05:05:26 +0000 Subject: [PATCH 280/725] Updated descriptions --- docs/source/contribs/development_MacARM.md | 7 +++---- docs/source/contribs/development_MacM1.rst | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/docs/source/contribs/development_MacARM.md b/docs/source/contribs/development_MacARM.md index 080fb1f8..251f1aac 100644 --- a/docs/source/contribs/development_MacARM.md +++ b/docs/source/contribs/development_MacARM.md @@ -1,6 +1,6 @@ # Tensorcircuit Installation Guide on MacOS -Contributed by Mark Song +Contributed by Mark (Zixuan) Song ## Starting From Scratch For completely new macos or macos without xcode and brew @@ -29,10 +29,10 @@ There are four backends to choose from, Tensorflow, Jax, Torch. pip install [Package Name] ``` ### Install Tensorflow (Optional) -#### Install Tensorflow +#### Install Tensorflow (Recommended Approach) ❗️ Tensorflow with MacOS optimization would not function correctly in version 2.11.0 and before. Do not use this version of tensorflow if you intented to train any machine learning model. -FYI: Error can occur when machine learning training or gpu related code is involved +FYI: Error can occur when machine learning training or gpu related code is involved. ⚠️ Tensorflow without macos optimization does not support Metal API and utilizing GPU (both intel chips and M-series chips) until at least tensorflow 2.11. ``` @@ -61,7 +61,6 @@ model.fit(x_train, y_train, epochs=5, batch_size=64) pip install tensorcircuit ``` -Comments: Testing Platform - Platform 1: - MacOS Ventura 13.1 (Build version 22C65) diff --git a/docs/source/contribs/development_MacM1.rst b/docs/source/contribs/development_MacM1.rst index 7971e157..cb6dfda4 100644 --- a/docs/source/contribs/development_MacM1.rst +++ b/docs/source/contribs/development_MacM1.rst @@ -2,7 +2,7 @@ Run TensorCircuit on TensorlowBackend with Apple M1 ======================================================== Contributed by (Yuqin Chen) -This page is deprecated. Please visit `this page `_ for latest information. +This page is deprecated. Please visit `the update tutorial `_ for latest information. -------------------------------------------------------------------------------------------------------------- Why We Can't Run TensorCircuit on TensorlowBackend with Apple M1 From f39605e691af02db6756e62ac9edd0ab61dcd72b Mon Sep 17 00:00:00 2001 From: Zixuan Song <78847784+MarkSong535@users.noreply.github.com> Date: Thu, 2 Feb 2023 05:10:01 +0000 Subject: [PATCH 281/725] Updated information --- docs/source/contribs/development_MacARM.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/contribs/development_MacARM.md b/docs/source/contribs/development_MacARM.md index 251f1aac..fe6e103a 100644 --- a/docs/source/contribs/development_MacARM.md +++ b/docs/source/contribs/development_MacARM.md @@ -34,7 +34,7 @@ pip install [Package Name] FYI: Error can occur when machine learning training or gpu related code is involved. -⚠️ Tensorflow without macos optimization does not support Metal API and utilizing GPU (both intel chips and M-series chips) until at least tensorflow 2.11. +⚠️ Tensorflow without macos optimization does not support Metal API and utilizing GPU (both intel chips and M-series chips) until at least tensorflow 2.11. Tensorflow-macos would fail when running `tc.backend.to_dense()` ``` conda config --add channels conda-forge conda config --set channel_priority strict From 58ec16de83aeb7568c097abcc0939a179eca8395 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 2 Feb 2023 13:46:54 +0800 Subject: [PATCH 282/725] improve the contrib doc --- docs/source/contribs/development_MacARM.md | 41 +++- docs/source/contribs/development_MacM1.rst | 6 +- docs/source/locale/zh/LC_MESSAGES/api.po | 38 +++- docs/source/locale/zh/LC_MESSAGES/contribs.po | 175 +++++++++++++++--- docs/source/locale/zh/LC_MESSAGES/index.po | 44 +++-- 5 files changed, 253 insertions(+), 51 deletions(-) diff --git a/docs/source/contribs/development_MacARM.md b/docs/source/contribs/development_MacARM.md index fe6e103a..ffddf582 100644 --- a/docs/source/contribs/development_MacARM.md +++ b/docs/source/contribs/development_MacARM.md @@ -3,44 +3,62 @@ Contributed by Mark (Zixuan) Song ## Starting From Scratch + For completely new macos or macos without xcode and brew + ### Install Xcode Command Line Tools -Need graphical access to the machine. + +Need graphical access to the machine. Run `xcode-select --install` to install if on optimal internet. -Or Download from [Apple](https://developer.apple.com/download/more/) Command Line Tools installation image then install if internet connection is weak. +Or Download from [Apple](https://developer.apple.com/download/more/) Command Line Tools installation image then install if internet connection is weak. + ## Install Miniconda + Due to the limitation of MacOS and packages, the lastest version of python does not always function as desired, thus miniconda installation is advised to solve the issues. + ``` curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh bash ~/miniconda.sh -b -p $HOME/miniconda source ~/miniconda/bin/activate conda install -c apple tensorflow-deps ``` + ## Install TC Prerequisites + ``` pip install numpy scipy tensornetwork networkx ``` + ## Install TC Backends -There are four backends to choose from, Tensorflow, Jax, Torch. + +There are four backends to choose from, Numpy, Tensorflow, Jax, Torch. + ### Install Jax, Pytorch, Qiskit, Cirq (Optional) + ``` pip install [Package Name] ``` + ### Install Tensorflow (Optional) + #### Install Tensorflow (Recommended Approach) + ❗️ Tensorflow with MacOS optimization would not function correctly in version 2.11.0 and before. Do not use this version of tensorflow if you intented to train any machine learning model. -FYI: Error can occur when machine learning training or gpu related code is involved. +FYI: Error can occur when machine learning training or gpu related code is involved. ⚠️ Tensorflow without macos optimization does not support Metal API and utilizing GPU (both intel chips and M-series chips) until at least tensorflow 2.11. Tensorflow-macos would fail when running `tc.backend.to_dense()` + ``` -conda config --add channels conda-forge +conda config --add channels conda-forge conda config --set channel_priority strict conda create -n tc_venv python tensorflow=2.7 ``` + #### Verify Tensorflow Installation + ``` import tensorflow as tf @@ -56,15 +74,18 @@ loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) model.compile(optimizer="adam", loss=loss_fn, metrics=["accuracy"]) model.fit(x_train, y_train, epochs=5, batch_size=64) ``` + ## Install Tensorcircuit + ``` pip install tensorcircuit ``` -Testing Platform +Testing Platform (Tested Feb 2023) + - Platform 1: - - MacOS Ventura 13.1 (Build version 22C65) - - M1 Ultra + - MacOS Ventura 13.1 (Build version 22C65) + - M1 Ultra - Platform 2: - - MacOS Ventura 13.2 (Build version 22D49) - - M1 Ultra (Virtual) \ No newline at end of file + - MacOS Ventura 13.2 (Build version 22D49) + - M1 Ultra (Virtual) diff --git a/docs/source/contribs/development_MacM1.rst b/docs/source/contribs/development_MacM1.rst index cb6dfda4..3df9c949 100644 --- a/docs/source/contribs/development_MacM1.rst +++ b/docs/source/contribs/development_MacM1.rst @@ -2,8 +2,10 @@ Run TensorCircuit on TensorlowBackend with Apple M1 ======================================================== Contributed by (Yuqin Chen) -This page is deprecated. Please visit `the update tutorial `_ for latest information. --------------------------------------------------------------------------------------------------------------- + +.. warning:: + This page is deprecated. Please visit `the update tutorial `_ for latest information. + Why We Can't Run TensorCircuit on TensorlowBackend with Apple M1 ----------------------------------------------------------------------- diff --git a/docs/source/locale/zh/LC_MESSAGES/api.po b/docs/source/locale/zh/LC_MESSAGES/api.po index 18d69e91..2481995c 100644 --- a/docs/source/locale/zh/LC_MESSAGES/api.po +++ b/docs/source/locale/zh/LC_MESSAGES/api.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-01-24 13:45+0800\n" +"POT-Creation-Date: 2023-02-02 13:41+0800\n" "PO-Revision-Date: 2022-04-13 14:58+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -604,6 +604,7 @@ msgstr "" #: tensorcircuit.simplify.pseudo_contract_between #: tensorcircuit.templates.blocks.Bell_pair_block #: tensorcircuit.templates.blocks.example_block +#: tensorcircuit.templates.blocks.qft #: tensorcircuit.templates.blocks.state_centric #: tensorcircuit.templates.chems.get_ps #: tensorcircuit.templates.graphs.Grid2DCoord.__init__ @@ -1439,6 +1440,7 @@ msgstr "" #: tensorcircuit.simplify.pseudo_contract_between #: tensorcircuit.templates.blocks.Bell_pair_block #: tensorcircuit.templates.blocks.example_block +#: tensorcircuit.templates.blocks.qft #: tensorcircuit.templates.blocks.state_centric #: tensorcircuit.templates.chems.get_ps #: tensorcircuit.templates.graphs.Grid2DCoord.all_cols @@ -2079,6 +2081,7 @@ msgstr "" #: tensorcircuit.simplify.pseudo_contract_between #: tensorcircuit.templates.blocks.Bell_pair_block #: tensorcircuit.templates.blocks.example_block +#: tensorcircuit.templates.blocks.qft #: tensorcircuit.templates.blocks.state_centric #: tensorcircuit.templates.chems.get_ps #: tensorcircuit.templates.graphs.Grid2DCoord.all_cols @@ -12915,11 +12918,11 @@ msgstr "" #: of tensorcircuit.cons.get_dtype:3 tensorcircuit.cons.set_dtype:3 msgid "" -"\"complex64\" or \"complex128\", defaults to None, which is equivalent to" -" \"complex64\"." +"\"complex64\"/\"float32\" or \"complex128\"/\"float64\", defaults to " +"None, which is equivalent to \"complex64\"." msgstr "" -#: of tensorcircuit.cons.get_dtype:5 tensorcircuit.cons.set_dtype:5 +#: of tensorcircuit.cons.get_dtype:6 tensorcircuit.cons.set_dtype:6 msgid "complex dtype str and the corresponding real dtype str" msgstr "" @@ -16165,6 +16168,7 @@ msgid "" msgstr "" #: of tensorcircuit.templates.blocks.Bell_pair_block:3 +#: tensorcircuit.templates.blocks.qft:3 msgid "Circuit in" msgstr "" @@ -16205,6 +16209,32 @@ msgstr "" msgid "The circuit with example ansatz attached" msgstr "" +#: of tensorcircuit.templates.blocks.qft:1 +msgid "" +"This function applies quantum fourier transformation (QFT) to the " +"selected circuit lines" +msgstr "" + +#: of tensorcircuit.templates.blocks.qft:5 +msgid "the indices of the circuit lines to apply QFT" +msgstr "" + +#: of tensorcircuit.templates.blocks.qft:7 +msgid "Whether to include the final swaps in the QFT" +msgstr "" + +#: of tensorcircuit.templates.blocks.qft:9 +msgid "If True, the inverse Fourier transform is constructed" +msgstr "" + +#: of tensorcircuit.templates.blocks.qft:11 +msgid "If True, barriers are inserted as visualization improvement" +msgstr "" + +#: of tensorcircuit.templates.blocks.qft:13 +msgid "Circuit c" +msgstr "" + #: of tensorcircuit.templates.blocks.state_centric:1 msgid "" "Function decorator wraps the function with the first input and output in " diff --git a/docs/source/locale/zh/LC_MESSAGES/contribs.po b/docs/source/locale/zh/LC_MESSAGES/contribs.po index f59a61f1..87b08294 100644 --- a/docs/source/locale/zh/LC_MESSAGES/contribs.po +++ b/docs/source/locale/zh/LC_MESSAGES/contribs.po @@ -9,7 +9,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit \n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-01-13 11:04+0800\n" +"POT-Creation-Date: 2023-02-02 13:41+0800\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" @@ -18,6 +18,133 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.9.1\n" +#: ../../source/contribs/development_MacARM.md:1 +msgid "Tensorcircuit Installation Guide on MacOS" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:3 +msgid "Contributed by Mark (Zixuan) Song" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:5 +msgid "Starting From Scratch" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:6 +msgid "For completely new macos or macos without xcode and brew" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:7 +msgid "Install Xcode Command Line Tools" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:8 +msgid "Need graphical access to the machine." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:10 +msgid "Run `xcode-select --install` to install if on optimal internet." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:12 +msgid "" +"Or Download from [Apple](https://developer.apple.com/download/more/) " +"Command Line Tools installation image then install if internet connection" +" is weak." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:13 +msgid "Install Miniconda" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:14 +msgid "" +"Due to the limitation of MacOS and packages, the lastest version of " +"python does not always function as desired, thus miniconda installation " +"is advised to solve the issues." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:21 +msgid "Install TC Prerequisites" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:25 +msgid "Install TC Backends" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:26 +msgid "There are four backends to choose from, Tensorflow, Jax, Torch." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:27 +msgid "Install Jax, Pytorch, Qiskit, Cirq (Optional)" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:31 +msgid "Install Tensorflow (Optional)" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:32 +msgid "Install Tensorflow (Recommended Approach)" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:33 +msgid "" +"❗️ Tensorflow with MacOS optimization would not function correctly in " +"version 2.11.0 and before. Do not use this version of tensorflow if you " +"intented to train any machine learning model." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:35 +msgid "" +"FYI: Error can occur when machine learning training or gpu related code " +"is involved." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:37 +msgid "" +"⚠️ Tensorflow without macos optimization does not support Metal API and " +"utilizing GPU (both intel chips and M-series chips) until at least " +"tensorflow 2.11. Tensorflow-macos would fail when running " +"`tc.backend.to_dense()`" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:43 +msgid "Verify Tensorflow Installation" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:59 +msgid "Install Tensorcircuit" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:64 +msgid "Testing Platform" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:65 +msgid "Platform 1:" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:66 +msgid "MacOS Ventura 13.1 (Build version 22C65)" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:67 +msgid "M1 Ultra" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:68 +msgid "Platform 2:" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:69 +msgid "MacOS Ventura 13.2 (Build version 22D49)" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:70 +msgid "M1 Ultra (Virtual)" +msgstr "" + #: ../../source/contribs/development_MacM1.rst:2 msgid "Run TensorCircuit on TensorlowBackend with Apple M1" msgstr "" @@ -26,11 +153,17 @@ msgstr "" msgid "Contributed by (Yuqin Chen)" msgstr "" -#: ../../source/contribs/development_MacM1.rst:6 +#: ../../source/contribs/development_MacM1.rst:7 +msgid "" +"This page is deprecated. Please visit `the update tutorial " +"`_ for latest information." +msgstr "" + +#: ../../source/contribs/development_MacM1.rst:11 msgid "Why We Can't Run TensorCircuit on TensorlowBackend with Apple M1" msgstr "" -#: ../../source/contribs/development_MacM1.rst:7 +#: ../../source/contribs/development_MacM1.rst:12 msgid "" "TensorCircuit requires Tensorflow to support TensorflowBackend. However " "for Apple M1, Tensorflow package cannot be properly installed by a usual " @@ -41,11 +174,11 @@ msgid "" " it." msgstr "" -#: ../../source/contribs/development_MacM1.rst:11 +#: ../../source/contribs/development_MacM1.rst:16 msgid "Install tensorflow on Apple M1" msgstr "" -#: ../../source/contribs/development_MacM1.rst:12 +#: ../../source/contribs/development_MacM1.rst:17 msgid "" "According to the instructions below or the installation manual on Apple's" " official website `tensorflow-metal PluggableDevice " @@ -53,59 +186,59 @@ msgid "" " tensorflow step by step." msgstr "" -#: ../../source/contribs/development_MacM1.rst:14 +#: ../../source/contribs/development_MacM1.rst:19 msgid "**Step1: Environment setup**" msgstr "" -#: ../../source/contribs/development_MacM1.rst:16 +#: ../../source/contribs/development_MacM1.rst:21 msgid "x86 : AMD Create virtual environment (recommended):" msgstr "" -#: ../../source/contribs/development_MacM1.rst:27 +#: ../../source/contribs/development_MacM1.rst:32 msgid "NOTE: python version 3.8 required" msgstr "" -#: ../../source/contribs/development_MacM1.rst:29 +#: ../../source/contribs/development_MacM1.rst:34 msgid "arm64 : Apple Silicon" msgstr "" -#: ../../source/contribs/development_MacM1.rst:31 +#: ../../source/contribs/development_MacM1.rst:36 msgid "Download and install Conda env:" msgstr "" -#: ../../source/contribs/development_MacM1.rst:41 +#: ../../source/contribs/development_MacM1.rst:46 msgid "Install the TensorFlow dependencies:" msgstr "" -#: ../../source/contribs/development_MacM1.rst:47 +#: ../../source/contribs/development_MacM1.rst:52 msgid "When upgrading to new base TensorFlow version, recommend:" msgstr "" -#: ../../source/contribs/development_MacM1.rst:65 +#: ../../source/contribs/development_MacM1.rst:70 msgid "tensorflow-deps versions are following base TensorFlow versions so:" msgstr "" -#: ../../source/contribs/development_MacM1.rst:67 +#: ../../source/contribs/development_MacM1.rst:72 msgid "for v2.5" msgstr "" -#: ../../source/contribs/development_MacM1.rst:75 +#: ../../source/contribs/development_MacM1.rst:80 msgid "for v2.6" msgstr "" -#: ../../source/contribs/development_MacM1.rst:82 +#: ../../source/contribs/development_MacM1.rst:87 msgid "**Step2: Install base TensorFlow**" msgstr "" -#: ../../source/contribs/development_MacM1.rst:88 +#: ../../source/contribs/development_MacM1.rst:93 msgid "**Step3: Install tensorflow-metal plugin**" msgstr "" -#: ../../source/contribs/development_MacM1.rst:96 +#: ../../source/contribs/development_MacM1.rst:101 msgid "Install TensorCircuit on Apple M1" msgstr "" -#: ../../source/contribs/development_MacM1.rst:97 +#: ../../source/contribs/development_MacM1.rst:102 msgid "" "After properly install tensorflow, you can continue install " "TensorCircuit. Up to now, for Apple M1, the Tensorcircuit package can not" @@ -115,11 +248,11 @@ msgid "" "installation proceess can recognize the Apple M1 environment." msgstr "" -#: ../../source/contribs/development_MacM1.rst:102 +#: ../../source/contribs/development_MacM1.rst:107 msgid "One should download the TensorCircuit package to local at first." msgstr "" -#: ../../source/contribs/development_MacM1.rst:109 +#: ../../source/contribs/development_MacM1.rst:114 msgid "Then unpackage it, and cd into the folder with \"setup.py\". Conducting" msgstr "" diff --git a/docs/source/locale/zh/LC_MESSAGES/index.po b/docs/source/locale/zh/LC_MESSAGES/index.po index 681cb7ec..1ee54686 100644 --- a/docs/source/locale/zh/LC_MESSAGES/index.po +++ b/docs/source/locale/zh/LC_MESSAGES/index.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-01-24 13:45+0800\n" +"POT-Creation-Date: 2023-02-02 13:41+0800\n" "PO-Revision-Date: 2022-04-16 22:37+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -59,11 +59,12 @@ msgstr "重要链接" #: ../../source/index.rst:22 msgid "" -"This project is released by `Tencent Quantum Lab " -"`_ and is created and maintained by `Shi-" -"Xin Zhang `_ The current core authors " -"are `Shi-Xin Zhang `_ and `Yu-Qin Chen" -" `_. We also thank `contributions " +"TensorCircuit is created and maintained by `Shi-Xin Zhang " +"`_ and this version of the software is" +" released by `Tencent Quantum Lab `_. The " +"current core authors of TensorCircuit are `Shi-Xin Zhang " +"`_ and `Yu-Qin Chen " +"`_. We also thank `contributions " "`_ from the lab and the open source" " community." @@ -74,20 +75,21 @@ msgid "Source code: https://github.com/tencent-quantum-lab/tensorcircuit" msgstr "源代码: https://github.com/tencent-quantum-lab/tensorcircuit" #: ../../source/index.rst:28 -msgid "Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues" -msgstr "问题跟踪: https://github.com/tencent-quantum-lab/tensorcircuit/issues" +#, fuzzy +msgid "Software Whitepaper: https://arxiv.org/abs/2205.10091" +msgstr "白皮书文章: https://arxiv.org/abs/2205.10091" #: ../../source/index.rst:30 -msgid "Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" -msgstr "论坛社区: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" - -#: ../../source/index.rst:32 msgid "Documentation: https://tensorcircuit.readthedocs.io" msgstr "文档: https://tensorcircuit.readthedocs.io" +#: ../../source/index.rst:32 +msgid "Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues" +msgstr "问题跟踪: https://github.com/tencent-quantum-lab/tensorcircuit/issues" + #: ../../source/index.rst:34 -msgid "Whitepaper: https://arxiv.org/abs/2205.10091" -msgstr "白皮书文章: https://arxiv.org/abs/2205.10091" +msgid "Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" +msgstr "论坛社区: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" #: ../../source/index.rst:36 msgid "PyPI page: https://pypi.org/project/tensorcircuit" @@ -152,3 +154,17 @@ msgstr ":ref:`search`" #~ "pull?repo=https://github.com/tencent-quantum-" #~ "lab/tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" +#~ msgid "" +#~ "This project is released by `Tencent " +#~ "Quantum Lab `_ and " +#~ "is created and maintained by `Shi-" +#~ "Xin Zhang `_ " +#~ "The current core authors are `Shi-" +#~ "Xin Zhang `_ " +#~ "and `Yu-Qin Chen " +#~ "`_. We also thank " +#~ "`contributions `_ from the " +#~ "lab and the open source community." +#~ msgstr "" + From 859fe04173fa0c7132834d4fd30eb7653f3ffdbe Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 2 Feb 2023 14:21:18 +0800 Subject: [PATCH 283/725] add installation section in quick start --- docs/source/locale/zh/LC_MESSAGES/api.po | 16 +- docs/source/locale/zh/LC_MESSAGES/contribs.po | 79 +++-- .../locale/zh/LC_MESSAGES/quickstart.po | 288 +++++++++++------- docs/source/quickstart.rst | 35 +++ 4 files changed, 273 insertions(+), 145 deletions(-) diff --git a/docs/source/locale/zh/LC_MESSAGES/api.po b/docs/source/locale/zh/LC_MESSAGES/api.po index 2481995c..ce19c1ca 100644 --- a/docs/source/locale/zh/LC_MESSAGES/api.po +++ b/docs/source/locale/zh/LC_MESSAGES/api.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-02-02 13:41+0800\n" +"POT-Creation-Date: 2023-02-02 14:19+0800\n" "PO-Revision-Date: 2022-04-13 14:58+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -12849,14 +12849,6 @@ msgstr "" msgid "The result of :math:`\\langle bra\\vert ops \\vert ket\\rangle`." msgstr "" -#: ../../source/api/cloud.rst:2 -msgid "tensorcircuit.cloud" -msgstr "" - -#: ../../source/api/cloud/config.rst:2 -msgid "tensorcircuit.cloud.config" -msgstr "" - #: ../../source/api/compiler.rst:2 msgid "tensorcircuit.compiler" msgstr "" @@ -22105,3 +22097,9 @@ msgstr "" #~ msgid "calibration qubit list" #~ msgstr "" +#~ msgid "tensorcircuit.cloud" +#~ msgstr "" + +#~ msgid "tensorcircuit.cloud.config" +#~ msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/contribs.po b/docs/source/locale/zh/LC_MESSAGES/contribs.po index 87b08294..cb11a0fd 100644 --- a/docs/source/locale/zh/LC_MESSAGES/contribs.po +++ b/docs/source/locale/zh/LC_MESSAGES/contribs.po @@ -9,7 +9,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit \n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-02-02 13:41+0800\n" +"POT-Creation-Date: 2023-02-02 14:19+0800\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" @@ -30,78 +30,78 @@ msgstr "" msgid "Starting From Scratch" msgstr "" -#: ../../source/contribs/development_MacARM.md:6 +#: ../../source/contribs/development_MacARM.md:7 msgid "For completely new macos or macos without xcode and brew" msgstr "" -#: ../../source/contribs/development_MacARM.md:7 +#: ../../source/contribs/development_MacARM.md:9 msgid "Install Xcode Command Line Tools" msgstr "" -#: ../../source/contribs/development_MacARM.md:8 +#: ../../source/contribs/development_MacARM.md:11 msgid "Need graphical access to the machine." msgstr "" -#: ../../source/contribs/development_MacARM.md:10 +#: ../../source/contribs/development_MacARM.md:13 msgid "Run `xcode-select --install` to install if on optimal internet." msgstr "" -#: ../../source/contribs/development_MacARM.md:12 +#: ../../source/contribs/development_MacARM.md:15 msgid "" -"Or Download from [Apple](https://developer.apple.com/download/more/) " +"Or Download from [Apple](https://developer.apple.com/download/more/) " "Command Line Tools installation image then install if internet connection" " is weak." msgstr "" -#: ../../source/contribs/development_MacARM.md:13 +#: ../../source/contribs/development_MacARM.md:17 msgid "Install Miniconda" msgstr "" -#: ../../source/contribs/development_MacARM.md:14 +#: ../../source/contribs/development_MacARM.md:19 msgid "" "Due to the limitation of MacOS and packages, the lastest version of " "python does not always function as desired, thus miniconda installation " "is advised to solve the issues." msgstr "" -#: ../../source/contribs/development_MacARM.md:21 +#: ../../source/contribs/development_MacARM.md:28 msgid "Install TC Prerequisites" msgstr "" -#: ../../source/contribs/development_MacARM.md:25 +#: ../../source/contribs/development_MacARM.md:34 msgid "Install TC Backends" msgstr "" -#: ../../source/contribs/development_MacARM.md:26 -msgid "There are four backends to choose from, Tensorflow, Jax, Torch." +#: ../../source/contribs/development_MacARM.md:36 +msgid "There are four backends to choose from, Numpy, Tensorflow, Jax, Torch." msgstr "" -#: ../../source/contribs/development_MacARM.md:27 +#: ../../source/contribs/development_MacARM.md:38 msgid "Install Jax, Pytorch, Qiskit, Cirq (Optional)" msgstr "" -#: ../../source/contribs/development_MacARM.md:31 +#: ../../source/contribs/development_MacARM.md:44 msgid "Install Tensorflow (Optional)" msgstr "" -#: ../../source/contribs/development_MacARM.md:32 +#: ../../source/contribs/development_MacARM.md:46 msgid "Install Tensorflow (Recommended Approach)" msgstr "" -#: ../../source/contribs/development_MacARM.md:33 +#: ../../source/contribs/development_MacARM.md:48 msgid "" "❗️ Tensorflow with MacOS optimization would not function correctly in " "version 2.11.0 and before. Do not use this version of tensorflow if you " "intented to train any machine learning model." msgstr "" -#: ../../source/contribs/development_MacARM.md:35 +#: ../../source/contribs/development_MacARM.md:50 msgid "" -"FYI: Error can occur when machine learning training or gpu related code " +"FYI: Error can occur when machine learning training or gpu related code " "is involved." msgstr "" -#: ../../source/contribs/development_MacARM.md:37 +#: ../../source/contribs/development_MacARM.md:52 msgid "" "⚠️ Tensorflow without macos optimization does not support Metal API and " "utilizing GPU (both intel chips and M-series chips) until at least " @@ -109,39 +109,39 @@ msgid "" "`tc.backend.to_dense()`" msgstr "" -#: ../../source/contribs/development_MacARM.md:43 +#: ../../source/contribs/development_MacARM.md:60 msgid "Verify Tensorflow Installation" msgstr "" -#: ../../source/contribs/development_MacARM.md:59 +#: ../../source/contribs/development_MacARM.md:78 msgid "Install Tensorcircuit" msgstr "" -#: ../../source/contribs/development_MacARM.md:64 -msgid "Testing Platform" +#: ../../source/contribs/development_MacARM.md:84 +msgid "Testing Platform (Tested Feb 2023)" msgstr "" -#: ../../source/contribs/development_MacARM.md:65 +#: ../../source/contribs/development_MacARM.md:86 msgid "Platform 1:" msgstr "" -#: ../../source/contribs/development_MacARM.md:66 +#: ../../source/contribs/development_MacARM.md:87 msgid "MacOS Ventura 13.1 (Build version 22C65)" msgstr "" -#: ../../source/contribs/development_MacARM.md:67 +#: ../../source/contribs/development_MacARM.md:88 msgid "M1 Ultra" msgstr "" -#: ../../source/contribs/development_MacARM.md:68 +#: ../../source/contribs/development_MacARM.md:89 msgid "Platform 2:" msgstr "" -#: ../../source/contribs/development_MacARM.md:69 +#: ../../source/contribs/development_MacARM.md:90 msgid "MacOS Ventura 13.2 (Build version 22D49)" msgstr "" -#: ../../source/contribs/development_MacARM.md:70 +#: ../../source/contribs/development_MacARM.md:91 msgid "M1 Ultra (Virtual)" msgstr "" @@ -647,3 +647,22 @@ msgstr "" msgid "Tips: Currently, we don't suggest you to use TPU accelerator." msgstr "" +#~ msgid "" +#~ "Or Download from " +#~ "[Apple](https://developer.apple.com/download/more/) Command " +#~ "Line Tools installation image then " +#~ "install if internet connection is weak." +#~ msgstr "" + +#~ msgid "There are four backends to choose from, Tensorflow, Jax, Torch." +#~ msgstr "" + +#~ msgid "" +#~ "FYI: Error can occur when machine " +#~ "learning training or gpu related code" +#~ " is involved." +#~ msgstr "" + +#~ msgid "Testing Platform" +#~ msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/quickstart.po b/docs/source/locale/zh/LC_MESSAGES/quickstart.po index 6290e6dc..fb97d394 100644 --- a/docs/source/locale/zh/LC_MESSAGES/quickstart.po +++ b/docs/source/locale/zh/LC_MESSAGES/quickstart.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-01-13 11:04+0800\n" +"POT-Creation-Date: 2023-02-02 14:19+0800\n" "PO-Revision-Date: 2022-04-11 08:23+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -22,23 +22,99 @@ msgstr "" msgid "Quick Start" msgstr "快速上手" -#: ../../source/quickstart.rst:7 +#: ../../source/quickstart.rst:6 +msgid "Installation" +msgstr "" + +#: ../../source/quickstart.rst:8 +msgid "For x86 Linux or Mac," +msgstr "" + +#: ../../source/quickstart.rst:10 +msgid "``pip install tensorcircuit``" +msgstr "" + +#: ../../source/quickstart.rst:12 +msgid "" +"is in general enough. Either pip from conda or other python env managers " +"is fine." +msgstr "" + +#: ../../source/quickstart.rst:15 +msgid "" +"Since there are many optional packages for various features, the users " +"may need to install more pip packages when required." +msgstr "" + +#: ../../source/quickstart.rst:18 +msgid "For Linux with Nvidia GPU," +msgstr "" + +#: ../../source/quickstart.rst:19 +msgid "" +"please refer to the GPU aware installation guide of corresponding machine" +" learning frameworks: `TensorFlow " +"`_, `Jax " +"`_, or `PyTorch " +"`_." +msgstr "" + +#: ../../source/quickstart.rst:24 +msgid "Docker is also recommended (especially Linux + Nvidia GPU setup):" +msgstr "" + +#: ../../source/quickstart.rst:26 +msgid "" +"``sudo docker run -it --network host --gpus all " +"tensorcircuit/tensorcircuit``." +msgstr "" + +#: ../../source/quickstart.rst:28 +msgid "" +"For Windows, due to the lack of support for Jax, we recommend to use " +"docker or WSL, please refer to `TC via windows docker " +"`_ or `TC via WSL " +"`_." +msgstr "" + +#: ../../source/quickstart.rst:30 +msgid "" +"For Mac with M series chips (arm architecture), please refer to `TC on " +"Mac M series `_." +msgstr "" + +#: ../../source/quickstart.rst:32 +msgid "" +"Overall, the installation of TensorCircuit is simple, since it is purely " +"in Python and hence very portable. As long as the users can take care of " +"the installation of ML frameworks on the corresponding system, " +"TensorCircuit will work as expected." +msgstr "" + +#: ../../source/quickstart.rst:36 +msgid "" +"We also provide a nightly build of tensorcircuit via PyPI which can be " +"accessed by ``pip uninstall tensorcircuit``, then ``pip install " +"tensorcircuit-nightly``" +msgstr "" + +#: ../../source/quickstart.rst:42 msgid "Circuit Object" msgstr "电路对象" -#: ../../source/quickstart.rst:9 +#: ../../source/quickstart.rst:44 msgid "The basic object for TensorCircuit is ``tc.Circuit``." msgstr "TensorCircuit的基本对象是 ``tc.Circuit``。" -#: ../../source/quickstart.rst:11 +#: ../../source/quickstart.rst:46 msgid "Initialize the circuit with the number of qubits ``c=tc.Circuit(n)``." msgstr "用量子比特数(n) ``c=tc.Circuit(n)`` 来初始化电路。" -#: ../../source/quickstart.rst:13 +#: ../../source/quickstart.rst:48 msgid "**Input States:**" msgstr "**输入状态:**" -#: ../../source/quickstart.rst:15 +#: ../../source/quickstart.rst:50 msgid "" "The default input function for the circuit is :math:`\\vert 0^n " "\\rangle`. One can change this to other wavefunctions by directly feeding" @@ -47,17 +123,17 @@ msgstr "" "电路的默认输入函数是 :math:`\\vert 0^n \\rangle` 。可以通过直接输入输入状态向量 w 将其更改为其他波函数: " "``c=tc.Circuit(n, inputs=w)``。" -#: ../../source/quickstart.rst:17 +#: ../../source/quickstart.rst:52 msgid "" "One can also feed matrix product states as input states for the circuit, " "but we leave MPS/MPO usage for future sections." msgstr "也可以将矩阵乘积状态作为电路的输入状态，但我们将矩阵乘积状态/矩阵乘积算子的使用留待后续讲解。" -#: ../../source/quickstart.rst:19 +#: ../../source/quickstart.rst:54 msgid "**Quantum Gates:**" msgstr "**量子门:**" -#: ../../source/quickstart.rst:21 +#: ../../source/quickstart.rst:56 msgid "" "We can apply gates on circuit objects. For example, using ``c.H(1)`` or " "``c.rx(2, theta=0.2)``, we can apply Hadamard gate on qubit 1 (0-based) " @@ -66,15 +142,15 @@ msgstr "" "我们可以将门应用于电路对象。 例如，使用 ``c.H(1)`` 或 ``c.rx(2, theta=0.2)``，我们可以将 Hadamard " "门应用于量子比特1 （基于0）或将 Rx 门应用于量子比特2 :math:`e^{-i\\theta/2 X}`。" -#: ../../source/quickstart.rst:23 +#: ../../source/quickstart.rst:58 msgid "The same rule also applies to multi-qubit gates, such as ``c.cnot(0, 1)``." msgstr "同样的规则亦适用于多量子比特门，例如 ``c.cnot(0, 1)`` 。" -#: ../../source/quickstart.rst:25 +#: ../../source/quickstart.rst:60 msgid "There are also highly customizable gates, two instances are:" msgstr "这些量子门也是高度可定制的，下面是两个例子" -#: ../../source/quickstart.rst:27 +#: ../../source/quickstart.rst:62 msgid "" "``c.exp1(0, 1, unitary=m, theta=0.2)`` which is for the exponential gate " ":math:`e^{i\\theta m}` of any matrix m as long as :math:`m^2=1`." @@ -82,33 +158,33 @@ msgstr "" "``c.exp1(0, 1, unitary=m, theta=0.2)`` 用于任何矩阵 m 的指数门 :math:`e^{i\\theta " "m}`，只要 m 满足 :math:`m^2=1`。" -#: ../../source/quickstart.rst:29 +#: ../../source/quickstart.rst:64 msgid "" "``c.any(0, 1, unitary=m)`` which is for applying the unitary gate m on " "the circuit." msgstr "``c.any(0, 1, unitary=m)`` 在电路上作用任意的幺正量子门。" -#: ../../source/quickstart.rst:31 +#: ../../source/quickstart.rst:66 msgid "These two examples are flexible and support gates on any number of qubits." msgstr "这两个例子很灵活，支持任意数量的量子比特上的门。" -#: ../../source/quickstart.rst:33 +#: ../../source/quickstart.rst:68 msgid "**Measurements and Expectations:**" msgstr "**测量与期望**" -#: ../../source/quickstart.rst:35 +#: ../../source/quickstart.rst:70 msgid "" "The most straightforward way to get the output from the circuit object is" " by getting the output wavefunction in vector form as ``c.state()``." msgstr "从电路对象中获取输出的最直接的方法是通过 ``c.state()`` 以向量形式获取输出波函数。" -#: ../../source/quickstart.rst:37 +#: ../../source/quickstart.rst:72 msgid "" "For bitstring sampling, we have ``c.perfect_sampling()`` which returns " "the bitstring and the corresponding probability amplitude." msgstr "对于位串采样，我们有 ``c.perfect_sampling()``，它返回位串和相应的概率幅度。" -#: ../../source/quickstart.rst:39 +#: ../../source/quickstart.rst:74 msgid "" "To measure part of the qubits, we can use ``c.measure(0, 1)``, if we want" " to know the corresponding probability of the measurement output, try " @@ -119,18 +195,18 @@ msgstr "" "``c.measure(0, 1, with_prob=True)``。 测量 API 在默认情况下是不可即时编译的 " "，但我们也有一个可即时编译的版本，如 ``c.measure_jit(0, 1)``。" -#: ../../source/quickstart.rst:41 +#: ../../source/quickstart.rst:76 msgid "" "The measurement and sampling utilize advanced algorithms based on " "tensornetwork and thus require no knowledge or space for the full " "wavefunction." msgstr "测量和采样使用了基于张量网络的高级算法，因此不需要任何相关知识或者空间来获取全波函数。" -#: ../../source/quickstart.rst:43 +#: ../../source/quickstart.rst:78 msgid "See the example below:" msgstr "请看下面的例子：" -#: ../../source/quickstart.rst:61 +#: ../../source/quickstart.rst:96 msgid "" "To compute expectation values for local observables, we have " "``c.expectation([tc.gates.z(), [0]], [tc.gates.z(), [1]])`` for " @@ -142,35 +218,35 @@ msgstr "" "``c.expectation([tc.gates.x(), [0]])`` 对应的期望为 :math:`\\langle X_0 " "\\rangle`时." -#: ../../source/quickstart.rst:63 +#: ../../source/quickstart.rst:98 msgid "" "This expectation API is rather flexible, as one can measure an m on " "several qubits as ``c.expectation([m, [0, 1, 2]])``." msgstr "因为可以在几个量子比特上测量一个 m，这种计算期望值的 API 相当灵活：``c.expectation([m, [0, 1, 2]])``。" -#: ../../source/quickstart.rst:65 +#: ../../source/quickstart.rst:100 msgid "" "We can also extract the unitary matrix underlying the whole circuit as " "follows:" msgstr "我们还可以提取整个电路下面的幺正矩阵，如下所示：" -#: ../../source/quickstart.rst:78 +#: ../../source/quickstart.rst:113 msgid "**Circuit Transformations:**" msgstr "**电路可视化**" -#: ../../source/quickstart.rst:80 +#: ../../source/quickstart.rst:115 msgid "" "We currently support transform ``tc.Circuit`` from and to Qiskit " "``QuantumCircuit`` object." msgstr "我们目前支持 ``tc.Circuit`` 与 Qiskit ``QuantumCircuit`` 对象之间的互相转换。" -#: ../../source/quickstart.rst:82 +#: ../../source/quickstart.rst:117 msgid "" "Export to Qiskit (possible for further hardware experiment, compiling, " "and visualization): ``c.to_qiskit()``." msgstr "导出到 Qiskit（可能用于进一步的硬件实验、编译和可视化）：``c.to_qiskit()``。" -#: ../../source/quickstart.rst:84 +#: ../../source/quickstart.rst:119 msgid "" "Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``. " "Parameterized Qiskit circuit is supported by passing the parameters to " @@ -178,11 +254,11 @@ msgid "" "similar to the ``assign_parameters`` function in Qiskit." msgstr "" -#: ../../source/quickstart.rst:88 +#: ../../source/quickstart.rst:123 msgid "**Circuit Visualization:**" msgstr "**电路可视化**" -#: ../../source/quickstart.rst:90 +#: ../../source/quickstart.rst:125 msgid "" "``c.vis_tex()`` can generate tex code for circuit visualization based on " "LaTeX `quantikz `__ package." @@ -190,14 +266,14 @@ msgstr "" "``c.vis_tex()`` 可以基于 `quantikz `__ " "package 生成用于电路可视化的 tex 代码。" -#: ../../source/quickstart.rst:92 +#: ../../source/quickstart.rst:127 msgid "" "There are also some automatic pipeline helper functions to directly " "generate figures from tex code, but they require extra installations in " "the environment." msgstr "还有一些自动辅助函数可以直接从 tex 代码生成图形，但它们需要在环境中进行额外安装。" -#: ../../source/quickstart.rst:94 +#: ../../source/quickstart.rst:129 msgid "" "``render_pdf(tex)`` function requires full installation of LaTeX locally." " And in the Jupyter environment, we may prefer ``render_pdf(tex, " @@ -209,7 +285,7 @@ msgstr "" "``render_pdf(tex, notebook=True)`` 来返回 jpg 图形，这需要安装 wand magicwand 库，请参阅 " "`这里 `__ 。" -#: ../../source/quickstart.rst:96 +#: ../../source/quickstart.rst:131 msgid "" "Or since we can transform ``tc.Circuit`` into QuantumCircuit easily, we " "have a simple pipeline to first transform ``tc.Circuit`` into Qiskit and " @@ -220,18 +296,18 @@ msgstr "" "或者因为我们可以轻松地将 ``tc.Circuit`` 转换为 QuantumCircuit，我们有一个简单的管道来首先转换 " "``tc.Circuit`` 为 Qiskit，然后调用 Qiskit 中内置的可视化。 也就是说，我们有 ``c.draw()`` API。" -#: ../../source/quickstart.rst:98 +#: ../../source/quickstart.rst:133 msgid "**Circuit Intermediate Representation:**" msgstr "**电路中间表示:**" -#: ../../source/quickstart.rst:100 +#: ../../source/quickstart.rst:135 msgid "" "TensorCircuit provides its own circuit IR as a python list of dicts. This" " IR can be further utilized to run compiling, generate serialization " "qasm, or render circuit figures." msgstr "TensorCircuit 提供自己的中间表示是元素是字典的列表。此中间表示可进一步用于运行编译、生成序列化 qasm 或渲染电路图。" -#: ../../source/quickstart.rst:102 +#: ../../source/quickstart.rst:137 msgid "" "The IR is given as a list, each element is a dict containing information " "on one gate that is applied to the circuit. Note gate attr in the dict is" @@ -240,18 +316,18 @@ msgstr "" "中间表示以列表形式给出，每个元素都是一个字典，其中包含应用于电路的一个量子门的信息。 注意字典中的 gate atrr " "实际上是一个返回此量子门的节点的 python 函数。" -#: ../../source/quickstart.rst:114 +#: ../../source/quickstart.rst:149 msgid "Programming Paradigm" msgstr "编程范式" -#: ../../source/quickstart.rst:116 +#: ../../source/quickstart.rst:151 msgid "" "The most common case and the most typical programming paradigm for " "TensorCircuit are to evaluate the circuit output and the corresponding " "quantum gradients, which is common in variational quantum algorithms." msgstr "TensorCircuit 最常见的情况和最典型的编程范式是评估电路的输出以及相应的量子梯度，这在变分量子算法中很常见。" -#: ../../source/quickstart.rst:143 +#: ../../source/quickstart.rst:178 #, fuzzy msgid "" "Also for a non-quantum example (linear regression) demonstrating the " @@ -268,7 +344,7 @@ msgstr "" "dev/blob/master/examples/universal_lr.py>`_ 。 " "这个例子可能对机器学习的用户更友好，因为它纯粹是经典的，同时也展示了 TensorCircuit 的主要特征和范式。" -#: ../../source/quickstart.rst:146 +#: ../../source/quickstart.rst:181 msgid "" "If the user has no intention to maintain the application code in a " "backend agnostic fashion, the API for ML frameworks can be more handily " @@ -277,11 +353,11 @@ msgstr "" "如果用户无意以与后端无关的方式维护应用程序代码，则可以更方便地使用用于机器学习框架的 API 并将其与 TensorCircuit API " "交替使用。" -#: ../../source/quickstart.rst:181 +#: ../../source/quickstart.rst:216 msgid "Automatic Differentiation, JIT, and Vectorized Parallelism" msgstr "自动微分、即时编译和矢量化并行 " -#: ../../source/quickstart.rst:183 +#: ../../source/quickstart.rst:218 msgid "" "For concepts of AD, JIT and VMAP, please refer to `Jax documentation " "`__ ." @@ -289,7 +365,7 @@ msgstr "" "关于自动微分、即时编译和向量并行化，请参考 `Jax 文档 " "`__ 。" -#: ../../source/quickstart.rst:185 +#: ../../source/quickstart.rst:220 msgid "" "The related API design in TensorCircuit closely follows the functional " "programming design pattern in Jax with some slight differences. So we " @@ -299,21 +375,21 @@ msgstr "" "TensorCircuit 中的相关 API 设计与 Jax 中的函数式编程的设计模式密切相关，但是略有不同。因此，我们强烈建议用户学习一些有关 " "Jax 的基础知识，无论他们打算使用哪种机器学习后端。" -#: ../../source/quickstart.rst:187 +#: ../../source/quickstart.rst:222 msgid "**AD Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:189 +#: ../../source/quickstart.rst:224 msgid "" "Gradients, vjps, jvps, natural gradients, Jacobians, and Hessians. AD is " "the base for all modern machine learning libraries." msgstr "梯度、矢量雅可比乘积、自然梯度、 Jacobian 矩阵和 Hessian 矩阵。自动微分是所有现代机器学习库的基础。" -#: ../../source/quickstart.rst:193 +#: ../../source/quickstart.rst:228 msgid "**JIT Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:195 +#: ../../source/quickstart.rst:230 msgid "" "Parameterized quantum circuits can run in a blink. Always use jit if the " "circuit will get evaluations multiple times, it can greatly boost the " @@ -328,11 +404,11 @@ msgstr "" " 即时编译，否则，即时编译的函数可能会返回意外结果或每次在点击时都重新编译（浪费大量时间）。要了解更多关于即时编译机制的信息，可以参考关于 " "``tf.function`` 或 ``jax.jit`` 的文档或博客，即使这两者仍然存在细微差别。" -#: ../../source/quickstart.rst:199 +#: ../../source/quickstart.rst:234 msgid "**VMAP Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:201 +#: ../../source/quickstart.rst:236 msgid "" "Inputs, parameters, measurements, circuit structures, and Monte Carlo " "noise can all be evaluated in parallel. To learn more about vmap " @@ -342,11 +418,11 @@ msgstr "" "输入、参数、测量、电路结构、蒙特卡洛噪声都可以并行测算。 要了解有关矢量并行化机制的更多信息，可以参考 ``tf.vectorized_map``" " 或 ``jax.vmap`` 上的文档或博客。" -#: ../../source/quickstart.rst:206 +#: ../../source/quickstart.rst:241 msgid "Backend Agnosticism" msgstr "后端无关特性" -#: ../../source/quickstart.rst:208 +#: ../../source/quickstart.rst:243 msgid "" "TensorCircuit supports TensorFlow, Jax, and PyTorch backends. We " "recommend using TensorFlow or Jax backend since PyTorch lacks advanced " @@ -355,7 +431,7 @@ msgstr "" "TensorCircuit 支持 TensorFlow、Jax 和 PyTorch 后端。 我们建议使用 TensorFlow 或 Jax " "后端，因为 PyTorch 缺乏高级 jit 和 vmap 功能。" -#: ../../source/quickstart.rst:210 +#: ../../source/quickstart.rst:245 msgid "" "The backend can be set as ``K=tc.set_backend(\"jax\")`` and ``K`` is the " "backend with a full set of APIs as a conventional ML framework, which can" @@ -364,7 +440,7 @@ msgstr "" "后端可以设置为 ``K=tc.set_backend(\"jax\")`` ，``K``作为常规机器学习框架的全套API的后端，也可以通过``tc" " .backend`` 被访问。" -#: ../../source/quickstart.rst:233 +#: ../../source/quickstart.rst:268 #, fuzzy msgid "" "The supported APIs in the backend come from two sources, one part is " @@ -379,11 +455,11 @@ msgstr "" " 另一个来自 `TensorCircuit package `__。" -#: ../../source/quickstart.rst:387 +#: ../../source/quickstart.rst:422 msgid "Switch the Dtype" msgstr "转换 dtype" -#: ../../source/quickstart.rst:389 +#: ../../source/quickstart.rst:424 msgid "" "TensorCircuit supports simulation using 32/64 bit precession. The default" " dtype is 32-bit as \"complex64\". Change this by " @@ -393,24 +469,24 @@ msgstr "" "\"complex64\"。可以通过 ``tc.set_dtype(\"complex128\")`` 把 dtype 改为 \"complex" " 128\" 。" -#: ../../source/quickstart.rst:392 +#: ../../source/quickstart.rst:427 msgid "" "``tc.dtypestr`` always returns the current dtype string: either " "\"complex64\" or \"complex128\"." msgstr "``tc.dtypestr`` 总会返回当前的 dtype 字符串: 不是 \"complex64\" 就是 \"complex128\"." -#: ../../source/quickstart.rst:396 +#: ../../source/quickstart.rst:431 msgid "Setup the Contractor" msgstr "设置 contractor" -#: ../../source/quickstart.rst:398 +#: ../../source/quickstart.rst:433 msgid "" "TensorCircuit is a tensornetwork contraction-based quantum circuit " "simulator. A contractor is for searching for the optimal contraction path" " of the circuit tensornetwork." msgstr "TensorCircuit 是一个基于张量网络收缩的量子电路模拟器。 contractor 用于搜索电路张量网络的最佳收缩路径。" -#: ../../source/quickstart.rst:400 +#: ../../source/quickstart.rst:435 msgid "" "There are various advanced contractors provided by third-party packages, " "such as `opt-einsum `__ and " @@ -420,7 +496,7 @@ msgstr "" "`__ 和 `cotengra " "`__ 。" -#: ../../source/quickstart.rst:402 +#: ../../source/quickstart.rst:437 msgid "" "`opt-einsum` is shipped with TensorNetwork package. To use cotengra, one " "needs to pip install it; kahypar is also recommended to install with " @@ -429,11 +505,11 @@ msgstr "" "`opt-einsum` 随 TensorNetwork 软件包一起。如要使用 cotengra，则需要 pip 安装它； 还建议安装 " "cotengra 随 kahypar 一起使用。" -#: ../../source/quickstart.rst:404 +#: ../../source/quickstart.rst:439 msgid "Some setup cases:" msgstr "一些设置案例：" -#: ../../source/quickstart.rst:430 +#: ../../source/quickstart.rst:465 #, fuzzy msgid "" "For advanced configurations on cotengra contractors, please refer to " @@ -448,25 +524,25 @@ msgstr "" "`contractor 教程 `__." -#: ../../source/quickstart.rst:432 +#: ../../source/quickstart.rst:467 msgid "**Setup in Function or Context Level**" msgstr "**函数和上下文级别的设置**" -#: ../../source/quickstart.rst:434 +#: ../../source/quickstart.rst:469 msgid "" "Beside global level setup, we can also setup the backend, the dtype, and " "the contractor at the function level or context manager level:" msgstr "除了全局级别设置，我们还可以在函数级别或上下文管理器级别设置后端、dtype 和contractor：" -#: ../../source/quickstart.rst:452 +#: ../../source/quickstart.rst:487 msgid "Noisy Circuit Simulation" msgstr "噪声电路模拟" -#: ../../source/quickstart.rst:454 +#: ../../source/quickstart.rst:489 msgid "**Monte Carlo State Simulator:**" msgstr "**蒙特卡洛态模拟器**" -#: ../../source/quickstart.rst:456 +#: ../../source/quickstart.rst:491 msgid "" "For the Monte Carlo trajectory noise simulator, the unitary Kraus channel" " can be handled easily. TensorCircuit also supports fully jittable and " @@ -475,40 +551,40 @@ msgstr "" "对于蒙特卡洛轨迹噪声模拟器，可以轻松处理幺正的 Kraus 通道。 不过，TensorCircuit 还支持完全可即时编译和可微分的通用 " "Kraus 通道蒙特卡罗模拟。" -#: ../../source/quickstart.rst:483 +#: ../../source/quickstart.rst:518 msgid "**Density Matrix Simulator:**" msgstr "**密度矩阵模拟器**" -#: ../../source/quickstart.rst:485 +#: ../../source/quickstart.rst:520 msgid "" "Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full " "form, but takes twice qubits to do noiseless simulation. The API is the " "same as ``tc.Circuit``." msgstr "密度矩阵模拟器``tc.DMCircuit`` 以完整形式模拟噪声，但需要两倍的量子比特。API 与 ``tc.Circuit`` 基本相同。" -#: ../../source/quickstart.rst:504 +#: ../../source/quickstart.rst:539 msgid "**Experiment with quantum errors:**" msgstr "" -#: ../../source/quickstart.rst:506 +#: ../../source/quickstart.rst:541 msgid "Multiple quantum errors can be added on circuit." msgstr "" -#: ../../source/quickstart.rst:522 +#: ../../source/quickstart.rst:557 msgid "**Experiment with readout error:**" msgstr "" -#: ../../source/quickstart.rst:524 +#: ../../source/quickstart.rst:559 msgid "" "Readout error can be added in experiments for sampling and expectation " "value calculation." msgstr "" -#: ../../source/quickstart.rst:550 +#: ../../source/quickstart.rst:585 msgid "MPS and MPO" msgstr "矩阵乘积状态和矩阵乘积算子" -#: ../../source/quickstart.rst:552 +#: ../../source/quickstart.rst:587 msgid "" "TensorCircuit has its class for MPS and MPO originally defined in " "TensorNetwork as ``tc.QuVector``, ``tc.QuOperator``." @@ -516,7 +592,7 @@ msgstr "" "TensorCircuit 有自己的 MPS 和 MPO 类，起初在 TensorNetwork 中定义为“tc.QuVector” 和 " "“tc.QuOperator”。" -#: ../../source/quickstart.rst:554 +#: ../../source/quickstart.rst:589 msgid "" "``tc.QuVector`` can be extracted from ``tc.Circuit`` as the tensor " "network form for the output state (uncontracted) by ``c.quvector()``." @@ -524,7 +600,7 @@ msgstr "" "作为``c.quvector()`` 的输出状态（未收缩）的张量网络形式，``tc.QuVector`` 可以从``tc.Circuit`` " "中提取。" -#: ../../source/quickstart.rst:556 +#: ../../source/quickstart.rst:591 msgid "" "The QuVector forms a wavefunction w, which can also be fed into Circuit " "as the inputs state as ``c=tc.Circuit(n, mps_inputs=w)``." @@ -532,61 +608,61 @@ msgstr "" "QuVector 形成一个波函数 w，它也可以作为 ``c=tc.Circuit(n, mps_inputs=w)`` 的输入状态输入到 " "Circuit 中。" -#: ../../source/quickstart.rst:558 +#: ../../source/quickstart.rst:593 msgid "MPS as input state for circuit" msgstr "MPS 作为电路的输入状态" -#: ../../source/quickstart.rst:560 +#: ../../source/quickstart.rst:595 msgid "" "The MPS/QuVector representation of the input state has a more efficient " "and compact form." msgstr "输入状态的 MPS/QuVector 表示具有更高效和紧凑的形式。" -#: ../../source/quickstart.rst:572 +#: ../../source/quickstart.rst:607 msgid "MPS as (uncomputed) output state for circuit" msgstr "MPS 作为电路的（未计算的）输出状态" -#: ../../source/quickstart.rst:574 +#: ../../source/quickstart.rst:609 msgid "" "For example, a quick way to calculate the wavefunction overlap without " "explicitly computing the state amplitude is given as below:" msgstr "例如，在不显式计算状态幅度的情况下，计算波函数重叠的快速方法如下：" -#: ../../source/quickstart.rst:591 +#: ../../source/quickstart.rst:626 msgid "MPO as the gate on the circuit" msgstr "MPO 作为电路上的门" -#: ../../source/quickstart.rst:593 +#: ../../source/quickstart.rst:628 msgid "" "Instead of a common quantum gate in matrix/node format, we can directly " "apply a gate in MPO/QuOperator format." msgstr "代替矩阵/节点格式的普通量子门，我们可以直接应用 MPO/QuOperator 格式的门。" -#: ../../source/quickstart.rst:604 +#: ../../source/quickstart.rst:639 msgid "" "The representative gate defined in MPO format is the ``multicontrol`` " "gate." msgstr "以 MPO 格式定义的代表门是 ``multicontrol`` 门。" -#: ../../source/quickstart.rst:606 +#: ../../source/quickstart.rst:641 msgid "MPO as the operator for expectation evaluation on a circuit" msgstr "MPO作为电路期望估测算子" -#: ../../source/quickstart.rst:608 +#: ../../source/quickstart.rst:643 msgid "" "We can also measure operator expectation on the circuit output state " "where the operator is in MPO/QuOperator format." msgstr "我们还可以测量运算符对 MPO/QuOperator 格式的电路输出状态的期望。" -#: ../../source/quickstart.rst:620 +#: ../../source/quickstart.rst:655 msgid "Interfaces" msgstr "接口" -#: ../../source/quickstart.rst:622 +#: ../../source/quickstart.rst:657 msgid "**PyTorch Interface to Hybrid with PyTorch Modules:**" msgstr "**与 PyTorch 模块混合的 PyTorch 接口：**" -#: ../../source/quickstart.rst:624 +#: ../../source/quickstart.rst:659 msgid "" "As we have mentioned in the backend section, the PyTorch backend may lack" " advanced features. This doesn't mean we cannot hybrid the advanced " @@ -597,7 +673,7 @@ msgstr "" "正如我们在后端部分提到的，PyTorch 后端可能缺少高级功能。 这并不意味着我们不能将高级量子电路模块与 PyTorch 神经模块混合。 " "我们可以在 TensorFlow 或 Jax 后端运行量子函数，同时使用 Torch 接口包装它。 " -#: ../../source/quickstart.rst:651 +#: ../../source/quickstart.rst:686 msgid "" "For a GPU/CPU, torch/tensorflow, quantum/classical hybrid machine " "learning pipeline enabled by tensorcircuit, see `example script " @@ -605,96 +681,96 @@ msgid "" "lab/tensorcircuit/blob/master/examples/hybrid_gpu_pipeline.py>`__." msgstr "" -#: ../../source/quickstart.rst:653 +#: ../../source/quickstart.rst:688 msgid "" "We also provider wrapper of quantum function for torch module as " ":py:meth:`tensorcircuit.TorchLayer` alias to " ":py:meth:`tensorcircuit.torchnn.QuantumNet`." msgstr "" -#: ../../source/quickstart.rst:655 +#: ../../source/quickstart.rst:690 msgid "" "For ``TorchLayer``, ``use_interface=True`` is by default, which natively " "allow the quantum function defined on other tensorcircuit backends, such " "as jax or tf for speed consideration." msgstr "" -#: ../../source/quickstart.rst:657 +#: ../../source/quickstart.rst:692 msgid "" "``TorchLayer`` can process multiple input arguments as multiple function " "inputs, following torch practice." msgstr "" -#: ../../source/quickstart.rst:685 +#: ../../source/quickstart.rst:720 msgid "**TensorFlow interfaces:**" msgstr "" -#: ../../source/quickstart.rst:687 +#: ../../source/quickstart.rst:722 msgid "" "Similar rules apply similar as torch interface. The interface can even be" " used within jit environment outside. See " ":py:meth:`tensorcircuit.interfaces.tensorflow.tensorflow_interface`." msgstr "" -#: ../../source/quickstart.rst:690 +#: ../../source/quickstart.rst:725 msgid "" "We also provider ``enable_dlpack=True`` option in torch and tf " "interfaces, which allow the tensor transformation happen without memory " "transfer via dlpack, higher version of tf or torch package required." msgstr "" -#: ../../source/quickstart.rst:693 +#: ../../source/quickstart.rst:728 msgid "" "We also provider wrapper of quantum function for keras layer as " ":py:meth:`tensorcircuit.KerasLayer` alias to " ":py:meth:`tensorcircuit.keras.KerasLayer`." msgstr "" -#: ../../source/quickstart.rst:695 +#: ../../source/quickstart.rst:730 msgid "" "``KerasLayer`` can process multiple input arguments with the input as a " "dict, following the common keras practice, see example below." msgstr "" -#: ../../source/quickstart.rst:717 +#: ../../source/quickstart.rst:752 msgid "**Scipy Interface to Utilize Scipy Optimizers:**" msgstr "**使用 scipy接口使用scipy优化器：**" -#: ../../source/quickstart.rst:719 +#: ../../source/quickstart.rst:754 msgid "" "Automatically transform quantum functions as scipy-compatible values and " "grad functions as provided for scipy interface with ``jac=True``." msgstr "为带有 jac=True 的 scipy 接口自动将量子函数转换为与 scipy 兼容的 value 和 grad 函数。" -#: ../../source/quickstart.rst:745 +#: ../../source/quickstart.rst:780 msgid "Templates as Shortcuts" msgstr "捷径模板" -#: ../../source/quickstart.rst:747 +#: ../../source/quickstart.rst:782 msgid "**Measurements:**" msgstr "**测量**" -#: ../../source/quickstart.rst:749 +#: ../../source/quickstart.rst:784 msgid "Ising type Hamiltonian defined on a general graph" msgstr "在一般图上定义的伊辛型哈密顿量" -#: ../../source/quickstart.rst:751 +#: ../../source/quickstart.rst:786 msgid "" "See " ":py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" msgstr "参考 :py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" -#: ../../source/quickstart.rst:753 +#: ../../source/quickstart.rst:788 msgid "Heisenberg Hamiltonian on a general graph with possible external fields" msgstr "具有可能存在的外场的一般图上的海森堡哈密顿量" -#: ../../source/quickstart.rst:755 +#: ../../source/quickstart.rst:790 msgid "" "See " ":py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" msgstr "参考 :py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" -#: ../../source/quickstart.rst:757 +#: ../../source/quickstart.rst:792 msgid "**Circuit Blocks:**" msgstr "**电路块**" diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 8ff6d6ff..4e5800a5 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -2,6 +2,41 @@ Quick Start ================ +Installation +-------------- + +- For x86 Linux or Mac, + +``pip install tensorcircuit`` + +is in general enough. +Either pip from conda or other python env managers is fine. + +Since there are many optional packages for various features, +the users may need to install more pip packages when required. + +- For Linux with Nvidia GPU, +please refer to the GPU aware installation guide of corresponding machine learning frameworks: +`TensorFlow `_, +`Jax `_, +or `PyTorch `_. + +Docker is also recommended (especially Linux + Nvidia GPU setup): + +``sudo docker run -it --network host --gpus all tensorcircuit/tensorcircuit``. + +- For Windows, due to the lack of support for Jax, we recommend to use docker or WSL, please refer to `TC via windows docker `_ or `TC via WSL `_. + +- For Mac with M series chips (arm architecture), please refer to `TC on Mac M series `_. + +Overall, the installation of TensorCircuit is simple, since it is purely in Python and hence very portable. +As long as the users can take care of the installation of ML frameworks on the corresponding system, TensorCircuit will work as expected. + +.. Note:: + We also provide a nightly build of tensorcircuit via PyPI which can be accessed by + ``pip uninstall tensorcircuit``, then + ``pip install tensorcircuit-nightly`` + Circuit Object ------------------ From 29ed344da2bd7259c09254d4502e1b9a83881153 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 2 Feb 2023 14:28:16 +0800 Subject: [PATCH 284/725] update cloud sdk tutorial --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 306 +++++++++++++++++----- 1 file changed, 234 insertions(+), 72 deletions(-) diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb index 2680dac9..5b1c0467 100644 --- a/docs/source/tutorials/tc_qcloud_sdk.ipynb +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -5,7 +5,7 @@ "id": "38c73e8c", "metadata": {}, "source": [ - "# tensorcircuit SDK for QCloud（230116 ver）" + "# tensorcircuit SDK for QCloud（230203 ver）" ] }, { @@ -27,6 +27,7 @@ "source": [ "import tensorcircuit as tc\n", "from tensorcircuit.cloud import apis\n", + "from tensorcircuit.compiler.qiskit_compiler import qiskit_compile\n", "import numpy as np" ] }, @@ -56,7 +57,9 @@ "id": "f3e53835", "metadata": {}, "source": [ - "## list providers/devices/properties" + "## list providers/devices/properties\n", + "\n", + "Get basic info of devices and device information" ] }, { @@ -108,7 +111,7 @@ "metadata": {}, "outputs": [], "source": [ - "d.list_properties()[\"usage\"]" + "d.list_properties()[\"bits\"][8]" ] }, { @@ -121,6 +124,16 @@ "d.topology()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "1823e172", + "metadata": {}, + "outputs": [], + "source": [ + "d.native_gates()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -139,6 +152,14 @@ "## Task submit and the results" ] }, + { + "cell_type": "markdown", + "id": "dc7645ab", + "metadata": {}, + "source": [ + "Basic task submission syntax below, here we use a simulator backend on tQuK `simulator:tc`" + ] + }, { "cell_type": "code", "execution_count": null, @@ -182,6 +203,14 @@ "t.get_device()" ] }, + { + "cell_type": "markdown", + "id": "7e550c80", + "metadata": {}, + "source": [ + "resubmit a job with the same source (device/shots) and command (circuit)\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -189,7 +218,6 @@ "metadata": {}, "outputs": [], "source": [ - "# resubmit a job with the same source and command\n", "t1 = t.resubmit()\n", "t1.details(blocked=True, prettify=True)" ] @@ -209,7 +237,9 @@ "id": "8c795e68", "metadata": {}, "source": [ - "## local provider enable quick debugging and testing" + "## local provider enable quick debugging and testing\n", + "\n", + "TC comes with a local provider which behaves as a simple cloud provider but run the circuit locally" ] }, { @@ -282,7 +312,7 @@ "id": "2e359725", "metadata": {}, "source": [ - "The task can indexed either with device information or not (as long as we use ``set_provider``)" + "As shown above, the task can be indexed either with device information or not (as long as we use ``set_provider``)" ] }, { @@ -301,7 +331,7 @@ "id": "9bf0d5ca", "metadata": {}, "source": [ - "## GHZ on real device and readout mitigation" + "## GHZ state on real device and readout mitigation" ] }, { @@ -320,12 +350,17 @@ "c.cnot(0, 2)\n", "c.cnot(2, 6)\n", "\n", + "# above we dirct assign physical qubits\n", + "\n", "t = apis.submit_task(\n", " circuit=c, shots=shots, device=\"9gmon\", enable_qos_qubit_mapping=False\n", ")\n", "raw_count = t.results(blocked=True)\n", "# blocked = True will block the process until the result is returned\n", - "# the default behavior is blocked=False, where only one query is made and raise error when the task is incomplete" + "# the default behavior is blocked=False, where only one query is made and raise error when the task is incomplete\n", + "\n", + "# note we explicitly turn off qubit mapping from qos, which gurantee our logical circuit are identical to the physical one.\n", + "# but one should ensure the topology link in the logical circuit is compatible with the target device" ] }, { @@ -333,7 +368,7 @@ "id": "80b617b4", "metadata": {}, "source": [ - "In the below, we use tensorcircuit builtin powerful tool for readout mitigation: ``tc.results.readout_mitigation.ReadoutMit``, it supports various method for calibriation and mitigation" + "In the below, we use tensorcircuit builtin powerful tool for readout mitigation: ``tc.results.rem.ReadoutMit``, it supports various method for calibriation and mitigation" ] }, { @@ -343,10 +378,11 @@ "metadata": {}, "outputs": [], "source": [ - "ReadoutMit = tc.results.readout_mitigation.ReadoutMit\n", - "mit = ReadoutMit(\"9gmon?o=0\")\n", + "mit = tc.results.rem.ReadoutMit(\"9gmon?o=0\")\n", + "# here o=0 is a short for disable qubit mapping and gate decomposition at the backend server\n", "mit.cals_from_system(nqubit, shots, method=\"local\")\n", - "miti_count = mit.apply_correction(raw_count, nqubit, method=\"square\")" + "# local calibriation\n", + "miti_count = mit.apply_correction(raw_count, nqubit, method=\"constrained_least_square\")" ] }, { @@ -355,7 +391,28 @@ "metadata": {}, "source": [ "By attaching ``?o=0`` after the device string, we have the same effect of setting ``enable_qos_qubit_mapping=False`` (o=1)\n", - "and ``enable_qos_gate_decomposition=False`` (o=2), and both of them of by default True (o=3)" + "and ``enable_qos_gate_decomposition=False`` (o=2), and both of them are by default True (o=3).\n", + "\n", + "We can define the REM class by using more customizable function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09a498b1", + "metadata": {}, + "outputs": [], + "source": [ + "def run(cs, shots):\n", + " \"\"\"batch mode\"\"\"\n", + " ts = apis.submit_task(\n", + " circuit=cs, shots=shots, device=\"9gmon\", enable_qos_qubit_mapping=False\n", + " )\n", + " return [t.results(blocked=True) for t in ts]\n", + "\n", + "\n", + "mit = tc.results.rem.ReadoutMit(run)\n", + "mit.cals_from_system(nqubit, shots, method=\"local\")" ] }, { @@ -412,6 +469,26 @@ " print(m)" ] }, + { + "cell_type": "markdown", + "id": "1c88101c", + "metadata": {}, + "source": [ + "Apart from calibriation from real experiments, we can access the readout error matrix from API (which is fast but may be not that up to date)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecca1aab", + "metadata": {}, + "outputs": [], + "source": [ + "mit = tc.results.rem.ReadoutMit(\"9gmon?o=0\")\n", + "mit.cals_from_api(nqubit)\n", + "mit.single_qubit_cals[0]" + ] + }, { "cell_type": "markdown", "id": "422d0a1b", @@ -419,11 +496,13 @@ "source": [ "## Abstraction of three layers of qubits and the mappings\n", "\n", + "In the above example, the circuit is not compiled by the frontend: tc or backend: qos, in the follows, we will introduce circuit compiling and the new abstraction on different level of qubits.\n", + "\n", "New abstraction on qubits: positional qubits, logical qubits, physical qubits, we need two more mappings: ``positional_logical_mapping`` and ``logical_physical_mapping``.\n", "\n", "The separation between positional and logical qubits is due to partial measurement, while the seperation between logical and physical qubits are from circuit compiling onto hardware, including swap inserting (where the last swap is omitted, current qos behavior), qubit routing (i.e. initial mapping).\n", "\n", - "Now we do the GHZ preparation on another chip, but use mapping and partial measurement abstraction" + "Now we do the GHZ preparation on another chip, but use mapping and partial measurement abstraction this time" ] }, { @@ -433,6 +512,8 @@ "metadata": {}, "outputs": [], "source": [ + "# logical circuit for GHZ-5\n", + "\n", "c = tc.Circuit(5)\n", "c.h(0)\n", "for i in range(4):\n", @@ -440,13 +521,23 @@ "for i in range(5):\n", " c.measure_instruction(i)\n", "\n", - "# We map the circuit on the physical qubits\n", + "# We map the circuit on the physical qubits by hand\n", "\n", - "c1 = c.initial_mapping({i: 12 + i for i in range(5)}, n=20)\n", + "c1 = c.initial_mapping({0: 8, 1: 4, 2: 0, 3: 2, 4: 6}, n=9)\n", "positional_logical_mapping = c1.get_positional_logical_mapping()\n", "positional_logical_mapping" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb7e4b4b", + "metadata": {}, + "outputs": [], + "source": [ + "c1.draw() # circuit after mapping" + ] + }, { "cell_type": "code", "execution_count": null, @@ -455,7 +546,7 @@ "outputs": [], "source": [ "t = apis.submit_task(\n", - " circuit=c1, shots=shots, device=\"20xmon\", enable_qos_qubit_mapping=False\n", + " circuit=c1, shots=shots, device=\"9gmon\", enable_qos_qubit_mapping=False\n", ")\n", "raw_count = t.results(blocked=True)" ] @@ -468,7 +559,8 @@ "outputs": [], "source": [ "logical_physical_mapping = t.details()[\"optimization\"][\"pairs\"]\n", - "logical_physical_mapping = {int(k): int(v) for k, v in logical_physical_mapping.items()}" + "logical_physical_mapping\n", + "# this mapping is identical since we disable qos qubit mapping above" ] }, { @@ -478,11 +570,11 @@ "metadata": {}, "outputs": [], "source": [ - "mit = ReadoutMit(\"20xmon?o=0\")\n", - "mit.cals_from_system(20, shots, method=\"local\")\n", + "mit = tc.results.rem.ReadoutMit(\"9gmon?o=0\")\n", + "mit.cals_from_system(9, shots, method=\"local\")\n", "miti_count = mit.apply_correction(\n", " raw_count,\n", - " [12, 13, 14, 15, 16],\n", + " [8, 4, 0, 2, 6],\n", " positional_logical_mapping=positional_logical_mapping,\n", " logical_physical_mapping=logical_physical_mapping,\n", " method=\"square\",\n", @@ -504,7 +596,7 @@ "id": "03d5c6cf", "metadata": {}, "source": [ - "We can have another way to understand logical qubits: we could treat 0-4 in the original circuit as logical qubits, then we will have the following convention" + "We can have another way to understand logical qubits: we could treat 0-4 in the original circuit as logical qubits, then we will have the following convention and the circuit after initial mapping as the physical one (abstraction reference shift)" ] }, { @@ -518,7 +610,7 @@ " raw_count,\n", " [0, 1, 2, 3, 4],\n", " positional_logical_mapping=None,\n", - " logical_physical_mapping={0: 12, 1: 13, 2: 14, 3: 15, 4: 16},\n", + " logical_physical_mapping={0: 8, 1: 4, 2: 0, 3: 2, 4: 6},\n", " method=\"square\",\n", ")\n", "# note how the None by default implies an identity mapping" @@ -532,7 +624,80 @@ "outputs": [], "source": [ "plot_histogram([raw_count, miti_count])\n", - "# the results should be exactly the same" + "# the results should be exactly the same, since they are just the same thing using different reference system" + ] + }, + { + "cell_type": "markdown", + "id": "32d753ff", + "metadata": {}, + "source": [ + "The above abstraction is rather low level where the compiling is done by hand and we recommend the following api for users (**the highly recommended way**).\n", + "\n", + "The recommended approach heavily depends on the frontend compiling via qiskit (builtin support in tc)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2711fdb3", + "metadata": {}, + "outputs": [], + "source": [ + "# 0. acquire readout mitigation class\n", + "\n", + "mit = tc.results.rem.ReadoutMit(\"9gmon?o=0\")\n", + "mit.cals_from_system(9)\n", + "\n", + "# 1. define the logical circuit\n", + "\n", + "n = 5\n", + "c = tc.Circuit(n)\n", + "c.h(0)\n", + "for i in range(n - 1):\n", + " c.cx(i, i + 1)\n", + "for i in reversed(range(n)):\n", + " c.measure_instruction(i)\n", + "\n", + "# 2. compile the circuit\n", + "\n", + "d = apis.get_device(\"9gmon\")\n", + "\n", + "c1, info = qiskit_compile(\n", + " c,\n", + " compiled_options={\n", + " \"basis_gates\": d.native_gates(),\n", + " \"optimization_level\": 3,\n", + " \"coupling_map\": d.topology(),\n", + " },\n", + ")\n", + "\n", + "\n", + "# 3. submit the job and get the raw result\n", + "\n", + "t = apis.submit_task(\n", + " circuit=c1,\n", + " shots=8192,\n", + " device=d,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + ")\n", + "raw_count = t.results(blocked=True)\n", + "\n", + "# 4. obtain the mitigated result in terms of distribution or expectation\n", + "\n", + "print(\"distribution\", mit.apply_correction(raw_count, n, method=\"square\", **info))\n", + "print(\"\", mit.expectation(raw_count, [0, 1], **info))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa854a6e", + "metadata": {}, + "outputs": [], + "source": [ + "info # compiling info and the qubit mapping are recorded automatically" ] }, { @@ -540,7 +705,7 @@ "id": "f13baa43", "metadata": {}, "source": [ - "batch submission is possible with multiple circuits in a list and the return is a list of task, respectively" + "batch submission is possible with multiple circuits in a list and the return is a list of task, respectively. The batch mechanism are supported both on real chips and simulators." ] }, { @@ -558,7 +723,7 @@ "c1 = tc.Circuit(2)\n", "c1.h(1)\n", "\n", - "ts = apis.submit_task(device=\"9gmon\", circuit=[c, c1], shots=1024)\n", + "ts = apis.submit_task(device=\"20xmon\", circuit=[c, c1], shots=1024)\n", "\n", "for t in ts:\n", " print(t.results(blocked=True))" @@ -569,31 +734,11 @@ "id": "4d2c56b6", "metadata": {}, "source": [ - "## three approaches for measure on partial of the qubits\n", + "## measure on partial of the qubits\n", "\n", "Note the return order should ideally follow the measure order in the instructions" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "9d7abd03", - "metadata": {}, - "outputs": [], - "source": [ - "# directly partial measure\n", - "\n", - "# approach 1: this approach is deprecated and not recommend\n", - "nqubit = 9\n", - "shots = 4096\n", - "c = tc.Circuit(nqubit)\n", - "c.x(8)\n", - "c.x(6)\n", - "\n", - "t = apis.submit_task(circuit=c, shots=shots, device=\"9gmon?o=0\", measure=[8, 2, 6])\n", - "print(t.results(blocked=True))" - ] - }, { "cell_type": "code", "execution_count": null, @@ -601,9 +746,8 @@ "metadata": {}, "outputs": [], "source": [ - "# directly partial measure\n", + "# directly partial measure via qiskit\n", "\n", - "# approach 2\n", "from qiskit.circuit import QuantumCircuit\n", "\n", "qc = QuantumCircuit(9, 9)\n", @@ -632,9 +776,9 @@ "metadata": {}, "outputs": [], "source": [ - "# directly partial measure\n", + "# directly partial measure on tc\n", "\n", - "# approach 3, recommended approach\n", + "# recommended approach\n", "\n", "nqubit = 9\n", "shots = 4096\n", @@ -646,7 +790,8 @@ "c.measure_instruction(6)\n", "\n", "t = apis.submit_task(circuit=c, shots=shots, device=\"9gmon?o=0\")\n", - "print(t.results(blocked=True))" + "print(t.results(blocked=True))\n", + "print(c.get_positional_logical_mapping())" ] }, { @@ -654,7 +799,7 @@ "id": "e431f862", "metadata": {}, "source": [ - "partial measurment also supported via the simulator" + "partial measurment also supported via the simulator on the cloud" ] }, { @@ -705,7 +850,7 @@ "## two level compiling system\n", "\n", "We provide compiling support at frond end (via tc-qiskit pipeline) and at back end (in qos).\n", - "The front end option is enabled by ``compiled-True`` (default to False) and also with an optional dict for ``qiskit.transpile`` arguments called ``compiled_options``. The backend qos compiling is controlled by ``enable_qos_qubit_mapping`` and ``enable_qos_gate_decomposition`` (all default to True). The ``?o=int`` str after the device name can overide qos compiling options." + "The front end option is enabled by ``compiled=True`` (default to False) and also with an optional dict for ``qiskit.transpile`` arguments called ``compiled_options``. For advanced users, we recommand you to separately deal with the circuit compiling and submission as we discussed above as the recommended approach. The backend qos compiling is controlled by ``enable_qos_qubit_mapping`` and ``enable_qos_gate_decomposition`` (all default to True). The ``?o=int`` str after the device name can overide qos compiling options. We strongly recommend the users only use one part of the compiling in case confusing and conflicts. For front end compiling, though the built-in compiling via ``compiled`` switch in ``submit_task`` is handy, we recommend the advanced user to use standalone compiling module as shown above, i.e. explicitly call ``qiskit_compile``, the advantage for the latter is we can obtain qubit mapping information at the same time for further error mitigation pipelines." ] }, { @@ -721,14 +866,19 @@ "shots = 8192\n", "c = tc.Circuit(nqubit)\n", "c.h(0)\n", + "c.rz(0, theta=0.4)\n", + "c.x(0)\n", + "c.y(0)\n", "c.h(1)\n", "c.rx(2, theta=0.7)\n", "c.ry(1, theta=-1.2)\n", "c.cnot(0, 1)\n", "c.cnot(2, 0)\n", "c.h(1)\n", + "c.x(2)\n", + "\n", + "print(\"exact: \", [np.real(c.expectation_ps(z=[i])).tolist() for i in range(nqubit)])\n", "\n", - "print(\"exact: \", [np.real(c.expectation_ps(z=[i])) for i in range(nqubit)])\n", "t = apis.submit_task(\n", " circuit=c,\n", " shots=shots,\n", @@ -741,24 +891,33 @@ "ct = t.results(blocked=True)\n", "\n", "mit = tc.results.readout_mitigation.ReadoutMit(\"9gmon?o=0\")\n", - "mit.cals_from_system(3, method=\"local\")\n", + "mit.cals_from_system(3, shots=8192, method=\"local\")\n", "\n", "print(\n", - " \"experiments (mitigated): \",\n", + " \"experiments (mitigated directly via expectation): \",\n", " [mit.expectation(ct, [i]) for i in range(nqubit)],\n", + ")\n", + "\n", + "# no need to provider mapping in mit as there is no mapping in this case,\n", + "# compiled=True itself doesn't enable front end qubit routing\n", + "\n", + "print(\n", + " \"experiments (mitigated using lstm): \",\n", + " [\n", + " tc.results.counts.expectation(mit.apply_correction(ct, 3, method=\"square\"), [i])\n", + " for i in range(nqubit)\n", + " ],\n", ")" ] }, { "cell_type": "code", "execution_count": null, - "id": "bd760c6b", - "metadata": { - "scrolled": true - }, + "id": "60e9d6d0", + "metadata": {}, "outputs": [], "source": [ - "c.draw()" + "c.draw() # target circuit: mimic a VQA case" ] }, { @@ -768,18 +927,23 @@ "metadata": {}, "outputs": [], "source": [ - "# use backend compiling system enabled by qos\n", + "# use backend compiling system enabled by qos and the very handy built-in auto mitigation\n", + "# (only works without qubit mapping at front end)\n", "\n", "nqubit = 3\n", "shots = 8192\n", "c = tc.Circuit(nqubit)\n", "c.h(0)\n", + "c.rz(0, theta=0.4)\n", + "c.x(0)\n", + "c.y(0)\n", "c.h(1)\n", "c.rx(2, theta=0.7)\n", "c.ry(1, theta=-1.2)\n", "c.cnot(0, 1)\n", "c.cnot(2, 0)\n", "c.h(1)\n", + "c.x(2)\n", "\n", "print(\"exact: \", [np.real(c.expectation_ps(z=[i])) for i in range(nqubit)])\n", "\n", @@ -792,14 +956,13 @@ " enable_qos_gate_decomposition=True,\n", ")\n", "\n", - "ct = t.results(blocked=True)\n", + "ct = t.results(blocked=True, mitigated=True)\n", + "# auto mitigation with backend qubit mapping considered\n", "\n", - "mit = tc.results.readout_mitigation.ReadoutMit(\"9gmon\")\n", - "mit.cals_from_system(3, method=\"local\")\n", "\n", "print(\n", " \"experiments (mitigated): \",\n", - " [mit.expectation(ct, [i]) for i in range(nqubit)],\n", + " [tc.results.counts.expectation(ct, [i]) for i in range(nqubit)],\n", ")" ] }, @@ -833,7 +996,7 @@ "metadata": {}, "outputs": [], "source": [ - "c_complied_after_qos.draw()" + "c_complied_after_qos.draw(output=\"mpl\")" ] }, { @@ -862,7 +1025,6 @@ "c.cnot(2, 0)\n", "c.h(1)\n", "\n", - "print(\"exact: \", [np.real(c.expectation_ps(z=[i])) for i in range(nqubit)])\n", "\n", "t = apis.submit_task(\n", " circuit=c,\n", @@ -884,7 +1046,7 @@ }, "outputs": [], "source": [ - "t.details(prettify=True)[\"backend\"].draw()" + "t.details(prettify=True, blocked=True)[\"backend\"].draw()" ] }, { @@ -985,7 +1147,7 @@ "metadata": {}, "outputs": [], "source": [ - "# mitigated with m3 scalable directly on expectation: not a wrapper for count but a new algorithm!\n", + "# mitigated scalable directly on expectation: not a wrapper for count but a new algorithm!\n", "# see eq 6 in https://arxiv.org/pdf/2006.14044.pdf\n", "\n", "mit.expectation(raw_count, [0])" @@ -998,7 +1160,7 @@ "source": [ "## list task and get previous task\n", "\n", - "get history tasks and their details" + "get history tasks and their details, so that your experimental data are always accessible with detailed meta data on the cloud" ] }, { From eafb8ecf76d9ad17beb79f2bd1f92664b3be43b3 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 2 Feb 2023 14:45:45 +0800 Subject: [PATCH 285/725] update sphnix requires --- requirements/requirements-docker.txt | 1 + requirements/requirements-rtd.txt | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/requirements/requirements-docker.txt b/requirements/requirements-docker.txt index 04def897..57d327a0 100644 --- a/requirements/requirements-docker.txt +++ b/requirements/requirements-docker.txt @@ -34,6 +34,7 @@ sphinx-intl sphinx-copybutton nbsphinx furo +myst-parser pylint pennylane tensorflow_quantum==0.6.1 \ No newline at end of file diff --git a/requirements/requirements-rtd.txt b/requirements/requirements-rtd.txt index c58fa3b4..cb334c99 100644 --- a/requirements/requirements-rtd.txt +++ b/requirements/requirements-rtd.txt @@ -12,4 +12,5 @@ sphinx==4.3.2 ipykernel furo==2022.4.7 sphinx-copybutton -nbsphinx \ No newline at end of file +nbsphinx +myst-parser \ No newline at end of file From e9b69f571afc6e617dd2021a8b03c40f5d15442b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 3 Feb 2023 10:14:34 +0800 Subject: [PATCH 286/725] update citation with publish in quantum --- CITATION.cff | 53 +++++++++++++++++++++++++++++++++++++++++++ README.md | 4 ++-- README_cn.md | 4 ++-- docs/source/index.rst | 2 +- 4 files changed, 58 insertions(+), 5 deletions(-) create mode 100644 CITATION.cff diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 00000000..f4fa6cc3 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,53 @@ +cff-version: 1.2.0 +message: "If you find this software helpful in your research, please cite it as below." +authors: +- family-names: "Zhang" + given-names: "Shi-Xin" +- family-names: "Chen" + given-names: "Yu-Qin" +title: "TensorCircuit" +version: 0.7.0 +date-released: 2020-04-19 +url: "https://github.com/tencent-quantum-lab/tensorcircuit" +preferred-citation: + type: article + authors: + - family-names: "Zhang" + given-names: "Shi-Xin" + - family-names: "Allcock" + given-names: "Jonathan" + - family-names: "Wan" + given-names: "Zhou-Quan" + - family-names: "Liu" + given-names: "Shuo" + - family-names: "Sun" + given-names: "Jiace" + - family-names: "Yu" + given-names: "Hao" + - family-names: "Yang" + given-names: "Xing-Han" + - family-names: "Qiu" + given-names: "Jiezhong" + - family-names: "Ye" + given-names: "Zhaofeng" + - family-names: "Chen" + given-names: "Yu-Qin" + - family-names: "Lee" + given-names: "Chee-Kong" + - family-names: "Zheng" + given-names: "Yi-Cong" + - family-names: "Jian" + given-names: "Shao-Kai" + - family-names: "Yao" + given-names: "Hong" + - family-names: "Hsieh" + given-names: "Chang-Yu" + - family-names: "Zhang" + given-names: "Shengyu" + doi: "10.22331/q-2023-02-02-912" + journal: "Quantum" + month: 2 + pages: 912 + title: "TensorCircuit: a Quantum Software Framework for the NISQ Era" + volume: 7 + year: 2023 \ No newline at end of file diff --git a/README.md b/README.md index bc28341f..5475214b 100644 --- a/README.md +++ b/README.md @@ -127,9 +127,9 @@ This project is released by [Tencent Quantum Lab](https://quantum.tencent.com/) ### Citation -If this project helps in your research, please cite our software whitepaper: +If this project helps in your research, please cite our software whitepaper published in Quantum: -[TensorCircuit: a Quantum Software Framework for the NISQ Era](https://arxiv.org/abs/2205.10091) +[TensorCircuit: a Quantum Software Framework for the NISQ Era](https://quantum-journal.org/papers/q-2023-02-02-912/) which is also a good introduction to the software. diff --git a/README_cn.md b/README_cn.md index 1fe018e7..a4a8a26d 100644 --- a/README_cn.md +++ b/README_cn.md @@ -123,9 +123,9 @@ pip install tensorcircuit-nightly ### 引用 -如果该软件对您的研究有帮助, 请引用我们的白皮书文章: +如果该软件对您的研究有帮助, 请引用我们发表在 Quantum 期刊的白皮书文章: -[TensorCircuit: a Quantum Software Framework for the NISQ Era](https://arxiv.org/abs/2205.10091). +[TensorCircuit: a Quantum Software Framework for the NISQ Era](https://quantum-journal.org/papers/q-2023-02-02-912/). ### 说明 diff --git a/docs/source/index.rst b/docs/source/index.rst index 26707cd1..e45dd318 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -25,7 +25,7 @@ We also thank `contributions Date: Mon, 6 Feb 2023 16:02:21 +0800 Subject: [PATCH 287/725] print PathFindingTime --- tensorcircuit/cons.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tensorcircuit/cons.py b/tensorcircuit/cons.py index 778d2a25..deafdbe9 100644 --- a/tensorcircuit/cons.py +++ b/tensorcircuit/cons.py @@ -5,6 +5,7 @@ import logging import sys +import time from contextlib import contextmanager from functools import partial, reduce, wraps from operator import mul @@ -707,7 +708,9 @@ def new_algorithm( size_dict: Dict[Any, int], **kws: Any, ) -> Any: + t0 = time.time() path = algorithm(input_sets, output_set, size_dict, **kws) + path_finding_time = time.time() - t0 tree = ContractionTree.from_path(input_sets, output_set, size_dict, path=path) print("------ contraction cost summary ------") print( @@ -717,6 +720,8 @@ def new_algorithm( "%.0f" % tree.contraction_width(), " log2[WRITE]: ", "%.3f" % np.log2(float(tree.total_write())), + " PathFindingTime: ", + "%.3f" % path_finding_time ) return path From fa858c1ebd46c04a201458ce58a7017da663b493 Mon Sep 17 00:00:00 2001 From: xptree Date: Mon, 6 Feb 2023 16:03:31 +0800 Subject: [PATCH 288/725] fix with black reformat --- tensorcircuit/cons.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/cons.py b/tensorcircuit/cons.py index deafdbe9..c733d8e0 100644 --- a/tensorcircuit/cons.py +++ b/tensorcircuit/cons.py @@ -721,7 +721,7 @@ def new_algorithm( " log2[WRITE]: ", "%.3f" % np.log2(float(tree.total_write())), " PathFindingTime: ", - "%.3f" % path_finding_time + "%.3f" % path_finding_time, ) return path From 5f5814b24b26196ce68f0158175774bea3b68153 Mon Sep 17 00:00:00 2001 From: xptree Date: Mon, 6 Feb 2023 16:04:28 +0800 Subject: [PATCH 289/725] add benchmark results table --- examples/omeinsum_julia/benchmark_results.csv | 295 ++++++++++++++++++ 1 file changed, 295 insertions(+) create mode 100644 examples/omeinsum_julia/benchmark_results.csv diff --git a/examples/omeinsum_julia/benchmark_results.csv b/examples/omeinsum_julia/benchmark_results.csv new file mode 100644 index 00000000..620fcb16 --- /dev/null +++ b/examples/omeinsum_julia/benchmark_results.csv @@ -0,0 +1,295 @@ +Circuit,Method,log10[FLOPs],log2[SIZE],log2[WRITE],PathFindingTime +circuit_patch_n53_m20_s19_e35_pABCDCDAB,cotengra,11.645,27.0,35.68,317.342 +circuit_patch_n53_m20_s19_e35_pABCDCDAB,treesa_greedy,11.501,27.0,34.665,602.444 +circuit_patch_n53_m20_s19_e35_pABCDCDAB,treesa_kahypar,11.496,27.0,34.543,486.355 +circuit_n53_m20_s9_e22_pABCDCDAB,cotengra,17.937,41.0,43.775,610.416 +circuit_n53_m20_s9_e22_pABCDCDAB,treesa_greedy,16.568,42.0,46.278,743.266 +circuit_n53_m20_s9_e22_pABCDCDAB,treesa_kahypar,16.861,40.0,45.633,605.181 +circuit_n53_m20_s9_e0_pABCDCDAB,cotengra,19.557,53.0,61.963,532.239 +circuit_n53_m20_s9_e0_pABCDCDAB,treesa_greedy,19.446,53.0,61.279,1560.847 +circuit_n53_m20_s9_e0_pABCDCDAB,treesa_kahypar,19.421,53.0,61.117,2265.351 +circuit_patch_n53_m18_s19_e31_pABCDCDAB,cotengra,11.575,27.0,35.454,330.965 +circuit_patch_n53_m18_s19_e31_pABCDCDAB,treesa_greedy,11.409,27.0,34.285,538.116 +circuit_patch_n53_m18_s19_e31_pABCDCDAB,treesa_kahypar,11.401,27.0,34.102,439.004 +circuit_n53_m18_s9_e19_pABCDCDAB,cotengra,14.172,34.0,37.063,1423.764 +circuit_n53_m18_s9_e19_pABCDCDAB,treesa_greedy,14.163,34.0,38.185,592.027 +circuit_n53_m18_s9_e19_pABCDCDAB,treesa_kahypar,14.163,34.0,38.382,401.272 +circuit_n53_m18_s9_e0_pABCDCDAB,cotengra,19.475,53.0,61.696,332.417 +circuit_n53_m18_s9_e0_pABCDCDAB,treesa_greedy,19.324,53.0,60.87,1414.159 +circuit_n53_m18_s9_e0_pABCDCDAB,treesa_kahypar,19.312,53.0,60.65,1886.625 +circuit_patch_n53_m16_s19_e28_pABCDCDAB,cotengra,11.504,27.0,35.211,334.772 +circuit_patch_n53_m16_s19_e28_pABCDCDAB,treesa_greedy,11.346,27.0,34.12,475.684 +circuit_patch_n53_m16_s19_e28_pABCDCDAB,treesa_kahypar,11.342,27.0,34.023,436.568 +circuit_n53_m16_s9_e15_pABCDCDAB,cotengra,17.566,42.0,44.29,928.736 +circuit_n53_m16_s9_e15_pABCDCDAB,treesa_greedy,16.08,46.0,49.819,686.65 +circuit_n53_m16_s9_e15_pABCDCDAB,treesa_kahypar,16.592,44.0,47.877,631.217 +circuit_n53_m16_s9_e0_pABCDCDAB,cotengra,19.383,53.0,61.388,377.769 +circuit_n53_m16_s9_e0_pABCDCDAB,treesa_greedy,19.219,53.0,60.47,1220.764 +circuit_n53_m16_s9_e0_pABCDCDAB,treesa_kahypar,19.24,53.0,60.536,1766.683 +circuit_patch_n53_m14_s19_e25_pABCDCDAB,cotengra,11.403,27.0,34.873,191.059 +circuit_patch_n53_m14_s19_e25_pABCDCDAB,treesa_greedy,11.192,27.0,33.343,406.669 +circuit_patch_n53_m14_s19_e25_pABCDCDAB,treesa_kahypar,11.199,27.0,33.358,375.971 +circuit_n53_m14_s9_e12_pABCDCDAB,cotengra,15.148,36.0,38.137,659.913 +circuit_n53_m14_s9_e12_pABCDCDAB,treesa_greedy,15.073,36.0,40.602,429.041 +circuit_n53_m14_s9_e12_pABCDCDAB,treesa_kahypar,15.072,36.0,40.432,346.216 +circuit_n53_m14_s9_e11_pEFGH,cotengra,16.04,40.0,41.073,450.93 +circuit_n53_m14_s9_e11_pEFGH,treesa_greedy,15.752,36.0,40.182,482.829 +circuit_n53_m14_s9_e11_pEFGH,treesa_kahypar,15.956,38.0,40.972,339.366 +circuit_n53_m14_s9_e0_pEFGH,cotengra,19.209,55.0,60.822,215.841 +circuit_n53_m14_s9_e0_pEFGH,treesa_greedy,19.038,53.0,59.909,992.68 +circuit_n53_m14_s9_e0_pEFGH,treesa_kahypar,20.484,53.0,59.617,1099.601 +circuit_n53_m14_s9_e0_pABCDCDAB,cotengra,19.229,53.0,60.874,285.173 +circuit_n53_m14_s9_e0_pABCDCDAB,treesa_greedy,19.034,53.0,59.847,966.856 +circuit_n53_m14_s9_e0_pABCDCDAB,treesa_kahypar,19.036,53.0,59.678,1400.73 +circuit_patch_n53_m12_s19_e21_pABCDCDAB,cotengra,11.279,27.0,34.473,128.908 +circuit_patch_n53_m12_s19_e21_pABCDCDAB,treesa_greedy,11.103,27.0,33.189,354.306 +circuit_patch_n53_m12_s19_e21_pABCDCDAB,treesa_kahypar,11.097,27.0,33.346,357.097 +circuit_n53_m12_s9_e8_pABCDCDAB,cotengra,18.012,49.0,49.337,228.721 +circuit_n53_m12_s9_e8_pABCDCDAB,treesa_greedy,16.568,42.0,46.236,496.834 +circuit_n53_m12_s9_e8_pABCDCDAB,treesa_kahypar,16.861,40.0,45.511,468.701 +circuit_n53_m12_s9_e0_pABCDCDAB,cotengra,19.07,53.0,60.348,204.507 +circuit_n53_m12_s9_e0_pABCDCDAB,treesa_greedy,18.873,53.0,59.324,867.543 +circuit_n53_m12_s9_e0_pABCDCDAB,treesa_kahypar,18.926,53.0,59.575,1188.158 +circuit_patch_n51_m14_s19_e25_pEFGH,cotengra,11.111,26.0,33.913,188.369 +circuit_patch_n51_m14_s19_e25_pEFGH,treesa_greedy,10.967,26.0,33.109,420.76 +circuit_patch_n51_m14_s19_e25_pEFGH,treesa_kahypar,10.982,26.0,33.079,375.921 +circuit_n51_m14_s9_e11_pEFGH,cotengra,16.265,42.0,44.935,986.076 +circuit_n51_m14_s9_e11_pEFGH,treesa_greedy,15.356,38.0,40.518,479.331 +circuit_n51_m14_s9_e11_pEFGH,treesa_kahypar,15.753,38.0,40.943,340.365 +circuit_n51_m14_s9_e0_pEFGH,cotengra,18.627,53.0,58.878,250.292 +circuit_n51_m14_s9_e0_pEFGH,treesa_greedy,18.46,51.0,58.05,925.77 +circuit_n51_m14_s9_e0_pEFGH,treesa_kahypar,18.456,51.0,58.009,1000.855 +circuit_patch_n50_m14_s19_e25_pEFGH,cotengra,10.912,25.0,33.253,170.648 +circuit_patch_n50_m14_s19_e25_pEFGH,treesa_greedy,10.77,25.0,32.364,404.916 +circuit_patch_n50_m14_s19_e25_pEFGH,treesa_kahypar,10.785,25.0,32.444,351.123 +circuit_n50_m14_s9_e6_pEFGH,cotengra,15.473,36.0,37.622,559.121 +circuit_n50_m14_s9_e6_pEFGH,treesa_greedy,15.357,35.0,38.348,468.989 +circuit_n50_m14_s9_e6_pEFGH,treesa_kahypar,15.357,35.0,38.431,304.096 +circuit_n50_m14_s9_e0_pEFGH,cotengra,18.32,50.0,57.861,291.025 +circuit_n50_m14_s9_e0_pEFGH,treesa_greedy,18.123,50.0,56.899,905.059 +circuit_n50_m14_s9_e0_pEFGH,treesa_kahypar,18.2,50.0,57.005,1064.76 +circuit_patch_n49_m14_s19_e25_pEFGH,cotengra,10.784,26.0,32.817,168.981 +circuit_patch_n49_m14_s19_e25_pEFGH,treesa_greedy,10.657,25.0,32.039,400.606 +circuit_patch_n49_m14_s19_e25_pEFGH,treesa_kahypar,10.672,25.0,31.982,360.391 +circuit_n49_m14_s9_e6_pEFGH,cotengra,15.426,40.0,43.488,977.093 +circuit_n49_m14_s9_e6_pEFGH,treesa_greedy,15.38,35.0,38.721,435.335 +circuit_n49_m14_s9_e6_pEFGH,treesa_kahypar,15.381,37.0,39.817,315.995 +circuit_n49_m14_s9_e0_pEFGH,cotengra,18.0,49.0,56.796,202.637 +circuit_n49_m14_s9_e0_pEFGH,treesa_greedy,17.812,49.0,55.846,865.665 +circuit_n49_m14_s9_e0_pEFGH,treesa_kahypar,17.902,49.0,55.917,1097.266 +circuit_patch_n48_m14_s19_e25_pEFGH,cotengra,10.579,25.0,32.142,165.566 +circuit_patch_n48_m14_s19_e25_pEFGH,treesa_greedy,10.461,24.0,31.403,388.58 +circuit_patch_n48_m14_s19_e25_pEFGH,treesa_kahypar,10.463,24.0,31.332,376.502 +circuit_n48_m14_s9_e6_pEFGH,cotengra,15.39,39.0,42.954,356.865 +circuit_n48_m14_s9_e6_pEFGH,treesa_greedy,15.075,39.0,42.456,418.301 +circuit_n48_m14_s9_e6_pEFGH,treesa_kahypar,15.353,35.0,37.725,327.35 +circuit_n48_m14_s9_e0_pEFGH,cotengra,17.699,48.0,55.797,247.7 +circuit_n48_m14_s9_e0_pEFGH,treesa_greedy,17.542,48.0,54.951,867.798 +circuit_n48_m14_s9_e0_pEFGH,treesa_kahypar,17.561,48.0,55.12,1023.973 +circuit_patch_n47_m14_s19_e21_pEFGH,cotengra,10.472,24.0,31.79,185.068 +circuit_patch_n47_m14_s19_e21_pEFGH,treesa_greedy,10.375,24.0,31.223,384.684 +circuit_patch_n47_m14_s19_e21_pEFGH,treesa_kahypar,10.371,24.0,31.002,375.058 +circuit_n47_m14_s9_e6_pEFGH,cotengra,15.392,36.0,38.739,717.684 +circuit_n47_m14_s9_e6_pEFGH,treesa_greedy,15.079,34.0,38.001,421.445 +circuit_n47_m14_s9_e6_pEFGH,treesa_kahypar,15.08,36.0,38.969,321.19 +circuit_n47_m14_s9_e0_pEFGH,cotengra,17.404,47.0,54.818,188.359 +circuit_n47_m14_s9_e0_pEFGH,treesa_greedy,17.238,47.0,53.996,806.703 +circuit_n47_m14_s9_e0_pEFGH,treesa_kahypar,17.232,47.0,53.929,1011.005 +circuit_patch_n46_m14_s19_e21_pEFGH,cotengra,10.281,23.0,31.152,152.554 +circuit_patch_n46_m14_s19_e21_pEFGH,treesa_greedy,10.197,23.0,30.537,377.39 +circuit_patch_n46_m14_s19_e21_pEFGH,treesa_kahypar,,,, +circuit_n46_m14_s9_e6_pEFGH,cotengra,13.634,36.0,39.078,520.681 +circuit_n46_m14_s9_e6_pEFGH,treesa_greedy,13.61,36.0,38.42,365.466 +circuit_n46_m14_s9_e6_pEFGH,treesa_kahypar,13.849,30.0,34.175,297.738 +circuit_n46_m14_s9_e0_pEFGH,cotengra,17.069,46.0,53.705,234.515 +circuit_n46_m14_s9_e0_pEFGH,treesa_greedy,16.904,46.0,52.783,803.606 +circuit_n46_m14_s9_e0_pEFGH,treesa_kahypar,16.977,46.0,52.974,825.773 +circuit_patch_n45_m14_s19_e21_pEFGH,cotengra,10.145,23.0,30.706,126.501 +circuit_patch_n45_m14_s19_e21_pEFGH,treesa_greedy,10.064,23.0,30.111,370.784 +circuit_patch_n45_m14_s19_e21_pEFGH,treesa_kahypar,10.068,23.0,30.111,389.19 +circuit_n45_m14_s9_e6_pEFGH,cotengra,14.805,35.0,37.31,562.626 +circuit_n45_m14_s9_e6_pEFGH,treesa_greedy,14.778,33.0,37.072,468.155 +circuit_n45_m14_s9_e6_pEFGH,treesa_kahypar,14.802,33.0,36.592,312.201 +circuit_n45_m14_s9_e0_pEFGH,cotengra,16.77,45.0,52.711,182.538 +circuit_n45_m14_s9_e0_pEFGH,treesa_greedy,16.588,45.0,51.792,758.175 +circuit_n45_m14_s9_e0_pEFGH,treesa_kahypar,16.909,45.0,52.135,845.952 +circuit_patch_n44_m14_s19_e21_pEFGH,cotengra,9.978,22.0,30.147,136.122 +circuit_patch_n44_m14_s19_e21_pEFGH,treesa_greedy,9.884,22.0,29.617,362.106 +circuit_patch_n44_m14_s19_e21_pEFGH,treesa_kahypar,,,, +circuit_n44_m14_s9_e6_pEFGH,cotengra,13.26,30.0,32.518,501.754 +circuit_n44_m14_s9_e6_pEFGH,treesa_greedy,13.249,30.0,33.105,362.069 +circuit_n44_m14_s9_e6_pEFGH,treesa_kahypar,13.25,31.0,33.689,317.296 +circuit_n44_m14_s9_e0_pEFGH,cotengra,16.472,44.0,51.716,166.682 +circuit_n44_m14_s9_e0_pEFGH,treesa_greedy,16.323,44.0,50.795,725.629 +circuit_n44_m14_s9_e0_pEFGH,treesa_kahypar,16.342,44.0,51.098,836.718 +circuit_patch_n43_m14_s19_e21_pEFGH,cotengra,9.829,22.0,29.656,141.768 +circuit_patch_n43_m14_s19_e21_pEFGH,treesa_greedy,9.741,22.0,28.902,346.601 +circuit_patch_n43_m14_s19_e21_pEFGH,treesa_kahypar,9.743,22.0,28.925,362.367 +circuit_n43_m14_s9_e6_pEFGH,cotengra,14.506,34.0,37.565,457.91 +circuit_n43_m14_s9_e6_pEFGH,treesa_greedy,14.477,32.0,36.386,417.651 +circuit_n43_m14_s9_e6_pEFGH,treesa_kahypar,14.478,34.0,37.138,325.975 +circuit_n43_m14_s9_e0_pEFGH,cotengra,16.164,43.0,50.7,188.734 +circuit_n43_m14_s9_e0_pEFGH,treesa_greedy,16.016,43.0,49.954,703.888 +circuit_n43_m14_s9_e0_pEFGH,treesa_kahypar,16.196,43.0,50.008,810.97 +circuit_patch_n42_m14_s19_e21_pEFGH,cotengra,9.635,21.0,29.008,130.04 +circuit_patch_n42_m14_s19_e21_pEFGH,treesa_greedy,9.552,21.0,28.338,334.113 +circuit_patch_n42_m14_s19_e21_pEFGH,treesa_kahypar,9.546,21.0,28.271,361.009 +circuit_n42_m14_s9_e6_pEFGH,cotengra,13.077,34.0,37.894,580.035 +circuit_n42_m14_s9_e6_pEFGH,treesa_greedy,12.949,30.0,33.037,349.173 +circuit_n42_m14_s9_e6_pEFGH,treesa_kahypar,12.949,30.0,32.338,300.511 +circuit_n42_m14_s9_e0_pEFGH,cotengra,15.853,42.0,49.668,148.982 +circuit_n42_m14_s9_e0_pEFGH,treesa_greedy,15.691,42.0,48.799,647.25 +circuit_n42_m14_s9_e0_pEFGH,treesa_kahypar,,,, +circuit_patch_n41_m14_s19_e21_pEFGH,cotengra,9.505,21.0,28.582,132.947 +circuit_patch_n41_m14_s19_e21_pEFGH,treesa_greedy,9.421,21.0,27.913,335.316 +circuit_patch_n41_m14_s19_e21_pEFGH,treesa_kahypar,9.421,21.0,27.85,362.026 +circuit_n41_m14_s9_e6_pEFGH,cotengra,15.104,33.0,36.033,193.758 +circuit_n41_m14_s9_e6_pEFGH,treesa_greedy,14.177,32.0,36.003,377.052 +circuit_n41_m14_s9_e6_pEFGH,treesa_kahypar,14.177,32.0,35.905,309.514 +circuit_n41_m14_s9_e0_pEFGH,cotengra,15.537,41.0,48.619,143.36 +circuit_n41_m14_s9_e0_pEFGH,treesa_greedy,15.377,41.0,47.724,483.166 +circuit_n41_m14_s9_e0_pEFGH,treesa_kahypar,15.374,41.0,47.552,511.412 +circuit_patch_n40_m14_s19_e21_pEFGH,cotengra,9.341,21.0,28.022,113.84 +circuit_patch_n40_m14_s19_e21_pEFGH,treesa_greedy,9.245,20.0,27.402,325.868 +circuit_patch_n40_m14_s19_e21_pEFGH,treesa_kahypar,9.245,20.0,27.224,370.192 +circuit_n40_m14_s9_e6_pEFGH,cotengra,11.782,26.0,30.112,429.931 +circuit_n40_m14_s9_e6_pEFGH,treesa_greedy,11.553,29.0,32.558,317.519 +circuit_n40_m14_s9_e6_pEFGH,treesa_kahypar,11.754,26.0,30.131,299.827 +circuit_n40_m14_s9_e0_pEFGH,cotengra,15.279,40.0,47.758,167.751 +circuit_n40_m14_s9_e0_pEFGH,treesa_greedy,15.127,40.0,46.888,485.121 +circuit_n40_m14_s9_e0_pEFGH,treesa_kahypar,15.122,40.0,46.827,570.709 +circuit_patch_n39_m14_s19_e21_pEFGH,cotengra,9.193,20.0,27.542,128.104 +circuit_patch_n39_m14_s19_e21_pEFGH,treesa_greedy,9.115,20.0,26.959,320.177 +circuit_patch_n39_m14_s19_e21_pEFGH,treesa_kahypar,9.117,20.0,26.913,356.401 +circuit_n39_m14_s9_e6_pEFGH,cotengra,14.982,39.0,46.773,155.635 +circuit_n39_m14_s9_e6_pEFGH,treesa_greedy,13.605,32.0,35.819,359.551 +circuit_n39_m14_s9_e6_pEFGH,treesa_kahypar,13.606,32.0,35.772,304.695 +circuit_n39_m14_s9_e0_pEFGH,cotengra,14.946,39.0,46.654,154.522 +circuit_n39_m14_s9_e0_pEFGH,treesa_greedy,14.83,39.0,46.045,452.056 +circuit_n39_m14_s9_e0_pEFGH,treesa_kahypar,14.839,39.0,46.029,451.003 +circuit_patch_n38_m14_s19_e18_pEFGH,cotengra,9.018,19.0,26.967,112.198 +circuit_patch_n38_m14_s19_e18_pEFGH,treesa_greedy,8.929,19.0,26.307,313.817 +circuit_patch_n38_m14_s19_e18_pEFGH,treesa_kahypar,8.927,19.0,26.208,364.629 +circuit_n38_m14_s9_e6_pEFGH,cotengra,13.44,33.0,35.424,444.322 +circuit_n38_m14_s9_e6_pEFGH,treesa_greedy,13.354,32.0,35.714,353.183 +circuit_n38_m14_s9_e6_pEFGH,treesa_kahypar,13.352,32.0,35.259,298.964 +circuit_n38_m14_s9_e0_pEFGH,cotengra,14.633,38.0,45.615,168.515 +circuit_n38_m14_s9_e0_pEFGH,treesa_greedy,14.514,38.0,44.77,426.414 +circuit_n38_m14_s9_e0_pEFGH,treesa_kahypar,14.512,38.0,44.717,465.762 +circuit_patch_n36_m14_s19_e18_pEFGH,cotengra,8.685,18.0,25.848,106.775 +circuit_patch_n36_m14_s19_e18_pEFGH,treesa_greedy,8.597,18.0,25.117,297.455 +circuit_patch_n36_m14_s19_e18_pEFGH,treesa_kahypar,8.595,18.0,25.207,349.325 +circuit_n36_m14_s9_e6_pEFGH,cotengra,13.31,30.0,33.416,399.867 +circuit_n36_m14_s9_e6_pEFGH,treesa_greedy,12.987,32.0,34.57,313.595 +circuit_n36_m14_s9_e6_pEFGH,treesa_kahypar,12.982,30.0,34.073,306.227 +circuit_n36_m14_s9_e0_pEFGH,cotengra,14.047,36.0,43.666,112.642 +circuit_n36_m14_s9_e0_pEFGH,treesa_greedy,13.899,36.0,42.852,334.293 +circuit_n36_m14_s9_e0_pEFGH,treesa_kahypar,13.897,36.0,42.839,342.502 +circuit_patch_n34_m14_s19_e18_pEFGH,cotengra,8.364,17.0,24.796,89.63 +circuit_patch_n34_m14_s19_e18_pEFGH,treesa_greedy,8.28,17.0,24.047,276.926 +circuit_patch_n34_m14_s19_e18_pEFGH,treesa_kahypar,8.28,17.0,23.999,351.047 +circuit_n34_m14_s9_e6_pEFGH,cotengra,12.977,30.0,32.099,186.683 +circuit_n34_m14_s9_e6_pEFGH,treesa_greedy,12.417,32.0,34.306,290.161 +circuit_n34_m14_s9_e6_pEFGH,treesa_kahypar,12.409,31.0,34.133,301.459 +circuit_n34_m14_s9_e0_pEFGH,cotengra,13.366,34.0,41.184,723.872 +circuit_n34_m14_s9_e0_pEFGH,treesa_greedy,13.235,34.0,40.647,321.03 +circuit_n34_m14_s9_e0_pEFGH,treesa_kahypar,13.304,34.0,40.84,313.386 +circuit_patch_n32_m14_s19_e18_pEFGH,cotengra,8.146,17.0,24.073,74.613 +circuit_patch_n32_m14_s19_e18_pEFGH,treesa_greedy,8.06,17.0,23.497,260.724 +circuit_patch_n32_m14_s19_e18_pEFGH,treesa_kahypar,8.06,17.0,23.349,339.217 +circuit_n32_m14_s9_e6_pEFGH,cotengra,12.455,30.0,31.599,274.974 +circuit_n32_m14_s9_e6_pEFGH,treesa_greedy,12.387,32.0,37.673,282.553 +circuit_n32_m14_s9_e6_pEFGH,treesa_kahypar,11.927,30.0,33.364,287.065 +circuit_n32_m14_s9_e0_pEFGH,cotengra,12.767,32.0,39.409,102.515 +circuit_n32_m14_s9_e0_pEFGH,treesa_greedy,12.613,32.0,38.534,301.8 +circuit_n32_m14_s9_e0_pEFGH,treesa_kahypar,12.616,32.0,38.531,315.007 +circuit_patch_n30_m14_s19_e18_pEFGH,cotengra,7.729,15.0,22.669,71.216 +circuit_patch_n30_m14_s19_e18_pEFGH,treesa_greedy,7.627,15.0,21.929,244.174 +circuit_patch_n30_m14_s19_e18_pEFGH,treesa_kahypar,7.627,15.0,21.85,325.5 +circuit_n30_m14_s9_e6_pEFGH,cotengra,11.93,30.0,36.445,126.822 +circuit_n30_m14_s9_e6_pEFGH,treesa_greedy,11.767,30.0,35.616,266.514 +circuit_n30_m14_s9_e6_pEFGH,treesa_kahypar,11.755,30.0,35.362,294.707 +circuit_n30_m14_s9_e0_pEFGH,cotengra,12.108,30.0,37.106,589.94 +circuit_n30_m14_s9_e0_pEFGH,treesa_greedy,12.008,30.0,36.456,281.111 +circuit_n30_m14_s9_e0_pEFGH,treesa_kahypar,12.004,30.0,36.513,336.693 +circuit_patch_n28_m14_s19_e18_pEFGH,cotengra,7.391,15.0,21.548,66.319 +circuit_patch_n28_m14_s19_e18_pEFGH,treesa_greedy,7.296,14.0,20.873,224.338 +circuit_patch_n28_m14_s19_e18_pEFGH,treesa_kahypar,7.296,14.0,20.795,324.174 +circuit_n28_m14_s9_e6_pEFGH,cotengra,11.337,28.0,34.601,127.216 +circuit_n28_m14_s9_e6_pEFGH,treesa_greedy,11.165,28.0,33.674,246.72 +circuit_n28_m14_s9_e6_pEFGH,treesa_kahypar,11.159,28.0,33.527,312.592 +circuit_n28_m14_s9_e0_pEFGH,cotengra,11.535,28.0,35.321,94.159 +circuit_n28_m14_s9_e0_pEFGH,treesa_greedy,11.42,28.0,34.62,264.422 +circuit_n28_m14_s9_e0_pEFGH,treesa_kahypar,11.423,28.0,34.546,339.157 +circuit_patch_n26_m14_s19_e18_pEFGH,cotengra,7.176,14.0,20.847,60.356 +circuit_patch_n26_m14_s19_e18_pEFGH,treesa_greedy,7.079,14.0,20.039,213.163 +circuit_patch_n26_m14_s19_e18_pEFGH,treesa_kahypar,7.079,14.0,19.986,331.146 +circuit_n26_m14_s9_e6_pEFGH,cotengra,10.81,26.0,32.907,360.491 +circuit_n26_m14_s9_e6_pEFGH,treesa_greedy,10.563,26.0,31.617,238.924 +circuit_n26_m14_s9_e6_pEFGH,treesa_kahypar,10.551,26.0,31.253,291.778 +circuit_n26_m14_s9_e0_pEFGH,cotengra,10.913,26.0,33.164,408.503 +circuit_n26_m14_s9_e0_pEFGH,treesa_greedy,10.83,26.0,32.713,254.088 +circuit_n26_m14_s9_e0_pEFGH,treesa_kahypar,10.826,26.0,32.389,337.32 +circuit_patch_n24_m14_s19_e18_pEFGH,cotengra,6.73,12.0,19.35,59.624 +circuit_patch_n24_m14_s19_e18_pEFGH,treesa_greedy,6.646,12.0,18.69,200.344 +circuit_patch_n24_m14_s19_e18_pEFGH,treesa_kahypar,6.646,12.0,18.693,299.906 +circuit_n24_m14_s9_e6_pEFGH,cotengra,10.161,24.0,30.525,283.776 +circuit_n24_m14_s9_e6_pEFGH,treesa_greedy,9.962,24.0,29.678,223.605 +circuit_n24_m14_s9_e6_pEFGH,treesa_kahypar,9.957,24.0,29.504,360.26 +circuit_n24_m14_s9_e0_pEFGH,cotengra,10.316,24.0,31.273,72.708 +circuit_n24_m14_s9_e0_pEFGH,treesa_greedy,10.227,24.0,30.624,236.467 +circuit_n24_m14_s9_e0_pEFGH,treesa_kahypar,10.227,24.0,30.754,331.976 +circuit_patch_n22_m14_s19_e18_pEFGH,cotengra,6.355,12.0,18.102,52.99 +circuit_patch_n22_m14_s19_e18_pEFGH,treesa_greedy,6.279,11.0,17.415,183.257 +circuit_patch_n22_m14_s19_e18_pEFGH,treesa_kahypar,6.28,11.0,17.483,267.011 +circuit_n22_m14_s9_e6_pEFGH,cotengra,9.467,22.0,28.381,120.142 +circuit_n22_m14_s9_e6_pEFGH,treesa_greedy,9.331,22.0,27.346,202.433 +circuit_n22_m14_s9_e6_pEFGH,treesa_kahypar,9.331,22.0,27.448,272.657 +circuit_n22_m14_s9_e0_pEFGH,cotengra,9.677,23.0,29.144,78.247 +circuit_n22_m14_s9_e0_pEFGH,treesa_greedy,9.577,22.0,28.358,215.617 +circuit_n22_m14_s9_e0_pEFGH,treesa_kahypar,9.579,22.0,28.466,307.613 +circuit_patch_n20_m14_s19_e18_pEFGH,cotengra,6.134,11.0,17.382,49.623 +circuit_patch_n20_m14_s19_e18_pEFGH,treesa_greedy,6.053,11.0,16.795,167.424 +circuit_patch_n20_m14_s19_e18_pEFGH,treesa_kahypar,6.053,11.0,16.695,247.914 +circuit_n20_m14_s9_e6_pEFGH,cotengra,8.894,20.0,26.542,150.987 +circuit_n20_m14_s9_e6_pEFGH,treesa_greedy,8.7,20.0,25.433,190.071 +circuit_n20_m14_s9_e6_pEFGH,treesa_kahypar,8.7,20.0,25.527,258.81 +circuit_n20_m14_s9_e0_pEFGH,cotengra,9.035,20.0,27.015,61.283 +circuit_n20_m14_s9_e0_pEFGH,treesa_greedy,8.919,20.0,26.257,199.232 +circuit_n20_m14_s9_e0_pEFGH,treesa_kahypar,8.919,20.0,26.13,284.502 +circuit_patch_n18_m14_s19_e18_pEFGH,cotengra,5.634,9.0,15.699,45.035 +circuit_patch_n18_m14_s19_e18_pEFGH,treesa_greedy,5.58,9.0,15.302,148.657 +circuit_patch_n18_m14_s19_e18_pEFGH,treesa_kahypar,5.578,9.0,15.371,219.656 +circuit_n18_m14_s9_e6_pEFGH,cotengra,8.21,18.0,24.042,133.862 +circuit_n18_m14_s9_e6_pEFGH,treesa_greedy,8.084,18.0,23.465,172.065 +circuit_n18_m14_s9_e6_pEFGH,treesa_kahypar,8.084,18.0,23.504,245.05 +circuit_n18_m14_s9_e0_pEFGH,cotengra,8.368,18.0,24.778,66.721 +circuit_n18_m14_s9_e0_pEFGH,treesa_greedy,8.3,18.0,24.309,188.926 +circuit_n18_m14_s9_e0_pEFGH,treesa_kahypar,8.296,18.0,24.173,277.908 +circuit_patch_n16_m14_s19_e18_pEFGH,cotengra,5.244,8.0,14.35,40.832 +circuit_patch_n16_m14_s19_e18_pEFGH,treesa_greedy,5.223,8.0,14.195,115.272 +circuit_patch_n16_m14_s19_e18_pEFGH,treesa_kahypar,5.221,8.0,14.219,175.4 +circuit_n16_m14_s9_e6_pEFGH,cotengra,7.581,16.0,22.179,85.893 +circuit_n16_m14_s9_e6_pEFGH,treesa_greedy,7.461,16.0,21.426,152.915 +circuit_n16_m14_s9_e6_pEFGH,treesa_kahypar,7.461,16.0,21.376,231.679 +circuit_n16_m14_s9_e0_pEFGH,cotengra,7.722,16.0,22.646,50.145 +circuit_n16_m14_s9_e0_pEFGH,treesa_greedy,7.657,16.0,22.006,165.097 +circuit_n16_m14_s9_e0_pEFGH,treesa_kahypar,7.657,16.0,22.083,264.186 +circuit_patch_n14_m14_s19_e18_pEFGH,cotengra,5.037,8.0,13.656,38.015 +circuit_patch_n14_m14_s19_e18_pEFGH,treesa_greedy,5.026,8.0,13.613,96.427 +circuit_patch_n14_m14_s19_e18_pEFGH,treesa_kahypar,5.026,8.0,13.612,151.793 +circuit_n14_m14_s9_e6_pEFGH,cotengra,6.903,14.0,19.89,41.915 +circuit_n14_m14_s9_e6_pEFGH,treesa_greedy,6.881,14.0,19.67,135.775 +circuit_n14_m14_s9_e6_pEFGH,treesa_kahypar,6.877,14.0,19.566,201.495 +circuit_n14_m14_s9_e0_pEFGH,cotengra,7.056,14.0,20.401,47.314 +circuit_n14_m14_s9_e0_pEFGH,treesa_greedy,7.037,14.0,20.083,147.727 +circuit_n14_m14_s9_e0_pEFGH,treesa_kahypar,7.037,14.0,20.186,247.662 +circuit_patch_n12_m14_s19_e18_pEFGH,cotengra,4.601,6.0,12.309,34.705 +circuit_patch_n12_m14_s19_e18_pEFGH,treesa_greedy,4.599,6.0,12.293,77.623 +circuit_patch_n12_m14_s19_e18_pEFGH,treesa_kahypar,4.599,6.0,12.293,121.916 +circuit_n12_m14_s9_e6_pEFGH,cotengra,6.237,12.0,17.714,80.464 +circuit_n12_m14_s9_e6_pEFGH,treesa_greedy,6.197,12.0,17.461,115.898 +circuit_n12_m14_s9_e6_pEFGH,treesa_kahypar,6.197,12.0,17.362,188.599 +circuit_n12_m14_s9_e0_pEFGH,cotengra,6.407,12.0,18.252,44.137 +circuit_n12_m14_s9_e0_pEFGH,treesa_greedy,6.387,12.0,18.075,133.648 +circuit_n12_m14_s9_e0_pEFGH,treesa_kahypar,6.387,12.0,18.077,218.335 From a98456184bb12521fa0a763cc3a69c73d61a5b13 Mon Sep 17 00:00:00 2001 From: xptree Date: Mon, 6 Feb 2023 16:51:47 +0800 Subject: [PATCH 290/725] update README --- examples/omeinsum_julia/README.md | 95 +++++++++++++++++++++++++------ 1 file changed, 78 insertions(+), 17 deletions(-) diff --git a/examples/omeinsum_julia/README.md b/examples/omeinsum_julia/README.md index 86e39c05..a35ce16d 100644 --- a/examples/omeinsum_julia/README.md +++ b/examples/omeinsum_julia/README.md @@ -7,48 +7,109 @@ We provide two solutions: * use subprocess to call a stand-alone julia script (recommended) * use juliacall to integrate julia script into python (seems to be more elegant, but not recommended) -We highly recommend use the first solution based on subprocess, not only due to its compatibility to julia multi-threading, but also because the experimental KaHyPar-based initialization is developed based on it. - - -## Subprocess solution (Recommended) - -This solution calls a stand-alone julia script `omeinsum.jl` for tensor network contraction. - -### Setup +We highly recommend to use the first solution based on subprocess, not only due to its compatibility to julia multi-threading, but also because the experimental KaHyPar-based initialization is developed based on it. + +## Experiments + +We test contractors from OMEinsum on Google random circuits ([available online](https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8)) and compare with the cotengra contractor. +We list experimental results in [benchmark_results.csv](benchmark_results.csv). + + +Specifically, we test the following three methods: + +* **cotengra**: the HyperOptimizer from cotengra. More formally: +```python +opt = ctg.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel=True, + minimize="flops", + max_repeats=1024, + progbar=False, +) +``` +* **treesa_greedy**: TreeSA contractor with greedy initialization. More formally: +```python +opt = OMEinsumTreeSAOptimizerSubprocess( + sc_target=60, sc_weight=0.0, rw_weight=0.0, ntrials=16, niters=64 +) +``` +* **treesa_kahypar**: TreeSA contractor with kahypar initialization, where the betas hyperparameters (initial temperature for SA) are [suggested by the author of OMEimsum](https://github.com/TensorBFS/OMEinsumContractionOrders.jl/issues/35#issuecomment-1397117653). More formally: +```python +opt = OMEinsumTreeSAOptimizerSubprocess( + sc_target=60, + sc_weight=0.0, + rw_weight=0.0, + kahypar_init=True, + ntrials=16, + niters=64, + betas=(10, 0.01, 40), +) +``` + +The above three `opt` are passed to TensorCircuit for contraction, respectively: +```python +tc.set_contractor( + "custom", + optimizer=opt, + preprocessing=True, + contraction_info=True, + debug_level=2, +) +``` + +We compute +```python +c.expectation_ps(z=[0], reuse=False) +``` + +Both OMEimsum and cotengra are able to optimize a weighted average of `log10[FLOPs]`, `log2[SIZE]` and `log2[WRITE]`. +However, OMEimsum and cotengra have different weight coefficient, which makes fair comparison difficult. +Thus we force each method to purely optimized `FLOPs`, but we do collect all contraction information in the table, including +`log10[FLOPs]`, `log2[SIZE]`, `log2[WRITE]`, `PathFindingTime`. + + +## Details about subprocess and JuliaCall solutions +### Subprocess solution (Recommended) + +This solution calls a stand-alone julia script [omeinsum.jl](omeinsum.jl) for tensor network contraction. + +#### Setup * Step 1: install julia, see https://julialang.org/download/. Please install julia >= 1.8.5, the 1.6.7 LTS version raises: `Error in python: free(): invalid pointer` * Step 2: add julia path to the PATH env variable so that we can find it * Step 3: install julia package `OMEinsum`, `ArgParse`, `JSON` and `KaHyPar`, this example was tested with OMEinsum v0.7.2, ArgParse v1.1.4, JSON v0.21.3 and KaHyPar v0.3.0. See https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager -### How to run +#### How to run Run `JULIA_NUM_THREADS=N python omeinsum_contractor_subprocess.py`. The env variable `JULIA_NUM_THREADS=N` will be passed to the julia script, so that you can enjoy the accelaration brought by julia multi-threading. -### KaHyPar initialization +#### KaHyPar initialization The choice of initial status plays an important role in simulated annealing. -In a discussion with the author of OMEinsum https://github.com/TensorBFS/OMEinsumContractionOrders.jl/issues/35, we +In a [discussion with the author of OMEinsum](https://github.com/TensorBFS/OMEinsumContractionOrders.jl/issues/35), we found that there was a way to run TreeSA with initialzier other than greedy or random. We demo how KaHyPar can be used to produce the initial status of simulated annealing. Although we haven't seen significant improvement by using KaHyPar initialization, we believe it is a interesting topic to explore. -## JuliaCall solution (Not Recommended) +### JuliaCall solution (Not Recommended) JuliaCall seems to be a more elegant solution because all related code are integrated into a single python script. -However, in order to use julia multi-threading in juliacall, we have to turn off julia GC at the risk of OOM. See see https://github.com/cjdoris/PythonCall.jl/issues/219 for more details. +However, in order to use julia multi-threading in juliacall, we have to turn off julia GC at the risk of OOM. See see [this issue](https://github.com/cjdoris/PythonCall.jl/issues/219) for more details. -### Setup +#### Setup -* Step 1: install julia, see https://julialang.org/download/. Please install julia >= 1.8.5, the 1.6.7 LTS version raises: `Error in python: free(): invalid pointer` +* Step 1: install julia (say, from [here](https://julialang.org/download/)). Please install julia >= 1.8.5, the 1.6.7 LTS version raises: `Error in python: free(): invalid pointer` * Step 2: add julia path to the PATH env variable so that juliacall can find it * Step 3: install juliacall via `pip install juliacall`, this example was tested with juliacall 0.9.9 -* Step 4: install julia package `OMEinsum`, this example was tested with OMEinsum v0.7.2, see https://docs.julialang.org/en/v1/stdlib/Pkg/ for more details on julia's package manager +* Step 4: install julia package `OMEinsum`, this example was tested with OMEinsum v0.7.2, see [here](https://docs.julialang.org/en/v1/stdlib/Pkg/) for more details on julia's package manager * Step 5: for julia multi-threading, set env variable `PYTHON_JULIACALL_THREADS=`. -### How to run +#### How to run Run `PYTHON_JULIACALL_THREADS= python omeinsum_contractor_juliacall.py`. + + From 40f2d42df79bd2bf6ba72f4f27da359f50a63705 Mon Sep 17 00:00:00 2001 From: xptree Date: Mon, 6 Feb 2023 17:03:10 +0800 Subject: [PATCH 291/725] Update README --- examples/omeinsum_julia/README.md | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/examples/omeinsum_julia/README.md b/examples/omeinsum_julia/README.md index a35ce16d..7175e1f9 100644 --- a/examples/omeinsum_julia/README.md +++ b/examples/omeinsum_julia/README.md @@ -12,6 +12,8 @@ We highly recommend to use the first solution based on subprocess, not only due ## Experiments We test contractors from OMEinsum on Google random circuits ([available online](https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8)) and compare with the cotengra contractor. +For circuits only differ in PRNG seed number (which means with the same tensor network structure, but different tenser entries), we choose the one with the largest seed. For example, we benchmark `circuit_n12_m14_s9_e6_pEFGH.qsim`, but skip +circuits like `circuit_n12_m14_s0_e6_pEFGH.qsim`. We list experimental results in [benchmark_results.csv](benchmark_results.csv). @@ -36,13 +38,13 @@ opt = OMEinsumTreeSAOptimizerSubprocess( * **treesa_kahypar**: TreeSA contractor with kahypar initialization, where the betas hyperparameters (initial temperature for SA) are [suggested by the author of OMEimsum](https://github.com/TensorBFS/OMEinsumContractionOrders.jl/issues/35#issuecomment-1397117653). More formally: ```python opt = OMEinsumTreeSAOptimizerSubprocess( - sc_target=60, - sc_weight=0.0, - rw_weight=0.0, - kahypar_init=True, - ntrials=16, - niters=64, - betas=(10, 0.01, 40), + sc_target=60, + sc_weight=0.0, + rw_weight=0.0, + kahypar_init=True, + ntrials=16, + niters=64, + betas=(10, 0.01, 40), ) ``` @@ -67,6 +69,8 @@ However, OMEimsum and cotengra have different weight coefficient, which makes fa Thus we force each method to purely optimized `FLOPs`, but we do collect all contraction information in the table, including `log10[FLOPs]`, `log2[SIZE]`, `log2[WRITE]`, `PathFindingTime`. +For three circuits, namely `circuit_patch_n46_m14_s19_e21_pEFGH`, `circuit_patch_n44_m14_s19_e21_pEFGH` and `circuit_n42_m14_s9_e0_pEFGH`, we meet [errors in OMEinsum](https://github.com/TensorBFS/OMEinsumContractionOrders.jl/issues/35#issuecomment-1405236778), and there results are set to empty in [benchmark_results.csv](benchmark_results.csv). + ## Details about subprocess and JuliaCall solutions ### Subprocess solution (Recommended) From b3094419a1f3b102d8edd4d32588bf8a26c0af69 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Mon, 6 Feb 2023 18:21:35 +0800 Subject: [PATCH 292/725] add readout mitigation example --- examples/qem.py | 89 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) create mode 100644 examples/qem.py diff --git a/examples/qem.py b/examples/qem.py new file mode 100644 index 00000000..f942c89e --- /dev/null +++ b/examples/qem.py @@ -0,0 +1,89 @@ +import numpy as np + +import tensorcircuit as tc +from tensorcircuit.results import counts +from tensorcircuit.results.readout_mitigation import ReadoutMit + + +def partial_sample(c, batch, readout_error=None): + measure_index = [] + for inst in c._extra_qir: + if inst["name"] == "measure": + measure_index.append(inst["index"][0]) + if len(measure_index) == 0: + measure_index = list(range(c._nqubits)) + + ct = c.sample( + allow_state=True, + batch=batch, + readout_error=readout_error, + format="count_dict_bin", + ) + return tc.results.counts.marginal_count(ct, measure_index) + + +def run(cs, shots): + # customized backend for mitigation test + ts = [] + for c in cs: + count = simulator(c, shots) + ts.append(count) + return ts + + +def simulator(c, shots, logical_physical_mapping=None): + # with readout_error noise + nqubit = c._nqubits + if logical_physical_mapping is None: + logical_physical_mapping = {i: i for i in range(nqubit)} + + gg = [] + for i in range(200): + gg.append(np.sin(i) * 0.02 + 0.978) + # gg.append(0.98 - i * 0.01) + readout_error = np.reshape(gg[0 : nqubit * 2], (nqubit, 2)) + mapped_readout_error = [[1, 1]] * nqubit + for lq, phyq in logical_physical_mapping.items(): + mapped_readout_error[lq] = readout_error[phyq] + return partial_sample(c, shots, mapped_readout_error) + + +def apply_readout_mitigation(): + nqubit = 4 + c = tc.Circuit(nqubit) + c.H(0) + c.cnot(0, 1) + c.x(3) + + idea_count = c.sample(batch=100000, allow_state=True, format="count_dict_bin") + raw_count = run([c], 100000)[0] + + cal_qubits = [0, 1, 2, 3] + use_qubits = [0, 1] + + # idea_value = c.expectation_ps(z=[0,1]) + idea_count2 = counts.marginal_count(idea_count, use_qubits) + idea_value = counts.expectation(idea_count2, z=[0, 1]) + + # use case 1 + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="local") + mit_count = mit.apply_correction(raw_count, use_qubits, method="inverse") + mit_value1 = counts.expectation(mit_count, z=[0, 1]) + + # use case 2 + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="local") + mit_value2 = mit.expectation(raw_count, z=[0, 1], method="inverse") + + # use case 3 + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=100000, method="global") + mit_value3 = mit.expectation(raw_count, z=[0, 1], method="square") + + print("idea expectation value:", idea_value) + print("mitigated expectation value:", mit_value1, mit_value2, mit_value3) + + +if __name__ == "__main__": + apply_readout_mitigation() From 4b768fc8cb23753ee6d417e22dab31dc08e367fb Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Tue, 7 Feb 2023 14:28:18 +0800 Subject: [PATCH 293/725] add readout mitigation example to qem_method.py --- examples/qem_method.py | 91 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 examples/qem_method.py diff --git a/examples/qem_method.py b/examples/qem_method.py new file mode 100644 index 00000000..e4d718f9 --- /dev/null +++ b/examples/qem_method.py @@ -0,0 +1,91 @@ +import numpy as np + +import tensorcircuit as tc +from tensorcircuit.results import counts +from tensorcircuit.results.readout_mitigation import ReadoutMit + + +def partial_sample(c, batch, readout_error=None): + measure_index = [] + for inst in c._extra_qir: + if inst["name"] == "measure": + measure_index.append(inst["index"][0]) + if len(measure_index) == 0: + measure_index = list(range(c._nqubits)) + + ct = c.sample( + allow_state=True, + batch=batch, + readout_error=readout_error, + format="count_dict_bin", + ) + return tc.results.counts.marginal_count(ct, measure_index) + + +def run(cs, shots): + # customized backend for mitigation test + ts = [] + for c in cs: + count = simulator(c, shots) + ts.append(count) + return ts + + +def simulator(c, shots, logical_physical_mapping=None): + # with readout_error noise + nqubit = c._nqubits + if logical_physical_mapping is None: + logical_physical_mapping = {i: i for i in range(nqubit)} + + gg = [] + for i in range(200): + gg.append(np.sin(i) * 0.02 + 0.978) + # gg.append(0.98 - i * 0.01) + readout_error = np.reshape(gg[0 : nqubit * 2], (nqubit, 2)) + mapped_readout_error = [[1, 1]] * nqubit + for lq, phyq in logical_physical_mapping.items(): + mapped_readout_error[lq] = readout_error[phyq] + return partial_sample(c, shots, mapped_readout_error) + + +def apply_readout_mitigation(): + nqubit = 4 + c = tc.Circuit(nqubit) + c.H(0) + c.cnot(0, 1) + c.x(3) + + shots=10000 + + idea_count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") + raw_count = run([c], 100000)[0] + + cal_qubits = [0, 1, 2, 3] + use_qubits = [0, 1] + + # idea_value = c.expectation_ps(z=[0,1]) + idea_count2 = counts.marginal_count(idea_count, use_qubits) + idea_value = counts.expectation(idea_count2, z=[0, 1]) + + # use case 1 + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=shots, method="local") + mit_count = mit.apply_correction(raw_count, use_qubits, method="inverse") + mit_value1 = counts.expectation(mit_count, z=[0, 1]) + + # use case 2 + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=shots, method="local") + mit_value2 = mit.expectation(raw_count, z=[0, 1], method="inverse") + + # use case 3 + mit = ReadoutMit(execute=run) + mit.cals_from_system(cal_qubits, shots=shots, method="global") + mit_value3 = mit.expectation(raw_count, z=[0, 1], method="square") + + print("idea expectation value:", idea_value) + print("mitigated expectation value:", mit_value1, mit_value2, mit_value3) + + +if __name__ == "__main__": + apply_readout_mitigation() From 6dc751f9d48ed076b995a651f98a35f5bc59fcfa Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Tue, 7 Feb 2023 14:31:42 +0800 Subject: [PATCH 294/725] revise readout mitigation example --- examples/qem_method.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/qem_method.py b/examples/qem_method.py index e4d718f9..83c177f0 100644 --- a/examples/qem_method.py +++ b/examples/qem_method.py @@ -55,7 +55,7 @@ def apply_readout_mitigation(): c.cnot(0, 1) c.x(3) - shots=10000 + shots = 10000 idea_count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") raw_count = run([c], 100000)[0] From c95aa974068916bfa3b00e6213737ed9a9a5a9cc Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Tue, 7 Feb 2023 14:38:56 +0800 Subject: [PATCH 295/725] add readout_mitigation.py --- examples/qem.py | 89 ------------------- .../{qem_method.py => readout_mitigation.py} | 0 2 files changed, 89 deletions(-) delete mode 100644 examples/qem.py rename examples/{qem_method.py => readout_mitigation.py} (100%) diff --git a/examples/qem.py b/examples/qem.py deleted file mode 100644 index f942c89e..00000000 --- a/examples/qem.py +++ /dev/null @@ -1,89 +0,0 @@ -import numpy as np - -import tensorcircuit as tc -from tensorcircuit.results import counts -from tensorcircuit.results.readout_mitigation import ReadoutMit - - -def partial_sample(c, batch, readout_error=None): - measure_index = [] - for inst in c._extra_qir: - if inst["name"] == "measure": - measure_index.append(inst["index"][0]) - if len(measure_index) == 0: - measure_index = list(range(c._nqubits)) - - ct = c.sample( - allow_state=True, - batch=batch, - readout_error=readout_error, - format="count_dict_bin", - ) - return tc.results.counts.marginal_count(ct, measure_index) - - -def run(cs, shots): - # customized backend for mitigation test - ts = [] - for c in cs: - count = simulator(c, shots) - ts.append(count) - return ts - - -def simulator(c, shots, logical_physical_mapping=None): - # with readout_error noise - nqubit = c._nqubits - if logical_physical_mapping is None: - logical_physical_mapping = {i: i for i in range(nqubit)} - - gg = [] - for i in range(200): - gg.append(np.sin(i) * 0.02 + 0.978) - # gg.append(0.98 - i * 0.01) - readout_error = np.reshape(gg[0 : nqubit * 2], (nqubit, 2)) - mapped_readout_error = [[1, 1]] * nqubit - for lq, phyq in logical_physical_mapping.items(): - mapped_readout_error[lq] = readout_error[phyq] - return partial_sample(c, shots, mapped_readout_error) - - -def apply_readout_mitigation(): - nqubit = 4 - c = tc.Circuit(nqubit) - c.H(0) - c.cnot(0, 1) - c.x(3) - - idea_count = c.sample(batch=100000, allow_state=True, format="count_dict_bin") - raw_count = run([c], 100000)[0] - - cal_qubits = [0, 1, 2, 3] - use_qubits = [0, 1] - - # idea_value = c.expectation_ps(z=[0,1]) - idea_count2 = counts.marginal_count(idea_count, use_qubits) - idea_value = counts.expectation(idea_count2, z=[0, 1]) - - # use case 1 - mit = ReadoutMit(execute=run) - mit.cals_from_system(cal_qubits, shots=100000, method="local") - mit_count = mit.apply_correction(raw_count, use_qubits, method="inverse") - mit_value1 = counts.expectation(mit_count, z=[0, 1]) - - # use case 2 - mit = ReadoutMit(execute=run) - mit.cals_from_system(cal_qubits, shots=100000, method="local") - mit_value2 = mit.expectation(raw_count, z=[0, 1], method="inverse") - - # use case 3 - mit = ReadoutMit(execute=run) - mit.cals_from_system(cal_qubits, shots=100000, method="global") - mit_value3 = mit.expectation(raw_count, z=[0, 1], method="square") - - print("idea expectation value:", idea_value) - print("mitigated expectation value:", mit_value1, mit_value2, mit_value3) - - -if __name__ == "__main__": - apply_readout_mitigation() diff --git a/examples/qem_method.py b/examples/readout_mitigation.py similarity index 100% rename from examples/qem_method.py rename to examples/readout_mitigation.py From d6a6909879f47698b0988f3544f346f34c012a87 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 7 Feb 2023 14:54:37 +0800 Subject: [PATCH 296/725] improve rem example --- examples/readout_mitigation.py | 38 +++++++++++++++++----------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/examples/readout_mitigation.py b/examples/readout_mitigation.py index 83c177f0..5429d894 100644 --- a/examples/readout_mitigation.py +++ b/examples/readout_mitigation.py @@ -1,7 +1,6 @@ import numpy as np import tensorcircuit as tc -from tensorcircuit.results import counts from tensorcircuit.results.readout_mitigation import ReadoutMit @@ -22,15 +21,6 @@ def partial_sample(c, batch, readout_error=None): return tc.results.counts.marginal_count(ct, measure_index) -def run(cs, shots): - # customized backend for mitigation test - ts = [] - for c in cs: - count = simulator(c, shots) - ts.append(count) - return ts - - def simulator(c, shots, logical_physical_mapping=None): # with readout_error noise nqubit = c._nqubits @@ -40,7 +30,7 @@ def simulator(c, shots, logical_physical_mapping=None): gg = [] for i in range(200): gg.append(np.sin(i) * 0.02 + 0.978) - # gg.append(0.98 - i * 0.01) + # mocked readout error readout_error = np.reshape(gg[0 : nqubit * 2], (nqubit, 2)) mapped_readout_error = [[1, 1]] * nqubit for lq, phyq in logical_physical_mapping.items(): @@ -48,6 +38,16 @@ def simulator(c, shots, logical_physical_mapping=None): return partial_sample(c, shots, mapped_readout_error) +def run(cs, shots): + # customized backend for mitigation test + # a simulator with readout error and qubit mapping supporting batch submission + ts = [] + for c in cs: + count = simulator(c, shots) + ts.append(count) + return ts + + def apply_readout_mitigation(): nqubit = 4 c = tc.Circuit(nqubit) @@ -57,28 +57,28 @@ def apply_readout_mitigation(): shots = 10000 - idea_count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") - raw_count = run([c], 100000)[0] + raw_count = run([c], shots)[0] cal_qubits = [0, 1, 2, 3] use_qubits = [0, 1] # idea_value = c.expectation_ps(z=[0,1]) - idea_count2 = counts.marginal_count(idea_count, use_qubits) - idea_value = counts.expectation(idea_count2, z=[0, 1]) + idea_count = partial_sample(c, batch=shots) + idea_count = tc.results.counts.marginal_count(idea_count, use_qubits) + idea_value = tc.results.counts.expectation(idea_count, z=[0, 1]) # use case 1 mit = ReadoutMit(execute=run) mit.cals_from_system(cal_qubits, shots=shots, method="local") mit_count = mit.apply_correction(raw_count, use_qubits, method="inverse") - mit_value1 = counts.expectation(mit_count, z=[0, 1]) + mit_value1 = tc.results.counts.expectation(mit_count, z=[0, 1]) - # use case 2 + # use case 2: directly mitigation on expectation mit = ReadoutMit(execute=run) mit.cals_from_system(cal_qubits, shots=shots, method="local") - mit_value2 = mit.expectation(raw_count, z=[0, 1], method="inverse") + mit_value2 = mit.expectation(raw_count, z=[0, 1]) - # use case 3 + # use case 3: global calibriation mit = ReadoutMit(execute=run) mit.cals_from_system(cal_qubits, shots=shots, method="global") mit_value3 = mit.expectation(raw_count, z=[0, 1], method="square") From b62fdb025d07e6115d5984ccf64c355120a6dbb4 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 7 Feb 2023 22:16:33 +0800 Subject: [PATCH 297/725] add batched expectation ps hardware abstraction --- tensorcircuit/cloud/wrapper.py | 74 ++++++++++++++++++++++++++++++++-- 1 file changed, 71 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 67ec14f5..8fe868aa 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -1,13 +1,15 @@ """ higher level wrapper shortcut for submit_task """ -from typing import Any, Callable, List, Optional, Sequence, Union +from typing import Any, Callable, Dict, List, Optional, Sequence, Union import numpy as np from ..circuit import Circuit from ..results import counts +from ..results.readout_mitigation import ReadoutMit from ..utils import is_sequence +from ..compiler.qiskit_compiler import qiskit_compile from .apis import submit_task, get_device from .abstraction import Device @@ -46,6 +48,7 @@ def sample_expectation_ps( device: Optional[Device] = None, **kws: Any, ) -> float: + # deprecated # TODO(@refraction-ray): integrated error mitigation c1 = Circuit.from_qir(c.to_qir()) if x is None: @@ -66,5 +69,70 @@ def sample_expectation_ps( return counts.expectation(raw_counts, x + y + z) -# TODO(@refraction-ray): batch support -# def batch_sample_expectation_ps(c, pss, ws, device, shots) +def batch_sample_expectation_ps( + c: Circuit, + device: Any, + pss: List[List[int]], + ws: Optional[List[float]] = None, + shots: int = 8192, + with_rem: bool = True, +) -> float: + cs = [] + infos = [] + exps = [] + if isinstance(device, str): + device = get_device(device) + for ps in pss: + c1 = Circuit.from_qir(c.to_qir()) + exp = [] + for j, i in enumerate(ps): + if i == 1: + c1.H(i) # type: ignore + exp.append(j) + elif i == 2: + c1.rx(i, theta=np.pi / 2) # type: ignore + exp.append(j) + elif i == 3: + exp.append(j) + c1, info = qiskit_compile( + c1, + compiled_options={ + "basis_gates": device.native_gates(), + "optimization_level": 3, + "coupling_map": device.topology(), + }, + ) + cs.append(c1) + infos.append(info) + exps.append(exp) + if ws is None: + ws = [1.0 for _ in range(len(pss))] + + def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: + ts = submit_task( + circuit=cs, + device=device, + shots=shots, + enable_qos_qubit_mapping=False, + enable_qos_gate_decomposition=False, + ) + raw_counts = [t.results(blocked=True) for t in ts] + return raw_counts + + raw_counts = run(cs, shots) + + if with_rem: + mit = ReadoutMit(run) + # TODO(@refraction-ray) only work for tencent provider + mit.cals_from_system(device.list_properties()["qubits"]) + + results = [ + mit.expectation(raw_counts[i], exps[i], **infos[i]) + for i in range(len(raw_counts)) + ] + else: + results = [ + counts.expectation(raw_counts[i], exps[i]) for i in range(len(raw_counts)) + ] + sumr = sum([w * r for w, r in zip(ws, results)]) + return sumr From e52c691f026ca32d68ff9f769817c0ff86ff55d0 Mon Sep 17 00:00:00 2001 From: xptree Date: Wed, 8 Feb 2023 00:22:56 +0800 Subject: [PATCH 298/725] Add wall clock time --- examples/omeinsum_julia/README.md | 9 +- examples/omeinsum_julia/benchmark_results.csv | 590 +++++++++--------- 2 files changed, 301 insertions(+), 298 deletions(-) diff --git a/examples/omeinsum_julia/README.md b/examples/omeinsum_julia/README.md index 7175e1f9..56bbda43 100644 --- a/examples/omeinsum_julia/README.md +++ b/examples/omeinsum_julia/README.md @@ -4,7 +4,7 @@ This example introduces how to use OMEinsum, a julia-based einsum package, to co We provide two solutions: -* use subprocess to call a stand-alone julia script (recommended) +* use subprocess to call a stand-alone julia script (**recommended**) * use juliacall to integrate julia script into python (seems to be more elegant, but not recommended) We highly recommend to use the first solution based on subprocess, not only due to its compatibility to julia multi-threading, but also because the experimental KaHyPar-based initialization is developed based on it. @@ -12,9 +12,10 @@ We highly recommend to use the first solution based on subprocess, not only due ## Experiments We test contractors from OMEinsum on Google random circuits ([available online](https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8)) and compare with the cotengra contractor. -For circuits only differ in PRNG seed number (which means with the same tensor network structure, but different tenser entries), we choose the one with the largest seed. For example, we benchmark `circuit_n12_m14_s9_e6_pEFGH.qsim`, but skip +For circuits only differ in PRNG seed number (which means with the same tensor network structure, but different tensor entries), we choose the one with the largest seed. For example, we benchmark `circuit_n12_m14_s9_e6_pEFGH.qsim`, but skip circuits like `circuit_n12_m14_s0_e6_pEFGH.qsim`. We list experimental results in [benchmark_results.csv](benchmark_results.csv). +All experiments are done with a 32GB CPU machine with 16 cores. Specifically, we test the following three methods: @@ -67,7 +68,9 @@ c.expectation_ps(z=[0], reuse=False) Both OMEimsum and cotengra are able to optimize a weighted average of `log10[FLOPs]`, `log2[SIZE]` and `log2[WRITE]`. However, OMEimsum and cotengra have different weight coefficient, which makes fair comparison difficult. Thus we force each method to purely optimized `FLOPs`, but we do collect all contraction information in the table, including -`log10[FLOPs]`, `log2[SIZE]`, `log2[WRITE]`, `PathFindingTime`. +`log10[FLOPs]`, `log2[SIZE]`, `log2[WRITE]`, `PathFindingTime`, `WallClockTime`. + +For circuits with `PathFindingTime` but empty `WallClockTime`, it means we meet OOM when computing with a 32GB CPU machine. For three circuits, namely `circuit_patch_n46_m14_s19_e21_pEFGH`, `circuit_patch_n44_m14_s19_e21_pEFGH` and `circuit_n42_m14_s9_e0_pEFGH`, we meet [errors in OMEinsum](https://github.com/TensorBFS/OMEinsumContractionOrders.jl/issues/35#issuecomment-1405236778), and there results are set to empty in [benchmark_results.csv](benchmark_results.csv). diff --git a/examples/omeinsum_julia/benchmark_results.csv b/examples/omeinsum_julia/benchmark_results.csv index 620fcb16..ddbb9955 100644 --- a/examples/omeinsum_julia/benchmark_results.csv +++ b/examples/omeinsum_julia/benchmark_results.csv @@ -1,295 +1,295 @@ -Circuit,Method,log10[FLOPs],log2[SIZE],log2[WRITE],PathFindingTime -circuit_patch_n53_m20_s19_e35_pABCDCDAB,cotengra,11.645,27.0,35.68,317.342 -circuit_patch_n53_m20_s19_e35_pABCDCDAB,treesa_greedy,11.501,27.0,34.665,602.444 -circuit_patch_n53_m20_s19_e35_pABCDCDAB,treesa_kahypar,11.496,27.0,34.543,486.355 -circuit_n53_m20_s9_e22_pABCDCDAB,cotengra,17.937,41.0,43.775,610.416 -circuit_n53_m20_s9_e22_pABCDCDAB,treesa_greedy,16.568,42.0,46.278,743.266 -circuit_n53_m20_s9_e22_pABCDCDAB,treesa_kahypar,16.861,40.0,45.633,605.181 -circuit_n53_m20_s9_e0_pABCDCDAB,cotengra,19.557,53.0,61.963,532.239 -circuit_n53_m20_s9_e0_pABCDCDAB,treesa_greedy,19.446,53.0,61.279,1560.847 -circuit_n53_m20_s9_e0_pABCDCDAB,treesa_kahypar,19.421,53.0,61.117,2265.351 -circuit_patch_n53_m18_s19_e31_pABCDCDAB,cotengra,11.575,27.0,35.454,330.965 -circuit_patch_n53_m18_s19_e31_pABCDCDAB,treesa_greedy,11.409,27.0,34.285,538.116 -circuit_patch_n53_m18_s19_e31_pABCDCDAB,treesa_kahypar,11.401,27.0,34.102,439.004 -circuit_n53_m18_s9_e19_pABCDCDAB,cotengra,14.172,34.0,37.063,1423.764 -circuit_n53_m18_s9_e19_pABCDCDAB,treesa_greedy,14.163,34.0,38.185,592.027 -circuit_n53_m18_s9_e19_pABCDCDAB,treesa_kahypar,14.163,34.0,38.382,401.272 -circuit_n53_m18_s9_e0_pABCDCDAB,cotengra,19.475,53.0,61.696,332.417 -circuit_n53_m18_s9_e0_pABCDCDAB,treesa_greedy,19.324,53.0,60.87,1414.159 -circuit_n53_m18_s9_e0_pABCDCDAB,treesa_kahypar,19.312,53.0,60.65,1886.625 -circuit_patch_n53_m16_s19_e28_pABCDCDAB,cotengra,11.504,27.0,35.211,334.772 -circuit_patch_n53_m16_s19_e28_pABCDCDAB,treesa_greedy,11.346,27.0,34.12,475.684 -circuit_patch_n53_m16_s19_e28_pABCDCDAB,treesa_kahypar,11.342,27.0,34.023,436.568 -circuit_n53_m16_s9_e15_pABCDCDAB,cotengra,17.566,42.0,44.29,928.736 -circuit_n53_m16_s9_e15_pABCDCDAB,treesa_greedy,16.08,46.0,49.819,686.65 -circuit_n53_m16_s9_e15_pABCDCDAB,treesa_kahypar,16.592,44.0,47.877,631.217 -circuit_n53_m16_s9_e0_pABCDCDAB,cotengra,19.383,53.0,61.388,377.769 -circuit_n53_m16_s9_e0_pABCDCDAB,treesa_greedy,19.219,53.0,60.47,1220.764 -circuit_n53_m16_s9_e0_pABCDCDAB,treesa_kahypar,19.24,53.0,60.536,1766.683 -circuit_patch_n53_m14_s19_e25_pABCDCDAB,cotengra,11.403,27.0,34.873,191.059 -circuit_patch_n53_m14_s19_e25_pABCDCDAB,treesa_greedy,11.192,27.0,33.343,406.669 -circuit_patch_n53_m14_s19_e25_pABCDCDAB,treesa_kahypar,11.199,27.0,33.358,375.971 -circuit_n53_m14_s9_e12_pABCDCDAB,cotengra,15.148,36.0,38.137,659.913 -circuit_n53_m14_s9_e12_pABCDCDAB,treesa_greedy,15.073,36.0,40.602,429.041 -circuit_n53_m14_s9_e12_pABCDCDAB,treesa_kahypar,15.072,36.0,40.432,346.216 -circuit_n53_m14_s9_e11_pEFGH,cotengra,16.04,40.0,41.073,450.93 -circuit_n53_m14_s9_e11_pEFGH,treesa_greedy,15.752,36.0,40.182,482.829 -circuit_n53_m14_s9_e11_pEFGH,treesa_kahypar,15.956,38.0,40.972,339.366 -circuit_n53_m14_s9_e0_pEFGH,cotengra,19.209,55.0,60.822,215.841 -circuit_n53_m14_s9_e0_pEFGH,treesa_greedy,19.038,53.0,59.909,992.68 -circuit_n53_m14_s9_e0_pEFGH,treesa_kahypar,20.484,53.0,59.617,1099.601 -circuit_n53_m14_s9_e0_pABCDCDAB,cotengra,19.229,53.0,60.874,285.173 -circuit_n53_m14_s9_e0_pABCDCDAB,treesa_greedy,19.034,53.0,59.847,966.856 -circuit_n53_m14_s9_e0_pABCDCDAB,treesa_kahypar,19.036,53.0,59.678,1400.73 -circuit_patch_n53_m12_s19_e21_pABCDCDAB,cotengra,11.279,27.0,34.473,128.908 -circuit_patch_n53_m12_s19_e21_pABCDCDAB,treesa_greedy,11.103,27.0,33.189,354.306 -circuit_patch_n53_m12_s19_e21_pABCDCDAB,treesa_kahypar,11.097,27.0,33.346,357.097 -circuit_n53_m12_s9_e8_pABCDCDAB,cotengra,18.012,49.0,49.337,228.721 -circuit_n53_m12_s9_e8_pABCDCDAB,treesa_greedy,16.568,42.0,46.236,496.834 -circuit_n53_m12_s9_e8_pABCDCDAB,treesa_kahypar,16.861,40.0,45.511,468.701 -circuit_n53_m12_s9_e0_pABCDCDAB,cotengra,19.07,53.0,60.348,204.507 -circuit_n53_m12_s9_e0_pABCDCDAB,treesa_greedy,18.873,53.0,59.324,867.543 -circuit_n53_m12_s9_e0_pABCDCDAB,treesa_kahypar,18.926,53.0,59.575,1188.158 -circuit_patch_n51_m14_s19_e25_pEFGH,cotengra,11.111,26.0,33.913,188.369 -circuit_patch_n51_m14_s19_e25_pEFGH,treesa_greedy,10.967,26.0,33.109,420.76 -circuit_patch_n51_m14_s19_e25_pEFGH,treesa_kahypar,10.982,26.0,33.079,375.921 -circuit_n51_m14_s9_e11_pEFGH,cotengra,16.265,42.0,44.935,986.076 -circuit_n51_m14_s9_e11_pEFGH,treesa_greedy,15.356,38.0,40.518,479.331 -circuit_n51_m14_s9_e11_pEFGH,treesa_kahypar,15.753,38.0,40.943,340.365 -circuit_n51_m14_s9_e0_pEFGH,cotengra,18.627,53.0,58.878,250.292 -circuit_n51_m14_s9_e0_pEFGH,treesa_greedy,18.46,51.0,58.05,925.77 -circuit_n51_m14_s9_e0_pEFGH,treesa_kahypar,18.456,51.0,58.009,1000.855 -circuit_patch_n50_m14_s19_e25_pEFGH,cotengra,10.912,25.0,33.253,170.648 -circuit_patch_n50_m14_s19_e25_pEFGH,treesa_greedy,10.77,25.0,32.364,404.916 -circuit_patch_n50_m14_s19_e25_pEFGH,treesa_kahypar,10.785,25.0,32.444,351.123 -circuit_n50_m14_s9_e6_pEFGH,cotengra,15.473,36.0,37.622,559.121 -circuit_n50_m14_s9_e6_pEFGH,treesa_greedy,15.357,35.0,38.348,468.989 -circuit_n50_m14_s9_e6_pEFGH,treesa_kahypar,15.357,35.0,38.431,304.096 -circuit_n50_m14_s9_e0_pEFGH,cotengra,18.32,50.0,57.861,291.025 -circuit_n50_m14_s9_e0_pEFGH,treesa_greedy,18.123,50.0,56.899,905.059 -circuit_n50_m14_s9_e0_pEFGH,treesa_kahypar,18.2,50.0,57.005,1064.76 -circuit_patch_n49_m14_s19_e25_pEFGH,cotengra,10.784,26.0,32.817,168.981 -circuit_patch_n49_m14_s19_e25_pEFGH,treesa_greedy,10.657,25.0,32.039,400.606 -circuit_patch_n49_m14_s19_e25_pEFGH,treesa_kahypar,10.672,25.0,31.982,360.391 -circuit_n49_m14_s9_e6_pEFGH,cotengra,15.426,40.0,43.488,977.093 -circuit_n49_m14_s9_e6_pEFGH,treesa_greedy,15.38,35.0,38.721,435.335 -circuit_n49_m14_s9_e6_pEFGH,treesa_kahypar,15.381,37.0,39.817,315.995 -circuit_n49_m14_s9_e0_pEFGH,cotengra,18.0,49.0,56.796,202.637 -circuit_n49_m14_s9_e0_pEFGH,treesa_greedy,17.812,49.0,55.846,865.665 -circuit_n49_m14_s9_e0_pEFGH,treesa_kahypar,17.902,49.0,55.917,1097.266 -circuit_patch_n48_m14_s19_e25_pEFGH,cotengra,10.579,25.0,32.142,165.566 -circuit_patch_n48_m14_s19_e25_pEFGH,treesa_greedy,10.461,24.0,31.403,388.58 -circuit_patch_n48_m14_s19_e25_pEFGH,treesa_kahypar,10.463,24.0,31.332,376.502 -circuit_n48_m14_s9_e6_pEFGH,cotengra,15.39,39.0,42.954,356.865 -circuit_n48_m14_s9_e6_pEFGH,treesa_greedy,15.075,39.0,42.456,418.301 -circuit_n48_m14_s9_e6_pEFGH,treesa_kahypar,15.353,35.0,37.725,327.35 -circuit_n48_m14_s9_e0_pEFGH,cotengra,17.699,48.0,55.797,247.7 -circuit_n48_m14_s9_e0_pEFGH,treesa_greedy,17.542,48.0,54.951,867.798 -circuit_n48_m14_s9_e0_pEFGH,treesa_kahypar,17.561,48.0,55.12,1023.973 -circuit_patch_n47_m14_s19_e21_pEFGH,cotengra,10.472,24.0,31.79,185.068 -circuit_patch_n47_m14_s19_e21_pEFGH,treesa_greedy,10.375,24.0,31.223,384.684 -circuit_patch_n47_m14_s19_e21_pEFGH,treesa_kahypar,10.371,24.0,31.002,375.058 -circuit_n47_m14_s9_e6_pEFGH,cotengra,15.392,36.0,38.739,717.684 -circuit_n47_m14_s9_e6_pEFGH,treesa_greedy,15.079,34.0,38.001,421.445 -circuit_n47_m14_s9_e6_pEFGH,treesa_kahypar,15.08,36.0,38.969,321.19 -circuit_n47_m14_s9_e0_pEFGH,cotengra,17.404,47.0,54.818,188.359 -circuit_n47_m14_s9_e0_pEFGH,treesa_greedy,17.238,47.0,53.996,806.703 -circuit_n47_m14_s9_e0_pEFGH,treesa_kahypar,17.232,47.0,53.929,1011.005 -circuit_patch_n46_m14_s19_e21_pEFGH,cotengra,10.281,23.0,31.152,152.554 -circuit_patch_n46_m14_s19_e21_pEFGH,treesa_greedy,10.197,23.0,30.537,377.39 -circuit_patch_n46_m14_s19_e21_pEFGH,treesa_kahypar,,,, -circuit_n46_m14_s9_e6_pEFGH,cotengra,13.634,36.0,39.078,520.681 -circuit_n46_m14_s9_e6_pEFGH,treesa_greedy,13.61,36.0,38.42,365.466 -circuit_n46_m14_s9_e6_pEFGH,treesa_kahypar,13.849,30.0,34.175,297.738 -circuit_n46_m14_s9_e0_pEFGH,cotengra,17.069,46.0,53.705,234.515 -circuit_n46_m14_s9_e0_pEFGH,treesa_greedy,16.904,46.0,52.783,803.606 -circuit_n46_m14_s9_e0_pEFGH,treesa_kahypar,16.977,46.0,52.974,825.773 -circuit_patch_n45_m14_s19_e21_pEFGH,cotengra,10.145,23.0,30.706,126.501 -circuit_patch_n45_m14_s19_e21_pEFGH,treesa_greedy,10.064,23.0,30.111,370.784 -circuit_patch_n45_m14_s19_e21_pEFGH,treesa_kahypar,10.068,23.0,30.111,389.19 -circuit_n45_m14_s9_e6_pEFGH,cotengra,14.805,35.0,37.31,562.626 -circuit_n45_m14_s9_e6_pEFGH,treesa_greedy,14.778,33.0,37.072,468.155 -circuit_n45_m14_s9_e6_pEFGH,treesa_kahypar,14.802,33.0,36.592,312.201 -circuit_n45_m14_s9_e0_pEFGH,cotengra,16.77,45.0,52.711,182.538 -circuit_n45_m14_s9_e0_pEFGH,treesa_greedy,16.588,45.0,51.792,758.175 -circuit_n45_m14_s9_e0_pEFGH,treesa_kahypar,16.909,45.0,52.135,845.952 -circuit_patch_n44_m14_s19_e21_pEFGH,cotengra,9.978,22.0,30.147,136.122 -circuit_patch_n44_m14_s19_e21_pEFGH,treesa_greedy,9.884,22.0,29.617,362.106 -circuit_patch_n44_m14_s19_e21_pEFGH,treesa_kahypar,,,, -circuit_n44_m14_s9_e6_pEFGH,cotengra,13.26,30.0,32.518,501.754 -circuit_n44_m14_s9_e6_pEFGH,treesa_greedy,13.249,30.0,33.105,362.069 -circuit_n44_m14_s9_e6_pEFGH,treesa_kahypar,13.25,31.0,33.689,317.296 -circuit_n44_m14_s9_e0_pEFGH,cotengra,16.472,44.0,51.716,166.682 -circuit_n44_m14_s9_e0_pEFGH,treesa_greedy,16.323,44.0,50.795,725.629 -circuit_n44_m14_s9_e0_pEFGH,treesa_kahypar,16.342,44.0,51.098,836.718 -circuit_patch_n43_m14_s19_e21_pEFGH,cotengra,9.829,22.0,29.656,141.768 -circuit_patch_n43_m14_s19_e21_pEFGH,treesa_greedy,9.741,22.0,28.902,346.601 -circuit_patch_n43_m14_s19_e21_pEFGH,treesa_kahypar,9.743,22.0,28.925,362.367 -circuit_n43_m14_s9_e6_pEFGH,cotengra,14.506,34.0,37.565,457.91 -circuit_n43_m14_s9_e6_pEFGH,treesa_greedy,14.477,32.0,36.386,417.651 -circuit_n43_m14_s9_e6_pEFGH,treesa_kahypar,14.478,34.0,37.138,325.975 -circuit_n43_m14_s9_e0_pEFGH,cotengra,16.164,43.0,50.7,188.734 -circuit_n43_m14_s9_e0_pEFGH,treesa_greedy,16.016,43.0,49.954,703.888 -circuit_n43_m14_s9_e0_pEFGH,treesa_kahypar,16.196,43.0,50.008,810.97 -circuit_patch_n42_m14_s19_e21_pEFGH,cotengra,9.635,21.0,29.008,130.04 -circuit_patch_n42_m14_s19_e21_pEFGH,treesa_greedy,9.552,21.0,28.338,334.113 -circuit_patch_n42_m14_s19_e21_pEFGH,treesa_kahypar,9.546,21.0,28.271,361.009 -circuit_n42_m14_s9_e6_pEFGH,cotengra,13.077,34.0,37.894,580.035 -circuit_n42_m14_s9_e6_pEFGH,treesa_greedy,12.949,30.0,33.037,349.173 -circuit_n42_m14_s9_e6_pEFGH,treesa_kahypar,12.949,30.0,32.338,300.511 -circuit_n42_m14_s9_e0_pEFGH,cotengra,15.853,42.0,49.668,148.982 -circuit_n42_m14_s9_e0_pEFGH,treesa_greedy,15.691,42.0,48.799,647.25 -circuit_n42_m14_s9_e0_pEFGH,treesa_kahypar,,,, -circuit_patch_n41_m14_s19_e21_pEFGH,cotengra,9.505,21.0,28.582,132.947 -circuit_patch_n41_m14_s19_e21_pEFGH,treesa_greedy,9.421,21.0,27.913,335.316 -circuit_patch_n41_m14_s19_e21_pEFGH,treesa_kahypar,9.421,21.0,27.85,362.026 -circuit_n41_m14_s9_e6_pEFGH,cotengra,15.104,33.0,36.033,193.758 -circuit_n41_m14_s9_e6_pEFGH,treesa_greedy,14.177,32.0,36.003,377.052 -circuit_n41_m14_s9_e6_pEFGH,treesa_kahypar,14.177,32.0,35.905,309.514 -circuit_n41_m14_s9_e0_pEFGH,cotengra,15.537,41.0,48.619,143.36 -circuit_n41_m14_s9_e0_pEFGH,treesa_greedy,15.377,41.0,47.724,483.166 -circuit_n41_m14_s9_e0_pEFGH,treesa_kahypar,15.374,41.0,47.552,511.412 -circuit_patch_n40_m14_s19_e21_pEFGH,cotengra,9.341,21.0,28.022,113.84 -circuit_patch_n40_m14_s19_e21_pEFGH,treesa_greedy,9.245,20.0,27.402,325.868 -circuit_patch_n40_m14_s19_e21_pEFGH,treesa_kahypar,9.245,20.0,27.224,370.192 -circuit_n40_m14_s9_e6_pEFGH,cotengra,11.782,26.0,30.112,429.931 -circuit_n40_m14_s9_e6_pEFGH,treesa_greedy,11.553,29.0,32.558,317.519 -circuit_n40_m14_s9_e6_pEFGH,treesa_kahypar,11.754,26.0,30.131,299.827 -circuit_n40_m14_s9_e0_pEFGH,cotengra,15.279,40.0,47.758,167.751 -circuit_n40_m14_s9_e0_pEFGH,treesa_greedy,15.127,40.0,46.888,485.121 -circuit_n40_m14_s9_e0_pEFGH,treesa_kahypar,15.122,40.0,46.827,570.709 -circuit_patch_n39_m14_s19_e21_pEFGH,cotengra,9.193,20.0,27.542,128.104 -circuit_patch_n39_m14_s19_e21_pEFGH,treesa_greedy,9.115,20.0,26.959,320.177 -circuit_patch_n39_m14_s19_e21_pEFGH,treesa_kahypar,9.117,20.0,26.913,356.401 -circuit_n39_m14_s9_e6_pEFGH,cotengra,14.982,39.0,46.773,155.635 -circuit_n39_m14_s9_e6_pEFGH,treesa_greedy,13.605,32.0,35.819,359.551 -circuit_n39_m14_s9_e6_pEFGH,treesa_kahypar,13.606,32.0,35.772,304.695 -circuit_n39_m14_s9_e0_pEFGH,cotengra,14.946,39.0,46.654,154.522 -circuit_n39_m14_s9_e0_pEFGH,treesa_greedy,14.83,39.0,46.045,452.056 -circuit_n39_m14_s9_e0_pEFGH,treesa_kahypar,14.839,39.0,46.029,451.003 -circuit_patch_n38_m14_s19_e18_pEFGH,cotengra,9.018,19.0,26.967,112.198 -circuit_patch_n38_m14_s19_e18_pEFGH,treesa_greedy,8.929,19.0,26.307,313.817 -circuit_patch_n38_m14_s19_e18_pEFGH,treesa_kahypar,8.927,19.0,26.208,364.629 -circuit_n38_m14_s9_e6_pEFGH,cotengra,13.44,33.0,35.424,444.322 -circuit_n38_m14_s9_e6_pEFGH,treesa_greedy,13.354,32.0,35.714,353.183 -circuit_n38_m14_s9_e6_pEFGH,treesa_kahypar,13.352,32.0,35.259,298.964 -circuit_n38_m14_s9_e0_pEFGH,cotengra,14.633,38.0,45.615,168.515 -circuit_n38_m14_s9_e0_pEFGH,treesa_greedy,14.514,38.0,44.77,426.414 -circuit_n38_m14_s9_e0_pEFGH,treesa_kahypar,14.512,38.0,44.717,465.762 -circuit_patch_n36_m14_s19_e18_pEFGH,cotengra,8.685,18.0,25.848,106.775 -circuit_patch_n36_m14_s19_e18_pEFGH,treesa_greedy,8.597,18.0,25.117,297.455 -circuit_patch_n36_m14_s19_e18_pEFGH,treesa_kahypar,8.595,18.0,25.207,349.325 -circuit_n36_m14_s9_e6_pEFGH,cotengra,13.31,30.0,33.416,399.867 -circuit_n36_m14_s9_e6_pEFGH,treesa_greedy,12.987,32.0,34.57,313.595 -circuit_n36_m14_s9_e6_pEFGH,treesa_kahypar,12.982,30.0,34.073,306.227 -circuit_n36_m14_s9_e0_pEFGH,cotengra,14.047,36.0,43.666,112.642 -circuit_n36_m14_s9_e0_pEFGH,treesa_greedy,13.899,36.0,42.852,334.293 -circuit_n36_m14_s9_e0_pEFGH,treesa_kahypar,13.897,36.0,42.839,342.502 -circuit_patch_n34_m14_s19_e18_pEFGH,cotengra,8.364,17.0,24.796,89.63 -circuit_patch_n34_m14_s19_e18_pEFGH,treesa_greedy,8.28,17.0,24.047,276.926 -circuit_patch_n34_m14_s19_e18_pEFGH,treesa_kahypar,8.28,17.0,23.999,351.047 -circuit_n34_m14_s9_e6_pEFGH,cotengra,12.977,30.0,32.099,186.683 -circuit_n34_m14_s9_e6_pEFGH,treesa_greedy,12.417,32.0,34.306,290.161 -circuit_n34_m14_s9_e6_pEFGH,treesa_kahypar,12.409,31.0,34.133,301.459 -circuit_n34_m14_s9_e0_pEFGH,cotengra,13.366,34.0,41.184,723.872 -circuit_n34_m14_s9_e0_pEFGH,treesa_greedy,13.235,34.0,40.647,321.03 -circuit_n34_m14_s9_e0_pEFGH,treesa_kahypar,13.304,34.0,40.84,313.386 -circuit_patch_n32_m14_s19_e18_pEFGH,cotengra,8.146,17.0,24.073,74.613 -circuit_patch_n32_m14_s19_e18_pEFGH,treesa_greedy,8.06,17.0,23.497,260.724 -circuit_patch_n32_m14_s19_e18_pEFGH,treesa_kahypar,8.06,17.0,23.349,339.217 -circuit_n32_m14_s9_e6_pEFGH,cotengra,12.455,30.0,31.599,274.974 -circuit_n32_m14_s9_e6_pEFGH,treesa_greedy,12.387,32.0,37.673,282.553 -circuit_n32_m14_s9_e6_pEFGH,treesa_kahypar,11.927,30.0,33.364,287.065 -circuit_n32_m14_s9_e0_pEFGH,cotengra,12.767,32.0,39.409,102.515 -circuit_n32_m14_s9_e0_pEFGH,treesa_greedy,12.613,32.0,38.534,301.8 -circuit_n32_m14_s9_e0_pEFGH,treesa_kahypar,12.616,32.0,38.531,315.007 -circuit_patch_n30_m14_s19_e18_pEFGH,cotengra,7.729,15.0,22.669,71.216 -circuit_patch_n30_m14_s19_e18_pEFGH,treesa_greedy,7.627,15.0,21.929,244.174 -circuit_patch_n30_m14_s19_e18_pEFGH,treesa_kahypar,7.627,15.0,21.85,325.5 -circuit_n30_m14_s9_e6_pEFGH,cotengra,11.93,30.0,36.445,126.822 -circuit_n30_m14_s9_e6_pEFGH,treesa_greedy,11.767,30.0,35.616,266.514 -circuit_n30_m14_s9_e6_pEFGH,treesa_kahypar,11.755,30.0,35.362,294.707 -circuit_n30_m14_s9_e0_pEFGH,cotengra,12.108,30.0,37.106,589.94 -circuit_n30_m14_s9_e0_pEFGH,treesa_greedy,12.008,30.0,36.456,281.111 -circuit_n30_m14_s9_e0_pEFGH,treesa_kahypar,12.004,30.0,36.513,336.693 -circuit_patch_n28_m14_s19_e18_pEFGH,cotengra,7.391,15.0,21.548,66.319 -circuit_patch_n28_m14_s19_e18_pEFGH,treesa_greedy,7.296,14.0,20.873,224.338 -circuit_patch_n28_m14_s19_e18_pEFGH,treesa_kahypar,7.296,14.0,20.795,324.174 -circuit_n28_m14_s9_e6_pEFGH,cotengra,11.337,28.0,34.601,127.216 -circuit_n28_m14_s9_e6_pEFGH,treesa_greedy,11.165,28.0,33.674,246.72 -circuit_n28_m14_s9_e6_pEFGH,treesa_kahypar,11.159,28.0,33.527,312.592 -circuit_n28_m14_s9_e0_pEFGH,cotengra,11.535,28.0,35.321,94.159 -circuit_n28_m14_s9_e0_pEFGH,treesa_greedy,11.42,28.0,34.62,264.422 -circuit_n28_m14_s9_e0_pEFGH,treesa_kahypar,11.423,28.0,34.546,339.157 -circuit_patch_n26_m14_s19_e18_pEFGH,cotengra,7.176,14.0,20.847,60.356 -circuit_patch_n26_m14_s19_e18_pEFGH,treesa_greedy,7.079,14.0,20.039,213.163 -circuit_patch_n26_m14_s19_e18_pEFGH,treesa_kahypar,7.079,14.0,19.986,331.146 -circuit_n26_m14_s9_e6_pEFGH,cotengra,10.81,26.0,32.907,360.491 -circuit_n26_m14_s9_e6_pEFGH,treesa_greedy,10.563,26.0,31.617,238.924 -circuit_n26_m14_s9_e6_pEFGH,treesa_kahypar,10.551,26.0,31.253,291.778 -circuit_n26_m14_s9_e0_pEFGH,cotengra,10.913,26.0,33.164,408.503 -circuit_n26_m14_s9_e0_pEFGH,treesa_greedy,10.83,26.0,32.713,254.088 -circuit_n26_m14_s9_e0_pEFGH,treesa_kahypar,10.826,26.0,32.389,337.32 -circuit_patch_n24_m14_s19_e18_pEFGH,cotengra,6.73,12.0,19.35,59.624 -circuit_patch_n24_m14_s19_e18_pEFGH,treesa_greedy,6.646,12.0,18.69,200.344 -circuit_patch_n24_m14_s19_e18_pEFGH,treesa_kahypar,6.646,12.0,18.693,299.906 -circuit_n24_m14_s9_e6_pEFGH,cotengra,10.161,24.0,30.525,283.776 -circuit_n24_m14_s9_e6_pEFGH,treesa_greedy,9.962,24.0,29.678,223.605 -circuit_n24_m14_s9_e6_pEFGH,treesa_kahypar,9.957,24.0,29.504,360.26 -circuit_n24_m14_s9_e0_pEFGH,cotengra,10.316,24.0,31.273,72.708 -circuit_n24_m14_s9_e0_pEFGH,treesa_greedy,10.227,24.0,30.624,236.467 -circuit_n24_m14_s9_e0_pEFGH,treesa_kahypar,10.227,24.0,30.754,331.976 -circuit_patch_n22_m14_s19_e18_pEFGH,cotengra,6.355,12.0,18.102,52.99 -circuit_patch_n22_m14_s19_e18_pEFGH,treesa_greedy,6.279,11.0,17.415,183.257 -circuit_patch_n22_m14_s19_e18_pEFGH,treesa_kahypar,6.28,11.0,17.483,267.011 -circuit_n22_m14_s9_e6_pEFGH,cotengra,9.467,22.0,28.381,120.142 -circuit_n22_m14_s9_e6_pEFGH,treesa_greedy,9.331,22.0,27.346,202.433 -circuit_n22_m14_s9_e6_pEFGH,treesa_kahypar,9.331,22.0,27.448,272.657 -circuit_n22_m14_s9_e0_pEFGH,cotengra,9.677,23.0,29.144,78.247 -circuit_n22_m14_s9_e0_pEFGH,treesa_greedy,9.577,22.0,28.358,215.617 -circuit_n22_m14_s9_e0_pEFGH,treesa_kahypar,9.579,22.0,28.466,307.613 -circuit_patch_n20_m14_s19_e18_pEFGH,cotengra,6.134,11.0,17.382,49.623 -circuit_patch_n20_m14_s19_e18_pEFGH,treesa_greedy,6.053,11.0,16.795,167.424 -circuit_patch_n20_m14_s19_e18_pEFGH,treesa_kahypar,6.053,11.0,16.695,247.914 -circuit_n20_m14_s9_e6_pEFGH,cotengra,8.894,20.0,26.542,150.987 -circuit_n20_m14_s9_e6_pEFGH,treesa_greedy,8.7,20.0,25.433,190.071 -circuit_n20_m14_s9_e6_pEFGH,treesa_kahypar,8.7,20.0,25.527,258.81 -circuit_n20_m14_s9_e0_pEFGH,cotengra,9.035,20.0,27.015,61.283 -circuit_n20_m14_s9_e0_pEFGH,treesa_greedy,8.919,20.0,26.257,199.232 -circuit_n20_m14_s9_e0_pEFGH,treesa_kahypar,8.919,20.0,26.13,284.502 -circuit_patch_n18_m14_s19_e18_pEFGH,cotengra,5.634,9.0,15.699,45.035 -circuit_patch_n18_m14_s19_e18_pEFGH,treesa_greedy,5.58,9.0,15.302,148.657 -circuit_patch_n18_m14_s19_e18_pEFGH,treesa_kahypar,5.578,9.0,15.371,219.656 -circuit_n18_m14_s9_e6_pEFGH,cotengra,8.21,18.0,24.042,133.862 -circuit_n18_m14_s9_e6_pEFGH,treesa_greedy,8.084,18.0,23.465,172.065 -circuit_n18_m14_s9_e6_pEFGH,treesa_kahypar,8.084,18.0,23.504,245.05 -circuit_n18_m14_s9_e0_pEFGH,cotengra,8.368,18.0,24.778,66.721 -circuit_n18_m14_s9_e0_pEFGH,treesa_greedy,8.3,18.0,24.309,188.926 -circuit_n18_m14_s9_e0_pEFGH,treesa_kahypar,8.296,18.0,24.173,277.908 -circuit_patch_n16_m14_s19_e18_pEFGH,cotengra,5.244,8.0,14.35,40.832 -circuit_patch_n16_m14_s19_e18_pEFGH,treesa_greedy,5.223,8.0,14.195,115.272 -circuit_patch_n16_m14_s19_e18_pEFGH,treesa_kahypar,5.221,8.0,14.219,175.4 -circuit_n16_m14_s9_e6_pEFGH,cotengra,7.581,16.0,22.179,85.893 -circuit_n16_m14_s9_e6_pEFGH,treesa_greedy,7.461,16.0,21.426,152.915 -circuit_n16_m14_s9_e6_pEFGH,treesa_kahypar,7.461,16.0,21.376,231.679 -circuit_n16_m14_s9_e0_pEFGH,cotengra,7.722,16.0,22.646,50.145 -circuit_n16_m14_s9_e0_pEFGH,treesa_greedy,7.657,16.0,22.006,165.097 -circuit_n16_m14_s9_e0_pEFGH,treesa_kahypar,7.657,16.0,22.083,264.186 -circuit_patch_n14_m14_s19_e18_pEFGH,cotengra,5.037,8.0,13.656,38.015 -circuit_patch_n14_m14_s19_e18_pEFGH,treesa_greedy,5.026,8.0,13.613,96.427 -circuit_patch_n14_m14_s19_e18_pEFGH,treesa_kahypar,5.026,8.0,13.612,151.793 -circuit_n14_m14_s9_e6_pEFGH,cotengra,6.903,14.0,19.89,41.915 -circuit_n14_m14_s9_e6_pEFGH,treesa_greedy,6.881,14.0,19.67,135.775 -circuit_n14_m14_s9_e6_pEFGH,treesa_kahypar,6.877,14.0,19.566,201.495 -circuit_n14_m14_s9_e0_pEFGH,cotengra,7.056,14.0,20.401,47.314 -circuit_n14_m14_s9_e0_pEFGH,treesa_greedy,7.037,14.0,20.083,147.727 -circuit_n14_m14_s9_e0_pEFGH,treesa_kahypar,7.037,14.0,20.186,247.662 -circuit_patch_n12_m14_s19_e18_pEFGH,cotengra,4.601,6.0,12.309,34.705 -circuit_patch_n12_m14_s19_e18_pEFGH,treesa_greedy,4.599,6.0,12.293,77.623 -circuit_patch_n12_m14_s19_e18_pEFGH,treesa_kahypar,4.599,6.0,12.293,121.916 -circuit_n12_m14_s9_e6_pEFGH,cotengra,6.237,12.0,17.714,80.464 -circuit_n12_m14_s9_e6_pEFGH,treesa_greedy,6.197,12.0,17.461,115.898 -circuit_n12_m14_s9_e6_pEFGH,treesa_kahypar,6.197,12.0,17.362,188.599 -circuit_n12_m14_s9_e0_pEFGH,cotengra,6.407,12.0,18.252,44.137 -circuit_n12_m14_s9_e0_pEFGH,treesa_greedy,6.387,12.0,18.075,133.648 -circuit_n12_m14_s9_e0_pEFGH,treesa_kahypar,6.387,12.0,18.077,218.335 +Circuit,Method,log10[FLOPs],log2[SIZE],log2[WRITE],PathFindingTime,WallClockTime +circuit_patch_n53_m20_s19_e35_pABCDCDAB,cotengra,11.647,27.0,35.691,398.803,904.630027267456 +circuit_patch_n53_m20_s19_e35_pABCDCDAB,treesa_greedy,11.5,27.0,34.627,580.954,470.45179032897954 +circuit_patch_n53_m20_s19_e35_pABCDCDAB,treesa_kahypar,11.495,27.0,34.529,475.356,437.65489906692505 +circuit_n53_m20_s9_e22_pABCDCDAB,cotengra,17.937,41.0,43.775,610.416, +circuit_n53_m20_s9_e22_pABCDCDAB,treesa_greedy,16.568,42.0,46.278,743.266, +circuit_n53_m20_s9_e22_pABCDCDAB,treesa_kahypar,16.861,40.0,45.633,605.181, +circuit_n53_m20_s9_e0_pABCDCDAB,cotengra,19.557,53.0,61.963,532.239, +circuit_n53_m20_s9_e0_pABCDCDAB,treesa_greedy,19.446,53.0,61.279,1560.847, +circuit_n53_m20_s9_e0_pABCDCDAB,treesa_kahypar,19.421,53.0,61.117,2265.351, +circuit_patch_n53_m18_s19_e31_pABCDCDAB,cotengra,11.575,27.0,35.454,330.965, +circuit_patch_n53_m18_s19_e31_pABCDCDAB,treesa_greedy,11.406,27.0,34.29,536.233,374.6099431915284 +circuit_patch_n53_m18_s19_e31_pABCDCDAB,treesa_kahypar,11.401,27.0,34.102,439.004, +circuit_n53_m18_s9_e19_pABCDCDAB,cotengra,14.172,34.0,37.063,1423.764, +circuit_n53_m18_s9_e19_pABCDCDAB,treesa_greedy,14.163,34.0,38.185,592.027, +circuit_n53_m18_s9_e19_pABCDCDAB,treesa_kahypar,14.163,34.0,38.382,401.272, +circuit_n53_m18_s9_e0_pABCDCDAB,cotengra,19.475,53.0,61.696,332.417, +circuit_n53_m18_s9_e0_pABCDCDAB,treesa_greedy,19.324,53.0,60.87,1414.159, +circuit_n53_m18_s9_e0_pABCDCDAB,treesa_kahypar,19.312,53.0,60.65,1886.625, +circuit_patch_n53_m16_s19_e28_pABCDCDAB,cotengra,11.504,27.0,35.211,334.772, +circuit_patch_n53_m16_s19_e28_pABCDCDAB,treesa_greedy,11.344,27.0,34.117,478.65,331.2237154006958 +circuit_patch_n53_m16_s19_e28_pABCDCDAB,treesa_kahypar,11.34,27.0,34.077,427.951,321.19098875427244 +circuit_n53_m16_s9_e15_pABCDCDAB,cotengra,17.566,42.0,44.29,928.736, +circuit_n53_m16_s9_e15_pABCDCDAB,treesa_greedy,16.08,46.0,49.819,686.65, +circuit_n53_m16_s9_e15_pABCDCDAB,treesa_kahypar,16.592,44.0,47.877,631.217, +circuit_n53_m16_s9_e0_pABCDCDAB,cotengra,19.383,53.0,61.388,377.769, +circuit_n53_m16_s9_e0_pABCDCDAB,treesa_greedy,19.219,53.0,60.47,1220.764, +circuit_n53_m16_s9_e0_pABCDCDAB,treesa_kahypar,19.24,53.0,60.536,1766.683, +circuit_patch_n53_m14_s19_e25_pABCDCDAB,cotengra,11.399,27.0,34.863,188.49,509.74672747612 +circuit_patch_n53_m14_s19_e25_pABCDCDAB,treesa_greedy,11.203,27.0,33.567,406.24,228.8411741352081 +circuit_patch_n53_m14_s19_e25_pABCDCDAB,treesa_kahypar,11.196,27.0,33.447,382.167,211.26469307708743 +circuit_n53_m14_s9_e12_pABCDCDAB,cotengra,15.148,36.0,38.137,659.913, +circuit_n53_m14_s9_e12_pABCDCDAB,treesa_greedy,15.073,36.0,40.602,429.041, +circuit_n53_m14_s9_e12_pABCDCDAB,treesa_kahypar,15.072,36.0,40.432,346.216, +circuit_n53_m14_s9_e11_pEFGH,cotengra,16.04,40.0,41.073,450.93, +circuit_n53_m14_s9_e11_pEFGH,treesa_greedy,15.752,36.0,40.182,482.829, +circuit_n53_m14_s9_e11_pEFGH,treesa_kahypar,15.956,38.0,40.972,339.366, +circuit_n53_m14_s9_e0_pEFGH,cotengra,19.209,55.0,60.822,215.841, +circuit_n53_m14_s9_e0_pEFGH,treesa_greedy,19.038,53.0,59.909,992.68, +circuit_n53_m14_s9_e0_pEFGH,treesa_kahypar,20.484,53.0,59.617,1099.601, +circuit_n53_m14_s9_e0_pABCDCDAB,cotengra,19.229,53.0,60.874,285.173, +circuit_n53_m14_s9_e0_pABCDCDAB,treesa_greedy,19.034,53.0,59.847,966.856, +circuit_n53_m14_s9_e0_pABCDCDAB,treesa_kahypar,19.036,53.0,59.678,1400.73, +circuit_patch_n53_m12_s19_e21_pABCDCDAB,cotengra,11.275,27.0,34.452,131.188,383.0614959831238 +circuit_patch_n53_m12_s19_e21_pABCDCDAB,treesa_greedy,11.097,27.0,33.278,356.329,184.52528404808044 +circuit_patch_n53_m12_s19_e21_pABCDCDAB,treesa_kahypar,11.098,27.0,33.305,360.083,187.92855328750608 +circuit_n53_m12_s9_e8_pABCDCDAB,cotengra,18.012,49.0,49.337,228.721, +circuit_n53_m12_s9_e8_pABCDCDAB,treesa_greedy,16.568,42.0,46.236,496.834, +circuit_n53_m12_s9_e8_pABCDCDAB,treesa_kahypar,16.861,40.0,45.511,468.701, +circuit_n53_m12_s9_e0_pABCDCDAB,cotengra,19.07,53.0,60.348,204.507, +circuit_n53_m12_s9_e0_pABCDCDAB,treesa_greedy,18.873,53.0,59.324,867.543, +circuit_n53_m12_s9_e0_pABCDCDAB,treesa_kahypar,18.926,53.0,59.575,1188.158, +circuit_patch_n51_m14_s19_e25_pEFGH,cotengra,11.118,26.0,33.936,176.226,265.7081673851013 +circuit_patch_n51_m14_s19_e25_pEFGH,treesa_greedy,10.967,26.0,33.088,410.717,162.59800005722047 +circuit_patch_n51_m14_s19_e25_pEFGH,treesa_kahypar,10.974,26.0,33.023,364.369,156.77375979995725 +circuit_n51_m14_s9_e11_pEFGH,cotengra,16.265,42.0,44.935,986.076, +circuit_n51_m14_s9_e11_pEFGH,treesa_greedy,15.356,38.0,40.518,479.331, +circuit_n51_m14_s9_e11_pEFGH,treesa_kahypar,15.753,38.0,40.943,340.365, +circuit_n51_m14_s9_e0_pEFGH,cotengra,18.627,53.0,58.878,250.292, +circuit_n51_m14_s9_e0_pEFGH,treesa_greedy,18.46,51.0,58.05,925.77, +circuit_n51_m14_s9_e0_pEFGH,treesa_kahypar,18.456,51.0,58.009,1000.855, +circuit_patch_n50_m14_s19_e25_pEFGH,cotengra,10.896,26.0,33.194,189.555,161.8636086654663 +circuit_patch_n50_m14_s19_e25_pEFGH,treesa_greedy,10.77,25.0,32.356,401.736,101.84471446418765 +circuit_patch_n50_m14_s19_e25_pEFGH,treesa_kahypar,10.783,25.0,32.41,359.563,106.30724927139283 +circuit_n50_m14_s9_e6_pEFGH,cotengra,15.473,36.0,37.622,559.121, +circuit_n50_m14_s9_e6_pEFGH,treesa_greedy,15.357,35.0,38.348,468.989, +circuit_n50_m14_s9_e6_pEFGH,treesa_kahypar,15.357,35.0,38.431,304.096, +circuit_n50_m14_s9_e0_pEFGH,cotengra,18.32,50.0,57.861,291.025, +circuit_n50_m14_s9_e0_pEFGH,treesa_greedy,18.123,50.0,56.899,905.059, +circuit_n50_m14_s9_e0_pEFGH,treesa_kahypar,18.2,50.0,57.005,1064.76, +circuit_patch_n49_m14_s19_e25_pEFGH,cotengra,10.784,25.0,32.822,234.339,126.944433675766 +circuit_patch_n49_m14_s19_e25_pEFGH,treesa_greedy,10.656,25.0,31.946,396.791,79.66520441436768 +circuit_patch_n49_m14_s19_e25_pEFGH,treesa_kahypar,10.671,25.0,32.005,362.81,83.06759184837341 +circuit_n49_m14_s9_e6_pEFGH,cotengra,15.426,40.0,43.488,977.093, +circuit_n49_m14_s9_e6_pEFGH,treesa_greedy,15.38,35.0,38.721,435.335, +circuit_n49_m14_s9_e6_pEFGH,treesa_kahypar,15.381,37.0,39.817,315.995, +circuit_n49_m14_s9_e0_pEFGH,cotengra,18.0,49.0,56.796,202.637, +circuit_n49_m14_s9_e0_pEFGH,treesa_greedy,17.812,49.0,55.846,865.665, +circuit_n49_m14_s9_e0_pEFGH,treesa_kahypar,17.902,49.0,55.917,1097.266, +circuit_patch_n48_m14_s19_e25_pEFGH,cotengra,10.593,25.0,32.194,141.984,84.87485381698608 +circuit_patch_n48_m14_s19_e25_pEFGH,treesa_greedy,10.461,24.0,31.434,385.411,58.61000372314453 +circuit_patch_n48_m14_s19_e25_pEFGH,treesa_kahypar,10.468,24.0,31.311,370.662,54.62013644027712 +circuit_n48_m14_s9_e6_pEFGH,cotengra,15.39,39.0,42.954,356.865, +circuit_n48_m14_s9_e6_pEFGH,treesa_greedy,15.075,39.0,42.456,418.301, +circuit_n48_m14_s9_e6_pEFGH,treesa_kahypar,15.353,35.0,37.725,327.35, +circuit_n48_m14_s9_e0_pEFGH,cotengra,17.699,48.0,55.797,247.7, +circuit_n48_m14_s9_e0_pEFGH,treesa_greedy,17.542,48.0,54.951,867.798, +circuit_n48_m14_s9_e0_pEFGH,treesa_kahypar,17.561,48.0,55.12,1023.973, +circuit_patch_n47_m14_s19_e21_pEFGH,cotengra,10.47,24.0,31.78,139.135,66.35265134811402 +circuit_patch_n47_m14_s19_e21_pEFGH,treesa_greedy,10.376,24.0,31.211,385.959,52.02424632644653 +circuit_patch_n47_m14_s19_e21_pEFGH,treesa_kahypar,10.372,24.0,31.07,361.883,47.92822636795046 +circuit_n47_m14_s9_e6_pEFGH,cotengra,15.392,36.0,38.739,717.684, +circuit_n47_m14_s9_e6_pEFGH,treesa_greedy,15.079,34.0,38.001,421.445, +circuit_n47_m14_s9_e6_pEFGH,treesa_kahypar,15.08,36.0,38.969,321.19, +circuit_n47_m14_s9_e0_pEFGH,cotengra,17.404,47.0,54.818,188.359, +circuit_n47_m14_s9_e0_pEFGH,treesa_greedy,17.238,47.0,53.996,806.703, +circuit_n47_m14_s9_e0_pEFGH,treesa_kahypar,17.232,47.0,53.929,1011.005, +circuit_patch_n46_m14_s19_e21_pEFGH,cotengra,10.291,23.0,31.19,132.961,47.43699904823302 +circuit_patch_n46_m14_s19_e21_pEFGH,treesa_greedy,10.195,23.0,30.649,372.6,38.02652993202207 +circuit_patch_n46_m14_s19_e21_pEFGH,treesa_kahypar,,,,, +circuit_n46_m14_s9_e6_pEFGH,cotengra,13.634,36.0,39.078,520.681, +circuit_n46_m14_s9_e6_pEFGH,treesa_greedy,13.61,36.0,38.42,365.466, +circuit_n46_m14_s9_e6_pEFGH,treesa_kahypar,13.849,30.0,34.175,297.738, +circuit_n46_m14_s9_e0_pEFGH,cotengra,17.069,46.0,53.705,234.515, +circuit_n46_m14_s9_e0_pEFGH,treesa_greedy,16.904,46.0,52.783,803.606, +circuit_n46_m14_s9_e0_pEFGH,treesa_kahypar,16.977,46.0,52.974,825.773, +circuit_patch_n45_m14_s19_e21_pEFGH,cotengra,10.151,23.0,30.722,140.734,36.95154472923278 +circuit_patch_n45_m14_s19_e21_pEFGH,treesa_greedy,10.064,23.0,30.134,377.491,29.460883554458636 +circuit_patch_n45_m14_s19_e21_pEFGH,treesa_kahypar,10.065,23.0,29.992,393.157,27.99106628227236 +circuit_n45_m14_s9_e6_pEFGH,cotengra,14.805,35.0,37.31,562.626, +circuit_n45_m14_s9_e6_pEFGH,treesa_greedy,14.778,33.0,37.072,468.155, +circuit_n45_m14_s9_e6_pEFGH,treesa_kahypar,14.802,33.0,36.592,312.201, +circuit_n45_m14_s9_e0_pEFGH,cotengra,16.77,45.0,52.711,182.538, +circuit_n45_m14_s9_e0_pEFGH,treesa_greedy,16.588,45.0,51.792,758.175, +circuit_n45_m14_s9_e0_pEFGH,treesa_kahypar,16.909,45.0,52.135,845.952, +circuit_patch_n44_m14_s19_e21_pEFGH,cotengra,9.973,22.0,30.134,139.612,27.20677493858338 +circuit_patch_n44_m14_s19_e21_pEFGH,treesa_greedy,9.885,22.0,29.572,359.367,23.439527376174908 +circuit_patch_n44_m14_s19_e21_pEFGH,treesa_kahypar,,,,, +circuit_n44_m14_s9_e6_pEFGH,cotengra,13.26,30.0,32.518,501.754, +circuit_n44_m14_s9_e6_pEFGH,treesa_greedy,13.249,30.0,33.105,362.069, +circuit_n44_m14_s9_e6_pEFGH,treesa_kahypar,13.25,31.0,33.689,317.296, +circuit_n44_m14_s9_e0_pEFGH,cotengra,16.472,44.0,51.716,166.682, +circuit_n44_m14_s9_e0_pEFGH,treesa_greedy,16.323,44.0,50.795,725.629, +circuit_n44_m14_s9_e0_pEFGH,treesa_kahypar,16.342,44.0,51.098,836.718, +circuit_patch_n43_m14_s19_e21_pEFGH,cotengra,9.841,23.0,29.701,124.817,22.214245708465583 +circuit_patch_n43_m14_s19_e21_pEFGH,treesa_greedy,9.739,22.0,28.984,348.046,18.258648876190197 +circuit_patch_n43_m14_s19_e21_pEFGH,treesa_kahypar,9.739,22.0,28.932,359.195,18.26624458312989 +circuit_n43_m14_s9_e6_pEFGH,cotengra,14.506,34.0,37.565,457.91, +circuit_n43_m14_s9_e6_pEFGH,treesa_greedy,14.477,32.0,36.386,417.651, +circuit_n43_m14_s9_e6_pEFGH,treesa_kahypar,14.478,34.0,37.138,325.975, +circuit_n43_m14_s9_e0_pEFGH,cotengra,16.164,43.0,50.7,188.734, +circuit_n43_m14_s9_e0_pEFGH,treesa_greedy,16.016,43.0,49.954,703.888, +circuit_n43_m14_s9_e0_pEFGH,treesa_kahypar,16.196,43.0,50.008,810.97, +circuit_patch_n42_m14_s19_e21_pEFGH,cotengra,9.628,22.0,28.986,136.774,16.64340107536316 +circuit_patch_n42_m14_s19_e21_pEFGH,treesa_greedy,9.551,21.0,28.359,337.304,14.703207632064846 +circuit_patch_n42_m14_s19_e21_pEFGH,treesa_kahypar,9.548,21.0,28.267,349.973,14.334425737380968 +circuit_n42_m14_s9_e6_pEFGH,cotengra,13.077,34.0,37.894,580.035, +circuit_n42_m14_s9_e6_pEFGH,treesa_greedy,12.949,30.0,33.037,349.173, +circuit_n42_m14_s9_e6_pEFGH,treesa_kahypar,12.949,30.0,32.338,300.511, +circuit_n42_m14_s9_e0_pEFGH,cotengra,15.853,42.0,49.668,148.982, +circuit_n42_m14_s9_e0_pEFGH,treesa_greedy,15.691,42.0,48.799,647.25, +circuit_n42_m14_s9_e0_pEFGH,treesa_kahypar,,,,, +circuit_patch_n41_m14_s19_e21_pEFGH,cotengra,9.509,21.0,28.596,127.293,14.677715522766109 +circuit_patch_n41_m14_s19_e21_pEFGH,treesa_greedy,9.42,21.0,27.908,335.6,12.917063379287695 +circuit_patch_n41_m14_s19_e21_pEFGH,treesa_kahypar,9.419,21.0,27.914,365.479,12.920412155151382 +circuit_n41_m14_s9_e6_pEFGH,cotengra,15.104,33.0,36.033,193.758, +circuit_n41_m14_s9_e6_pEFGH,treesa_greedy,14.177,32.0,36.003,377.052, +circuit_n41_m14_s9_e6_pEFGH,treesa_kahypar,14.177,32.0,35.905,309.514, +circuit_n41_m14_s9_e0_pEFGH,cotengra,15.537,41.0,48.619,143.36, +circuit_n41_m14_s9_e0_pEFGH,treesa_greedy,15.377,41.0,47.724,483.166, +circuit_n41_m14_s9_e0_pEFGH,treesa_kahypar,15.374,41.0,47.552,511.412, +circuit_patch_n40_m14_s19_e21_pEFGH,cotengra,9.339,20.0,28.02,114.253,12.69566180419922 +circuit_patch_n40_m14_s19_e21_pEFGH,treesa_greedy,9.243,20.0,27.29,321.336,11.173633779525744 +circuit_patch_n40_m14_s19_e21_pEFGH,treesa_kahypar,9.242,20.0,27.336,380.531,11.552189010620111 +circuit_n40_m14_s9_e6_pEFGH,cotengra,11.782,26.0,30.112,429.931, +circuit_n40_m14_s9_e6_pEFGH,treesa_greedy,11.553,29.0,32.558,317.519, +circuit_n40_m14_s9_e6_pEFGH,treesa_kahypar,11.754,26.0,30.017,307.609,32.396990266799946 +circuit_n40_m14_s9_e0_pEFGH,cotengra,15.279,40.0,47.758,167.751, +circuit_n40_m14_s9_e0_pEFGH,treesa_greedy,15.127,40.0,46.888,485.121, +circuit_n40_m14_s9_e0_pEFGH,treesa_kahypar,15.122,40.0,46.827,570.709, +circuit_patch_n39_m14_s19_e21_pEFGH,cotengra,9.183,20.0,27.503,117.214,11.140823112487794 +circuit_patch_n39_m14_s19_e21_pEFGH,treesa_greedy,9.114,20.0,26.894,320.019,10.45490222549438 +circuit_patch_n39_m14_s19_e21_pEFGH,treesa_kahypar,9.117,20.0,26.907,359.031,10.429051774978632 +circuit_n39_m14_s9_e6_pEFGH,cotengra,14.982,39.0,46.773,155.635, +circuit_n39_m14_s9_e6_pEFGH,treesa_greedy,13.605,32.0,35.819,359.551, +circuit_n39_m14_s9_e6_pEFGH,treesa_kahypar,13.606,32.0,35.772,304.695, +circuit_n39_m14_s9_e0_pEFGH,cotengra,14.946,39.0,46.654,154.522, +circuit_n39_m14_s9_e0_pEFGH,treesa_greedy,14.83,39.0,46.045,452.056, +circuit_n39_m14_s9_e0_pEFGH,treesa_kahypar,14.839,39.0,46.029,451.003, +circuit_patch_n38_m14_s19_e18_pEFGH,cotengra,9.02,20.0,26.976,113.789,10.02211407279968 +circuit_patch_n38_m14_s19_e18_pEFGH,treesa_greedy,8.929,19.0,26.184,313.756,9.229728740692169 +circuit_patch_n38_m14_s19_e18_pEFGH,treesa_kahypar,8.927,19.0,26.211,367.953,9.526923963546778 +circuit_n38_m14_s9_e6_pEFGH,cotengra,13.44,33.0,35.424,444.322, +circuit_n38_m14_s9_e6_pEFGH,treesa_greedy,13.354,32.0,35.714,353.183, +circuit_n38_m14_s9_e6_pEFGH,treesa_kahypar,13.352,32.0,35.259,298.964, +circuit_n38_m14_s9_e0_pEFGH,cotengra,14.633,38.0,45.615,168.515, +circuit_n38_m14_s9_e0_pEFGH,treesa_greedy,14.514,38.0,44.77,426.414, +circuit_n38_m14_s9_e0_pEFGH,treesa_kahypar,14.512,38.0,44.717,465.762, +circuit_patch_n36_m14_s19_e18_pEFGH,cotengra,8.693,20.0,25.88,111.161,8.696066631317137 +circuit_patch_n36_m14_s19_e18_pEFGH,treesa_greedy,8.595,18.0,25.128,295.207,7.998978631973273 +circuit_patch_n36_m14_s19_e18_pEFGH,treesa_kahypar,8.595,18.0,25.218,352.907,8.22156841087343 +circuit_n36_m14_s9_e6_pEFGH,cotengra,13.31,30.0,33.416,399.867, +circuit_n36_m14_s9_e6_pEFGH,treesa_greedy,12.987,32.0,34.57,313.595, +circuit_n36_m14_s9_e6_pEFGH,treesa_kahypar,12.982,30.0,34.073,306.227, +circuit_n36_m14_s9_e0_pEFGH,cotengra,14.047,36.0,43.666,112.642, +circuit_n36_m14_s9_e0_pEFGH,treesa_greedy,13.899,36.0,42.852,334.293, +circuit_n36_m14_s9_e0_pEFGH,treesa_kahypar,13.897,36.0,42.839,342.502, +circuit_patch_n34_m14_s19_e18_pEFGH,cotengra,8.362,17.0,24.789,92.887,7.233053529739379 +circuit_patch_n34_m14_s19_e18_pEFGH,treesa_greedy,8.279,17.0,24.067,280.897,6.78341157722474 +circuit_patch_n34_m14_s19_e18_pEFGH,treesa_kahypar,8.278,17.0,24.093,351.171,7.07559204483033 +circuit_n34_m14_s9_e6_pEFGH,cotengra,12.977,30.0,32.099,186.683, +circuit_n34_m14_s9_e6_pEFGH,treesa_greedy,12.417,32.0,34.306,290.161, +circuit_n34_m14_s9_e6_pEFGH,treesa_kahypar,12.409,31.0,34.133,301.459, +circuit_n34_m14_s9_e0_pEFGH,cotengra,13.366,34.0,41.184,723.872, +circuit_n34_m14_s9_e0_pEFGH,treesa_greedy,13.235,34.0,40.647,321.03, +circuit_n34_m14_s9_e0_pEFGH,treesa_kahypar,13.304,34.0,40.84,313.386, +circuit_patch_n32_m14_s19_e18_pEFGH,cotengra,8.14,17.0,24.05,82.169,6.364380270004276 +circuit_patch_n32_m14_s19_e18_pEFGH,treesa_greedy,8.06,17.0,23.345,260.718,6.2471072025298895 +circuit_patch_n32_m14_s19_e18_pEFGH,treesa_kahypar,8.06,17.0,23.263,336.565,5.982450304031374 +circuit_n32_m14_s9_e6_pEFGH,cotengra,12.455,30.0,31.599,274.974, +circuit_n32_m14_s9_e6_pEFGH,treesa_greedy,12.387,32.0,37.673,282.553, +circuit_n32_m14_s9_e6_pEFGH,treesa_kahypar,11.927,30.0,33.364,287.065, +circuit_n32_m14_s9_e0_pEFGH,cotengra,12.767,32.0,39.409,102.515, +circuit_n32_m14_s9_e0_pEFGH,treesa_greedy,12.613,32.0,38.534,301.8, +circuit_n32_m14_s9_e0_pEFGH,treesa_kahypar,12.616,32.0,38.531,315.007, +circuit_patch_n30_m14_s19_e18_pEFGH,cotengra,7.722,16.0,22.654,81.24,5.3438632583618215 +circuit_patch_n30_m14_s19_e18_pEFGH,treesa_greedy,7.627,15.0,21.867,243.191,5.291374429702756 +circuit_patch_n30_m14_s19_e18_pEFGH,treesa_kahypar,7.627,15.0,22.003,321.618,5.321541578292852 +circuit_n30_m14_s9_e6_pEFGH,cotengra,11.93,30.0,36.445,126.822, +circuit_n30_m14_s9_e6_pEFGH,treesa_greedy,11.767,30.0,35.616,266.514, +circuit_n30_m14_s9_e6_pEFGH,treesa_kahypar,11.755,30.0,35.362,294.707, +circuit_n30_m14_s9_e0_pEFGH,cotengra,12.108,30.0,37.106,589.94, +circuit_n30_m14_s9_e0_pEFGH,treesa_greedy,12.008,30.0,36.456,281.111, +circuit_n30_m14_s9_e0_pEFGH,treesa_kahypar,12.004,30.0,36.513,336.693, +circuit_patch_n28_m14_s19_e18_pEFGH,cotengra,7.39,15.0,21.544,67.828,4.449433633804318 +circuit_patch_n28_m14_s19_e18_pEFGH,treesa_greedy,7.295,14.0,20.685,225.298,4.4308215160369855 +circuit_patch_n28_m14_s19_e18_pEFGH,treesa_kahypar,7.296,14.0,20.815,327.638,4.614945423126244 +circuit_n28_m14_s9_e6_pEFGH,cotengra,11.337,28.0,34.601,127.216, +circuit_n28_m14_s9_e6_pEFGH,treesa_greedy,11.165,28.0,33.674,246.72, +circuit_n28_m14_s9_e6_pEFGH,treesa_kahypar,11.159,28.0,33.527,312.592, +circuit_n28_m14_s9_e0_pEFGH,cotengra,11.535,28.0,35.321,94.159, +circuit_n28_m14_s9_e0_pEFGH,treesa_greedy,11.42,28.0,34.62,264.422, +circuit_n28_m14_s9_e0_pEFGH,treesa_kahypar,11.423,28.0,34.546,339.157, +circuit_patch_n26_m14_s19_e18_pEFGH,cotengra,7.148,14.0,20.659,81.953,3.9409566612243614 +circuit_patch_n26_m14_s19_e18_pEFGH,treesa_greedy,7.079,14.0,20.113,213.555,3.86619908332824 +circuit_patch_n26_m14_s19_e18_pEFGH,treesa_kahypar,7.079,14.0,20.016,303.826,4.038710569381692 +circuit_n26_m14_s9_e6_pEFGH,cotengra,10.806,26.0,32.895,356.549,128.8634298095703 +circuit_n26_m14_s9_e6_pEFGH,treesa_greedy,10.563,26.0,31.556,236.575,56.48603467941285 +circuit_n26_m14_s9_e6_pEFGH,treesa_kahypar,10.557,26.0,31.361,300.496,49.58447723770144 +circuit_n26_m14_s9_e0_pEFGH,cotengra,10.959,26.0,33.408,88.53,181.06059762954712 +circuit_n26_m14_s9_e0_pEFGH,treesa_greedy,10.827,26.0,32.479,250.678,103.2807061405182 +circuit_n26_m14_s9_e0_pEFGH,treesa_kahypar,10.826,26.0,32.687,351.967,120.00889325904848 +circuit_patch_n24_m14_s19_e18_pEFGH,cotengra,6.729,12.0,19.348,61.661,3.498441232681273 +circuit_patch_n24_m14_s19_e18_pEFGH,treesa_greedy,6.646,12.0,18.699,198.9,3.5054071903228703 +circuit_patch_n24_m14_s19_e18_pEFGH,treesa_kahypar,6.646,12.0,18.673,300.658,3.372755758285507 +circuit_n24_m14_s9_e6_pEFGH,cotengra,10.171,24.0,30.782,311.853,30.42965380859374 +circuit_n24_m14_s9_e6_pEFGH,treesa_greedy,9.962,24.0,29.59,226.844,16.06061111068726 +circuit_n24_m14_s9_e6_pEFGH,treesa_kahypar,9.957,24.0,29.503,294.211,15.658095802307116 +circuit_n24_m14_s9_e0_pEFGH,cotengra,10.299,24.0,31.136,404.642,37.84940930175782 +circuit_n24_m14_s9_e0_pEFGH,treesa_greedy,10.227,24.0,30.55,236.778,28.07969152641297 +circuit_n24_m14_s9_e0_pEFGH,treesa_kahypar,10.219,24.0,30.526,337.676,27.57617652320863 +circuit_patch_n22_m14_s19_e18_pEFGH,cotengra,6.358,11.0,18.104,54.359,3.0047275695800764 +circuit_patch_n22_m14_s19_e18_pEFGH,treesa_greedy,6.279,11.0,17.488,178.999,2.7667670974731493 +circuit_patch_n22_m14_s19_e18_pEFGH,treesa_kahypar,6.282,11.0,17.514,261.383,2.939791814804096 +circuit_n22_m14_s9_e6_pEFGH,cotengra,9.637,22.0,29.023,63.475,10.559750938415526 +circuit_n22_m14_s9_e6_pEFGH,treesa_greedy,9.331,22.0,27.236,202.455,5.451742572784411 +circuit_n22_m14_s9_e6_pEFGH,treesa_kahypar,9.335,22.0,27.534,270.648,6.229142667770361 +circuit_n22_m14_s9_e0_pEFGH,cotengra,9.664,22.0,29.101,324.958,11.2127053184509 +circuit_n22_m14_s9_e0_pEFGH,treesa_greedy,9.577,22.0,28.5,216.074,8.796073556900012 +circuit_n22_m14_s9_e0_pEFGH,treesa_kahypar,9.577,22.0,28.517,303.148,8.924938919067358 +circuit_patch_n20_m14_s19_e18_pEFGH,cotengra,6.117,11.0,17.306,50.205,2.314639015197756 +circuit_patch_n20_m14_s19_e18_pEFGH,treesa_greedy,6.053,11.0,16.765,168.795,2.467866020202649 +circuit_patch_n20_m14_s19_e18_pEFGH,treesa_kahypar,6.052,11.0,16.821,247.906,2.282943862915033 +circuit_n20_m14_s9_e6_pEFGH,cotengra,8.855,20.0,26.352,69.377,3.870749090194707 +circuit_n20_m14_s9_e6_pEFGH,treesa_greedy,8.7,20.0,25.226,188.972,3.292818906784049 +circuit_n20_m14_s9_e6_pEFGH,treesa_kahypar,8.7,20.0,25.255,249.616,3.154874023437486 +circuit_n20_m14_s9_e0_pEFGH,cotengra,9.025,20.0,26.99,61.497,4.605196216583252 +circuit_n20_m14_s9_e0_pEFGH,treesa_greedy,8.921,20.0,26.163,200.363,3.766950284957886 +circuit_n20_m14_s9_e0_pEFGH,treesa_kahypar,8.922,20.0,26.111,269.689,3.91698325729368 +circuit_patch_n18_m14_s19_e18_pEFGH,cotengra,5.633,9.0,14.972,46.211,1.9544469966888445 +circuit_patch_n18_m14_s19_e18_pEFGH,treesa_greedy,5.58,9.0,15.293,149.954,1.8456432781219403 +circuit_patch_n18_m14_s19_e18_pEFGH,treesa_kahypar,5.578,9.0,15.371,237.544,1.9948498306274305 +circuit_n18_m14_s9_e6_pEFGH,cotengra,8.189,18.0,24.108,157.027,2.411690185546888 +circuit_n18_m14_s9_e6_pEFGH,treesa_greedy,8.084,18.0,23.467,176.467,2.463656433105456 +circuit_n18_m14_s9_e6_pEFGH,treesa_kahypar,8.084,18.0,23.472,247.014,2.3280464992523093 +circuit_n18_m14_s9_e0_pEFGH,cotengra,8.369,18.0,24.769,60.902,2.8730332355499257 +circuit_n18_m14_s9_e0_pEFGH,treesa_greedy,8.298,18.0,24.253,185.16,2.7633098030090366 +circuit_n18_m14_s9_e0_pEFGH,treesa_kahypar,8.296,18.0,24.191,275.009,2.5868957672118995 +circuit_patch_n16_m14_s19_e18_pEFGH,cotengra,5.244,8.0,14.229,41.156,1.5808226051330578 +circuit_patch_n16_m14_s19_e18_pEFGH,treesa_greedy,5.223,8.0,14.19,116.484,1.542439189910894 +circuit_patch_n16_m14_s19_e18_pEFGH,treesa_kahypar,5.221,8.0,14.219,177.855,1.4062686157226665 +circuit_n16_m14_s9_e6_pEFGH,cotengra,7.661,16.0,22.435,46.802,1.917652652740479 +circuit_n16_m14_s9_e6_pEFGH,treesa_greedy,7.461,16.0,21.268,152.908,1.6896731777191292 +circuit_n16_m14_s9_e6_pEFGH,treesa_kahypar,7.461,16.0,21.475,233.981,1.976748413085943 +circuit_n16_m14_s9_e0_pEFGH,cotengra,7.707,16.0,22.591,49.002,1.8988505344390845 +circuit_n16_m14_s9_e0_pEFGH,treesa_greedy,7.658,16.0,22.015,164.476,1.8667677154541025 +circuit_n16_m14_s9_e0_pEFGH,treesa_kahypar,7.657,16.0,22.145,263.176,2.03469669723512 +circuit_patch_n14_m14_s19_e18_pEFGH,cotengra,5.033,8.0,13.664,37.481,1.0769466819763167 +circuit_patch_n14_m14_s19_e18_pEFGH,treesa_greedy,5.026,8.0,13.612,99.889,1.2105106697082562 +circuit_patch_n14_m14_s19_e18_pEFGH,treesa_kahypar,5.026,8.0,13.612,149.045,1.068460779190076 +circuit_n14_m14_s9_e6_pEFGH,cotengra,6.9,14.0,19.893,41.197,1.3414757518768283 +circuit_n14_m14_s9_e6_pEFGH,treesa_greedy,6.881,14.0,19.725,135.419,1.4815486965179332 +circuit_n14_m14_s9_e6_pEFGH,treesa_kahypar,6.881,14.0,19.67,203.684,1.3270058784484888 +circuit_n14_m14_s9_e0_pEFGH,cotengra,7.055,14.0,20.397,44.708,1.4755951805114762 +circuit_n14_m14_s9_e0_pEFGH,treesa_greedy,7.037,14.0,20.166,150.216,1.6235471572875897 +circuit_n14_m14_s9_e0_pEFGH,treesa_kahypar,7.037,14.0,20.224,250.565,1.4627597904205345 +circuit_patch_n12_m14_s19_e18_pEFGH,cotengra,4.6,6.0,12.3,34.107,0.799267166137696 +circuit_patch_n12_m14_s19_e18_pEFGH,treesa_greedy,4.599,6.0,12.293,80.596,0.7942165889739954 +circuit_patch_n12_m14_s19_e18_pEFGH,treesa_kahypar,4.599,6.0,12.293,129.781,0.9455541553497256 +circuit_n12_m14_s9_e6_pEFGH,cotengra,6.24,12.0,17.684,39.775,1.0273772239685073 +circuit_n12_m14_s9_e6_pEFGH,treesa_greedy,6.197,12.0,17.363,118.493,1.0141830749511769 +circuit_n12_m14_s9_e6_pEFGH,treesa_kahypar,6.197,12.0,17.494,182.711,1.0144590988159052 +circuit_n12_m14_s9_e0_pEFGH,cotengra,6.409,12.0,18.255,53.6,1.1409694194793687 +circuit_n12_m14_s9_e0_pEFGH,treesa_greedy,6.387,12.0,18.034,132.08,1.27682678222655 +circuit_n12_m14_s9_e0_pEFGH,treesa_kahypar,6.387,12.0,18.077,214.627,1.1322091560363674 From a97ea2bfa18fa65a9982f88b5e70b25636957767 Mon Sep 17 00:00:00 2001 From: Jiezhong Qiu Date: Wed, 8 Feb 2023 12:45:03 +0800 Subject: [PATCH 299/725] add backend/jit info and fix typo in readme --- examples/omeinsum_julia/README.md | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/examples/omeinsum_julia/README.md b/examples/omeinsum_julia/README.md index 56bbda43..eadad801 100644 --- a/examples/omeinsum_julia/README.md +++ b/examples/omeinsum_julia/README.md @@ -7,15 +7,18 @@ We provide two solutions: * use subprocess to call a stand-alone julia script (**recommended**) * use juliacall to integrate julia script into python (seems to be more elegant, but not recommended) -We highly recommend to use the first solution based on subprocess, not only due to its compatibility to julia multi-threading, but also because the experimental KaHyPar-based initialization is developed based on it. +We highly recommend using the first solution based on subprocess, not only due to its compatibility with julia's multi-threading but also because the experimental KaHyPar-based initialization is developed based on it. ## Experiments We test contractors from OMEinsum on Google random circuits ([available online](https://datadryad.org/stash/dataset/doi:10.5061/dryad.k6t1rj8)) and compare with the cotengra contractor. -For circuits only differ in PRNG seed number (which means with the same tensor network structure, but different tensor entries), we choose the one with the largest seed. For example, we benchmark `circuit_n12_m14_s9_e6_pEFGH.qsim`, but skip +We choose the one with the largest seed for circuits that only differ in PRNG seed number (which means with the same tensor network structure but different tensor entries). For example, we benchmark `circuit_n12_m14_s9_e6_pEFGH.qsim` but skip circuits like `circuit_n12_m14_s0_e6_pEFGH.qsim`. We list experimental results in [benchmark_results.csv](benchmark_results.csv). -All experiments are done with a 32GB CPU machine with 16 cores. +All experiments are done with +1. a 32GB CPU machine with 16 cores +2. TensorCircuit with TensorFlow backend +3. without using jit Specifically, we test the following three methods: @@ -66,7 +69,7 @@ c.expectation_ps(z=[0], reuse=False) ``` Both OMEimsum and cotengra are able to optimize a weighted average of `log10[FLOPs]`, `log2[SIZE]` and `log2[WRITE]`. -However, OMEimsum and cotengra have different weight coefficient, which makes fair comparison difficult. +However, OMEimsum and cotengra have different weight coefficients, which makes fair comparison difficult. Thus we force each method to purely optimized `FLOPs`, but we do collect all contraction information in the table, including `log10[FLOPs]`, `log2[SIZE]`, `log2[WRITE]`, `PathFindingTime`, `WallClockTime`. @@ -89,19 +92,19 @@ This solution calls a stand-alone julia script [omeinsum.jl](omeinsum.jl) for te #### How to run Run -`JULIA_NUM_THREADS=N python omeinsum_contractor_subprocess.py`. The env variable `JULIA_NUM_THREADS=N` will be passed to the julia script, so that you can enjoy the accelaration brought by julia multi-threading. +`JULIA_NUM_THREADS=N python omeinsum_contractor_subprocess.py`. The env variable `JULIA_NUM_THREADS=N` will be passed to the julia script, so that you can enjoy the acceleration brought by julia multi-threading. #### KaHyPar initialization The choice of initial status plays an important role in simulated annealing. In a [discussion with the author of OMEinsum](https://github.com/TensorBFS/OMEinsumContractionOrders.jl/issues/35), we -found that there was a way to run TreeSA with initialzier other than greedy or random. We demo how KaHyPar can be used to produce the initial status of simulated annealing. Although we haven't seen significant improvement by using KaHyPar initialization, we believe it is a interesting topic to explore. +found that there was a way to run TreeSA with initializer other than greedy or random. We demo how KaHyPar can produce the initial status of simulated annealing. Although we have not seen significant improvement by using KaHyPar initialization, we believe it is an interesting topic to explore. ### JuliaCall solution (Not Recommended) JuliaCall seems to be a more elegant solution because all related code are integrated into a single python script. -However, in order to use julia multi-threading in juliacall, we have to turn off julia GC at the risk of OOM. See see [this issue](https://github.com/cjdoris/PythonCall.jl/issues/219) for more details. +However, in order to use julia multi-threading in juliacall, we have to turn off julia GC at the risk of OOM. See [this issue](https://github.com/cjdoris/PythonCall.jl/issues/219) for more details. #### Setup From 3feed1d689a57a3af8cdbd0ac6c7984ee5cd0b13 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Feb 2023 14:40:02 +0800 Subject: [PATCH 300/725] attached mit to device instead of task --- tensorcircuit/cloud/abstraction.py | 6 +++--- tensorcircuit/cloud/tencent.py | 1 + tensorcircuit/cloud/wrapper.py | 11 ++++++++--- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index d145faf7..d234e20d 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -413,7 +413,7 @@ def results( device = self.get_device() if device.provider.name != "tencent": raise ValueError("Only tencent provider supports auto readout mitigation") - if readout_mit is None and getattr(self, "readout_mit", None) is None: + if readout_mit is None and getattr(device, "readout_mit", None) is None: def run(cs: Any, shots: Any) -> Any: """ @@ -431,9 +431,9 @@ def run(cs: Any, shots: Any) -> Any: readout_mit.cals_from_system( list(range(nqubit)), shots, **calibriation_options ) - self.readout_mit = readout_mit + device.readout_mit = readout_mit elif readout_mit is None: - readout_mit = self.readout_mit + readout_mit = device.readout_mit if mitigation_options is None: try: diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 55ac9ce8..282a7551 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -132,6 +132,7 @@ def submit_task( enable_qos_gate_decomposition: bool = True, enable_qos_initial_mapping: bool = False, qos_dry_run: bool = False, + **kws: Any ) -> List[Task]: """ Submit task via tencent provider, we suggest to enable one of the compiling functionality: diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 8fe868aa..1cb58f98 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -83,6 +83,7 @@ def batch_sample_expectation_ps( if isinstance(device, str): device = get_device(device) for ps in pss: + # TODO(@refraction-ray): Pauli string grouping c1 = Circuit.from_qir(c.to_qir()) exp = [] for j, i in enumerate(ps): @@ -122,9 +123,13 @@ def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: raw_counts = run(cs, shots) if with_rem: - mit = ReadoutMit(run) - # TODO(@refraction-ray) only work for tencent provider - mit.cals_from_system(device.list_properties()["qubits"]) + if getattr(device, "readout_mit", None) is None: + mit = ReadoutMit(run) + # TODO(@refraction-ray) only work for tencent provider + mit.cals_from_system(device.list_properties()["qubits"], shots=shots) + device.readout_mit = mit + else: + mit = device.readout_mit results = [ mit.expectation(raw_counts[i], exps[i], **infos[i]) From b8bd03b7a6b96d05fabd22ff611a22982c2f2f42 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Feb 2023 15:30:55 +0800 Subject: [PATCH 301/725] fix bug when only one circuit in wrapper --- tensorcircuit/cloud/wrapper.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 1cb58f98..891c3c82 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -117,6 +117,8 @@ def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: enable_qos_qubit_mapping=False, enable_qos_gate_decomposition=False, ) + if not is_sequence(ts): + ts = [ts] raw_counts = [t.results(blocked=True) for t in ts] return raw_counts From 99f955fe9d9f3363df8cdfd2fe57262894f71abd Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Feb 2023 16:01:50 +0800 Subject: [PATCH 302/725] fix mypy --- tensorcircuit/cloud/abstraction.py | 1 + tensorcircuit/cloud/wrapper.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index d234e20d..0a17928c 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -135,6 +135,7 @@ def __init__( self.name = name self.provider = get_provider() + self.readout_mit: Any = None def __str__(self) -> str: return self.provider.name + sep + self.name diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 891c3c82..fb84323e 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -118,7 +118,7 @@ def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: enable_qos_gate_decomposition=False, ) if not is_sequence(ts): - ts = [ts] + ts = [ts] # type: ignore raw_counts = [t.results(blocked=True) for t in ts] return raw_counts From 29343107d1a7b204b44f4100e4bf7fb866503db4 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Feb 2023 16:02:56 +0800 Subject: [PATCH 303/725] add nonjit keras layer --- CHANGELOG.md | 2 ++ tensorcircuit/keras.py | 27 +++++++++++++++++++++++++++ 2 files changed, 29 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 537e3642..78d1c416 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,6 +24,8 @@ - Add Tensorcircuit MacOS (univerisal) installation guide +- Add KerasLayer without jit (quantum hardware compatible) + ### Fixed - Circuit nosify in noise model now support all circuit attributs apart from qubit number diff --git a/tensorcircuit/keras.py b/tensorcircuit/keras.py index c8f9415f..5788c685 100644 --- a/tensorcircuit/keras.py +++ b/tensorcircuit/keras.py @@ -123,6 +123,33 @@ def call( KerasLayer = QuantumLayer +class HardwareLayer(QuantumLayer): # type: ignore + def call( + self, + inputs: tf.Tensor, + training: Optional[bool] = None, + mask: Optional[tf.Tensor] = None, + **kwargs: Any + ) -> tf.Tensor: + if inputs is None: # not possible + result = self.f(*self.pqc_weights, **kwargs) + elif ( + len( + backend.tree_map(backend.shape_tuple, backend.tree_flatten(inputs))[0][ + 0 + ] + ) + == 1 + ): + result = self.f(inputs, *self.pqc_weights, **kwargs) + else: + result = [] + for inp in inputs: + result.append(self.f(inp, *self.pqc_weights, **kwargs)) + result = tf.stack(result) + return result + + def output_asis_loss(y_true: tf.Tensor, y_pred: tf.Tensor) -> tf.Tensor: """ The keras loss function that directly taking the model output as the loss. From 4b32443e9350e09b212ca30e9dd06ba9d1d246b6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Feb 2023 16:22:54 +0800 Subject: [PATCH 304/725] fix potential qiskit parameterexpression after compiling --- tensorcircuit/compiler/qiskit_compiler.py | 6 +++++- tensorcircuit/translation.py | 3 ++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/compiler/qiskit_compiler.py b/tensorcircuit/compiler/qiskit_compiler.py index 31e1cde8..9a56b5b4 100644 --- a/tensorcircuit/compiler/qiskit_compiler.py +++ b/tensorcircuit/compiler/qiskit_compiler.py @@ -144,7 +144,11 @@ def qiskit_compile( r0 = ncircuit elif output.lower() in ["tc", "tensorcircuit"]: - r0 = Circuit.from_qiskit(ncircuit) + s = _free_pi(ncircuit.qasm()) + r0 = Circuit.from_openqasm( + s, + keep_measure_order=True, + ) else: raise ValueError("Unknown output format: %s" % output) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 72f73506..1832690b 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -726,7 +726,8 @@ def qiskit_from_qasm_str_ordered_measure(qasm_str: str) -> Any: for line in qasm_str.split("\n"): if line.startswith("measure"): index = int(line.split(" ")[1][2:-1]) - cindex = int(line.split(" ")[3].strip(";")[2:-1]) + cindex = int(line.split(" ")[3].strip(";").split("[")[1][:-1]) + # sometimes we have qasm as "measure q[3] -> meas[0];" measure_sequence.append((index, cindex)) else: From bc006b6fca24a2cbd1a09b5cdb95d0853082dd97 Mon Sep 17 00:00:00 2001 From: liwt31 Date: Wed, 8 Feb 2023 16:40:59 +0800 Subject: [PATCH 305/725] fix translation --- tensorcircuit/translation.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 1832690b..f6fcc5bf 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -354,6 +354,9 @@ def _translate_qiskit_params( elif isinstance(p, Parameter): parameters.append(binding_params[p]) elif isinstance(p, ParameterExpression): + if len(p.parameters) == 0: + parameters.append(float(p)) + continue if len(p.parameters) != 1: raise ValueError( f"Can't translate parameter expression with more than 1 parameters: {p}" From f381b73964e575595a1d6657637b18bb3341ab23 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Feb 2023 16:41:53 +0800 Subject: [PATCH 306/725] add nonjit label --- tensorcircuit/keras.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorcircuit/keras.py b/tensorcircuit/keras.py index 5788c685..aa7e03f3 100644 --- a/tensorcircuit/keras.py +++ b/tensorcircuit/keras.py @@ -124,6 +124,7 @@ def call( class HardwareLayer(QuantumLayer): # type: ignore + @tf.autograph.experimental.do_not_convert def call( self, inputs: tf.Tensor, From 541430109b0f47bcf7525ae5804d3312dc910299 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Feb 2023 16:56:08 +0800 Subject: [PATCH 307/725] fix mypy --- tensorcircuit/keras.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/keras.py b/tensorcircuit/keras.py index aa7e03f3..a549be1b 100644 --- a/tensorcircuit/keras.py +++ b/tensorcircuit/keras.py @@ -124,7 +124,7 @@ def call( class HardwareLayer(QuantumLayer): # type: ignore - @tf.autograph.experimental.do_not_convert + @tf.autograph.experimental.do_not_convert # type: ignore def call( self, inputs: tf.Tensor, From 4620ba5866b7532634e67b170732a191644ed1d8 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Feb 2023 19:37:59 +0800 Subject: [PATCH 308/725] add regularizers for keraslayer --- CHANGELOG.md | 2 ++ tensorcircuit/keras.py | 16 +++++++++++++--- tests/test_keras.py | 15 +++++++++++++++ 3 files changed, 30 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 78d1c416..4d991b11 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,8 @@ - Add KerasLayer without jit (quantum hardware compatible) +- Add regularizer support for KerasLayer + ### Fixed - Circuit nosify in noise model now support all circuit attributs apart from qubit number diff --git a/tensorcircuit/keras.py b/tensorcircuit/keras.py index a549be1b..82096481 100644 --- a/tensorcircuit/keras.py +++ b/tensorcircuit/keras.py @@ -7,7 +7,7 @@ import numpy as np import tensorflow as tf from tensorflow.keras.layers import Layer -from tensorflow.keras import initializers, constraints +from tensorflow.keras import initializers, constraints, regularizers from .cons import rdtypestr, backend @@ -23,6 +23,7 @@ def __init__( weights_shape: Sequence[Tuple[int, ...]], initializer: Union[Text, Sequence[Text]] = "glorot_uniform", constraint: Optional[Union[Text, Sequence[Text]]] = None, + regularizer: Optional[Union[Text, Sequence[Text]]] = None, **kwargs: Any ) -> None: """ @@ -38,6 +39,8 @@ def __init__( :type initializer: Union[Text, Sequence[Text]], optional :param constraint: [description], defaults to None :type constraint: Optional[Union[Text, Sequence[Text]]], optional + :param initializer: The regularizer of the weights, defaults to None + :type initializer: Union[Text, Sequence[Text]], optional """ super().__init__(**kwargs) @@ -58,14 +61,20 @@ def __init__( constraints.get(item) if isinstance(item, str) else item for item in constraint ] + if not (isinstance(regularizer, list) or isinstance(regularizer, tuple)): + regularizer = [regularizer for _ in range(self.number_weights)] # type: ignore + self.regularizer = [ + regularizers.get(item) if isinstance(item, str) else item + for item in regularizer + ] def build(self, input_shape: Optional[List[int]] = None) -> None: if input_shape is None: input_shape = [1, 1] super().build(input_shape) self.pqc_weights = [] - for i, (shape, init, cst) in enumerate( - zip(self.weights_shape, self.initializer, self.constraint) + for i, (shape, init, cst, reg) in enumerate( + zip(self.weights_shape, self.initializer, self.constraint, self.regularizer) ): self.pqc_weights.append( self.add_weight( @@ -75,6 +84,7 @@ def build(self, input_shape: Optional[List[int]] = None) -> None: trainable=True, initializer=init, constraint=cst, + regularizer=reg, ) ) diff --git a/tests/test_keras.py b/tests/test_keras.py index db11b69a..187a316e 100644 --- a/tests/test_keras.py +++ b/tests/test_keras.py @@ -113,6 +113,21 @@ def test_function_io(tfb, tmp_path, highp): print(loaded(weights=tf.ones([6, 6], dtype=tf.float64), nlayers=3, n=6)) +def test_keras_hardware(tfb): + n = 2 + + def qf(inputs, param): + c = tc.Circuit(n) + c.rx(0, theta=inputs[0]) + c.rx(1, theta=inputs[1]) + c.h(1) + c.rzz(0, 1, theta=param[0]) + return tc.backend.stack([c.expectation_ps(z=[i]) for i in range(n)]) + + ql = tc.keras.HardwareLayer(qf, [1], regularizer=tf.keras.regularizers.l2(1e-3)) + print(ql(tf.ones([1, 2]))) + + def test_keras_layer_inputs_dict(tfb): n = 3 p = 0.1 From 3f4fe44731ba86984e0a7ca805c5aa09f6ade9af Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 9 Feb 2023 13:00:19 +0800 Subject: [PATCH 309/725] batch cloud wrapper: circuit merging, logging, list return --- tensorcircuit/cloud/apis.py | 4 ++-- tensorcircuit/cloud/wrapper.py | 39 ++++++++++++++++++++++++++++------ tests/test_cloud.py | 2 +- 3 files changed, 36 insertions(+), 9 deletions(-) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index ca396180..9c462252 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -88,11 +88,11 @@ def set_device( if isinstance(device, str): if len(device.split(sep)) > 1: - device = Device(device, provider) + device = Device.from_name(device, provider) else: if provider is None: provider = get_provider() - device = Device(device, provider) + device = Device.from_name(device, provider) else: if provider is None: provider = get_provider() diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index fb84323e..4bbc246e 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -2,6 +2,8 @@ higher level wrapper shortcut for submit_task """ from typing import Any, Callable, Dict, List, Optional, Sequence, Union +import logging +import time import numpy as np @@ -13,6 +15,8 @@ from .apis import submit_task, get_device from .abstraction import Device + +logger = logging.getLogger(__name__) Tensor = Any @@ -76,7 +80,7 @@ def batch_sample_expectation_ps( ws: Optional[List[float]] = None, shots: int = 8192, with_rem: bool = True, -) -> float: +) -> Union[float, List[float]]: cs = [] infos = [] exps = [] @@ -106,10 +110,23 @@ def batch_sample_expectation_ps( cs.append(c1) infos.append(info) exps.append(exp) - if ws is None: - ws = [1.0 for _ in range(len(pss))] + + reduced_cs = [] + reduced_dict = {} + recover_dict = {} + # merge the same circuit + for j, ps in enumerate(pss): + ps = [i if i in [1, 2] else 0 for i in ps] + if tuple(ps) not in reduced_dict: + reduced_dict[tuple(ps)] = [j] + reduced_cs.append(cs[j]) + recover_dict[tuple(ps)] = len(reduced_cs) - 1 + else: + reduced_dict[tuple(ps)].append(j) def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: + logger.info(f"submit task on {device.name} for {len(cs)} circuits") + time0 = time.time() ts = submit_task( circuit=cs, device=device, @@ -120,9 +137,17 @@ def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: if not is_sequence(ts): ts = [ts] # type: ignore raw_counts = [t.results(blocked=True) for t in ts] + time1 = time.time() + logger.info( + f"finished collecting count results of {len(cs)} tasks in {round(time1-time0, 4)} seconds" + ) return raw_counts - raw_counts = run(cs, shots) + reduced_raw_counts = run(reduced_cs, shots) + raw_counts: List[Dict[str, int]] = [None] * len(cs) # type: ignore + for i in range(len(cs)): + ps = [i if i in [1, 2] else 0 for i in pss[i]] + raw_counts[i] = reduced_raw_counts[recover_dict[tuple(ps)]] if with_rem: if getattr(device, "readout_mit", None) is None: @@ -141,5 +166,7 @@ def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: results = [ counts.expectation(raw_counts[i], exps[i]) for i in range(len(raw_counts)) ] - sumr = sum([w * r for w, r in zip(ws, results)]) - return sumr + if ws is not None: + sumr = sum([w * r for w, r in zip(ws, results)]) + return sumr + return results diff --git a/tests/test_cloud.py b/tests/test_cloud.py index 82902fa0..d99d4de5 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -118,7 +118,7 @@ def test_local_batch_submit(): c.ry(1, theta=0.8) ts = apis.submit_task(device="testing", circuit=[c, c]) - print(ts[0].results(mitigated=True)) + print(ts[0].results()) apis.set_device("testing") ts = apis.submit_task(circuit=[c, c]) From d34924312856bb471c5c3a59a4f01f6593f0475b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 9 Feb 2023 13:01:04 +0800 Subject: [PATCH 310/725] new paradigm of sample in readme --- README.md | 2 +- README_cn.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 5475214b..777f2a0c 100644 --- a/README.md +++ b/README.md @@ -51,7 +51,7 @@ c.CNOT(0,1) c.rx(1, theta=0.2) print(c.wavefunction()) print(c.expectation_ps(z=[0, 1])) -print(c.sample()) +print(c.sample(allow_state=True, batch=1024, format="count_dict_bin")) ``` - Runtime behavior customization: diff --git a/README_cn.md b/README_cn.md index a4a8a26d..777e866a 100644 --- a/README_cn.md +++ b/README_cn.md @@ -47,7 +47,7 @@ c.CNOT(0,1) c.rx(1, theta=0.2) print(c.wavefunction()) print(c.expectation_ps(z=[0, 1])) -print(c.sample()) +print(c.sample(allow_state=True, batch=1024, format="count_dict_bin")) ``` - 运行时特性定制: From 917aadcb2849fa8144947f7376d8c068101f5c4b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 9 Feb 2023 14:34:35 +0800 Subject: [PATCH 311/725] new version black --- benchmarks/scripts/utils.py | 1 + docs/source/generate_rst.py | 2 -- docs/source/tutorials/dqas.ipynb | 1 - docs/source/tutorials/dqas_cn.ipynb | 1 - docs/source/tutorials/tfim_vqe.ipynb | 1 - docs/source/tutorials/tfim_vqe_cn.ipynb | 1 - examples/bp_benchmark.py | 3 --- examples/noise_calibration.py | 6 +----- examples/optperformance_comparison.py | 1 - examples/universal_lr.py | 2 +- examples/vqetfim_benchmark.py | 2 -- requirements/requirements-dev.txt | 2 +- requirements/requirements-docker.txt | 2 +- tensorcircuit/applications/dqas.py | 1 - tensorcircuit/applications/vags.py | 2 +- tensorcircuit/applications/vqes.py | 2 -- tensorcircuit/backends/tensorflow_backend.py | 1 - tensorcircuit/channels.py | 9 --------- tensorcircuit/mps_base.py | 2 +- tensorcircuit/noisemodel.py | 7 ------- tensorcircuit/quantum.py | 10 +++++----- tensorcircuit/results/readout_mitigation.py | 7 ------- tensorcircuit/translation.py | 1 - tensorcircuit/vis.py | 1 - tests/test_calibrating.py | 5 ----- tests/test_channels.py | 6 ------ tests/test_noisemodel.py | 1 - tests/test_quantum.py | 1 - tests/test_results.py | 2 -- tests/test_torchnn.py | 1 - 30 files changed, 12 insertions(+), 72 deletions(-) diff --git a/benchmarks/scripts/utils.py b/benchmarks/scripts/utils.py index bd437cec..82b2a01d 100644 --- a/benchmarks/scripts/utils.py +++ b/benchmarks/scripts/utils.py @@ -128,6 +128,7 @@ def mnist_data_preprocessing(PCA_components=10): if qml_data == {}: if Path("mnist.npz").exists(): print("load local dataset") + # from https://www.kaggle.com/vikramtiwari/mnist-numpy def load_data(path): with np.load(path) as f: diff --git a/docs/source/generate_rst.py b/docs/source/generate_rst.py index a0226511..60fcf0de 100644 --- a/docs/source/generate_rst.py +++ b/docs/source/generate_rst.py @@ -5,7 +5,6 @@ class RSTGenerator: - title_line = "=" * 50 toctree = ".. toctree::\n {}" automodule = ".. automodule:: {}\n :members:\n :undoc-members:\n :show-inheritance:\n :inherited-members:" @@ -38,7 +37,6 @@ def single_file_module(self): """Process the module in the self.pfolder/*.py""" for module_name in glob.glob(pj(self.pfolder, "*.py")): - module_name = os.path.basename(module_name)[:-3] if module_name in self.ingnored_modules: continue diff --git a/docs/source/tutorials/dqas.ipynb b/docs/source/tutorials/dqas.ipynb index d66f75e6..d652a3f0 100644 --- a/docs/source/tutorials/dqas.ipynb +++ b/docs/source/tutorials/dqas.ipynb @@ -554,7 +554,6 @@ "nnp = K.implicit_randn(stddev=0.02, shape=[p, 6], dtype=rtype)\n", "stp = K.implicit_randn(stddev=0.02, shape=[p, 8], dtype=rtype)\n", "for epoch in range(epochs):\n", - "\n", " infd, (gnnp, gstp) = vag2(nnp, stp)\n", "\n", " nnp = network_opt.update(gnnp, nnp)\n", diff --git a/docs/source/tutorials/dqas_cn.ipynb b/docs/source/tutorials/dqas_cn.ipynb index 504dfc79..6306ef2b 100644 --- a/docs/source/tutorials/dqas_cn.ipynb +++ b/docs/source/tutorials/dqas_cn.ipynb @@ -550,7 +550,6 @@ "nnp = K.implicit_randn(stddev=0.02, shape=[p, 6], dtype=rtype)\n", "stp = K.implicit_randn(stddev=0.02, shape=[p, 8], dtype=rtype)\n", "for epoch in range(epochs):\n", - "\n", " infd, (gnnp, gstp) = vag2(nnp, stp)\n", "\n", " nnp = network_opt.update(gnnp, nnp)\n", diff --git a/docs/source/tutorials/tfim_vqe.ipynb b/docs/source/tutorials/tfim_vqe.ipynb index d515d288..31170fe5 100644 --- a/docs/source/tutorials/tfim_vqe.ipynb +++ b/docs/source/tutorials/tfim_vqe.ipynb @@ -443,7 +443,6 @@ "\n", "\n", "def batched_train_step_jax(batch, n, nlayers, maxiter=10000):\n", - "\n", " key = jax.random.PRNGKey(42)\n", " param = jax.random.normal(key, shape=[batch, nlayers * 2, n]) * 0.1\n", " opt_init, opt_update, get_params = optimizers.adam(step_size=1e-2)\n", diff --git a/docs/source/tutorials/tfim_vqe_cn.ipynb b/docs/source/tutorials/tfim_vqe_cn.ipynb index 42132ad6..fbb293a1 100644 --- a/docs/source/tutorials/tfim_vqe_cn.ipynb +++ b/docs/source/tutorials/tfim_vqe_cn.ipynb @@ -440,7 +440,6 @@ "\n", "\n", "def batched_train_step_jax(batch, n, nlayers, maxiter=10000):\n", - "\n", " key = jax.random.PRNGKey(42)\n", " param = jax.random.normal(key, shape=[batch, nlayers * 2, n]) * 0.1\n", " opt_init, opt_update, get_params = optimizers.adam(step_size=1e-2)\n", diff --git a/examples/bp_benchmark.py b/examples/bp_benchmark.py index 9d74d12e..98a81621 100644 --- a/examples/bp_benchmark.py +++ b/examples/bp_benchmark.py @@ -54,7 +54,6 @@ def generate_random_qnn(qubits, symbol, depth): return circuit def process_batch(circuits, symbol, op): - # Setup a simple layer to batch compute the expectation gradients. expectation = tfq.layers.Expectation() @@ -125,7 +124,6 @@ def op_expectation(params, seed, n_qubits, depth): def pennylane_approach(n_qubits=10, depth=10, n_circuits=100): - dev = qml.device("lightning.qubit", wires=n_qubits) gate_set = [qml.RX, qml.RY, qml.RZ] @@ -161,7 +159,6 @@ def rand_circuit(params, status): def tc_approach(n_qubits=10, depth=10, n_circuits=100): - seed = tc.array_to_tensor( np.random.uniform(low=0.0, high=1.0, size=[n_circuits, n_qubits, depth]), dtype="float32", diff --git a/examples/noise_calibration.py b/examples/noise_calibration.py index cd61c897..c88392dc 100644 --- a/examples/noise_calibration.py +++ b/examples/noise_calibration.py @@ -7,6 +7,7 @@ from scipy.optimize import minimize, curve_fit import tensorcircuit as tc + # Add readout error and mitigate readout error with two methods. def miti_readout_circ(nqubit): miticirc = [] @@ -49,7 +50,6 @@ def fun(x): def mitigate_readout(nqubit, circ, readout_error): - K = tc.set_backend("tensorflow") key = K.get_random_state(42) @@ -125,12 +125,10 @@ def fit_function(x_values, y_values, function, init_params): def T1_cali(t1, t2, time, method, excitedstatepopulation): - # calibrating experiments nstep = int(4 * t1 / time) pex = [] for i in range(nstep): - dmc = tc.DMCircuit(1) dmc.x(0) for _ in range(i): @@ -155,12 +153,10 @@ def T1_cali(t1, t2, time, method, excitedstatepopulation): def T2_cali(t1, t2, time, method, excitedstatepopulation): - # calibrating experiments nstep = int(4 * t2 / time) pex = [] for i in range(nstep): - dmc = tc.DMCircuit(1) dmc.h(0) for _ in range(0, i): diff --git a/examples/optperformance_comparison.py b/examples/optperformance_comparison.py index 7011210c..7ebe0be9 100644 --- a/examples/optperformance_comparison.py +++ b/examples/optperformance_comparison.py @@ -59,7 +59,6 @@ def energy_p(params, p, seed, n, nlayers): if __name__ == "__main__": - n = 12 nlayers = 12 nsteps = 250 diff --git a/examples/universal_lr.py b/examples/universal_lr.py index d98e62ca..2aa547c8 100644 --- a/examples/universal_lr.py +++ b/examples/universal_lr.py @@ -27,6 +27,7 @@ def lr(xs, ys): """ fully ML backend agnostic linear regression implementation """ + # construct the loss def loss_pointwise(x, y, param): k, b = param["k"], param["b"] @@ -74,7 +75,6 @@ def loss(xs, ys, param): if __name__ == "__main__": - for n in ["tensorflow", "jax"]: with tc.runtime_backend(n): # runtime backend switch with context manager print("~~~~~~~~ using %s backend ~~~~~~~~" % n) diff --git a/examples/vqetfim_benchmark.py b/examples/vqetfim_benchmark.py index 9b17c27a..343fb05d 100644 --- a/examples/vqetfim_benchmark.py +++ b/examples/vqetfim_benchmark.py @@ -119,13 +119,11 @@ def vqe_template(param, op): ) if enable_dense is True: - hamiltonian_dense = K.to_dense(hamiltonian_sparse) vqe3 = partial(vqe_template, op=hamiltonian_dense) else: - vqe3 = vqe1 # 4. sparse matrix diff --git a/requirements/requirements-dev.txt b/requirements/requirements-dev.txt index 5929ef0c..c1b1cf2d 100644 --- a/requirements/requirements-dev.txt +++ b/requirements/requirements-dev.txt @@ -3,7 +3,7 @@ pytest==6.2.4 pytest-cov pytest-benchmark pytest-xdist -black==22.3.0 +black==23.1.0 sphinx>=4.0 pytest-lazy-fixture pylint==2.11.1 diff --git a/requirements/requirements-docker.txt b/requirements/requirements-docker.txt index 57d327a0..c3195c12 100644 --- a/requirements/requirements-docker.txt +++ b/requirements/requirements-docker.txt @@ -28,7 +28,7 @@ pytest-cov pytest-benchmark pytest-xdist pytest-lazy-fixture -black==22.3.0 +black==23.1.0 sphinx>=4.0 sphinx-intl sphinx-copybutton diff --git a/tensorcircuit/applications/dqas.py b/tensorcircuit/applications/dqas.py index c6bf7a22..d139fe01 100644 --- a/tensorcircuit/applications/dqas.py +++ b/tensorcircuit/applications/dqas.py @@ -778,7 +778,6 @@ def DQAS_search_pmb( try: for epoch in range(epochs): # iteration to update strcuture param - print("----------new epoch %s-----------" % epoch) deri_stp = [] diff --git a/tensorcircuit/applications/vags.py b/tensorcircuit/applications/vags.py index 7311eb81..80e5b74a 100644 --- a/tensorcircuit/applications/vags.py +++ b/tensorcircuit/applications/vags.py @@ -681,6 +681,7 @@ def gatewise_vqe_vag( try: v = sympy.symbols("v_{0:64}") vv = sympy.symbols(["v_" + str(i) + "_0:32" for i in range(32)]) + # symbol pool def double_qubits_initial() -> Iterator[Sequence[Any]]: while True: @@ -750,7 +751,6 @@ def q(i: int) -> cirq.LineQubit: @lru_cache() def qft_circuit(n: int) -> cirq.Circuit: - circuit = cirq.Circuit() for i in reversed(range(n)): circuit.append(cirq.H(q(i))) diff --git a/tensorcircuit/applications/vqes.py b/tensorcircuit/applications/vqes.py index 98ffa355..8eb6c510 100644 --- a/tensorcircuit/applications/vqes.py +++ b/tensorcircuit/applications/vqes.py @@ -282,7 +282,6 @@ def create_real_model( width: int = 2, **kws: Any, ) -> Model: - model = tf.keras.Sequential() for _ in range(depth): model.add(tf.keras.layers.Dense(width * self.n, activation="relu")) @@ -485,7 +484,6 @@ def plain_evaluation(self, cv: Tensor) -> Tensor: :rtype: Tensor """ with tf.GradientTape() as tape: - c = self.circuit(cv) if not self.shortcut: loss = tf.math.real(vqe_energy(c, self.hamiltonian)) diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index dbee893c..59fc1a02 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -795,7 +795,6 @@ def pf(x: Tensor) -> Tensor: return tf.vectorized_map(pf, args[0]) else: - # @self.jit # otherwise, vectorized_map claim on retracing def wrapper(*args: Any, **kws: Any) -> Tensor: # @self.jit diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index 808571ac..6d085b10 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -126,21 +126,17 @@ def generaldepolarizingchannel( """ if num_qubits == 1: - if isinstance(p, float): - assert p > 0 and p < 1 / 3, "p should be >0 and <1/3" probs = [1 - 3 * p] + 3 * [p] elif isinstance(p, list): - assert reduce( and_, [pi > 0 and pi < 1 for pi in p] ), "p should be >0 and <1" probs = [1 - sum(p)] + p # type: ignore elif isinstance(p, tuple): - p = list[p] # type: ignore assert reduce( and_, [pi > 0 and pi < 1 for pi in p] @@ -151,21 +147,17 @@ def generaldepolarizingchannel( raise ValueError("p should be float or list") elif num_qubits == 2: - if isinstance(p, float): - assert p > 0 and p < 1, "p should be >0 and <1/15" probs = [1 - 15 * p] + 15 * [p] elif isinstance(p, list): - assert reduce( and_, [pi > 0 and pi < 1 for pi in p] ), "p should be >0 and <1" probs = [1 - sum(p)] + p # type: ignore elif isinstance(p, tuple): - p = list[p] # type: ignore assert reduce( and_, [pi > 0 and pi < 1 for pi in p] @@ -695,7 +687,6 @@ def choi_to_kraus( truncation_rules = {} if truncation_rules.get("max_singular_values", None) is not None: - nkraus = truncation_rules["max_singular_values"] for i in range(nkraus): k = backend.sqrt(backend.cast(e[-(i + 1)], dtypestr)) * backend.transpose( diff --git a/tensorcircuit/mps_base.py b/tensorcircuit/mps_base.py index 146493a7..1b09b5a8 100644 --- a/tensorcircuit/mps_base.py +++ b/tensorcircuit/mps_base.py @@ -19,6 +19,7 @@ class FiniteMPS(tn.FiniteMPS): # type: ignore center_position: Optional[int] + # TODO(@SUSYUSTC): Maybe more functions can be put here to disentangle with circuits def apply_two_site_gate( self, @@ -264,7 +265,6 @@ def measure_two_body_correlator( c = [] if len(left_sites) > 0: - A = Node(self.tensors[site1], backend=self.backend) O1 = Node(op1, backend=self.backend) conj_A = conj(A) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 031816ef..9ce7f87d 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -114,7 +114,6 @@ def apply_qir_with_noise( """ quantum_index = 0 for d in qir: - d["name"] = AbstractCircuit.standardize_gate(d["name"]) if "parameters" not in d: # paramized gate @@ -126,12 +125,10 @@ def apply_qir_with_noise( if isinstance(c, DMCircuit): if d["name"] in noise_conf.nc: - if ( "Default" in noise_conf.nc[d["name"]] or d["index"] in noise_conf.nc[d["name"]] ): - if "Default" in noise_conf.nc[d["name"]]: noise_kraus = noise_conf.nc[d["name"]]["Default"] if d["index"] in noise_conf.nc[d["name"]]: @@ -141,12 +138,10 @@ def apply_qir_with_noise( else: if d["name"] in noise_conf.nc: - if ( "Default" in noise_conf.nc[d["name"]] or d["index"] in noise_conf.nc[d["name"]] ): - if "Default" in noise_conf.nc[d["name"]]: noise_kraus = noise_conf.nc[d["name"]]["Default"] if d["index"] in noise_conf.nc[d["name"]]: @@ -290,7 +285,6 @@ def sample_expectation_ps_noisfy( readout_error = None if noise_conf.has_quantum is True: - # density matrix if isinstance(c, DMCircuit): cnoise = circuit_with_noise(c, noise_conf) # type: ignore @@ -368,7 +362,6 @@ def expectation_noisfy( logger.warning("expectation_ps_noisfy can't support readout error.") if noise_conf.has_quantum is True: - # density matrix if isinstance(c, DMCircuit): cnoise = circuit_with_noise(c, noise_conf) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 8b195678..a2857f0a 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -195,7 +195,7 @@ def check_spaces(edges_1: Sequence[Edge], edges_2: Sequence[Edge]) -> None: "with {} subsystems.".format(len(edges_1), len(edges_2)) ) - for (i, (e1, e2)) in enumerate(zip(edges_1, edges_2)): + for i, (e1, e2) in enumerate(zip(edges_1, edges_2)): if e1.dimension != e2.dimension: raise ValueError( "Hilbert-space mismatch on subsystems {}: Input " @@ -429,10 +429,10 @@ def check_network(self) -> None: there are no other dangling edges (except any specified in `ignore_edges`). If not, an exception is raised. """ - for (i, e) in enumerate(self.out_edges): + for i, e in enumerate(self.out_edges): if not e.is_dangling(): raise ValueError("Output edge {} is not dangling!".format(i)) - for (i, e) in enumerate(self.in_edges): + for i, e in enumerate(self.in_edges): if not e.is_dangling(): raise ValueError("Input edge {} is not dangling!".format(i)) for e in self.ignore_edges: @@ -511,7 +511,7 @@ def partial_trace(self, subsystems_to_trace_out: Collection[int]) -> "QuOperator check_spaces(in_edges_trace, out_edges_trace) nodes_dict, edge_dict = copy(self.nodes, False) - for (e1, e2) in zip(out_edges_trace, in_edges_trace): + for e1, e2 in zip(out_edges_trace, in_edges_trace): edge_dict[e1] = edge_dict[e1] ^ edge_dict[e2] # get leftover edges in the original order @@ -544,7 +544,7 @@ def __matmul__(self, other: Union["QuOperator", Tensor]) -> "QuOperator": nodes_dict2, edges_dict2 = copy(other.nodes, False) # connect edges to create network for the result - for (e1, e2) in zip(self.in_edges, other.out_edges): + for e1, e2 in zip(self.in_edges, other.out_edges): _ = edges_dict1[e1] ^ edges_dict2[e2] in_edges = [edges_dict2[e] for e in other.in_edges] diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index e2d6dbf1..1065e396 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -128,7 +128,6 @@ def get_matrix(self, qubits: Optional[Sequence[Any]] = None) -> Tensor: qubits = self.cal_qubits if self.local is False: - lbs = [marginal_count(i, qubits) for i in self.global_cal] calmatrix = np.zeros((2 ** len(qubits), 2 ** len(qubits))) @@ -153,7 +152,6 @@ def get_matrix(self, qubits: Optional[Sequence[Any]] = None) -> Tensor: return calmatrix def _form_cals(self, qubits): # type: ignore - qubits = np.asarray(qubits, dtype=int) cals = np.zeros(4 * qubits.shape[0], dtype=float) @@ -534,7 +532,6 @@ def apply_correction( quasi_out = [] for idx, cnts in enumerate(counts): - quasi_out.append( self._apply_correction( cnts, @@ -603,7 +600,6 @@ def _apply_correction( # type: ignore self._grab_additional_cals(missing_qubits, method=self.cal_method) # type: ignore if method == "M3_auto": - import psutil current_free_mem = psutil.virtual_memory().available / 1024**3 @@ -676,7 +672,6 @@ def callback(_): # type: ignore raise M3Error("Invalid method: {}".format(method)) def reduced_cal_matrix(self, counts, qubits, distance=None): # type: ignore - counts = dict(counts) # If distance is None, then assume max distance. num_bits = len(qubits) @@ -698,7 +693,6 @@ def reduced_cal_matrix(self, counts, qubits, distance=None): # type: ignore def _direct_solver( # type: ignore self, counts, qubits, distance=None, return_mitigation_overhead=False ): - cals = self._form_cals(qubits) num_bits = len(qubits) A, sorted_counts, col_norms = _reduced_cal_matrix( @@ -724,7 +718,6 @@ def _matvec_solver( # type: ignore callback=None, return_mitigation_overhead=False, ): - cals = self._form_cals(qubits) M = M3MatVec(dict(counts), cals, distance) L = spla.LinearOperator( diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index f6fcc5bf..c87549f1 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -348,7 +348,6 @@ def _translate_qiskit_params( ) -> List[float]: parameters = [] for p in gate_info[0].params: - if isinstance(p, ParameterVectorElement): parameters.append(binding_params[p.index]) elif isinstance(p, Parameter): diff --git a/tensorcircuit/vis.py b/tensorcircuit/vis.py index ab96540a..092216b8 100644 --- a/tensorcircuit/vis.py +++ b/tensorcircuit/vis.py @@ -95,7 +95,6 @@ def qir2tex( # apply gates in qir for x in qir: - idx = x["index"] gate_length = len(idx) if x["name"].startswith("invisible"): diff --git a/tests/test_calibrating.py b/tests/test_calibrating.py index 764cbb87..4bfd9314 100644 --- a/tests/test_calibrating.py +++ b/tests/test_calibrating.py @@ -19,12 +19,10 @@ def fit_function(x_values, y_values, function, init_params): def T1_cali(t1, t2, time, method, excitedstatepopulation): - # calibrating experiments nstep = int(4 * t1 / time) pex = [] for i in range(nstep): - dmc = tc.DMCircuit(1) dmc.x(0) for _ in range(i): @@ -49,12 +47,10 @@ def T1_cali(t1, t2, time, method, excitedstatepopulation): def T2_cali(t1, t2, time, method, excitedstatepopulation): - # calibrating experiments nstep = int(4 * t2 / time) pex = [] for i in range(nstep): - dmc = tc.DMCircuit(1) dmc.h(0) for _ in range(0, i): @@ -84,7 +80,6 @@ def dep_cali(dep, nqubit): pex = [] nstep = 40 for i in range(nstep): - dmc = tc.DMCircuit(1) dmc.x(0) for _ in range(i): diff --git a/tests/test_channels.py b/tests/test_channels.py index 89a582cf..18571740 100644 --- a/tests/test_channels.py +++ b/tests/test_channels.py @@ -33,7 +33,6 @@ def test_channel_identity(backend): @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_dep(backend): - cs = tc.channels.generaldepolarizingchannel(0.1, 1) tc.channels.kraus_identity_check(cs) @@ -46,7 +45,6 @@ def test_dep(backend): @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_rep_transformation(backend): - kraus_set = [] kraus_set.append(tc.channels.phasedampingchannel(0.2)) kraus_set.append(tc.channels.resetchannel()) @@ -107,10 +105,8 @@ def test_thermal(backend): @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_noisecircuit(backend): - # Monte carlo simulation def noisecircuit(X): - n = 1 c = tc.Circuit(n) c.x(0) @@ -155,7 +151,6 @@ def noisecircuitdm(): @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_readout(backend): - nqubit = 3 c = tc.Circuit(nqubit) c.X(0) @@ -299,7 +294,6 @@ def fun(x): def mitigate_readout(nqubit, circ, readout_error): - key = tc.backend.get_random_state(42) keys = [] for _ in range(2**nqubit): diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index 73ea6a05..73085620 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -14,7 +14,6 @@ @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_noisemodel(backend): - # test data structure # noise_conf = NoiseConf() # noise_conf.add_noise("h1", "t0") diff --git a/tests/test_quantum.py b/tests/test_quantum.py index 3fcf1de8..e7861c6a 100644 --- a/tests/test_quantum.py +++ b/tests/test_quantum.py @@ -189,7 +189,6 @@ def test_mul(backend): @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_expectations(backend): - psi_tensor = np.random.rand(2, 2, 2) + 1.0j * np.random.rand(2, 2, 2) op_tensor = np.random.rand(2, 2) + 1.0j * np.random.rand(2, 2) diff --git a/tests/test_results.py b/tests/test_results.py index 791c22b9..599fb9e1 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -85,7 +85,6 @@ def test_readout_masks(): def test_readout_expv(): - nqubit = 4 c = tc.Circuit(nqubit) c.H(0) @@ -145,7 +144,6 @@ def test_readout_expv(): def test_M3(): - try: import mthree # pylint: disable=unused-import except ImportError: diff --git a/tests/test_torchnn.py b/tests/test_torchnn.py index 6e85eedc..1d2807bb 100644 --- a/tests/test_torchnn.py +++ b/tests/test_torchnn.py @@ -19,7 +19,6 @@ @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("torchb")]) def test_quantumnet(backend): - n = 6 nlayers = 2 From 1c55a63fadcfc648cba2c83c1156b1b8d7a355d2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 13 Feb 2023 14:30:59 +0800 Subject: [PATCH 312/725] update gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 291c4f1c..c1649c55 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ dataset *.disable *.mo develop +examples-ng .coverage* tutorials.po whitepaper.po From d10af7efe1029555eceacec930e3efc2cd7a7803 Mon Sep 17 00:00:00 2001 From: weitang li Date: Sun, 12 Feb 2023 18:32:49 +0800 Subject: [PATCH 313/725] qiskit translation with circuit initialization --- tensorcircuit/abstractcircuit.py | 25 ++++++++++++++++++++----- tensorcircuit/translation.py | 14 +++++++++++++- tests/test_circuit.py | 28 ++++++++++++++++++++++++++++ 3 files changed, 61 insertions(+), 6 deletions(-) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 6c2f4349..d0abc052 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -638,20 +638,35 @@ def to_cirq(self, enable_instruction: bool = False) -> Any: return qir2cirq(qir, n=self._nqubits) return qir2cirq(qir, n=self._nqubits, extra_qir=self._extra_qir) - def to_qiskit(self, enable_instruction: bool = False) -> Any: + def to_qiskit( + self, enable_instruction: bool = False, enable_inputs: bool = False + ) -> Any: """ Translate ``tc.Circuit`` to a qiskit QuantumCircuit object. :param enable_instruction: whether also export measurement and reset instructions :type enable_instruction: bool, defaults to False + :param enable_inputs: whether also export the inputs + :type enable_inputs: bool, defaults to False :return: A qiskit object of this circuit. """ - from .translation import qir2qiskit + from .translation import qir2qiskit, perm_matrix qir = self.to_qir() - if enable_instruction is False: - return qir2qiskit(qir, n=self._nqubits) - return qir2qiskit(qir, n=self._nqubits, extra_qir=self._extra_qir) + if enable_instruction: + extra_qir = self._extra_qir + else: + extra_qir = None + if enable_inputs and self.circuit_param.get("inputs") is not None: + initialization = perm_matrix(self._nqubits).T @ self.circuit_param["inputs"] + else: + initialization = None + return qir2qiskit( + qir, + n=self._nqubits, + extra_qir=extra_qir, + initialization=initialization, + ) def to_openqasm(self, **kws: Any) -> str: """ diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index f6fcc5bf..e8b9960f 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -197,7 +197,10 @@ def _circuit_diagram_info_(self) -> List[str]: def qir2qiskit( - qir: List[Dict[str, Any]], n: int, extra_qir: Optional[List[Dict[str, Any]]] = None + qir: List[Dict[str, Any]], + n: int, + extra_qir: Optional[List[Dict[str, Any]]] = None, + initialization: Optional[Tensor] = None, ) -> Any: r""" Generate a qiskit quantum circuit using the quantum intermediate @@ -220,6 +223,8 @@ def qir2qiskit( :param extra_qir: The extra quantum IR of tc circuit including measure and reset on hardware, defaults to None :type extra_qir: Optional[List[Dict[str, Any]]] + :param initialization: Circuit initial state in qiskit format + :type initialization: Optional[Tensor] :return: qiskit QuantumCircuit object :rtype: Any """ @@ -228,6 +233,8 @@ def qir2qiskit( qiskit_circ = QuantumCircuit(n, n) else: qiskit_circ = QuantumCircuit(n) + if initialization is not None: + qiskit_circ.initialize(initialization) for gate_info in qir: index = gate_info["index"] gate_name = str(gate_info["gatef"]) @@ -440,6 +447,8 @@ def qiskit2tc( circuit_params = {} if "nqubits" not in circuit_params: circuit_params["nqubits"] = n + if qcdata[0][0].name == "initialize" and "inputs" not in circuit_params: + circuit_params["inputs"] = perm_matrix(n) @ np.array(qcdata[0][0].params) if inputs is not None: circuit_params["inputs"] = inputs @@ -532,6 +541,9 @@ def qiskit2tc( # ) elif gate_name == "barrier": tc_circuit.barrier_instruction(*idx) + elif gate_name == "initialize": + # already taken care of when initializing + continue elif not hasattr(gate_info[0], "__array__"): # an instruction containing a lot of gates. # the condition is based on diff --git a/tests/test_circuit.py b/tests/test_circuit.py index a8bf5cd1..e9e80f23 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1186,6 +1186,34 @@ def cost_fn(_params): assert not np.isnan(grad[ansatz3_param]) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_qiskit_vs_tc_intialization(backend): + try: + from qiskit import QuantumCircuit + import qiskit.quantum_info as qi + except ImportError: + pytest.skip("qiskit is not installed") + + n = 3 + + qis_c = QuantumCircuit(n) + qis_c.h(0) + qis_c.cnot(0, 1) + qis_c.y(2) + state = qi.Statevector(qis_c) + qis_c = QuantumCircuit(n) + qis_c.initialize(state) + c = tc.Circuit.from_qiskit(qis_c) + c2 = tc.Circuit(n) + c2.h(0) + c2.cnot(0, 1) + c2.y(2) + np.testing.assert_allclose(c.state(), c2.state(), atol=1e-8) + np.testing.assert_allclose( + qi.Statevector(c.to_qiskit(enable_inputs=True)), state, atol=1e-8 + ) + + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_batch_sample(backend): c = tc.Circuit(3) From dc3f6838c4f2af9992a8d572dd88f9de0a734c20 Mon Sep 17 00:00:00 2001 From: liwt31 Date: Tue, 14 Feb 2023 09:28:11 +0800 Subject: [PATCH 314/725] more test case --- tests/test_circuit.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index e9e80f23..7ec5e51d 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1203,14 +1203,18 @@ def test_qiskit_vs_tc_intialization(backend): state = qi.Statevector(qis_c) qis_c = QuantumCircuit(n) qis_c.initialize(state) + qis_c.cnot(1, 2) c = tc.Circuit.from_qiskit(qis_c) c2 = tc.Circuit(n) c2.h(0) c2.cnot(0, 1) c2.y(2) + c2.cnot(1, 2) np.testing.assert_allclose(c.state(), c2.state(), atol=1e-8) np.testing.assert_allclose( - qi.Statevector(c.to_qiskit(enable_inputs=True)), state, atol=1e-8 + qi.Statevector(c.to_qiskit(enable_inputs=True)), + qi.Statevector(qis_c), + atol=1e-8, ) From 0b984de11fa865af3a9540a71345141ac13d354d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 14 Feb 2023 10:49:35 +0800 Subject: [PATCH 315/725] add numerical simulation support for batch expectation ps wrapper --- tensorcircuit/cloud/wrapper.py | 25 +++++++++++++++++++------ tests/test_cloud.py | 19 ++++++++++++++++++- 2 files changed, 37 insertions(+), 7 deletions(-) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 4bbc246e..2c8140a8 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -11,6 +11,8 @@ from ..results import counts from ..results.readout_mitigation import ReadoutMit from ..utils import is_sequence +from ..cons import backend +from ..quantum import ps2xyz from ..compiler.qiskit_compiler import qiskit_compile from .apis import submit_task, get_device from .abstraction import Device @@ -73,14 +75,22 @@ def sample_expectation_ps( return counts.expectation(raw_counts, x + y + z) -def batch_sample_expectation_ps( +def batch_expectation_ps( c: Circuit, - device: Any, pss: List[List[int]], + device: Any = None, ws: Optional[List[float]] = None, shots: int = 8192, with_rem: bool = True, -) -> Union[float, List[float]]: +) -> Union[Any, List[Any]]: + if device is None: + results = [] + for ps in pss: + results.append(c.expectation_ps(**ps2xyz(ps))) # type: ignore + if ws is None: + return backend.stack(results) + else: + return backend.sum([w * r for w, r in zip(ws, results)]) cs = [] infos = [] exps = [] @@ -92,10 +102,10 @@ def batch_sample_expectation_ps( exp = [] for j, i in enumerate(ps): if i == 1: - c1.H(i) # type: ignore + c1.H(j) # type: ignore exp.append(j) elif i == 2: - c1.rx(i, theta=np.pi / 2) # type: ignore + c1.rx(j, theta=np.pi / 2) # type: ignore exp.append(j) elif i == 3: exp.append(j) @@ -153,7 +163,10 @@ def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: if getattr(device, "readout_mit", None) is None: mit = ReadoutMit(run) # TODO(@refraction-ray) only work for tencent provider - mit.cals_from_system(device.list_properties()["qubits"], shots=shots) + nq = device.list_properties().get("qubits", None) + if nq is None: + nq = c._nqubits + mit.cals_from_system(nq, shots=shots) device.readout_mit = mit else: mit = device.readout_mit diff --git a/tests/test_cloud.py b/tests/test_cloud.py index d99d4de5..f6f4bf75 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -2,13 +2,14 @@ import os import time import pytest +import numpy as np thisfile = os.path.abspath(__file__) modulepath = os.path.dirname(os.path.dirname(thisfile)) sys.path.insert(0, modulepath) import tensorcircuit as tc -from tensorcircuit.cloud import apis +from tensorcircuit.cloud import apis, wrapper from tensorcircuit.results import counts @@ -125,3 +126,19 @@ def test_local_batch_submit(): print(ts[1].results()) print(ts[1].details()) apis.set_provider() + + +def test_batch_exp_ps(): + pss = [[1, 0], [0, 3]] + c = tc.Circuit(2) + c.h(0) + c.x(1) + np.testing.assert_allclose(wrapper.batch_expectation_ps(c, pss), [1, -1], atol=1e-5) + np.testing.assert_allclose( + wrapper.batch_expectation_ps(c, pss, ws=[1, -0.5]), 1.5, atol=1e-5 + ) + np.testing.assert_allclose( + wrapper.batch_expectation_ps(c, pss, device="simulator:tcn1"), + [1, -1], + atol=1e-3, + ) From edf3ea2056158a55cb1fdc65bde807eb56c67cc5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 14 Feb 2023 10:50:39 +0800 Subject: [PATCH 316/725] add ps2xyz and xyz2ps --- CHANGELOG.md | 2 ++ tensorcircuit/quantum.py | 46 ++++++++++++++++++++++++++++++++++++++++ tests/test_quantum.py | 9 ++++++++ 3 files changed, 57 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4d991b11..46e91ded 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,8 @@ - Add regularizer support for KerasLayer +- Add methods in quantum module for translating ps list and xyz argument dict + ### Fixed - Circuit nosify in noise model now support all circuit attributs apart from qubit number diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index a2857f0a..e21d856d 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1021,6 +1021,52 @@ def show_attributes(op): return cls(set([n])) +def ps2xyz(ps: List[int]) -> Dict[str, List[int]]: + """ + pauli string list to xyz dict + + # ps2xyz([1, 2, 2, 0]) = {"x": [0], "y": [1, 2], "z": []} + + :param ps: _description_ + :type ps: List[int] + :return: _description_ + :rtype: Dict[str, List[int]] + """ + xyz: Dict[str, List[int]] = {"x": [], "y": [], "z": []} + for i, j in enumerate(ps): + if j == 1: + xyz["x"].append(i) + if j == 2: + xyz["y"].append(i) + if j == 3: + xyz["z"].append(i) + return xyz + + +def xyz2ps(xyz: Dict[str, List[int]], n: Optional[int] = None) -> List[int]: + """ + xyz dict to pauli string list + + :param xyz: _description_ + :type xyz: Dict[str, List[int]] + :param n: _description_, defaults to None + :type n: Optional[int], optional + :return: _description_ + :rtype: List[int] + """ + if n is None: + n = max(xyz.get("x", []) + xyz.get("y", []) + xyz.get("z", [])) + 1 + ps = [0 for _ in range(n)] + for i in range(n): + if i in xyz.get("x", []): + ps[i] = 1 + elif i in xyz.get("y", []): + ps[i] = 2 + elif i in xyz.get("z", []): + ps[i] = 3 + return ps + + def generate_local_hamiltonian( *hlist: Sequence[Tensor], matrix_form: bool = True ) -> Union[QuOperator, Tensor]: diff --git a/tests/test_quantum.py b/tests/test_quantum.py index e7861c6a..609111ad 100644 --- a/tests/test_quantum.py +++ b/tests/test_quantum.py @@ -457,3 +457,12 @@ def test_measurement_results(backend): w, counts=c, format="count_dict_int", jittable=True ) print(r) + + +def test_ps2xyz(): + xyz = {"x": [1], "z": [2]} + assert tc.quantum.xyz2ps(xyz) == [0, 1, 3] + assert tc.quantum.xyz2ps(xyz, 6) == [0, 1, 3, 0, 0, 0] + xyz.update({"y": []}) + assert tc.quantum.ps2xyz([0, 1, 3]) == xyz + assert tc.quantum.ps2xyz([0, 1, 3, 0]) == xyz From 83476800bf92531d1878395e9fb1ca2ccde4f48a Mon Sep 17 00:00:00 2001 From: liwt31 Date: Wed, 15 Feb 2023 11:27:57 +0800 Subject: [PATCH 317/725] refactor depolarizing channel --- tensorcircuit/channels.py | 59 +++++++++++++++++++-------------------- 1 file changed, 28 insertions(+), 31 deletions(-) diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index 6d085b10..9e7ed9f0 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -4,8 +4,6 @@ import sys from typing import Any, Sequence, Union, Optional, Dict -from operator import and_ -from functools import reduce from functools import partial import numpy as np @@ -107,7 +105,27 @@ def generaldepolarizingchannel( p: Union[float, Sequence[Any]], num_qubits: int = 1 ) -> Sequence[Gate]: r""" - Return a Depolarizing Channel for 1 qubit or 2 qubits + Return a Depolarizing Channel for 1 qubit or 2 qubits. + If :math:`p` is a float number, the one qubit channel is + + .. math:: + + \mathcal{E}(\rho) = (1 - 3p)\rho + p(X\rho X + Y\rho Y + Z\rho Z) + + Or alternatively + + .. math:: + + \mathcal{E}(\rho) = \frac{4p}{3} \frac{I}{2} \rho + (1 - \frac{4p}{3}) \rho + + And if :math:`p` is a list, the one qubit channel is + + .. math:: + + \mathcal{E}(\rho) = (1 - \sum_i p_i) \rho + p_1 X\rho X + p_2 Y\rho Y + p_3 \rho Z + + The logic for two-qubit channel follows similarly. + Higher qubit channels are not implemented. :Example: @@ -127,49 +145,28 @@ def generaldepolarizingchannel( if num_qubits == 1: if isinstance(p, float): - assert p > 0 and p < 1 / 3, "p should be >0 and <1/3" probs = [1 - 3 * p] + 3 * [p] - elif isinstance(p, list): - assert reduce( - and_, [pi > 0 and pi < 1 for pi in p] - ), "p should be >0 and <1" - probs = [1 - sum(p)] + p # type: ignore - - elif isinstance(p, tuple): - p = list[p] # type: ignore - assert reduce( - and_, [pi > 0 and pi < 1 for pi in p] - ), "p should be >0 and <1" probs = [1 - sum(p)] + p # type: ignore - else: raise ValueError("p should be float or list") - elif num_qubits == 2: if isinstance(p, float): - assert p > 0 and p < 1, "p should be >0 and <1/15" probs = [1 - 15 * p] + 15 * [p] - elif isinstance(p, list): - assert reduce( - and_, [pi > 0 and pi < 1 for pi in p] - ), "p should be >0 and <1" probs = [1 - sum(p)] + p # type: ignore - - elif isinstance(p, tuple): - p = list[p] # type: ignore - assert reduce( - and_, [pi > 0 and pi < 1 for pi in p] - ), "p should be >0 and <1" - probs = [1 - sum(p)] + p # type: ignore - else: raise ValueError("p should be float or list") + else: + raise ValueError(f"num_qubits should be 1 or 2. Got {num_qubits}") + + if not np.all(np.array(probs) >= 0): + raise ValueError(f"Invalid probability input {p}") if num_qubits == 1: tup = [gates.i().tensor, gates.x().tensor, gates.y().tensor, gates.z().tensor] # type: ignore - if num_qubits == 2: + else: + assert num_qubits == 2 tup = [ gates.ii().tensor, # type: ignore gates.ix().tensor, # type: ignore From 838e1955b019c00eb33c46da782fff422852c5d5 Mon Sep 17 00:00:00 2001 From: liwt31 Date: Wed, 15 Feb 2023 12:58:32 +0800 Subject: [PATCH 318/725] change list to sequence and fix document --- tensorcircuit/channels.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index 9e7ed9f0..3526dcac 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -102,7 +102,7 @@ def depolarizingchannel(px: float, py: float, pz: float) -> Sequence[Gate]: def generaldepolarizingchannel( - p: Union[float, Sequence[Any]], num_qubits: int = 1 + p: Union[float, Sequence[float]], num_qubits: int = 1 ) -> Sequence[Gate]: r""" Return a Depolarizing Channel for 1 qubit or 2 qubits. @@ -116,9 +116,9 @@ def generaldepolarizingchannel( .. math:: - \mathcal{E}(\rho) = \frac{4p}{3} \frac{I}{2} \rho + (1 - \frac{4p}{3}) \rho + \mathcal{E}(\rho) = 4p \frac{I}{2} + (1 - 4p) \rho - And if :math:`p` is a list, the one qubit channel is + And if :math:`p` is a sequence, the one qubit channel is .. math:: @@ -146,14 +146,14 @@ def generaldepolarizingchannel( if num_qubits == 1: if isinstance(p, float): probs = [1 - 3 * p] + 3 * [p] - elif isinstance(p, list): + elif isinstance(p, Sequence): probs = [1 - sum(p)] + p # type: ignore else: raise ValueError("p should be float or list") elif num_qubits == 2: if isinstance(p, float): probs = [1 - 15 * p] + 15 * [p] - elif isinstance(p, list): + elif isinstance(p, Sequence): probs = [1 - sum(p)] + p # type: ignore else: raise ValueError("p should be float or list") From 5e3fbc820577e516e0f33695bfb910ef1c3861dc Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 15 Feb 2023 15:21:21 +0800 Subject: [PATCH 319/725] further sort apply correction --- tensorcircuit/results/readout_mitigation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 1065e396..5a17062b 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -500,10 +500,10 @@ def apply_correction( # methods for small system, "global" calibration only fit for those methods. if method in ["inverse", "pseudo_inverse"]: mitcounts = self.apply_readout_mitigation(counts, method="inverse") - return mitcounts + return sort_count(mitcounts) elif method in ["square", "constrained_least_square"]: mitcounts = self.apply_readout_mitigation(counts, method="square") - return mitcounts + return sort_count(mitcounts) if mthree_installed is False: warnings.warn( " To use [scalable-] related methods, please pip install mthree !" From f1345549bd4cfb96a445317c1d52350dc63233aa Mon Sep 17 00:00:00 2001 From: liwt31 Date: Wed, 15 Feb 2023 17:35:26 +0800 Subject: [PATCH 320/725] add gate count by condition --- tensorcircuit/abstractcircuit.py | 30 +++++++++++++++++++++++++++++- tests/test_circuit.py | 7 +++++-- 2 files changed, 34 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index d0abc052..ca87f0fe 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -556,10 +556,38 @@ def gate_count(self, gate_list: Optional[Sequence[str]] = None) -> int: gate_list = [self.standardize_gate(g) for g in gate_list] c = 0 for d in self._qir: - if d["name"] in gate_list: + if d["gatef"].n in gate_list: c += 1 return c + def gate_count_by_condition( + self, cond_func: Callable[[Dict[str, Any]], bool] + ) -> int: + """ + count the number of gates that satisfy certain condition + + :Example: + + >>> c = tc.Circuit(3) + >>> c.x(0) + >>> c.h(0) + >>> c.multicontrol(0, 1, 2, ctrl=[0, 1], unitary=tc.gates._x_matrix) + >>> c.gate_count_by_condition(lambda qir: qir["index"] == (0, )) + 2 + >>> c.gate_count_by_condition(lambda qir: qir["mpo"]) + 1 + + :param cond_func: the condition for counting the gate + :type cond_func: Callable[[Dict[str, Any]], bool] + :return: the total number of all gates which satisfy the ``condition`` + :rtype: int + """ + count = 0 + for d in self._qir: + if cond_func(d): + count += 1 + return count + def gate_summary(self) -> Dict[str, int]: """ return the summary dictionary on gate type - gate count pair diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 7ec5e51d..4e373d81 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1413,6 +1413,7 @@ def test_circuit_to_json(backend): def test_gate_count(): c = tc.Circuit(3) + c.x(0) c.h(0) c.rx(1, theta=-0.2) c.h(2) @@ -1420,12 +1421,14 @@ def test_gate_count(): c.toffoli(0, 2, 1) c.ccnot(1, 2, 0) c.ccx(1, 2, 0) - assert c.gate_count() == 7 + assert c.gate_count() == 8 assert c.gate_count(["h"]) == 2 assert c.gate_count(["ccnot"]) == 3 assert c.gate_count(["rx", "multicontrol"]) == 2 + assert c.gate_count_by_condition(lambda qir: qir["index"] == (0,)) == 2 + assert c.gate_count_by_condition(lambda qir: qir["mpo"]) == 1 print(c.gate_summary()) - # {'h': 2, 'rx': 1, 'multicontrol': 1, 'toffoli': 3} + # {'x': 1, 'h': 2, 'rx': 1, 'multicontrol': 1, 'toffoli': 3} def test_to_openqasm(): From e87dfbb4f0ddf5be04327e3d6c8323fae98e9511 Mon Sep 17 00:00:00 2001 From: liwt31 Date: Thu, 16 Feb 2023 15:00:30 +0800 Subject: [PATCH 321/725] enhance depolarizing channel --- tensorcircuit/channels.py | 103 ++++++++++++++++++++++-------------- tensorcircuit/noisemodel.py | 6 ++- tests/test_channels.py | 4 ++ 3 files changed, 70 insertions(+), 43 deletions(-) diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index 3526dcac..ac523038 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -101,11 +101,47 @@ def depolarizingchannel(px: float, py: float, pz: float) -> Sequence[Gate]: return KrausList([i, x, y, z], name="depolarizing", is_unitary=True) +def isotropicdepolarizingchannel(p: float, num_qubits: int = 1) -> Sequence[Gate]: + r""" + Return an isotropic depolarizing channel. + + .. math:: + + \mathcal{E}(\rho) = (1 - p)\rho + p/(4^n-1)\sum_j P_j \rho P_j + + where $n$ is the number of qubits and $P_j$ are $n$-qubit Pauli strings except $I$. + Or alternatively + + .. math:: + + \mathcal{E}(\rho) = \frac{4^n}{4^n-1}p \frac{I}{2} + (1 - \frac{4^n}{4^n-1}p) \rho + + .. note:: + + The definition of ``p`` in this method is different from :func:`generaldepolarizingchannel`. + + :Example: + + >>> cs = tc.channels.isotropicdepolarizingchannel(0.30,2) + >>> tc.channels.kraus_identity_check(cs) + + + :param p: error probability + :type p: float + :param num_qubits: number of qubits, 1 and 2 are avaliable, defaults 1 + :type num_qubits: int, optional + :return: Sequences of Gates + :rtype: Sequence[Gate] + """ + real_p = p / (4**num_qubits - 1) + return generaldepolarizingchannel(real_p, num_qubits) + + def generaldepolarizingchannel( p: Union[float, Sequence[float]], num_qubits: int = 1 ) -> Sequence[Gate]: r""" - Return a Depolarizing Channel for 1 qubit or 2 qubits. + Return a depolarizing channel. If :math:`p` is a float number, the one qubit channel is .. math:: @@ -118,14 +154,18 @@ def generaldepolarizingchannel( \mathcal{E}(\rho) = 4p \frac{I}{2} + (1 - 4p) \rho + .. note:: + + The definition of ``p`` in this method is different from :func:`isotropicdepolarizingchannel`. + + And if :math:`p` is a sequence, the one qubit channel is .. math:: \mathcal{E}(\rho) = (1 - \sum_i p_i) \rho + p_1 X\rho X + p_2 Y\rho Y + p_3 \rho Z - The logic for two-qubit channel follows similarly. - Higher qubit channels are not implemented. + The logic for two-qubit or more-qubit channel follows similarly. :Example: @@ -142,49 +182,30 @@ def generaldepolarizingchannel( :return: Sequences of Gates :rtype: Sequence[Gate] """ - - if num_qubits == 1: - if isinstance(p, float): - probs = [1 - 3 * p] + 3 * [p] - elif isinstance(p, Sequence): - probs = [1 - sum(p)] + p # type: ignore - else: - raise ValueError("p should be float or list") - elif num_qubits == 2: - if isinstance(p, float): - probs = [1 - 15 * p] + 15 * [p] - elif isinstance(p, Sequence): - probs = [1 - sum(p)] + p # type: ignore - else: - raise ValueError("p should be float or list") + m = 4**num_qubits - 1 + if isinstance(p, float): + probs = [1 - m * p] + m * [p] + elif isinstance(p, Sequence): + if not len(p) == m: + raise ValueError(f"Invalid probability input {p}") + probs = [1 - sum(p)] + list(p) else: - raise ValueError(f"num_qubits should be 1 or 2. Got {num_qubits}") + raise ValueError("p should be float or list") if not np.all(np.array(probs) >= 0): raise ValueError(f"Invalid probability input {p}") - if num_qubits == 1: - tup = [gates.i().tensor, gates.x().tensor, gates.y().tensor, gates.z().tensor] # type: ignore - else: - assert num_qubits == 2 - tup = [ - gates.ii().tensor, # type: ignore - gates.ix().tensor, # type: ignore - gates.iy().tensor, # type: ignore - gates.iz().tensor, # type: ignore - gates.xi().tensor, # type: ignore - gates.xx().tensor, # type: ignore - gates.xy().tensor, # type: ignore - gates.xz().tensor, # type: ignore - gates.yi().tensor, # type: ignore - gates.yx().tensor, # type: ignore - gates.yy().tensor, # type: ignore - gates.yz().tensor, # type: ignore - gates.zi().tensor, # type: ignore - gates.zx().tensor, # type: ignore - gates.zy().tensor, # type: ignore - gates.zz().tensor, # type: ignore - ] + paulis = [gates.i().tensor, gates.x().tensor, gates.y().tensor, gates.z().tensor] # type: ignore + tup = paulis + for _ in range(num_qubits - 1): + old_tup = tup + tup = [] + for pauli in paulis: + for term in old_tup: + mat = np.kron(pauli, term).reshape([2, 2] * num_qubits) + tup.append(mat) + + assert len(tup) == len(probs) Gkarus = [] for pro, paugate in zip(probs, tup): diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 9ce7f87d..6613fa82 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -117,9 +117,11 @@ def apply_qir_with_noise( d["name"] = AbstractCircuit.standardize_gate(d["name"]) if "parameters" not in d: # paramized gate - c.apply_general_gate_delayed(d["gatef"], d["name"])(c, *d["index"]) + c.apply_general_gate_delayed(d["gatef"], d["name"], d["mpo"])( + c, *d["index"] + ) else: - c.apply_general_variable_gate_delayed(d["gatef"], d["name"])( + c.apply_general_variable_gate_delayed(d["gatef"], d["name"], d["mpo"])( c, *d["index"], **d["parameters"] ) diff --git a/tests/test_channels.py b/tests/test_channels.py index 18571740..67478473 100644 --- a/tests/test_channels.py +++ b/tests/test_channels.py @@ -42,6 +42,10 @@ def test_dep(backend): cs = tc.channels.generaldepolarizingchannel(0.02, 2) tc.channels.kraus_identity_check(cs) + cs2 = tc.channels.isotropicdepolarizingchannel(0.02 * 15, 2) + for c1, c2 in zip(cs, cs2): + np.testing.assert_allclose(c1.tensor, c2.tensor) + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_rep_transformation(backend): From b09bad2c447ca437706b0cc9bbeea27535a2cf34 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 16 Feb 2023 16:19:19 +0800 Subject: [PATCH 322/725] reduced native gate set --- tensorcircuit/cloud/tencent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 282a7551..8217de3c 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -65,7 +65,7 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An for bit in r["bits"]: bits_dict[bit["Qubit"]] = bit r["bits"] = bits_dict - r["native_gates"] = ["h", "rz", "x", "y", "z", "cx", "cz"] # handcoded + r["native_gates"] = ["h", "rz", "x", "y", "z", "cz"] # handcoded return r # type: ignore else: raise ValueError("No device with the name: %s" % device) From 072bca0d0a3f3c45d937ad51ca64dc5df5fb55f6 Mon Sep 17 00:00:00 2001 From: liwt31 Date: Thu, 16 Feb 2023 16:28:37 +0800 Subject: [PATCH 323/725] fix depolarizing doc --- tensorcircuit/channels.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/channels.py b/tensorcircuit/channels.py index ac523038..6b2fd959 100644 --- a/tensorcircuit/channels.py +++ b/tensorcircuit/channels.py @@ -128,7 +128,7 @@ def isotropicdepolarizingchannel(p: float, num_qubits: int = 1) -> Sequence[Gate :param p: error probability :type p: float - :param num_qubits: number of qubits, 1 and 2 are avaliable, defaults 1 + :param num_qubits: number of qubits, defaults 1 :type num_qubits: int, optional :return: Sequences of Gates :rtype: Sequence[Gate] @@ -177,7 +177,7 @@ def generaldepolarizingchannel( :param p: parameter for each Pauli channel :type p: Union[float, Sequence] - :param num_qubits: number of qubits, 1 and 2 are avaliable, defaults 1 + :param num_qubits: number of qubits, defaults 1 :type num_qubits: int, optional :return: Sequences of Gates :rtype: Sequence[Gate] From a0f1a091eed72a6a0a9d42ee7459a271142c4d5e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 16 Feb 2023 20:22:01 +0800 Subject: [PATCH 324/725] add explicit compiler pipeline abstraction --- tensorcircuit/compiler/__init__.py | 1 + tensorcircuit/compiler/composed_compiler.py | 43 +++++++++++++++++++++ tensorcircuit/results/counts.py | 26 ++++++------- tests/test_compiler.py | 27 +++++++++++++ tests/test_results.py | 6 +++ 5 files changed, 90 insertions(+), 13 deletions(-) create mode 100644 tensorcircuit/compiler/composed_compiler.py diff --git a/tensorcircuit/compiler/__init__.py b/tensorcircuit/compiler/__init__.py index 4dbf1ada..9d8f25a0 100644 --- a/tensorcircuit/compiler/__init__.py +++ b/tensorcircuit/compiler/__init__.py @@ -2,3 +2,4 @@ Experimental module, no software agnostic unified interface for now, only reserve for internal use """ +from .composed_compiler import Compiler, default_compiler diff --git a/tensorcircuit/compiler/composed_compiler.py b/tensorcircuit/compiler/composed_compiler.py new file mode 100644 index 00000000..30c30057 --- /dev/null +++ b/tensorcircuit/compiler/composed_compiler.py @@ -0,0 +1,43 @@ +""" +object oriented compiler pipeline +""" + +from typing import Any, Callable, Dict, List, Optional, Union + +from ..utils import is_sequence +from ..abstractcircuit import AbstractCircuit +from .qiskit_compiler import qiskit_compile + + +class Compiler: + def __init__( + self, + compile_funcs: Union[Callable[..., Any], List[Callable[..., Any]]], + compiled_options: Optional[List[Dict[str, Any]]] = None, + ): + if not is_sequence(compile_funcs): + self.compile_funcs = [compile_funcs] + else: + self.compile_funcs = list(compile_funcs) # type: ignore + self.add_options(compiled_options) + + def add_options( + self, compiled_options: Optional[List[Dict[str, Any]]] = None + ) -> None: + if not is_sequence(compiled_options): + self.compiled_options = [compiled_options for _ in self.compile_funcs] + else: + assert len(compiled_options) == len( # type: ignore + self.compile_funcs + ), "`compiled_options` must have the same list length as `compile_funcs`" + self.compiled_options = list(compiled_options) # type: ignore + + def __call__( + self, circuit: AbstractCircuit, info: Optional[Dict[str, Any]] = None + ) -> Any: + for f, d in zip(self.compile_funcs, self.compiled_options): + circuit, info = f(circuit, info, compiled_options=d) # type: ignore + return circuit, info + + +default_compiler = Compiler(qiskit_compile) diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index 2a7cbec0..78695734 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -104,16 +104,16 @@ def expectation( return r / shots -# def correlation( -# count: ct, zlist: Sequence[int], values: Tuple[int, int] = (1, -1) -# ) -> float: -# map_dict = {"0": values[0], "1": values[1]} -# r = 0 -# shots = 0 -# for k, v in count.items(): -# ct = 1.0 -# for i in zlist: -# ct *= map_dict[k[i]] -# r += ct * v # type: ignore -# shots += v -# return r / shots +def plot_histogram(data: Any, **kws: Any) -> Any: + """ + See ``qiskit.visualization.plot_histogram``: + https://qiskit.org/documentation/stubs/qiskit.visualization.plot_histogram.html + + :param data: _description_ + :type data: Any + :return: _description_ + :rtype: Any + """ + from qiskit.visualization import plot_histogram + + return plot_histogram(data) diff --git a/tests/test_compiler.py b/tests/test_compiler.py index 17f59112..6559b476 100644 --- a/tests/test_compiler.py +++ b/tests/test_compiler.py @@ -70,3 +70,30 @@ def test_qsikit_compiler(): ) assert info2["positional_logical_mapping"] == {0: 1} print(c2.draw()) + + +def test_composed_compiler(): + from tensorcircuit.compiler import default_compiler + + c = tc.Circuit(3) + c.rx(0) + c.cx(0, 1) + c.cz(1, 0) + c.rxx(0, 2, theta=0.2) + c.measure_instruction(2) + c.measure_instruction(0) + c1, info = default_compiler(c) + print(c1.draw()) + assert c1.gate_count_by_condition(lambda qir: qir["name"] == "cnot") == 4 + assert info["positional_logical_mapping"][0] == 2 + + default_compiler.add_options( + { + "basis_gates": ["h", "rz", "cz"], + "optimization_level": 2, + "coupling_map": [[0, 1], [1, 2]], + } + ) + c1, info = default_compiler(c) + assert c1.gate_count_by_condition(lambda qir: qir["name"] == "cnot") == 0 + print(info) diff --git a/tests/test_results.py b/tests/test_results.py index 599fb9e1..8c11eddd 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -29,6 +29,12 @@ def test_expectation(): assert counts.expectation(d, None, [[1, -1], [1, 0], [1, 1]]) == -5 / 9 +def test_plot_histogram(): + d = {"00": 10, "01": 2, "11": 8} + d1 = {"00": 11, "11": 9} + print(counts.plot_histogram([d, d1])) + + def test_readout(): nqubit = 4 shots = 4096 From 36edfad546144336a9b8959b506de4ebda8c105d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 17 Feb 2023 10:42:28 +0800 Subject: [PATCH 325/725] finer catch on unsupported method --- tensorcircuit/cloud/apis.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 9c462252..3762aed1 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -301,6 +301,8 @@ def list_properties( token = device.get_token() # type: ignore if provider.name == "tencent": # type: ignore return tencent.list_properties(device, token) + elif provider.name == "local": + raise ValueError("Unsupported method for local backend") else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore @@ -437,6 +439,8 @@ def resubmit_task( if provider.name == "tencent": # type: ignore return tencent.resubmit_task(task, token) # type: ignore + elif provider.name == "local": + raise ValueError("Unsupported method for local backend") else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore @@ -454,6 +458,8 @@ def remove_task( if provider.name == "tencent": # type: ignore return tencent.remove_task(task, token) # type: ignore + elif provider.name == "local": + raise ValueError("Unsupported method for local backend") else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore From 0d84ddded6ffa94cc24889e13c1724dac01430cd Mon Sep 17 00:00:00 2001 From: Shuo Liu Date: Sat, 18 Feb 2023 16:41:39 +0800 Subject: [PATCH 326/725] Time evolution realized by Trotter decomposition --- examples/timeevolution_trotter.py | 47 +++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 examples/timeevolution_trotter.py diff --git a/examples/timeevolution_trotter.py b/examples/timeevolution_trotter.py new file mode 100644 index 00000000..210820ae --- /dev/null +++ b/examples/timeevolution_trotter.py @@ -0,0 +1,47 @@ +""" +Time evolution of Heisenberg model realized by Trotter decomposition +""" + +import numpy as np +import tensorcircuit as tc + +K = tc.set_backend("tensorflow") +tc.set_dtype("complex128") + +xx = tc.gates._xx_matrix +yy = tc.gates._yy_matrix +zz = tc.gates._zz_matrix + +nqubit = 4 +t = 1.0 +tau = 0.1 + + +def Trotter_step_unitary(input_state, tau, nqubit): + c = tc.Circuit(nqubit, inputs=input_state) + for i in range(nqubit - 1): ### U_zz + c.exp1(i, i + 1, theta=tau, unitary=zz) + for i in range(nqubit - 1): ### U_yy + c.exp1(i, i + 1, theta=tau, unitary=yy) + for i in range(nqubit - 1): ### U_xx + c.exp1(i, i + 1, theta=tau, unitary=xx) + TSUstate = c.state() ### return state U(τ)|ψ_i> + z0 = c.expectation_ps(z=[0]) + return TSUstate, z0 + + +TSU_vmap = tc.backend.jit( + tc.backend.vmap( + Trotter_step_unitary, + vectorized_argnums=0, + ) +) + +ninput = 2 +input_state = np.zeros((ninput, 2 ** nqubit)) +input_state[0, 0] = 1.0 +input_state[1, -1] = 1.0 + +for _ in range(int(t / tau)): + input_state, z0 = TSU_vmap(input_state, tau, nqubit) + print("z: ", z0) From 8c93a944fd2ece4137ffd1b61d874fde58d2780e Mon Sep 17 00:00:00 2001 From: Shuo Liu Date: Sat, 18 Feb 2023 19:41:47 +0800 Subject: [PATCH 327/725] Time evolution realized by Trotter decomposition --- examples/timeevolution_trotter.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/timeevolution_trotter.py b/examples/timeevolution_trotter.py index 210820ae..91ea7f0f 100644 --- a/examples/timeevolution_trotter.py +++ b/examples/timeevolution_trotter.py @@ -38,7 +38,7 @@ def Trotter_step_unitary(input_state, tau, nqubit): ) ninput = 2 -input_state = np.zeros((ninput, 2 ** nqubit)) +input_state = np.zeros((ninput, 2**nqubit)) input_state[0, 0] = 1.0 input_state[1, -1] = 1.0 From dd37b5eed8e7002f44d4db71e16ab23d5eb39327 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 20 Feb 2023 10:48:38 +0800 Subject: [PATCH 328/725] update qcloud doc --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 59 ++++++++++++++++++++--- 1 file changed, 52 insertions(+), 7 deletions(-) diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb index 5b1c0467..4994620f 100644 --- a/docs/source/tutorials/tc_qcloud_sdk.ipynb +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -27,6 +27,7 @@ "source": [ "import tensorcircuit as tc\n", "from tensorcircuit.cloud import apis\n", + "from tensorcircuit.cloud.wrapper import batch_expectation_ps\n", "from tensorcircuit.compiler.qiskit_compiler import qiskit_compile\n", "import numpy as np" ] @@ -434,9 +435,7 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit.visualization import plot_histogram\n", - "\n", - "plot_histogram([raw_count, miti_count])" + "tc.results.counts.plot_histogram([raw_count, miti_count])" ] }, { @@ -646,8 +645,8 @@ "source": [ "# 0. acquire readout mitigation class\n", "\n", - "mit = tc.results.rem.ReadoutMit(\"9gmon?o=0\")\n", - "mit.cals_from_system(9)\n", + "mit = tc.results.rem.ReadoutMit(\"20xmon?o=0\")\n", + "mit.cals_from_system(20)\n", "\n", "# 1. define the logical circuit\n", "\n", @@ -661,7 +660,7 @@ "\n", "# 2. compile the circuit\n", "\n", - "d = apis.get_device(\"9gmon\")\n", + "d = apis.get_device(\"20xmon\")\n", "\n", "c1, info = qiskit_compile(\n", " c,\n", @@ -693,13 +692,59 @@ { "cell_type": "code", "execution_count": null, - "id": "fa854a6e", + "id": "84b26c27", "metadata": {}, "outputs": [], "source": [ "info # compiling info and the qubit mapping are recorded automatically" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5b63e46", + "metadata": {}, + "outputs": [], + "source": [ + "tc.results.counts.plot_histogram(\n", + " [raw_count, mit.apply_correction(raw_count, n, method=\"square\", **info)]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e2b28dbe", + "metadata": {}, + "source": [ + "And the **all-in-one API**: ``batch_expectation_ps`` with circuit generating, grouping, compiling, optimization and error mitigation support is as shown below, the API is also consistent with numerical simulations, basically the API capture all the workflow shown in above cell with extra enhancement" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35ba52b4", + "metadata": {}, + "outputs": [], + "source": [ + "c = tc.Circuit(2)\n", + "c.h(0)\n", + "c.cz(0, 1)\n", + "c.x(1)\n", + "print(\"numerical results: [, ]\", batch_expectation_ps(c, [[1, 0], [1, 3]]))\n", + "print(\n", + " \"hardware results: [, ]\",\n", + " batch_expectation_ps(c, [[1, 0], [1, 3]], \"20xmon\"),\n", + ")\n", + "print(\n", + " \"numerical results: + 0.5* \",\n", + " batch_expectation_ps(c, [[1, 0], [1, 3]], ws=[1, 0.5]),\n", + ")\n", + "print(\n", + " \"hardware results: + 0.5* \",\n", + " batch_expectation_ps(c, [[1, 0], [1, 3]], \"20xmon\", ws=[1, 0.5]),\n", + ")" + ] + }, { "cell_type": "markdown", "id": "f13baa43", From 48d55c83e243db4a4c3413e045da1be2ffe3f021 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 20 Feb 2023 10:50:51 +0800 Subject: [PATCH 329/725] fix sdk version no. --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb index 4994620f..9f8ccab4 100644 --- a/docs/source/tutorials/tc_qcloud_sdk.ipynb +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -5,7 +5,7 @@ "id": "38c73e8c", "metadata": {}, "source": [ - "# tensorcircuit SDK for QCloud（230203 ver）" + "# tensorcircuit SDK for QCloud（230220 ver）" ] }, { From 4add4b3948fb0c51883d9c211c2fe64ca4d3a816 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 21 Feb 2023 19:32:49 +0800 Subject: [PATCH 330/725] update keraslayer to support lambda layer --- CHANGELOG.md | 2 ++ tensorcircuit/keras.py | 41 +++++++++++++++++++++++++---------------- 2 files changed, 27 insertions(+), 16 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 46e91ded..ef2d4cdf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -42,6 +42,8 @@ - Rem results after `apply_correction` is now sorted +- Fix `KerasLayer` so that it supports null weights + ## 0.7.0 ### Added diff --git a/tensorcircuit/keras.py b/tensorcircuit/keras.py index 82096481..2f51d980 100644 --- a/tensorcircuit/keras.py +++ b/tensorcircuit/keras.py @@ -20,7 +20,7 @@ class QuantumLayer(Layer): # type: ignore def __init__( self, f: Callable[..., Any], - weights_shape: Sequence[Tuple[int, ...]], + weights_shape: Optional[Sequence[Tuple[int, ...]]] = None, initializer: Union[Text, Sequence[Text]] = "glorot_uniform", constraint: Optional[Union[Text, Sequence[Text]]] = None, regularizer: Optional[Union[Text, Sequence[Text]]] = None, @@ -44,9 +44,12 @@ def __init__( """ super().__init__(**kwargs) - if isinstance(weights_shape[0], int): + if weights_shape is not None and isinstance(weights_shape[0], int): weights_shape = [weights_shape] - self.number_weights = len(weights_shape) + if weights_shape is not None: + self.number_weights = len(weights_shape) + else: + self.number_weights = 0 self.f = f self.weights_shape = weights_shape if not (isinstance(initializer, list) or isinstance(initializer, tuple)): @@ -73,20 +76,26 @@ def build(self, input_shape: Optional[List[int]] = None) -> None: input_shape = [1, 1] super().build(input_shape) self.pqc_weights = [] - for i, (shape, init, cst, reg) in enumerate( - zip(self.weights_shape, self.initializer, self.constraint, self.regularizer) - ): - self.pqc_weights.append( - self.add_weight( - name="PQCweights%s" % i, - shape=shape, - dtype=getattr(np, rdtypestr), - trainable=True, - initializer=init, - constraint=cst, - regularizer=reg, + if self.weights_shape is not None: + for i, (shape, init, cst, reg) in enumerate( + zip( + self.weights_shape, + self.initializer, + self.constraint, + self.regularizer, + ) + ): + self.pqc_weights.append( + self.add_weight( + name="PQCweights%s" % i, + shape=shape, + dtype=getattr(np, rdtypestr), + trainable=True, + initializer=init, + constraint=cst, + regularizer=reg, + ) ) - ) @tf.function # type: ignore def call( From 6503d32207443bb356a84debb6c70e1c5cd5a8d1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 23 Feb 2023 20:19:34 +0800 Subject: [PATCH 331/725] update tf opt --- tensorcircuit/backends/tensorflow_backend.py | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 59fc1a02..032e7456 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -5,6 +5,7 @@ from functools import reduce, partial from operator import mul +from copy import deepcopy from typing import Any, Callable, Optional, Sequence, Tuple, Union from scipy.sparse import coo_matrix @@ -24,6 +25,7 @@ class keras_optimizer: def __init__(self, optimizer: Any) -> None: self.optimizer = optimizer self.is_variable = True + self.is_initialized = False def _c2v(self, v: Tensor) -> Tensor: if not isinstance(v, tf.Variable): @@ -31,13 +33,22 @@ def _c2v(self, v: Tensor) -> Tensor: self.is_variable = False return v - def _apply_gradients(self, grads: Tensor, params: Tensor) -> None: - self.optimizer.apply_gradients([(grads, params)]) + def _apply_gradients(self, opt: Any, grads: Tensor, params: Tensor) -> None: + opt.apply_gradients([(grads, params)]) def update(self, grads: pytree, params: pytree) -> pytree: + if not self.is_initialized: + l, treedef = TensorFlowBackend.tree_flatten(None, params) + # https://github.com/tensorflow/tensorflow/issues/58973 + # still breaks tf2.11 + ol = [deepcopy(self.optimizer) for _ in l] + self.optimizer = TensorFlowBackend.tree_unflatten(None, treedef, ol) + self.is_initialized = True params = TensorFlowBackend.tree_map(None, self._c2v, params) # don't do the () initialization since cache is in upper level of backend_factory - TensorFlowBackend.tree_map(None, self._apply_gradients, grads, params) + TensorFlowBackend.tree_map( + None, self._apply_gradients, self.optimizer, grads, params + ) if not self.is_variable: return TensorFlowBackend.tree_map(None, tf.convert_to_tensor, params) return params From d3995dad369194bde0f4e8e696314571c19514ff Mon Sep 17 00:00:00 2001 From: liwt31 Date: Fri, 24 Feb 2023 09:14:45 +0800 Subject: [PATCH 332/725] refactor noise model --- tensorcircuit/abstractcircuit.py | 6 +- tensorcircuit/interfaces/scipy.py | 6 +- tensorcircuit/noisemodel.py | 205 +++++++++++++----------------- tests/test_circuit.py | 2 +- tests/test_noisemodel.py | 32 +++-- 5 files changed, 114 insertions(+), 137 deletions(-) diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index ca87f0fe..b98c892f 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -530,7 +530,7 @@ def standardize_gate(name: str) -> str: ) return name - def gate_count(self, gate_list: Optional[Sequence[str]] = None) -> int: + def gate_count(self, gate_list: Optional[Union[str, Sequence[str]]] = None) -> int: """ count the gate number of the circuit @@ -545,7 +545,7 @@ def gate_count(self, gate_list: Optional[Sequence[str]] = None) -> int: >>> c.gate_count(["multicontrol", "toffoli"]) 2 - :param gate_list: gate name list to be counted, defaults to None (counting all gates) + :param gate_list: gate name or gate name list to be counted, defaults to None (counting all gates) :type gate_list: Optional[Sequence[str]], optional :return: the total number of all gates or gates in the ``gate_list`` :rtype: int @@ -553,6 +553,8 @@ def gate_count(self, gate_list: Optional[Sequence[str]] = None) -> int: if gate_list is None: return len(self._qir) else: + if isinstance(gate_list, str): + gate_list = [gate_list] gate_list = [self.standardize_gate(g) for g in gate_list] c = 0 for d in self._qir: diff --git a/tensorcircuit/interfaces/scipy.py b/tensorcircuit/interfaces/scipy.py index dbebd431..fe45a1dd 100644 --- a/tensorcircuit/interfaces/scipy.py +++ b/tensorcircuit/interfaces/scipy.py @@ -80,8 +80,8 @@ def scipy_vg(*args: Any, **kws: Any) -> Tuple[Tensor, Tensor]: scipy_vs = general_args_to_numpy(vs) gs = backend.reshape(gs, [-1]) scipy_gs = general_args_to_numpy(gs) - scipy_vs = scipy_vs.astype(np.float64) - scipy_gs = scipy_gs.astype(np.float64) + scipy_vs = scipy_vs.real.astype(np.float64) + scipy_gs = scipy_gs.real.astype(np.float64) return scipy_vs, scipy_gs return scipy_vg @@ -97,7 +97,7 @@ def scipy_v(*args: Any, **kws: Any) -> Tensor: scipy_args = tuple(scipy_args) vs = fun(*scipy_args, **kws) scipy_vs = general_args_to_numpy(vs) - scipy_vs = scipy_vs.astype(np.float64) + scipy_vs = scipy_vs.real.astype(np.float64) return scipy_vs return scipy_v diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 6613fa82..313de285 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -2,7 +2,8 @@ General Noise Model Construction. """ import logging -from typing import Any, Sequence, Optional, List, Dict, Tuple +from functools import partial +from typing import Any, Sequence, Optional, List, Dict, Tuple, Callable, Union import tensornetwork as tn @@ -10,7 +11,7 @@ from . import gates from . import Circuit, DMCircuit from .cons import backend -from .channels import KrausList, composedkraus +from .channels import KrausList Gate = gates.Gate Tensor = Any @@ -37,14 +38,15 @@ def __init__(self) -> None: """ Establish a noise configuration. """ - self.nc = {} # type: ignore + # description, condition and Kraus operators + self.nc: List[Tuple[Any, Callable[[Dict[str, Any]], bool], KrausList]] = [] self.has_quantum = False - self.has_readout = False + self.readout_error = None def add_noise( self, gate_name: str, - kraus: Sequence[KrausList], + kraus: Union[KrausList, Sequence[KrausList]], qubit: Optional[Sequence[Any]] = None, ) -> None: """ @@ -57,40 +59,79 @@ def add_noise( :param qubit: the list of noisy qubit, defaults to None, indicating applying the noise channel on all qubits :type qubit: Optional[Sequence[Any]], optional """ - if gate_name != "readout": - gate_name = AbstractCircuit.standardize_gate(gate_name) + if gate_name == "readout": + # probably need to refactor readout error + assert qubit is None + self.readout_error = kraus # type:ignore + return - if gate_name not in self.nc: - qubit_kraus = {} - else: - qubit_kraus = self.nc[gate_name] + gate_name = AbstractCircuit.standardize_gate(gate_name) + description: Any if qubit is None: - if qubit_kraus: - for qname in qubit_kraus: - qubit_kraus[qname] = composedkraus(qubit_kraus[qname], kraus) # type: ignore + description = gate_name + + def condition(d: Dict[str, Any]) -> bool: + return str(d["gatef"].n) == gate_name + + if not isinstance(kraus, KrausList): + assert len(kraus) == 1 + krauslist = kraus[0] else: - qubit_kraus["Default"] = kraus + krauslist = kraus + self.nc.append((description, condition, krauslist)) else: - for i in range(len(qubit)): - if tuple(qubit[i]) in qubit_kraus: - qubit_kraus[tuple(qubit[i])] = composedkraus( - qubit_kraus[tuple(qubit[i])], kraus[i] - ) - else: - if "Default" in qubit_kraus: - qubit_kraus[tuple(qubit[i])] = composedkraus( - qubit_kraus["Default"], kraus[i] - ) - else: - qubit_kraus[tuple(qubit[i])] = kraus[i] + for idx, krauslist in zip(qubit, kraus): + description = (gate_name, idx) - self.nc[gate_name] = qubit_kraus + # https://stackoverflow.com/questions/1107210/python-create-function-in-a-loop-capturing-the-loop-variable + def condition( # type:ignore + d: Dict[str, Any], _idx: Sequence[Any] + ) -> bool: + # avoid bad black style because the long is too long + b1 = d["gatef"].n == gate_name + b2 = tuple(d["index"]) == tuple(_idx) + return b1 and b2 - if gate_name == "readout": - self.has_readout = True - else: - self.has_quantum = True + condition = partial(condition, _idx=idx) + self.nc.append((description, condition, krauslist)) + + self.has_quantum = True + + def add_noise_by_condition( + self, + condition: Callable[[Dict[str, Any]], bool], + kraus: KrausList, + name: Optional[Any] = "custom", + ) -> None: + """ + Add noise based on specified condition + + :param condition: a function to decide if the noise should be added to the qir. + :type condition: Callable[[Dict[str, Any]], bool] + :param kraus: the error channel + :type kraus: KrausList + :param name: the name of the condition. A metadata that does not affect the numerics. + :type name: Any + """ + self.nc.append((name, condition, kraus)) + + def channel_count(self, c: Circuit) -> int: + """ + Count the total number of channels in a given circuit + + :param c: the circuit to be counted + :type c: Circuit + :return: the count + :rtype: int + """ + count = 0 + for d in c.to_qir(): + # pylint: disable-next=unused-variable + for _, condition, krauslist in self.nc: + if condition(d): + count += 1 + return count def apply_qir_with_noise( @@ -126,38 +167,21 @@ def apply_qir_with_noise( ) if isinstance(c, DMCircuit): - if d["name"] in noise_conf.nc: - if ( - "Default" in noise_conf.nc[d["name"]] - or d["index"] in noise_conf.nc[d["name"]] - ): - if "Default" in noise_conf.nc[d["name"]]: - noise_kraus = noise_conf.nc[d["name"]]["Default"] - if d["index"] in noise_conf.nc[d["name"]]: - noise_kraus = noise_conf.nc[d["name"]][d["index"]] - - c.general_kraus(noise_kraus, *d["index"]) - + for _, condition, krauslist in noise_conf.nc: + if condition(d): + c.general_kraus(krauslist, *d["index"]) else: - if d["name"] in noise_conf.nc: - if ( - "Default" in noise_conf.nc[d["name"]] - or d["index"] in noise_conf.nc[d["name"]] - ): - if "Default" in noise_conf.nc[d["name"]]: - noise_kraus = noise_conf.nc[d["name"]]["Default"] - if d["index"] in noise_conf.nc[d["name"]]: - noise_kraus = noise_conf.nc[d["name"]][d["index"]] - - if noise_kraus.is_unitary is True: + for _, condition, krauslist in noise_conf.nc: + if condition(d): + if krauslist.is_unitary: c.unitary_kraus( - noise_kraus, + krauslist, *d["index"], status=status[quantum_index], # type: ignore ) else: c.general_kraus( - noise_kraus, + krauslist, *d["index"], status=status[quantum_index], # type: ignore ) @@ -190,50 +214,6 @@ def circuit_with_noise( return cnew -# def expectation_ps_noisfy( -# c: Any, -# x: Optional[Sequence[int]] = None, -# y: Optional[Sequence[int]] = None, -# z: Optional[Sequence[int]] = None, -# noise_conf: Optional[NoiseConf] = None, -# nmc: int = 1000, -# status: Optional[Tensor] = None, -# ) -> Tensor: - -# if noise_conf is None: -# noise_conf = NoiseConf() - -# num_quantum = c.gate_count(list(noise_conf.nc.keys())) - -# if noise_conf.has_readout is True: -# logger.warning("expectation_ps_noisfy can't support readout error.") - -# if noise_conf.has_quantum is True: - -# # density matrix -# if isinstance(c, DMCircuit): -# cnoise = circuit_with_noise(c, noise_conf) -# return cnoise.expectation_ps(x=x, y=y, z=z) - -# # monte carlo -# else: - -# def mcsim(status: Optional[Tensor]) -> Tensor: -# cnoise = circuit_with_noise(c, noise_conf, status) # type: ignore -# return cnoise.expectation_ps(x=x, y=y, z=z) - -# mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) -# if status is None: -# status = backend.implicit_randu([nmc, num_quantum]) - -# value = backend.mean(mcsim_vmap(status)) - -# return value - -# else: -# return c.expectation_ps(x=x, y=y, z=z) - - def sample_expectation_ps_noisfy( c: Any, x: Optional[Sequence[int]] = None, @@ -276,17 +256,9 @@ def sample_expectation_ps_noisfy( if noise_conf is None: noise_conf = NoiseConf() - lgate = list(noise_conf.nc.keys()) - if "readout" in lgate: - lgate.remove("readout") - num_quantum = c.gate_count(lgate) - - if noise_conf.has_readout is True: - readout_error = noise_conf.nc["readout"]["Default"] - else: - readout_error = None + readout_error = noise_conf.readout_error - if noise_conf.has_quantum is True: + if noise_conf.has_quantum: # density matrix if isinstance(c, DMCircuit): cnoise = circuit_with_noise(c, noise_conf) # type: ignore @@ -310,6 +282,7 @@ def mcsim(statusc: Optional[Tensor], status: Optional[Tensor]) -> Tensor: mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=(0, 1)) if statusc is None: + num_quantum = noise_conf.channel_count(c) statusc = backend.implicit_randu([nmc, num_quantum]) if status is None: @@ -355,15 +328,10 @@ def expectation_noisfy( if noise_conf is None: noise_conf = NoiseConf() - lgate = list(noise_conf.nc.keys()) - if "readout" in lgate: - lgate.remove("readout") - num_quantum = c.gate_count(lgate) - - if noise_conf.has_readout is True: + if noise_conf.readout_error is not None: logger.warning("expectation_ps_noisfy can't support readout error.") - if noise_conf.has_quantum is True: + if noise_conf.has_quantum: # density matrix if isinstance(c, DMCircuit): cnoise = circuit_with_noise(c, noise_conf) @@ -378,6 +346,7 @@ def mcsim(status: Optional[Tensor]) -> Tensor: mcsim_vmap = backend.vmap(mcsim, vectorized_argnums=0) if status is None: + num_quantum = noise_conf.channel_count(c) status = backend.implicit_randu([nmc, num_quantum]) value = backend.mean(mcsim_vmap(status)) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 4e373d81..24aa115c 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1422,7 +1422,7 @@ def test_gate_count(): c.ccnot(1, 2, 0) c.ccx(1, 2, 0) assert c.gate_count() == 8 - assert c.gate_count(["h"]) == 2 + assert c.gate_count("h") == 2 assert c.gate_count(["ccnot"]) == 3 assert c.gate_count(["rx", "multicontrol"]) == 2 assert c.gate_count_by_condition(lambda qir: qir["index"] == (0,)) == 2 diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index 73085620..dbc727eb 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -66,22 +66,26 @@ def test_noisemodel(backend): # with readout_error value = sample_expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf) - np.testing.assert_allclose(value, -0.11, atol=1e-1) + np.testing.assert_allclose(value, -0.12, atol=1e-2) value = sample_expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=100000) - np.testing.assert_allclose(value, -0.11, atol=1e-1) + np.testing.assert_allclose(value, -0.12, atol=1e-2) - # test composed channel + # test composed channel and general condition newerror = composedkraus(error1, error3) noise_conf1 = NoiseConf() noise_conf1.add_noise("rx", [newerror, error1], [[0], [1]]) noise_conf1.add_noise("h", [error3, error1], [[0], [1]]) noise_conf1.add_noise("x", [error3], [[0]]) - noise_conf1.add_noise("cnot", [error2], [[0, 1]]) + + def condition(d): + return d["name"] == "cnot" and d["index"] == (0, 1) + + noise_conf1.add_noise_by_condition(condition, error2) noise_conf1.add_noise("readout", readout_error) - # value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf1, nmc=10000) - # np.testing.assert_allclose(value, 0.09, atol=1e-1) + value = sample_expectation_ps_noisfy(dmc, x=[0, 1], noise_conf=noise_conf1) + np.testing.assert_allclose(value, -0.12, atol=1e-2) # test standardized gate newerror = composedkraus(error1, error3) @@ -92,8 +96,10 @@ def test_noisemodel(backend): noise_conf2.add_noise("cx", [error2], [[0, 1]]) noise_conf2.add_noise("readout", readout_error) - # value = expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf2, nmc=10000) - # np.testing.assert_allclose(value, 0.09, atol=1e-1) + value = sample_expectation_ps_noisfy( + c, x=[0, 1], noise_conf=noise_conf2, nmc=100000 + ) + np.testing.assert_allclose(value, -0.12, atol=1e-2) @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) @@ -132,8 +138,8 @@ def test_general_noisemodel(backend): value1 = sample_expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) value2 = c.sample_expectation_ps(x=[0, 1], noise_conf=noise_conf, nmc=10000) value3 = dmc.sample_expectation_ps(x=[0, 1], noise_conf=noise_conf) - np.testing.assert_allclose(value1, value2, atol=1e-1) - np.testing.assert_allclose(value3, value2, atol=1e-1) + np.testing.assert_allclose(value1, value2, atol=1e-2) + np.testing.assert_allclose(value3, value2, atol=1e-2) # test expectation value1 = expectation_noisfy( @@ -141,11 +147,11 @@ def test_general_noisemodel(backend): ) value2 = c.expectation((tc.gates.z(), [0]), noise_conf=noise_conf, nmc=10000) value3 = dmc.expectation((tc.gates.z(), [0]), noise_conf=noise_conf) - np.testing.assert_allclose(value1, value2, atol=1e-1) - np.testing.assert_allclose(value3, value2, atol=1e-1) + np.testing.assert_allclose(value1, value2, atol=1e-2) + np.testing.assert_allclose(value3, value2, atol=1e-2) # test expectation_ps # value = expectation_ps_noisfy(c, x=[0], noise_conf=noise_conf, nmc=10000) value1 = c.expectation_ps(x=[0], noise_conf=noise_conf, nmc=10000) value2 = dmc.expectation_ps(x=[0], noise_conf=noise_conf) - np.testing.assert_allclose(value1, value2, atol=1e-1) + np.testing.assert_allclose(value1, value2, atol=1e-2) From f306b484ef2e9a47da753a3d18bb6d5727c97252 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 24 Feb 2023 10:21:48 +0800 Subject: [PATCH 333/725] opt compatible with tf2.11 --- CHANGELOG.md | 2 + tensorcircuit/backends/tensorflow_backend.py | 59 ++++++++++++-------- 2 files changed, 39 insertions(+), 22 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ef2d4cdf..bbc9f345 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -44,6 +44,8 @@ - Fix `KerasLayer` so that it supports null weights +- Fix tf optimizer bug and optimizer compatibility issue with tf2.11 + ## 0.7.0 ### Added diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 032e7456..81ec6047 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -5,7 +5,6 @@ from functools import reduce, partial from operator import mul -from copy import deepcopy from typing import Any, Callable, Optional, Sequence, Tuple, Union from scipy.sparse import coo_matrix @@ -24,33 +23,49 @@ class keras_optimizer: def __init__(self, optimizer: Any) -> None: self.optimizer = optimizer - self.is_variable = True self.is_initialized = False - def _c2v(self, v: Tensor) -> Tensor: - if not isinstance(v, tf.Variable): - v = tf.Variable(v) - self.is_variable = False - return v - - def _apply_gradients(self, opt: Any, grads: Tensor, params: Tensor) -> None: - opt.apply_gradients([(grads, params)]) + # def _apply_gradients(self, grads: Tensor, params: Tensor) -> None: + # self.optimizer.apply_gradients([(grads, params)]) def update(self, grads: pytree, params: pytree) -> pytree: + # if not self.is_initialized: + # l, treedef = TensorFlowBackend.tree_flatten(None, params) + # # https://github.com/tensorflow/tensorflow/issues/58973 + # # still breaks tf2.11 + # ol = [deepcopy(self.optimizer) for _ in l] + # self.optimizer = TensorFlowBackend.tree_unflatten(None, treedef, ol) + # self.is_initialized = True + # params = TensorFlowBackend.tree_map(None, self._c2v, params) + # don't do the () initialization since cache is in upper level of backend_factory + grads_l, _ = TensorFlowBackend.tree_flatten(None, grads) + params_l, params_def = TensorFlowBackend.tree_flatten(None, params) if not self.is_initialized: - l, treedef = TensorFlowBackend.tree_flatten(None, params) - # https://github.com/tensorflow/tensorflow/issues/58973 - # still breaks tf2.11 - ol = [deepcopy(self.optimizer) for _ in l] - self.optimizer = TensorFlowBackend.tree_unflatten(None, treedef, ol) + self.params_v = [] + self.is_variable = [] + for p in params_l: + if not isinstance(p, tf.Variable): + self.params_v.append(tf.Variable(p)) + self.is_variable.append(False) + else: + self.params_v.append(p) + self.is_variable.append(True) self.is_initialized = True - params = TensorFlowBackend.tree_map(None, self._c2v, params) - # don't do the () initialization since cache is in upper level of backend_factory - TensorFlowBackend.tree_map( - None, self._apply_gradients, self.optimizer, grads, params - ) - if not self.is_variable: - return TensorFlowBackend.tree_map(None, tf.convert_to_tensor, params) + else: + for i, p in enumerate(params_l): + if not isinstance(p, tf.Variable): + self.params_v[i] = self.params_v[i].assign(p) + else: + self.params_v[i] = self.params_v[i].assign(p.value()) + + self.optimizer.apply_gradients(zip(grads_l, self.params_v)) + nparams_l = [] + for p, flag in zip(self.params_v, self.is_variable): + if flag is True: + nparams_l.append(p) + else: + nparams_l.append(p.value()) + params = TensorFlowBackend.tree_unflatten(None, params_def, nparams_l) return params From 363cfb5e0a19f808c7523669ce1585c9eda53e8e Mon Sep 17 00:00:00 2001 From: liwt31 Date: Fri, 24 Feb 2023 12:44:12 +0800 Subject: [PATCH 334/725] make noisy test more robust --- tensorcircuit/noisemodel.py | 4 +--- tests/test_noisemodel.py | 13 ++++++------- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 313de285..38933b7a 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -60,7 +60,6 @@ def add_noise( :type qubit: Optional[Sequence[Any]], optional """ if gate_name == "readout": - # probably need to refactor readout error assert qubit is None self.readout_error = kraus # type:ignore return @@ -127,8 +126,7 @@ def channel_count(self, c: Circuit) -> int: """ count = 0 for d in c.to_qir(): - # pylint: disable-next=unused-variable - for _, condition, krauslist in self.nc: + for _, condition, _ in self.nc: if condition(d): count += 1 return count diff --git a/tests/test_noisemodel.py b/tests/test_noisemodel.py index dbc727eb..75ec82d7 100644 --- a/tests/test_noisemodel.py +++ b/tests/test_noisemodel.py @@ -134,24 +134,23 @@ def test_general_noisemodel(backend): noise_conf.add_noise("cnot", [error2], [[0, 1]]) noise_conf.add_noise("readout", readout_error) + nmc = 100000 # # test sample_expectation_ps - value1 = sample_expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=10000) - value2 = c.sample_expectation_ps(x=[0, 1], noise_conf=noise_conf, nmc=10000) + value1 = sample_expectation_ps_noisfy(c, x=[0, 1], noise_conf=noise_conf, nmc=nmc) + value2 = c.sample_expectation_ps(x=[0, 1], noise_conf=noise_conf, nmc=nmc) value3 = dmc.sample_expectation_ps(x=[0, 1], noise_conf=noise_conf) np.testing.assert_allclose(value1, value2, atol=1e-2) np.testing.assert_allclose(value3, value2, atol=1e-2) # test expectation - value1 = expectation_noisfy( - c, (tc.gates.z(), [0]), noise_conf=noise_conf, nmc=10000 - ) - value2 = c.expectation((tc.gates.z(), [0]), noise_conf=noise_conf, nmc=10000) + value1 = expectation_noisfy(c, (tc.gates.z(), [0]), noise_conf=noise_conf, nmc=nmc) + value2 = c.expectation((tc.gates.z(), [0]), noise_conf=noise_conf, nmc=nmc) value3 = dmc.expectation((tc.gates.z(), [0]), noise_conf=noise_conf) np.testing.assert_allclose(value1, value2, atol=1e-2) np.testing.assert_allclose(value3, value2, atol=1e-2) # test expectation_ps # value = expectation_ps_noisfy(c, x=[0], noise_conf=noise_conf, nmc=10000) - value1 = c.expectation_ps(x=[0], noise_conf=noise_conf, nmc=10000) + value1 = c.expectation_ps(x=[0], noise_conf=noise_conf, nmc=nmc) value2 = dmc.expectation_ps(x=[0], noise_conf=noise_conf) np.testing.assert_allclose(value1, value2, atol=1e-2) From 896fe4bfc7bc91366a6a12d2e46a11b2b1e26ffe Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 24 Feb 2023 19:05:46 +0800 Subject: [PATCH 335/725] add state argument for listing device --- tensorcircuit/cloud/apis.py | 8 +++++--- tensorcircuit/cloud/local.py | 2 +- tensorcircuit/cloud/tencent.py | 4 ++-- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 3762aed1..0825f81c 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -246,7 +246,9 @@ def get_token( def list_devices( - provider: Optional[Union[str, Provider]] = None, token: Optional[str] = None + provider: Optional[Union[str, Provider]] = None, + token: Optional[str] = None, + **kws: Any, ) -> List[Device]: """ List all devices under a provider @@ -264,9 +266,9 @@ def list_devices( if token is None: token = provider.get_token() if provider.name == "tencent": - return tencent.list_devices(token) + return tencent.list_devices(token, **kws) elif provider.name == "local": - return local.list_devices(token) + return local.list_devices(token, **kws) else: raise ValueError("Unsupported provider: %s" % provider.name) diff --git a/tensorcircuit/cloud/local.py b/tensorcircuit/cloud/local.py index 959a9493..aa11681a 100644 --- a/tensorcircuit/cloud/local.py +++ b/tensorcircuit/cloud/local.py @@ -15,7 +15,7 @@ task_list: Dict[str, Any] = {} # memory only task cache -def list_devices(token: Optional[str] = None) -> List[Device]: +def list_devices(token: Optional[str] = None, **kws: Any) -> List[Device]: rs = [] for d in local_devices: rs.append(Device.from_name("local" + sep + d)) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 8217de3c..0b71c0e0 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -34,8 +34,8 @@ def error_handling(r: Dict[str, Any]) -> Dict[str, Any]: return r -def list_devices(token: Optional[str] = None) -> List[Device]: - json: Dict[Any, Any] = {} +def list_devices(token: Optional[str] = None, **kws: Any) -> List[Device]: + json: Dict[Any, Any] = kws r = rpost_json( tencent_base_url + "device/find", json=json, headers=tencent_headers(token) ) From 18cb97ce62e8434273cd721efc620cbbef8f4361 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 24 Feb 2023 19:07:20 +0800 Subject: [PATCH 336/725] add zero circuit protection in translation --- tensorcircuit/translation.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index cf63877d..18beffed 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -446,7 +446,11 @@ def qiskit2tc( circuit_params = {} if "nqubits" not in circuit_params: circuit_params["nqubits"] = n - if qcdata[0][0].name == "initialize" and "inputs" not in circuit_params: + if ( + len(qcdata) > 0 + and qcdata[0][0].name == "initialize" + and "inputs" not in circuit_params + ): circuit_params["inputs"] = perm_matrix(n) @ np.array(qcdata[0][0].params) if inputs is not None: circuit_params["inputs"] = inputs From f84d34c5dd46b09fe9f2fde117cffd968d31752d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 24 Feb 2023 19:25:13 +0800 Subject: [PATCH 337/725] more clear error message when submitting the job --- tensorcircuit/cloud/tencent.py | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 0b71c0e0..95497779 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -278,20 +278,22 @@ def c2qasm(c: Any, compiling: bool) -> str: tencent_base_url + "task/submit", json=json, headers=tencent_headers(token) ) r = error_handling(r) - try: - rtn = [] - for t in r["tasks"]: + rtn = [] + for t in r["tasks"]: + if "err" in t or "id" not in t: if "err" in t: logger.warning(t["err"]) else: - ti = Task(id_=t["id"], device=device) - rtn.append(ti) - if len(rtn) == 1: - return rtn[0] # type: ignore + logger.warning("unsuccessful submission of the task:\n" + dumps(r)) else: - return rtn - except KeyError: - raise ValueError(dumps(r)) + ti = Task(id_=t["id"], device=device) + rtn.append(ti) + if len(rtn) == 1: + return rtn[0] # type: ignore + elif len(rtn) == 0: + raise ValueError("All tasks submitted failed") + else: + return rtn def resubmit_task(task: Task, token: str) -> Task: From d0764d694ee674b9ddb0e46d0ffa7d24b06275b9 Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Sun, 26 Feb 2023 16:33:22 +0800 Subject: [PATCH 338/725] added bagging and its test case --- tensorcircuit/templates/ensemble.py | 165 ++++++++++++++++++++++++++++ tests/test_ensemble.py | 51 +++++++++ 2 files changed, 216 insertions(+) create mode 100644 tensorcircuit/templates/ensemble.py create mode 100644 tests/test_ensemble.py diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py new file mode 100644 index 00000000..9a1f698c --- /dev/null +++ b/tensorcircuit/templates/ensemble.py @@ -0,0 +1,165 @@ +""" +Useful utilities for ensemble +""" + +import tensorflow as tf +import numpy as np + +class bagging: # A.K.A. voting + + def __init__(self): + self.models = [] + self.is_trained = [] + self.count = 0 + self.need_confidence = True # Help in reducing numbers of get_confidence runs + self.permit_train = False + + def append(self, model, is_trained): + ''' + Add model to the voting method + ''' + self.models.append(model) + self.is_trained.append(is_trained) + self.count += 1 + + def __train_model(self, i, **kwargs): + ''' + Train a model if it isn't trained already + ''' + if not self.is_trained[i]: + self.need_confidence = True + self.is_trained[i] = True + self.models[i] + self.models[i].trainable + self.models[i].fit(**kwargs) + + def train(self, **kwargs): + ''' + Train all models in the class, **kwargs expect to receive the argus that can be directly sent to tf.fit + Expected to be run after finishing compile + ''' + if not self.permit_train: + raise Exception("Needed to be compiled before training") + for i in range(self.count): + if "verbose" in kwargs: + if kwargs["verbose"] == 1: + print("Model ",i+1,"/",self.count," is training...") + else: + print("Model ",i+1,"/",self.count," is training...") + self.__train_model(i,**kwargs) + + def compile(self, **kwargs): + ''' + Compile code + ''' + self.permit_train = True + for i in range(self.count): + self.models[i].compile(**kwargs) + + def __get_confidence(self, model_index, input): + ''' + Get the confidence value that is needed by voting. + Number of calling this function is reduced by self.need_confidence + ''' + self.need_confidence = False + prediction = self.models[model_index].predict(input) + prediction_returns = np.zeros(len(prediction)) + for i in range(len(prediction)): + prediction_returns[i] = prediction[i][0] + return prediction_returns + + ''' + Voting strategies begin + More voting strategies can be added beneath, a single function, and a if function in self.predict + ''' + + def __voting_weight(self,array): + result = [] + for i in array: + result.append(self.__voting_weight_single(i)) + return result + + def __voting_most(self,array): + result = [] + for i in array: + result.append(self.__voting_most_single(i)) + return result + + def __voting_average(self,array): + result = [] + for i in array: + result.append(self.__voting_average_single(i)) + return result + + def __voting_weight_single(self,array): + opp_array = np.ones(len(array))-array + weight = np.absolute(opp_array - array) + weight_sum = np.sum(weight) + weight = weight / weight_sum + result = array * weight + return np.sum(result) + + def __voting_most_single(self,array): + weight = array.size + result = 0 + for i in array: + result += i/weight + return result + + def __voting_average_single(self,array): + result = array / array.size + return np.sum(result) + + def predict(self, input_data, voting_policy: str="none"): + ''' + Input data is expected to be a 2D array that the first layer is different input data (into the trained models) + ''' + if self.need_confidence: + predictions = [] + for i in range(self.count): + predictions.append(np.array(self.__get_confidence(i, input_data))) + predictions = np.array(predictions) + self.predictions = np.transpose(predictions) + if voting_policy == "weight": + return self.__voting_weight(self.predictions) + elif voting_policy == "most": + return self.__voting_most(self.predictions) + elif voting_policy == "average": + return self.__voting_average(self.predictions) + elif voting_policy == "none": + return self.predictions + else: + raise Exception("voting_policy must be none, weight, most, or average") + + def __acc_binarify(self,array): + ''' + Needed for ACC test + ''' + result = [] + for i in array: + result.append(1 if (i>0.5) else 0) + return result + + def __eval_accuracy(self, input_data): + input_data[1] = self.__acc_binarify(input_data[1]) + algo = tf.keras.metrics.Accuracy() + algo.reset_state() + algo.update_state(input_data[0], input_data[1]) + return algo.result().numpy() + + def __eval_auc(self, input_data): + algo = tf.keras.metrics.AUC() + algo.reset_state() + algo.update_state(input_data[0], input_data[1]) + return algo.result().numpy() + + def eval(self, input_data, evaluation_method: str="acc"): + ''' + Expect input data to be a 2D array, which a 1D array of yTrue followed by a 1D array of yPred is expected to be the components of the 2D array + ''' + if evaluation_method == "acc": + return self.__eval_accuracy(input_data) + elif evaluation_method == "auc": + return self.__eval_auc(input_data) + else: + raise Exception("evaluation_method must be acc or auc") diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py new file mode 100644 index 00000000..9821a429 --- /dev/null +++ b/tests/test_ensemble.py @@ -0,0 +1,51 @@ +import tensorflow as tf +import numpy as np +from tensorcircuit.templates.ensemble import bagging + +data_amount = 100 # Amount of data to be used +linear_demension = 4 # linear demension of the data +epochs = 10 +batch_size = 32 +lr = 1e-3 + +x_train, y_train = (np.ones([data_amount, linear_demension]), np.ones([data_amount, 1])) + +obj_bagging = bagging() + +def model(): + + DROP = 0.1 + + activation = 'selu' + inputs = tf.keras.Input(shape=(linear_demension,), name="digits") + x0 = tf.keras.layers.Dense(1, + kernel_regularizer = tf.keras.regularizers.l2(9.613e-06), + activation = activation, + )(inputs) + x0 = tf.keras.layers.Dropout(DROP)(x0) + + x = tf.keras.layers.Dense(1, + kernel_regularizer = tf.keras.regularizers.l2(1e-07), + activation='sigmoid', + )(x0) + + model = tf.keras.Model(inputs, x) + + return model + +obj_bagging.append(model(), False) +obj_bagging.append(model(), False) +obj_bagging.append(model(), False) +obj_bagging.compile( + loss=tf.keras.losses.BinaryCrossentropy(), + optimizer=tf.keras.optimizers.Adam(lr), + metrics=[tf.keras.metrics.AUC(),'acc'] + ) +obj_bagging.train(x = x_train, y = y_train, epochs = epochs, batch_size = batch_size, verbose = 0) + +v_weight = obj_bagging.predict(x_train, "weight") +v_most = obj_bagging.predict(x_train, "most") +v_average = obj_bagging.predict(x_train, "average") +validation_data = [] +validation_data.append(obj_bagging.eval([y_train,v_weight],"acc")) +validation_data.append(obj_bagging.eval([y_train,v_weight],"auc")) \ No newline at end of file From faf3b5b258cb003d2e38a1b7cc3edd3ccc143121 Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Sun, 26 Feb 2023 17:28:48 +0800 Subject: [PATCH 339/725] Fix issues --- tensorcircuit/templates/ensemble.py | 2 +- tests/test_ensemble.py | 92 ++++++++++++++++------------- 2 files changed, 52 insertions(+), 42 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 9a1f698c..dc074495 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -62,7 +62,7 @@ def __get_confidence(self, model_index, input): Number of calling this function is reduced by self.need_confidence ''' self.need_confidence = False - prediction = self.models[model_index].predict(input) + prediction = self.models[model_index].predict(input,verbose=0) prediction_returns = np.zeros(len(prediction)) for i in range(len(prediction)): prediction_returns[i] = prediction[i][0] diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py index 9821a429..9e459c60 100644 --- a/tests/test_ensemble.py +++ b/tests/test_ensemble.py @@ -1,51 +1,61 @@ import tensorflow as tf import numpy as np +import os +import sys + +thisfile = os.path.abspath(__file__) +modulepath = os.path.dirname(os.path.dirname(thisfile)) + +sys.path.insert(0, modulepath) + from tensorcircuit.templates.ensemble import bagging -data_amount = 100 # Amount of data to be used -linear_demension = 4 # linear demension of the data -epochs = 10 -batch_size = 32 -lr = 1e-3 +def test_ensemble_bagging(): -x_train, y_train = (np.ones([data_amount, linear_demension]), np.ones([data_amount, 1])) + data_amount = 100 # Amount of data to be used + linear_demension = 4 # linear demension of the data + epochs = 10 + batch_size = 32 + lr = 1e-3 -obj_bagging = bagging() + x_train, y_train = (np.ones([data_amount, linear_demension]), np.ones([data_amount, 1])) -def model(): + obj_bagging = bagging() - DROP = 0.1 + def model(): - activation = 'selu' - inputs = tf.keras.Input(shape=(linear_demension,), name="digits") - x0 = tf.keras.layers.Dense(1, - kernel_regularizer = tf.keras.regularizers.l2(9.613e-06), - activation = activation, - )(inputs) - x0 = tf.keras.layers.Dropout(DROP)(x0) - - x = tf.keras.layers.Dense(1, - kernel_regularizer = tf.keras.regularizers.l2(1e-07), - activation='sigmoid', - )(x0) + DROP = 0.1 + + activation = 'selu' + inputs = tf.keras.Input(shape=(linear_demension,), name="digits") + x0 = tf.keras.layers.Dense(1, + kernel_regularizer = tf.keras.regularizers.l2(9.613e-06), + activation = activation, + )(inputs) + x0 = tf.keras.layers.Dropout(DROP)(x0) + + x = tf.keras.layers.Dense(1, + kernel_regularizer = tf.keras.regularizers.l2(1e-07), + activation='sigmoid', + )(x0) + + model = tf.keras.Model(inputs, x) - model = tf.keras.Model(inputs, x) - - return model - -obj_bagging.append(model(), False) -obj_bagging.append(model(), False) -obj_bagging.append(model(), False) -obj_bagging.compile( - loss=tf.keras.losses.BinaryCrossentropy(), - optimizer=tf.keras.optimizers.Adam(lr), - metrics=[tf.keras.metrics.AUC(),'acc'] - ) -obj_bagging.train(x = x_train, y = y_train, epochs = epochs, batch_size = batch_size, verbose = 0) - -v_weight = obj_bagging.predict(x_train, "weight") -v_most = obj_bagging.predict(x_train, "most") -v_average = obj_bagging.predict(x_train, "average") -validation_data = [] -validation_data.append(obj_bagging.eval([y_train,v_weight],"acc")) -validation_data.append(obj_bagging.eval([y_train,v_weight],"auc")) \ No newline at end of file + return model + + obj_bagging.append(model(), False) + obj_bagging.append(model(), False) + obj_bagging.append(model(), False) + obj_bagging.compile( + loss=tf.keras.losses.BinaryCrossentropy(), + optimizer=tf.keras.optimizers.Adam(lr), + metrics=[tf.keras.metrics.AUC(),'acc'] + ) + obj_bagging.train(x = x_train, y = y_train, epochs = epochs, batch_size = batch_size, verbose = 0) + + v_weight = obj_bagging.predict(x_train, "weight") + v_most = obj_bagging.predict(x_train, "most") + v_average = obj_bagging.predict(x_train, "average") + validation_data = [] + validation_data.append(obj_bagging.eval([y_train,v_weight],"acc")) + validation_data.append(obj_bagging.eval([y_train,v_weight],"auc")) \ No newline at end of file From c004c1aba7c980cb6e756f432896ec608b22c547 Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Sun, 26 Feb 2023 17:49:00 +0800 Subject: [PATCH 340/725] fix to black --- tensorcircuit/templates/ensemble.py | 84 ++++++++++++++--------------- tests/test_ensemble.py | 54 ++++++++++--------- 2 files changed, 72 insertions(+), 66 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index dc074495..72f444c1 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -5,27 +5,27 @@ import tensorflow as tf import numpy as np -class bagging: # A.K.A. voting +class bagging: # A.K.A. voting def __init__(self): self.models = [] self.is_trained = [] self.count = 0 - self.need_confidence = True # Help in reducing numbers of get_confidence runs + self.need_confidence = True # Help in reducing numbers of get_confidence runs self.permit_train = False def append(self, model, is_trained): - ''' + """ Add model to the voting method - ''' + """ self.models.append(model) self.is_trained.append(is_trained) self.count += 1 def __train_model(self, i, **kwargs): - ''' + """ Train a model if it isn't trained already - ''' + """ if not self.is_trained[i]: self.need_confidence = True self.is_trained[i] = True @@ -34,86 +34,86 @@ def __train_model(self, i, **kwargs): self.models[i].fit(**kwargs) def train(self, **kwargs): - ''' + """ Train all models in the class, **kwargs expect to receive the argus that can be directly sent to tf.fit - Expected to be run after finishing compile - ''' + Expected to be run after finishing compile + """ if not self.permit_train: raise Exception("Needed to be compiled before training") for i in range(self.count): if "verbose" in kwargs: if kwargs["verbose"] == 1: - print("Model ",i+1,"/",self.count," is training...") + print("Model ", i + 1, "/", self.count, " is training...") else: - print("Model ",i+1,"/",self.count," is training...") - self.__train_model(i,**kwargs) + print("Model ", i + 1, "/", self.count, " is training...") + self.__train_model(i, **kwargs) def compile(self, **kwargs): - ''' + """ Compile code - ''' + """ self.permit_train = True for i in range(self.count): self.models[i].compile(**kwargs) def __get_confidence(self, model_index, input): - ''' + """ Get the confidence value that is needed by voting. Number of calling this function is reduced by self.need_confidence - ''' + """ self.need_confidence = False - prediction = self.models[model_index].predict(input,verbose=0) + prediction = self.models[model_index].predict(input, verbose=0) prediction_returns = np.zeros(len(prediction)) for i in range(len(prediction)): prediction_returns[i] = prediction[i][0] return prediction_returns - ''' + """ Voting strategies begin More voting strategies can be added beneath, a single function, and a if function in self.predict - ''' + """ - def __voting_weight(self,array): + def __voting_weight(self, array): result = [] for i in array: result.append(self.__voting_weight_single(i)) return result - def __voting_most(self,array): + def __voting_most(self, array): result = [] for i in array: result.append(self.__voting_most_single(i)) return result - - def __voting_average(self,array): + + def __voting_average(self, array): result = [] for i in array: result.append(self.__voting_average_single(i)) return result - def __voting_weight_single(self,array): - opp_array = np.ones(len(array))-array + def __voting_weight_single(self, array): + opp_array = np.ones(len(array)) - array weight = np.absolute(opp_array - array) weight_sum = np.sum(weight) weight = weight / weight_sum result = array * weight return np.sum(result) - def __voting_most_single(self,array): + def __voting_most_single(self, array): weight = array.size result = 0 for i in array: - result += i/weight + result += i / weight return result - - def __voting_average_single(self,array): + + def __voting_average_single(self, array): result = array / array.size return np.sum(result) - def predict(self, input_data, voting_policy: str="none"): - ''' + def predict(self, input_data, voting_policy: str = "none"): + """ Input data is expected to be a 2D array that the first layer is different input data (into the trained models) - ''' + """ if self.need_confidence: predictions = [] for i in range(self.count): @@ -131,15 +131,15 @@ def predict(self, input_data, voting_policy: str="none"): else: raise Exception("voting_policy must be none, weight, most, or average") - def __acc_binarify(self,array): - ''' + def __acc_binarify(self, array): + """ Needed for ACC test - ''' + """ result = [] for i in array: - result.append(1 if (i>0.5) else 0) + result.append(1 if (i > 0.5) else 0) return result - + def __eval_accuracy(self, input_data): input_data[1] = self.__acc_binarify(input_data[1]) algo = tf.keras.metrics.Accuracy() @@ -151,12 +151,12 @@ def __eval_auc(self, input_data): algo = tf.keras.metrics.AUC() algo.reset_state() algo.update_state(input_data[0], input_data[1]) - return algo.result().numpy() - - def eval(self, input_data, evaluation_method: str="acc"): - ''' + return algo.result().numpy() + + def eval(self, input_data, evaluation_method: str = "acc"): + """ Expect input data to be a 2D array, which a 1D array of yTrue followed by a 1D array of yPred is expected to be the components of the 2D array - ''' + """ if evaluation_method == "acc": return self.__eval_accuracy(input_data) elif evaluation_method == "auc": diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py index 9e459c60..339179fa 100644 --- a/tests/test_ensemble.py +++ b/tests/test_ensemble.py @@ -10,52 +10,58 @@ from tensorcircuit.templates.ensemble import bagging -def test_ensemble_bagging(): - data_amount = 100 # Amount of data to be used - linear_demension = 4 # linear demension of the data +def test_ensemble_bagging(): + data_amount = 100 # Amount of data to be used + linear_demension = 4 # linear demension of the data epochs = 10 batch_size = 32 lr = 1e-3 - x_train, y_train = (np.ones([data_amount, linear_demension]), np.ones([data_amount, 1])) + x_train, y_train = ( + np.ones([data_amount, linear_demension]), + np.ones([data_amount, 1]), + ) obj_bagging = bagging() def model(): - DROP = 0.1 - activation = 'selu' + activation = "selu" inputs = tf.keras.Input(shape=(linear_demension,), name="digits") - x0 = tf.keras.layers.Dense(1, - kernel_regularizer = tf.keras.regularizers.l2(9.613e-06), - activation = activation, - )(inputs) + x0 = tf.keras.layers.Dense( + 1, + kernel_regularizer=tf.keras.regularizers.l2(9.613e-06), + activation=activation, + )(inputs) x0 = tf.keras.layers.Dropout(DROP)(x0) - - x = tf.keras.layers.Dense(1, - kernel_regularizer = tf.keras.regularizers.l2(1e-07), - activation='sigmoid', - )(x0) - + + x = tf.keras.layers.Dense( + 1, + kernel_regularizer=tf.keras.regularizers.l2(1e-07), + activation="sigmoid", + )(x0) + model = tf.keras.Model(inputs, x) - + return model obj_bagging.append(model(), False) obj_bagging.append(model(), False) obj_bagging.append(model(), False) obj_bagging.compile( - loss=tf.keras.losses.BinaryCrossentropy(), - optimizer=tf.keras.optimizers.Adam(lr), - metrics=[tf.keras.metrics.AUC(),'acc'] - ) - obj_bagging.train(x = x_train, y = y_train, epochs = epochs, batch_size = batch_size, verbose = 0) + loss=tf.keras.losses.BinaryCrossentropy(), + optimizer=tf.keras.optimizers.Adam(lr), + metrics=[tf.keras.metrics.AUC(), "acc"], + ) + obj_bagging.train( + x=x_train, y=y_train, epochs=epochs, batch_size=batch_size, verbose=0 + ) v_weight = obj_bagging.predict(x_train, "weight") v_most = obj_bagging.predict(x_train, "most") v_average = obj_bagging.predict(x_train, "average") validation_data = [] - validation_data.append(obj_bagging.eval([y_train,v_weight],"acc")) - validation_data.append(obj_bagging.eval([y_train,v_weight],"auc")) \ No newline at end of file + validation_data.append(obj_bagging.eval([y_train, v_weight], "acc")) + validation_data.append(obj_bagging.eval([y_train, v_weight], "auc")) From a035ae6effe71fa90d2de921fcd6463e3ce142dc Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Sun, 26 Feb 2023 19:31:28 +0800 Subject: [PATCH 341/725] Fix type annotation and typo --- tensorcircuit/templates/ensemble.py | 87 ++++++++++++----------------- tests/test_ensemble.py | 13 +++-- 2 files changed, 43 insertions(+), 57 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 72f444c1..49a208d9 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -3,43 +3,48 @@ """ import tensorflow as tf +import keras import numpy as np +from typing import Any, Optional, Sequence, Tuple, List + +NDArray = Any +kwargus = Any class bagging: # A.K.A. voting - def __init__(self): - self.models = [] - self.is_trained = [] + def __init__(self) -> None: + self.models: List[keras.engine.functional.Functional]= [] + self.model_trained: List[bool] = [] self.count = 0 self.need_confidence = True # Help in reducing numbers of get_confidence runs self.permit_train = False - def append(self, model, is_trained): + def append(self, model: keras.engine.functional.Functional, model_trained: bool) -> None: """ Add model to the voting method """ self.models.append(model) - self.is_trained.append(is_trained) + self.model_trained.append(model_trained) self.count += 1 - def __train_model(self, i, **kwargs): + def __train_model(self, i: int, **kwargs: kwargus) -> None: """ Train a model if it isn't trained already """ - if not self.is_trained[i]: + if not self.model_trained[i]: self.need_confidence = True - self.is_trained[i] = True - self.models[i] + self.model_trained[i] = True self.models[i].trainable self.models[i].fit(**kwargs) - def train(self, **kwargs): + def train(self, **kwargs: kwargus) -> None: """ Train all models in the class, **kwargs expect to receive the argus that can be directly sent to tf.fit Expected to be run after finishing compile """ if not self.permit_train: - raise Exception("Needed to be compiled before training") + #raise Exception("Needed to be compiled before training") + raise ValueError() for i in range(self.count): if "verbose" in kwargs: if kwargs["verbose"] == 1: @@ -48,7 +53,7 @@ def train(self, **kwargs): print("Model ", i + 1, "/", self.count, " is training...") self.__train_model(i, **kwargs) - def compile(self, **kwargs): + def compile(self, **kwargs: kwargus) -> None: """ Compile code """ @@ -56,7 +61,7 @@ def compile(self, **kwargs): for i in range(self.count): self.models[i].compile(**kwargs) - def __get_confidence(self, model_index, input): + def __get_confidence(self, model_index: int, input: NDArray) -> NDArray: """ Get the confidence value that is needed by voting. Number of calling this function is reduced by self.need_confidence @@ -73,44 +78,25 @@ def __get_confidence(self, model_index, input): More voting strategies can be added beneath, a single function, and a if function in self.predict """ - def __voting_weight(self, array): + def __voting_weight(self, array: NDArray) -> NDArray: result = [] for i in array: result.append(self.__voting_weight_single(i)) - return result + return np.array(result) - def __voting_most(self, array): - result = [] - for i in array: - result.append(self.__voting_most_single(i)) + def __voting_average(self, array: NDArray) -> NDArray: + result = np.mean(array, axis=1) return result - def __voting_average(self, array): - result = [] - for i in array: - result.append(self.__voting_average_single(i)) - return result - - def __voting_weight_single(self, array): + def __voting_weight_single(self, array: NDArray) -> float: opp_array = np.ones(len(array)) - array weight = np.absolute(opp_array - array) weight_sum = np.sum(weight) weight = weight / weight_sum result = array * weight - return np.sum(result) - - def __voting_most_single(self, array): - weight = array.size - result = 0 - for i in array: - result += i / weight - return result - - def __voting_average_single(self, array): - result = array / array.size - return np.sum(result) + return float(np.sum(result)) - def predict(self, input_data, voting_policy: str = "none"): + def predict(self, input_data: NDArray, voting_policy: str = "None") -> NDArray: """ Input data is expected to be a 2D array that the first layer is different input data (into the trained models) """ @@ -118,20 +104,19 @@ def predict(self, input_data, voting_policy: str = "none"): predictions = [] for i in range(self.count): predictions.append(np.array(self.__get_confidence(i, input_data))) - predictions = np.array(predictions) - self.predictions = np.transpose(predictions) + self.predictions = np.transpose(np.array(predictions)) if voting_policy == "weight": return self.__voting_weight(self.predictions) elif voting_policy == "most": - return self.__voting_most(self.predictions) + return self.__voting_average(self.predictions) elif voting_policy == "average": return self.__voting_average(self.predictions) - elif voting_policy == "none": + elif voting_policy == "None" or voting_policy == "none": return self.predictions else: - raise Exception("voting_policy must be none, weight, most, or average") + raise ValueError() - def __acc_binarify(self, array): + def __acc_binarify(self, array: NDArray) -> NDArray: """ Needed for ACC test """ @@ -140,20 +125,20 @@ def __acc_binarify(self, array): result.append(1 if (i > 0.5) else 0) return result - def __eval_accuracy(self, input_data): + def __eval_accuracy(self, input_data: NDArray) -> float: input_data[1] = self.__acc_binarify(input_data[1]) algo = tf.keras.metrics.Accuracy() algo.reset_state() algo.update_state(input_data[0], input_data[1]) - return algo.result().numpy() + return float(algo.result().numpy()) - def __eval_auc(self, input_data): + def __eval_auc(self, input_data: NDArray) -> float: algo = tf.keras.metrics.AUC() algo.reset_state() algo.update_state(input_data[0], input_data[1]) - return algo.result().numpy() + return float(algo.result().numpy()) - def eval(self, input_data, evaluation_method: str = "acc"): + def eval(self, input_data: List[NDArray], evaluation_method: str = "acc") -> float: """ Expect input data to be a 2D array, which a 1D array of yTrue followed by a 1D array of yPred is expected to be the components of the 2D array """ @@ -162,4 +147,4 @@ def eval(self, input_data, evaluation_method: str = "acc"): elif evaluation_method == "auc": return self.__eval_auc(input_data) else: - raise Exception("evaluation_method must be acc or auc") + raise ValueError() diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py index 339179fa..d82ebc84 100644 --- a/tests/test_ensemble.py +++ b/tests/test_ensemble.py @@ -1,7 +1,7 @@ -import tensorflow as tf -import numpy as np import os import sys +import tensorflow as tf +import numpy as np thisfile = os.path.abspath(__file__) modulepath = os.path.dirname(os.path.dirname(thisfile)) @@ -13,13 +13,13 @@ def test_ensemble_bagging(): data_amount = 100 # Amount of data to be used - linear_demension = 4 # linear demension of the data + linear_dimension = 4 # linear demension of the data epochs = 10 batch_size = 32 lr = 1e-3 x_train, y_train = ( - np.ones([data_amount, linear_demension]), + np.ones([data_amount, linear_dimension]), np.ones([data_amount, 1]), ) @@ -29,7 +29,7 @@ def model(): DROP = 0.1 activation = "selu" - inputs = tf.keras.Input(shape=(linear_demension,), name="digits") + inputs = tf.keras.Input(shape=(linear_dimension,), name="digits") x0 = tf.keras.layers.Dense( 1, kernel_regularizer=tf.keras.regularizers.l2(9.613e-06), @@ -60,8 +60,9 @@ def model(): ) v_weight = obj_bagging.predict(x_train, "weight") - v_most = obj_bagging.predict(x_train, "most") v_average = obj_bagging.predict(x_train, "average") validation_data = [] validation_data.append(obj_bagging.eval([y_train, v_weight], "acc")) validation_data.append(obj_bagging.eval([y_train, v_weight], "auc")) + +test_ensemble_bagging() \ No newline at end of file From 2ae95a9060091be036bb43e22e309f00585b26e2 Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Sun, 26 Feb 2023 19:44:59 +0800 Subject: [PATCH 342/725] black format --- tensorcircuit/templates/ensemble.py | 8 +++++--- tests/test_ensemble.py | 3 ++- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 49a208d9..ac107f66 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -13,13 +13,15 @@ class bagging: # A.K.A. voting def __init__(self) -> None: - self.models: List[keras.engine.functional.Functional]= [] + self.models: List[keras.engine.functional.Functional] = [] self.model_trained: List[bool] = [] self.count = 0 self.need_confidence = True # Help in reducing numbers of get_confidence runs self.permit_train = False - def append(self, model: keras.engine.functional.Functional, model_trained: bool) -> None: + def append( + self, model: keras.engine.functional.Functional, model_trained: bool + ) -> None: """ Add model to the voting method """ @@ -43,7 +45,7 @@ def train(self, **kwargs: kwargus) -> None: Expected to be run after finishing compile """ if not self.permit_train: - #raise Exception("Needed to be compiled before training") + # raise Exception("Needed to be compiled before training") raise ValueError() for i in range(self.count): if "verbose" in kwargs: diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py index d82ebc84..b01bdf83 100644 --- a/tests/test_ensemble.py +++ b/tests/test_ensemble.py @@ -65,4 +65,5 @@ def model(): validation_data.append(obj_bagging.eval([y_train, v_weight], "acc")) validation_data.append(obj_bagging.eval([y_train, v_weight], "auc")) -test_ensemble_bagging() \ No newline at end of file + +test_ensemble_bagging() From e07157ef7e6b19dfa482b65a08c2d187ed23f56c Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Sun, 26 Feb 2023 20:06:41 +0800 Subject: [PATCH 343/725] fix pylint --- tensorcircuit/templates/ensemble.py | 5 +---- tests/test_ensemble.py | 5 +---- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index ac107f66..d87d1643 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -2,10 +2,10 @@ Useful utilities for ensemble """ +from typing import Any, List import tensorflow as tf import keras import numpy as np -from typing import Any, Optional, Sequence, Tuple, List NDArray = Any kwargus = Any @@ -56,9 +56,6 @@ def train(self, **kwargs: kwargus) -> None: self.__train_model(i, **kwargs) def compile(self, **kwargs: kwargus) -> None: - """ - Compile code - """ self.permit_train = True for i in range(self.count): self.models[i].compile(**kwargs) diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py index b01bdf83..c71ce466 100644 --- a/tests/test_ensemble.py +++ b/tests/test_ensemble.py @@ -63,7 +63,4 @@ def model(): v_average = obj_bagging.predict(x_train, "average") validation_data = [] validation_data.append(obj_bagging.eval([y_train, v_weight], "acc")) - validation_data.append(obj_bagging.eval([y_train, v_weight], "auc")) - - -test_ensemble_bagging() + validation_data.append(obj_bagging.eval([y_train, v_average], "auc")) From 6085f88cd020bf958fa104e08db2c16d2ba1033f Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Sun, 26 Feb 2023 20:23:26 +0800 Subject: [PATCH 344/725] fix pylint --- tensorcircuit/templates/ensemble.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index d87d1643..01dcc016 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -139,7 +139,8 @@ def __eval_auc(self, input_data: NDArray) -> float: def eval(self, input_data: List[NDArray], evaluation_method: str = "acc") -> float: """ - Expect input data to be a 2D array, which a 1D array of yTrue followed by a 1D array of yPred is expected to be the components of the 2D array + Expect input data to be a 2D array + which a 1D array of yTrue followed by a 1D array of yPred is expected to be the components of the 2D array """ if evaluation_method == "acc": return self.__eval_accuracy(input_data) From 624f6b9ff7aadf5d11b6afaafee0182551fa7e7b Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Sun, 26 Feb 2023 21:16:07 +0800 Subject: [PATCH 345/725] Added error message --- tensorcircuit/templates/ensemble.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 01dcc016..638e7c6c 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -46,7 +46,7 @@ def train(self, **kwargs: kwargus) -> None: """ if not self.permit_train: # raise Exception("Needed to be compiled before training") - raise ValueError() + raise ValueError("Models needed to be compiled before training") for i in range(self.count): if "verbose" in kwargs: if kwargs["verbose"] == 1: @@ -113,7 +113,7 @@ def predict(self, input_data: NDArray, voting_policy: str = "None") -> NDArray: elif voting_policy == "None" or voting_policy == "none": return self.predictions else: - raise ValueError() + raise ValueError("voting_policy must be none, weight, most, or average") def __acc_binarify(self, array: NDArray) -> NDArray: """ @@ -147,4 +147,4 @@ def eval(self, input_data: List[NDArray], evaluation_method: str = "acc") -> flo elif evaluation_method == "auc": return self.__eval_auc(input_data) else: - raise ValueError() + raise ValueError("evaluation_method must be acc or auc") From e5adb0465d052ef815fceee5627f915d02755823 Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Mon, 27 Feb 2023 10:06:29 +0800 Subject: [PATCH 346/725] Optimization --- tensorcircuit/templates/ensemble.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 638e7c6c..61954f4f 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -36,7 +36,6 @@ def __train_model(self, i: int, **kwargs: kwargus) -> None: if not self.model_trained[i]: self.need_confidence = True self.model_trained[i] = True - self.models[i].trainable self.models[i].fit(**kwargs) def train(self, **kwargs: kwargus) -> None: @@ -45,7 +44,6 @@ def train(self, **kwargs: kwargus) -> None: Expected to be run after finishing compile """ if not self.permit_train: - # raise Exception("Needed to be compiled before training") raise ValueError("Models needed to be compiled before training") for i in range(self.count): if "verbose" in kwargs: @@ -58,7 +56,8 @@ def train(self, **kwargs: kwargus) -> None: def compile(self, **kwargs: kwargus) -> None: self.permit_train = True for i in range(self.count): - self.models[i].compile(**kwargs) + if not self.model_trained[i]: + self.models[i].compile(**kwargs) def __get_confidence(self, model_index: int, input: NDArray) -> NDArray: """ @@ -95,7 +94,7 @@ def __voting_weight_single(self, array: NDArray) -> float: result = array * weight return float(np.sum(result)) - def predict(self, input_data: NDArray, voting_policy: str = "None") -> NDArray: + def predict(self, input_data: NDArray, voting_policy: str = None) -> NDArray: """ Input data is expected to be a 2D array that the first layer is different input data (into the trained models) """ @@ -106,11 +105,9 @@ def predict(self, input_data: NDArray, voting_policy: str = "None") -> NDArray: self.predictions = np.transpose(np.array(predictions)) if voting_policy == "weight": return self.__voting_weight(self.predictions) - elif voting_policy == "most": - return self.__voting_average(self.predictions) elif voting_policy == "average": return self.__voting_average(self.predictions) - elif voting_policy == "None" or voting_policy == "none": + elif voting_policy is None: return self.predictions else: raise ValueError("voting_policy must be none, weight, most, or average") From 91ebec93ede94b508d52eb64256228931bb11d6b Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Mon, 27 Feb 2023 10:23:24 +0800 Subject: [PATCH 347/725] Updates for mypy --- tensorcircuit/templates/ensemble.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 61954f4f..14dee4ec 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -94,7 +94,7 @@ def __voting_weight_single(self, array: NDArray) -> float: result = array * weight return float(np.sum(result)) - def predict(self, input_data: NDArray, voting_policy: str = None) -> NDArray: + def predict(self, input_data: NDArray, voting_policy: str = "None") -> NDArray: """ Input data is expected to be a 2D array that the first layer is different input data (into the trained models) """ @@ -107,7 +107,7 @@ def predict(self, input_data: NDArray, voting_policy: str = None) -> NDArray: return self.__voting_weight(self.predictions) elif voting_policy == "average": return self.__voting_average(self.predictions) - elif voting_policy is None: + elif voting_policy == "None": return self.predictions else: raise ValueError("voting_policy must be none, weight, most, or average") From 8ee333be67c17b5ccc2d77adf8e55d23d033804f Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Mon, 27 Feb 2023 11:14:21 +0800 Subject: [PATCH 348/725] Added most voting method --- tensorcircuit/templates/ensemble.py | 20 +++++++++++++++++--- tests/test_ensemble.py | 2 ++ 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 14dee4ec..5c5c7955 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -2,7 +2,7 @@ Useful utilities for ensemble """ -from typing import Any, List +from typing import Any, List, Optional import tensorflow as tf import keras import numpy as np @@ -94,7 +94,19 @@ def __voting_weight_single(self, array: NDArray) -> float: result = array * weight return float(np.sum(result)) - def predict(self, input_data: NDArray, voting_policy: str = "None") -> NDArray: + def __voting_most(self, array: NDArray) -> NDArray: + return_result = [] + for items in array: + items_ = items > 0.5 + result = 0 + for i in items_: + result += 1 if i else -1 + return_result.append(1 if result > 0 else 0) + return np.array(return_result) + + def predict( + self, input_data: NDArray, voting_policy: Optional[str] = "None" + ) -> NDArray: """ Input data is expected to be a 2D array that the first layer is different input data (into the trained models) """ @@ -105,9 +117,11 @@ def predict(self, input_data: NDArray, voting_policy: str = "None") -> NDArray: self.predictions = np.transpose(np.array(predictions)) if voting_policy == "weight": return self.__voting_weight(self.predictions) + elif voting_policy == "most": + return self.__voting_most(self.predictions) elif voting_policy == "average": return self.__voting_average(self.predictions) - elif voting_policy == "None": + elif voting_policy is None: return self.predictions else: raise ValueError("voting_policy must be none, weight, most, or average") diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py index c71ce466..5aec52cc 100644 --- a/tests/test_ensemble.py +++ b/tests/test_ensemble.py @@ -61,6 +61,8 @@ def model(): v_weight = obj_bagging.predict(x_train, "weight") v_average = obj_bagging.predict(x_train, "average") + v_most = obj_bagging.predict(x_train, "most") validation_data = [] validation_data.append(obj_bagging.eval([y_train, v_weight], "acc")) validation_data.append(obj_bagging.eval([y_train, v_average], "auc")) + validation_data.append(obj_bagging.eval([y_train, v_most], "acc")) From 9a03cafbfdeb60e5b531982608646b7b118a806e Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Mon, 27 Feb 2023 11:24:25 +0800 Subject: [PATCH 349/725] typo fix --- tensorcircuit/templates/ensemble.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 5c5c7955..f8b97aee 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -105,7 +105,7 @@ def __voting_most(self, array: NDArray) -> NDArray: return np.array(return_result) def predict( - self, input_data: NDArray, voting_policy: Optional[str] = "None" + self, input_data: NDArray, voting_policy: Optional[str] = None ) -> NDArray: """ Input data is expected to be a 2D array that the first layer is different input data (into the trained models) From 4da03a0b9cea48a1b4586f6559e8375dc0ba2374 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Mon, 27 Feb 2023 05:05:33 +0000 Subject: [PATCH 350/725] docs: update README.md [skip ci] --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 777f2a0c..36ae3719 100644 --- a/README.md +++ b/README.md @@ -164,7 +164,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) Yicong Zheng
Yicong Zheng
✅ - Zixuan Song
Zixuan Song
📖 🌍 + Zixuan Song
Zixuan Song
📖 🌍 💻 ⚠️ Hao Xie
Hao Xie
📖 Pramit Singh
Pramit Singh
⚠️ Jonathan Allcock
Jonathan Allcock
📖 🤔 📢 From 50b08ab71fca602c065b778d5bb76571d7cca549 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Mon, 27 Feb 2023 05:05:34 +0000 Subject: [PATCH 351/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index 8ba87a4b..2c2fbf48 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -179,7 +179,9 @@ "profile": "https://marksong.tech", "contributions": [ "doc", - "translation" + "translation", + "code", + "test" ] }, { From 69f92a15a116ca089e5f54ee9cbae34c5bde5ff5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 27 Feb 2023 16:32:42 +0800 Subject: [PATCH 352/725] add finite difference decorator for tf function --- tensorcircuit/experimental.py | 51 +++++++++++++++++++++++++++++++++++ tests/test_miscs.py | 33 +++++++++++++++++++++++ 2 files changed, 84 insertions(+) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index b1fa8cdf..a8e6651b 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -347,6 +347,57 @@ def grad_f(*args: Any, **kws: Any) -> Any: # TODO(@refraction-ray): add SPSA gradient wrapper similar to parameter shift +def finite_difference_differentiator( + f: Callable[..., Any], + argnums: Tuple[int, ...] = (0,), + shifts: Tuple[float, float] = (0.001, 0.002), +) -> Callable[..., Any]: + # \bar{x}_j = \sum_i \bar{y}_i \frac{\Delta y_i}{\Delta x_j} + # tf only now and designed for hardware, since we dont do batch evaluation + import tensorflow as tf + + @tf.custom_gradient # type: ignore + def tf_function(*args: Any, **kwargs: Any) -> Any: + y = f(*args, **kwargs) + + def grad(*ybar: Any) -> Any: + # only support one output + delta_ms = [] + for argnum in argnums: + delta_m = [] + xi = tf.reshape(args[argnum], [-1]) + xi_size = xi.shape[0] + onehot = tf.one_hot(tf.range(xi_size), xi_size) + for j in range(xi_size): + xi_plus = xi + shifts[0] * onehot[j] + xi_minus = xi - shifts[0] * onehot[j] + args_plus = list(args) + args_plus[argnum] = xi_plus + args_minus = list(args) + args_minus[argnum] = xi_minus + dy = f(*args_plus, **kwargs) - f(*args_minus, **kwargs) + dy /= shifts[-1] + delta_m.append(tf.reshape(dy, [-1])) + delta_m = tf.stack(delta_m) + delta_m = tf.transpose(delta_m) + delta_ms.append(delta_m) + dxs = [] + ybar_flatten = tf.reshape(ybar, [1, -1]) + for i, argnum in enumerate(argnums): + dxs.append( + tf.cast( + tf.reshape(ybar_flatten @ delta_ms[i], args[i].shape), + args[i].dtype, + ) + ) + + return tuple(dxs) + + return y, grad + + return tf_function # type: ignore + + def hamiltonian_evol( tlist: Tensor, h: Tensor, diff --git a/tests/test_miscs.py b/tests/test_miscs.py index 9db5048d..2b5d7c5a 100644 --- a/tests/test_miscs.py +++ b/tests/test_miscs.py @@ -181,3 +181,36 @@ def f(theta: float, beta: float) -> float: np.testing.assert_allclose(f(beta=0.2, alpha=0.1), 0.3, atol=1e-5) print(f.__doc__) assert len(f.__doc__.strip().split("\n")) == 12 + + +def test_finite_difference_tf(tfb): + def f(param1, param2): + n = 4 + c = tc.Circuit(n) + for i in range(n): + c.rx(i, theta=param1[i]) + for i in range(n - 1): + c.cx(i, i + 1) + for i in range(n - 1): + c.rzz(i, i + 1, theta=param2[i]) + r = [c.expectation_ps(z=[i]) for i in range(n)] + return tc.backend.stack(r) + + def fsum(param1, param2): + return tc.backend.mean(f(param1, param2)) + + p1 = tf.ones([4]) + p2 = tf.ones([3]) + g1, g2 = tc.backend.value_and_grad(fsum)(p1, p2) + + f1 = experimental.finite_difference_differentiator( + f, argnums=(0, 1), shifts=(np.pi / 2, 2) + ) + + def fsum1(param1, param2): + return tc.backend.mean(f1(param1, param2)) + + g3, g4 = tc.backend.value_and_grad(fsum1)(p1, p2) + + np.testing.assert_allclose(g1, g3, atol=1e-5) + np.testing.assert_allclose(g2, g4, atol=1e-5) From 7416a651502697a595ef0ce77bddd13f2335d667 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 27 Feb 2023 17:20:30 +0800 Subject: [PATCH 353/725] fix tf differentiator --- tensorcircuit/experimental.py | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index a8e6651b..b2de6451 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -360,7 +360,7 @@ def finite_difference_differentiator( def tf_function(*args: Any, **kwargs: Any) -> Any: y = f(*args, **kwargs) - def grad(*ybar: Any) -> Any: + def grad(ybar: Any) -> Any: # only support one output delta_ms = [] for argnum in argnums: @@ -369,26 +369,24 @@ def grad(*ybar: Any) -> Any: xi_size = xi.shape[0] onehot = tf.one_hot(tf.range(xi_size), xi_size) for j in range(xi_size): - xi_plus = xi + shifts[0] * onehot[j] - xi_minus = xi - shifts[0] * onehot[j] + xi_plus = xi + tf.cast(shifts[0] * onehot[j], xi.dtype) + xi_minus = xi - tf.cast(shifts[0] * onehot[j], xi.dtype) args_plus = list(args) - args_plus[argnum] = xi_plus + args_plus[argnum] = tf.reshape(xi_plus, args[argnum].shape) args_minus = list(args) - args_minus[argnum] = xi_minus + args_minus[argnum] = tf.reshape(xi_minus, args[argnum].shape) dy = f(*args_plus, **kwargs) - f(*args_minus, **kwargs) dy /= shifts[-1] delta_m.append(tf.reshape(dy, [-1])) delta_m = tf.stack(delta_m) delta_m = tf.transpose(delta_m) delta_ms.append(delta_m) - dxs = [] + dxs = [tf.zeros_like(arg) for arg in args] ybar_flatten = tf.reshape(ybar, [1, -1]) for i, argnum in enumerate(argnums): - dxs.append( - tf.cast( - tf.reshape(ybar_flatten @ delta_ms[i], args[i].shape), - args[i].dtype, - ) + dxs[argnum] = tf.cast( + tf.reshape(ybar_flatten @ delta_ms[i], args[argnum].shape), + args[argnum].dtype, ) return tuple(dxs) From b6ededc3b402a71d654b9be933ec48b4010ccbf2 Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Mon, 27 Feb 2023 19:26:09 +0800 Subject: [PATCH 354/725] Update doc for tc.template.ensemble --- CHANGELOG.md | 2 ++ docs/source/api/templates.rst | 1 + docs/source/api/templates/ensemble.rst | 7 +++++++ 3 files changed, 10 insertions(+) create mode 100644 docs/source/api/templates/ensemble.rst diff --git a/CHANGELOG.md b/CHANGELOG.md index ef2d4cdf..3fbf98af 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -30,6 +30,8 @@ - Add methods in quantum module for translating ps list and xyz argument dict +- add `templates.ensemble.bagging` module for bagging ensemble method + ### Fixed - Circuit nosify in noise model now support all circuit attributs apart from qubit number diff --git a/docs/source/api/templates.rst b/docs/source/api/templates.rst index 586d74cc..330fa6db 100644 --- a/docs/source/api/templates.rst +++ b/docs/source/api/templates.rst @@ -4,5 +4,6 @@ tensorcircuit.templates templates/blocks.rst templates/chems.rst templates/dataset.rst + templates/ensemble.rst templates/graphs.rst templates/measurements.rst \ No newline at end of file diff --git a/docs/source/api/templates/ensemble.rst b/docs/source/api/templates/ensemble.rst new file mode 100644 index 00000000..c7dd6f85 --- /dev/null +++ b/docs/source/api/templates/ensemble.rst @@ -0,0 +1,7 @@ +tensorcircuit.templates.ensemble +================================================== +.. automodule:: tensorcircuit.templates.ensemble + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file From d41f47266fb84ffa7d3c3ed19553d7c615d7cd09 Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Mon, 27 Feb 2023 19:37:09 +0800 Subject: [PATCH 355/725] Resolve for preexisting issues on docs --- docs/source/api/compiler.rst | 1 + docs/source/api/compiler/composed_compiler.rst | 7 +++++++ docs/source/modules.rst | 1 - 3 files changed, 8 insertions(+), 1 deletion(-) create mode 100644 docs/source/api/compiler/composed_compiler.rst diff --git a/docs/source/api/compiler.rst b/docs/source/api/compiler.rst index 8c7f091b..43370b18 100644 --- a/docs/source/api/compiler.rst +++ b/docs/source/api/compiler.rst @@ -1,4 +1,5 @@ tensorcircuit.compiler ================================================== .. toctree:: + compiler/composed_compiler.rst compiler/qiskit_compiler.rst \ No newline at end of file diff --git a/docs/source/api/compiler/composed_compiler.rst b/docs/source/api/compiler/composed_compiler.rst new file mode 100644 index 00000000..c856636d --- /dev/null +++ b/docs/source/api/compiler/composed_compiler.rst @@ -0,0 +1,7 @@ +tensorcircuit.compiler.composed_compiler +================================================== +.. automodule:: tensorcircuit.compiler.composed_compiler + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/modules.rst b/docs/source/modules.rst index 05ea1cc3..b71e1b6f 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -7,7 +7,6 @@ tensorcircuit ./api/basecircuit.rst ./api/channels.rst ./api/circuit.rst - ./api/cloud.rst ./api/compiler.rst ./api/cons.rst ./api/densitymatrix.rst From 1f1cddbaa85392de893d1dce701830ce22eda3e6 Mon Sep 17 00:00:00 2001 From: MarkSong535 <78847784+MarkSong535@users.noreply.github.com> Date: Mon, 27 Feb 2023 20:22:09 +0800 Subject: [PATCH 356/725] typo fix --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3fbf98af..d6205e43 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -30,7 +30,7 @@ - Add methods in quantum module for translating ps list and xyz argument dict -- add `templates.ensemble.bagging` module for bagging ensemble method +- Add `templates.ensemble.bagging` module for bagging ensemble method ### Fixed From 062a8223b6bca04114b802f4bf95b74eeb7c0e0f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 1 Mar 2023 15:34:41 +0800 Subject: [PATCH 357/725] fix cache device bug and submittask with provider str bug --- tensorcircuit/cloud/abstraction.py | 21 ++++++++++++++++----- tensorcircuit/cloud/apis.py | 6 ++++++ tests/test_cloud.py | 18 ++++++++++++++++-- 3 files changed, 38 insertions(+), 7 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 0a17928c..4c588553 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -86,10 +86,10 @@ def get_token(self) -> str: return get_token(self) # type: ignore - def list_devices(self) -> Any: + def list_devices(self, **kws: Any) -> Any: from .apis import list_devices - return list_devices(self) + return list_devices(self, **kws) def get_device(self, device: Optional[Union[str, "Device"]]) -> "Device": from .apis import get_device @@ -153,13 +153,24 @@ def from_name( if isinstance(device, cls): d = device elif isinstance(device, str): - if device in cls.activated_devices: - return cls.activated_devices[device] + if len(device.split(sep)) > 1: + provider = device.split(sep)[0] + device = device.split(sep)[1] + if provider is None: + pn = "" + elif isinstance(provider, str): + pn = provider + else: + pn = provider.name + if pn + sep + device in cls.activated_devices: + return cls.activated_devices[pn + sep + device] else: d = cls(device, provider) - cls.activated_devices[device] = d + + cls.activated_devices[pn + sep + device] = d else: raise ValueError("Unsupported format for `provider` argument: %s" % device) + return d def set_token(self, token: str, cached: bool = True) -> Any: diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 0825f81c..151ffd22 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -88,14 +88,18 @@ def set_device( if isinstance(device, str): if len(device.split(sep)) > 1: + provider, device = device.split(sep) + provider = Provider.from_name(provider) device = Device.from_name(device, provider) else: if provider is None: provider = get_provider() + provider = Provider.from_name(provider) device = Device.from_name(device, provider) else: if provider is None: provider = get_provider() + provider = Provider.from_name(provider) device = Device.from_name(device, provider) if set_global: @@ -147,6 +151,8 @@ def _preprocess( device = Device.from_name(device, provider) if provider is None: provider = device.provider + if isinstance(provider, str): + provider = Provider.from_name(provider) return provider, device # type: ignore diff --git a/tests/test_cloud.py b/tests/test_cloud.py index f6f4bf75..aa36ecad 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -24,6 +24,7 @@ def test_list_devices(): print(apis.list_devices()) p = apis.get_provider() print(p.list_devices()) + print(p.list_devices(state="on")) def test_get_device(): @@ -42,6 +43,19 @@ def test_get_device(): assert d4.provider.name == "tencent" +def test_get_device_cache(): + d1 = apis.get_device("local::testing") + d2 = apis.get_device(provider="local", device="testing") + apis.set_provider("local") + d3 = apis.get_device("testing") + assert id(d1) == id(d2) + assert id(d3) == id(d1) + apis.set_provider("tencent") + d4 = apis.get_device("testing") + assert d4.provider.name == "tencent" + assert id(d4) != id(d1) + + def test_list_properties(): d = apis.get_device(device="simulator:aer") print(d.list_properties()) @@ -125,7 +139,7 @@ def test_local_batch_submit(): ts = apis.submit_task(circuit=[c, c]) print(ts[1].results()) print(ts[1].details()) - apis.set_provider() + apis.set_provider("tencent") def test_batch_exp_ps(): @@ -140,5 +154,5 @@ def test_batch_exp_ps(): np.testing.assert_allclose( wrapper.batch_expectation_ps(c, pss, device="simulator:tcn1"), [1, -1], - atol=1e-3, + atol=1e-1, ) From 5a8b52d23e4940a1c669e1fb676503d7057a843e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 1 Mar 2023 15:37:52 +0800 Subject: [PATCH 358/725] update on sdk doc --- docs/source/tutorials/tc_qcloud_sdk.ipynb | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/source/tutorials/tc_qcloud_sdk.ipynb b/docs/source/tutorials/tc_qcloud_sdk.ipynb index 9f8ccab4..3080c416 100644 --- a/docs/source/tutorials/tc_qcloud_sdk.ipynb +++ b/docs/source/tutorials/tc_qcloud_sdk.ipynb @@ -83,6 +83,16 @@ "apis.list_devices(\"tencent\")" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "be41de9d", + "metadata": {}, + "outputs": [], + "source": [ + "apis.list_devices(\"tencent\", state=\"on\")" + ] + }, { "cell_type": "code", "execution_count": null, From 0f85ee8f8c347219382cb5708ddecbca442bdf81 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 6 Mar 2023 19:01:55 +0800 Subject: [PATCH 359/725] add cloud module for general infra --- tensorcircuit/cloud/__init__.py | 0 tensorcircuit/cloud/abstraction.py | 460 +++++++++++++++++++++++++ tensorcircuit/cloud/apis.py | 516 +++++++++++++++++++++++++++++ tensorcircuit/cloud/local.py | 75 +++++ tensorcircuit/cloud/utils.py | 120 +++++++ tensorcircuit/cloud/wrapper.py | 185 +++++++++++ 6 files changed, 1356 insertions(+) create mode 100644 tensorcircuit/cloud/__init__.py create mode 100644 tensorcircuit/cloud/abstraction.py create mode 100644 tensorcircuit/cloud/apis.py create mode 100644 tensorcircuit/cloud/local.py create mode 100644 tensorcircuit/cloud/utils.py create mode 100644 tensorcircuit/cloud/wrapper.py diff --git a/tensorcircuit/cloud/__init__.py b/tensorcircuit/cloud/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py new file mode 100644 index 00000000..4c588553 --- /dev/null +++ b/tensorcircuit/cloud/abstraction.py @@ -0,0 +1,460 @@ +""" +Abstraction for Provider, Device and Task +""" + +from typing import Any, Dict, List, Optional, Union, Tuple +from functools import partial +import time + +import networkx as nx + +from ..results import readout_mitigation as rem +from ..results import counts +from ..utils import arg_alias + + +class TCException(BaseException): + pass + + +class TaskException(TCException): + pass + + +class TaskUnfinished(TaskException): + def __init__(self, taskid: str, state: str): + self.taskid = taskid + self.state = state + super().__init__( + "Task %s is not completed yet, now in %s state" % (self.taskid, self.state) + ) + + +class TaskFailed(TaskException): + def __init__(self, taskid: str, state: str, message: str): + self.taskid = taskid + self.state = state + self.message = message + super().__init__( + "Task %s is in %s state with err message %s" + % (self.taskid, self.state, self.message) + ) + + +class Provider: + """ + Provider abstraction for cloud connection, eg. "tencent", "local" + """ + + activated_providers: Dict[str, "Provider"] = {} + + def __init__(self, name: str, lower: bool = True): + if lower is True: + name = name.lower() + self.name = name + + def __str__(self) -> str: + return self.name + + __repr__ = __str__ + + @classmethod + def from_name(cls, provider: Union[str, "Provider"] = "tencent") -> "Provider": + if provider is None: + provider = "tencent" + if isinstance(provider, cls): + p = provider + elif isinstance(provider, str): + if provider in cls.activated_providers: + return cls.activated_providers[provider] + else: + p = cls(provider) + cls.activated_providers[provider] = p + else: + raise ValueError( + "Unsupported format for `provider` argument: %s" % provider + ) + return p + + def set_token(self, token: str, cached: bool = True) -> Any: + from .apis import set_token + + return set_token(token, self, cached=cached) + + def get_token(self) -> str: + from .apis import get_token + + return get_token(self) # type: ignore + + def list_devices(self, **kws: Any) -> Any: + from .apis import list_devices + + return list_devices(self, **kws) + + def get_device(self, device: Optional[Union[str, "Device"]]) -> "Device": + from .apis import get_device + + return get_device(self, device) + + def list_tasks(self, **filter_kws: Any) -> List["Task"]: + from .apis import list_tasks + + return list_tasks(self, **filter_kws) + + +sep = "::" + + +class Device: + """ + Device abstraction for cloud connection, eg. quantum chips + """ + + activated_devices: Dict[str, "Device"] = {} + + def __init__( + self, + name: str, + provider: Optional[Union[str, Provider]] = None, + lower: bool = True, + ): + if lower is True: + name = name.lower() + if provider is not None: + self.provider = Provider.from_name(provider) + if len(name.split(sep)) > 1: + self.name = name.split(sep)[1] + else: + self.name = name + else: # no explicit provider + if len(name.split(sep)) > 1: + self.name = name.split(sep)[1] + self.provider = Provider.from_name(name.split(sep)[0]) + else: + from .apis import get_provider + + self.name = name + self.provider = get_provider() + self.readout_mit: Any = None + + def __str__(self) -> str: + return self.provider.name + sep + self.name + + __repr__ = __str__ + + @classmethod + def from_name( + cls, + device: Union[str, "Device"], + provider: Optional[Union[str, Provider]] = None, + ) -> "Device": + # if device is None: + # raise ValueError("Must specify on device instead of default ``None``") + if isinstance(device, cls): + d = device + elif isinstance(device, str): + if len(device.split(sep)) > 1: + provider = device.split(sep)[0] + device = device.split(sep)[1] + if provider is None: + pn = "" + elif isinstance(provider, str): + pn = provider + else: + pn = provider.name + if pn + sep + device in cls.activated_devices: + return cls.activated_devices[pn + sep + device] + else: + d = cls(device, provider) + + cls.activated_devices[pn + sep + device] = d + else: + raise ValueError("Unsupported format for `provider` argument: %s" % device) + + return d + + def set_token(self, token: str, cached: bool = True) -> Any: + from .apis import set_token + + return set_token(token, provider=self.provider, device=self, cached=cached) + + def get_token(self) -> Optional[str]: + from .apis import get_token + + s = get_token(provider=self.provider, device=self) + if s is not None: + return s + # fallback to provider default + return get_token(provider=self.provider) + + def list_properties(self) -> Dict[str, Any]: + """ + List all device properties in as dict + + :return: [description] + :rtype: Dict[str, Any] + """ + from .apis import list_properties + + return list_properties(self.provider, self) + + def native_gates(self) -> List[str]: + """ + List native gates supported for the device, str conforms qiskit convention + + :return: _description_ + :rtype: List[str] + """ + properties = self.list_properties() + + if "native_gates" in properties: + return properties["native_gates"] # type: ignore + return [] + + def topology(self) -> List[Tuple[int, int]]: + """ + Get the bidirectional topology link list of the device + + :return: [description] + :rtype: List[Tuple[int, int]] + """ + properties = self.list_properties() + if "links" not in properties: + return # type: ignore + links = [] + for link in properties["links"]: + links.append((link[0], link[1])) + links.append((link[1], link[0])) + links = list(set(links)) + links = [list(link) for link in links] # type: ignore + # compatible with coupling_map in qiskit + return links + + def topology_graph(self, visualize: bool = False) -> nx.Graph: + """ + Get the qubit topology in ``nx.Graph`` or directly visualize it + + :param visualize: [description], defaults to False + :type visualize: bool, optional + :return: [description] + :rtype: nx.Graph + """ + pro = self.list_properties() + if not ("links" in pro and "bits" in pro): + return # type: ignore + g = nx.Graph() + node_color = [] + edge_color = [] + for i in pro["bits"]: + g.add_node(i) + node_color.append(pro["bits"][i]["T1"]) + for e1, e2 in pro["links"]: + g.add_edge(e1, e2) + edge_color.append(pro["links"][(e1, e2)]["CZErrRate"]) + if visualize is False: + return g + from matplotlib import colormaps + + # pos1 = nx.planar_layout(g) + # pos2 = nx.spring_layout(g, pos=pos1, k=2) + pos = nx.kamada_kawai_layout(g) + return nx.draw( + g, + pos=pos, + with_labels=True, + node_size=600, + node_color=node_color, + cmap=colormaps["Wistia"], + vmin=max(min(node_color) - 5, 0), + width=2.5, + edge_color=edge_color, + edge_cmap=colormaps["gray"], + edge_vmin=0, + edge_vmax=max(edge_color) * 1.2, + ) + + def get_task(self, taskid: str) -> "Task": + from .apis import get_task + + return get_task(taskid, device=self) + + def submit_task(self, **task_kws: Any) -> List["Task"]: + from .apis import submit_task + + return submit_task(provider=self.provider, device=self, **task_kws) + + def list_tasks(self, **filter_kws: Any) -> List["Task"]: + from .apis import list_tasks + + return list_tasks(self.provider, self, **filter_kws) + + +sep2 = "~~" + + +class Task: + """ + Task abstraction for quantum jobs on the cloud + """ + + def __init__(self, id_: str, device: Optional[Device] = None): + self.id_ = id_ + self.device = device + self.more_details: Dict[str, Any] = {} + + def __repr__(self) -> str: + return self.device.__repr__() + sep2 + self.id_ + + __str__ = __repr__ + + def get_device(self) -> Device: + """ + Query which device the task is run on + + :return: _description_ + :rtype: Device + """ + if self.device is None: + return Device.from_name(self.details()["device"]) + else: + return Device.from_name(self.device) + + def details(self, blocked: bool = False, **kws: Any) -> Dict[str, Any]: + """ + Get the current task details + + + :param blocked: whether return until task is finished, defaults to False + :type blocked: bool + :return: _description_ + :rtype: Dict[str, Any] + """ + from .apis import get_task_details + + if blocked is False: + dt = get_task_details(self, **kws) + dt.update(self.more_details) + return dt + s = self.state() + tries = 0 + while s == "pending": + time.sleep(0.5 + tries / 10) + tries += 1 + s = self.state() + return self.details(**kws) + + def add_details(self, **kws: Any) -> None: + self.more_details.update(kws) + + def state(self) -> str: + """ + Query the current task status + + :return: _description_ + :rtype: str + """ + r = self.details() + return r["state"] # type: ignore + + status = state + + def resubmit(self) -> "Task": + """ + resubmit the task + + :return: the resubmitted task + :rtype: Task + """ + from .apis import resubmit_task + + return resubmit_task(self) + + @partial(arg_alias, alias_dict={"format": ["format_"]}) + def results( + self, + format: Optional[str] = None, + blocked: bool = False, + mitigated: bool = False, + calibriation_options: Optional[Dict[str, Any]] = None, + readout_mit: Optional[rem.ReadoutMit] = None, + mitigation_options: Optional[Dict[str, Any]] = None, + ) -> counts.ct: + """ + get task results of the qjob + + :param format: unsupported now, defaults to None, which is "count_dict_bin" + :type format: Optional[str], optional + :param blocked: whether blocked to wait until the result is returned, defaults to False, + which raise error when the task is unfinished + :type blocked: bool, optional + :param mitigated: whether enable readout error mitigation, defaults to False + :type mitigated: bool, optional + :param calibriation_options: option dict for ``ReadoutMit.cals_from_system``, + defaults to None + :type calibriation_options: Optional[Dict[str, Any]], optional + :param readout_mit: if given, directly use the calibriation info on ``readout_mit``, + defaults to None + :type readout_mit: Optional[rem.ReadoutMit], optional + :param mitigation_options: option dict for ``ReadoutMit.apply_correction``, defaults to None + :type mitigation_options: Optional[Dict[str, Any]], optional + :return: count dict results + :rtype: Any + """ + if not blocked: + s = self.state() + if s != "completed": + raise TaskUnfinished(self.id_, s) + r = self.details()["results"] + r = counts.sort_count(r) # type: ignore + else: + s = self.state() + tries = 0 + while s != "completed": + if s in ["failed"]: + err = self.details().get("err", "") + raise TaskFailed(self.id_, s, err) + time.sleep(0.5 + tries / 10) + tries += 1 + s = self.state() + r = self.results(format=format, blocked=False, mitigated=False) + if mitigated is False: + return r # type: ignore + nqubit = len(list(r.keys())[0]) + + # mitigated is True: + device = self.get_device() + if device.provider.name != "tencent": + raise ValueError("Only tencent provider supports auto readout mitigation") + if readout_mit is None and getattr(device, "readout_mit", None) is None: + + def run(cs: Any, shots: Any) -> Any: + """ + current workaround for batch + """ + from .apis import submit_task + + ts = submit_task(circuit=cs, shots=shots, device=device.name + "?o=0") + return [t.results(blocked=True) for t in ts] # type: ignore + + shots = self.details()["shots"] + readout_mit = rem.ReadoutMit(run) + if calibriation_options is None: + calibriation_options = {} + readout_mit.cals_from_system( + list(range(nqubit)), shots, **calibriation_options + ) + device.readout_mit = readout_mit + elif readout_mit is None: + readout_mit = device.readout_mit + + if mitigation_options is None: + try: + mitigation_options = { + "logical_physical_mapping": self.details()["optimization"]["pairs"] + } + except KeyError: + mitigation_options = {} + miti_count = readout_mit.apply_correction( + r, list(range(nqubit)), **mitigation_options + ) + return counts.sort_count(miti_count) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py new file mode 100644 index 00000000..d656d07c --- /dev/null +++ b/tensorcircuit/cloud/apis.py @@ -0,0 +1,516 @@ +""" +main entrypoints of cloud module +""" + +from typing import Any, List, Optional, Dict, Union, Tuple +from base64 import b64decode, b64encode +from functools import partial +import json +import os +import sys +import logging + +logger = logging.getLogger(__name__) + +from .abstraction import Provider, Device, Task, sep, sep2 + +try: + from . import tencent # type: ignore +except ImportError as e: + logger.warning("fail to load cloud provider module: tencent") + +try: + from . import local +except ImportError as e: + logger.warning("fail to load cloud provider module: local") + +package_name = "tensorcircuit" +thismodule = sys.modules[__name__] + + +default_provider = Provider.from_name("tencent") +avail_providers = ["tencent", "local"] + + +def list_providers() -> List[Provider]: + """ + list all providers that tensorcircuit supports + + :return: _description_ + :rtype: List[Provider] + """ + return [get_provider(s) for s in avail_providers] + + +def set_provider( + provider: Optional[Union[str, Provider]] = None, set_global: bool = True +) -> Provider: + """ + set default provider for the program + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param set_global: whether set, defaults to True, + if False, equivalent to ``get_provider`` + :type set_global: bool, optional + :return: _description_ + :rtype: Provider + """ + if provider is None: + provider = default_provider + provider = Provider.from_name(provider) + if set_global: + for module in sys.modules: + if module.startswith(package_name): + setattr(sys.modules[module], "default_provider", provider) + return provider + + +set_provider() +get_provider = partial(set_provider, set_global=False) + +default_device = Device.from_name("tencent::simulator:tc") + + +def set_device( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + set_global: bool = True, +) -> Device: + """ + _summary_ + + :param provider: provider of the device, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: the device, defaults to None + :type device: Optional[Union[str, Device]], optional + :param set_global: whether set, defaults to True, + if False, equivalent to ``get_device``, defaults to True + :type set_global: bool, optional + :return: _description_ + :rtype: Device + """ + if provider is not None and device is None: + provider, device = None, provider + if device is None and provider is not None: + raise ValueError("Please specify the device apart from the provider") + if device is None: + device = default_device + + if isinstance(device, str): + if len(device.split(sep)) > 1: + provider, device = device.split(sep) + provider = Provider.from_name(provider) + device = Device.from_name(device, provider) + else: + if provider is None: + provider = get_provider() + provider = Provider.from_name(provider) + device = Device.from_name(device, provider) + else: + if provider is None: + provider = get_provider() + provider = Provider.from_name(provider) + device = Device.from_name(device, provider) + + if set_global: + for module in sys.modules: + if module.startswith(package_name): + setattr(sys.modules[module], "default_device", device) + return device + + +set_device() +get_device = partial(set_device, set_global=False) + + +def b64encode_s(s: str) -> str: + return b64encode(s.encode("utf-8")).decode("utf-8") + + +def b64decode_s(s: str) -> str: + return b64decode(s.encode("utf-8")).decode("utf-8") + + +saved_token: Dict[str, Any] = {} + + +def _preprocess( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, +) -> Tuple[Provider, Device]: + """ + Smartly determine the provider and device based on the input + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :return: a pair of provider and device after preprocessing + :rtype: Tuple[Provider, Device] + """ + if provider is not None and device is None: + provider, device = None, provider + if device is None: + device = get_device() + if isinstance(device, str): + if len(device.split(sep)) > 1: + device = Device.from_name(device, provider) + else: + if provider is None: + provider = get_provider() + device = Device.from_name(device, provider) + if provider is None: + provider = device.provider + if isinstance(provider, str): + provider = Provider.from_name(provider) + return provider, device # type: ignore + + +def set_token( + token: Optional[str] = None, + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + cached: bool = True, +) -> Dict[str, Any]: + """ + Set API token for given provider or specifically to given device + + :param token: the API token, defaults to None + :type token: Optional[str], optional + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :param cached: whether save on the disk, defaults to True + :type cached: bool, optional + :return: _description_ + :rtype: Dict[str, Any] + """ + global saved_token + homedir = os.path.expanduser("~") + authpath = os.path.join(homedir, ".tc.auth.json") + # provider, device = _preprocess(provider, device) + + if token is None: + if cached and os.path.exists(authpath): + with open(authpath, "r") as f: + file_token = json.load(f) + file_token = {k: b64decode_s(v) for k, v in file_token.items()} + # file_token = backend.tree_map(b64decode_s, file_token) + else: + file_token = {} + file_token.update(saved_token) + saved_token = file_token + else: # with token + if isinstance(provider, str): + provider = Provider.from_name(provider) + if device is None: + if provider is None: + provider = default_provider + added_token = {provider.name + sep: token} + else: + if provider is None: + provider = device.provider # type: ignore + if provider is None: + provider = default_provider + added_token = {provider.name + sep + device.name: token} # type: ignore + saved_token.update(added_token) + + if cached: + # file_token = backend.tree_map(b64encode_s, saved_token) + file_token = {k: b64encode_s(v) for k, v in saved_token.items()} + + with open(authpath, "w") as f: + json.dump(file_token, f) + + return saved_token + + +set_token() + + +def get_token( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, +) -> Optional[str]: + """ + Get API token setted for given provider or device, + if no device token saved, the corresponding provider tken is returned + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :return: _description_ + :rtype: Optional[str] + """ + if provider is None: + provider = get_provider() + provider = Provider.from_name(provider) + target = provider.name + sep + if device is not None: + device = Device.from_name(device, provider) + target = target + device.name + for k, v in saved_token.items(): + if k == target: + return v # type: ignore + return None + + +# token json structure +# {"tencent::": token1, "tencent::20xmon": token2} + + +def list_devices( + provider: Optional[Union[str, Provider]] = None, + token: Optional[str] = None, + **kws: Any, +) -> List[Device]: + """ + List all devices under a provider + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: _description_ + :rtype: Any + """ + if provider is None: + provider = default_provider + provider = Provider.from_name(provider) + if token is None: + token = provider.get_token() + if provider.name == "tencent": + return tencent.list_devices(token, **kws) # type: ignore + elif provider.name == "local": + return local.list_devices(token, **kws) + else: + raise ValueError("Unsupported provider: %s" % provider.name) + + +def list_properties( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + token: Optional[str] = None, +) -> Dict[str, Any]: + """ + List properties of a given device + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: Propeties dict + :rtype: Dict[str, Any] + """ + # if provider is not None and device is None: + # provider, device = None, provider + # if device is None: + # device = default_device + # device = Device.from_name(device, provider) + # if provider is None: + # provider = device.provider + provider, device = _preprocess(provider, device) + + if token is None: + token = device.get_token() # type: ignore + if provider.name == "tencent": # type: ignore + return tencent.list_properties(device, token) # type: ignore + elif provider.name == "local": + raise ValueError("Unsupported method for local backend") + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def get_task( + taskid: str, + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, +) -> Task: + """ + Get ``Task`` object from task string, the binding device can also be provided + + :param taskid: _description_ + :type taskid: str + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :return: _description_ + :rtype: Task + """ + if provider is not None and device is None: + provider, device = None, provider + if device is not None: # device can be None for identify tasks + device = Device.from_name(device, provider) + elif len(taskid.split(sep2)) > 1: + device = Device(taskid.split(sep2)[0]) + taskid = taskid.split(sep2)[1] + return Task(taskid, device=device) + + +def get_task_details( + taskid: Union[str, Task], token: Optional[str] = None, prettify: bool = False +) -> Dict[str, Any]: + """ + Get task details dict given task id + + :param taskid: _description_ + :type taskid: Union[str, Task] + :param token: _description_, defaults to None + :type token: Optional[str], optional + :param prettify: whether make the returned dict more readable and more phythonic, + defaults to False + :type prettify: bool + :return: _description_ + :rtype: Dict[str, Any] + """ + if isinstance(taskid, str): + task = Task(taskid) + else: + task = taskid + if task.device is not None: + device = task.device + else: + device = default_device + if token is None: + token = device.get_token() + provider = device.provider + + if provider.name == "tencent": + return tencent.get_task_details(task, device, token, prettify) # type: ignore + elif provider.name == "local": + return local.get_task_details(task, device, token, prettify) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def submit_task( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + token: Optional[str] = None, + **task_kws: Any, +) -> List[Task]: + """ + submit task to the cloud platform, batch submission default enabled + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :param token: _description_, defaults to None + :type token: Optional[str], optional + :param task_kws: all necessary keywords arguments for task submission, + see detailed API in each provider backend: + 1. tencent - :py:meth:`tensorcircuit.cloud.tencent.submit_task` + :type task_kws: Any + :return: The task object + :rtype: List[Task] + """ + # if device is None: + # device = get_device() + # if isinstance(device, str): + # if len(device.split(sep)) > 1: + # device = Device(device, provider) + # else: + # if provider is None: + # provider = get_provider() + # device = Device(device, provider) + # if provider is None: + # provider = device.provider + provider, device = _preprocess(provider, device) + + if token is None: + token = device.get_token() # type: ignore + + if provider.name == "tencent": # type: ignore + return tencent.submit_task(device, token, **task_kws) # type: ignore + elif provider.name == "local": # type: ignore + return local.submit_task(device, token, **task_kws) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def resubmit_task( + task: Optional[Union[str, Task]], + token: Optional[str] = None, +) -> Task: + """ + Rerun the given task + + :param task: _description_ + :type task: Optional[Union[str, Task]] + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: _description_ + :rtype: Task + """ + if isinstance(task, str): + task = Task(task) + device = task.get_device() # type: ignore + if token is None: + token = device.get_token() + provider = device.provider + + if provider.name == "tencent": # type: ignore + return tencent.resubmit_task(task, token) # type: ignore + elif provider.name == "local": + raise ValueError("Unsupported method for local backend") + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def remove_task( + task: Optional[Union[str, Task]], + token: Optional[str] = None, +) -> Task: + if isinstance(task, str): + task = Task(task) + device = task.get_device() # type: ignore + if token is None: + token = device.get_token() + provider = device.provider + + if provider.name == "tencent": # type: ignore + return tencent.remove_task(task, token) # type: ignore + elif provider.name == "local": + raise ValueError("Unsupported method for local backend") + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore + + +def list_tasks( + provider: Optional[Union[str, Provider]] = None, + device: Optional[Union[str, Device]] = None, + token: Optional[str] = None, + **filter_kws: Any, +) -> List[Task]: + """ + List tasks based on given filters + + :param provider: _description_, defaults to None + :type provider: Optional[Union[str, Provider]], optional + :param device: _description_, defaults to None + :type device: Optional[Union[str, Device]], optional + :param token: _description_, defaults to None + :type token: Optional[str], optional + :return: list of task object that satisfy these filter criteria + :rtype: List[Task] + """ + if provider is None: + provider = default_provider + provider = Provider.from_name(provider) + if token is None: + token = provider.get_token() # type: ignore + if device is not None: + device = Device.from_name(device) + if provider.name == "tencent": # type: ignore + return tencent.list_tasks(device, token, **filter_kws) # type: ignore + elif provider.name == "local": # type: ignore + return local.list_tasks(device, token, **filter_kws) # type: ignore + else: + raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/local.py b/tensorcircuit/cloud/local.py new file mode 100644 index 00000000..aa11681a --- /dev/null +++ b/tensorcircuit/cloud/local.py @@ -0,0 +1,75 @@ +""" +Cloud provider from local machine +""" + +from typing import Any, Dict, List, Optional, Union, Sequence +from uuid import uuid4 +import time + +from .abstraction import Device, sep, Task +from ..utils import is_sequence +from ..abstractcircuit import AbstractCircuit + +local_devices = ["testing"] + +task_list: Dict[str, Any] = {} # memory only task cache + + +def list_devices(token: Optional[str] = None, **kws: Any) -> List[Device]: + rs = [] + for d in local_devices: + rs.append(Device.from_name("local" + sep + d)) + return rs + + +def get_task_details( + task: Task, device: Device, token: str, prettify: bool +) -> Dict[str, Any]: + if task.id_ in task_list: + return task_list[task.id_] # type: ignore + raise ValueError("no task with id: %s" % task.id_) + + +def submit_task( + device: Device, + token: str, + shots: Union[int, Sequence[int]] = 1024, + version: str = "1", + circuit: Optional[Union[AbstractCircuit, Sequence[AbstractCircuit]]] = None, + **kws: Any +) -> List[Task]: + def _circuit2result(c: AbstractCircuit) -> Dict[str, Any]: + if device.name == "testing": + count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") # type: ignore + else: + raise ValueError("Unsupported device from local provider: %s" % device.name) + d = { + "id": str(uuid4()), + "state": "completed", + "at": time.time() * 1e6, + "shots": shots, + "device": device.name, + "results": count, + } + return d + + if is_sequence(circuit): + tl = [] + for c in circuit: # type: ignore + d = _circuit2result(c) + task_list[d["id"]] = d + tl.append(Task(id_=d["id"], device=device)) + return tl + else: + d = _circuit2result(circuit) # type: ignore + task_list[d["id"]] = d + + return Task(id_=d["id"], device=device) # type: ignore + + +def list_tasks(device: Device, token: str, **filter_kws: Any) -> List[Task]: + r = [] + for t, v in task_list.items(): + if (device is not None and v["device"] == device.name) or device is None: + r.append(Task(id_=t, device=Device.from_name("local" + sep + v["device"]))) + return r diff --git a/tensorcircuit/cloud/utils.py b/tensorcircuit/cloud/utils.py new file mode 100644 index 00000000..296e66df --- /dev/null +++ b/tensorcircuit/cloud/utils.py @@ -0,0 +1,120 @@ +""" +utility functions for cloud connection +""" +from typing import Any, Callable, Optional +from functools import wraps +import inspect +import logging +import os +import sys +import time + +import requests + +# from simplejson.errors import JSONDecodeError + +logger = logging.getLogger(__name__) +thismodule = sys.modules[__name__] + + +class HttpStatusError(Exception): + """ + Used when the return request has http code beyond 200 + """ + + pass + + +# TODO(@refraction-ray): whether an exception hierarchy for tc is necessary? +connection_errors = ( + ConnectionResetError, + HttpStatusError, + requests.exceptions.RequestException, + requests.exceptions.ConnectionError, + requests.exceptions.SSLError, + ValueError, + # JSONDecodeError, +) + + +def set_proxy(proxy: Optional[str] = None) -> None: + """ + :param proxy: str. format as "http://user:passwd@host:port" user passwd part can be omitted if not set. + None for turning off the proxy. + :return: + """ + if proxy: + os.environ["http_proxy"] = proxy + os.environ["https_proxy"] = proxy + setattr(thismodule, "proxy", proxy) + else: + os.environ["http_proxy"] = "" + os.environ["https_proxy"] = "" + setattr(thismodule, "proxy", None) + + +def reconnect(tries: int = 5, timeout: int = 12) -> Callable[..., Any]: + # wrapper originally designed in xalpha by @refraction-ray + # https://github.com/refraction-ray/xalpha + def robustify(f: Callable[..., Any]) -> Callable[..., Any]: + @wraps(f) + def wrapper(*args: Any, **kws: Any) -> Any: + if getattr(thismodule, "proxy", None): + kws["proxies"] = { + "http": getattr(thismodule, "proxy"), + "https": getattr(thismodule, "proxy"), + } + logger.debug("Using proxy %s" % getattr(thismodule, "proxy")) + kws["timeout"] = timeout + if args: + url = args[0] + else: + url = kws.get("url", "") + headers = kws.get("headers", {}) + if (not headers.get("user-agent", None)) and ( + not headers.get("User-Agent", None) + ): + headers["user-agent"] = "Mozilla/5.0" + kws["headers"] = headers + for count in range(tries): + try: + logger.debug( + "Fetching url: %s . Inside function `%s`" + % (url, inspect.stack()[1].function) + ) + r = f(*args, **kws) + if ( + getattr(r, "status_code", 200) != 200 + ): # in case r is a json dict + raise HttpStatusError + return r + except connection_errors as e: + logger.warning("Fails at fetching url: %s. Try again." % url) + if count == tries - 1: + logger.error( + "Still wrong at fetching url: %s. after %s tries." + % (url, tries) + ) + logger.error("Fails due to %s" % e.args[0]) + raise e + time.sleep(0.5 * count) + + return wrapper + + return robustify + + +rget = reconnect()(requests.get) +rpost = reconnect()(requests.post) + + +@reconnect() +def rget_json(*args: Any, **kws: Any) -> Any: + r = requests.get(*args, **kws) + return r.json() + + +@reconnect() +def rpost_json(*args: Any, **kws: Any) -> Any: + r = requests.post(*args, **kws) + return r.json() diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py new file mode 100644 index 00000000..2c8140a8 --- /dev/null +++ b/tensorcircuit/cloud/wrapper.py @@ -0,0 +1,185 @@ +""" +higher level wrapper shortcut for submit_task +""" +from typing import Any, Callable, Dict, List, Optional, Sequence, Union +import logging +import time + +import numpy as np + +from ..circuit import Circuit +from ..results import counts +from ..results.readout_mitigation import ReadoutMit +from ..utils import is_sequence +from ..cons import backend +from ..quantum import ps2xyz +from ..compiler.qiskit_compiler import qiskit_compile +from .apis import submit_task, get_device +from .abstraction import Device + + +logger = logging.getLogger(__name__) +Tensor = Any + + +def batch_submit_template(device: str) -> Callable[..., List[counts.ct]]: + # TODO(@refraction-ray): fixed when batch submission really works + def run(cs: Union[Circuit, Sequence[Circuit]], shots: int) -> List[counts.ct]: + """ + batch circuit running alternative + """ + single = False + if not is_sequence(cs): + cs = [cs] # type: ignore + single = True + ts = [] + # for c in cs: # type: ignore + # ts.append(submit_task(circuit=c, shots=shots, device=device)) + # time.sleep(0.3) + ts = submit_task(circuit=cs, shots=shots, device=device) + l = [t.results(blocked=True) for t in ts] # type: ignore + if single is False: + return l + return l[0] # type: ignore + + return run + + +def sample_expectation_ps( + c: Circuit, + x: Optional[Sequence[int]] = None, + y: Optional[Sequence[int]] = None, + z: Optional[Sequence[int]] = None, + shots: int = 1024, + device: Optional[Device] = None, + **kws: Any, +) -> float: + # deprecated + # TODO(@refraction-ray): integrated error mitigation + c1 = Circuit.from_qir(c.to_qir()) + if x is None: + x = [] + if y is None: + y = [] + if z is None: + z = [] + for i in x: + c1.H(i) # type: ignore + for i in y: + c1.rx(i, theta=np.pi / 2) # type: ignore + if device is None: + device = get_device() + t = submit_task(circuit=c1, device=device, shots=shots) + raw_counts = t.results(blocked=True) # type: ignore + x, y, z = list(x), list(y), list(z) + return counts.expectation(raw_counts, x + y + z) + + +def batch_expectation_ps( + c: Circuit, + pss: List[List[int]], + device: Any = None, + ws: Optional[List[float]] = None, + shots: int = 8192, + with_rem: bool = True, +) -> Union[Any, List[Any]]: + if device is None: + results = [] + for ps in pss: + results.append(c.expectation_ps(**ps2xyz(ps))) # type: ignore + if ws is None: + return backend.stack(results) + else: + return backend.sum([w * r for w, r in zip(ws, results)]) + cs = [] + infos = [] + exps = [] + if isinstance(device, str): + device = get_device(device) + for ps in pss: + # TODO(@refraction-ray): Pauli string grouping + c1 = Circuit.from_qir(c.to_qir()) + exp = [] + for j, i in enumerate(ps): + if i == 1: + c1.H(j) # type: ignore + exp.append(j) + elif i == 2: + c1.rx(j, theta=np.pi / 2) # type: ignore + exp.append(j) + elif i == 3: + exp.append(j) + c1, info = qiskit_compile( + c1, + compiled_options={ + "basis_gates": device.native_gates(), + "optimization_level": 3, + "coupling_map": device.topology(), + }, + ) + cs.append(c1) + infos.append(info) + exps.append(exp) + + reduced_cs = [] + reduced_dict = {} + recover_dict = {} + # merge the same circuit + for j, ps in enumerate(pss): + ps = [i if i in [1, 2] else 0 for i in ps] + if tuple(ps) not in reduced_dict: + reduced_dict[tuple(ps)] = [j] + reduced_cs.append(cs[j]) + recover_dict[tuple(ps)] = len(reduced_cs) - 1 + else: + reduced_dict[tuple(ps)].append(j) + + def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: + logger.info(f"submit task on {device.name} for {len(cs)} circuits") + time0 = time.time() + ts = submit_task( + circuit=cs, + device=device, + shots=shots, + enable_qos_qubit_mapping=False, + enable_qos_gate_decomposition=False, + ) + if not is_sequence(ts): + ts = [ts] # type: ignore + raw_counts = [t.results(blocked=True) for t in ts] + time1 = time.time() + logger.info( + f"finished collecting count results of {len(cs)} tasks in {round(time1-time0, 4)} seconds" + ) + return raw_counts + + reduced_raw_counts = run(reduced_cs, shots) + raw_counts: List[Dict[str, int]] = [None] * len(cs) # type: ignore + for i in range(len(cs)): + ps = [i if i in [1, 2] else 0 for i in pss[i]] + raw_counts[i] = reduced_raw_counts[recover_dict[tuple(ps)]] + + if with_rem: + if getattr(device, "readout_mit", None) is None: + mit = ReadoutMit(run) + # TODO(@refraction-ray) only work for tencent provider + nq = device.list_properties().get("qubits", None) + if nq is None: + nq = c._nqubits + mit.cals_from_system(nq, shots=shots) + device.readout_mit = mit + else: + mit = device.readout_mit + + results = [ + mit.expectation(raw_counts[i], exps[i], **infos[i]) + for i in range(len(raw_counts)) + ] + else: + results = [ + counts.expectation(raw_counts[i], exps[i]) for i in range(len(raw_counts)) + ] + if ws is not None: + sumr = sum([w * r for w, r in zip(ws, results)]) + return sumr + return results From a0debf2acf79d7d9529a89532ab0e66f1248c23b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 6 Mar 2023 19:32:22 +0800 Subject: [PATCH 360/725] add ref in readme --- README.md | 11 ++++++++--- README_cn.md | 11 ++++++++--- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 36ae3719..6cd46356 100644 --- a/README.md +++ b/README.md @@ -193,14 +193,19 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) ### DQAS For the application of Differentiable Quantum Architecture Search, see [applications](/tensorcircuit/applications). -Reference paper: https://arxiv.org/pdf/2010.08561.pdf. +Reference paper: https://arxiv.org/pdf/2010.08561.pdf (published in QST). ### VQNHE For the application of Variational Quantum-Neural Hybrid Eigensolver, see [applications](/tensorcircuit/applications). -Reference paper: https://arxiv.org/pdf/2106.05105.pdf and https://arxiv.org/pdf/2112.10380.pdf. +Reference paper: https://arxiv.org/pdf/2106.05105.pdf (published in PRL) and https://arxiv.org/pdf/2112.10380.pdf. ### VQEX - MBL For the application of VQEX on MBL phase identification, see the [tutorial](/docs/source/tutorials/vqex_mbl.ipynb). -Reference paper: https://arxiv.org/pdf/2111.13719.pdf. +Reference paper: https://arxiv.org/pdf/2111.13719.pdf (published in PRB). + +### Stark - DTC + +For the numerical demosntration of discrete time crystal enabled by Stark many-body localization, see the Floquet simulation [demo](/examples/timeevolution_trotter.py). +Reference paper: https://arxiv.org/pdf/2208.02866.pdf (published in PRL). diff --git a/README_cn.md b/README_cn.md index 777e866a..d22b37fd 100644 --- a/README_cn.md +++ b/README_cn.md @@ -138,14 +138,19 @@ pip install tensorcircuit-nightly ### DQAS 可微量子架构搜索的应用见 [应用](/tensorcircuit/applications)。 -参考论文：https://arxiv.org/pdf/2010.08561.pdf +参考论文：https://arxiv.org/pdf/2010.08561.pdf (QST)。 ### VQNHE 关于变分量子神经混合本征求解器的应用，请参见 [应用](tensorcircuit/applications)。 -参考论文：https://arxiv.org/pdf/2106.05105.pdf 和 https://arxiv.org/pdf/2112.10380.pdf 。 +参考论文：https://arxiv.org/pdf/2106.05105.pdf (PRL) 和 https://arxiv.org/pdf/2112.10380.pdf 。 ### VQEX - MBL VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mbl.ipynb)。 -参考论文: https://arxiv.org/pdf/2111.13719.pdf 。 +参考论文: https://arxiv.org/pdf/2111.13719.pdf (PRB)。 + +### Stark - DTC + +数值验证 Stark 多体局域化稳定的离散时间晶体，类似的 Floquet 系统模拟请参考 [例子](/examples/timeevolution_trotter.py). +参考论文: https://arxiv.org/pdf/2208.02866.pdf (PRL). From 579051c3ef6a2810796c83a8270e8bf513e8439c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 6 Mar 2023 19:40:27 +0800 Subject: [PATCH 361/725] update changelog --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e5083c01..80be2cbb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,7 +8,7 @@ - Add `get_positional_logical_mapping` circuit method to return the mapping when only part of the qubits are measured -- `results.rem.ReadoutMit` class now support three layers of abstriction on qubits: positional, logical, and physical +- `results.rem.ReadoutMit` class now support three layers of abstraction on qubits: positional, logical, and physical - Add an example script demonstrating how tc can use external contraction path finder wirtten in Julia @@ -34,7 +34,7 @@ ### Fixed -- Circuit nosify in noise model now support all circuit attributs apart from qubit number +- Circuit nosify in noise model now support all circuit attributes apart from qubit number - Some string warnings are fixed by using r-string From da7f32dff3ad5375b04fc44fb156d808d87010fc Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 7 Mar 2023 13:11:37 +0800 Subject: [PATCH 362/725] fix general kraus zero prob error --- tensorcircuit/circuit.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index 04df94b2..c6f456a9 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -549,8 +549,9 @@ def calculate_kraus_p(i: int) -> Tensor: return backend.real(norm_square) prob = [calculate_kraus_p(i) for i in range(len(kraus))] + eps = 1e-10 new_kraus = [ - k / backend.cast(backend.sqrt(w), dtypestr) + k / backend.cast(backend.sqrt(w) + eps, dtypestr) for w, k in zip(prob, kraus_tensor) ] From d13a81e49c0fe24fdc9d4a7b4eae03b19b5df056 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 7 Mar 2023 13:13:39 +0800 Subject: [PATCH 363/725] add mipt examples --- examples/mipt.py | 83 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 examples/mipt.py diff --git a/examples/mipt.py b/examples/mipt.py new file mode 100644 index 00000000..ba43d98e --- /dev/null +++ b/examples/mipt.py @@ -0,0 +1,83 @@ +""" +demo example of mipt in tc style +""" +from functools import partial +import time +import numpy as np +from scipy import stats +import tensorcircuit as tc + +K = tc.set_backend("jax") +# tf backend is slow (at least on cpu) + + +@partial(K.jit, static_argnums=(2, 3, 4)) +def circuit_output(random_matrix, status, n, d, p): + """ + mipt circuit + + :param random_matrix: a float or complex tensor containing 4*4 random haar matrix wth size [d*n, 4, 4] + :type random_matrix: _type_ + :param status: a int tensor with element in 0 or 1 or 2 (no meausrement) with size d*n + :type status: _type_ + :param n: number of qubits + :type n: _type_ + :param d: number of depth + :type d: _type_ + :param p: measurement ratio + :type p: float + :return: output state + """ + random_matrix = K.reshape(random_matrix, [d, n, 4, 4]) + status = K.reshape(status, [d, n]) + inputs = None + for j in range(d): + if inputs is None: + c = tc.Circuit(n) + else: + c = tc.Circuit(n, inputs=inputs) + for i in range(0, n, 2): + c.unitary(i, (i + 1) % n, unitary=random_matrix[j, i]) + for i in range(1, n, 2): + c.unitary(i, (i + 1) % n, unitary=random_matrix[j, i]) + inputs = c.state() + c = tc.Circuit(n, inputs=inputs) + for i in range(n): + c.general_kraus( + [ + np.sqrt(p) * np.array([[1.0, 0], [0, 0]]), + np.sqrt(p) * np.array([[0, 0], [0, 1.0]]), + np.sqrt(1 - p) * np.eye(2), + ], + i, + status=status[j, i], + ) + inputs = c.state() + c = tc.Circuit(n, inputs=inputs) + inputs = c.state() + inputs /= K.norm(inputs) + return inputs + + +@partial(K.jit, static_argnums=(2, 3, 4)) +def cals(random_matrix, status, n, d, p): + state = circuit_output(random_matrix, status, n, d, p) + rho = tc.quantum.reduced_density_matrix(state, cut=[i for i in range(n // 2)]) + return tc.quantum.entropy(rho), tc.quantum.renyi_entropy(rho, k=2) + + +if __name__ == "__main__": + n = 12 + d = 12 + st = np.random.uniform(size=[d * n]) + ## assume all X gate instead + rm = [stats.unitary_group.rvs(4) for _ in range(d * n)] + rm = [r / np.linalg.det(r) for r in rm] + rm = np.stack(rm) + time0 = time.time() + print(cals(rm, st, n, d, 0.1)) + time1 = time.time() + st = np.random.uniform(size=[d * n]) + print(cals(rm, st, n, d, 0.1)) + time2 = time.time() + print(f"compiling time {time1-time0}, running time {time2-time1}") From 15c240a42ee71e3f1d1f171c11d26d18941f2235 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Mar 2023 17:05:36 +0800 Subject: [PATCH 364/725] add general kraus simulation v2 example --- examples/mcnoise_boost_v2.py | 84 ++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 examples/mcnoise_boost_v2.py diff --git a/examples/mcnoise_boost_v2.py b/examples/mcnoise_boost_v2.py new file mode 100644 index 00000000..19b8e25a --- /dev/null +++ b/examples/mcnoise_boost_v2.py @@ -0,0 +1,84 @@ +""" +Boost the Monte Carlo noise simulation (specifically the staging time) +on general error with circuit layerwise slicing: new paradigm, +essentially the same as v1, but much simpler +""" + +import time +import sys + +sys.path.insert(0, "../") +import tensorcircuit as tc + +tc.set_backend("jax") + +n = 6 # 10 +nlayer = 5 # 4 + + +def precompute(c): + s = c.state() + return tc.Circuit(c._nqubits, inputs=s) + + +def f1(key, param, n, nlayer): + if key is not None: + tc.backend.set_random_state(key) + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayer): + for i in range(n - 1): + c.cnot(i, i + 1) + c.apply_general_kraus(tc.channels.phasedampingchannel(0.15), i) + c.apply_general_kraus(tc.channels.phasedampingchannel(0.15), i + 1) + for i in range(n): + c.rx(i, theta=param[j, i]) + return tc.backend.real(c.expectation((tc.gates.z(), [int(n / 2)]))) + + +def f2(key, param, n, nlayer): + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayer): + for i in range(n - 1): + c.cnot(i, i + 1) + c = precompute(c) + c.apply_general_kraus(tc.channels.phasedampingchannel(0.15), i) + c = precompute(c) + c.apply_general_kraus(tc.channels.phasedampingchannel(0.15), i + 1) + for i in range(n): + c.rx(i, theta=param[j, i]) + return tc.backend.real(c.expectation((tc.gates.z(), [int(n / 2)]))) + + +vagf1 = tc.backend.jit(tc.backend.value_and_grad(f1, argnums=1), static_argnums=(2, 3)) +vagf2 = tc.backend.jit(tc.backend.value_and_grad(f2, argnums=1), static_argnums=(2, 3)) + +param = tc.backend.ones([nlayer, n]) + + +def benchmark(f, tries=3): + time0 = time.time() + key = tc.backend.get_random_state(42) + print(f(key, param, n, nlayer)[0]) + time1 = time.time() + for _ in range(tries): + print(f(key, param, n, nlayer)[0]) + time2 = time.time() + print( + "staging time: ", + time1 - time0, + "running time: ", + (time2 - time1) / tries, + ) + + +print("without layerwise slicing jit") +benchmark(vagf1) +print("=============================") +print("with layerwise slicing jit") +benchmark(vagf2) + +# mac16 intel cpu: (6*5, jax) 1015, 0.0035; 31.68, 0.00082 From 7a63d6b8bc0ab9fbfc8d4fdcadb44d43109604ea Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Mar 2023 17:09:52 +0800 Subject: [PATCH 365/725] add tests --- tests/test_cloud.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_cloud.py b/tests/test_cloud.py index aa36ecad..dc0a5c0f 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -83,7 +83,7 @@ def test_resubmit_task(): time.sleep(15) t1 = apis.resubmit_task(t) print(t.details()) - print(t1.details()) + print(t1.details(wait=True)) def test_get_task(): From fda069f78a163b165f1ee1d8a9f68b0bc13b5dc0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 8 Mar 2023 17:10:08 +0800 Subject: [PATCH 366/725] add wait alias --- tensorcircuit/cloud/abstraction.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 4c588553..1c0e3f62 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -319,6 +319,7 @@ def get_device(self) -> Device: else: return Device.from_name(self.device) + @partial(arg_alias, alias_dict={"blocked": ["wait"]}) def details(self, blocked: bool = False, **kws: Any) -> Dict[str, Any]: """ Get the current task details @@ -369,11 +370,11 @@ def resubmit(self) -> "Task": return resubmit_task(self) - @partial(arg_alias, alias_dict={"format": ["format_"]}) + @partial(arg_alias, alias_dict={"format": ["format_"], "blocked": ["wait"]}) def results( self, format: Optional[str] = None, - blocked: bool = False, + blocked: bool = True, mitigated: bool = False, calibriation_options: Optional[Dict[str, Any]] = None, readout_mit: Optional[rem.ReadoutMit] = None, From 6be5941eda43adb2636719e6bf02c16ae8a26881 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 10 Mar 2023 14:30:26 +0800 Subject: [PATCH 367/725] update tests --- tests/test_cloud.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_cloud.py b/tests/test_cloud.py index dc0a5c0f..1d8219e9 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -73,6 +73,7 @@ def test_submit_task(): r = t.details() assert r["state"] in ["pending", "completed"] print(t.results(blocked=True)) + assert t.get_logical_physical_mapping() == {0: 0, 1: 1, 2: 2} def test_resubmit_task(): From 9bf106dd2329d697472b1e2ffa74a7a15ac71fc0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 10 Mar 2023 14:30:50 +0800 Subject: [PATCH 368/725] add get_logical_physical_mapping --- tensorcircuit/cloud/abstraction.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index 1c0e3f62..f3ed5aff 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -342,7 +342,18 @@ def details(self, blocked: bool = False, **kws: Any) -> Dict[str, Any]: time.sleep(0.5 + tries / 10) tries += 1 s = self.state() - return self.details(**kws) + return self.details(**kws) # type: ignore + + def get_logical_physical_mapping(self) -> Optional[Dict[int, int]]: + d = self.details() + try: + mp = d["optimization"]["pairs"] + except KeyError: + if "qubits" in d and isinstance(d["qubits"], int): + mp = {i: i for i in range(d["qubits"])} + else: + mp = None + return mp # type: ignore def add_details(self, **kws: Any) -> None: self.more_details.update(kws) From 4e14e0cdbfdc4f9f8bdf870bbfcb10dae23b8538 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 10 Mar 2023 16:31:22 +0800 Subject: [PATCH 369/725] fix entropy singular behavior --- tensorcircuit/quantum.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index e21d856d..0b2c1527 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1518,6 +1518,7 @@ def entanglement2(param, n, nlayers): :return: Entropy on the given density matrix. :rtype: Tensor """ + rho += eps * backend.cast(backend.eye(rho.shape[-1]), rho.dtype) # type: ignore lbd = backend.real(backend.eigh(rho)[0]) lbd = backend.relu(lbd) # we need the matrix anyway for AD. From 1a0792ab996c56581d254a554f5dfb732a236006 Mon Sep 17 00:00:00 2001 From: liwt31 Date: Wed, 15 Mar 2023 10:20:19 +0800 Subject: [PATCH 370/725] add cupy backend --- tensorcircuit/backends/backend_factory.py | 6 + tensorcircuit/backends/cupy_backend.py | 468 ++++++++++++++++++++++ 2 files changed, 474 insertions(+) create mode 100644 tensorcircuit/backends/cupy_backend.py diff --git a/tensorcircuit/backends/backend_factory.py b/tensorcircuit/backends/backend_factory.py index ca5f71a7..c665a76c 100644 --- a/tensorcircuit/backends/backend_factory.py +++ b/tensorcircuit/backends/backend_factory.py @@ -4,6 +4,8 @@ from typing import Any, Dict, Text, Union +import tensornetwork as tn + try: # old version tn compatiblity from tensornetwork.backends import base_backend @@ -18,6 +20,7 @@ from .jax_backend import JaxBackend from .tensorflow_backend import TensorFlowBackend from .pytorch_backend import PyTorchBackend +from .cupy_backend import CuPyBackend bk = Any # tnbackend @@ -26,8 +29,11 @@ "jax": JaxBackend, "tensorflow": TensorFlowBackend, "pytorch": PyTorchBackend, # no intention to fully maintain this one + "cupy": CuPyBackend, # no intention to fully maintain this one } +tn.backends.backend_factory._BACKENDS["cupy"] = CuPyBackend + _INSTANTIATED_BACKENDS: Dict[str, bk] = dict() diff --git a/tensorcircuit/backends/cupy_backend.py b/tensorcircuit/backends/cupy_backend.py new file mode 100644 index 00000000..3ae9c5b9 --- /dev/null +++ b/tensorcircuit/backends/cupy_backend.py @@ -0,0 +1,468 @@ +""" +CuPy backend. Not in the tensornetwork package and highly experimental. +""" +# pylint: disable=invalid-name + +import logging +import warnings +from typing import Any, Callable, Optional, Sequence, Tuple, Union + +import numpy as np + +try: # old version tn compatiblity + from tensornetwork.backends import base_backend + + tnbackend = base_backend.BaseBackend + +except ImportError: + from tensornetwork.backends import abstract_backend + + tnbackend = abstract_backend.AbstractBackend + + +from .abstract_backend import ExtendedBackend + +logger = logging.getLogger(__name__) + +dtypestr: str +Tensor = Any + +cp: Any +cpx: Any + + +class CuPyBackend(tnbackend, ExtendedBackend): # type: ignore + def __init__(self) -> None: + super().__init__() + try: + import cupy + import cupyx + except ImportError: + raise ImportError( + "CuPy not installed, please switch to a different " + "backend or install CuPy." + ) + global cp + global cpx + cp = cupy + cpx = cupyx + self.name = "cupy" + + def convert_to_tensor(self, a: Tensor) -> Tensor: + if not isinstance(a, cp.ndarray) and not cp.isscalar(a): + a = cp.array(a) + a = cp.asarray(a) + return a + + def sum( + self: Any, + a: Tensor, + axis: Optional[Sequence[int]] = None, + keepdims: bool = False, + ) -> Tensor: + return cp.sum(a, axis=axis, keepdims=keepdims) + + def shape_tuple(self, tensor: Tensor) -> Tuple[int]: + return tensor.shape # type:ignore + + def tensordot( + self, a: Tensor, b: Tensor, axes: Union[int, Sequence[Sequence[int]]] + ) -> Tensor: + return cp.tensordot(a, b, axes) + + def outer_product(self, tensor1: Tensor, tensor2: Tensor) -> Tensor: + return cp.tensordot(tensor1, tensor2, 0) + + def transpose(self, tensor: Tensor, perm: Optional[Sequence[int]] = None) -> Tensor: + return cp.transpose(tensor, perm) + + def reshape(self, tensor: Tensor, shape: Tensor) -> Tensor: + return cp.reshape(tensor, np.asarray(shape).astype(np.int32)) + + def eye( + self, N: int, dtype: Optional[str] = None, M: Optional[int] = None + ) -> Tensor: + if dtype is None: + dtype = dtypestr + return cp.eye(N, M=M, dtype=dtype) + + def ones(self, shape: Sequence[int], dtype: Optional[str] = None) -> Tensor: + if dtype is None: + dtype = dtypestr + return cp.ones(shape, dtype=dtype) + + def zeros(self, shape: Sequence[int], dtype: Optional[str] = None) -> Tensor: + if dtype is None: + dtype = dtypestr + return cp.zeros(shape, dtype=dtype) + + def copy(self, a: Tensor) -> Tensor: + return a.copy() + + def expm(self, a: Tensor) -> Tensor: + raise NotImplementedError + + def abs(self, a: Tensor) -> Tensor: + return cp.abs(a) + + def sin(self, a: Tensor) -> Tensor: + return cp.sin(a) + + def cos(self, a: Tensor) -> Tensor: + return cp.cos(a) + + # acos acosh asin asinh atan atan2 atanh cosh (cos) tan tanh sinh (sin) + def acos(self, a: Tensor) -> Tensor: + return cp.arccos(a) + + def acosh(self, a: Tensor) -> Tensor: + return cp.arccosh(a) + + def asin(self, a: Tensor) -> Tensor: + return cp.arcsin(a) + + def asinh(self, a: Tensor) -> Tensor: + return cp.arcsinh(a) + + def atan(self, a: Tensor) -> Tensor: + return cp.arctan(a) + + def atan2(self, y: Tensor, x: Tensor) -> Tensor: + return cp.arctan2(y, x) + + def atanh(self, a: Tensor) -> Tensor: + return cp.arctanh(a) + + def cosh(self, a: Tensor) -> Tensor: + return cp.cosh(a) + + def tan(self, a: Tensor) -> Tensor: + return cp.tan(a) + + def tanh(self, a: Tensor) -> Tensor: + return cp.tanh(a) + + def sinh(self, a: Tensor) -> Tensor: + return cp.sinh(a) + + def size(self, a: Tensor) -> Tensor: + return a.size + + def eigvalsh(self, a: Tensor) -> Tensor: + return cp.linalg.eigvalsh(a) + + def kron(self, a: Tensor, b: Tensor) -> Tensor: + return cp.kron(a, b) + + def dtype(self, a: Tensor) -> str: + return a.dtype.__str__() # type: ignore + + def numpy(self, a: Tensor) -> Tensor: + if isinstance(a, cp.ndarray): + return a.get() + else: + return np.array(a) + + def i(self, dtype: Any = None) -> Tensor: + if not dtype: + dtype = npdtype # type: ignore + if isinstance(dtype, str): + dtype = getattr(np, dtype) + return cp.array(1j, dtype=dtype) + + def stack(self, a: Sequence[Tensor], axis: int = 0) -> Tensor: + return cp.stack(a, axis=axis) + + def concat(self, a: Sequence[Tensor], axis: int = 0) -> Tensor: + return cp.concatenate(a, axis=axis) + + def tile(self, a: Tensor, rep: Tensor) -> Tensor: + return cp.tile(a, rep) + + def mean( + self, + a: Tensor, + axis: Optional[Sequence[int]] = None, + keepdims: bool = False, + ) -> Tensor: + return cp.mean(a, axis=axis, keepdims=keepdims) + + def std( + self, a: Tensor, axis: Optional[Sequence[int]] = None, keepdims: bool = False + ) -> Tensor: + return cp.std(a, axis=axis, keepdims=keepdims) + + def unique_with_counts(self, a: Tensor, **kws: Any) -> Tuple[Tensor, Tensor]: + return cp.unique(a, return_counts=True) # type: ignore + + def min(self, a: Tensor, axis: Optional[int] = None) -> Tensor: + return cp.min(a, axis=axis) + + def max(self, a: Tensor, axis: Optional[int] = None) -> Tensor: + return cp.max(a, axis=axis) + + def argmax(self, a: Tensor, axis: int = 0) -> Tensor: + return cp.argmax(a, axis=axis) + + def argmin(self, a: Tensor, axis: int = 0) -> Tensor: + return cp.argmin(a, axis=axis) + + def sigmoid(self, a: Tensor) -> Tensor: + return cpx.scipy.special.expit(a) + + def relu(self, a: Tensor) -> Tensor: + return (abs(a) + a) / 2 + # this impl seems to be the fastest + # see https://stackoverflow.com/questions/32109319/how-to-implement-the-relu-function-in-numpy + + def softmax(self, a: Sequence[Tensor], axis: Optional[int] = None) -> Tensor: + return cpx.scipy.special.softmax(a, axis=axis) + + def onehot(self, a: Tensor, num: int) -> Tensor: + res = cp.eye(num)[a.reshape([-1])] + return res.reshape(list(a.shape) + [num]) + # https://stackoverflow.com/questions/38592324/one-hot-encoding-using-numpy + + def cumsum(self, a: Tensor, axis: Optional[int] = None) -> Tensor: + return cp.cumsum(a, axis) + + def is_tensor(self, a: Any) -> bool: + if isinstance(a, cp.ndarray): + return True + return False + + def real(self, a: Tensor) -> Tensor: + return cp.real(a) + + def imag(self, a: Tensor) -> Tensor: + return cp.imag(a) + + def cast(self, a: Tensor, dtype: str) -> Tensor: + with warnings.catch_warnings(): + warnings.simplefilter("ignore", np.ComplexWarning) + if isinstance(dtype, str): + return a.astype(getattr(np, dtype)) + return a.astype(dtype) + + def arange(self, start: int, stop: Optional[int] = None, step: int = 1) -> Tensor: + if stop is None: + return cp.arange(start=0, stop=start, step=step) + return cp.arange(start=start, stop=stop, step=step) + + def mod(self, x: Tensor, y: Tensor) -> Tensor: + return cp.mod(x, y) + + def right_shift(self, x: Tensor, y: Tensor) -> Tensor: + return cp.right_shift(x, y) + + def left_shift(self, x: Tensor, y: Tensor) -> Tensor: + return cp.left_shift(x, y) + + def solve(self, A: Tensor, b: Tensor, assume_a: str = "gen") -> Tensor: # type: ignore + raise NotImplementedError + + def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: + return cp.searchsorted(a, v, side=side) # type: ignore + + def set_random_state( + self, seed: Optional[int] = None, get_only: bool = False + ) -> Any: + g = cp.random.default_rng(seed) # None auto supported + if get_only is False: + self.g = g + return g + + def stateful_randn( + self, + g: "cp.random.Generator", + shape: Union[int, Sequence[int]] = 1, + mean: float = 0, + stddev: float = 1, + dtype: str = "32", + ) -> Tensor: + if isinstance(dtype, str): + dtype = dtype[-2:] + if isinstance(shape, int): + shape = (shape,) + r = g.normal(loc=mean, scale=stddev, size=shape) + if dtype == "32": + r = r.astype(np.float32) + elif dtype == "64": + r = r.astype(np.float64) + elif not isinstance(dtype, str): + r = r.astype(dtype) + else: + raise ValueError("unspported `dtype` %s" % dtype) + return r + + def stateful_randu( + self, + g: "cp.random.Generator", + shape: Union[int, Sequence[int]] = 1, + low: float = 0, + high: float = 1, + dtype: str = "32", + ) -> Tensor: + if isinstance(dtype, str): + dtype = dtype[-2:] + if isinstance(shape, int): + shape = (shape,) + r = g.uniform(low=low, high=high, size=shape) + if dtype == "32": + r = r.astype(np.float32) + elif dtype == "64": + r = r.astype(np.float64) + elif not isinstance(dtype, str): + r = r.astype(dtype) + else: + raise ValueError("unspported `dtype` %s" % dtype) + return r + + def stateful_randc( + self, + g: "cp.random.Generator", + a: Union[int, Sequence[int], Tensor], + shape: Union[int, Sequence[int]], + p: Optional[Union[Sequence[float], Tensor]] = None, + ) -> Tensor: + if isinstance(shape, int): + shape = (shape,) + return g.choice(a, size=shape, replace=True, p=p) + + def scatter(self, operand: Tensor, indices: Tensor, updates: Tensor) -> Tensor: + operand_new = cp.copy(operand) + operand_new[tuple([indices[:, i] for i in range(indices.shape[1])])] = updates + return operand_new + + def coo_sparse_matrix( + self, indices: Tensor, values: Tensor, shape: Tensor + ) -> Tensor: + values = self.convert_to_tensor(values) + indices = self.convert_to_tensor(indices).T + return cp.sparse.coo_matrix((values, indices), shape=shape) + + def sparse_dense_matmul( + self, + sp_a: Tensor, + b: Tensor, + ) -> Tensor: + return sp_a @ b + + def to_dense(self, sp_a: Tensor) -> Tensor: + return sp_a.todense() + + def is_sparse(self, a: Tensor) -> bool: + return cpx.scipy.sparse.issparse(a) # type: ignore + + def cond( + self, + pred: bool, + true_fun: Callable[[], Tensor], + false_fun: Callable[[], Tensor], + ) -> Tensor: + if pred: + return true_fun() + return false_fun() + + def switch(self, index: Tensor, branches: Sequence[Callable[[], Tensor]]) -> Tensor: + return branches[index]() + + def device(self, a: Tensor) -> str: + return "gpu" + + def device_move(self, a: Tensor, dev: Any) -> Tensor: + if dev == "gpu": + return a + raise ValueError("CuPy backend only support GPU device") + + def _dev2str(self, dev: Any) -> str: + if dev == "gpu": + return "gpu" + raise ValueError("CuPy backend only support GPU device") + + def _str2dev(self, str_: str) -> Any: + if str_ == "gpu": + return "gpu" + raise ValueError("CuPy backend only support GPU device") + + def stop_gradient(self, a: Tensor) -> Tensor: + raise NotImplementedError("CuPy backend doesn't support AD") + + def grad( + self, + f: Callable[..., Any], + argnums: Union[int, Sequence[int]] = 0, + has_aux: bool = False, + ) -> Callable[..., Any]: + raise NotImplementedError("CuPy backend doesn't support AD") + + def value_and_grad( + self, + f: Callable[..., Any], + argnums: Union[int, Sequence[int]] = 0, + has_aux: bool = False, + ) -> Callable[..., Tuple[Any, Any]]: + raise NotImplementedError("CuPy backend doesn't support AD") + + def jit( + self, + f: Callable[..., Any], + static_argnums: Optional[Union[int, Sequence[int]]] = None, + jit_compile: Optional[bool] = None, + ) -> Callable[..., Any]: + logger.warning("CuPy backend has no jit interface, just do nothing") + return f + # raise NotImplementedError("numpy backend doesn't support jit compiling") + + def vmap( + self, f: Callable[..., Any], vectorized_argnums: Union[int, Sequence[int]] = 0 + ) -> Any: + logger.warning( + "CuPy backend has no intrinsic vmap like interface" + ", use vectorize instead (plain for loop)" + ) + if isinstance(vectorized_argnums, int): + vectorized_argnums = (vectorized_argnums,) + + def wrapper(*args: Any, **kws: Any) -> Tensor: + results = [] + for barg in zip(*[args[i] for i in vectorized_argnums]): # type: ignore + narg = [] + j = 0 + for k in range(len(args)): + if k in vectorized_argnums: # type: ignore + narg.append(barg[j]) + j += 1 + else: + narg.append(args[k]) + results.append(f(*narg, **kws)) + return cp.array(results) + + return wrapper + + def vectorized_value_and_grad( + self, + f: Callable[..., Any], + argnums: Union[int, Sequence[int]] = 0, + vectorized_argnums: Union[int, Sequence[int]] = 0, + has_aux: bool = False, + ) -> Callable[..., Tuple[Any, Any]]: + raise NotImplementedError("CuPy backend doesn't support AD") + + vvag = vectorized_value_and_grad + + def vjp( + self, + f: Callable[..., Any], + inputs: Union[Tensor, Sequence[Tensor]], + v: Union[Tensor, Sequence[Tensor]], + ) -> Tuple[Union[Tensor, Sequence[Tensor]], Union[Tensor, Sequence[Tensor]]]: + raise NotImplementedError("CuPy backend doesn't support AD") + + def jvp( + self, + f: Callable[..., Any], + inputs: Union[Tensor, Sequence[Tensor]], + v: Union[Tensor, Sequence[Tensor]], + ) -> Tuple[Union[Tensor, Sequence[Tensor]], Union[Tensor, Sequence[Tensor]]]: + raise NotImplementedError("CuPy backend doesn't support AD") From 99b04c867485bfa46097fc12dc8b40d241144cb5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 15 Mar 2023 20:32:19 +0800 Subject: [PATCH 371/725] add cloud pip option --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index 84be50d3..6495eed6 100644 --- a/setup.py +++ b/setup.py @@ -23,6 +23,7 @@ "jax": ["jax", "jaxlib"], "torch": ["torch"], "qiskit": ["qiskit"], + "cloud": ["qiskit", "mthree"], }, classifiers=[ "Programming Language :: Python :: 3", From f44564a4010db57747c64a3e281084164d07ed8d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 17 Mar 2023 15:01:06 +0800 Subject: [PATCH 372/725] add bo on qaoa example --- docs/source/tutorials/qaoa_bo.ipynb | 314 ++++++++++++++++++++++++++++ 1 file changed, 314 insertions(+) create mode 100644 docs/source/tutorials/qaoa_bo.ipynb diff --git a/docs/source/tutorials/qaoa_bo.ipynb b/docs/source/tutorials/qaoa_bo.ipynb new file mode 100644 index 00000000..cd6e97e4 --- /dev/null +++ b/docs/source/tutorials/qaoa_bo.ipynb @@ -0,0 +1,314 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Optimizing QAOA using BO" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Setup" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "import tensorcircuit as tc\n", + "import tensorflow as tf\n", + "import cotengra as ctg\n", + "import optax\n", + "import networkx as nx\n", + "import time\n", + "import numpy as np\n", + "import torch\n", + "import os\n", + "\n", + "K = tc.set_backend(\"tensorflow\")" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## QAOA blackbox" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "source": [ + "# Generate a graph\n", + "def dict2graph(d):\n", + " g = nx.to_networkx_graph(d)\n", + " for e in g.edges:\n", + " if not g[e[0]][e[1]].get(\"weight\"):\n", + " g[e[0]][e[1]][\"weight\"] = 1.0\n", + " nx.draw(g, with_labels=True)\n", + " return g\n", + "\n", + "\n", + "# a graph instance\n", + "example_graph_dict = {\n", + " 0: {1: {\"weight\": 0.9}, 7: {\"weight\": 0.4}, 3: {\"weight\": 0.38}},\n", + " 1: {0: {\"weight\": 0.44}, 2: {\"weight\": 0.67}, 3: {\"weight\": 0.62}},\n", + " 2: {1: {\"weight\": 0.21}, 3: {\"weight\": 0.87}, 5: {\"weight\": 0.72}},\n", + " 4: {7: {\"weight\": 0.34}, 6: {\"weight\": 0.53}, 5: {\"weight\": 0.45}},\n", + " 7: {4: {\"weight\": 0.45}, 6: {\"weight\": 0.63}, 0: {\"weight\": 0.59}},\n", + " 3: {1: {\"weight\": 0.12}, 2: {\"weight\": 0.21}, 0: {\"weight\": 0.68}},\n", + " 6: {7: {\"weight\": 0.34}, 4: {\"weight\": 0.33}, 5: {\"weight\": 0.96}},\n", + " 5: {6: {\"weight\": 0.18}, 4: {\"weight\": 0.79}, 2: {\"weight\": 0.17}},\n", + "}\n", + "\n", + "example_graph = dict2graph(example_graph_dict)" + ], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "

" + ], + "image/png": "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" + }, + "metadata": {} + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "def QAOAansatz(params, g=example_graph):\n", + " n = len(g.nodes) # the number of nodes\n", + " c = tc.Circuit(n)\n", + " for i in range(n):\n", + " c.H(i)\n", + " # PQC\n", + " for j in range(nlayers):\n", + " # U_j\n", + " for e in g.edges:\n", + " c.exp1(\n", + " e[0],\n", + " e[1],\n", + " unitary=tc.gates._zz_matrix,\n", + " theta=g[e[0]][e[1]].get(\"weight\", 1.0) * params[2 * j],\n", + " )\n", + " # V_j\n", + " for i in range(n):\n", + " c.rx(i, theta=params[2 * j + 1])\n", + "\n", + " # calculate the loss function\n", + " loss = 0.0\n", + " for e in g.edges:\n", + " loss += g[e[0]][e[1]].get(\"weight\") * c.expectation_ps(z=[e[0], e[1]])\n", + "\n", + " return K.real(loss)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Using BO optimizer from ODBO\n" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "import odbo\n", + "\n", + "# BO settings\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "dtype = torch.float\n", + "batch_size = 1\n", + "acqfn = \"ucb\"\n", + "\n", + "QAOA_nograd = K.jit(QAOAansatz)\n", + "\n", + "\n", + "def eval_objective(x, example_graph):\n", + " \"\"\"This is a helper function we use to unnormalize and evalaute a point\"\"\"\n", + " a = tf.convert_to_tensor(np.array(x).ravel())\n", + " return -QAOA_nograd(a, example_graph).numpy()\n", + "\n", + "\n", + "X_new = np.random.uniform(low=0, high=1, size=[1, 2 * nlayers])\n", + "X_bo = torch.tensor(np.vstack([initial_X, X_new]))\n", + "Y_bo = torch.tensor(\n", + " [eval_objective(x, example_graph) for x in X_bo], dtype=dtype, device=device\n", + ").unsqueeze(-1)" + ], + "outputs": [], + "metadata": { + "scrolled": false + } + }, + { + "cell_type": "code", + "execution_count": 6, + "source": [ + "# BO Optimizer\n", + "for i in range(100): # run 100 iter optimizations\n", + " X_next, acq_value, ids = odbo.run_exp.bo_design(\n", + " X=X_bo,\n", + " Y=Y_bo,\n", + " batch_size=batch_size,\n", + " acqfn=acqfn,\n", + " normalize=False,\n", + " verbose=False,\n", + " )\n", + " X_next = torch.reshape(X_next, [batch_size, 2 * nlayers])\n", + " Y_next = torch.tensor(\n", + " [eval_objective(x, example_graph) for x in X_next], dtype=dtype, device=device\n", + " )\n", + " # Update training set\n", + " X_bo = torch.cat((X_bo, X_next), dim=0)\n", + " Y_bo = torch.cat((Y_bo, Y_next.unsqueeze(-1)), dim=0)\n", + " print(f\"{i+1}) New loss: {-Y_next.item(): .4e} Best loss: {-Y_bo.max():.4e}\")" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1) New loss: 1.3437e+00 Best loss: 1.2106e+00\n", + "2) New loss: 8.7936e-01 Best loss: 8.7936e-01\n", + "3) New loss: 7.1789e-01 Best loss: 7.1789e-01\n", + "4) New loss: 6.1326e-01 Best loss: 6.1326e-01\n", + "5) New loss: 5.8545e-01 Best loss: 5.8545e-01\n", + "6) New loss: 2.7606e-01 Best loss: 2.7606e-01\n", + "7) New loss: 1.7849e-02 Best loss: 1.7849e-02\n", + "8) New loss: -1.1042e-01 Best loss: -1.1042e-01\n", + "9) New loss: -1.1939e-01 Best loss: -1.1939e-01\n", + "10) New loss: -2.5096e-01 Best loss: -2.5096e-01\n", + "11) New loss: -5.6989e-01 Best loss: -5.6989e-01\n", + "12) New loss: -7.5698e-01 Best loss: -7.5698e-01\n", + "13) New loss: -8.6725e-01 Best loss: -8.6725e-01\n", + "14) New loss: -9.1735e-01 Best loss: -9.1735e-01\n", + "15) New loss: -9.2709e-01 Best loss: -9.2709e-01\n", + "16) New loss: -9.3580e-01 Best loss: -9.3580e-01\n", + "17) New loss: -9.1267e-01 Best loss: -9.3580e-01\n", + "18) New loss: -9.4420e-01 Best loss: -9.4420e-01\n", + "19) New loss: -9.4391e-01 Best loss: -9.4420e-01\n", + "20) New loss: -9.5668e-01 Best loss: -9.5668e-01\n", + "21) New loss: -9.7023e-01 Best loss: -9.7023e-01\n", + "22) New loss: -9.7753e-01 Best loss: -9.7753e-01\n", + "23) New loss: -9.7975e-01 Best loss: -9.7975e-01\n", + "24) New loss: -9.8380e-01 Best loss: -9.8380e-01\n", + "25) New loss: -9.8546e-01 Best loss: -9.8546e-01\n", + "26) New loss: -9.8754e-01 Best loss: -9.8754e-01\n", + "27) New loss: -9.8786e-01 Best loss: -9.8786e-01\n", + "28) New loss: -9.8514e-01 Best loss: -9.8786e-01\n", + "29) New loss: -9.9017e-01 Best loss: -9.9017e-01\n", + "30) New loss: -9.9235e-01 Best loss: -9.9235e-01\n", + "31) New loss: -9.9391e-01 Best loss: -9.9391e-01\n", + "32) New loss: -9.9355e-01 Best loss: -9.9391e-01\n", + "33) New loss: -9.8973e-01 Best loss: -9.9391e-01\n", + "34) New loss: -9.9798e-01 Best loss: -9.9798e-01\n", + "35) New loss: -1.0005e+00 Best loss: -1.0005e+00\n", + "36) New loss: -1.0021e+00 Best loss: -1.0021e+00\n", + "37) New loss: -1.0029e+00 Best loss: -1.0029e+00\n", + "38) New loss: -1.0029e+00 Best loss: -1.0029e+00\n", + "39) New loss: -1.0022e+00 Best loss: -1.0029e+00\n", + "40) New loss: -1.0034e+00 Best loss: -1.0034e+00\n", + "41) New loss: -1.0037e+00 Best loss: -1.0037e+00\n", + "42) New loss: -1.0035e+00 Best loss: -1.0037e+00\n", + "43) New loss: -1.0037e+00 Best loss: -1.0037e+00\n", + "44) New loss: -1.0036e+00 Best loss: -1.0037e+00\n", + "45) New loss: -1.0035e+00 Best loss: -1.0037e+00\n", + "46) New loss: -1.0033e+00 Best loss: -1.0037e+00\n", + "47) New loss: -1.0033e+00 Best loss: -1.0037e+00\n", + "48) New loss: -1.0036e+00 Best loss: -1.0037e+00\n", + "49) New loss: -1.0041e+00 Best loss: -1.0041e+00\n", + "50) New loss: -1.0035e+00 Best loss: -1.0041e+00\n", + "51) New loss: -1.0044e+00 Best loss: -1.0044e+00\n", + "52) New loss: -1.0044e+00 Best loss: -1.0044e+00\n", + "53) New loss: -1.0044e+00 Best loss: -1.0044e+00\n", + "54) New loss: -1.0045e+00 Best loss: -1.0045e+00\n", + "55) New loss: -1.0043e+00 Best loss: -1.0045e+00\n", + "56) New loss: -1.0046e+00 Best loss: -1.0046e+00\n", + "57) New loss: -1.0043e+00 Best loss: -1.0046e+00\n", + "58) New loss: -1.0045e+00 Best loss: -1.0046e+00\n", + "59) New loss: -1.0042e+00 Best loss: -1.0046e+00\n", + "60) New loss: -1.0045e+00 Best loss: -1.0046e+00\n", + "61) New loss: -1.0042e+00 Best loss: -1.0046e+00\n", + "62) New loss: -1.0047e+00 Best loss: -1.0047e+00\n", + "63) New loss: -1.0047e+00 Best loss: -1.0047e+00\n", + "64) New loss: -1.0048e+00 Best loss: -1.0048e+00\n", + "65) New loss: -1.0045e+00 Best loss: -1.0048e+00\n", + "66) New loss: -1.0047e+00 Best loss: -1.0048e+00\n", + "67) New loss: -1.0045e+00 Best loss: -1.0048e+00\n", + "68) New loss: -1.0045e+00 Best loss: -1.0048e+00\n", + "69) New loss: -1.0049e+00 Best loss: -1.0049e+00\n", + "70) New loss: -1.0049e+00 Best loss: -1.0049e+00\n", + "71) New loss: -1.0049e+00 Best loss: -1.0049e+00\n", + "72) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "73) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", + "74) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", + "75) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", + "76) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "77) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "78) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "79) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "80) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "81) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "82) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", + "83) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "84) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", + "85) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "86) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "87) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", + "88) New loss: -1.0051e+00 Best loss: -1.0051e+00\n", + "89) New loss: -1.0051e+00 Best loss: -1.0051e+00\n", + "90) New loss: -1.0051e+00 Best loss: -1.0051e+00\n", + "91) New loss: -1.0052e+00 Best loss: -1.0052e+00\n", + "92) New loss: -1.0050e+00 Best loss: -1.0052e+00\n", + "93) New loss: -1.0052e+00 Best loss: -1.0052e+00\n", + "94) New loss: -1.0050e+00 Best loss: -1.0052e+00\n", + "95) New loss: -1.0049e+00 Best loss: -1.0052e+00\n", + "96) New loss: -1.0051e+00 Best loss: -1.0052e+00\n", + "97) New loss: -1.0051e+00 Best loss: -1.0052e+00\n", + "98) New loss: -1.0051e+00 Best loss: -1.0052e+00\n", + "99) New loss: -1.0052e+00 Best loss: -1.0052e+00\n", + "100) New loss: -1.0051e+00 Best loss: -1.0052e+00\n" + ] + } + ], + "metadata": { + "scrolled": false + } + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From e1fc0614af59d93010916a05f467a6192d889d24 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 17 Mar 2023 16:16:46 +0800 Subject: [PATCH 373/725] dc sum for paulis2coo --- CHANGELOG.md | 2 ++ tensorcircuit/quantum.py | 42 ++++++++++++++++++++++++++++++---------- 2 files changed, 34 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 80be2cbb..f1f09eb4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -32,6 +32,8 @@ - Add `templates.ensemble.bagging` module for bagging ensemble method +- The speed of Pauli string sum Hamiltonian generation is improved by a divide-and-conquer sum + ### Fixed - Circuit nosify in noise model now support all circuit attributes apart from qubit number diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 0b2c1527..ab837c7f 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1333,25 +1333,47 @@ def PauliStringSum2COO( # numpy version is 3* faster! nterms = len(ls) - n = len(ls[0]) - s = 0b1 << n + # n = len(ls[0]) + # s = 0b1 << n if weight is None: weight = [1.0 for _ in range(nterms)] if not (isinstance(weight, tf.Tensor) or isinstance(weight, tf.Variable)): weight = tf.constant(weight, dtype=getattr(tf, dtypestr)) - rsparse = get_backend("numpy").coo_sparse_matrix( - indices=np.array([[0, 0]], dtype=np.int64), - values=np.array([0.0], dtype=getattr(np, dtypestr)), - shape=(s, s), - ) - for i in range(nterms): - rsparse += get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore - # auto transformed into csr format!! + # rsparse = get_backend("numpy").coo_sparse_matrix( + # indices=np.array([[0, 0]], dtype=np.int64), + # values=np.array([0.0], dtype=getattr(np, dtypestr)), + # shape=(s, s), + # ) + rsparses = [ + get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore + for i in range(nterms) + ] + rsparse = _dc_sum(rsparses) + # auto transformed into csr format!! + + # for i in range(nterms): + # rsparse += get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore rsparse = rsparse.tocoo() if numpy: return rsparse return backend.coo_sparse_matrix_from_numpy(rsparse) + def _dc_sum(l: List[Any]) -> Any: + """ + For the sparse sum, the speed is determined by the non zero terms, + so the DC way to do the sum can indeed bring some speed advantage (several times) + + :param l: _description_ + :type l: List[Any] + :return: _description_ + :rtype: Any + """ + n = len(l) + if n > 2: + return _dc_sum(l[: n // 2]) + _dc_sum(l[n // 2 :]) + else: + return sum(l) + PauliStringSum2COO_numpy = partial(PauliStringSum2COO, numpy=True) def PauliStringSum2COO_tf( From 06005c13e0746d5cc80e8b4cda27c4676c97b2d6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 27 Mar 2023 20:30:19 +0800 Subject: [PATCH 374/725] add quafu provider --- tensorcircuit/cloud/abstraction.py | 2 +- tensorcircuit/cloud/apis.py | 18 ++++-- tensorcircuit/cloud/quafu_provider.py | 84 +++++++++++++++++++++++++++ 3 files changed, 99 insertions(+), 5 deletions(-) create mode 100644 tensorcircuit/cloud/quafu_provider.py diff --git a/tensorcircuit/cloud/abstraction.py b/tensorcircuit/cloud/abstraction.py index f3ed5aff..b94e2a69 100644 --- a/tensorcircuit/cloud/abstraction.py +++ b/tensorcircuit/cloud/abstraction.py @@ -116,7 +116,7 @@ def __init__( self, name: str, provider: Optional[Union[str, Provider]] = None, - lower: bool = True, + lower: bool = False, ): if lower is True: name = name.lower() diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index d656d07c..7ebb20d6 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -10,20 +10,26 @@ import sys import logging +from .abstraction import Provider, Device, Task, sep, sep2 + logger = logging.getLogger(__name__) -from .abstraction import Provider, Device, Task, sep, sep2 try: from . import tencent # type: ignore -except ImportError as e: +except (ImportError, ModuleNotFoundError): logger.warning("fail to load cloud provider module: tencent") try: from . import local -except ImportError as e: +except (ImportError, ModuleNotFoundError): logger.warning("fail to load cloud provider module: local") +try: + from . import quafu_provider +except (ImportError, ModuleNotFoundError): + logger.warning("fail to load cloud provider module: quafu") + package_name = "tensorcircuit" thismodule = sys.modules[__name__] @@ -385,6 +391,9 @@ def get_task_details( return tencent.get_task_details(task, device, token, prettify) # type: ignore elif provider.name == "local": return local.get_task_details(task, device, token, prettify) # type: ignore + elif provider.name == "quafu": + return quafu_provider.get_task_details(task, device, token, prettify) # type: ignore + else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore @@ -426,11 +435,12 @@ def submit_task( if token is None: token = device.get_token() # type: ignore - if provider.name == "tencent": # type: ignore return tencent.submit_task(device, token, **task_kws) # type: ignore elif provider.name == "local": # type: ignore return local.submit_task(device, token, **task_kws) # type: ignore + elif provider.name == "quafu": # type: ignore + return quafu_provider.submit_task(device, token, **task_kws) # type: ignore else: raise ValueError("Unsupported provider: %s" % provider.name) # type: ignore diff --git a/tensorcircuit/cloud/quafu_provider.py b/tensorcircuit/cloud/quafu_provider.py new file mode 100644 index 00000000..a852b905 --- /dev/null +++ b/tensorcircuit/cloud/quafu_provider.py @@ -0,0 +1,84 @@ +""" +Cloud provider from QuaFu: http://quafu.baqis.ac.cn/ +""" + +from typing import Any, Dict, List, Optional, Sequence, Union +import logging + +from quafu import User, QuantumCircuit +from quafu import Task as Task_ + +from .abstraction import Device, sep, Task +from ..abstractcircuit import AbstractCircuit + +logger = logging.getLogger(__name__) + + +def list_devices(token: Optional[str] = None, **kws: Any) -> List[Device]: + raise NotImplementedError + + +def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, Any]: + raise NotImplementedError + + +def submit_task( + device: Device, + token: str, + shots: Union[int, Sequence[int]] = 1024, + circuit: Optional[Union[AbstractCircuit, Sequence[AbstractCircuit]]] = None, + source: Optional[Union[str, Sequence[str]]] = None, + compile: bool = True, + **kws: Any +) -> Task: + if source is None: + + def c2qasm(c: Any) -> str: + from qiskit.circuit import QuantumCircuit + + if isinstance(c, QuantumCircuit): + s = c.qasm() + # nq = c.num_qubits + else: + s = c.to_openqasm() + return s # type: ignore + + source = c2qasm(circuit) + user = User() + user.save_apitoken(token) + nq = int(source.split("\n")[2].split("[")[1].split("]")[0]) # type: ignore + qc = QuantumCircuit(nq) + qc.from_openqasm(source) + task = Task_() + device_name = device.name.split(sep)[-1] + task.config(backend=device_name, shots=shots, compile=compile) + res = task.send(qc, wait=False) + wrapper = Task(res.taskid, device=device) + return wrapper + + +def resubmit_task(task: Task, token: str) -> Task: + raise NotImplementedError + + +def remove_task(task: Task, token: str) -> Any: + raise NotImplementedError + + +def list_tasks(device: Device, token: str, **filter_kws: Any) -> List[Task]: + raise NotImplementedError + + +def get_task_details( + task: Task, device: Device, token: str, prettify: bool +) -> Dict[str, Any]: + # id results + r = {} + r["id"] = task.id_ + t = Task_() + r["results"] = dict(t.retrieve(task.id_).counts) # type: ignore + if r["results"]: + r["state"] = "completed" + else: + r["state"] = "pending" + return r From 8538e7ac8442244197c62418619308890aa79d25 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 28 Mar 2023 12:17:25 +0800 Subject: [PATCH 375/725] version0.8.0 --- CHANGELOG.md | 2 ++ tensorcircuit/__init__.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index f1f09eb4..6d892c2b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.8.0 + ### Added - Add `initial_mapping` circuit method to return a new circuit with given `logical_physical_mapping` diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 2119e20f..f9a2da2c 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.7.0" +__version__ = "0.8.0" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From a85d14368943cd6e0063284e8e0ef77e898a6d8e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 28 Mar 2023 14:12:21 +0800 Subject: [PATCH 376/725] update dockerfiles --- .dockerignore | 4 +++- docker/Dockerfile | 2 +- requirements/requirements-docker.txt | 8 +++++--- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/.dockerignore b/.dockerignore index b470a6f7..be657f84 100644 --- a/.dockerignore +++ b/.dockerignore @@ -12,4 +12,6 @@ **/*.outdated **/*.result **/*.results -**/*.data \ No newline at end of file +**/*.data +**/*.egg-info +**/*examples-ng \ No newline at end of file diff --git a/docker/Dockerfile b/docker/Dockerfile index aba5d7df..718fbc2c 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -33,7 +33,7 @@ COPY requirements/requirements-docker.txt /app/requirements-docker.txt RUN pip install -r /app/requirements-docker.txt -RUN pip install jaxlib==0.3.2+cuda11.cudnn805 -f https://storage.googleapis.com/jax-releases/jax_releases.html +RUN pip install jaxlib==0.3.2+cuda11.cudnn805 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html RUN pip install -U git+https://github.com/jcmgray/cotengra.git diff --git a/requirements/requirements-docker.txt b/requirements/requirements-docker.txt index c3195c12..41186706 100644 --- a/requirements/requirements-docker.txt +++ b/requirements/requirements-docker.txt @@ -21,8 +21,12 @@ qiskit openfermion quimb openfermionpyscf +pennylane +# tensorflow_quantum==0.6.1 +mthree +mitiq # below is for development -mypy==0.782 +mypy==0.982 pytest pytest-cov pytest-benchmark @@ -36,5 +40,3 @@ nbsphinx furo myst-parser pylint -pennylane -tensorflow_quantum==0.6.1 \ No newline at end of file From 24c88a20100e8b9f072996bc1c577837a4dfce8c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 28 Mar 2023 16:11:24 +0800 Subject: [PATCH 377/725] add clear token option --- tensorcircuit/cloud/apis.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 7ebb20d6..d6495dd0 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -178,6 +178,7 @@ def set_token( provider: Optional[Union[str, Provider]] = None, device: Optional[Union[str, Device]] = None, cached: bool = True, + clear: bool = False, ) -> Dict[str, Any]: """ Set API token for given provider or specifically to given device @@ -190,6 +191,8 @@ def set_token( :type device: Optional[Union[str, Device]], optional :param cached: whether save on the disk, defaults to True :type cached: bool, optional + :param clear: if True, clear all token saved, defaults to False + :type clear: bool, optional :return: _description_ :rtype: Dict[str, Any] """ @@ -197,7 +200,8 @@ def set_token( homedir = os.path.expanduser("~") authpath = os.path.join(homedir, ".tc.auth.json") # provider, device = _preprocess(provider, device) - + if clear is True: + saved_token = {} if token is None: if cached and os.path.exists(authpath): with open(authpath, "r") as f: @@ -216,6 +220,7 @@ def set_token( provider = default_provider added_token = {provider.name + sep: token} else: + device = Device.from_name(device) if provider is None: provider = device.provider # type: ignore if provider is None: From 1f2856d87acd1878c57f476d451f39da855b4bae Mon Sep 17 00:00:00 2001 From: WiuYuan <108848998+WiuYuan@users.noreply.github.com> Date: Fri, 7 Apr 2023 13:41:52 +0800 Subject: [PATCH 378/725] Create quantun_variation YuanWen's quantum variation in quantum simulation --- examples/quantun_variation | 208 +++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 examples/quantun_variation diff --git a/examples/quantun_variation b/examples/quantun_variation new file mode 100644 index 00000000..47ef7d79 --- /dev/null +++ b/examples/quantun_variation @@ -0,0 +1,208 @@ +from scipy.linalg import expm +import numpy as np + +#solve expm error +A=[[1, 0], [0, 1]]; A = np.array(A); expm(-1j * A) + +import inspect +import tensorcircuit as tc +import random +import math +import matplotlib.pyplot as plt +import time + +tc.set_backend("tensorflow") + +#calculate the matirx of kth qubit exert matrix[[a, b], [c, d]] +def up_to_matrixx(k, a, b, c, d): + I2 = np.array([[1,0],[0,1]])*(1+0j); K=np.array([[a,b],[c,d]])*(1+0j); um=I2; + if k == 0: + um = K; + for i in range(1, N): + if i == k: + um = np.kron(um, K) + else: + um = np.kron(um, I2) + return um + +#realize R gates in paper +def R_gate(k): + if door[k][0] == 0: + c.rx(door[k][1]+1,theta=ODE_theta[k]) + if door[k][0] == 1: + c.ry(door[k][1]+1,theta=ODE_theta[k]) + if door[k][0] == 2: + c.rz(door[k][1]+1,theta=ODE_theta[k]) + if door[k][0] == 3: + c.rxx(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) + if door[k][0] == 4: + c.ryy(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) + if door[k][0] == 5: + c.rzz(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) + if door[k][0] == 6: + c.crx(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) + if door[k][0] == 7: + c.cry(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) + if door[k][0] == 8: + c.crz(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) + +#realize U gates in paper +def U_gate(k): + if door[k][0] == 0: + c.cx(0,door[k][1]+1) + if door[k][0] == 1: + c.cy(0,door[k][1]+1) + if door[k][0] == 2: + c.cz(0,door[k][1]+1) + if door[k][0] == 3: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0],unitary=tc.gates._xx_matrix) + if door[k][0] == 4: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0],unitary=tc.gates._yy_matrix) + if door[k][0] == 5: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0],unitary=tc.gates._zz_matrix) + if door[k][0] == 6: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._xx_matrix) + if door[k][0] == 7: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._yy_matrix) + if door[k][0] == 8: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._zz_matrix) + +#realize Hamilton gates in ancillary circuit +def H_gate(q): + if h_door[q][0] == 0: + c.cx(0,h_door[q][1]+1) + if h_door[q][0] == 1: + c.cy(0,h_door[q][1]+1) + if h_door[q][0] == 2: + c.cz(0,h_door[q][1]+1) + if h_door[q][0] == 3: + c.multicontrol(0,h_door[q][1]+1,h_door[q][2]+1,ctrl=[0],unitary=tc.gates._xx_matrix) + if h_door[q][0] == 4: + c.multicontrol(0,h_door[q][1]+1,h_door[q][2]+1,ctrl=[0],unitary=tc.gates._yy_matrix) + if h_door[q][0] == 5: + c.multicontrol(0,h_door[q][1]+1,h_door[q][2]+1,ctrl=[0],unitary=tc.gates._zz_matrix) + if h_door[q][0] == 6: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._xx_matrix) + if h_door[q][0] == 7: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._yy_matrix) + if h_door[q][0] == 8: + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._zz_matrix) + +#use quantum circuit to calculate coefficient of variation A and C in paper +def find_ACkq(mod, theta_x, k, q, whi): + #mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C + global c + ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) + c = tc.Circuit(N+1,inputs = np.kron(ancilla, state)) + for i in range(len(door)): + if i == k: + c.x(0) + U_gate(i) + c.x(0) + if whi == 0 and i == q: + U_gate(i) + R_gate(i) + break + R_gate(i) + if whi == 1: + H_gate(q) + pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) + return mod * (2 * pstar - 1) + +#use original quantum circuit simulate with c +def simulation(): + global c + c=tc.Circuit(N,inputs=state) + for k in range(len(door)): + if door[k][0]==0: + c.rx(door[k][1],theta=ODE_theta[k]) + if door[k][0]==1: + c.ry(door[k][1],theta=ODE_theta[k]) + if door[k][0]==2: + c.rz(door[k][1],theta=ODE_theta[k]) + if door[k][0]==3: + c.rxx(door[k][1],door[k][2],theta=ODE_theta[k]) + if door[k][0]==4: + c.ryy(door[k][1],door[k][2],theta=ODE_theta[k]) + if door[k][0]==5: + c.rzz(door[k][1],door[k][2],theta=ODE_theta[k]) + +if __name__ == '__main__': + + #l: layers; h and J: coefficient of Hamilton; L_var and L_num: results of variation method and numerical method + N=3; l=2; J=1/4; dt=0.05; t=1; h=[]; L_var=[]; L_num=[]; x_value=[]; + + how_variation = 0 #0 McLachlan 1 time-dependent + + #the priciple correspond with all gates + #the first term: 0rx,1ry,2rz,3rxx,4ryy,5rzz,6crx,7cry,8crz; + #the second and the third term: num/ctrl+num + #f: coefficient with simulation gates in paper + door = []; h_door = []; f = [] + for k in range(l): + for i in range(N): + f.append(-0.5j) + door.append([0, i]) + for i in range(N - 1): + f.append(-1j) + door.append([5, i, i + 1]) + for i in range(N - 1): + f.append(-1j) + door.append([3, i, i + 1]) + for i in range(N): + h.append(1) + h_door.append([0, i]) + for i in range(N-1): + h.append(J); h_door.append([5, i, i + 1]) + + #initial state + state = np.zeros(1 << N); state[0]=1 + + #numerical realize H + H = np.zeros((1< q: + A[k, q] = A[q, k] + continue + if how_variation == 0: + A[k, q] = find_ACkq(abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]), k, q, 0) + if how_variation == 1: + A[k, q] = find_ACkq(abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]) - math.pi / 2, k, q, 0) + for k in range(len(door)): + for q in range(len(h)): + if how_variation == 0: + C[k] += find_ACkq(abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]) - math.pi / 2, k, q, 1) + if how_variation == 1: + C[k] += find_ACkq(-abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]), k, q, 1) + + #calculate parameter and its derivative + A += np.eye(len(door)) * 1e-5 + ODE_dtheta = np.linalg.solve(A, C) + print(ODE_dtheta) + for i in range(len(door)): + ODE_theta[i] += ODE_dtheta[i] * dt + + #numerical results + simulation() + ep = expm(-1j * H * (T + 1) * dt) @ state + L_num.append(np.real(np.array(ep.conj().T @ up_to_matrixx(1, 0, 1, 1, 0) @ ep)).tolist()) + + #variation results + L_var.append(np.real(np.array(c.expectation([tc.gates.x(), [1]]))).tolist()) + + x_value.append((T + 1) * dt) + print([(T + 1) * dt, L_num[T] - L_var[T]]) + plt.plot(x_value, L_var, color = 'green') + plt.plot(x_value, L_num, color = 'red') + plt.show() From 4a1faea3dd08724415bee1b0f9e757ebdc40d03d Mon Sep 17 00:00:00 2001 From: WiuYuan <108848998+WiuYuan@users.noreply.github.com> Date: Fri, 7 Apr 2023 15:42:50 +0800 Subject: [PATCH 379/725] Update and rename quantun_variation to quantum_variation --- .../{quantun_variation => quantum_variation} | 131 +++++++++++------- 1 file changed, 84 insertions(+), 47 deletions(-) rename examples/{quantun_variation => quantum_variation} (63%) diff --git a/examples/quantun_variation b/examples/quantum_variation similarity index 63% rename from examples/quantun_variation rename to examples/quantum_variation index 47ef7d79..6bdf6e23 100644 --- a/examples/quantun_variation +++ b/examples/quantum_variation @@ -1,9 +1,5 @@ from scipy.linalg import expm import numpy as np - -#solve expm error -A=[[1, 0], [0, 1]]; A = np.array(A); expm(-1j * A) - import inspect import tensorcircuit as tc import random @@ -15,9 +11,11 @@ tc.set_backend("tensorflow") #calculate the matirx of kth qubit exert matrix[[a, b], [c, d]] def up_to_matrixx(k, a, b, c, d): - I2 = np.array([[1,0],[0,1]])*(1+0j); K=np.array([[a,b],[c,d]])*(1+0j); um=I2; + I2 = np.array([[1, 0], [0, 1]]) * (1 + 0j) + K = np.array([[a, b], [c, d]]) * (1 + 0j) + um = I2 if k == 0: - um = K; + um = K for i in range(1, N): if i == k: um = np.kron(um, K) @@ -26,7 +24,7 @@ def up_to_matrixx(k, a, b, c, d): return um #realize R gates in paper -def R_gate(k): +def R_gate(k, c): if door[k][0] == 0: c.rx(door[k][1]+1,theta=ODE_theta[k]) if door[k][0] == 1: @@ -47,7 +45,7 @@ def R_gate(k): c.crz(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) #realize U gates in paper -def U_gate(k): +def U_gate(k, c): if door[k][0] == 0: c.cx(0,door[k][1]+1) if door[k][0] == 1: @@ -61,14 +59,14 @@ def U_gate(k): if door[k][0] == 5: c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0],unitary=tc.gates._zz_matrix) if door[k][0] == 6: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._xx_matrix) + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._x_matrix) if door[k][0] == 7: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._yy_matrix) + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._y_matrix) if door[k][0] == 8: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._zz_matrix) + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._z_matrix) #realize Hamilton gates in ancillary circuit -def H_gate(q): +def H_gate(q, c): if h_door[q][0] == 0: c.cx(0,h_door[q][1]+1) if h_door[q][0] == 1: @@ -82,36 +80,46 @@ def H_gate(q): if h_door[q][0] == 5: c.multicontrol(0,h_door[q][1]+1,h_door[q][2]+1,ctrl=[0],unitary=tc.gates._zz_matrix) if h_door[q][0] == 6: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._xx_matrix) + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._x_matrix) if h_door[q][0] == 7: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._yy_matrix) + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._y_matrix) if h_door[q][0] == 8: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._zz_matrix) + c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._z_matrix) #use quantum circuit to calculate coefficient of variation A and C in paper -def find_ACkq(mod, theta_x, k, q, whi): +def Calculation_A(mod, theta_x, k, q): #mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C - global c ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) c = tc.Circuit(N+1,inputs = np.kron(ancilla, state)) for i in range(len(door)): if i == k: c.x(0) - U_gate(i) + U_gate(i, c) c.x(0) - if whi == 0 and i == q: - U_gate(i) - R_gate(i) + if i == q: + U_gate(i, c) + R_gate(i, c) break - R_gate(i) - if whi == 1: - H_gate(q) + R_gate(i, c) + pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) + return mod * (2 * pstar - 1) + +def Calculation_C(mod, theta_x, k, q): + #mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C + ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) + c = tc.Circuit(N+1,inputs = np.kron(ancilla, state)) + for i in range(len(door)): + if i == k: + c.x(0) + U_gate(i, c) + c.x(0) + R_gate(i, c) + H_gate(q, c) pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) return mod * (2 * pstar - 1) #use original quantum circuit simulate with c def simulation(): - global c c=tc.Circuit(N,inputs=state) for k in range(len(door)): if door[k][0]==0: @@ -120,17 +128,32 @@ def simulation(): c.ry(door[k][1],theta=ODE_theta[k]) if door[k][0]==2: c.rz(door[k][1],theta=ODE_theta[k]) - if door[k][0]==3: - c.rxx(door[k][1],door[k][2],theta=ODE_theta[k]) - if door[k][0]==4: - c.ryy(door[k][1],door[k][2],theta=ODE_theta[k]) - if door[k][0]==5: - c.rzz(door[k][1],door[k][2],theta=ODE_theta[k]) + if door[k][0] == 3: + c.multicontrol(0,door[k][1],door[k][2],ctrl=[0],unitary=tc.gates._xx_matrix) + if door[k][0] == 4: + c.multicontrol(0,door[k][1],door[k][2],ctrl=[0],unitary=tc.gates._yy_matrix) + if door[k][0] == 5: + c.multicontrol(0,door[k][1],door[k][2],ctrl=[0],unitary=tc.gates._zz_matrix) + if door[k][0] == 6: + c.multicontrol(0,door[k][1],door[k][2],ctrl=[0,door[k][1]],unitary=tc.gates._x_matrix) + if door[k][0] == 7: + c.multicontrol(0,door[k][1],door[k][2],ctrl=[0,door[k][1]],unitary=tc.gates._y_matrix) + if door[k][0] == 8: + c.multicontrol(0,door[k][1],door[k][2],ctrl=[0,door[k][1]],unitary=tc.gates._z_matrix) + return c if __name__ == '__main__': #l: layers; h and J: coefficient of Hamilton; L_var and L_num: results of variation method and numerical method - N=3; l=2; J=1/4; dt=0.05; t=1; h=[]; L_var=[]; L_num=[]; x_value=[]; + N = 3 + l = 2 + J = 1/4 + dt = 0.05 + t = 1 + h = [] + L_var = [] + L_num = [] + x_value = [] how_variation = 0 #0 McLachlan 1 time-dependent @@ -138,7 +161,9 @@ if __name__ == '__main__': #the first term: 0rx,1ry,2rz,3rxx,4ryy,5rzz,6crx,7cry,8crz; #the second and the third term: num/ctrl+num #f: coefficient with simulation gates in paper - door = []; h_door = []; f = [] + door = [] + h_door = [] + f = [] for k in range(l): for i in range(N): f.append(-0.5j) @@ -152,39 +177,51 @@ if __name__ == '__main__': for i in range(N): h.append(1) h_door.append([0, i]) - for i in range(N-1): - h.append(J); h_door.append([5, i, i + 1]) + for i in range(N - 1): + h.append(J) + h_door.append([5, i, i + 1]) #initial state - state = np.zeros(1 << N); state[0]=1 + state = np.zeros(1 << N) + state[0] = 1 #numerical realize H - H = np.zeros((1< q: A[k, q] = A[q, k] continue if how_variation == 0: - A[k, q] = find_ACkq(abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]), k, q, 0) + A[k, q] = Calculation_A(abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]), k, q) if how_variation == 1: - A[k, q] = find_ACkq(abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]) - math.pi / 2, k, q, 0) + A[k, q] = Calculation_A(abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]) - math.pi / 2, k, q) for k in range(len(door)): for q in range(len(h)): if how_variation == 0: - C[k] += find_ACkq(abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]) - math.pi / 2, k, q, 1) + C[k] += Calculation_C(abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]) - math.pi / 2, k, q) if how_variation == 1: - C[k] += find_ACkq(-abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]), k, q, 1) + C[k] += Calculation_C(-abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]), k, q) #calculate parameter and its derivative A += np.eye(len(door)) * 1e-5 @@ -194,7 +231,7 @@ if __name__ == '__main__': ODE_theta[i] += ODE_dtheta[i] * dt #numerical results - simulation() + c = simulation() ep = expm(-1j * H * (T + 1) * dt) @ state L_num.append(np.real(np.array(ep.conj().T @ up_to_matrixx(1, 0, 1, 1, 0) @ ep)).tolist()) From 57f3b35164bc377064e31467a4fd49afabcfe924 Mon Sep 17 00:00:00 2001 From: WiuYuan <108848998+WiuYuan@users.noreply.github.com> Date: Fri, 7 Apr 2023 16:24:08 +0800 Subject: [PATCH 380/725] Update and rename quantum_variation to quantum_variation.py --- examples/quantum_variation | 245 ------------------------- examples/quantum_variation.py | 327 ++++++++++++++++++++++++++++++++++ 2 files changed, 327 insertions(+), 245 deletions(-) delete mode 100644 examples/quantum_variation create mode 100644 examples/quantum_variation.py diff --git a/examples/quantum_variation b/examples/quantum_variation deleted file mode 100644 index 6bdf6e23..00000000 --- a/examples/quantum_variation +++ /dev/null @@ -1,245 +0,0 @@ -from scipy.linalg import expm -import numpy as np -import inspect -import tensorcircuit as tc -import random -import math -import matplotlib.pyplot as plt -import time - -tc.set_backend("tensorflow") - -#calculate the matirx of kth qubit exert matrix[[a, b], [c, d]] -def up_to_matrixx(k, a, b, c, d): - I2 = np.array([[1, 0], [0, 1]]) * (1 + 0j) - K = np.array([[a, b], [c, d]]) * (1 + 0j) - um = I2 - if k == 0: - um = K - for i in range(1, N): - if i == k: - um = np.kron(um, K) - else: - um = np.kron(um, I2) - return um - -#realize R gates in paper -def R_gate(k, c): - if door[k][0] == 0: - c.rx(door[k][1]+1,theta=ODE_theta[k]) - if door[k][0] == 1: - c.ry(door[k][1]+1,theta=ODE_theta[k]) - if door[k][0] == 2: - c.rz(door[k][1]+1,theta=ODE_theta[k]) - if door[k][0] == 3: - c.rxx(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) - if door[k][0] == 4: - c.ryy(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) - if door[k][0] == 5: - c.rzz(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) - if door[k][0] == 6: - c.crx(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) - if door[k][0] == 7: - c.cry(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) - if door[k][0] == 8: - c.crz(door[k][1]+1,door[k][2]+1,theta=ODE_theta[k]) - -#realize U gates in paper -def U_gate(k, c): - if door[k][0] == 0: - c.cx(0,door[k][1]+1) - if door[k][0] == 1: - c.cy(0,door[k][1]+1) - if door[k][0] == 2: - c.cz(0,door[k][1]+1) - if door[k][0] == 3: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0],unitary=tc.gates._xx_matrix) - if door[k][0] == 4: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0],unitary=tc.gates._yy_matrix) - if door[k][0] == 5: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0],unitary=tc.gates._zz_matrix) - if door[k][0] == 6: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._x_matrix) - if door[k][0] == 7: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._y_matrix) - if door[k][0] == 8: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._z_matrix) - -#realize Hamilton gates in ancillary circuit -def H_gate(q, c): - if h_door[q][0] == 0: - c.cx(0,h_door[q][1]+1) - if h_door[q][0] == 1: - c.cy(0,h_door[q][1]+1) - if h_door[q][0] == 2: - c.cz(0,h_door[q][1]+1) - if h_door[q][0] == 3: - c.multicontrol(0,h_door[q][1]+1,h_door[q][2]+1,ctrl=[0],unitary=tc.gates._xx_matrix) - if h_door[q][0] == 4: - c.multicontrol(0,h_door[q][1]+1,h_door[q][2]+1,ctrl=[0],unitary=tc.gates._yy_matrix) - if h_door[q][0] == 5: - c.multicontrol(0,h_door[q][1]+1,h_door[q][2]+1,ctrl=[0],unitary=tc.gates._zz_matrix) - if h_door[q][0] == 6: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._x_matrix) - if h_door[q][0] == 7: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._y_matrix) - if h_door[q][0] == 8: - c.multicontrol(0,door[k][1]+1,door[k][2]+1,ctrl=[0,door[k][1]+1],unitary=tc.gates._z_matrix) - -#use quantum circuit to calculate coefficient of variation A and C in paper -def Calculation_A(mod, theta_x, k, q): - #mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C - ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) - c = tc.Circuit(N+1,inputs = np.kron(ancilla, state)) - for i in range(len(door)): - if i == k: - c.x(0) - U_gate(i, c) - c.x(0) - if i == q: - U_gate(i, c) - R_gate(i, c) - break - R_gate(i, c) - pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) - return mod * (2 * pstar - 1) - -def Calculation_C(mod, theta_x, k, q): - #mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C - ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) - c = tc.Circuit(N+1,inputs = np.kron(ancilla, state)) - for i in range(len(door)): - if i == k: - c.x(0) - U_gate(i, c) - c.x(0) - R_gate(i, c) - H_gate(q, c) - pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) - return mod * (2 * pstar - 1) - -#use original quantum circuit simulate with c -def simulation(): - c=tc.Circuit(N,inputs=state) - for k in range(len(door)): - if door[k][0]==0: - c.rx(door[k][1],theta=ODE_theta[k]) - if door[k][0]==1: - c.ry(door[k][1],theta=ODE_theta[k]) - if door[k][0]==2: - c.rz(door[k][1],theta=ODE_theta[k]) - if door[k][0] == 3: - c.multicontrol(0,door[k][1],door[k][2],ctrl=[0],unitary=tc.gates._xx_matrix) - if door[k][0] == 4: - c.multicontrol(0,door[k][1],door[k][2],ctrl=[0],unitary=tc.gates._yy_matrix) - if door[k][0] == 5: - c.multicontrol(0,door[k][1],door[k][2],ctrl=[0],unitary=tc.gates._zz_matrix) - if door[k][0] == 6: - c.multicontrol(0,door[k][1],door[k][2],ctrl=[0,door[k][1]],unitary=tc.gates._x_matrix) - if door[k][0] == 7: - c.multicontrol(0,door[k][1],door[k][2],ctrl=[0,door[k][1]],unitary=tc.gates._y_matrix) - if door[k][0] == 8: - c.multicontrol(0,door[k][1],door[k][2],ctrl=[0,door[k][1]],unitary=tc.gates._z_matrix) - return c - -if __name__ == '__main__': - - #l: layers; h and J: coefficient of Hamilton; L_var and L_num: results of variation method and numerical method - N = 3 - l = 2 - J = 1/4 - dt = 0.05 - t = 1 - h = [] - L_var = [] - L_num = [] - x_value = [] - - how_variation = 0 #0 McLachlan 1 time-dependent - - #the priciple correspond with all gates - #the first term: 0rx,1ry,2rz,3rxx,4ryy,5rzz,6crx,7cry,8crz; - #the second and the third term: num/ctrl+num - #f: coefficient with simulation gates in paper - door = [] - h_door = [] - f = [] - for k in range(l): - for i in range(N): - f.append(-0.5j) - door.append([0, i]) - for i in range(N - 1): - f.append(-1j) - door.append([5, i, i + 1]) - for i in range(N - 1): - f.append(-1j) - door.append([3, i, i + 1]) - for i in range(N): - h.append(1) - h_door.append([0, i]) - for i in range(N - 1): - h.append(J) - h_door.append([5, i, i + 1]) - - #initial state - state = np.zeros(1 << N) - state[0] = 1 - - #numerical realize H - H = np.zeros((1 << N, 1 << N)) * 1j - for q in range(len(h_door)): - if h_door[q][0] == 0: - H += h[q] * up_to_matrixx(h_door[q][1], 0, 1, 1, 0) - if h_door[q][0] == 1: - H += h[q] * up_to_matrixx(h_door[q][1], 0, -1j, 1j, 0) - if h_door[q][0] == 2: - H += h[q] * up_to_matrixx(h_door[q][1], 1, 0, 0, -1) - if h_door[q][0] == 3: - H += h[q] * up_to_matrixx(h_door[q][1], 0, 1, 1, 0) @ up_to_matrixx(h_door[q][2], 0, 1, 1, 0) - if h_door[q][0] == 4: - H += h[q] * up_to_matrixx(h_door[q][1], 0, -1j, 1j, 0) @ up_to_matrixx(h_door[q][2], 0, -1j, 1j, 0) - if h_door[q][0] == 5: - H += h[q] * up_to_matrixx(h_door[q][1], 1, 0, 0, -1) @ up_to_matrixx(h_door[q][2], 1, 0, 0, -1) - - #variation realize - ODE_theta = np.zeros(len(door)) - for T in range(int(t / dt)): - #calculate coefficient in paper - A = np.zeros((len(door), len(door))) - C = np.zeros(len(door)) - for k in range(len(door)): - for q in range(len(door)): - if k > q: - A[k, q] = A[q, k] - continue - if how_variation == 0: - A[k, q] = Calculation_A(abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]), k, q) - if how_variation == 1: - A[k, q] = Calculation_A(abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]) - math.pi / 2, k, q) - for k in range(len(door)): - for q in range(len(h)): - if how_variation == 0: - C[k] += Calculation_C(abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]) - math.pi / 2, k, q) - if how_variation == 1: - C[k] += Calculation_C(-abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]), k, q) - - #calculate parameter and its derivative - A += np.eye(len(door)) * 1e-5 - ODE_dtheta = np.linalg.solve(A, C) - print(ODE_dtheta) - for i in range(len(door)): - ODE_theta[i] += ODE_dtheta[i] * dt - - #numerical results - c = simulation() - ep = expm(-1j * H * (T + 1) * dt) @ state - L_num.append(np.real(np.array(ep.conj().T @ up_to_matrixx(1, 0, 1, 1, 0) @ ep)).tolist()) - - #variation results - L_var.append(np.real(np.array(c.expectation([tc.gates.x(), [1]]))).tolist()) - - x_value.append((T + 1) * dt) - print([(T + 1) * dt, L_num[T] - L_var[T]]) - plt.plot(x_value, L_var, color = 'green') - plt.plot(x_value, L_num, color = 'red') - plt.show() diff --git a/examples/quantum_variation.py b/examples/quantum_variation.py new file mode 100644 index 00000000..0c897f98 --- /dev/null +++ b/examples/quantum_variation.py @@ -0,0 +1,327 @@ +from scipy.linalg import expm +import numpy as np +import inspect +import tensorcircuit as tc +import random +import math +import matplotlib.pyplot as plt + +tc.set_backend("tensorflow") + +# calculate the matirx of kth qubit exert matrix[[a, b], [c, d]] +def up_to_matrixx(k, a, b, c, d): + I2 = np.array([[1, 0], [0, 1]]) * (1 + 0j) + K = np.array([[a, b], [c, d]]) * (1 + 0j) + um = I2 + if k == 0: + um = K + for i in range(1, N): + if i == k: + um = np.kron(um, K) + else: + um = np.kron(um, I2) + return um + + +# realize R gates in paper +def R_gate(k, c): + if door[k][0] == 0: + c.rx(door[k][1] + 1, theta=ODE_theta[k]) + if door[k][0] == 1: + c.ry(door[k][1] + 1, theta=ODE_theta[k]) + if door[k][0] == 2: + c.rz(door[k][1] + 1, theta=ODE_theta[k]) + if door[k][0] == 3: + c.rxx(door[k][1] + 1, door[k][2] + 1, theta=ODE_theta[k]) + if door[k][0] == 4: + c.ryy(door[k][1] + 1, door[k][2] + 1, theta=ODE_theta[k]) + if door[k][0] == 5: + c.rzz(door[k][1] + 1, door[k][2] + 1, theta=ODE_theta[k]) + if door[k][0] == 6: + c.crx(door[k][1] + 1, door[k][2] + 1, theta=ODE_theta[k]) + if door[k][0] == 7: + c.cry(door[k][1] + 1, door[k][2] + 1, theta=ODE_theta[k]) + if door[k][0] == 8: + c.crz(door[k][1] + 1, door[k][2] + 1, theta=ODE_theta[k]) + + +# realize U gates in paper +def U_gate(k, c): + if door[k][0] == 0: + c.cx(0, door[k][1] + 1) + if door[k][0] == 1: + c.cy(0, door[k][1] + 1) + if door[k][0] == 2: + c.cz(0, door[k][1] + 1) + if door[k][0] == 3: + c.multicontrol( + 0, door[k][1] + 1, door[k][2] + 1, ctrl=[0], unitary=tc.gates._xx_matrix + ) + if door[k][0] == 4: + c.multicontrol( + 0, door[k][1] + 1, door[k][2] + 1, ctrl=[0], unitary=tc.gates._yy_matrix + ) + if door[k][0] == 5: + c.multicontrol( + 0, door[k][1] + 1, door[k][2] + 1, ctrl=[0], unitary=tc.gates._zz_matrix + ) + if door[k][0] == 6: + c.multicontrol( + 0, + door[k][1] + 1, + door[k][2] + 1, + ctrl=[0, door[k][1] + 1], + unitary=tc.gates._x_matrix, + ) + if door[k][0] == 7: + c.multicontrol( + 0, + door[k][1] + 1, + door[k][2] + 1, + ctrl=[0, door[k][1] + 1], + unitary=tc.gates._y_matrix, + ) + if door[k][0] == 8: + c.multicontrol( + 0, + door[k][1] + 1, + door[k][2] + 1, + ctrl=[0, door[k][1] + 1], + unitary=tc.gates._z_matrix, + ) + + +# realize Hamilton gates in ancillary circuit +def H_gate(q, c): + if h_door[q][0] == 0: + c.cx(0, h_door[q][1] + 1) + if h_door[q][0] == 1: + c.cy(0, h_door[q][1] + 1) + if h_door[q][0] == 2: + c.cz(0, h_door[q][1] + 1) + if h_door[q][0] == 3: + c.multicontrol( + 0, h_door[q][1] + 1, h_door[q][2] + 1, ctrl=[0], unitary=tc.gates._xx_matrix + ) + if h_door[q][0] == 4: + c.multicontrol( + 0, h_door[q][1] + 1, h_door[q][2] + 1, ctrl=[0], unitary=tc.gates._yy_matrix + ) + if h_door[q][0] == 5: + c.multicontrol( + 0, h_door[q][1] + 1, h_door[q][2] + 1, ctrl=[0], unitary=tc.gates._zz_matrix + ) + if h_door[q][0] == 6: + c.multicontrol( + 0, + door[k][1] + 1, + door[k][2] + 1, + ctrl=[0, door[k][1] + 1], + unitary=tc.gates._x_matrix, + ) + if h_door[q][0] == 7: + c.multicontrol( + 0, + door[k][1] + 1, + door[k][2] + 1, + ctrl=[0, door[k][1] + 1], + unitary=tc.gates._y_matrix, + ) + if h_door[q][0] == 8: + c.multicontrol( + 0, + door[k][1] + 1, + door[k][2] + 1, + ctrl=[0, door[k][1] + 1], + unitary=tc.gates._z_matrix, + ) + + +# use quantum circuit to calculate coefficient of variation A and C in paper +def Calculation_A(mod, theta_x, k, q): + # mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C + ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) + c = tc.Circuit(N + 1, inputs=np.kron(ancilla, state)) + for i in range(len(door)): + if i == k: + c.x(0) + U_gate(i, c) + c.x(0) + if i == q: + U_gate(i, c) + R_gate(i, c) + break + R_gate(i, c) + pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) + return mod * (2 * pstar - 1) + + +def Calculation_C(mod, theta_x, k, q): + # mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C + ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) + c = tc.Circuit(N + 1, inputs=np.kron(ancilla, state)) + for i in range(len(door)): + if i == k: + c.x(0) + U_gate(i, c) + c.x(0) + R_gate(i, c) + H_gate(q, c) + pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) + return mod * (2 * pstar - 1) + + +# use original quantum circuit simulate with c +def simulation(): + c = tc.Circuit(N, inputs=state) + for k in range(len(door)): + if door[k][0] == 0: + c.rx(door[k][1], theta=ODE_theta[k]) + if door[k][0] == 1: + c.ry(door[k][1], theta=ODE_theta[k]) + if door[k][0] == 2: + c.rz(door[k][1], theta=ODE_theta[k]) + if door[k][0] == 3: + c.rxx(door[k][1], door[k][2], theta=ODE_theta[k]) + if door[k][0] == 4: + c.ryy(door[k][1], door[k][2], theta=ODE_theta[k]) + if door[k][0] == 5: + c.rzz(door[k][1], door[k][2], theta=ODE_theta[k]) + if door[k][0] == 6: + c.crx(door[k][1], door[k][2], theta=ODE_theta[k]) + if door[k][0] == 7: + c.cry(door[k][1], door[k][2], theta=ODE_theta[k]) + if door[k][0] == 8: + c.crz(door[k][1], door[k][2], theta=ODE_theta[k]) + return c + + +if __name__ == "__main__": + + # l: layers; h and J: coefficient of Hamilton; L_var and L_num: results of variation method and numerical method + N = 3 + l = 2 + J = 1 / 4 + dt = 0.05 + t = 1 + h = [] + L_var = [] + L_num = [] + x_value = [] + + how_variation = 0 # 0 McLachlan 1 time-dependent + + # the priciple correspond with all gates + # the first term: 0rx,1ry,2rz,3rxx,4ryy,5rzz,6crx,7cry,8crz; + # the second and the third term: num/ctrl+num + # f: coefficient with simulation gates in paper + door = [] + h_door = [] + f = [] + for k in range(l): + for i in range(N): + f.append(-0.5j) + door.append([0, i]) + for i in range(N - 1): + f.append(-1j) + door.append([5, i, i + 1]) + for i in range(N - 1): + f.append(-1j) + door.append([3, i, i + 1]) + for i in range(N): + h.append(1) + h_door.append([0, i]) + for i in range(N - 1): + h.append(J) + h_door.append([5, i, i + 1]) + + # initial state + state = np.zeros(1 << N) + state[0] = 1 + + # numerical realize H + H = np.zeros((1 << N, 1 << N)) * 1j + for q in range(len(h_door)): + if h_door[q][0] == 0: + H += h[q] * up_to_matrixx(h_door[q][1], 0, 1, 1, 0) + if h_door[q][0] == 1: + H += h[q] * up_to_matrixx(h_door[q][1], 0, -1j, 1j, 0) + if h_door[q][0] == 2: + H += h[q] * up_to_matrixx(h_door[q][1], 1, 0, 0, -1) + if h_door[q][0] == 3: + H += ( + h[q] + * up_to_matrixx(h_door[q][1], 0, 1, 1, 0) + @ up_to_matrixx(h_door[q][2], 0, 1, 1, 0) + ) + if h_door[q][0] == 4: + H += ( + h[q] + * up_to_matrixx(h_door[q][1], 0, -1j, 1j, 0) + @ up_to_matrixx(h_door[q][2], 0, -1j, 1j, 0) + ) + if h_door[q][0] == 5: + H += ( + h[q] + * up_to_matrixx(h_door[q][1], 1, 0, 0, -1) + @ up_to_matrixx(h_door[q][2], 1, 0, 0, -1) + ) + + # variation realize + ODE_theta = np.zeros(len(door)) + for T in range(int(t / dt)): + # calculate coefficient in paper + A = np.zeros((len(door), len(door))) + C = np.zeros(len(door)) + for k in range(len(door)): + for q in range(len(door)): + if k > q: + A[k, q] = A[q, k] + continue + if how_variation == 0: + A[k, q] = Calculation_A( + abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]), k, q + ) + if how_variation == 1: + A[k, q] = Calculation_A( + abs(f[k] * f[q]), + np.angle(f[q]) - np.angle(f[k]) - math.pi / 2, + k, + q, + ) + for k in range(len(door)): + for q in range(len(h)): + if how_variation == 0: + C[k] += Calculation_C( + abs(f[k] * h[q]), + np.angle(h[q]) - np.angle(f[k]) - math.pi / 2, + k, + q, + ) + if how_variation == 1: + C[k] += Calculation_C( + -abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]), k, q + ) + + # calculate parameter and its derivative + A += np.eye(len(door)) * 1e-5 + ODE_dtheta = np.linalg.solve(A, C) + print(ODE_dtheta) + for i in range(len(door)): + ODE_theta[i] += ODE_dtheta[i] * dt + + # numerical results + c = simulation() + ep = expm(-1j * H * (T + 1) * dt) @ state + L_num.append( + np.real(np.array(ep.conj().T @ up_to_matrixx(1, 0, 1, 1, 0) @ ep)).tolist() + ) + + # variation results + L_var.append(np.real(np.array(c.expectation([tc.gates.x(), [1]]))).tolist()) + + x_value.append((T + 1) * dt) + print([(T + 1) * dt, L_num[T] - L_var[T]]) + plt.plot(x_value, L_var, color="green") + plt.plot(x_value, L_num, color="red") + plt.show() From fc651a601a9ac7422ab645bcfd1c6285c60d2c3f Mon Sep 17 00:00:00 2001 From: WiuYuan <108848998+WiuYuan@users.noreply.github.com> Date: Sun, 9 Apr 2023 15:14:35 +0800 Subject: [PATCH 381/725] Update quantum_variation.py update quantum variation with vmap --- examples/quantum_variation.py | 338 +++++++++++++++++----------------- 1 file changed, 166 insertions(+), 172 deletions(-) diff --git a/examples/quantum_variation.py b/examples/quantum_variation.py index 0c897f98..c431b764 100644 --- a/examples/quantum_variation.py +++ b/examples/quantum_variation.py @@ -1,30 +1,13 @@ -from scipy.linalg import expm -import numpy as np -import inspect -import tensorcircuit as tc -import random import math +import numpy as np import matplotlib.pyplot as plt +import tensorcircuit as tc tc.set_backend("tensorflow") - -# calculate the matirx of kth qubit exert matrix[[a, b], [c, d]] -def up_to_matrixx(k, a, b, c, d): - I2 = np.array([[1, 0], [0, 1]]) * (1 + 0j) - K = np.array([[a, b], [c, d]]) * (1 + 0j) - um = I2 - if k == 0: - um = K - for i in range(1, N): - if i == k: - um = np.kron(um, K) - else: - um = np.kron(um, I2) - return um - +tc.set_dtype("complex64") # realize R gates in paper -def R_gate(k, c): +def R_gate(k, c, ODE_theta): if door[k][0] == 0: c.rx(door[k][1] + 1, theta=ODE_theta[k]) if door[k][0] == 1: @@ -46,131 +29,112 @@ def R_gate(k, c): # realize U gates in paper -def U_gate(k, c): +def U_gate_conditional(k): if door[k][0] == 0: - c.cx(0, door[k][1] + 1) + gate_now = tc.gates.multicontrol_gate( + np.kron(tc.gates._x_matrix, np.eye(2)), [1] + ) if door[k][0] == 1: - c.cy(0, door[k][1] + 1) + gate_now = tc.gates.multicontrol_gate( + np.kron(tc.gates._y_matrix, np.eye(2)), [1] + ) if door[k][0] == 2: - c.cz(0, door[k][1] + 1) - if door[k][0] == 3: - c.multicontrol( - 0, door[k][1] + 1, door[k][2] + 1, ctrl=[0], unitary=tc.gates._xx_matrix + gate_now = tc.gates.multicontrol_gate( + np.kron(tc.gates._z_matrix, np.eye(2)), [1] ) + if door[k][0] == 3: + gate_now = tc.gates.multicontrol_gate(tc.gates._xx_matrix, [1]) if door[k][0] == 4: - c.multicontrol( - 0, door[k][1] + 1, door[k][2] + 1, ctrl=[0], unitary=tc.gates._yy_matrix - ) + gate_now = tc.gates.multicontrol_gate(tc.gates._yy_matrix, [1]) if door[k][0] == 5: - c.multicontrol( - 0, door[k][1] + 1, door[k][2] + 1, ctrl=[0], unitary=tc.gates._zz_matrix - ) - if door[k][0] == 6: - c.multicontrol( - 0, - door[k][1] + 1, - door[k][2] + 1, - ctrl=[0, door[k][1] + 1], - unitary=tc.gates._x_matrix, - ) - if door[k][0] == 7: - c.multicontrol( - 0, - door[k][1] + 1, - door[k][2] + 1, - ctrl=[0, door[k][1] + 1], - unitary=tc.gates._y_matrix, - ) - if door[k][0] == 8: - c.multicontrol( - 0, - door[k][1] + 1, - door[k][2] + 1, - ctrl=[0, door[k][1] + 1], - unitary=tc.gates._z_matrix, - ) + gate_now = tc.gates.multicontrol_gate(tc.gates._zz_matrix, [1]) + return gate_now.eval_matrix() # realize Hamilton gates in ancillary circuit -def H_gate(q, c): +def H_gate_conditional(q): if h_door[q][0] == 0: - c.cx(0, h_door[q][1] + 1) + gate_now = tc.gates.multicontrol_gate( + np.kron(tc.gates._x_matrix, np.eye(2)), [1] + ) if h_door[q][0] == 1: - c.cy(0, h_door[q][1] + 1) + gate_now = tc.gates.multicontrol_gate( + np.kron(tc.gates._y_matrix, np.eye(2)), [1] + ) if h_door[q][0] == 2: - c.cz(0, h_door[q][1] + 1) - if h_door[q][0] == 3: - c.multicontrol( - 0, h_door[q][1] + 1, h_door[q][2] + 1, ctrl=[0], unitary=tc.gates._xx_matrix + gate_now = tc.gates.multicontrol_gate( + np.kron(tc.gates._z_matrix, np.eye(2)), [1] ) + if h_door[q][0] == 3: + gate_now = tc.gates.multicontrol_gate(tc.gates._xx_matrix, [1]) if h_door[q][0] == 4: - c.multicontrol( - 0, h_door[q][1] + 1, h_door[q][2] + 1, ctrl=[0], unitary=tc.gates._yy_matrix - ) + gate_now = tc.gates.multicontrol_gate(tc.gates._yy_matrix, [1]) if h_door[q][0] == 5: - c.multicontrol( - 0, h_door[q][1] + 1, h_door[q][2] + 1, ctrl=[0], unitary=tc.gates._zz_matrix - ) - if h_door[q][0] == 6: - c.multicontrol( - 0, - door[k][1] + 1, - door[k][2] + 1, - ctrl=[0, door[k][1] + 1], - unitary=tc.gates._x_matrix, - ) - if h_door[q][0] == 7: - c.multicontrol( + gate_now = tc.gates.multicontrol_gate(tc.gates._zz_matrix, [1]) + return gate_now.eval_matrix() + + +# use quantum circuit to calculate coefficient of variation A and C in paper +@tc.backend.jit +def Calculation_A(theta_x, is_k, is_q, ODE_theta): + # mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term(k <= q) + c = tc.Circuit(N + 1, inputs=np.kron([1, 1] / np.sqrt(2), state)) + c.rz(0, theta=-theta_x) + for i in range(len(door)): + c.conditional_gate(is_k[i], [np.eye(2), tc.gates._x_matrix], 0) + c.conditional_gate( + is_k[i], + [np.eye(8), U_gate_conditional(i)], 0, - door[k][1] + 1, - door[k][2] + 1, - ctrl=[0, door[k][1] + 1], - unitary=tc.gates._y_matrix, + door[i][1] + 1, + door[i][2] + 1, ) - if h_door[q][0] == 8: - c.multicontrol( + c.conditional_gate(is_k[i], [np.eye(2), tc.gates._x_matrix], 0) + c.conditional_gate( + is_q[i], + [np.eye(8), U_gate_conditional(i)], 0, - door[k][1] + 1, - door[k][2] + 1, - ctrl=[0, door[k][1] + 1], - unitary=tc.gates._z_matrix, + door[i][1] + 1, + door[i][2] + 1, ) + R_gate(i, c, ODE_theta) + pstar = c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]) + return 2 * pstar - 1 -# use quantum circuit to calculate coefficient of variation A and C in paper -def Calculation_A(mod, theta_x, k, q): - # mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C - ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) - c = tc.Circuit(N + 1, inputs=np.kron(ancilla, state)) - for i in range(len(door)): - if i == k: - c.x(0) - U_gate(i, c) - c.x(0) - if i == q: - U_gate(i, c) - R_gate(i, c) - break - R_gate(i, c) - pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) - return mod * (2 * pstar - 1) +Calculation_A_vmap = tc.backend.vmap(Calculation_A, vectorized_argnums=[0, 1, 2]) -def Calculation_C(mod, theta_x, k, q): - # mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term; whi: whi=0 A whi=1 C - ancilla = np.array([1, np.exp(1j * theta_x)]) / np.sqrt(2) - c = tc.Circuit(N + 1, inputs=np.kron(ancilla, state)) +@tc.backend.jit +def Calculation_C(theta_x, is_k, is_q, ODE_theta): + # mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term + c = tc.Circuit(N + 1, inputs=np.kron([1, 1] / np.sqrt(2), state)) + c.rz(0, theta=-theta_x) for i in range(len(door)): - if i == k: - c.x(0) - U_gate(i, c) - c.x(0) - R_gate(i, c) - H_gate(q, c) - pstar = np.real(np.array(c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]))) - return mod * (2 * pstar - 1) + c.conditional_gate(is_k[i], [np.eye(2), tc.gates._x_matrix], 0) + c.conditional_gate( + is_k[i], + [np.eye(8), U_gate_conditional(i)], + 0, + door[i][1] + 1, + door[i][2] + 1, + ) + c.conditional_gate(is_k[i], [np.eye(2), tc.gates._x_matrix], 0) + R_gate(i, c, ODE_theta) + for i in range(len(h_door)): + c.conditional_gate( + is_q[i], + [np.eye(8), H_gate_conditional(i)], + 0, + h_door[i][1] + 1, + h_door[i][2] + 1, + ) + pstar = c.expectation([np.array([[1, 1], [1, 1]]) / 2, [0]]) + return 2 * pstar - 1 +Calculation_C_vmap = tc.backend.vmap(Calculation_C, vectorized_argnums=[0, 1, 2]) + # use original quantum circuit simulate with c def simulation(): c = tc.Circuit(N, inputs=state) @@ -196,20 +160,26 @@ def simulation(): return c +def numdiff(i): + if i != 0: + return i - 1 + return i + 1 + + if __name__ == "__main__": # l: layers; h and J: coefficient of Hamilton; L_var and L_num: results of variation method and numerical method N = 3 l = 2 J = 1 / 4 - dt = 0.05 + dt = 0.01 t = 1 h = [] L_var = [] L_num = [] x_value = [] - how_variation = 0 # 0 McLachlan 1 time-dependent + how_variation = 0 # 0:McLachlan; 1:time-dependent # the priciple correspond with all gates # the first term: 0rx,1ry,2rz,3rxx,4ryy,5rzz,6crx,7cry,8crz; @@ -221,7 +191,7 @@ def simulation(): for k in range(l): for i in range(N): f.append(-0.5j) - door.append([0, i]) + door.append([0, i, numdiff(i)]) for i in range(N - 1): f.append(-1j) door.append([5, i, i + 1]) @@ -230,7 +200,7 @@ def simulation(): door.append([3, i, i + 1]) for i in range(N): h.append(1) - h_door.append([0, i]) + h_door.append([0, i, numdiff(i)]) for i in range(N - 1): h.append(J) h_door.append([5, i, i + 1]) @@ -240,32 +210,36 @@ def simulation(): state[0] = 1 # numerical realize H + ls = [] + weight = [] H = np.zeros((1 << N, 1 << N)) * 1j for q in range(len(h_door)): if h_door[q][0] == 0: - H += h[q] * up_to_matrixx(h_door[q][1], 0, 1, 1, 0) + r = [0 for _ in range(N)] + r[h_door[q][1]] = 1 if h_door[q][0] == 1: - H += h[q] * up_to_matrixx(h_door[q][1], 0, -1j, 1j, 0) + r = [0 for _ in range(N)] + r[h_door[q][1]] = 2 if h_door[q][0] == 2: - H += h[q] * up_to_matrixx(h_door[q][1], 1, 0, 0, -1) + r = [0 for _ in range(N)] + r[h_door[q][1]] = 3 if h_door[q][0] == 3: - H += ( - h[q] - * up_to_matrixx(h_door[q][1], 0, 1, 1, 0) - @ up_to_matrixx(h_door[q][2], 0, 1, 1, 0) - ) + r = [0 for _ in range(N)] + r[h_door[q][1]] = 1 + r[h_door[q][2]] = 1 if h_door[q][0] == 4: - H += ( - h[q] - * up_to_matrixx(h_door[q][1], 0, -1j, 1j, 0) - @ up_to_matrixx(h_door[q][2], 0, -1j, 1j, 0) - ) + r = [0 for _ in range(N)] + r[h_door[q][1]] = 2 + r[h_door[q][2]] = 2 if h_door[q][0] == 5: - H += ( - h[q] - * up_to_matrixx(h_door[q][1], 1, 0, 0, -1) - @ up_to_matrixx(h_door[q][2], 1, 0, 0, -1) - ) + r = [0 for _ in range(N)] + r[h_door[q][1]] = 3 + r[h_door[q][2]] = 3 + ls.append(r) + weight.append(h[q]) + ls = tc.array_to_tensor(ls) + weight = tc.array_to_tensor(weight) + H = tc.quantum.PauliStringSum2Dense(ls, weight, numpy=False) # variation realize ODE_theta = np.zeros(len(door)) @@ -273,55 +247,75 @@ def simulation(): # calculate coefficient in paper A = np.zeros((len(door), len(door))) C = np.zeros(len(door)) + batch_theta = [] + batch_is_k = [] + batch_is_q = [] for k in range(len(door)): for q in range(len(door)): - if k > q: - A[k, q] = A[q, k] - continue + is_k = [0 for _ in range(len(door))] + is_k[k] = 1 + is_q = [0 for _ in range(len(door))] + is_q[q] = 1 if how_variation == 0: - A[k, q] = Calculation_A( - abs(f[k] * f[q]), np.angle(f[q]) - np.angle(f[k]), k, q - ) - if how_variation == 1: - A[k, q] = Calculation_A( - abs(f[k] * f[q]), - np.angle(f[q]) - np.angle(f[k]) - math.pi / 2, - k, - q, - ) + batch_theta.append(np.angle(f[q]) - np.angle(f[k])) + else: + batch_theta.append(np.angle(f[q]) - np.angle(f[k]) - math.pi / 2) + batch_is_k.append(is_k) + batch_is_q.append(is_q) + batch_theta = tc.array_to_tensor(batch_theta) + batch_is_k = tf.constant(batch_is_k) + batch_is_q = tf.constant(batch_is_q) + vmap_result = Calculation_A_vmap(batch_theta, batch_is_k, batch_is_q, ODE_theta) for k in range(len(door)): - for q in range(len(h)): + for q in range(len(door)): + A[k, q] = abs(f[k] * f[q]) * vmap_result[k * len(door) + q] + + batch_theta = [] + batch_is_k = [] + batch_is_q = [] + for k in range(len(door)): + for q in range(len(h_door)): + is_k = [0 for _ in range(len(door))] + is_k[k] = 1 + is_q = [0 for _ in range(len(door))] + is_q[q] = 1 if how_variation == 0: - C[k] += Calculation_C( - abs(f[k] * h[q]), - np.angle(h[q]) - np.angle(f[k]) - math.pi / 2, - k, - q, - ) - if how_variation == 1: - C[k] += Calculation_C( - -abs(f[k] * h[q]), np.angle(h[q]) - np.angle(f[k]), k, q - ) + batch_theta.append(np.angle(h[q]) - np.angle(f[k]) - math.pi / 2) + else: + batch_theta.append(np.angle(h[q]) - np.angle(f[k]) + math.pi) + batch_is_k.append(is_k) + batch_is_q.append(is_q) + batch_theta = tc.array_to_tensor(batch_theta) + batch_is_k = tf.constant(batch_is_k) + batch_is_q = tf.constant(batch_is_q) + vmap_result = Calculation_C_vmap(batch_theta, batch_is_k, batch_is_q, ODE_theta) + for k in range(len(door)): + for q in range(len(h_door)): + C[k] += abs(f[k] * h[q]) * vmap_result[k * len(h_door) + q] # calculate parameter and its derivative A += np.eye(len(door)) * 1e-5 - ODE_dtheta = np.linalg.solve(A, C) - print(ODE_dtheta) + ODE_dtheta = tc.backend.solve(A, C) for i in range(len(door)): ODE_theta[i] += ODE_dtheta[i] * dt # numerical results c = simulation() - ep = expm(-1j * H * (T + 1) * dt) @ state + ep = np.array(tc.backend.expm(-1j * H * (T + 1) * dt)) @ state L_num.append( - np.real(np.array(ep.conj().T @ up_to_matrixx(1, 0, 1, 1, 0) @ ep)).tolist() + np.array( + tc.backend.real( + tc.expectation([tc.gates.x(), [1]], ket=ep.astype("complex64")) + ) + ) ) # variation results L_var.append(np.real(np.array(c.expectation([tc.gates.x(), [1]]))).tolist()) - x_value.append((T + 1) * dt) - print([(T + 1) * dt, L_num[T] - L_var[T]]) + x_value.append(round((T + 1) * dt, 3)) + print("Now time:", x_value[T], "Loss:", L_num[T] - L_var[T]) + plt.plot(x_value, L_var, color="green") plt.plot(x_value, L_num, color="red") plt.show() From 078b827507b5918a22fdfdc68700d8a97982c72f Mon Sep 17 00:00:00 2001 From: WiuYuan <108848998+WiuYuan@users.noreply.github.com> Date: Sun, 9 Apr 2023 16:28:13 +0800 Subject: [PATCH 382/725] Update quantum_variation.py --- examples/quantum_variation.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/examples/quantum_variation.py b/examples/quantum_variation.py index c431b764..60486f13 100644 --- a/examples/quantum_variation.py +++ b/examples/quantum_variation.py @@ -6,6 +6,7 @@ tc.set_backend("tensorflow") tc.set_dtype("complex64") + # realize R gates in paper def R_gate(k, c, ODE_theta): if door[k][0] == 0: @@ -135,6 +136,7 @@ def Calculation_C(theta_x, is_k, is_q, ODE_theta): Calculation_C_vmap = tc.backend.vmap(Calculation_C, vectorized_argnums=[0, 1, 2]) + # use original quantum circuit simulate with c def simulation(): c = tc.Circuit(N, inputs=state) @@ -167,7 +169,6 @@ def numdiff(i): if __name__ == "__main__": - # l: layers; h and J: coefficient of Hamilton; L_var and L_num: results of variation method and numerical method N = 3 l = 2 From 2f8194f318ecb3993f8d7bd8e8bbf8dc9ccf1393 Mon Sep 17 00:00:00 2001 From: WiuYuan <108848998+WiuYuan@users.noreply.github.com> Date: Sun, 9 Apr 2023 18:06:06 +0800 Subject: [PATCH 383/725] Update quantum_variation.py --- examples/quantum_variation.py | 58 +++++++++++++---------------------- 1 file changed, 21 insertions(+), 37 deletions(-) diff --git a/examples/quantum_variation.py b/examples/quantum_variation.py index 60486f13..439e0bf7 100644 --- a/examples/quantum_variation.py +++ b/examples/quantum_variation.py @@ -1,6 +1,7 @@ import math import numpy as np import matplotlib.pyplot as plt +import tensorflow as tf import tensorcircuit as tc tc.set_backend("tensorflow") @@ -29,49 +30,32 @@ def R_gate(k, c, ODE_theta): c.crz(door[k][1] + 1, door[k][2] + 1, theta=ODE_theta[k]) -# realize U gates in paper -def U_gate_conditional(k): - if door[k][0] == 0: - gate_now = tc.gates.multicontrol_gate( - np.kron(tc.gates._x_matrix, np.eye(2)), [1] - ) - if door[k][0] == 1: - gate_now = tc.gates.multicontrol_gate( - np.kron(tc.gates._y_matrix, np.eye(2)), [1] - ) - if door[k][0] == 2: - gate_now = tc.gates.multicontrol_gate( - np.kron(tc.gates._z_matrix, np.eye(2)), [1] - ) - if door[k][0] == 3: - gate_now = tc.gates.multicontrol_gate(tc.gates._xx_matrix, [1]) - if door[k][0] == 4: - gate_now = tc.gates.multicontrol_gate(tc.gates._yy_matrix, [1]) - if door[k][0] == 5: - gate_now = tc.gates.multicontrol_gate(tc.gates._zz_matrix, [1]) - return gate_now.eval_matrix() - - -# realize Hamilton gates in ancillary circuit -def H_gate_conditional(q): - if h_door[q][0] == 0: +# realize U and H gates in paper +def U_H_gate(k, UHgate): + if UHgate[k][0] == 0: gate_now = tc.gates.multicontrol_gate( np.kron(tc.gates._x_matrix, np.eye(2)), [1] ) - if h_door[q][0] == 1: + if UHgate[k][0] == 1: gate_now = tc.gates.multicontrol_gate( np.kron(tc.gates._y_matrix, np.eye(2)), [1] ) - if h_door[q][0] == 2: + if UHgate[k][0] == 2: gate_now = tc.gates.multicontrol_gate( np.kron(tc.gates._z_matrix, np.eye(2)), [1] ) - if h_door[q][0] == 3: + if UHgate[k][0] == 3: gate_now = tc.gates.multicontrol_gate(tc.gates._xx_matrix, [1]) - if h_door[q][0] == 4: + if UHgate[k][0] == 4: gate_now = tc.gates.multicontrol_gate(tc.gates._yy_matrix, [1]) - if h_door[q][0] == 5: + if UHgate[k][0] == 5: gate_now = tc.gates.multicontrol_gate(tc.gates._zz_matrix, [1]) + if UHgate[k][0] == 6: + gate_now = tc.gates.multicontrol_gate(tc.gates._x_matrix, [1, 1]) + if UHgate[k][0] == 7: + gate_now = tc.gates.multicontrol_gate(tc.gates._y_matrix, [1, 1]) + if UHgate[k][0] == 8: + gate_now = tc.gates.multicontrol_gate(tc.gates._z_matrix, [1, 1]) return gate_now.eval_matrix() @@ -85,7 +69,7 @@ def Calculation_A(theta_x, is_k, is_q, ODE_theta): c.conditional_gate(is_k[i], [np.eye(2), tc.gates._x_matrix], 0) c.conditional_gate( is_k[i], - [np.eye(8), U_gate_conditional(i)], + [np.eye(8), U_H_gate(i, door)], 0, door[i][1] + 1, door[i][2] + 1, @@ -93,7 +77,7 @@ def Calculation_A(theta_x, is_k, is_q, ODE_theta): c.conditional_gate(is_k[i], [np.eye(2), tc.gates._x_matrix], 0) c.conditional_gate( is_q[i], - [np.eye(8), U_gate_conditional(i)], + [np.eye(8), U_H_gate(i, door)], 0, door[i][1] + 1, door[i][2] + 1, @@ -115,7 +99,7 @@ def Calculation_C(theta_x, is_k, is_q, ODE_theta): c.conditional_gate(is_k[i], [np.eye(2), tc.gates._x_matrix], 0) c.conditional_gate( is_k[i], - [np.eye(8), U_gate_conditional(i)], + [np.eye(8), U_H_gate(i, door)], 0, door[i][1] + 1, door[i][2] + 1, @@ -125,7 +109,7 @@ def Calculation_C(theta_x, is_k, is_q, ODE_theta): for i in range(len(h_door)): c.conditional_gate( is_q[i], - [np.eye(8), H_gate_conditional(i)], + [np.eye(8), U_H_gate(i, h_door)], 0, h_door[i][1] + 1, h_door[i][2] + 1, @@ -138,7 +122,7 @@ def Calculation_C(theta_x, is_k, is_q, ODE_theta): # use original quantum circuit simulate with c -def simulation(): +def simulation(ODE_theta): c = tc.Circuit(N, inputs=state) for k in range(len(door)): if door[k][0] == 0: @@ -301,7 +285,6 @@ def numdiff(i): ODE_theta[i] += ODE_dtheta[i] * dt # numerical results - c = simulation() ep = np.array(tc.backend.expm(-1j * H * (T + 1) * dt)) @ state L_num.append( np.array( @@ -312,6 +295,7 @@ def numdiff(i): ) # variation results + c = simulation(ODE_theta) L_var.append(np.real(np.array(c.expectation([tc.gates.x(), [1]]))).tolist()) x_value.append(round((T + 1) * dt, 3)) From ad2c04a781ab6a3ed5db59b1d522c2a936a15522 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 9 Apr 2023 20:53:06 +0800 Subject: [PATCH 384/725] add about to detect tc env --- docs/source/api/about.rst | 7 ++ docs/source/api/backends.rst | 1 + docs/source/api/backends/cupy_backend.rst | 7 ++ docs/source/modules.rst | 1 + tensorcircuit/__init__.py | 1 + tensorcircuit/about.py | 112 ++++++++++++++++++++++ 6 files changed, 129 insertions(+) create mode 100644 docs/source/api/about.rst create mode 100644 docs/source/api/backends/cupy_backend.rst create mode 100644 tensorcircuit/about.py diff --git a/docs/source/api/about.rst b/docs/source/api/about.rst new file mode 100644 index 00000000..8f7bbf76 --- /dev/null +++ b/docs/source/api/about.rst @@ -0,0 +1,7 @@ +tensorcircuit.about +================================================== +.. automodule:: tensorcircuit.about + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/backends.rst b/docs/source/api/backends.rst index 0186313f..4504e569 100644 --- a/docs/source/api/backends.rst +++ b/docs/source/api/backends.rst @@ -2,6 +2,7 @@ tensorcircuit.backends ================================================== .. toctree:: backends/backend_factory.rst + backends/cupy_backend.rst backends/jax_backend.rst backends/numpy_backend.rst backends/pytorch_backend.rst diff --git a/docs/source/api/backends/cupy_backend.rst b/docs/source/api/backends/cupy_backend.rst new file mode 100644 index 00000000..743fe8f3 --- /dev/null +++ b/docs/source/api/backends/cupy_backend.rst @@ -0,0 +1,7 @@ +tensorcircuit.backends.cupy_backend +================================================== +.. automodule:: tensorcircuit.backends.cupy_backend + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/modules.rst b/docs/source/modules.rst index b71e1b6f..fb5b3091 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -1,6 +1,7 @@ tensorcircuit ================================================== .. toctree:: + ./api/about.rst ./api/abstractcircuit.rst ./api/applications.rst ./api/backends.rst diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index f9a2da2c..74cf4e5c 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -2,6 +2,7 @@ __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" +from .about import about from .cons import ( backend, set_backend, diff --git a/tensorcircuit/about.py b/tensorcircuit/about.py new file mode 100644 index 00000000..40f77c8f --- /dev/null +++ b/tensorcircuit/about.py @@ -0,0 +1,112 @@ +""" +Prints the information for tensorcircuit installation and environment. +""" + +import platform +import sys +import numpy + + +def about() -> None: + """ + Prints the information for tensorcircuit installation and environment. + """ + print(f"OS info: {platform.platform(aliased=True)}") + print( + f"Python version: {sys.version_info[0]}.{sys.version_info[1]}.{sys.version_info[2]}" + ) + print(f"Numpy version: {numpy.__version__}") + + try: + import scipy + + print(f"Scipy version: {scipy.__version__}") + except ModuleNotFoundError: + print(f"Scipy is not installed") + + try: + import pandas + + print(f"Pandas version: {pandas.__version__}") + except ModuleNotFoundError: + print(f"Pandas is not installed") + + try: + import tensornetwork as tn + + print(f"TensorNetwork version: {tn.__version__}") + except ModuleNotFoundError: + print(f"TensorNetwork is not installed") + + try: + import cotengra as _ + + print(f"Cotengra: installed") + except ModuleNotFoundError: + print(f"Cotengra is not installed") + + try: + import tensorflow as tf + + print(f"TensorFlow version: {tf.__version__}") + print(f"TensorFlow GPU: {tf.config.list_physical_devices('GPU')}") + print(f"TensorFlow CUDA infos: {dict(tf.sysconfig.get_build_info())}") + except ModuleNotFoundError: + print(f"TensorFlow is not installed") + + try: + import jax + + print(f"Jax version: {jax.__version__}") + try: + device = jax.devices("gpu") + print(f"Jax GPU: {device}") + except RuntimeError: + print(f"Jax installation doesn't support GPU") + except ModuleNotFoundError: + print(f"Jax is not installed") + + try: + import jaxlib + + print(f"JaxLib version: {jaxlib.__version__}") + except ModuleNotFoundError: + print(f"JaxLib is not installed") + + try: + import torch + + print(f"PyTorch version: {torch.__version__}") + print(f"PyTorch GPU support: {torch.cuda.is_available()}") + print( + f"PyTorch GPUs: {[torch.cuda.device(i) for i in range(torch.cuda.device_count())]}" + ) + if torch.version.cuda is not None: + print(f"Pytorch cuda version: {torch.version.cuda}") + except ModuleNotFoundError: + print(f"PyTorch is not installed") + + try: + import cupy + + print(f"Cupy version: {cupy.__version__}") + except ModuleNotFoundError: + print(f"Cupy is not installed") + + try: + import qiskit + + print(f"Qiskit version: {qiskit.__version__}") + except ModuleNotFoundError: + print(f"Qiskit is not installed") + + try: + import cirq + + print(f"Cirq version: {cirq.__version__}") + except ModuleNotFoundError: + print(f"Cirq is not installed") + + +if __name__ == "__main__": + about() From 6d0ac119be7bfb30f82edc4f12d6b1bfb97673c4 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 9 Apr 2023 20:56:16 +0800 Subject: [PATCH 385/725] update doc for tc.about() --- CHANGELOG.md | 4 ++++ docs/source/quickstart.rst | 2 ++ 2 files changed, 6 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6d892c2b..99e14a67 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Added + +- Add `tc.about()` to print related software versions and configs. + ## 0.8.0 ### Added diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 4e5800a5..40f50645 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -32,6 +32,8 @@ Docker is also recommended (especially Linux + Nvidia GPU setup): Overall, the installation of TensorCircuit is simple, since it is purely in Python and hence very portable. As long as the users can take care of the installation of ML frameworks on the corresponding system, TensorCircuit will work as expected. +To debug the installation issue or report bugs, please check the environment information by ``tc.about()``. + .. Note:: We also provide a nightly build of tensorcircuit via PyPI which can be accessed by ``pip uninstall tensorcircuit``, then From 50a4a86d89fc3dbfb66297c7f922167ad619533c Mon Sep 17 00:00:00 2001 From: WiuYuan <108848998+WiuYuan@users.noreply.github.com> Date: Mon, 10 Apr 2023 08:44:05 +0800 Subject: [PATCH 386/725] Update quantum_variation.py --- examples/quantum_variation.py | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/examples/quantum_variation.py b/examples/quantum_variation.py index 439e0bf7..9e70bea7 100644 --- a/examples/quantum_variation.py +++ b/examples/quantum_variation.py @@ -189,6 +189,8 @@ def numdiff(i): for i in range(N - 1): h.append(J) h_door.append([5, i, i + 1]) + f = tf.constant(f, dtype="complex64") + h = tf.constant(h, dtype="float32") # initial state state = np.zeros(1 << N) @@ -197,7 +199,6 @@ def numdiff(i): # numerical realize H ls = [] weight = [] - H = np.zeros((1 << N, 1 << N)) * 1j for q in range(len(h_door)): if h_door[q][0] == 0: r = [0 for _ in range(N)] @@ -227,7 +228,7 @@ def numdiff(i): H = tc.quantum.PauliStringSum2Dense(ls, weight, numpy=False) # variation realize - ODE_theta = np.zeros(len(door)) + ODE_theta = tf.zeros(len(door), dtype="float32") for T in range(int(t / dt)): # calculate coefficient in paper A = np.zeros((len(door), len(door))) @@ -251,9 +252,9 @@ def numdiff(i): batch_is_k = tf.constant(batch_is_k) batch_is_q = tf.constant(batch_is_q) vmap_result = Calculation_A_vmap(batch_theta, batch_is_k, batch_is_q, ODE_theta) - for k in range(len(door)): - for q in range(len(door)): - A[k, q] = abs(f[k] * f[q]) * vmap_result[k * len(door) + q] + A = tf.cast( + tf.tensordot(tf.abs(f), tf.abs(f), 0), dtype="float32" + ) * tf.reshape(tc.backend.real(vmap_result), [len(door), len(door)]) batch_theta = [] batch_is_k = [] @@ -274,15 +275,16 @@ def numdiff(i): batch_is_k = tf.constant(batch_is_k) batch_is_q = tf.constant(batch_is_q) vmap_result = Calculation_C_vmap(batch_theta, batch_is_k, batch_is_q, ODE_theta) - for k in range(len(door)): - for q in range(len(h_door)): - C[k] += abs(f[k] * h[q]) * vmap_result[k * len(h_door) + q] + C = tf.reduce_sum( + tf.cast(tf.tensordot(tf.abs(f), tf.abs(h), 0), dtype="float32") + * tf.reshape(tc.backend.real(vmap_result), [len(door), len(h_door)]), + 1, + ) # calculate parameter and its derivative A += np.eye(len(door)) * 1e-5 ODE_dtheta = tc.backend.solve(A, C) - for i in range(len(door)): - ODE_theta[i] += ODE_dtheta[i] * dt + ODE_theta += ODE_dtheta * dt # numerical results ep = np.array(tc.backend.expm(-1j * H * (T + 1) * dt)) @ state From b6fc6898a65e44f4b7506bb25d6eefd07f44a010 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 10 Apr 2023 13:22:41 +0800 Subject: [PATCH 387/725] big upgrade for torch backend support --- .github/ISSUE_TEMPLATE/bug_report.md | 2 + CHANGELOG.md | 2 + tensorcircuit/backends/abstract_backend.py | 1 + tensorcircuit/backends/cupy_backend.py | 1 + tensorcircuit/backends/jax_backend.py | 1 + tensorcircuit/backends/numpy_backend.py | 1 + tensorcircuit/backends/pytorch_backend.py | 169 +++++++++++++------ tensorcircuit/backends/pytorch_ops.py | 18 +- tensorcircuit/backends/tensorflow_backend.py | 1 + tests/test_backends.py | 33 ++-- 10 files changed, 156 insertions(+), 73 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md index 03e7c193..187c97ad 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -25,3 +25,5 @@ assignees: "" ## Environment Context <--! Please report your OS version, Python environment and version, TensorCircuit version and necessary dependent package (NumPy, TensorFlow, Jax, Jaxlib, PyTorch) version here. --> + +Output of `tc.about()` and `tc.__version__`. diff --git a/CHANGELOG.md b/CHANGELOG.md index 99e14a67..499e51e7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Add `tc.about()` to print related software versions and configs. +- Torch support is updraded to 2.0, and now support native vmap and native functional grad, and thus `vvag`. Still jit support is conflict with these functional transformations and be turned off by default + ## 0.8.0 ### Added diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index 2d14d9c7..24023923 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -1606,6 +1606,7 @@ def jit( f: Callable[..., Any], static_argnums: Optional[Union[int, Sequence[int]]] = None, jit_compile: Optional[bool] = None, + **kws: Any ) -> Callable[..., Any]: """ Return the jitted version of function ``f``. diff --git a/tensorcircuit/backends/cupy_backend.py b/tensorcircuit/backends/cupy_backend.py index 3ae9c5b9..7d6e92ea 100644 --- a/tensorcircuit/backends/cupy_backend.py +++ b/tensorcircuit/backends/cupy_backend.py @@ -409,6 +409,7 @@ def jit( f: Callable[..., Any], static_argnums: Optional[Union[int, Sequence[int]]] = None, jit_compile: Optional[bool] = None, + **kws: Any ) -> Callable[..., Any]: logger.warning("CuPy backend has no jit interface, just do nothing") return f diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 23475da0..21c9edf2 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -686,6 +686,7 @@ def jit( f: Callable[..., Any], static_argnums: Optional[Union[int, Sequence[int]]] = None, jit_compile: Optional[bool] = None, + **kws: Any, ) -> Any: return libjax.jit(f, static_argnums=static_argnums) diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index 6ab2bde2..2d22b94d 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -377,6 +377,7 @@ def jit( f: Callable[..., Any], static_argnums: Optional[Union[int, Sequence[int]]] = None, jit_compile: Optional[bool] = None, + **kws: Any ) -> Callable[..., Any]: logger.warning("numpy backend has no jit interface, just do nothing") return f diff --git a/tensorcircuit/backends/pytorch_backend.py b/tensorcircuit/backends/pytorch_backend.py index 481f0b20..7362cc47 100644 --- a/tensorcircuit/backends/pytorch_backend.py +++ b/tensorcircuit/backends/pytorch_backend.py @@ -6,7 +6,7 @@ import logging from typing import Any, Callable, Optional, Sequence, Tuple, Union from operator import mul -from functools import reduce +from functools import reduce, partial import tensornetwork from tensornetwork.backends.pytorch import pytorch_backend @@ -26,6 +26,24 @@ # To be added once pytorch backend is ready +class torch_jit_func: + """ + Delay the tracing of torch jit to the first run time: + consistent with tf and jax mechanism + """ + + def __init__(self, f: Callable[..., Any]): + self.compiled = False + self.f = f + + def __call__(self, *args: Any, **kws: Any) -> Any: + if self.compiled is False: + self.f = torchlib.jit.trace(self.f, example_inputs=args) + self.compiled = True + + return self.f(*args, **kws) + + class torch_optimizer: def __init__(self, optimizer: Any) -> None: self.optimizer = optimizer @@ -514,37 +532,43 @@ def value_and_grad( argnums: Union[int, Sequence[int]] = 0, has_aux: bool = False, ) -> Callable[..., Tuple[Any, Any]]: - def ask_require(t: Tensor) -> Any: - t.requires_grad_(True) - return t - - def get_grad(t: Tensor) -> Tensor: - return t.grad - def wrapper(*args: Any, **kws: Any) -> Any: - x = [] - if isinstance(argnums, int): - argnumsl = [argnums] - # if you also call lhs as argnums, something weird may happen - # the reason is that python then take it as local vars - else: - argnumsl = argnums # type: ignore - for i, arg in enumerate(args): - if i in argnumsl: - x.append(self.tree_map(ask_require, arg)) - else: - x.append(arg) - y = f(*x, **kws) - if has_aux: - y[0].backward() - else: - y.backward() - gs = [self.tree_map(get_grad, x[i]) for i in argnumsl] - if len(gs) == 1: - gs = gs[0] - return y, gs + gavf = torchlib.func.grad_and_value(f, argnums=argnums, has_aux=has_aux) + g, v = gavf(*args, **kws) + return v, g return wrapper + # def ask_require(t: Tensor) -> Any: + # t.requires_grad_(True) + # return t + + # def get_grad(t: Tensor) -> Tensor: + # return t.grad + + # def wrapper(*args: Any, **kws: Any) -> Any: + # # x = [] + # if isinstance(argnums, int): + # argnumsl = [argnums] + # # if you also call lhs as argnums, something weird may happen + # # the reason is that python then take it as local vars + # else: + # argnumsl = argnums # type: ignore + # args = list(args) + # for i, arg in enumerate(args): + # if i in argnumsl: + # args[i] = self.tree_map(ask_require, arg) + # args = tuple(args) + # y = f(*args, **kws) + # if has_aux: + # y[0].backward() + # else: + # y.backward() + # gs = [self.tree_map(get_grad, x[i]) for i in argnumsl] + # if len(gs) == 1: + # gs = gs[0] + # return y, gs + + # return wrapper def vjp( self, @@ -577,33 +601,43 @@ def jvp( def vmap( self, f: Callable[..., Any], - vectorized_argnums: Optional[Union[int, Sequence[int]]] = None, + vectorized_argnums: Union[int, Sequence[int]] = 0, ) -> Any: - logger.warning( - "pytorch backend has no intrinsic vmap like interface" - ", use plain for loop for compatibility" - ) - # the vmap support is vey limited, f must return one tensor - # nested list of tensor as return is not supported if isinstance(vectorized_argnums, int): vectorized_argnums = (vectorized_argnums,) def wrapper(*args: Any, **kws: Any) -> Tensor: - results = [] - for barg in zip(*[args[i] for i in vectorized_argnums]): # type: ignore - narg = [] - j = 0 - for k in range(len(args)): - if k in vectorized_argnums: # type: ignore - narg.append(barg[j]) - j += 1 - else: - narg.append(args[k]) - results.append(f(*narg, **kws)) - return torchlib.stack(results) + in_axes = tuple([0 if i in vectorized_argnums else None for i in range(len(args))]) # type: ignore + return torchlib.vmap(f, in_axes, 0)(*args, **kws) return wrapper + # v3 + # logger.warning( + # "pytorch backend has no intrinsic vmap like interface" + # ", use plain for loop for compatibility" + # ) + # # the vmap support is vey limited, f must return one tensor + # # nested list of tensor as return is not supported + # if isinstance(vectorized_argnums, int): + # vectorized_argnums = (vectorized_argnums,) + + # def wrapper(*args: Any, **kws: Any) -> Tensor: + # results = [] + # for barg in zip(*[args[i] for i in vectorized_argnums]): # type: ignore + # narg = [] + # j = 0 + # for k in range(len(args)): + # if k in vectorized_argnums: # type: ignore + # narg.append(barg[j]) + # j += 1 + # else: + # narg.append(args[k]) + # results.append(f(*narg, **kws)) + # return torchlib.stack(results) + + # return wrapper + # v2 # def vmapf(*args: Tensor, **kws: Any) -> Tensor: # r = [] # for i in range(args[0].shape[0]): @@ -613,6 +647,7 @@ def wrapper(*args: Any, **kws: Any) -> Tensor: # return vmapf + # v1 # raise NotImplementedError("pytorch backend doesn't support vmap") # There seems to be no map like architecture in pytorch for now # see https://discuss.pytorch.org/t/fast-way-to-use-map-in-pytorch/70814 @@ -622,8 +657,13 @@ def jit( f: Callable[..., Any], static_argnums: Optional[Union[int, Sequence[int]]] = None, jit_compile: Optional[bool] = None, + **kws: Any ) -> Any: - return f # do nothing here until I figure out what torch.jit is for and how does it work + if jit_compile is True: + # experimental feature reusing the jit_compile flag for tf + return torch_jit_func(f) + return f + # return f # do nothing here until I figure out what torch.jit is for and how does it work # see https://github.com/pytorch/pytorch/issues/36910 def vectorized_value_and_grad( @@ -634,10 +674,33 @@ def vectorized_value_and_grad( has_aux: bool = False, ) -> Callable[..., Tuple[Any, Any]]: # [WIP], not a consistent impl compared to tf and jax backend, but pytorch backend is not fully supported anyway - f = self.value_and_grad(f, argnums=argnums, has_aux=has_aux) - f = self.vmap(f, vectorized_argnums=vectorized_argnums) - # f = self.jit(f) - return f + if isinstance(vectorized_argnums, int): + vectorized_argnums = (vectorized_argnums,) + + def wrapper( + *args: Any, **kws: Any + ) -> Tuple[Tensor, Union[Tensor, Tuple[Tensor, ...]]]: + jf = self.value_and_grad(f, argnums=argnums, has_aux=has_aux) + jf = self.vmap(jf, vectorized_argnums=vectorized_argnums) + vs, gs = jf(*args, **kws) + + if isinstance(argnums, int): + argnums_list = [argnums] + gs = [gs] + else: + argnums_list = argnums # type: ignore + gs = list(gs) + for i, (j, g) in enumerate(zip(argnums_list, gs)): + if j not in vectorized_argnums: # type: ignore + gs[i] = self.tree_map(partial(torchlib.sum, dim=0), g) + if isinstance(argnums, int): + gs = gs[0] + else: + gs = tuple(gs) + + return vs, gs + + return wrapper vvag = vectorized_value_and_grad diff --git a/tensorcircuit/backends/pytorch_ops.py b/tensorcircuit/backends/pytorch_ops.py index 49f10d2a..182101fd 100644 --- a/tensorcircuit/backends/pytorch_ops.py +++ b/tensorcircuit/backends/pytorch_ops.py @@ -90,11 +90,25 @@ class torchqr(torch.autograd.Function): """ @staticmethod - def forward(ctx, a: Array) -> Any: + def forward(a: Array) -> Any: q, r = torch.linalg.qr(a, mode="reduced") - ctx.save_for_backward(a, q, r) + # ctx.save_for_backward(a, q, r) return q, r + # setup_context is responsible for calling methods and/or assigning to + # the ctx object. Please do not do additional compute (e.g. add + # Tensors together) in setup_context. + # https://pytorch.org/docs/master/notes/extending.func.html + @staticmethod + def setup_context(ctx, inputs, output): + (a,) = inputs + q, r = output + # Tensors must be saved via ctx.save_for_backward. Please do not + # assign them directly onto the ctx object. + ctx.save_for_backward(a, q, r) + # Non-tensors may be saved by assigning them as attributes on the ctx object. + # ctx.dim = dim + @staticmethod def backward(ctx, dq: Array, dr: Array) -> Any: a, q, r = ctx.saved_tensors diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 81ec6047..10e065eb 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -732,6 +732,7 @@ def jit( f: Callable[..., Any], static_argnums: Optional[Union[int, Sequence[int]]] = None, jit_compile: Optional[bool] = None, + **kws: Any ) -> Any: # static_argnums not supported in tf case, this is only for a consistent interface # for more on static_argnums in tf.function, see issue: https://github.com/tensorflow/tensorflow/issues/52193 diff --git a/tests/test_backends.py b/tests/test_backends.py index 58daeb69..6a9e6efc 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -18,12 +18,6 @@ import tensorcircuit as tc dtype = np.complex64 -ii = np.eye(4, dtype=dtype) -iir = ii.reshape([2, 2, 2, 2]) -ym = np.array([[0, -1.0j], [1.0j, 0]], dtype=dtype) -zm = np.array([[1.0, 0.0], [0.0, -1.0]], dtype=dtype) -yz = np.kron(ym, zm) -yzr = yz.reshape([2, 2, 2, 2]) def universal_vmap(): @@ -50,9 +44,9 @@ def test_vmap_tf(tfb): assert r.numpy()[0, 0] == 3.0 -@pytest.mark.skip( - reason="pytorch backend to be fixed with newly added complex dtype support" -) +# @pytest.mark.skip( +# reason="pytorch backend to be fixed with newly added complex dtype support" +# ) def test_vmap_torch(torchb): r = universal_vmap() assert r.numpy()[0, 0] == 3.0 @@ -61,6 +55,7 @@ def test_vmap_torch(torchb): def test_grad_torch(torchb): a = tc.backend.ones([2], dtype="float32") + # @partial(tc.backend.jit, jit_compile=True) @tc.backend.grad def f(x): return tc.backend.sum(x) @@ -419,12 +414,13 @@ def vqe_energy(inputs, param, n, nlayers): c.H(i) for j in range(nlayers): for i in range(n - 1): - c.any( - i, - i + 1, - unitary=tc.backend.cos(paramc[2 * j, i]) * iir - + tc.backend.sin(paramc[2 * j, i]) * 1.0j * yzr, - ) + c.ryy(i, i + 1, theta=paramc[2 * j, i]) + # c.any( + # i, + # i + 1, + # unitary=tc.backend.cos(paramc[2 * j, i]) * iir + # + tc.backend.sin(paramc[2 * j, i]) * 1.0j * yzr, + # ) for i in range(n): c.rx(i, theta=paramc[2 * j + 1, i]) e = 0.0 @@ -436,14 +432,14 @@ def vqe_energy(inputs, param, n, nlayers): return e -@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("torchb")]) def test_vvag(backend): n = 4 nlayers = 3 inp = tc.backend.ones([2**n]) / 2 ** (n / 2) param = tc.backend.ones([2 * nlayers, n]) - inp = tc.backend.cast(inp, "complex64") - param = tc.backend.cast(param, "complex64") + # inp = tc.backend.cast(inp, "complex64") + # param = tc.backend.cast(param, "complex64") vqe_energy_p = partial(vqe_energy, n=n, nlayers=nlayers) @@ -456,6 +452,7 @@ def test_vvag(backend): pvag = tc.backend.vvag(vqe_energy_p, argnums=(0, 1)) v1, (g10, g11) = pvag(inps, param) + print(v1.shape, g10.shape, g11.shape) np.testing.assert_allclose(v1[0], v0, atol=1e-4) np.testing.assert_allclose(g10[0], g00, atol=1e-4) np.testing.assert_allclose(g11 / batch, g01, atol=1e-4) From 5441b85754a65677de8339e016cb22f56317a222 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 10 Apr 2023 14:19:02 +0800 Subject: [PATCH 388/725] improve vdc example --- ...ion.py => variational_dynamics_circuit.py} | 51 +++++++++++-------- 1 file changed, 30 insertions(+), 21 deletions(-) rename examples/{quantum_variation.py => variational_dynamics_circuit.py} (89%) diff --git a/examples/quantum_variation.py b/examples/variational_dynamics_circuit.py similarity index 89% rename from examples/quantum_variation.py rename to examples/variational_dynamics_circuit.py index 9e70bea7..4a5a55a1 100644 --- a/examples/quantum_variation.py +++ b/examples/variational_dynamics_circuit.py @@ -1,3 +1,7 @@ +""" +Variational quantum simulation by directly contruct circuit for matrix elements +""" + import math import numpy as np import matplotlib.pyplot as plt @@ -5,7 +9,7 @@ import tensorcircuit as tc tc.set_backend("tensorflow") -tc.set_dtype("complex64") +tc.set_dtype("complex128") # realize R gates in paper @@ -60,7 +64,6 @@ def U_H_gate(k, UHgate): # use quantum circuit to calculate coefficient of variation A and C in paper -@tc.backend.jit def Calculation_A(theta_x, is_k, is_q, ODE_theta): # mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term(k <= q) c = tc.Circuit(N + 1, inputs=np.kron([1, 1] / np.sqrt(2), state)) @@ -87,10 +90,11 @@ def Calculation_A(theta_x, is_k, is_q, ODE_theta): return 2 * pstar - 1 -Calculation_A_vmap = tc.backend.vmap(Calculation_A, vectorized_argnums=[0, 1, 2]) +Calculation_A_vmap = tc.backend.jit( + tc.backend.vmap(Calculation_A, vectorized_argnums=[0, 1, 2]) +) -@tc.backend.jit def Calculation_C(theta_x, is_k, is_q, ODE_theta): # mod: a in paper; theta_x: theta in paper; k, q: A[k, q] or C[k] qth term c = tc.Circuit(N + 1, inputs=np.kron([1, 1] / np.sqrt(2), state)) @@ -118,10 +122,13 @@ def Calculation_C(theta_x, is_k, is_q, ODE_theta): return 2 * pstar - 1 -Calculation_C_vmap = tc.backend.vmap(Calculation_C, vectorized_argnums=[0, 1, 2]) +Calculation_C_vmap = tc.backend.jit( + tc.backend.vmap(Calculation_C, vectorized_argnums=[0, 1, 2]) +) # use original quantum circuit simulate with c +@tc.backend.jit def simulation(ODE_theta): c = tc.Circuit(N, inputs=state) for k in range(len(door)): @@ -143,21 +150,20 @@ def simulation(ODE_theta): c.cry(door[k][1], door[k][2], theta=ODE_theta[k]) if door[k][0] == 8: c.crz(door[k][1], door[k][2], theta=ODE_theta[k]) - return c + return tc.backend.real(c.expectation([tc.gates.x(), [1]])) def numdiff(i): - if i != 0: - return i - 1 - return i + 1 + return (i + 1) % N if __name__ == "__main__": - # l: layers; h and J: coefficient of Hamilton; L_var and L_num: results of variation method and numerical method + # l: layers; h and J: coefficient of Hamiltonian; + # L_var and L_num: results of variation method and numerical method N = 3 - l = 2 + l = 4 J = 1 / 4 - dt = 0.01 + dt = 0.005 t = 1 h = [] L_var = [] @@ -228,7 +234,7 @@ def numdiff(i): H = tc.quantum.PauliStringSum2Dense(ls, weight, numpy=False) # variation realize - ODE_theta = tf.zeros(len(door), dtype="float32") + ODE_theta = tf.zeros(len(door), dtype="float64") for T in range(int(t / dt)): # calculate coefficient in paper A = np.zeros((len(door), len(door))) @@ -253,8 +259,10 @@ def numdiff(i): batch_is_q = tf.constant(batch_is_q) vmap_result = Calculation_A_vmap(batch_theta, batch_is_k, batch_is_q, ODE_theta) A = tf.cast( - tf.tensordot(tf.abs(f), tf.abs(f), 0), dtype="float32" - ) * tf.reshape(tc.backend.real(vmap_result), [len(door), len(door)]) + tf.tensordot(tf.abs(f), tf.abs(f), 0), dtype="float64" + ) * tf.reshape( + tc.backend.cast(vmap_result, dtype="float64"), [len(door), len(door)] + ) batch_theta = [] batch_is_k = [] @@ -276,13 +284,15 @@ def numdiff(i): batch_is_q = tf.constant(batch_is_q) vmap_result = Calculation_C_vmap(batch_theta, batch_is_k, batch_is_q, ODE_theta) C = tf.reduce_sum( - tf.cast(tf.tensordot(tf.abs(f), tf.abs(h), 0), dtype="float32") - * tf.reshape(tc.backend.real(vmap_result), [len(door), len(h_door)]), + tf.cast(tf.tensordot(tf.abs(f), tf.abs(h), 0), dtype="float64") + * tf.reshape( + tc.backend.cast(vmap_result, dtype="float64"), [len(door), len(h_door)] + ), 1, ) # calculate parameter and its derivative - A += np.eye(len(door)) * 1e-5 + A += np.eye(len(door)) * 1e-7 ODE_dtheta = tc.backend.solve(A, C) ODE_theta += ODE_dtheta * dt @@ -291,14 +301,13 @@ def numdiff(i): L_num.append( np.array( tc.backend.real( - tc.expectation([tc.gates.x(), [1]], ket=ep.astype("complex64")) + tc.expectation([tc.gates.x(), [1]], ket=ep.astype("complex128")) ) ) ) # variation results - c = simulation(ODE_theta) - L_var.append(np.real(np.array(c.expectation([tc.gates.x(), [1]]))).tolist()) + L_var.append(tc.backend.numpy(simulation(ODE_theta)).tolist()) x_value.append(round((T + 1) * dt, 3)) print("Now time:", x_value[T], "Loss:", L_num[T] - L_var[T]) From 1da9727bd14b69f3df15092e028a71afdcbdc914 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Mon, 10 Apr 2023 06:26:30 +0000 Subject: [PATCH 389/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 6cd46356..848de62c 100644 --- a/README.md +++ b/README.md @@ -172,6 +172,7 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) 隐公观鱼
隐公观鱼
💻 ⚠️ + WiuYuan
WiuYuan
💡 From 82427ed59f56eef6ff636718d29057fb2fd6f2af Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Mon, 10 Apr 2023 06:26:31 +0000 Subject: [PATCH 390/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 2c2fbf48..610c8223 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -231,6 +231,15 @@ "code", "test" ] + }, + { + "login": "WiuYuan", + "name": "WiuYuan", + "avatar_url": "https://avatars.githubusercontent.com/u/108848998?v=4", + "profile": "https://github.com/WiuYuan", + "contributions": [ + "example" + ] } ], "contributorsPerLine": 6, From 0918eb2e21a643bf50b2bd29b2265ee5771ee0b2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 10 Apr 2023 19:32:34 +0800 Subject: [PATCH 391/725] further simplify the vdc code --- examples/variational_dynamics_circuit.py | 90 +++++++++++++----------- 1 file changed, 48 insertions(+), 42 deletions(-) diff --git a/examples/variational_dynamics_circuit.py b/examples/variational_dynamics_circuit.py index 4a5a55a1..a7098c12 100644 --- a/examples/variational_dynamics_circuit.py +++ b/examples/variational_dynamics_circuit.py @@ -184,10 +184,10 @@ def numdiff(i): f.append(-0.5j) door.append([0, i, numdiff(i)]) for i in range(N - 1): - f.append(-1j) + f.append(-0.5j) door.append([5, i, i + 1]) for i in range(N - 1): - f.append(-1j) + f.append(-0.5j) door.append([3, i, i + 1]) for i in range(N): h.append(1) @@ -235,54 +235,60 @@ def numdiff(i): # variation realize ODE_theta = tf.zeros(len(door), dtype="float64") + + a_batch_theta = [] + a_batch_is_k = [] + a_batch_is_q = [] + for k in range(len(door)): + for q in range(len(door)): + is_k = [0 for _ in range(len(door))] + is_k[k] = 1 + is_q = [0 for _ in range(len(door))] + is_q[q] = 1 + if how_variation == 0: + a_batch_theta.append(np.angle(f[q]) - np.angle(f[k])) + else: + a_batch_theta.append(np.angle(f[q]) - np.angle(f[k]) - math.pi / 2) + a_batch_is_k.append(is_k) + a_batch_is_q.append(is_q) + a_batch_theta = tc.array_to_tensor(a_batch_theta) + a_batch_is_k = tf.constant(a_batch_is_k) + a_batch_is_q = tf.constant(a_batch_is_q) + + c_batch_theta = [] + c_batch_is_k = [] + c_batch_is_q = [] + for k in range(len(door)): + for q in range(len(h_door)): + is_k = [0 for _ in range(len(door))] + is_k[k] = 1 + is_q = [0 for _ in range(len(door))] + is_q[q] = 1 + c_batch_is_k.append(is_k) + c_batch_is_q.append(is_q) + if how_variation == 0: + c_batch_theta.append(np.angle(h[q]) - np.angle(f[k]) - math.pi / 2) + else: + c_batch_theta.append(np.angle(h[q]) - np.angle(f[k]) + math.pi) + c_batch_theta = tc.array_to_tensor(c_batch_theta) + c_batch_is_k = tf.constant(c_batch_is_k) + c_batch_is_q = tf.constant(c_batch_is_q) + for T in range(int(t / dt)): # calculate coefficient in paper - A = np.zeros((len(door), len(door))) - C = np.zeros(len(door)) - batch_theta = [] - batch_is_k = [] - batch_is_q = [] - for k in range(len(door)): - for q in range(len(door)): - is_k = [0 for _ in range(len(door))] - is_k[k] = 1 - is_q = [0 for _ in range(len(door))] - is_q[q] = 1 - if how_variation == 0: - batch_theta.append(np.angle(f[q]) - np.angle(f[k])) - else: - batch_theta.append(np.angle(f[q]) - np.angle(f[k]) - math.pi / 2) - batch_is_k.append(is_k) - batch_is_q.append(is_q) - batch_theta = tc.array_to_tensor(batch_theta) - batch_is_k = tf.constant(batch_is_k) - batch_is_q = tf.constant(batch_is_q) - vmap_result = Calculation_A_vmap(batch_theta, batch_is_k, batch_is_q, ODE_theta) + + vmap_result = Calculation_A_vmap( + a_batch_theta, a_batch_is_k, a_batch_is_q, ODE_theta + ) A = tf.cast( tf.tensordot(tf.abs(f), tf.abs(f), 0), dtype="float64" ) * tf.reshape( tc.backend.cast(vmap_result, dtype="float64"), [len(door), len(door)] ) - batch_theta = [] - batch_is_k = [] - batch_is_q = [] - for k in range(len(door)): - for q in range(len(h_door)): - is_k = [0 for _ in range(len(door))] - is_k[k] = 1 - is_q = [0 for _ in range(len(door))] - is_q[q] = 1 - if how_variation == 0: - batch_theta.append(np.angle(h[q]) - np.angle(f[k]) - math.pi / 2) - else: - batch_theta.append(np.angle(h[q]) - np.angle(f[k]) + math.pi) - batch_is_k.append(is_k) - batch_is_q.append(is_q) - batch_theta = tc.array_to_tensor(batch_theta) - batch_is_k = tf.constant(batch_is_k) - batch_is_q = tf.constant(batch_is_q) - vmap_result = Calculation_C_vmap(batch_theta, batch_is_k, batch_is_q, ODE_theta) + vmap_result = Calculation_C_vmap( + c_batch_theta, c_batch_is_k, c_batch_is_q, ODE_theta + ) C = tf.reduce_sum( tf.cast(tf.tensordot(tf.abs(f), tf.abs(h), 0), dtype="float64") * tf.reshape( From b0d672bc33b8e1ceb0381b5c796ae23c6ae4e43f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Apr 2023 13:01:48 +0800 Subject: [PATCH 392/725] update test suits fiiting gpu platform --- check_all.sh | 2 ++ tests/test_backends.py | 2 +- tests/test_interfaces.py | 1 + 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/check_all.sh b/check_all.sh index 3ef52ecd..84e839ef 100755 --- a/check_all.sh +++ b/check_all.sh @@ -8,6 +8,8 @@ echo "pylint check" pylint tensorcircuit tests examples/*.py echo "pytest check" pytest -n auto --cov=tensorcircuit -vv -W ignore::DeprecationWarning +# for test on gpu machine, please set `export TF_FORCE_GPU_ALLOW_GROWTH=true` for tf +# and `export XLA_PYTHON_CLIENT_PREALLOCATE=false` for jax to avoid OOM in testing echo "sphinx check" cd docs && sphinx-build source build/html && sphinx-build source -D language="zh" build/html_cn echo "all checks passed, congratulation! 💐" diff --git a/tests/test_backends.py b/tests/test_backends.py index 6a9e6efc..f2475e51 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -300,7 +300,7 @@ def test_backend_methods_2(backend): def test_device_cpu_only(backend): a = tc.backend.ones([]) dev_str = tc.backend.device(a) - assert dev_str == "cpu" + assert dev_str in ["cpu", "gpu:0"] tc.backend.device_move(a, dev_str) diff --git a/tests/test_interfaces.py b/tests/test_interfaces.py index b966d189..c950f47f 100644 --- a/tests/test_interfaces.py +++ b/tests/test_interfaces.py @@ -297,6 +297,7 @@ def test_dlpack_transformation(backend): target_backend=b, enable_dlpack=True, ) + ans = tc.interfaces.which_backend(ans).device_move(ans, "cpu") np.testing.assert_allclose(ans, np.ones([2])) From ea06cd8cf2d5397180ba00c3c91d890fd100cf0a Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Apr 2023 15:35:04 +0800 Subject: [PATCH 393/725] add about test --- tests/test_miscs.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/test_miscs.py b/tests/test_miscs.py index 2b5d7c5a..5a40d94e 100644 --- a/tests/test_miscs.py +++ b/tests/test_miscs.py @@ -31,6 +31,10 @@ ] +def test_about(): + print(tc.about()) + + def test_ps2coo(tfb): for l, a in check_pairs: r1 = PauliString2COO(tf.constant(l, dtype=tf.int64)) From ffba4566e894b79c6c8aae04316630682c9d61ef Mon Sep 17 00:00:00 2001 From: liwt31 Date: Fri, 14 Apr 2023 17:29:12 +0800 Subject: [PATCH 394/725] add basic test for cupy backend --- tensorcircuit/backends/cupy_backend.py | 17 ++++++- tensorcircuit/gates.py | 2 +- tests/conftest.py | 12 +++++ tests/test_circuit.py | 61 +++++++++++++++----------- 4 files changed, 64 insertions(+), 28 deletions(-) diff --git a/tensorcircuit/backends/cupy_backend.py b/tensorcircuit/backends/cupy_backend.py index 7d6e92ea..90307f03 100644 --- a/tensorcircuit/backends/cupy_backend.py +++ b/tensorcircuit/backends/cupy_backend.py @@ -8,6 +8,7 @@ from typing import Any, Callable, Optional, Sequence, Tuple, Union import numpy as np +import scipy try: # old version tn compatiblity from tensornetwork.backends import base_backend @@ -62,6 +63,18 @@ def sum( ) -> Tensor: return cp.sum(a, axis=axis, keepdims=keepdims) + def conj(self, tensor: Tensor) -> Tensor: + return tensor.conj() + + def sign(self, tensor: Tensor) -> Tensor: + return cp.sign(tensor) + + def multiply(self, tensor1: Tensor, tensor2: Tensor) -> Tensor: + return tensor1 * tensor2 + + def norm(self, tensor: Tensor) -> Tensor: + return cp.linalg.norm(tensor) + def shape_tuple(self, tensor: Tensor) -> Tuple[int]: return tensor.shape # type:ignore @@ -100,7 +113,7 @@ def copy(self, a: Tensor) -> Tensor: return a.copy() def expm(self, a: Tensor) -> Tensor: - raise NotImplementedError + return self.convert_to_tensor(scipy.linalg.expm(self.numpy(a))) def abs(self, a: Tensor) -> Tensor: return cp.abs(a) @@ -307,7 +320,7 @@ def stateful_randu( dtype = dtype[-2:] if isinstance(shape, int): shape = (shape,) - r = g.uniform(low=low, high=high, size=shape) + r = g.random(shape) * (high - low) + low if dtype == "32": r = r.astype(np.float32) elif dtype == "64": diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index b348c922..1529b389 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -812,7 +812,7 @@ def exponential_gate(unitary: Tensor, theta: float, name: str = "none") -> Gate: :return: Exponential Gate :rtype: Gate """ - theta = num_to_tensor(theta) + theta, unitary = num_to_tensor(theta, unitary) mat = backend.expm(-backend.i() * theta * unitary) dimension = reduce(mul, mat.shape) nolegs = int(np.log(dimension) / np.log(2)) diff --git a/tests/conftest.py b/tests/conftest.py index d0c9b1d2..91185b86 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -48,6 +48,18 @@ def torchb(): pytest.skip("****** No torch backend found, skipping test suit *******") +@pytest.fixture(scope="function") +def cpb(): + try: + tc.set_backend("cupy") + yield + tc.set_backend("numpy") + except ImportError as e: + print(e) + tc.set_backend("numpy") + pytest.skip("****** No cupy backend found, skipping test suit *******") + + @pytest.fixture(scope="function") def highp(): tc.set_dtype("complex128") diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 24aa115c..bbca262f 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -17,7 +17,8 @@ import tensorcircuit as tc -def test_wavefunction(): +@pytest.mark.parametrize("backend", [lf("npb"), lf("cpb")]) +def test_wavefunction(backend): qc = tc.Circuit(2) qc.unitary( 0, @@ -41,15 +42,17 @@ def test_wavefunction(): assert np.real(qc.wavefunction()[2]) == 2 -def test_basics(): +@pytest.mark.parametrize("backend", [lf("npb"), lf("cpb")]) +def test_basics(backend): c = tc.Circuit(2) c.x(0) - np.testing.assert_allclose(c.amplitude("10"), np.array(1.0)) + np.testing.assert_allclose(tc.backend.numpy(c.amplitude("10")), np.array(1.0)) c.CNOT(0, 1) - np.testing.assert_allclose(c.amplitude("11"), np.array(1.0)) + np.testing.assert_allclose(tc.backend.numpy(c.amplitude("11")), np.array(1.0)) -def test_measure(): +@pytest.mark.parametrize("backend", [lf("npb"), lf("cpb")]) +def test_measure(backend): c = tc.Circuit(3) c.H(0) c.h(1) @@ -232,13 +235,16 @@ def f5(key): ) -def test_expectation(): +@pytest.mark.parametrize("backend", [lf("npb"), lf("cpb")]) +def test_expectation(backend): c = tc.Circuit(2) c.H(0) - np.testing.assert_allclose(c.expectation((tc.gates.z(), [0])), 0, atol=1e-7) + np.testing.assert_allclose( + tc.backend.numpy(c.expectation((tc.gates.z(), [0]))), 0, atol=1e-7 + ) -@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("cpb")]) def test_exp1(backend): @partial(tc.backend.jit, jit_compile=True) def sf(): @@ -260,8 +266,8 @@ def s1f(): s1 = c.state() return s1 - s = sf() - s1 = s1f() + s = tc.backend.numpy(sf()) + s1 = tc.backend.numpy(s1f()) np.testing.assert_allclose(s, s1, atol=1e-4) @@ -316,7 +322,8 @@ def test_single_qubit(): np.testing.assert_allclose(w, np.array([1, 1]) / np.sqrt(2), atol=1e-4) -def test_expectation_between_two_states(): +@pytest.mark.parametrize("backend", [lf("npb"), lf("cpb")]) +def test_expectation_between_two_states(backend): zp = np.array([1.0, 0.0]) zd = np.array([0.0, 1.0]) assert tc.expectation((tc.gates.y(), [0]), ket=zp, bra=zd) == 1j @@ -330,7 +337,7 @@ def test_expectation_between_two_states(): x1z2 = [(tc.gates.x(), [0]), (tc.gates.z(), [1])] e1 = c.expectation(*x1z2) e2 = tc.expectation(*x1z2, ket=state, bra=state, normalization=True) - np.testing.assert_allclose(e2, e1) + np.testing.assert_allclose(tc.backend.numpy(e2), tc.backend.numpy(e1)) c = tc.Circuit(3) c.H(0) @@ -341,7 +348,7 @@ def test_expectation_between_two_states(): x1z2 = [(tc.gates.x(), [0]), (tc.gates.z(), [1])] e1 = c.expectation(*x1z2) / tc.backend.norm(state) ** 2 e2 = tc.expectation(*x1z2, ket=state, normalization=True) - np.testing.assert_allclose(e2, e1) + np.testing.assert_allclose(tc.backend.numpy(e2), tc.backend.numpy(e1)) c = tc.Circuit(2) c.X(1) @@ -354,12 +361,12 @@ def test_expectation_between_two_states(): s3 = c3.state() x1x2 = [(tc.gates.x(), [0]), (tc.gates.x(), [1])] e = tc.expectation(*x1x2, ket=s1, bra=s2) - np.testing.assert_allclose(e, 1.0) + np.testing.assert_allclose(tc.backend.numpy(e), 1.0) e2 = tc.expectation(*x1x2, ket=s3, bra=s2) - np.testing.assert_allclose(e2, 1.0 / np.sqrt(2)) + np.testing.assert_allclose(tc.backend.numpy(e2), 1.0 / np.sqrt(2)) -@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("cpb")]) def test_any_inputs_state(backend): c = tc.Circuit(2, inputs=tc.array_to_tensor(np.array([0.0, 0.0, 0.0, 1.0]))) c.X(0) @@ -379,10 +386,10 @@ def test_any_inputs_state(backend): ) c.X(0) z0 = c.expectation((tc.gates.z(), [0])) - np.testing.assert_allclose(z0, 0.0, rtol=1e-4, atol=1e-4) + np.testing.assert_allclose(tc.backend.numpy(z0), 0.0, rtol=1e-4, atol=1e-4) -@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb")]) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("cpb")]) def test_postselection(backend): c = tc.Circuit(3) c.H(1) @@ -390,27 +397,31 @@ def test_postselection(backend): c.mid_measurement(1, 1) c.mid_measurement(2, 1) s = c.wavefunction() - np.testing.assert_allclose(tc.backend.real(s[3]), 0.5) + np.testing.assert_allclose(tc.backend.numpy(s[3]).real, 0.5) -def test_unitary(): +@pytest.mark.parametrize("backend", [lf("npb"), lf("cpb")]) +def test_unitary(backend): c = tc.Circuit(2, inputs=np.eye(4)) c.X(0) c.Y(1) - answer = np.kron(tc.gates.x().tensor, tc.gates.y().tensor) - np.testing.assert_allclose(c.wavefunction().reshape([4, 4]), answer, atol=1e-4) + answer = tc.backend.numpy(np.kron(tc.gates.x().tensor, tc.gates.y().tensor)) + np.testing.assert_allclose( + tc.backend.numpy(c.wavefunction().reshape([4, 4])), answer, atol=1e-4 + ) -def test_expectation_ps(): +@pytest.mark.parametrize("backend", [lf("npb"), lf("cpb")]) +def test_expectation_ps(backend): c = tc.Circuit(2) c.X(0) r = c.expectation_ps(z=[0, 1]) - np.testing.assert_allclose(r, -1, atol=1e-5) + np.testing.assert_allclose(tc.backend.numpy(r), -1, atol=1e-5) c = tc.Circuit(2) c.H(0) r = c.expectation_ps(z=[1], x=[0]) - np.testing.assert_allclose(r, 1, atol=1e-5) + np.testing.assert_allclose(tc.backend.numpy(r), 1, atol=1e-5) def test_probability(): From 1013ebfda28c7f024380252d2551c43d96f05b76 Mon Sep 17 00:00:00 2001 From: liwt31 Date: Mon, 17 Apr 2023 10:44:39 +0800 Subject: [PATCH 395/725] fix cupy backend device --- tensorcircuit/backends/cupy_backend.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/tensorcircuit/backends/cupy_backend.py b/tensorcircuit/backends/cupy_backend.py index 90307f03..a2eeac13 100644 --- a/tensorcircuit/backends/cupy_backend.py +++ b/tensorcircuit/backends/cupy_backend.py @@ -381,22 +381,22 @@ def switch(self, index: Tensor, branches: Sequence[Callable[[], Tensor]]) -> Ten return branches[index]() def device(self, a: Tensor) -> str: - return "gpu" + return self._dev2str(a.device) def device_move(self, a: Tensor, dev: Any) -> Tensor: - if dev == "gpu": - return a - raise ValueError("CuPy backend only support GPU device") + if isinstance(dev, str): + dev = self._str2dev(dev) + with dev: + return cp.asarray(a) def _dev2str(self, dev: Any) -> str: - if dev == "gpu": - return "gpu" - raise ValueError("CuPy backend only support GPU device") + return f"gpu:{dev.id}" def _str2dev(self, str_: str) -> Any: - if str_ == "gpu": - return "gpu" - raise ValueError("CuPy backend only support GPU device") + if str_ == "cpu": + raise ValueError("CuPy backend only support GPU device") + else: + return cp.cuda.Device(int(str_.split(":")[-1])) def stop_gradient(self, a: Tensor) -> Tensor: raise NotImplementedError("CuPy backend doesn't support AD") @@ -422,7 +422,7 @@ def jit( f: Callable[..., Any], static_argnums: Optional[Union[int, Sequence[int]]] = None, jit_compile: Optional[bool] = None, - **kws: Any + **kws: Any, ) -> Callable[..., Any]: logger.warning("CuPy backend has no jit interface, just do nothing") return f From 4882e854767e224f5d29ba15745b9d652a63eac0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 18 Apr 2023 13:20:10 +0800 Subject: [PATCH 396/725] add kws support for torch interface --- CHANGELOG.md | 6 +++ tensorcircuit/interfaces/__init__.py | 2 +- tensorcircuit/interfaces/torch.py | 51 ++++++++++++++++++++- tests/test_interfaces.py | 68 ++++++++++++++++++++++++++++ 4 files changed, 125 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 499e51e7..33d5ceae 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,12 @@ - Torch support is updraded to 2.0, and now support native vmap and native functional grad, and thus `vvag`. Still jit support is conflict with these functional transformations and be turned off by default +- Add `torch_interfaces_kws` that support static keyword arguments when wrapping with the interface + +### Fixed + +- Add tests and fixed some missing methods for cupy backend, cupy backend is now ready to use (though still not guaranteed) + ## 0.8.0 ### Added diff --git a/tensorcircuit/interfaces/__init__.py b/tensorcircuit/interfaces/__init__.py index b9d23a09..f257d387 100644 --- a/tensorcircuit/interfaces/__init__.py +++ b/tensorcircuit/interfaces/__init__.py @@ -12,5 +12,5 @@ ) from .numpy import numpy_interface, np_interface from .scipy import scipy_interface, scipy_optimize_interface -from .torch import torch_interface, pytorch_interface +from .torch import torch_interface, pytorch_interface, torch_interface_kws from .tensorflow import tensorflow_interface, tf_interface diff --git a/tensorcircuit/interfaces/torch.py b/tensorcircuit/interfaces/torch.py index 4efd08da..8dee6163 100644 --- a/tensorcircuit/interfaces/torch.py +++ b/tensorcircuit/interfaces/torch.py @@ -2,7 +2,8 @@ Interface wraps quantum function as a torch function """ -from typing import Any, Callable, Tuple +from typing import Any, Callable, Dict, Tuple +from functools import partial from ..cons import backend from ..utils import is_sequence @@ -112,3 +113,51 @@ def backward(ctx: Any, *grad_y: Any) -> Any: pytorch_interface = torch_interface + + +def torch_interface_kws( + f: Callable[..., Any], jit: bool = True, enable_dlpack: bool = False +) -> Callable[..., Any]: + """ + similar to py:meth:`tensorcircuit.interfaces.torch.torch_interface`, + but now the interface support static arguments for function ``f``, + which is not a tensor and can be used with keyword arguments + + :Example: + + .. code-block:: python + + tc.set_backend("tensorflow") + + def f(tensor, integer): + r = 0. + for i in range(integer): + r += tensor + return r + + fnew = torch_interface_kws(f) + + print(fnew(torch.ones([2]), integer=3)) + print(fnew(torch.ones([2]), integer=4)) + + :param f: _description_ + :type f: Callable[..., Any] + :param jit: _description_, defaults to True + :type jit: bool, optional + :param enable_dlpack: _description_, defaults to False + :type enable_dlpack: bool, optional + :return: _description_ + :rtype: Callable[..., Any] + """ + cache_dict: Dict[Tuple[Any, ...], Callable[..., Any]] = {} + + def wrapper(*args: Any, **kws: Any) -> Any: + key = tuple([(k, v) for k, v in kws.items()]) + if key not in cache_dict: + fnew = torch_interface( + partial(f, **kws), jit=jit, enable_dlpack=enable_dlpack + ) + cache_dict[key] = fnew + return cache_dict[key](*args) + + return wrapper diff --git a/tests/test_interfaces.py b/tests/test_interfaces.py index c950f47f..a8655c2b 100644 --- a/tests/test_interfaces.py +++ b/tests/test_interfaces.py @@ -108,6 +108,74 @@ def f3(x): np.testing.assert_allclose(pg, 2 * np.ones([2]).astype(np.complex64), atol=1e-5) +@pytest.mark.skipif(is_torch is False, reason="torch not installed") +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_torch_interface_kws(backend): + def f(param, n): + c = tc.Circuit(n) + c = tc.templates.blocks.example_block(c, param) + loss = c.expectation( + [ + tc.gates.x(), + [ + 1, + ], + ] + ) + return tc.backend.real(loss) + + f_jit_torch = tc.interfaces.torch_interface_kws(f, jit=True, enable_dlpack=True) + + param = torch.ones([4, 4], requires_grad=True) + l = f_jit_torch(param, n=4) + l = l**2 + l.backward() + + pg = param.grad + np.testing.assert_allclose(pg.shape, [4, 4]) + np.testing.assert_allclose(pg[0, 1], -2.146e-3, atol=1e-5) + + def f2(paramzz, paramx, n, nlayer): + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayer): # 2 + for i in range(n - 1): + c.exp1(i, i + 1, unitary=tc.gates._zz_matrix, theta=paramzz[j, i]) + for i in range(n): + c.rx(i, theta=paramx[j, i]) + loss1 = c.expectation( + [ + tc.gates.x(), + [ + 1, + ], + ] + ) + loss2 = c.expectation( + [ + tc.gates.x(), + [ + 2, + ], + ] + ) + return tc.backend.real(loss1), tc.backend.real(loss2) + + f2_torch = tc.interfaces.torch_interface_kws(f2, jit=True, enable_dlpack=True) + + paramzz = torch.ones([2, 4], requires_grad=True) + paramx = torch.ones([2, 4], requires_grad=True) + + l1, l2 = f2_torch(paramzz, paramx, n=4, nlayer=2) + l = l1 - l2 + l.backward() + + pg = paramzz.grad + np.testing.assert_allclose(pg.shape, [2, 4]) + np.testing.assert_allclose(pg[0, 0], -0.41609, atol=1e-5) + + @pytest.mark.skipif(is_torch is False, reason="torch not installed") @pytest.mark.xfail( (int(tf.__version__.split(".")[1]) < 9) From 2c3caac7c8fe8fd2d60a2222cd2b373ff5bfee7f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 18 Apr 2023 13:57:59 +0800 Subject: [PATCH 397/725] fix some docs --- CHANGELOG.md | 2 +- tensorcircuit/interfaces/torch.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 33d5ceae..bca1c5fa 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,7 +4,7 @@ ### Added -- Add `tc.about()` to print related software versions and configs. +- Add `tc.about()` to print related software versions and configs - Torch support is updraded to 2.0, and now support native vmap and native functional grad, and thus `vvag`. Still jit support is conflict with these functional transformations and be turned off by default diff --git a/tensorcircuit/interfaces/torch.py b/tensorcircuit/interfaces/torch.py index 8dee6163..f4dd182c 100644 --- a/tensorcircuit/interfaces/torch.py +++ b/tensorcircuit/interfaces/torch.py @@ -135,7 +135,7 @@ def f(tensor, integer): r += tensor return r - fnew = torch_interface_kws(f) + fnew = tc.interfaces.torch_interface_kws(f) print(fnew(torch.ones([2]), integer=3)) print(fnew(torch.ones([2]), integer=4)) From f17f2cd78c148f380ae36031b86e27f28762b9c4 Mon Sep 17 00:00:00 2001 From: JAllcock Date: Wed, 19 Apr 2023 11:27:38 +0800 Subject: [PATCH 398/725] QAOA tutorial for portfolio optimization --- .../qaoa_portfolio_optimization.ipynb | 577 ++++++++++++++++++ 1 file changed, 577 insertions(+) create mode 100644 docs/source/tutorials/qaoa_portfolio_optimization.ipynb diff --git a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb new file mode 100644 index 00000000..488dec3d --- /dev/null +++ b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb @@ -0,0 +1,577 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6e228419-e835-4860-ac03-946eb02d08bb", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "from functools import partial" + ] + }, + { + "cell_type": "markdown", + "id": "6ddb8a88-779a-43f7-ae14-115463bd87f5", + "metadata": {}, + "source": [ + "### Solving QUBO problems using QAOA\n", + "\n", + "Here we show how to solve a quadratic unconstrained binary optimization (QUBO) problem using QAOA. Later on below we will extend this to show how to solve binary Markowitz portfolio optimization problems.\n", + "\n", + "Consider minimizing the following 2x2 QUBO objective function:\n", + "\n", + "$\\begin{pmatrix}x_1 & x_2\\end{pmatrix}\\begin{pmatrix}-5& -2 \\\\-2 & 6\\end{pmatrix}\\begin{pmatrix}x_1\\\\x_2\\end{pmatrix} = -5x_1^2 -4x_1x_2 +6x_2^2$\n", + "\n", + "Clearly this is minimized at $(x_1,x_2) = (1,0)$, with corresponding objective function value of $-5$\n", + "\n", + "We first convert this to an Ising Hamiltonian by mapping $x_i\\rightarrow \\frac{I-Z_i}{2}$\n", + "\n", + "This gives\n", + "\n", + "$$-\\frac{5}{4}(I-Z_1)^2 -\\frac{4}{4}(I-Z_1)(I-Z_2) + \\frac{6}{4}(I-Z_2)^2 $$\n", + "\n", + "which simplifies to\n", + "\n", + "$$-\\frac{1}{2}I +\\frac{7}{2}Z_1 -2Z_2 -Z_1Z_2$$ \n", + "\n", + "The $-I/2$ term is simply a constant offset, so we can solve the problem by finding the minimum of \n", + "$$\\langle \\psi | \\frac{7}{2}Z_1 -2Z_2 -Z_1Z_2 |\\psi\\rangle$$ \n", + "Note that the minimum should correspond to the computational basis state $|10\\rangle$, and the corresponding true objective function value should be $-4.5$ (ignoring the offset value of $-1/2$)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4006848a-1a2f-407a-9f80-63e75ea0d3a4", + "metadata": {}, + "outputs": [], + "source": [ + "# we first manually encode the terms (-7/2) Z_1 - 2 Z_2 - Z_1Z_2 as:\n", + "pauli_terms = [\n", + " [1, 0],\n", + " [0, 1],\n", + " [1, 1],\n", + "] # see the TensorCircuit whitepaper for 'pauli structures'\n", + "weights = [7 / 2, -2, -1]\n", + "\n", + "# see below for a function to generate the pauli terms and weights from the QUBO matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d197cf4a-1bad-4470-a846-998bfe68ba3c", + "metadata": {}, + "outputs": [], + "source": [ + "# Now we define the QAOA ansatz of depth nlayers\n", + "def QAOA_from_Ising(params, nlayers, pauli_terms, weights):\n", + " nqubits = len(pauli_terms[0])\n", + " c = tc.Circuit(nqubits)\n", + " for i in range(nqubits):\n", + " c.h(i)\n", + " for j in range(nlayers):\n", + " for k in range(len(pauli_terms)):\n", + " term = pauli_terms[k]\n", + " index_of_ones = []\n", + " for l in range(len(term)):\n", + " if term[l] == 1:\n", + " index_of_ones.append(l)\n", + " if len(index_of_ones) == 1:\n", + " c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j])\n", + " elif len(index_of_ones) == 2:\n", + " c.exp1(\n", + " index_of_ones[0],\n", + " index_of_ones[1],\n", + " unitary=tc.gates._zz_matrix,\n", + " theta=weights[k] * params[2 * j],\n", + " )\n", + " else:\n", + " raise ValueError(\"Invalid number of Z terms\")\n", + "\n", + " for i in range(nqubits):\n", + " c.rx(i, theta=params[2 * j + 1]) # mixing terms\n", + " return c" + ] + }, + { + "cell_type": "markdown", + "id": "cb38c120-500a-44cc-96ec-fb5ceb11032d", + "metadata": {}, + "source": [ + "For a general state that is the output of a quantum circuit c, we first define the corresponding loss with respect to the Ising Hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "88cec9cf-3ab6-4a4c-b743-ed95ee8c3817", + "metadata": {}, + "outputs": [], + "source": [ + "def Ising_loss(c, pauli_terms, weights):\n", + " loss = 0.0\n", + " for k in range(len(pauli_terms)):\n", + " term = pauli_terms[k]\n", + " index_of_ones = []\n", + "\n", + " for l in range(len(term)):\n", + " if term[l] == 1:\n", + " index_of_ones.append(l)\n", + "\n", + " if len(index_of_ones) == 1:\n", + " delta_loss = weights[k] * c.expectation_ps(z=[index_of_ones[0]])\n", + "\n", + " else:\n", + " delta_loss = weights[k] * c.expectation_ps(\n", + " z=[index_of_ones[0], index_of_ones[1]]\n", + " )\n", + "\n", + " loss += delta_loss\n", + "\n", + " return K.real(loss)" + ] + }, + { + "cell_type": "markdown", + "id": "30a3aa96-7823-4337-9b2f-5170502bb893", + "metadata": {}, + "source": [ + "For the particular case of a circuit corresponding to a QAOA ansatz this is:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "26e4bec2-ce5b-4d0d-9e06-c80fda20619f", + "metadata": {}, + "outputs": [], + "source": [ + "def QAOA_loss(nlayers, pauli_terms, weights, params):\n", + " c = QAOA_from_Ising(params, nlayers, pauli_terms, weights)\n", + " return Ising_loss(c, pauli_terms, weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ca8b7a76-5c4f-4ad8-9173-90126b8bb93b", + "metadata": {}, + "outputs": [], + "source": [ + "K = tc.set_backend(\"tensorflow\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d5b1897f-cd77-4cd3-bd3b-ece64e6004fc", + "metadata": {}, + "outputs": [], + "source": [ + "def QAOA_solve(pauli_terms, weights, nlayers, iterations):\n", + " print_every = 100\n", + " learning_rate = 1e-2\n", + "\n", + " loss_val_grad = K.value_and_grad(partial(QAOA_loss, nlayers, pauli_terms, weights))\n", + " loss_val_grad_jit = K.jit(loss_val_grad)\n", + "\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(learning_rate))\n", + "\n", + " params = K.implicit_randn(shape=[2 * nlayers], stddev=0.5)\n", + " print(f\"initial params: {params}\")\n", + " for i in range(iterations):\n", + " loss, grads = loss_val_grad_jit(params)\n", + " if i % print_every == 0:\n", + " print(K.numpy(loss))\n", + " params = opt.update(grads, params)\n", + "\n", + " return params" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2bc533da-b4f2-4ffb-b486-c65880a30a6d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "initial params: [ 0.39931756 -0.49578992 -0.22545011 -0.40585193]\n", + "-2.1728685\n", + "-4.177884\n", + "-4.2291102\n", + "-4.2291365\n", + "-4.229136\n" + ] + } + ], + "source": [ + "iterations = 500\n", + "nlayers = 2\n", + "final_params = QAOA_solve(pauli_terms, weights, nlayers, iterations)" + ] + }, + { + "cell_type": "markdown", + "id": "e93d8cbe-2884-4f0a-80f8-3b600194927b", + "metadata": {}, + "source": [ + "We note that for nlayers=2 and 500 iterations, the objective function does not in this case (although it depends on the initial parameters)converge to the true value of $-4.5$. However, the we see below that the final wavefunction does have large overlap with the desired state $|10\\rangle$, so measuring the output of the QAOA algorithm will, with high probability, output the correct answer." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "294ea9ce-5064-4176-94d0-8dbb7d1707f8", + "metadata": {}, + "outputs": [], + "source": [ + "def print_output(c):\n", + " n = c._nqubits\n", + " N = 2**n\n", + " x_label = r\"$\\left|{0:0\" + str(n) + r\"b}\\right>$\"\n", + " labels = [x_label.format(i) for i in range(N)]\n", + " plt.bar(range(N), c.probability())\n", + " plt.xticks(range(N), labels, rotation=70);" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "fc1353ab-7a7a-4cdc-931c-3b90417c4961", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c = QAOA_from_Ising(final_params, nlayers, pauli_terms, weights)\n", + "\n", + "print_output(c)" + ] + }, + { + "cell_type": "markdown", + "id": "d155c5e5-5843-4bba-9edc-595a18cb0c9a", + "metadata": {}, + "source": [ + "### General Case\n", + "For the general QUBO case, we wish to minimize\n", + "$$ x^T Q x$$\n", + "where $x\\in\\{0,1\\}^n$ and $Q\\in\\mathbb{R}^{n\\times n}$ is a real symmetric matrix.\n", + "\n", + "This maps to an Ising Hamiltonian \n", + "$$\\frac{1}{2}\\left(\\sum_{i=1}^n C_{ii} + \\sum_{i 0 $: risk-appetite\n", + "* $\\Sigma \\in \\mathbb{R}^{n\\times n}$: covariance matrix of the assets\n", + "* $\\mu\\in\\mathbb{R}^n$: mean return of the assets\n", + "* $B$: budget (i.e., total number of assets out of $n$ that can be selected)\n", + "\n", + "Our first step is to convert this constrained quadratic programming problem into a QUBO. We do this by adding a penalty factor $t$ and consider the alternative problem:\n", + "\n", + "$$ \\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^Tx + t(1^Tx-B)^2$$\n", + "\n", + "The variables in the linear terms $\\mu^Tx = \\mu_1 x_1 + \\mu_2 x_2+\\ldots$ can all be squared (since they are boolean variables), i.e. we can consider\n", + "\n", + "$$\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\sum_{i=1}^n\\mu_i x_i^2 + t(1^Tx-B)^2$$\n", + "which is a QUBO defined by the matrix $Q$ \n", + "\n", + "$$ Q = q\\Sigma -\\mu\\begin{pmatrix}1 & \\\\ & 1\\\\ & & \\ddots\\end{pmatrix} + t\\begin{pmatrix}1 -2B & 1 & \\ldots & 1 \\\\\n", + "1 & 1-2B & 1 & \\ldots \\\\1 & 1 & 1-2B \\\\\n", + "\\vdots\\end{pmatrix}$$\n", + "i.e., we wish to mimimize\n", + "$$ x^T Q X + tB$$\n", + "and we ignore the constant term $t B$.\n", + "We can now solve this by QAOA as above.\n", + "\n", + "Let us first define a function to convert portfolio data into a QUBO matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3080b901-fb6c-4bda-8348-c96540cbc39a", + "metadata": {}, + "outputs": [], + "source": [ + "def QUBO_from_portfolio(cov, mean, q, B, t):\n", + " # cov: n x n covariance numpy array\n", + " # mean: numpy array of means\n", + " n = cov.shape[0]\n", + " R = np.diag(mean)\n", + " S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n))\n", + "\n", + " Q = q * cov - R + t * S\n", + " return Q" + ] + }, + { + "cell_type": "markdown", + "id": "b4cdcb0e-15a2-461c-b487-084488486c67", + "metadata": {}, + "source": [ + "We can test this using the qiskit_finance package to generate some stock covariance and mean data:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "2168c69e-73ce-4306-8a39-4ddc475acc8f", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "from qiskit_finance.data_providers import RandomDataProvider" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6a7bc671-a496-4cd8-b954-50a280b5dd85", + "metadata": {}, + "outputs": [], + "source": [ + "num_assets = 4\n", + "seed = 123\n", + "\n", + "# Generate expected return and covariance matrix from (random) time-series\n", + "stocks = [(\"TICKER%s\" % i) for i in range(num_assets)]\n", + "data = RandomDataProvider(\n", + " tickers=stocks,\n", + " start=datetime.datetime(2016, 1, 1),\n", + " end=datetime.datetime(2016, 1, 30),\n", + " seed=seed,\n", + ")\n", + "data.run()\n", + "\n", + "mu = data.get_period_return_mean_vector()\n", + "sigma = data.get_period_return_covariance_matrix()" + ] + }, + { + "cell_type": "markdown", + "id": "f6dc53d4-7ed0-436d-aa1f-8674c56e756e", + "metadata": {}, + "source": [ + "Using this mean and covariance data, we can now define our portfolio optimization problem, convert it to a QUBO matrix, and then extract the pauli terms and weights" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "3f6edcd5-3c10-49fc-86ea-160fc6d3187e", + "metadata": {}, + "outputs": [], + "source": [ + "q = 0.5\n", + "budget = 3 # Note that in this example, there are 4 assets, but a budget of only 3\n", + "penalty = 3\n", + "\n", + "Q = QUBO_from_portfolio(sigma, mu, q, budget, penalty)\n", + "portfolio_pauli_terms, portfolio_weights, portfolio_offset = QUBO_to_Ising(Q)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "809b90fa-7047-4c88-b862-355da4f58a50", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0000: 21.006979417669037\n", + "0001: 6.006208358124514\n", + "0010: 6.006857249462996\n", + "0011: -2.994037697463167\n", + "0100: 6.007889613170697\n", + "0101: -2.992836964752989\n", + "0110: -2.992179512275861\n", + "0111: -5.9930299775811875\n", + "1000: 5.992965725313347\n", + "1001: -3.007905195444355\n", + "1010: -3.0070278423618397\n", + "1011: -6.008022650501182\n", + "1100: -3.0060506769683\n", + "1101: -6.006877116105166\n", + "1110: -6.005991201884008\n", + "1111: -3.006941528402507\n" + ] + } + ], + "source": [ + "# Brute force search over classical results for comparison before we run QAOA\n", + "for i in range(2):\n", + " for j in range(2):\n", + " for k in range(2):\n", + " for l in range(2):\n", + " x = np.array([i, j, k, l])\n", + " print(f\"{i}{j}{k}{l}: {np.dot(x,np.dot(Q,x))- portfolio_offset}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b5e69a34-87dc-47b4-aeb2-3b9a03fd0974", + "metadata": {}, + "source": [ + "We see that, due to the penalty, the lowest energy solutions correspond to 0111, 1011, 1101, 1110, i.e. the portfolios with only 3 assets." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "80c1de6c-d3a4-4ea5-922a-bffb59dd1ea3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "initial params: [ 0.13778198 -0.75357753 -0.01271329 -0.5461785 -0.1501883 0.36323363]\n", + "-4.204754\n", + "-5.681799\n", + "-5.6837077\n", + "-5.6837044\n", + "-5.6837053\n", + "-5.683704\n", + "-5.6837063\n", + "-5.683709\n", + "-5.6837063\n", + "-5.683705\n" + ] + } + ], + "source": [ + "iterations = 1000\n", + "nlayers = 3\n", + "final_params = QAOA_solve(portfolio_pauli_terms, portfolio_weights, nlayers, iterations)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "8a9064e3-0c61-4d2d-baf9-bdf120c0331d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c_final = QAOA_from_Ising(\n", + " final_params, nlayers, portfolio_pauli_terms, portfolio_weights\n", + ")\n", + "print_output(c_final)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 206160a5c67292d089b7679b69f5074deeee4559 Mon Sep 17 00:00:00 2001 From: JAllcock Date: Wed, 19 Apr 2023 11:43:52 +0800 Subject: [PATCH 399/725] added comment on qiskit verison to QAOA tutorial for portfolio optimization --- docs/source/tutorials/qaoa_portfolio_optimization.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb index 488dec3d..edddc61b 100644 --- a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb +++ b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb @@ -390,7 +390,9 @@ "id": "b4cdcb0e-15a2-461c-b487-084488486c67", "metadata": {}, "source": [ - "We can test this using the qiskit_finance package to generate some stock covariance and mean data:" + "We can test this using the qiskit_finance package to generate some stock covariance and mean data:\n", + "\n", + "*Note that this was tested with qiskit version 0.39.3 and qiskit-finance version 0.3.4.*" ] }, { From 54000796218afdb5cdd4e911d07bde259fcd6e28 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 19 Apr 2023 12:30:34 +0800 Subject: [PATCH 400/725] refactor the finance tutorial a bit --- docs/source/tutorial.rst | 3 +- docs/source/tutorials/qaoa.ipynb | 123 ++++++++++-------- .../qaoa_portfolio_optimization.ipynb | 45 ++++--- 3 files changed, 97 insertions(+), 74 deletions(-) diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index b7dcf31f..2596f072 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -19,4 +19,5 @@ Jupyter Tutorials tutorials/optimization_and_expressibility.ipynb tutorials/vqex_mbl.ipynb tutorials/dqas.ipynb - tutorials/barren_plateaus.ipynb \ No newline at end of file + tutorials/barren_plateaus.ipynb + tutorials/qaoa_portfolio_optimization.ipynb \ No newline at end of file diff --git a/docs/source/tutorials/qaoa.ipynb b/docs/source/tutorials/qaoa.ipynb index 82460c81..647818e9 100644 --- a/docs/source/tutorials/qaoa.ipynb +++ b/docs/source/tutorials/qaoa.ipynb @@ -2,41 +2,46 @@ "cells": [ { "cell_type": "markdown", + "id": "dc0db886", + "metadata": {}, "source": [ "# Quantum Approximation Optimization Algorithm (QAOA)" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "aecf6615", + "metadata": {}, "source": [ "## Overview" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "ddada0ca", + "metadata": {}, "source": [ "QAOA is a hybrid classical-quantum algorithm that combines quantum circuits, and classical optimization of those circuits. In this tutorial, we utilize QAOA to solve the maximum cut (MAX CUT) combinatorial optimization problem: Given a graph $G=(V, E)$ with nodes $V$ and edges $E$, find a subset $S \\in V$ such that the number of edges between $S$ and $S \\backslash V$ is maximized. And this problem can be reduced to that of finding the ground state of an antiferromagnetic Ising model whose Hamiltonian reads:\n", "\n", "$$H_C = \\frac{1}{2} \\sum_{i,j\\in E} C_{ij} \\sigma^{z}_{i} \\sigma^{z}_{j},$$\n", "\n", "where $\\sigma^{z}_{i}$ is the Pauli-z matrix on $i$th qubit and $C_{ij}$ is the weight of the edge between nodes $i$ and $j$. We set $C_{ij}=1$ for simplicity. If $\\sigma^{z}_{i}=\\sigma^{z}_{j}$, $i,j\\in S$ or $i,j\\in S \\backslash V$; if $\\sigma^{z}_{i}= -\\sigma^{z}_{j}$, $i\\in S, j\\in S \\backslash V$ or $i\\in S \\backslash V, j \\in S$. Obviously, the number of edges between $S$ and $S \\backslash V$ is maximized with the graph structure decoded from the ground state." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "940fa22b", + "metadata": {}, "source": [ "## Setup" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 1, + "id": "b0def04d", + "metadata": {}, + "outputs": [], "source": [ "import tensorcircuit as tc\n", "import tensorflow as tf\n", @@ -46,20 +51,33 @@ "\n", "nlayers = 3 # the number of layers\n", "ncircuits = 2 # the number of circuits with different initial parameters" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "6e407437", + "metadata": {}, "source": [ "## Define the Graph" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 2, + "id": "14a19854", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def dict2graph(d):\n", " g = nx.to_networkx_graph(d)\n", @@ -85,42 +103,34 @@ "}\n", "\n", "example_graph = dict2graph(example_graph_dict)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {} - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "c944f6dd", + "metadata": {}, "source": [ "## Parameterized Quantum Circuit (PQC)" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "021d2cb8", + "metadata": {}, "source": [ "The PQC with $p$ layers can be written as:\n", "$$\n", "U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", "$$\n", "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ and $V_{j}= e^{-i \\beta_{j} \\sum_{k} \\sigma^{x}_{k}}$." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 3, + "id": "055d1257", + "metadata": {}, + "outputs": [], "source": [ "def QAOAansatz(params, g=example_graph):\n", " n = len(g.nodes) # the number of nodes\n", @@ -147,45 +157,36 @@ " loss += c.expectation_ps(z=[e[0], e[1]])\n", "\n", " return K.real(loss)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "id": "5b159920", + "metadata": {}, "source": [ "## Main Optimization Loop" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 4, + "id": "b8d63c5d", + "metadata": {}, + "outputs": [], "source": [ "# use vvag to get the losses and gradients with different random circuit instances\n", "QAOA_vvag = K.jit(tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 5, - "source": [ - "params = K.implicit_randn(\n", - " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", - ") # initial parameters\n", - "opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", - "\n", - "for i in range(50):\n", - " loss, grads = QAOA_vvag(params, example_graph)\n", - " print(K.numpy(loss))\n", - " params = opt.update(grads, params) # gradient descent" - ], + "id": "c51b17a7", + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "[-0.23837963 -1.1651934 ]\n", "[-0.5175445 -1.4539642]\n", @@ -240,7 +241,17 @@ ] } ], - "metadata": {} + "source": [ + "params = K.implicit_randn(\n", + " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", + ") # initial parameters\n", + "opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "for i in range(50):\n", + " loss, grads = QAOA_vvag(params, example_graph)\n", + " print(K.numpy(loss))\n", + " params = opt.update(grads, params) # gradient descent" + ] } ], "metadata": { @@ -259,9 +270,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.8.0" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb index edddc61b..3d0ca7e8 100644 --- a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb +++ b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb @@ -1,25 +1,13 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "6e228419-e835-4860-ac03-946eb02d08bb", - "metadata": {}, - "outputs": [], - "source": [ - "import tensorcircuit as tc\n", - "import numpy as np\n", - "import tensorflow as tf\n", - "import matplotlib.pyplot as plt\n", - "from functools import partial" - ] - }, { "cell_type": "markdown", "id": "6ddb8a88-779a-43f7-ae14-115463bd87f5", "metadata": {}, "source": [ - "### Solving QUBO problems using QAOA\n", + "# Solving QUBO problems using QAOA\n", + "\n", + "## Overview\n", "\n", "Here we show how to solve a quadratic unconstrained binary optimization (QUBO) problem using QAOA. Later on below we will extend this to show how to solve binary Markowitz portfolio optimization problems.\n", "\n", @@ -44,6 +32,28 @@ "Note that the minimum should correspond to the computational basis state $|10\\rangle$, and the corresponding true objective function value should be $-4.5$ (ignoring the offset value of $-1/2$)" ] }, + { + "cell_type": "markdown", + "id": "8176aa81", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45964c1f", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "from functools import partial" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -275,7 +285,8 @@ "id": "d155c5e5-5843-4bba-9edc-595a18cb0c9a", "metadata": {}, "source": [ - "### General Case\n", + "## General Case\n", + "\n", "For the general QUBO case, we wish to minimize\n", "$$ x^T Q x$$\n", "where $x\\in\\{0,1\\}^n$ and $Q\\in\\mathbb{R}^{n\\times n}$ is a real symmetric matrix.\n", @@ -571,7 +582,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.15" + "version": "3.8.0" } }, "nbformat": 4, From 666355d805ae05d1e7fed9787f5bebb15c683653 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 19 Apr 2023 13:49:36 +0800 Subject: [PATCH 401/725] fix formula format in tutorial --- docs/source/tutorials/qaoa_portfolio_optimization.ipynb | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb index 3d0ca7e8..613fd5b1 100644 --- a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb +++ b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb @@ -28,7 +28,9 @@ "$$-\\frac{1}{2}I +\\frac{7}{2}Z_1 -2Z_2 -Z_1Z_2$$ \n", "\n", "The $-I/2$ term is simply a constant offset, so we can solve the problem by finding the minimum of \n", + "\n", "$$\\langle \\psi | \\frac{7}{2}Z_1 -2Z_2 -Z_1Z_2 |\\psi\\rangle$$ \n", + "\n", "Note that the minimum should correspond to the computational basis state $|10\\rangle$, and the corresponding true objective function value should be $-4.5$ (ignoring the offset value of $-1/2$)" ] }, @@ -288,10 +290,13 @@ "## General Case\n", "\n", "For the general QUBO case, we wish to minimize\n", + "\n", "$$ x^T Q x$$\n", + "\n", "where $x\\in\\{0,1\\}^n$ and $Q\\in\\mathbb{R}^{n\\times n}$ is a real symmetric matrix.\n", "\n", "This maps to an Ising Hamiltonian \n", + "\n", "$$\\frac{1}{2}\\left(\\sum_{i=1}^n C_{ii} + \\sum_{i Date: Wed, 19 Apr 2023 14:05:17 +0800 Subject: [PATCH 402/725] fix formula again --- docs/source/tutorials/qaoa_portfolio_optimization.ipynb | 3 +++ 1 file changed, 3 insertions(+) diff --git a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb index 613fd5b1..7f390853 100644 --- a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb +++ b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb @@ -354,8 +354,11 @@ "In a simple boolean Markowitz portfolio optimization problem, we wish to solve \n", "\n", "$$\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^T x$$\n", + "\n", "subject to \n", + "\n", "$$ 1^T x = B$$\n", + "\n", "where \n", "* $n$: number of assets under consideration\n", "* $q > 0 $: risk-appetite\n", From 18ff63a4261855d2cfb185a52e3dd6065ff71517 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 19 Apr 2023 16:31:42 +0800 Subject: [PATCH 403/725] add tensor consitency chapter in sharp bits --- docs/source/sharpbits.rst | 47 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/docs/source/sharpbits.rst b/docs/source/sharpbits.rst index ffce825c..a48edfab 100644 --- a/docs/source/sharpbits.rst +++ b/docs/source/sharpbits.rst @@ -141,6 +141,53 @@ Similarly, conditional gate application must be takend carefully. # +Tensor variables consistency +------------------------------------------------------- + + +All tensor variables' backend (tf vs jax vs ..), dtype (float vs complex), shape and device (cpu vs gpu) must be compatible/consistent. + +Inspect the backend, dtype, shape and device using the following codes. + +.. code-block:: python + + for backend in ["numpy", "tensorflow", "jax", "pytorch"]: + with tc.runtime_backend(backend): + a = tc.backend.ones([2, 3]) + print("tensor backend:", tc.interfaces.which_backend(a)) + print("tensor dtype:", tc.backend.dtype(a)) + print("tensor shape:", tc.backend.shape_tuple(a)) + print("tensor device:", tc.backend.device(a)) + +If the backend is inconsistent, one can convert the tensor backend via :py:meth:`tensorcircuit.interfaces.tensortrans.general_args_to_backend`. + +.. code-block:: python + + for backend in ["numpy", "tensorflow", "jax", "pytorch"]: + with tc.runtime_backend(backend): + a = tc.backend.ones([2, 3]) + print("tensor backend:", tc.interfaces.which_backend(a)) + b = tc.interfaces.general_args_to_backend(a, target_backend="jax", enable_dlpack=False) + print("tensor backend:", tc.interfaces.which_backend(b)) + +If the dtype is inconsistent, one can convert the tensor dtype using ``tc.backend.cast``. + +.. code-block:: python + + for backend in ["numpy", "tensorflow", "jax", "pytorch"]: + with tc.runtime_backend(backend): + a = tc.backend.ones([2, 3]) + print("tensor dtype:", tc.backend.dtype(a)) + b = tc.backend.cast(a, dtype="float64") + print("tensor dtype:", tc.backend.dtype(b)) + +Also note the jax issue on float64/complex128, see `jax gotcha `_. + +If the shape is not consistent, one can convert the shape by ``tc.backend.reshape``. + +If the device is not consistent, one can move the tensor between devices by ``tc.backend.device_move``. + + AD Consistency --------------------- From 54b99d63ea5dd2f04f4d5b3adef6315fdb412bd8 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 20 Apr 2023 14:17:35 +0800 Subject: [PATCH 404/725] update quick start doc --- docs/source/quickstart.rst | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 40f50645..b009aed6 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -318,6 +318,7 @@ and the other part is implemented in `TensorCircuit package `__. +There is also a more flexible torch interface that support static non-tensor inputs as keyword arguments, which can be utilized as below: + +.. code-block:: python + + def f(a, i): + s = 0. + for _ in range(i): + s += a + return s + + f_torch = tc.interfaces.torch_interface_kws(f) + f_torch(torch.ones([2]), i=3) + + We also provider wrapper of quantum function for torch module as :py:meth:`tensorcircuit.TorchLayer` alias to :py:meth:`tensorcircuit.torchnn.QuantumNet`. For ``TorchLayer``, ``use_interface=True`` is by default, which natively allow the quantum function defined on other tensorcircuit backends, such as jax or tf for speed consideration. From cf4209d459bea528386f211d0e9e8c71ced2b2f4 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 20 Apr 2023 14:19:01 +0800 Subject: [PATCH 405/725] remove quafu warning --- tensorcircuit/cloud/apis.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index d6495dd0..24441731 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -28,7 +28,8 @@ try: from . import quafu_provider except (ImportError, ModuleNotFoundError): - logger.warning("fail to load cloud provider module: quafu") + pass + # logger.warning("fail to load cloud provider module: quafu") package_name = "tensorcircuit" thismodule = sys.modules[__name__] From 0dbbee8460db1083f046f702691daca51b4d1d91 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 20 Apr 2023 22:48:53 +0800 Subject: [PATCH 406/725] fix numpy backend non jittable adjoint gate --- CHANGELOG.md | 2 ++ tensorcircuit/gates.py | 21 ++++++++------------- 2 files changed, 10 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bca1c5fa..5ffcaca9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,8 @@ - Add tests and fixed some missing methods for cupy backend, cupy backend is now ready to use (though still not guaranteed) +- Fix adjoint gate numpy conversion for fixed gate case + ## 0.8.0 ### Added diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index 1529b389..40fa9b26 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -14,7 +14,6 @@ from scipy.stats import unitary_group from .cons import backend, dtypestr, npdtype -from .backends import get_backend from .utils import arg_alias thismodule = sys.modules[__name__] @@ -257,22 +256,18 @@ def __init__( self.ctrl = ctrl def __call__(self, *args: Any, **kws: Any) -> Gate: - # m = array_to_tensor(self.m) + m1 = array_to_tensor(self.m) # m = backend.cast(m, dtypestr) - m = self.m.astype(npdtype) - return Gate(deepcopy(m), name=self.n) + m1 = backend.cast(m1, dtypestr) + return Gate(m1, name=self.n) def adjoint(self) -> "GateF": m = self.__call__() - npb = get_backend("numpy") - shape0 = npb.shape_tuple(m.tensor) - m0 = npb.reshapem(m.tensor) - ma = npb.adjoint(m0) - if np.allclose(m0, ma, atol=1e-5): - name = self.n - else: - name = self.n + "d" - ma = npb.reshape(ma, shape0) + shape0 = backend.shape_tuple(m.tensor) + m0 = backend.reshapem(m.tensor) + ma = backend.adjoint(m0) + name = self.n + "d" + ma = backend.reshape(ma, shape0) return GateF(ma, name, self.ctrl) # TODO(@refraction-ray): adjoint gate convention finally determined From 5ce7d21e17c17d009f64d7e8f3e70baa425a2384 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 21 Apr 2023 11:33:09 +0800 Subject: [PATCH 407/725] add tests for adjoint --- tests/test_circuit.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index bbca262f..5b72804d 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1515,3 +1515,22 @@ def test_get_positional_logical_mapping(): c.measure_instruction(2) c.measure_instruction(0) assert c.get_positional_logical_mapping() == {0: 2, 1: 0} + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_inverse_jit(backend): + K = tc.backend + def simple_ansatz(param): + c = tc.Circuit(3) + for i in range(3): + c.cx(i, (i+1)%3) + c.rzz(i, (i+1)%3, theta=param[i]) + c1 = c.inverse() + c2 = tc.Circuit(3) + c2.x(1) + c1.append(c2) + return tc.backend.real(c1.expectation_ps(z=[1])) + + v_ansatz = K.jit(K.vvag(simple_ansatz)) + vs, gs = v_ansatz(K.ones([2, 3], dtype="float32")) + assert K.shape_tuple(gs) == (2, 3) + np.testing.assert_allclose(K.numpy(vs), -1.*K.ones([2]), atol=1e-5) \ No newline at end of file From 78c18f37f0dcdcded2f68ce4100a6b55d75dc53b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 21 Apr 2023 12:06:05 +0800 Subject: [PATCH 408/725] blacked --- tests/test_circuit.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 5b72804d..14c7784f 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1516,14 +1516,16 @@ def test_get_positional_logical_mapping(): c.measure_instruction(0) assert c.get_positional_logical_mapping() == {0: 2, 1: 0} + @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_inverse_jit(backend): K = tc.backend + def simple_ansatz(param): c = tc.Circuit(3) for i in range(3): - c.cx(i, (i+1)%3) - c.rzz(i, (i+1)%3, theta=param[i]) + c.cx(i, (i + 1) % 3) + c.rzz(i, (i + 1) % 3, theta=param[i]) c1 = c.inverse() c2 = tc.Circuit(3) c2.x(1) @@ -1533,4 +1535,4 @@ def simple_ansatz(param): v_ansatz = K.jit(K.vvag(simple_ansatz)) vs, gs = v_ansatz(K.ones([2, 3], dtype="float32")) assert K.shape_tuple(gs) == (2, 3) - np.testing.assert_allclose(K.numpy(vs), -1.*K.ones([2]), atol=1e-5) \ No newline at end of file + np.testing.assert_allclose(K.numpy(vs), -1.0 * K.ones([2]), atol=1e-5) From 1049603525bf5553d3a289b4b0b3a0a0bd01846b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 21 Apr 2023 12:26:11 +0800 Subject: [PATCH 409/725] unify examples docstring format --- examples/adiabatic_vqnhe.py | 1 + examples/bp_benchmark.py | 1 + examples/bp_validation.py | 1 + examples/chaotic_behavior.py | 1 + examples/ghz_dqas.py | 1 + examples/hamiltonian_building.py | 1 + examples/incremental_twoqubit.py | 1 + examples/jsonio.py | 1 + examples/mcnoise_check.py | 1 + examples/mera_extra_mpo.py | 4 ++++ examples/mipt.py | 1 + examples/mpsvsexact.py | 1 + examples/optperformance_comparison.py | 1 + examples/qaoa_parallel_opt.py | 4 ++++ examples/qaoa_shot_noise.py | 1 + examples/qem_dqas.py | 1 + examples/readout_mitigation.py | 4 ++++ examples/sample_value_gradient.py | 1 + examples/simple_qaoa.py | 1 + examples/vqe_shot_noise.py | 1 + examples/vqnhe_h6.py | 1 + 21 files changed, 30 insertions(+) diff --git a/examples/adiabatic_vqnhe.py b/examples/adiabatic_vqnhe.py index 6e52b652..a1b093ca 100644 --- a/examples/adiabatic_vqnhe.py +++ b/examples/adiabatic_vqnhe.py @@ -1,6 +1,7 @@ """ Calculate the molecule dissociation curve using VQNHE. """ + from functools import partial import sys diff --git a/examples/bp_benchmark.py b/examples/bp_benchmark.py index 98a81621..66a12ea6 100644 --- a/examples/bp_benchmark.py +++ b/examples/bp_benchmark.py @@ -1,6 +1,7 @@ """ benchmark on barren plateau using tfq and tc """ + import os os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true" diff --git a/examples/bp_validation.py b/examples/bp_validation.py index dce80299..f620ee43 100644 --- a/examples/bp_validation.py +++ b/examples/bp_validation.py @@ -2,6 +2,7 @@ Compute the circuit gradient with single qubit random Haar averaged to demonstrate the gradient vanishing, aka, barren plateau. """ + import numpy as np from tqdm import tqdm import tensorcircuit as tc diff --git a/examples/chaotic_behavior.py b/examples/chaotic_behavior.py index f1039e86..6a37f4c7 100644 --- a/examples/chaotic_behavior.py +++ b/examples/chaotic_behavior.py @@ -1,6 +1,7 @@ """ Some chaotic properties calculations from the circuit state. """ + from functools import partial import sys diff --git a/examples/ghz_dqas.py b/examples/ghz_dqas.py index a3bfc325..5022f441 100644 --- a/examples/ghz_dqas.py +++ b/examples/ghz_dqas.py @@ -1,6 +1,7 @@ """ DQAS for GHZ state preparation circuit, deprecated DQAS implementation """ + import sys sys.path.insert(0, "../") diff --git a/examples/hamiltonian_building.py b/examples/hamiltonian_building.py index 055faed7..e00c6a7e 100644 --- a/examples/hamiltonian_building.py +++ b/examples/hamiltonian_building.py @@ -1,6 +1,7 @@ """ benchmark sparse hamiltonian building """ + import time import numpy as np import quimb diff --git a/examples/incremental_twoqubit.py b/examples/incremental_twoqubit.py index 8b8b0057..26fdb454 100644 --- a/examples/incremental_twoqubit.py +++ b/examples/incremental_twoqubit.py @@ -2,6 +2,7 @@ Optimizing the parameterized circuit with progressively dense two-qubit gates, as a potential approach to alleviate barren plateau. """ + import sys sys.path.insert(0, "../") diff --git a/examples/jsonio.py b/examples/jsonio.py index 7626cb06..565c12b0 100644 --- a/examples/jsonio.py +++ b/examples/jsonio.py @@ -2,6 +2,7 @@ example showcasing how circuit can be load from and dump to json: useful for storage or restful api """ + import numpy as np import tensorcircuit as tc diff --git a/examples/mcnoise_check.py b/examples/mcnoise_check.py index 79e292f1..de7a4c32 100644 --- a/examples/mcnoise_check.py +++ b/examples/mcnoise_check.py @@ -1,6 +1,7 @@ """ Cross check the correctness of the density matrix simulator and the Monte Carlo trajectory state simulator. """ + import os os.environ["CUDA_VISIBLE_DEVICES"] = "-1" diff --git a/examples/mera_extra_mpo.py b/examples/mera_extra_mpo.py index 5d80770a..c0b0d152 100644 --- a/examples/mera_extra_mpo.py +++ b/examples/mera_extra_mpo.py @@ -1,3 +1,7 @@ +""" +MERA VQE example with Hamiltonian expectation in MPO representation +""" + import time import logging import numpy as np diff --git a/examples/mipt.py b/examples/mipt.py index ba43d98e..ec703cb9 100644 --- a/examples/mipt.py +++ b/examples/mipt.py @@ -1,6 +1,7 @@ """ demo example of mipt in tc style """ + from functools import partial import time import numpy as np diff --git a/examples/mpsvsexact.py b/examples/mpsvsexact.py index 6e0bfa4a..0ea1cfe3 100644 --- a/examples/mpsvsexact.py +++ b/examples/mpsvsexact.py @@ -1,6 +1,7 @@ """ A simple script to benchmark the approximation power of the MPS simulator. """ + import sys sys.path.insert(0, "../") diff --git a/examples/optperformance_comparison.py b/examples/optperformance_comparison.py index 7ebe0be9..4a23c47e 100644 --- a/examples/optperformance_comparison.py +++ b/examples/optperformance_comparison.py @@ -2,6 +2,7 @@ Optimization for performance comparison for different densities of two-qubit gates (random layouts averaged). """ + import sys sys.path.insert(0, "../") diff --git a/examples/qaoa_parallel_opt.py b/examples/qaoa_parallel_opt.py index 8ab0734f..fd694ec1 100644 --- a/examples/qaoa_parallel_opt.py +++ b/examples/qaoa_parallel_opt.py @@ -1,3 +1,7 @@ +""" +Depracated, using ``vectorized_value_and_grad`` instead for batched optimization +""" + import sys sys.path.insert(0, "../") diff --git a/examples/qaoa_shot_noise.py b/examples/qaoa_shot_noise.py index 7b6e656e..65d93020 100644 --- a/examples/qaoa_shot_noise.py +++ b/examples/qaoa_shot_noise.py @@ -1,6 +1,7 @@ """ QAOA with finite measurement shot noise """ + from functools import partial import numpy as np from scipy import optimize diff --git a/examples/qem_dqas.py b/examples/qem_dqas.py index 44acf8f9..e5f6e8cd 100644 --- a/examples/qem_dqas.py +++ b/examples/qem_dqas.py @@ -1,6 +1,7 @@ """ DQAS for QFT QEM circuit design, deprecated DQAS implementation """ + import sys sys.path.insert(0, "../") diff --git a/examples/readout_mitigation.py b/examples/readout_mitigation.py index 5429d894..215313ed 100644 --- a/examples/readout_mitigation.py +++ b/examples/readout_mitigation.py @@ -1,3 +1,7 @@ +""" +Demonstration on readout error mitigation usage +""" + import numpy as np import tensorcircuit as tc diff --git a/examples/sample_value_gradient.py b/examples/sample_value_gradient.py index 1646f718..b3726b30 100644 --- a/examples/sample_value_gradient.py +++ b/examples/sample_value_gradient.py @@ -1,6 +1,7 @@ """ Evaluate expectation and gradient on Pauli string sum with finite measurement shots """ + from functools import partial import numpy as np import tensorcircuit as tc diff --git a/examples/simple_qaoa.py b/examples/simple_qaoa.py index 133b7d6e..a1fbfaa0 100644 --- a/examples/simple_qaoa.py +++ b/examples/simple_qaoa.py @@ -1,6 +1,7 @@ """ A plain QAOA optimization example with given graphs using networkx. """ + import sys sys.path.insert(0, "../") diff --git a/examples/vqe_shot_noise.py b/examples/vqe_shot_noise.py index 9c2a88ba..26a6b28b 100644 --- a/examples/vqe_shot_noise.py +++ b/examples/vqe_shot_noise.py @@ -1,6 +1,7 @@ """ VQE with finite measurement shot noise """ + from functools import partial import numpy as np from scipy import optimize diff --git a/examples/vqnhe_h6.py b/examples/vqnhe_h6.py index 5bc86719..1498c5d4 100644 --- a/examples/vqnhe_h6.py +++ b/examples/vqnhe_h6.py @@ -1,6 +1,7 @@ """ H6 molecule VQNHE with code from tc.application """ + import sys sys.path.insert(0, "../") From 4438669a44c267a93b868ef810956cf11d0a5bde Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 21 Apr 2023 12:58:41 +0800 Subject: [PATCH 410/725] update mypy --- CHANGELOG.md | 8 +++++++- requirements/requirements-dev.txt | 4 ++-- requirements/requirements-docker.txt | 4 ++-- tensorcircuit/__init__.py | 4 ++++ tensorcircuit/backends/cupy_backend.py | 2 +- tensorcircuit/backends/jax_ops.py | 2 +- tensorcircuit/backends/numpy_backend.py | 4 ++-- tensorcircuit/circuit.py | 2 +- tensorcircuit/interfaces/tensortrans.py | 2 +- tensorcircuit/interfaces/torch.py | 2 +- tensorcircuit/keras.py | 2 +- tensorcircuit/mpscircuit.py | 6 +++--- tensorcircuit/noisemodel.py | 2 +- tensorcircuit/results/readout_mitigation.py | 2 +- tensorcircuit/translation.py | 2 +- tensorcircuit/utils.py | 12 ++++++++++++ 16 files changed, 41 insertions(+), 19 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5ffcaca9..58252bfd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,16 +6,22 @@ - Add `tc.about()` to print related software versions and configs -- Torch support is updraded to 2.0, and now support native vmap and native functional grad, and thus `vvag`. Still jit support is conflict with these functional transformations and be turned off by default +- Torch support is upgraded to 2.0, and now support native vmap and native functional grad, and thus `vvag`. Still jit support is conflict with these functional transformations and be turned off by default - Add `torch_interfaces_kws` that support static keyword arguments when wrapping with the interface +- Add `gpu_memory_share` function and enable it by default + ### Fixed - Add tests and fixed some missing methods for cupy backend, cupy backend is now ready to use (though still not guaranteed) - Fix adjoint gate numpy conversion for fixed gate case +### Changed + +- Upgraded black and mypy==1.2.0 (breaking change for developers) + ## 0.8.0 ### Added diff --git a/requirements/requirements-dev.txt b/requirements/requirements-dev.txt index c1b1cf2d..f4d974b8 100644 --- a/requirements/requirements-dev.txt +++ b/requirements/requirements-dev.txt @@ -1,9 +1,9 @@ -mypy==0.982 +mypy==1.2.0 pytest==6.2.4 pytest-cov pytest-benchmark pytest-xdist -black==23.1.0 +black==23.3.0 sphinx>=4.0 pytest-lazy-fixture pylint==2.11.1 diff --git a/requirements/requirements-docker.txt b/requirements/requirements-docker.txt index 41186706..6f686f79 100644 --- a/requirements/requirements-docker.txt +++ b/requirements/requirements-docker.txt @@ -26,13 +26,13 @@ pennylane mthree mitiq # below is for development -mypy==0.982 +mypy==1.2.0 pytest pytest-cov pytest-benchmark pytest-xdist pytest-lazy-fixture -black==23.1.0 +black==23.3.0 sphinx>=4.0 sphinx-intl sphinx-copybutton diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 74cf4e5c..fe13edaa 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -2,6 +2,10 @@ __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" +from .utils import gpu_memory_share + +gpu_memory_share() + from .about import about from .cons import ( backend, diff --git a/tensorcircuit/backends/cupy_backend.py b/tensorcircuit/backends/cupy_backend.py index a2eeac13..4aa58d06 100644 --- a/tensorcircuit/backends/cupy_backend.py +++ b/tensorcircuit/backends/cupy_backend.py @@ -275,7 +275,7 @@ def solve(self, A: Tensor, b: Tensor, assume_a: str = "gen") -> Tensor: # type: raise NotImplementedError def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: - return cp.searchsorted(a, v, side=side) # type: ignore + return cp.searchsorted(a, v, side=side) def set_random_state( self, seed: Optional[int] = None, get_only: bool = False diff --git a/tensorcircuit/backends/jax_ops.py b/tensorcircuit/backends/jax_ops.py index 63cd2e33..e9e6c2cf 100644 --- a/tensorcircuit/backends/jax_ops.py +++ b/tensorcircuit/backends/jax_ops.py @@ -92,7 +92,7 @@ def jaxqr_bwd(res: Sequence[Array], tangents: Sequence[Array]) -> Tuple[Array]: dr = dr.conj() def _TriangularSolve(x: Array, r: Array) -> Array: - return jax.scipy.linalg.solve_triangular( # type: ignore + return jax.scipy.linalg.solve_triangular( r, x.T.conj(), lower=False, trans=0 ).T.conj() diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index 2d22b94d..7e4fb39a 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -24,7 +24,7 @@ def _sum_numpy( self: Any, a: Tensor, axis: Optional[Sequence[int]] = None, keepdims: bool = False ) -> Tensor: - return np.sum(a, axis=axis, keepdims=keepdims) # type: ignore + return np.sum(a, axis=axis, keepdims=keepdims) # see https://github.com/google/TensorNetwork/issues/952 @@ -161,7 +161,7 @@ def std( return np.std(a, axis=axis, keepdims=keepdims) def unique_with_counts(self, a: Tensor, **kws: Any) -> Tuple[Tensor, Tensor]: - return np.unique(a, return_counts=True) # type: ignore + return np.unique(a, return_counts=True) def min(self, a: Tensor, axis: Optional[int] = None) -> Tensor: return np.min(a, axis=axis) diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index c6f456a9..ade0cafa 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -774,7 +774,7 @@ def measure_reference( # TODO(@refraction-ray): more _before function like state_before? and better API? - def expectation( # type: ignore + def expectation( self, *ops: Tuple[tn.Node, List[int]], reuse: bool = True, diff --git a/tensorcircuit/interfaces/tensortrans.py b/tensorcircuit/interfaces/tensortrans.py index 704ae8a3..8d6b7ea5 100644 --- a/tensorcircuit/interfaces/tensortrans.py +++ b/tensorcircuit/interfaces/tensortrans.py @@ -276,7 +276,7 @@ def wrapper(*args: Any, **kws: Any) -> Any: arg = backend.tree_map( partial(gate_to_matrix, is_reshapem=gate_as_matrix), arg ) - if qop_to_matrix: + if qop_as_matrix: arg = backend.tree_map( partial(qop_to_matrix, is_reshapem=qop_as_matrix), arg ) diff --git a/tensorcircuit/interfaces/torch.py b/tensorcircuit/interfaces/torch.py index f4dd182c..e346b757 100644 --- a/tensorcircuit/interfaces/torch.py +++ b/tensorcircuit/interfaces/torch.py @@ -109,7 +109,7 @@ def backward(ctx: Any, *grad_y: Any) -> Any: return r # currently, memory transparent dlpack in these ML framework has broken support on complex dtypes - return Fun.apply # type: ignore + return Fun.apply pytorch_interface = torch_interface diff --git a/tensorcircuit/keras.py b/tensorcircuit/keras.py index 2f51d980..7aafdd15 100644 --- a/tensorcircuit/keras.py +++ b/tensorcircuit/keras.py @@ -142,7 +142,7 @@ def call( KerasLayer = QuantumLayer -class HardwareLayer(QuantumLayer): # type: ignore +class HardwareLayer(QuantumLayer): @tf.autograph.experimental.do_not_convert # type: ignore def call( self, diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index bf33d507..8a37b3ed 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -522,8 +522,8 @@ def apply_nqubit_gate( ordered = np.all(np.diff(index) > 0) if not ordered: order = np.argsort(index) - order2 = order + len(index) # type: ignore - order_all = order.tolist() + order2.tolist() # type: ignore + order2 = order + len(index) + order_all = order.tolist() + order2.tolist() newgate = backend.transpose(gate.tensor, order_all) index = np.sort(index).tolist() self.apply_nqubit_gate(newgate, *index, split=split) @@ -814,7 +814,7 @@ def slice(self, begin: int, end: int) -> "MPSCircuit": ) return mps - def expectation( # type: ignore + def expectation( self, *ops: Tuple[Gate, List[int]], reuse: bool = True, diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 38933b7a..0b03d966 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -259,7 +259,7 @@ def sample_expectation_ps_noisfy( if noise_conf.has_quantum: # density matrix if isinstance(c, DMCircuit): - cnoise = circuit_with_noise(c, noise_conf) # type: ignore + cnoise = circuit_with_noise(c, noise_conf) return cnoise.sample_expectation_ps( x=x, y=y, z=z, shots=shots, status=status, readout_error=readout_error ) diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index 5a17062b..ef205800 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -549,7 +549,7 @@ def apply_correction( r = quasi_out[0] r = sort_count(r) r = {k: v * shots for k, v in r.items()} - return sort_count(r) # type: ignore + return sort_count(r) # return quasi_out[0] # type: ignore mitcounts = QuasiCollection(quasi_out) return sort_count(mitcounts.nearest_probability_distribution()) # type: ignore diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 18beffed..6e867fd5 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -441,7 +441,7 @@ def qiskit2tc( elif is_dm: Circ = DMCircuit2 else: - Circ = Circuit # type: ignore + Circ = Circuit if circuit_params is None: circuit_params = {} if "nqubits" not in circuit_params: diff --git a/tensorcircuit/utils.py b/tensorcircuit/utils.py index ebb31a3e..44ce9e13 100644 --- a/tensorcircuit/utils.py +++ b/tensorcircuit/utils.py @@ -4,11 +4,23 @@ from typing import Any, Callable, Union, Sequence, Tuple, Dict from functools import wraps +import os import platform import re import time +def gpu_memory_share(flag: bool = True) -> None: + # TODO(@refraction-ray): the default torch behavior should be True + # preallocate behavior for torch to be investigated + if flag is True: + os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true" + os.environ["XLA_PYTHON_CLIENT_PREALLOCATE"] = "false" + else: + os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "false" + os.environ["XLA_PYTHON_CLIENT_PREALLOCATE"] = "true" + + def return_partial( f: Callable[..., Any], return_argnums: Union[int, Sequence[int]] = 0 ) -> Callable[..., Any]: From d3c9f1f191dc4148f6661b8cb01e64efa9c9ed69 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 21 Apr 2023 13:10:07 +0800 Subject: [PATCH 411/725] fix mypy --- tensorcircuit/backends/numpy_backend.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index 7e4fb39a..2d22b94d 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -24,7 +24,7 @@ def _sum_numpy( self: Any, a: Tensor, axis: Optional[Sequence[int]] = None, keepdims: bool = False ) -> Tensor: - return np.sum(a, axis=axis, keepdims=keepdims) + return np.sum(a, axis=axis, keepdims=keepdims) # type: ignore # see https://github.com/google/TensorNetwork/issues/952 @@ -161,7 +161,7 @@ def std( return np.std(a, axis=axis, keepdims=keepdims) def unique_with_counts(self, a: Tensor, **kws: Any) -> Tuple[Tensor, Tensor]: - return np.unique(a, return_counts=True) + return np.unique(a, return_counts=True) # type: ignore def min(self, a: Tensor, axis: Optional[int] = None) -> Tensor: return np.min(a, axis=axis) From 0020c3fb7617b8758fc745617ccc0ef91e61fda9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 21 Apr 2023 14:34:44 +0800 Subject: [PATCH 412/725] fix arg_to_tensor decorator quoperator behavior --- tensorcircuit/interfaces/tensortrans.py | 19 ++++++++++++++++--- tests/test_interfaces.py | 3 +-- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/tensorcircuit/interfaces/tensortrans.py b/tensorcircuit/interfaces/tensortrans.py index 8d6b7ea5..c258c481 100644 --- a/tensorcircuit/interfaces/tensortrans.py +++ b/tensorcircuit/interfaces/tensortrans.py @@ -50,10 +50,12 @@ def tensor_to_numpy(t: Tensor) -> Array: def tensor_to_backend_jittable(t: Tensor) -> Tensor: - if which_backend(t, return_backend=False) == backend.name: - return t if isinstance(t, int) or isinstance(t, float): return t + if isinstance(t, QuOperator): + return t + if which_backend(t, return_backend=False) == backend.name: + return t return backend.convert_to_tensor(which_backend(t).numpy(t)) @@ -281,9 +283,20 @@ def wrapper(*args: Any, **kws: Any) -> Any: partial(qop_to_matrix, is_reshapem=qop_as_matrix), arg ) arg = backend.tree_map(tensor_to_backend_jittable, arg) + # arg = backend.tree_map(backend.convert_to_tensor, arg) + def _cast(a: Tensor, dtype: str) -> Tensor: + if isinstance(a, QuOperator): + return a + return backend.cast(a, dtype) + + def _reshapem(a: Tensor) -> Tensor: + if isinstance(a, QuOperator): + return a + return backend.reshapem(a) + if cast_dtype: - arg = backend.tree_map(partial(backend.cast, dtype=dtypestr), arg) + arg = backend.tree_map(partial(_cast, dtype=dtypestr), arg) if tensor_as_matrix: arg = backend.tree_map(backend.reshapem, arg) diff --git a/tests/test_interfaces.py b/tests/test_interfaces.py index a8655c2b..deecc87f 100644 --- a/tests/test_interfaces.py +++ b/tests/test_interfaces.py @@ -425,6 +425,5 @@ def g(a, b, c): assert tc.interfaces.which_backend(a[0], return_backend=False) == tc.backend.name assert tc.backend.shape_tuple(a[1]) == (2, 2, 2, 2) - assert tc.interfaces.which_backend(b, return_backend=False) == tc.backend.name - assert tc.backend.shape_tuple(b) == (2, 2, 2, 2, 2, 2) + assert tc.backend.shape_tuple(b.eval()) == (2, 2, 2, 2, 2, 2) assert tc.backend.shape_tuple(c) == (2, 2, 2, 2) From d3427aa1ea08d11d3301e40d7846413b036ce849 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 21 Apr 2023 16:50:16 +0800 Subject: [PATCH 413/725] fix tab in quickstart doc --- docs/source/quickstart.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index b009aed6..32d54342 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -696,10 +696,10 @@ There is also a more flexible torch interface that support static non-tensor inp .. code-block:: python def f(a, i): - s = 0. - for _ in range(i): - s += a - return s + s = 0. + for _ in range(i): + s += a + return s f_torch = tc.interfaces.torch_interface_kws(f) f_torch(torch.ones([2]), i=3) From 2a0108f867229f5be9223373c83cce5ca0d3826d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 23 Apr 2023 16:29:36 +0800 Subject: [PATCH 414/725] add two super doped examples --- examples/jax_scan_jit_acc.py | 93 +++++++++++++ examples/slicing_wavefunction_vqa.py | 199 +++++++++++++++++++++++++++ 2 files changed, 292 insertions(+) create mode 100644 examples/jax_scan_jit_acc.py create mode 100644 examples/slicing_wavefunction_vqa.py diff --git a/examples/jax_scan_jit_acc.py b/examples/jax_scan_jit_acc.py new file mode 100644 index 00000000..c0307ad5 --- /dev/null +++ b/examples/jax_scan_jit_acc.py @@ -0,0 +1,93 @@ +""" +reducing jax jit compiling time by some magic +""" + +import numpy as np +import jax +import tensorcircuit as tc + +K = tc.set_backend("jax") +tc.set_dtype("complex128") + + +def energy_reference(param, n, nlayers): + c = tc.Circuit(n) + for i in range(n): + c.h(i) + for i in range(nlayers): + for j in range(n - 1): + c.rzz(j, j + 1, theta=param[i, j, 0]) + for j in range(n): + c.rx(j, theta=param[i, j, 1]) + return K.real(c.expectation_ps(z=[0, 1])) + + +vg_reference = K.jit( + K.value_and_grad(energy_reference, argnums=0), static_argnums=(1, 2) +) + +with tc.runtime_backend("tensorflow") as tfk: + + def energy_reference_tf(param, n, nlayers): + c = tc.Circuit(n) + for i in range(n): + c.h(i) + for i in range(nlayers): + for j in range(n - 1): + c.rzz(j, j + 1, theta=param[i, j, 0]) + for j in range(n): + c.rx(j, theta=param[i, j, 1]) + return tfk.real(c.expectation_ps(z=[0, 1])) + + vg_reference_tf = tfk.jit( + tfk.value_and_grad(energy_reference_tf, argnums=0), static_argnums=(1, 2) + ) + +# a jit efficient way to utilize jax scan + + +def energy(param, n, nlayers, each): + def loop_f(s_, param_): + c_ = tc.Circuit(n, inputs=s_) + for i in range(each): + for j in range(n - 1): + c_.rzz(j, j + 1, theta=param_[i, j, 0]) + for j in range(n): + c_.rx(j, theta=param_[i, j, 1]) + s_ = c_.state() + return s_, s_ + + c = tc.Circuit(n) + for i in range(n): + c.h(i) + s = c.state() + s1, _ = jax.lax.scan(loop_f, s, K.reshape(param, [nlayers // each, each, n, 2])) + c1 = tc.Circuit(n, inputs=s1) + return K.real(c1.expectation_ps(z=[0, 1])) + + +vg = K.jit(K.value_and_grad(energy, argnums=0), static_argnums=(1, 2, 3)) + +if __name__ == "__main__": + n = 10 + nlayers = 32 + param = K.implicit_randn([nlayers, n, 2]) + + r1 = tc.utils.benchmark(vg, param, n, nlayers, 1) + print(r1[0][0]) + r1 = tc.utils.benchmark(vg, param, n, nlayers, 2) + print(r1[0][0]) + r1 = tc.utils.benchmark(vg, param, n, nlayers, 4) + print(r1[0][0]) + + with tc.runtime_backend("tensorflow"): + print("tf plain impl") + param_tf = tc.array_to_tensor(param, dtype="float32") + r0 = tc.utils.benchmark(vg_reference_tf, param_tf, n, nlayers) + + np.testing.assert_allclose(r0[0][0], r1[0][0], atol=1e-5) + np.testing.assert_allclose(r0[0][1], r1[0][1], atol=1e-5) + # correctness check + + print("jax plain impl (may be super slow for deeper system)") + r0 = tc.utils.benchmark(vg_reference, param, n, nlayers) # too slow diff --git a/examples/slicing_wavefunction_vqa.py b/examples/slicing_wavefunction_vqa.py new file mode 100644 index 00000000..b31a2184 --- /dev/null +++ b/examples/slicing_wavefunction_vqa.py @@ -0,0 +1,199 @@ +""" +slicing the output wavefunction to save the memory in VQA context +""" + +from itertools import product +import numpy as np +import tensorcircuit as tc + +K = tc.set_backend("jax") + + +def circuit(param, n, nlayers): + c = tc.Circuit(n) + for i in range(n): + c.h(i) + c = tc.templates.blocks.example_block(c, param, nlayers) + return c + + +def sliced_state(c, cut, mask): + # mask = Tensor([0, 1, 0]) + # cut = [0, 1, 2] + n = c._nqubits + ncut = len(cut) + end0 = tc.array_to_tensor(np.array([1.0, 0.0])) + end1 = tc.array_to_tensor(np.array([0.0, 1.0])) + ends = [tc.Gate(mask[i] * end1 + (1 - mask[i]) * end0) for i in range(ncut)] + nodes, front = c._copy() + for j, i in enumerate(cut): + front[i] ^ ends[j][0] + oeo = [] + for i in range(n): + if i not in cut: + oeo.append(front[i]) + ss = tc.contractor(nodes + ends, output_edge_order=oeo) + return ss + + +def sliced_op(ps, cut, mask1, mask2): + # ps: Tensor([0, 0, 1, 1]) + n = K.shape_tuple(ps)[-1] + ncut = len(cut) + end0 = tc.array_to_tensor(np.array([1.0, 0.0])) + end1 = tc.array_to_tensor(np.array([0.0, 1.0])) + endsr = [tc.Gate(mask1[i] * end1 + (1 - mask1[i]) * end0) for i in range(ncut)] + endsl = [tc.Gate(mask2[i] * end1 + (1 - mask2[i]) * end0) for i in range(ncut)] + + structuresc = K.cast(ps, dtype="int32") + structuresc = K.onehot(structuresc, num=4) + structuresc = K.cast(structuresc, dtype=tc.dtypestr) + obs = [] + for i in range(n): + obs.append( + tc.Gate( + sum( + [ + structuresc[i, k] * g.tensor + for k, g in enumerate(tc.gates.pauli_gates) + ] + ) + ) + ) + for j, i in enumerate(cut): + obs[i][0] ^ endsl[j][0] + obs[i][1] ^ endsr[j][0] + oeo = [] + for i in range(n): + if i not in cut: + oeo.append(obs[i][0]) + for i in range(n): + if i not in cut: + oeo.append(obs[i][1]) + return obs + endsl + endsr, oeo + + +def sliced_core(param, n, nlayers, ps, cut, mask1, mask2): + # param, ps, mask1, mask2 are all tensor + c = circuit(param, n, nlayers) + ss = sliced_state(c, cut, mask1) + ssc = sliced_state(c, cut, mask2) + ssc, _ = tc.Circuit.copy([ssc], conj=True) + op_nodes, op_edges = sliced_op(ps, cut, mask1, mask2) + nodes = [ss] + ssc + op_nodes + ssc = ssc[0] + n = c._nqubits + nleft = n - len(cut) + for i in range(nleft): + op_edges[i + nleft] ^ ss[i] + op_edges[i] ^ ssc[i] + scalar = tc.contractor(nodes) + return K.real(scalar.tensor) + + +sliced_core_vvg = K.jit( + K.vectorized_value_and_grad(sliced_core, argnums=0, vectorized_argnums=(5, 6)), + static_argnums=(1, 2, 4), +) # vmap version if memory is enough + +sliced_core_vg = K.jit( + K.value_and_grad(sliced_core, argnums=0), + static_argnums=(1, 2, 4), +) # nonvmap version is memory is tight and distrubution workload may be enabled + + +def sliced_expectation_and_grad(param, n, nlayers, ps, cut, is_vmap=True): + pst = tc.array_to_tensor(ps) + res = 0.0 + mask1s = [] + mask2s = [] + for mask1 in product(*[(0, 1) for _ in cut]): + mask1t = tc.array_to_tensor(np.array(mask1)) + mask1s.append(mask1t) + mask2 = list(mask1) + for j, i in enumerate(cut): + if ps[i] in [1, 2]: + mask2[j] = 1 - mask1[j] + mask2t = tc.array_to_tensor(np.array(mask2)) + mask2s.append(mask2t) + if is_vmap: + mask1s = K.stack(mask1s) + mask2s = K.stack(mask2s) + res = sliced_core_vvg(param, n, nlayers, pst, cut, mask1s, mask2s) + res = list(res) + res[0] = K.sum(res[0]) + res = tuple(res) + else: + # memory bounded + # can modified to adpative pmap + vs = 0.0 + gs = 0.0 + for i in range(len(mask1s)): + mask1t = mask1s[i] + mask2t = mask2s[i] + v, g = sliced_core_vg(param, n, nlayers, pst, cut, mask1t, mask2t) + vs += v + gs += g + res = (vs, gs) + return res + + +def sliced_expectation_ref(c, ps, cut): + """ + reference implementation + """ + # ps: [0, 2, 1] + res = 0.0 + for mask1 in product(*[(0, 1) for _ in cut]): + mask1t = tc.array_to_tensor(np.array(mask1)) + ss = sliced_state(c, cut, mask1t) + mask2 = list(mask1) + for j, i in enumerate(cut): + if ps[i] in [1, 2]: + mask2[j] = 1 - mask1[j] + mask2t = tc.array_to_tensor(np.array(mask2)) + ssc = sliced_state(c, cut, mask2t) + ssc, _ = tc.Circuit.copy([ssc], conj=True) + ps = tc.array_to_tensor(ps) + op_nodes, op_edges = sliced_op(ps, cut, mask1t, mask2t) + nodes = [ss] + ssc + op_nodes + ssc = ssc[0] + n = c._nqubits + nleft = n - len(cut) + for i in range(nleft): + op_edges[i + nleft] ^ ss[i] + op_edges[i] ^ ssc[i] + scalar = tc.contractor(nodes) + res += scalar.tensor + return res + + +if __name__ == "__main__": + n = 10 + nlayers = 5 + param = K.ones([n, 2 * nlayers], dtype="float32") + cut = (0, 2, 5, 9) + ops = [2, 0, 3, 1, 0, 0, 1, 2, 0, 1] + ops_dict = tc.quantum.ps2xyz(ops) + + def trivial_core(param, n, nlayers): + c = circuit(param, n, nlayers) + return K.real(c.expectation_ps(**ops_dict)) + + trivial_vg = K.jit(K.value_and_grad(trivial_core, argnums=0), static_argnums=(1, 2)) + + print("reference impl") + r0 = tc.utils.benchmark(trivial_vg, param, n, nlayers) + print("vmapped slice") + r1 = tc.utils.benchmark( + sliced_expectation_and_grad, param, n, nlayers, ops, cut, True + ) + print("naive for slice") + r2 = tc.utils.benchmark( + sliced_expectation_and_grad, param, n, nlayers, ops, cut, False + ) + + np.testing.assert_allclose(r0[0][0], r1[0][0], atol=1e-5) + np.testing.assert_allclose(r2[0][0], r1[0][0], atol=1e-5) + np.testing.assert_allclose(r0[0][1], r1[0][1], atol=1e-5) + np.testing.assert_allclose(r2[0][1], r1[0][1], atol=1e-5) From 05efada98db4b3f648129263cc6b3e3d5d3b4d32 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 23 Apr 2023 16:58:52 +0800 Subject: [PATCH 415/725] add scan methods to backends --- CHANGELOG.md | 4 ++++ tensorcircuit/backends/abstract_backend.py | 22 ++++++++++++++++++++ tensorcircuit/backends/jax_backend.py | 10 +++++++++ tensorcircuit/backends/tensorflow_backend.py | 9 +++++--- tests/test_backends.py | 6 ++++++ 5 files changed, 48 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 58252bfd..b2063ad7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,10 @@ - Add `gpu_memory_share` function and enable it by default +- Add `scan` methods for backends + +- Add example demontrating how jax compiling time can be accelerated by `jax.lax.scan` + ### Fixed - Add tests and fixed some missing methods for cupy backend, cupy backend is now ready to use (though still not guaranteed) diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index 24023923..e6f69f97 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -1334,6 +1334,28 @@ def switch( "Backend '{}' has not implemented `switch`.".format(self.name) ) + def scan( + self: Any, f: Callable[[Tensor, Tensor], Tensor], xs: Tensor, init: Tensor + ) -> Tensor: + # use restricted f as tensorflow + """ + This API follows ``tf.scan`` covention, + i.e. no ys supported as jax + + :param f: _description_ + :type f: Callable[Tuple[Tensor, Tensor], Tensor] + :param xs: _description_ + :type xs: Tensor + :param init: _description_ + :type init: Tensor + :return: _description_ + :rtype: Tensor + """ + carry = init + for x in xs: + carry = f(carry, x) + return carry + def stop_gradient(self: Any, a: Tensor) -> Tensor: """ Stop backpropagation from ``a``. diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 21c9edf2..472066ea 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -577,6 +577,16 @@ def switch(self, index: Tensor, branches: Sequence[Callable[[], Tensor]]) -> Ten branches_null = [lambda _, f=b: f() for b in branches] return libjax.lax.switch(index, branches_null, None) + def scan( + self, f: Callable[[Tensor, Tensor], Tensor], xs: Tensor, init: Tensor + ) -> Tensor: + def f_jax(*args: Any, **kws: Any) -> Any: + r = f(*args, **kws) + return r, None + + carry, _ = libjax.lax.scan(f_jax, init, xs) + return carry + def scatter(self, operand: Tensor, indices: Tensor, updates: Tensor) -> Tensor: rank = len(operand.shape) dnums = libjax.lax.ScatterDimensionNumbers( diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 10e065eb..877c34b6 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -582,11 +582,14 @@ def cond( ) -> Tensor: return tf.cond(pred, true_fun, false_fun) - def switch( - self: Any, index: Tensor, branches: Sequence[Callable[[], Tensor]] - ) -> Tensor: + def switch(self, index: Tensor, branches: Sequence[Callable[[], Tensor]]) -> Tensor: return tf.switch_case(index, branches) + def scan( + self, f: Callable[[Tensor, Tensor], Tensor], xs: Tensor, init: Tensor + ) -> Tensor: + return tf.scan(f, xs, init)[-1] + def device(self, a: Tensor) -> str: dev = a.device return self._dev2str(dev) diff --git a/tests/test_backends.py b/tests/test_backends.py index f2475e51..f63de48d 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -172,6 +172,12 @@ def test_backend_methods(backend): atol=1e-5, ) + def sum_(carry, x): + return carry + x + + r = tc.backend.scan(sum_, tc.backend.ones([10, 2]), tc.backend.zeros([2])) + np.testing.assert_allclose(r, 10 * np.ones([2]), atol=1e-5) + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("torchb")]) def test_backend_methods_2(backend): From 1de1f171e8ca5973c04f924aabaf699a60b4c03e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 23 Apr 2023 17:20:43 +0800 Subject: [PATCH 416/725] add general scan method acc examples --- examples/hea_scan_jit_acc.py | 75 ++++++++++++++++++++++++++++++++++++ examples/jax_scan_jit_acc.py | 4 +- 2 files changed, 78 insertions(+), 1 deletion(-) create mode 100644 examples/hea_scan_jit_acc.py diff --git a/examples/hea_scan_jit_acc.py b/examples/hea_scan_jit_acc.py new file mode 100644 index 00000000..94e19032 --- /dev/null +++ b/examples/hea_scan_jit_acc.py @@ -0,0 +1,75 @@ +""" +reducing jit compiling time by general scan magic +""" + +import numpy as np +import tensorcircuit as tc + +n = 10 +nlayers = 16 +param_np = np.random.normal(size=[nlayers, n, 2]) + +for backend in ["tensorflow", "jax"]: + with tc.runtime_backend(backend) as K: + print("running %s" % K.name) + + def energy_reference(param, n, nlayers): + c = tc.Circuit(n) + for i in range(n): + c.h(i) + for i in range(nlayers): + for j in range(n - 1): + c.rzz(j, j + 1, theta=param[i, j, 0]) + for j in range(n): + c.rx(j, theta=param[i, j, 1]) + return K.real(c.expectation_ps(z=[0, 1]) + c.expectation_ps(x=[2])) + + vg_reference = K.jit( + K.value_and_grad(energy_reference, argnums=0), static_argnums=(1, 2) + ) + + # a jit efficient way to utilize scan + + def energy(param, n, nlayers, each): + def loop_f(s_, param_): + c_ = tc.Circuit(n, inputs=s_) + for i in range(each): + for j in range(n - 1): + c_.rzz(j, j + 1, theta=param_[i, j, 0]) + for j in range(n): + c_.rx(j, theta=param_[i, j, 1]) + s_ = c_.state() + return s_ + + c = tc.Circuit(n) + for i in range(n): + c.h(i) + s = c.state() + s1 = K.scan(loop_f, K.reshape(param, [nlayers // each, each, n, 2]), s) + c1 = tc.Circuit(n, inputs=s1) + return K.real(c1.expectation_ps(z=[0, 1]) + c1.expectation_ps(x=[2])) + + vg = K.jit( + K.value_and_grad(energy, argnums=0), + static_argnums=(1, 2, 3), + jit_compile=True, + ) + # set to False can improve compile time for tf + + param = K.convert_to_tensor(param_np) + + for each in [1, 2, 4]: + print(" scan impl with each=%s" % str(each)) + r1 = tc.utils.benchmark(vg, param, n, nlayers, each) + print(r1[0][0]) + + print(" plain impl") + r0 = tc.utils.benchmark(vg_reference, param, n, nlayers) # too slow + np.testing.assert_allclose(r0[0][0], r1[0][0], atol=1e-5) + np.testing.assert_allclose(r0[0][1], r1[0][1], atol=1e-5) + # correctness check + + +# jit_compile=True icrease runtime while degrades jit time for tensorflow +# and in general jax improves better with scan methodology, +# both compile time and running time can outperform tf diff --git a/examples/jax_scan_jit_acc.py b/examples/jax_scan_jit_acc.py index c0307ad5..34626680 100644 --- a/examples/jax_scan_jit_acc.py +++ b/examples/jax_scan_jit_acc.py @@ -1,5 +1,7 @@ """ -reducing jax jit compiling time by some magic +reducing jax jit compiling time by some magic: +for backend agnostic but similar approach, +see `hea_scan_jit_acc.py` """ import numpy as np From c66657832167323f2288ae936b28e1a582fe13a7 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 27 Apr 2023 12:53:58 +0800 Subject: [PATCH 417/725] fix indexedslice return from tf grad api --- CHANGELOG.md | 2 ++ tensorcircuit/backends/tensorflow_backend.py | 5 +++++ 2 files changed, 7 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b2063ad7..d30dde83 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,8 @@ - Fix adjoint gate numpy conversion for fixed gate case +- Sometime, tf just return IndexedSlice instead of tensor from gradient API, partially fix this in tc backend methods + ### Changed - Upgraded black and mypy==1.2.0 (breaking change for developers) diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 877c34b6..a77ea1d7 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -725,6 +725,11 @@ def vjp( for i, gi in enumerate(g): if gi is None: g[i] = tf.zeros_like(inputs[i]) + if isinstance(gi, tf.IndexedSlices): + # gradient can return sth weird + # TODO(@refraction-ray): check whether other AD tf methods have such issues + # shape is still unkown, dense_shape attr doesn't work? + g[i] = tf.convert_to_tensor(gi) g = tuple(g) if one_input: g = g[0] From d19d232026e413ea404ee141cb84c2ddbed62505 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 5 May 2023 15:36:44 +0800 Subject: [PATCH 418/725] add url config --- tensorcircuit/cloud/config.py | 1 + tests/test_cloud.py | 4 ++++ 2 files changed, 5 insertions(+) create mode 100644 tensorcircuit/cloud/config.py diff --git a/tensorcircuit/cloud/config.py b/tensorcircuit/cloud/config.py new file mode 100644 index 00000000..5ad31e81 --- /dev/null +++ b/tensorcircuit/cloud/config.py @@ -0,0 +1 @@ +tencent_base_url = "https://quantum.tencent.com/cloud/quk/" diff --git a/tests/test_cloud.py b/tests/test_cloud.py index 1d8219e9..c3f3e7ee 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -12,6 +12,10 @@ from tensorcircuit.cloud import apis, wrapper from tensorcircuit.results import counts +if "TC_CLOUD_TEST" not in os.environ: + pytest.skip(allow_module_level=True) + # skip on CI due to no token + def test_get_token(): print(apis.get_token(provider="Tencent")) From 1a2380bda2ba979120d2dba83ddfae7d95b4c577 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 5 May 2023 16:08:57 +0800 Subject: [PATCH 419/725] update change log --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d30dde83..52e2bb1d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ ### Added +- Cloud module for Tencent QCloud is now merged into the master branch and ready to release + - Add `tc.about()` to print related software versions and configs - Torch support is upgraded to 2.0, and now support native vmap and native functional grad, and thus `vvag`. Still jit support is conflict with these functional transformations and be turned off by default From 21a8fa5ef3fbf2cd2efd20e1fc9acf8ae96b2c4f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 5 May 2023 17:08:20 +0800 Subject: [PATCH 420/725] v0.9.0 --- CHANGELOG.md | 2 ++ tensorcircuit/__init__.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 52e2bb1d..52e40c05 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.9.0 + ### Added - Cloud module for Tencent QCloud is now merged into the master branch and ready to release diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index fe13edaa..ef701d00 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.8.0" +__version__ = "0.9.0" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From 79b06f407e4fd1e193591df9c0cf80347c24c540 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 5 May 2023 21:26:23 +0800 Subject: [PATCH 421/725] add docs for cloud --- CHANGELOG.md | 4 ++++ docs/source/api/cloud.rst | 11 +++++++++++ docs/source/api/cloud/abstraction.rst | 7 +++++++ docs/source/api/cloud/apis.rst | 7 +++++++ docs/source/api/cloud/config.rst | 7 +++++++ docs/source/api/cloud/local.rst | 7 +++++++ docs/source/api/cloud/quafu_provider.rst | 7 +++++++ docs/source/api/cloud/tencent.rst | 7 +++++++ docs/source/api/cloud/utils.rst | 7 +++++++ docs/source/api/cloud/wrapper.rst | 7 +++++++ docs/source/modules.rst | 1 + tensorcircuit/__init__.py | 2 ++ tensorcircuit/cloud/__init__.py | 3 +++ 13 files changed, 77 insertions(+) create mode 100644 docs/source/api/cloud.rst create mode 100644 docs/source/api/cloud/abstraction.rst create mode 100644 docs/source/api/cloud/apis.rst create mode 100644 docs/source/api/cloud/config.rst create mode 100644 docs/source/api/cloud/local.rst create mode 100644 docs/source/api/cloud/quafu_provider.rst create mode 100644 docs/source/api/cloud/tencent.rst create mode 100644 docs/source/api/cloud/utils.rst create mode 100644 docs/source/api/cloud/wrapper.rst diff --git a/CHANGELOG.md b/CHANGELOG.md index 52e40c05..b3789458 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Changed + +- Add compiler and cloud namespace to the global tensorcircuit namespace + ## 0.9.0 ### Added diff --git a/docs/source/api/cloud.rst b/docs/source/api/cloud.rst new file mode 100644 index 00000000..65b9c714 --- /dev/null +++ b/docs/source/api/cloud.rst @@ -0,0 +1,11 @@ +tensorcircuit.cloud +================================================== +.. toctree:: + cloud/abstraction.rst + cloud/apis.rst + cloud/config.rst + cloud/local.rst + cloud/quafu_provider.rst + cloud/tencent.rst + cloud/utils.rst + cloud/wrapper.rst \ No newline at end of file diff --git a/docs/source/api/cloud/abstraction.rst b/docs/source/api/cloud/abstraction.rst new file mode 100644 index 00000000..b0a50812 --- /dev/null +++ b/docs/source/api/cloud/abstraction.rst @@ -0,0 +1,7 @@ +tensorcircuit.cloud.abstraction +================================================== +.. automodule:: tensorcircuit.cloud.abstraction + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/cloud/apis.rst b/docs/source/api/cloud/apis.rst new file mode 100644 index 00000000..648baa66 --- /dev/null +++ b/docs/source/api/cloud/apis.rst @@ -0,0 +1,7 @@ +tensorcircuit.cloud.apis +================================================== +.. automodule:: tensorcircuit.cloud.apis + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/cloud/config.rst b/docs/source/api/cloud/config.rst new file mode 100644 index 00000000..a4338784 --- /dev/null +++ b/docs/source/api/cloud/config.rst @@ -0,0 +1,7 @@ +tensorcircuit.cloud.config +================================================== +.. automodule:: tensorcircuit.cloud.config + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/cloud/local.rst b/docs/source/api/cloud/local.rst new file mode 100644 index 00000000..c3ae767d --- /dev/null +++ b/docs/source/api/cloud/local.rst @@ -0,0 +1,7 @@ +tensorcircuit.cloud.local +================================================== +.. automodule:: tensorcircuit.cloud.local + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/cloud/quafu_provider.rst b/docs/source/api/cloud/quafu_provider.rst new file mode 100644 index 00000000..eae158af --- /dev/null +++ b/docs/source/api/cloud/quafu_provider.rst @@ -0,0 +1,7 @@ +tensorcircuit.cloud.quafu_provider +================================================== +.. automodule:: tensorcircuit.cloud.quafu_provider + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/cloud/tencent.rst b/docs/source/api/cloud/tencent.rst new file mode 100644 index 00000000..b38a7183 --- /dev/null +++ b/docs/source/api/cloud/tencent.rst @@ -0,0 +1,7 @@ +tensorcircuit.cloud.tencent +================================================== +.. automodule:: tensorcircuit.cloud.tencent + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/cloud/utils.rst b/docs/source/api/cloud/utils.rst new file mode 100644 index 00000000..190ea5a4 --- /dev/null +++ b/docs/source/api/cloud/utils.rst @@ -0,0 +1,7 @@ +tensorcircuit.cloud.utils +================================================== +.. automodule:: tensorcircuit.cloud.utils + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/cloud/wrapper.rst b/docs/source/api/cloud/wrapper.rst new file mode 100644 index 00000000..bac6a502 --- /dev/null +++ b/docs/source/api/cloud/wrapper.rst @@ -0,0 +1,7 @@ +tensorcircuit.cloud.wrapper +================================================== +.. automodule:: tensorcircuit.cloud.wrapper + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/modules.rst b/docs/source/modules.rst index fb5b3091..280c7584 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -8,6 +8,7 @@ tensorcircuit ./api/basecircuit.rst ./api/channels.rst ./api/circuit.rst + ./api/cloud.rst ./api/compiler.rst ./api/cons.rst ./api/densitymatrix.rst diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index ef701d00..8fe6a31b 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -38,6 +38,8 @@ from . import results from . import quantum from .quantum import QuOperator, QuVector, QuAdjointVector, QuScalar +from . import compiler +from . import cloud try: from . import keras diff --git a/tensorcircuit/cloud/__init__.py b/tensorcircuit/cloud/__init__.py index e69de29b..acd5bb51 100644 --- a/tensorcircuit/cloud/__init__.py +++ b/tensorcircuit/cloud/__init__.py @@ -0,0 +1,3 @@ +from . import apis +from . import abstraction +from . import wrapper From dbcbbf531115c4acd7a36f15c1c0ed48efc0afab Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 5 May 2023 23:01:00 +0800 Subject: [PATCH 422/725] fix rtd env version and add comment on docker readme --- docker/README.md | 6 +++++- requirements/requirements-rtd.txt | 3 ++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/docker/README.md b/docker/README.md index 4b011c1b..3e0e6cca 100644 --- a/docker/README.md +++ b/docker/README.md @@ -16,10 +16,14 @@ Run the docker container by the following command: ```bash sudo docker run -it --network host --gpus all tensorcircuit -# if one also wants mount local source code, also add args `-v "$(pwd)":/app` +# if one also wants to mount local source code, also add args `-v "$(pwd)":/app` + +# using tensorcircuit/tensorcircuit to run the prebuild docker image from dockerhub # for old dockerfile with no runtime env setting # sudo docker run -it --network host -e LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-11.0/targets/x86_64-linux/lib -e PYTHONPATH=/app -v "$(pwd)":/app --gpus all tensorcircuit ``` `export TF_CPP_MIN_LOG_LEVEL=3` maybe necessary since jax suprisingly frequently complain about ptxas version problem. And `export CUDA_VISIBLE_DEVICES=-1` if you want to test only on CPU. + +The built docker has no tensorcircuit installed but left with a tensorcircuit source code dir. So one can `python setup.py develop` to install tensorcircuit locally (in which one can also mount the tensorcircuit codebase on host) or `pip install tensorcircuit` within the running docker. diff --git a/requirements/requirements-rtd.txt b/requirements/requirements-rtd.txt index cb334c99..4c2d71c9 100644 --- a/requirements/requirements-rtd.txt +++ b/requirements/requirements-rtd.txt @@ -13,4 +13,5 @@ ipykernel furo==2022.4.7 sphinx-copybutton nbsphinx -myst-parser \ No newline at end of file +myst-parser +urllib3==1.26.15 \ No newline at end of file From d89f30595a30a360afe08b551c067cd9dd1eb07e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 5 May 2023 23:08:30 +0800 Subject: [PATCH 423/725] further fix rtd --- docs/source/conf.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/source/conf.py b/docs/source/conf.py index 4f8e644e..8b057226 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -52,6 +52,8 @@ "myst_parser", ] +nbsphinx_allow_errors = True + autosectionlabel_prefix_document = True # Add any paths that contain templates here, relative to this directory. From 7e1b05c1a6a06a042e73b23a7d351c5067c82c08 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 6 May 2023 11:23:12 +0800 Subject: [PATCH 424/725] more docs and docstrings --- docker/README.md | 5 ++-- docs/source/quickstart.rst | 2 ++ tensorcircuit/cloud/apis.py | 8 +++-- tensorcircuit/cloud/wrapper.py | 55 +++++++++++++++++++++++++++++----- 4 files changed, 58 insertions(+), 12 deletions(-) diff --git a/docker/README.md b/docker/README.md index 3e0e6cca..c9940635 100644 --- a/docker/README.md +++ b/docker/README.md @@ -4,13 +4,12 @@ Run the following command to build the docker for tensorcircuit at parent path: sudo docker build . -f docker/Dockerfile -t tensorcircuit ``` -One can also pull the [official image](https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit) from DockerHub as +One can also pull the [official image](https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit) from DockerHub as ```bash sudo docker pull tensorcircuit/tensorcircuit ``` - Run the docker container by the following command: ```bash @@ -26,4 +25,4 @@ sudo docker run -it --network host --gpus all tensorcircuit `export TF_CPP_MIN_LOG_LEVEL=3` maybe necessary since jax suprisingly frequently complain about ptxas version problem. And `export CUDA_VISIBLE_DEVICES=-1` if you want to test only on CPU. -The built docker has no tensorcircuit installed but left with a tensorcircuit source code dir. So one can `python setup.py develop` to install tensorcircuit locally (in which one can also mount the tensorcircuit codebase on host) or `pip install tensorcircuit` within the running docker. +The built docker has no tensorcircuit pip package installed but left with a tensorcircuit source code dir. So one can `python setup.py develop` to install tensorcircuit locally (one can also mount the tensorcircuit codebase on host) or `pip install tensorcircuit` within the running docker. diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 32d54342..9767d08f 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -25,6 +25,8 @@ Docker is also recommended (especially Linux + Nvidia GPU setup): ``sudo docker run -it --network host --gpus all tensorcircuit/tensorcircuit``. +For more details on docker setup, please refer to `docker readme `_. + - For Windows, due to the lack of support for Jax, we recommend to use docker or WSL, please refer to `TC via windows docker `_ or `TC via WSL `_. - For Mac with M series chips (arm architecture), please refer to `TC on Mac M series `_. diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 24441731..1fa1a9be 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -41,7 +41,7 @@ def list_providers() -> List[Provider]: """ - list all providers that tensorcircuit supports + list all cloud providers that tensorcircuit supports :return: _description_ :rtype: List[Provider] @@ -85,7 +85,7 @@ def set_device( set_global: bool = True, ) -> Device: """ - _summary_ + set the default device :param provider: provider of the device, defaults to None :type provider: Optional[Union[str, Provider]], optional @@ -413,6 +413,10 @@ def submit_task( """ submit task to the cloud platform, batch submission default enabled + .. seealso:: + + :py:meth:`tensorcircuit.cloud.tencent.submit_task` + :param provider: _description_, defaults to None :type provider: Optional[Union[str, Provider]], optional :param device: _description_, defaults to None diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 2c8140a8..3519d6bc 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -23,7 +23,7 @@ def batch_submit_template(device: str) -> Callable[..., List[counts.ct]]: - # TODO(@refraction-ray): fixed when batch submission really works + # TODO(@refraction-ray): adpative batch def run(cs: Union[Circuit, Sequence[Circuit]], shots: int) -> List[counts.ct]: """ batch circuit running alternative @@ -54,8 +54,12 @@ def sample_expectation_ps( device: Optional[Device] = None, **kws: Any, ) -> float: - # deprecated - # TODO(@refraction-ray): integrated error mitigation + """ + Deprecated, please use :py:meth:`tensorcircuit.cloud.wrapper.batch_expectation_ps`. + """ + logger.warning( + "This method is deprecated and not maintained, please use `tensorcircuit.cloud.wrapper.batch_expectation_ps` instead" + ) c1 = Circuit.from_qir(c.to_qir()) if x is None: x = [] @@ -83,14 +87,50 @@ def batch_expectation_ps( shots: int = 8192, with_rem: bool = True, ) -> Union[Any, List[Any]]: + """ + Unified interface to compute the Pauli string expectation lists or sums via simulation or on real qpu. + Error mitigation, circuit compilation and Pauli string grouping are all built-in. + + One line access to unlock the whole power or real quantum hardware on quantum cloud. + + :Example: + + .. code-block:: python + + c = tc.Circuit(2) + c.h(0) + c.x(1) + tc.cloud.wrapper.batch_expectation_ps(c, [[1, 0], [0, 3]], device=None) + # array([ 0.99999994, -0.99999994], dtype=float32) + tc.cloud.wrapper.batch_expectation_ps(c, [[1, 0], [0, 3]], device="tencent::9gmon") + # array([ 1.03093477, -1.11715944]) + + :param c: The target circuit to compute expectation + :type c: Circuit + :param pss: List of Pauli string list, eg. [[0, 1, 0], [2, 3, 3]] represents [X1, Y0Z1Z2]. + :type pss: List[List[int]] + :param device: The device str or object for quantum cloud module, + defaults to None, None is for analytical exact simulation + :type device: Any, optional + :param ws: List of float to indicate the final return is the weighted sum of Pauli string expectations, + e.g. [2., -0.3] represents the final results is 2* ``pss`` [0]-0.3* ``pss`` [1] + defaults to None, None indicate the list of expectations for ``pss`` are all returned + :type ws: Optional[List[float]], optional + :param shots: measurement shots for each expectation estimation, defaults to 8192 + :type shots: int, optional + :param with_rem: whether enable readout error mitigation for the result, defaults to True + :type with_rem: bool, optional + :return: List of Pauli string expectation or a weighted sum float for Pauli strings, depending on ``ws`` + :rtype: Union[Any, List[Any]] + """ if device is None: results = [] for ps in pss: results.append(c.expectation_ps(**ps2xyz(ps))) # type: ignore if ws is None: - return backend.stack(results) + return backend.real(backend.stack(results)) else: - return backend.sum([w * r for w, r in zip(ws, results)]) + return backend.real(backend.sum([w * r for w, r in zip(ws, results)])) cs = [] infos = [] exps = [] @@ -113,6 +153,7 @@ def batch_expectation_ps( c1, compiled_options={ "basis_gates": device.native_gates(), + # whether + "cx" here? "optimization_level": 3, "coupling_map": device.topology(), }, @@ -180,6 +221,6 @@ def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: counts.expectation(raw_counts[i], exps[i]) for i in range(len(raw_counts)) ] if ws is not None: - sumr = sum([w * r for w, r in zip(ws, results)]) + sumr = backend.sum([w * r for w, r in zip(ws, results)]) return sumr - return results + return backend.stack(results) From 10f91dd4d6e2323a58ed3ab364f5a639059ffcd9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 6 May 2023 12:38:22 +0800 Subject: [PATCH 425/725] update more on docs and readme --- README.md | 6 +++--- README_cn.md | 6 ++++-- docs/source/index.rst | 8 ++++++-- docs/source/infras.rst | 10 ++++++++-- tensorcircuit/cloud/wrapper.py | 3 ++- 5 files changed, 23 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 848de62c..eea2c13b 100644 --- a/README.md +++ b/README.md @@ -29,9 +29,9 @@

English | 简体中文

-TensorCircuit is the next generation of quantum circuit simulators with support for automatic differentiation, just-in-time compiling, hardware acceleration, and vectorized parallelism. +TensorCircuit is the next generation of quantum software framework with support for automatic differentiation, just-in-time compiling, hardware acceleration, and vectorized parallelism. -TensorCircuit is built on top of modern machine learning frameworks and is machine learning backend agnostic. It is specifically suitable for highly efficient simulations of quantum-classical hybrid paradigm and variational quantum algorithms. +TensorCircuit is built on top of modern machine learning frameworks and is machine learning backend agnostic. It is specifically suitable for highly efficient simulations of quantum-classical hybrid paradigm and variational quantum algorithms. It also supports real quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions since v0.9. ## Getting Started @@ -90,7 +90,7 @@ We recommend you install this package with tensorflow also installed as: pip install tensorcircuit[tensorflow] ``` -Other optional dependencies include `[torch]`, `[jax]` and `[qiskit]`. +Other optional dependencies include `[torch]`, `[jax]`, `[qiskit]` and `[cloud]`. For the nightly build of tensorcircuit with new features, try: diff --git a/README_cn.md b/README_cn.md index d22b37fd..672e55e1 100644 --- a/README_cn.md +++ b/README_cn.md @@ -25,10 +25,12 @@

English | 简体中文

-TensorCircuit 是下一代量子电路模拟器，支持自动微分、即时编译、硬件加速和向量并行化。 +TensorCircuit 是下一代量子软件框架，支持自动微分、即时编译、硬件加速和向量并行化。 TensorCircuit 建立在现代机器学习框架之上，并且与机器学习后端无关。 它特别适用于量子经典混合范式和变分量子算法的高效模拟。 +TensorCircuit 现在支持真实量子硬件连接和实验，并提供优雅的 CPU/GPU/QPU 混合部署方案（v0.9+）。 + ## 入门 请从 [快速上手](/docs/source/quickstart.rst) 和 [Jupyter 教程](/docs/source/tutorials) 开始。 @@ -86,7 +88,7 @@ pip install tensorcircuit pip install tensorcircuit[tensorflow] ``` -其他安装选项包括： `[torch]`, `[jax]` and `[qiskit]`。 +其他安装选项包括： `[torch]`, `[jax]`, `[qiskit]` 和 `[cloud]`。 此外我们有每日发布的最新版本 pip package，可以尝鲜开发的最新功能，请通过以下方式安装: diff --git a/docs/source/index.rst b/docs/source/index.rst index e45dd318..4b4029e9 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -12,10 +12,13 @@ TensorCircuit is an open source quantum circuit and algorithm simulation framewo * It is empowered by advanced tensor network simulator engine. 🔋 +* It is ready for quantum hardware access with CPU/GPU/QPU hybrid deployment solutions. 🖥 + * It is implemented with industry-standard machine learning frameworks: TensorFlow, JAX, and PyTorch. 🤖 * It is compatible with machine learning engineering paradigms: automatic differentiation, just-in-time compilation, vectorized parallelism and GPU acceleration. 🛠 + Links ---------- @@ -25,10 +28,10 @@ We also thank `contributions Date: Sat, 6 May 2023 12:51:44 +0800 Subject: [PATCH 426/725] update readme with more projects --- README.md | 18 ++++++++++++++---- README_cn.md | 18 ++++++++++++++---- 2 files changed, 28 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index eea2c13b..ea1eaeb3 100644 --- a/README.md +++ b/README.md @@ -194,19 +194,29 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) ### DQAS For the application of Differentiable Quantum Architecture Search, see [applications](/tensorcircuit/applications). -Reference paper: https://arxiv.org/pdf/2010.08561.pdf (published in QST). +Reference paper: https://arxiv.org/abs/2010.08561 (published in QST). ### VQNHE For the application of Variational Quantum-Neural Hybrid Eigensolver, see [applications](/tensorcircuit/applications). -Reference paper: https://arxiv.org/pdf/2106.05105.pdf (published in PRL) and https://arxiv.org/pdf/2112.10380.pdf. +Reference paper: https://arxiv.org/abs/2106.05105 (published in PRL) and https://arxiv.org/abs/2112.10380. ### VQEX - MBL For the application of VQEX on MBL phase identification, see the [tutorial](/docs/source/tutorials/vqex_mbl.ipynb). -Reference paper: https://arxiv.org/pdf/2111.13719.pdf (published in PRB). +Reference paper: https://arxiv.org/abs/2111.13719 (published in PRB). ### Stark - DTC For the numerical demosntration of discrete time crystal enabled by Stark many-body localization, see the Floquet simulation [demo](/examples/timeevolution_trotter.py). -Reference paper: https://arxiv.org/pdf/2208.02866.pdf (published in PRL). +Reference paper: https://arxiv.org/abs/2208.02866 (published in PRL). + +### EMQAOA-DARBO + +For the numerical simulation and hardware experiments with error mitigation on QAOA, see the [project repo](https://github.com/sherrylixuecheng/EMQAOA-DARBO). +Reference paper: https://arxiv.org/abs/2303.14877. + +### TenCirChem + +[TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) is an efficient and versatile quantum computation package for molecular properties. TenCirChem is based on TensorCircuit and is optimized for chemistry applications. +Reference paper: https://arxiv.org/abs/2303.10825. diff --git a/README_cn.md b/README_cn.md index 672e55e1..bca124cb 100644 --- a/README_cn.md +++ b/README_cn.md @@ -140,19 +140,29 @@ pip install tensorcircuit-nightly ### DQAS 可微量子架构搜索的应用见 [应用](/tensorcircuit/applications)。 -参考论文：https://arxiv.org/pdf/2010.08561.pdf (QST)。 +参考论文：https://arxiv.org/abs/2010.08561 (QST)。 ### VQNHE 关于变分量子神经混合本征求解器的应用，请参见 [应用](tensorcircuit/applications)。 -参考论文：https://arxiv.org/pdf/2106.05105.pdf (PRL) 和 https://arxiv.org/pdf/2112.10380.pdf 。 +参考论文：https://arxiv.org/abs/2106.05105 (PRL) 和 https://arxiv.org/abs/2112.10380 。 ### VQEX - MBL VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mbl.ipynb)。 -参考论文: https://arxiv.org/pdf/2111.13719.pdf (PRB)。 +参考论文: https://arxiv.org/abs/2111.13719 (PRB)。 ### Stark - DTC 数值验证 Stark 多体局域化稳定的离散时间晶体，类似的 Floquet 系统模拟请参考 [例子](/examples/timeevolution_trotter.py). -参考论文: https://arxiv.org/pdf/2208.02866.pdf (PRL). +参考论文: https://arxiv.org/abs/2208.02866 (PRL). + +### EMQAOA-DARBO + +数值模拟和带错误消除的真实量子硬件实验验证 QAOA 优化的代码请参考 [项目](https://github.com/sherrylixuecheng/EMQAOA-DARBO). +参考论文: https://arxiv.org/abs/2303.14877. + +### TenCirChem + +[TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) 是高效的，专注于处理和计算分子性质的量子计算软件。其基于 TensorCircuit 并为量子化学任务进行了专门的优化。 +参考论文: https://arxiv.org/abs/2303.10825. From 6ce35cc32987db6cee6fd2567919196f46015147 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 6 May 2023 12:56:00 +0800 Subject: [PATCH 427/725] further update readme research section --- README.md | 10 ++++++++-- README_cn.md | 22 ++++++++++++++-------- 2 files changed, 22 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index ea1eaeb3..6ff1936e 100644 --- a/README.md +++ b/README.md @@ -194,29 +194,35 @@ We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues) ### DQAS For the application of Differentiable Quantum Architecture Search, see [applications](/tensorcircuit/applications). + Reference paper: https://arxiv.org/abs/2010.08561 (published in QST). ### VQNHE For the application of Variational Quantum-Neural Hybrid Eigensolver, see [applications](/tensorcircuit/applications). + Reference paper: https://arxiv.org/abs/2106.05105 (published in PRL) and https://arxiv.org/abs/2112.10380. -### VQEX - MBL +### VQEX-MBL For the application of VQEX on MBL phase identification, see the [tutorial](/docs/source/tutorials/vqex_mbl.ipynb). + Reference paper: https://arxiv.org/abs/2111.13719 (published in PRB). -### Stark - DTC +### Stark-DTC For the numerical demosntration of discrete time crystal enabled by Stark many-body localization, see the Floquet simulation [demo](/examples/timeevolution_trotter.py). + Reference paper: https://arxiv.org/abs/2208.02866 (published in PRL). ### EMQAOA-DARBO For the numerical simulation and hardware experiments with error mitigation on QAOA, see the [project repo](https://github.com/sherrylixuecheng/EMQAOA-DARBO). + Reference paper: https://arxiv.org/abs/2303.14877. ### TenCirChem [TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) is an efficient and versatile quantum computation package for molecular properties. TenCirChem is based on TensorCircuit and is optimized for chemistry applications. + Reference paper: https://arxiv.org/abs/2303.10825. diff --git a/README_cn.md b/README_cn.md index bca124cb..c5524b30 100644 --- a/README_cn.md +++ b/README_cn.md @@ -35,7 +35,7 @@ TensorCircuit 现在支持真实量子硬件连接和实验，并提供优雅的 请从 [快速上手](/docs/source/quickstart.rst) 和 [Jupyter 教程](/docs/source/tutorials) 开始。 -有关更多信息和介绍，请参阅有用的 [示例脚本](/examples) 和 [完整文档](https://tensorcircuit.readthedocs.io/zh/latest/)。 [测试](/tests) 中的 API docstring 和测试用例也提供了丰富的信息。 +有关更多信息和介绍，请参阅有用的 [示例脚本](/examples) 和 [完整文档](https://tensorcircuit.readthedocs.io/zh/latest/)。 [测试](/tests)用例和 API docstring 也提供了丰富的使用信息。 以下是一些最简易的演示。 @@ -140,29 +140,35 @@ pip install tensorcircuit-nightly ### DQAS 可微量子架构搜索的应用见 [应用](/tensorcircuit/applications)。 + 参考论文：https://arxiv.org/abs/2010.08561 (QST)。 ### VQNHE 关于变分量子神经混合本征求解器的应用，请参见 [应用](tensorcircuit/applications)。 + 参考论文：https://arxiv.org/abs/2106.05105 (PRL) 和 https://arxiv.org/abs/2112.10380 。 -### VQEX - MBL +### VQEX-MBL VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mbl.ipynb)。 + 参考论文: https://arxiv.org/abs/2111.13719 (PRB)。 -### Stark - DTC +### Stark-DTC -数值验证 Stark 多体局域化稳定的离散时间晶体，类似的 Floquet 系统模拟请参考 [例子](/examples/timeevolution_trotter.py). -参考论文: https://arxiv.org/abs/2208.02866 (PRL). +数值验证 Stark 多体局域化稳定的离散时间晶体，类似的 Floquet 系统模拟请参考 [例子](/examples/timeevolution_trotter.py)。 + +参考论文: https://arxiv.org/abs/2208.02866 (PRL)。 ### EMQAOA-DARBO -数值模拟和带错误消除的真实量子硬件实验验证 QAOA 优化的代码请参考 [项目](https://github.com/sherrylixuecheng/EMQAOA-DARBO). -参考论文: https://arxiv.org/abs/2303.14877. +数值模拟和带错误消除的真实量子硬件实验验证 QAOA 优化的代码请参考 [项目](https://github.com/sherrylixuecheng/EMQAOA-DARBO)。 + +参考论文: https://arxiv.org/abs/2303.14877。 ### TenCirChem [TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) 是高效的，专注于处理和计算分子性质的量子计算软件。其基于 TensorCircuit 并为量子化学任务进行了专门的优化。 -参考论文: https://arxiv.org/abs/2303.10825. + +参考论文: https://arxiv.org/abs/2303.10825。 From 17d3e27f88f2b61cefa3b2a9feb5f708abc2ddf3 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 6 May 2023 16:43:45 +0800 Subject: [PATCH 428/725] add pauli group link comment --- tensorcircuit/cloud/wrapper.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 889a9291..68a396f9 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -139,6 +139,7 @@ def batch_expectation_ps( device = get_device(device) for ps in pss: # TODO(@refraction-ray): Pauli string grouping + # https://docs.pennylane.ai/en/stable/_modules/pennylane/pauli/grouping/group_observables.html c1 = Circuit.from_qir(c.to_qir()) exp = [] for j, i in enumerate(ps): From dcdfb7e455d44054123d8fcec2ac5b504b90a8c6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 7 May 2023 10:33:11 +0800 Subject: [PATCH 429/725] add torch hardware layer --- tensorcircuit/__init__.py | 4 ++-- tensorcircuit/backends/jax_ops.py | 2 +- tensorcircuit/keras.py | 8 +++++++ tensorcircuit/torchnn.py | 39 +++++++++++++++++++++++++++++++ tests/test_torchnn.py | 23 ++++++++++++++++++ 5 files changed, 73 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 8fe6a31b..2cfc536f 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -43,13 +43,13 @@ try: from . import keras - from .keras import QuantumLayer as KerasLayer + from .keras import KerasLayer, KerasHardwareLayer except ModuleNotFoundError: pass # in case tf is not installed try: from . import torchnn - from .torchnn import QuantumNet as TorchLayer + from .torchnn import TorchLayer, TorchHardwareLayer except ModuleNotFoundError: pass # in case torch is not installed diff --git a/tensorcircuit/backends/jax_ops.py b/tensorcircuit/backends/jax_ops.py index e9e6c2cf..63cd2e33 100644 --- a/tensorcircuit/backends/jax_ops.py +++ b/tensorcircuit/backends/jax_ops.py @@ -92,7 +92,7 @@ def jaxqr_bwd(res: Sequence[Array], tangents: Sequence[Array]) -> Tuple[Array]: dr = dr.conj() def _TriangularSolve(x: Array, r: Array) -> Array: - return jax.scipy.linalg.solve_triangular( + return jax.scipy.linalg.solve_triangular( # type: ignore r, x.T.conj(), lower=False, trans=0 ).T.conj() diff --git a/tensorcircuit/keras.py b/tensorcircuit/keras.py index 7aafdd15..ed947b8c 100644 --- a/tensorcircuit/keras.py +++ b/tensorcircuit/keras.py @@ -143,6 +143,11 @@ def call( class HardwareLayer(QuantumLayer): + """ + Keras Layer wrapping quantum function with cloud qpu access + (using :py:mod:`tensorcircuit.cloud` module) + """ + @tf.autograph.experimental.do_not_convert # type: ignore def call( self, @@ -170,6 +175,9 @@ def call( return result +KerasHardwareLayer = HardwareLayer + + def output_asis_loss(y_true: tf.Tensor, y_pred: tf.Tensor) -> tf.Tensor: """ The keras loss function that directly taking the model output as the loss. diff --git a/tensorcircuit/torchnn.py b/tensorcircuit/torchnn.py index f284e5e7..0cda7f0f 100644 --- a/tensorcircuit/torchnn.py +++ b/tensorcircuit/torchnn.py @@ -97,3 +97,42 @@ def forward(self, *inputs: Tensor) -> Tensor: TorchLayer = QuantumNet + + +class HardwareNet(QuantumNet): + """ + PyTorch Layer wrapping quantum function with cloud qpu access + (using :py:mod:`tensorcircuit.cloud` module) + """ + + def __init__( + self, + f: Callable[..., Any], + weights_shape: Sequence[Tuple[int, ...]], + initializer: Union[Any, Sequence[Any]] = None, + use_vmap: bool = True, + ): + super().__init__( + f, + weights_shape, + initializer, + use_vmap=False, + use_interface=False, + use_jit=False, + ) + self.batch_support = use_vmap + + def forward(self, *inputs: Tensor) -> Tensor: + if self.batch_support: + ypred = [] + batch = inputs[0].shape[0] + for i in range(batch): + inp = tuple([a[i] for a in inputs]) + ypred.append(self.f(*inp, *self.q_weights)) + ypred = torch.stack(ypred) # type: ignore + else: + ypred = self.f(*inputs, *self.q_weights) + return ypred + + +TorchHardwareLayer = HardwareNet diff --git a/tests/test_torchnn.py b/tests/test_torchnn.py index 1d2807bb..6acb7b17 100644 --- a/tests/test_torchnn.py +++ b/tests/test_torchnn.py @@ -74,3 +74,26 @@ def f(state, noise, weights): lsum.backward() for p in layer.parameters(): print(p.grad) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("torchb")]) +def test_torchnn_hardware(backend): + n = 2 + + def qf(inputs, param): + inputs = tc.backend.convert_to_tensor(tc.get_backend("pytorch").numpy(inputs)) + param = tc.backend.convert_to_tensor(tc.get_backend("pytorch").numpy(param)) + + c = tc.Circuit(n) + c.rx(0, theta=inputs[0]) + c.rx(1, theta=inputs[1]) + c.h(1) + c.rzz(0, 1, theta=param[0]) + r = tc.backend.stack([c.expectation_ps(z=[i]) for i in range(n)]) + + r = tc.get_backend("pytorch").convert_to_tensor(tc.backend.numpy(r)) + return torch.real(r) + + ql = tc.torchnn.HardwareNet(qf, [1]) + qnet = torch.nn.Sequential(ql, torch.nn.Linear(2, 1)) + print(qnet(torch.ones([5, 2]))) From 2d16c09e0c9cb811aaf7dea1480b3dc7b7899588 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 7 May 2023 11:02:16 +0800 Subject: [PATCH 430/725] update zh doc and readme --- README.md | 4 + README_cn.md | 4 + docs/source/index.rst | 6 +- docs/source/locale/zh/LC_MESSAGES/api.po | 3576 +++++++++++++---- docs/source/locale/zh/LC_MESSAGES/index.po | 154 +- docs/source/locale/zh/LC_MESSAGES/infras.po | 67 +- .../locale/zh/LC_MESSAGES/quickstart.po | 896 +++-- .../source/locale/zh/LC_MESSAGES/sharpbits.po | 96 +- 8 files changed, 3418 insertions(+), 1385 deletions(-) diff --git a/README.md b/README.md index 6ff1936e..412b10d9 100644 --- a/README.md +++ b/README.md @@ -139,6 +139,10 @@ For contribution guidelines and notes, see [CONTRIBUTING](/CONTRIBUTING.md). We welcome [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues), [PRs](https://github.com/tencent-quantum-lab/tensorcircuit/pulls), and [discussions](https://github.com/tencent-quantum-lab/tensorcircuit/discussions) from everyone, and these are all hosted on GitHub. +### License + +TensorCircuit is open source, released under the Apache License, Version 2.0. + ### Contributors diff --git a/README_cn.md b/README_cn.md index c5524b30..f85108e6 100644 --- a/README_cn.md +++ b/README_cn.md @@ -135,6 +135,10 @@ pip install tensorcircuit-nightly 我们欢迎大家提出 [issues](https://github.com/tencent-quantum-lab/tensorcircuit/issues), [PR](https://github.com/tencent-quantum-lab/tensorcircuit/pulls), 和 [讨论](https://github.com/tencent-quantum-lab/tensorcircuit/discussions)，这些都托管在 GitHub 上。 +### 协议 + +TensorCircuit 是基于 Apache License 2.0 的开源软件。 + ## 研究和应用 ### DQAS diff --git a/docs/source/index.rst b/docs/source/index.rst index 4b4029e9..d8958657 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -30,7 +30,7 @@ We also thank `contributions `_" +"Bases: " +":py:class:`~tensornetwork.backends.abstract_backend.AbstractBackend`, " +":py:class:`~tensorcircuit.backends.abstract_backend.ExtendedBackend`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.abs:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.abs:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.abs:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.abs:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.abs:1 @@ -7288,14 +7858,17 @@ msgid "" " tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.abs:4 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.abs:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.abs:4 #: tensorcircuit.backends.numpy_backend.NumpyBackend.abs:4 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.abs:4 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.abs:4 msgid "Its elementwise absolute value." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acos:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.acos:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.asin:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.acos:1 #: tensorcircuit.backends.jax_backend.JaxBackend.asin:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.acos:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.asin:1 @@ -7307,6 +7880,22 @@ msgid "Return the acos of a tensor ``a``." msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.sqrtmh:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.acos:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.acosh:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.asin:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.asinh:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.atan:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.atan2:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.atanh:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.copy:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.cosh:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.eigvalsh:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.kron:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.kron:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.numpy:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.sinh:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.tan:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.tanh:3 #: tensorcircuit.backends.jax_backend.JaxBackend.acos:3 #: tensorcircuit.backends.jax_backend.JaxBackend.acosh:3 #: tensorcircuit.backends.jax_backend.JaxBackend.asin:3 @@ -7374,28 +7963,32 @@ msgstr "" msgid "tensor in matrix form" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acos:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.acos:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.acos:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.acos:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acos:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acos:5 msgid "acos of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acosh:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.acosh:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.acosh:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh:1 msgid "Return the acosh of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.acosh:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.acosh:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.acosh:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.acosh:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.acosh:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.acosh:5 msgid "acosh of ``a``" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.addition:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.addition:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.addition:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.addition:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.addition:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.addition:1 @@ -7404,7 +7997,13 @@ msgid "" "implementation. :param tensor1: A tensor. :param tensor2: A tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cos:4 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.conj:4 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.cos:4 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.expm:4 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.multiply:7 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.sin:4 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.softmax:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.cos:4 #: tensorcircuit.backends.jax_backend.JaxBackend.expm:4 #: tensorcircuit.backends.jax_backend.JaxBackend.sin:4 #: tensorcircuit.backends.jax_backend.JaxBackend.softmax:9 @@ -7422,8 +8021,11 @@ msgstr "" #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin:4 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:9 #: tensorcircuit.experimental.hamiltonian_evol:12 +#: tensornetwork.backends.abstract_backend.AbstractBackend.addition:6 +#: tensornetwork.backends.abstract_backend.AbstractBackend.divide:6 #: tensornetwork.backends.abstract_backend.AbstractBackend.exp:4 #: tensornetwork.backends.abstract_backend.AbstractBackend.log:4 +#: tensornetwork.backends.abstract_backend.AbstractBackend.subtraction:6 #: tensornetwork.backends.jax.jax_backend.JaxBackend.addition:6 #: tensornetwork.backends.jax.jax_backend.JaxBackend.conj:4 #: tensornetwork.backends.jax.jax_backend.JaxBackend.divide:6 @@ -7459,6 +8061,7 @@ msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.adjoint:3 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshape2:3 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.reshapem:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.relu:9 #: tensorcircuit.backends.jax_backend.JaxBackend.relu:9 #: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:9 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:9 @@ -7470,42 +8073,49 @@ msgstr "" msgid "adjoint tensor of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.arange:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.arange:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:1 msgid "Values are generated within the half-open interval [start, stop)" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.arange:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.arange:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:3 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:3 msgid "start index" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.arange:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.arange:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:5 msgid "end index, defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.arange:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.arange:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.arange:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.arange:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.arange:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.arange:7 msgid "steps, defaults to 1" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.argmax:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.argmax:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.argmax:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmax:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmax:1 msgid "Return the index of maximum of an array an axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.argmax:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.argmax:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.argmin:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.argmax:5 #: tensorcircuit.backends.jax_backend.JaxBackend.argmin:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.argmax:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:5 @@ -7516,70 +8126,80 @@ msgstr "" msgid "[description], defaults to 0, different behavior from numpy defaults!" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.argmin:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.argmin:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.argmin:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.argmin:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.argmin:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.argmin:1 msgid "Return the index of minimum of an array an axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.asin:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.asin:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.asin:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.asin:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asin:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asin:5 msgid "asin of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.asinh:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.asinh:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.asinh:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh:1 msgid "Return the asinh of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.asinh:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.asinh:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.asinh:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.asinh:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.asinh:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.asinh:5 msgid "asinh of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atan:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.atan:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.atan:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan:1 msgid "Return the atan of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atan:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.atan:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.atan:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan:5 msgid "atan of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atan2:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.atan2:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.atan2:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2:1 msgid "Return the atan of a tensor ``y``/``x``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atan2:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.atan2:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.atan2:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.atan2:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atan2:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atan2:5 msgid "atan2 of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atanh:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.atanh:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.atanh:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.atanh:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atanh:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atanh:1 msgid "Return the atanh of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.atanh:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.atanh:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.atanh:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.atanh:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.atanh:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.atanh:5 @@ -7587,6 +8207,7 @@ msgid "atanh of ``a``" msgstr "" #: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.broadcast_left_multiplication:1 #: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_left_multiplication:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_left_multiplication:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_left_multiplication:1 @@ -7600,6 +8221,8 @@ msgid "" msgstr "" #: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.broadcast_left_multiplication:8 +#: tensornetwork.backends.abstract_backend.AbstractBackend.broadcast_right_multiplication:8 #: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_left_multiplication:8 #: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_right_multiplication:8 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_left_multiplication:8 @@ -7612,6 +8235,7 @@ msgid "The result of multiplying `tensor1` onto `tensor2`." msgstr "" #: of +#: tensornetwork.backends.abstract_backend.AbstractBackend.broadcast_right_multiplication:1 #: tensornetwork.backends.jax.jax_backend.JaxBackend.broadcast_right_multiplication:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.broadcast_right_multiplication:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.broadcast_right_multiplication:1 @@ -7624,7 +8248,8 @@ msgid "" "tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cast:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.cast:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:1 @@ -7632,6 +8257,10 @@ msgid "Cast the tensor dtype of a ``a``." msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.sizen:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.cast:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.imag:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.real:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.size:3 #: tensorcircuit.backends.jax_backend.JaxBackend.cast:3 #: tensorcircuit.backends.jax_backend.JaxBackend.imag:3 #: tensorcircuit.backends.jax_backend.JaxBackend.real:3 @@ -7651,21 +8280,24 @@ msgstr "" msgid "tensor" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cast:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.cast:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:5 msgid "\"float32\", \"float64\", \"complex64\", \"complex128\"" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cast:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cast:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.cast:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cast:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cast:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cast:7 msgid "``a`` of new dtype" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.concat:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.concat:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.concat:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.concat:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.concat:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.concat:1 @@ -7676,6 +8308,10 @@ msgstr "" #: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu:5 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:9 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:7 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.concat:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randn:9 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randu:7 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:31 #: tensorcircuit.backends.jax_backend.JaxBackend.concat:5 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:5 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:5 @@ -7695,7 +8331,8 @@ msgstr "" msgid "[description], defaults to 0" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cond:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cond:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.cond:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cond:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cond:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cond:1 @@ -7704,14 +8341,16 @@ msgid "" "functionality of ``jax.lax.cond``." msgstr "" -#: of tensorcircuit.backends.pytorch_backend._conj_torch:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.conj:1 +#: tensorcircuit.backends.pytorch_backend._conj_torch:1 #: tensornetwork.backends.jax.jax_backend.JaxBackend.conj:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.conj:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.conj:1 msgid "Return the complex conjugate of `tensor` :param tensor: A tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.convert_to_tensor:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.convert_to_tensor:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.convert_to_tensor:1 #: tensorcircuit.backends.numpy_backend._convert_to_tensor_numpy:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.convert_to_tensor:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.convert_to_tensor:1 @@ -7720,6 +8359,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.coo_sparse_matrix:1 #: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:1 @@ -7730,6 +8370,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:4 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.coo_sparse_matrix:4 #: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:4 #: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:4 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:4 @@ -7738,6 +8379,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:6 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.coo_sparse_matrix:6 #: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:6 #: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:6 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:6 @@ -7746,6 +8388,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.coo_sparse_matrix:8 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.coo_sparse_matrix:8 #: tensorcircuit.backends.jax_backend.JaxBackend.coo_sparse_matrix:8 #: tensorcircuit.backends.numpy_backend.NumpyBackend.coo_sparse_matrix:8 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.coo_sparse_matrix:8 @@ -7767,49 +8410,56 @@ msgstr "" msgid "SparseTensor in backend format" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.copy:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.copy:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.copy:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.copy:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy:1 msgid "Return the copy of ``a``, matrix exponential." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.copy:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.copy:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.copy:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.copy:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.copy:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.copy:5 msgid "matrix exponential of matrix ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cos:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cos:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.cos:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cos:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cos:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cos:1 msgid "Return cos of `tensor`. :param tensor: A tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cosh:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cosh:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.cosh:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh:1 msgid "Return the cosh of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cosh:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cosh:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.cosh:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cosh:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cosh:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cosh:5 msgid "cosh of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cumsum:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cumsum:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.cumsum:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:1 msgid "Return the cumulative sum of the elements along a given axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.cumsum:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.cumsum:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.cumsum:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.cumsum:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.cumsum:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.cumsum:5 @@ -7836,14 +8486,17 @@ msgstr "" msgid "The tensor object represented by the string." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.device:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.device:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.device:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.device:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device:1 msgid "get the universal device str for the tensor, in the format of tf" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.device:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.device:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.device_move:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.device:3 #: tensorcircuit.backends.jax_backend.JaxBackend.device_move:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.device:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move:3 @@ -7855,35 +8508,40 @@ msgstr "" msgid "the tensor" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.device:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.device:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.device:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.device:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device:5 msgid "device str where the tensor lives on" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.device_move:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.device_move:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.device_move:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move:1 msgid "move tensor ``a`` to device ``dev``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.device_move:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.device_move:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.device_move:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move:5 msgid "device str or device obj in corresponding backend" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.device_move:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.device_move:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.device_move:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.device_move:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.device_move:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.device_move:7 msgid "the tensor on new device" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagflat:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagflat:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagflat:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagflat:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagflat:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagflat:1 @@ -7893,21 +8551,24 @@ msgid "" "which to place its elements." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagflat:6 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagflat:6 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagflat:6 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagflat:6 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagflat:6 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagflat:6 msgid "A new tensor with all zeros save the specified diagonal." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:1 msgid "Return specified diagonals." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:3 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:3 @@ -7921,7 +8582,8 @@ msgid "" "diagonals." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:11 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:11 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:11 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:11 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:11 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:11 @@ -7930,7 +8592,14 @@ msgid "" "matrices from vectors, use diagflat." msgstr "" -#: of tensorcircuit.backends.tensorflow_backend._tensordot_tf:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.reshape:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.shape_tuple:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.tensordot:3 +#: tensorcircuit.backends.tensorflow_backend._tensordot_tf:3 +#: tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:14 +#: tensornetwork.backends.abstract_backend.AbstractBackend.shape_tensor:3 +#: tensornetwork.backends.abstract_backend.AbstractBackend.slice:3 +#: tensornetwork.backends.abstract_backend.AbstractBackend.trace:10 #: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:14 #: tensornetwork.backends.jax.jax_backend.JaxBackend.reshape:3 #: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor:3 @@ -7961,7 +8630,9 @@ msgstr "" msgid "A tensor." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:15 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:15 +#: tensornetwork.backends.abstract_backend.AbstractBackend.trace:11 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:15 #: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:11 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:15 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:11 @@ -7970,16 +8641,21 @@ msgstr "" msgid "Offset of the diagonal from the main diagonal." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:16 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:19 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:12 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:15 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:16 +#: tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:19 +#: tensornetwork.backends.abstract_backend.AbstractBackend.trace:12 +#: tensornetwork.backends.abstract_backend.AbstractBackend.trace:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:16 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:19 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:12 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:15 msgid "" "Axis to be used as the first/second axis of the 2D sub-arrays from which " -"the diagonals should be taken. Defaults to second last/last axis." +"the diagonals should be taken. Defaults to second-last/last axis." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:23 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:23 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:23 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:23 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:25 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:33 @@ -7988,21 +8664,24 @@ msgid "" "batched diagonals." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:25 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:25 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:25 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:25 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:27 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:35 msgid "A dim = min(1, tensor.ndim - 2) tensor storing" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:26 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.diagonal:26 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:26 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:26 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.diagonal:28 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.diagonal:36 msgid "the batched diagonals." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.divide:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.divide:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.divide:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.divide:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.divide:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.divide:1 @@ -8011,145 +8690,77 @@ msgid "" "implementation. :param tensor1: A tensor. :param tensor2: A tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.dtype:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.dtype:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.dtype:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype:1 msgid "Obtain dtype string for tensor ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.dtype:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.dtype:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.dtype:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype:3 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype:3 msgid "The tensor" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.dtype:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.dtype:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.dtype:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.dtype:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.dtype:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.dtype:5 msgid "dtype str, such as \"complex64\"" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigh:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh:1 msgid "Compute eigenvectors and eigenvalues of a hermitian matrix." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:3 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigh:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh:3 msgid "A symetric matrix." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:5 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigh:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigh:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigh:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigh:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eigh:5 msgid "The eigenvalues in ascending order. Tensor: The eigenvectors." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:1 -msgid "" -"Implicitly restarted Arnoldi method for finding the lowest eigenvector-" -"eigenvalue pairs of a linear operator `A`. `A` is a function implementing" -" the matrix-vector product." -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:6 -msgid "" -"WARNING: This routine uses jax.jit to reduce runtimes. jitting is " -"triggered at the first invocation of `eigs`, and on any subsequent calls " -"if the python `id` of `A` changes, even if the formal definition of `A` " -"stays the same. Example: the following will jit once at the beginning, " -"and then never again:" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:12 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:12 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:10 -msgid "```python import jax import numpy as np def A(H,x):" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:16 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:31 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:16 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:31 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:14 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:29 -msgid "return jax.np.dot(H,x)" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:19 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:19 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:17 -msgid "for n in range(100):" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:18 -msgid "" -"H = jax.np.array(np.random.rand(10,10)) x = " -"jax.np.array(np.random.rand(10,10)) res = eigs(A, [H],x) #jitting is " -"triggerd only at `n=0`" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:23 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:23 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:21 -msgid "" -"The following code triggers jitting at every iteration, which results in " -"considerably reduced performance" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:26 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:26 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:24 -msgid "```python import jax import numpy as np for n in range(100):" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:30 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:30 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:28 -msgid "def A(H,x):" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:32 -msgid "" -"H = jax.np.array(np.random.rand(10,10)) x = " -"jax.np.array(np.random.rand(10,10)) res = eigs(A, [H],x) #jitting is " -"triggerd at every step `n`" -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:37 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:37 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:35 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:1 msgid "" -"A (sparse) implementation of a linear operator. Call signature of `A` is " -"`res = A(vector, *args)`, where `vector` can be an arbitrary `Tensor`, " -"and `res.shape` has to be `vector.shape`." +"Arnoldi method for finding the lowest eigenvector-eigenvalue pairs of a " +"linear operator `A`. `A` is a callable implementing the matrix-vector " +"product. If no `initial_state` is provided then `shape` and `dtype` have " +"to be passed so that a suitable initial state can be randomly generated." +" :param A: A (sparse) implementation of a linear operator :param arsg: A " +"list of arguments to `A`. `A` will be called as" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:6 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:40 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:40 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:38 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:9 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:6 -#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:6 -msgid "" -"A list of arguments to `A`. `A` will be called as `res = " -"A(initial_state, *args)`." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:8 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:8 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:8 +msgid "`res = A(initial_state, *args)`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:42 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:42 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:9 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:9 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:11 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:9 msgid "" "An initial vector for the algorithm. If `None`, a random initial `Tensor`" -" is created using the `backend.randn` method" +" is created using the `numpy.random.randn` method." msgstr "" #: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:12 @@ -8165,12 +8776,16 @@ msgstr "" msgid "The shape of the input-dimension of `A`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:45 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:45 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:43 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:13 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:13 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:11 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:13 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:11 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:11 msgid "" -"The dtype of the input `A`. If no `initial_state` is provided, a random " -"initial state with shape `shape` and dtype `dtype` is created." +"The dtype of the input `A`. If both no `initial_state` is provided, a " +"random initial state with shape `shape` and dtype `dtype` is created." msgstr "" #: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:15 @@ -8186,111 +8801,121 @@ msgstr "" msgid "The number of iterations (number of krylov vectors)." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:48 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:48 -msgid "The number of eigenvector-eigenvalue pairs to be computed." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:16 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:16 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:14 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:18 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:16 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:14 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:14 +msgid "" +"The nummber of eigenvector-eigenvalue pairs to be computed. If `numeig > " +"1`, `reorthogonalize` has to be `True`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:49 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:49 -msgid "" -"The desired precision of the eigenvalues. For the jax backend this has " -"currently no effect, and precision of eigenvalues is not guaranteed. This" -" feature may be added at a later point. To increase precision the caller " -"can either increase `maxiter` or `num_krylov_vecs`." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:18 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:18 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:20 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:18 +msgid "The desired precision of the eigenvalus. Uses" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:53 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:53 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:19 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:19 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:19 msgid "" -"Flag for targetting different types of eigenvalues. Currently supported " -"are `which = 'LR'` (larges real part) and `which = 'LM'` (larges " -"magnitude)." +"['LM' | 'SM' | 'LR' | 'SR' | 'LI' | 'SI'] Which `k` eigenvectors and " +"eigenvalues to find: 'LM' : largest magnitude 'SM' : smallest " +"magnitude 'LR' : largest real part 'SR' : smallest real part " +"'LI' : largest imaginary part 'SI' : smallest imaginary part Note " +"that not all of those might be supported by specialized backends." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:56 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:56 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:19 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:19 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:19 msgid "" -"Maximum number of restarts. For `maxiter=0` the routine becomes " -"equivalent to a simple Arnoldi method." +"['LM' | 'SM' | 'LR' | 'SR' | 'LI' | 'SI'] Which `k` eigenvectors and " +"eigenvalues to find:" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:59 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:59 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:21 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:21 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:21 msgid "" -"(eigvals, eigvecs) eigvals: A list of `numeig` eigenvalues eigvecs: A " -"list of `numeig` eigenvectors" +"'LM' : largest magnitude 'SM' : smallest magnitude 'LR' : largest real " +"part 'SR' : smallest real part 'LI' : largest imaginary part 'SI' : " +"smallest imaginary part" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:33 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:62 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:62 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:66 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:33 -#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:33 -msgid "(eigvals, eigvecs)" +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:27 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:27 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:27 +msgid "Note that not all of those might be supported by specialized backends." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:62 -#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:62 -msgid "" -"eigvals: A list of `numeig` eigenvalues eigvecs: A list of `numeig` " -"eigenvectors" +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:28 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:28 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:28 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:28 +msgid "The maximum number of iterations." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:30 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:30 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:30 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:30 msgid "" -"Implicitly restarted Lanczos method for finding the lowest eigenvector-" -"eigenvalue pairs of a symmetric (hermitian) linear operator `A`. `A` is a" -" function implementing the matrix-vector product." -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:6 -msgid "" -"WARNING: This routine uses jax.jit to reduce runtimes. jitting is " -"triggered at the first invocation of `eigsh`, and on any subsequent calls" -" if the python `id` of `A` changes, even if the formal definition of `A` " -"stays the same. Example: the following will jit once at the beginning, " -"and then never again:" +"An array of `numeig` lowest eigenvalues `list`: A list of `numeig` lowest" +" eigenvectors" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:18 -msgid "" -"H = jax.np.array(np.random.rand(10,10)) x = " -"jax.np.array(np.random.rand(10,10)) res = eigsh(A, [H],x) #jitting is " -"triggerd only at `n=0`" +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:32 +#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:32 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:32 +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:12 +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor:10 +#: tensornetwork.matrixproductstates.base_mps.BaseMPS.position:10 +#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize:9 +msgid "`Tensor`" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:32 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:1 msgid "" -"H = jax.np.array(np.random.rand(10,10)) x = " -"jax.np.array(np.random.rand(10,10)) res = eigsh(A, [H],x) #jitting is " -"triggerd at every step `n`" +"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " +"symmetric (hermitian) linear operator `A`. `A` is a callable implementing" +" the matrix-vector product. If no `initial_state` is provided then " +"`shape` and `dtype` have to be passed so that a suitable initial state " +"can be randomly generated. :param A: A (sparse) implementation of a " +"linear operator :param arsg: A list of arguments to `A`. `A` will be " +"called as" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:1 msgid "" -"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " -"hermitian linear operator `A`. `A` is a function implementing the matrix-" -"vector product. WARNING: This routine uses jax.jit to reduce runtimes. " -"jitting is triggered at the first invocation of `eigsh_lanczos`, and on " -"any subsequent calls if the python `id` of `A` changes, even if the " -"formal definition of `A` stays the same. Example: the following will jit " -"once at the beginning, and then never again:" +"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of " +"`A`. :param A: A (sparse) implementation of a linear operator." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:16 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:4 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:4 msgid "" -"H = jax.np.array(np.random.rand(10,10)) x = " -"jax.np.array(np.random.rand(10,10)) res = eigsh_lanczos(A, [H],x) " -"#jitting is triggerd only at `n=0`" +"Call signature of `A` is `res = A(vector, *args)`, where `vector` can be " +"an arbitrary `Tensor`, and `res.shape` has to be `vector.shape`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:30 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:6 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:40 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:40 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:38 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:9 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:6 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:6 msgid "" -"H = jax.np.array(np.random.rand(10,10)) x = " -"jax.np.array(np.random.rand(10,10)) res = eigsh_lanczos(A, [H],x) " -"#jitting is triggerd at every step `n`" +"A list of arguments to `A`. `A` will be called as `res = " +"A(initial_state, *args)`." msgstr "" #: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:8 @@ -8301,18 +8926,12 @@ msgid "" "`Tensor` is created using the `backend.randn` method" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:46 -msgid "" -"The number of eigenvector-eigenvalue pairs to be computed. If `numeig > " -"1`, `reorthogonalize` has to be `True`." -msgstr "" - -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:48 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:16 msgid "" -"The desired precision of the eigenvalues. For the jax backend this has " -"currently no effect, and precision of eigenvalues is not guaranteed. This" -" feature may be added at a later point. To increase precision the caller " -"can increase `num_krylov_vecs`." +"The desired precision of the eigenvalus. Uses " +"`backend.norm(eigvalsnew[0:numeig] - eigvalsold[0:numeig]) < tol` as " +"stopping criterion between two diagonalization steps of the tridiagonal " +"operator." msgstr "" #: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:20 @@ -8326,11 +8945,12 @@ msgid "" "found." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:57 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:25 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:25 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:25 msgid "" "The tridiagonal Operator is diagonalized every `ndiag` iterations to " -"check convergence. This has currently no effect for the jax backend, but " -"may be added at a later point." +"check convergence." msgstr "" #: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:27 @@ -8342,54 +8962,73 @@ msgid "" "orthogonalization (more costly than `reorthogonalize=False`)" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:63 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:30 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:30 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:30 msgid "" -"(eigvals, eigvecs) eigvals: A jax-array containing `numeig` lowest " -"eigenvalues eigvecs: A list of `numeig` lowest eigenvectors" +"(eigvals, eigvecs) eigvals: A list of `numeig` lowest eigenvalues " +"eigvecs: A list of `numeig` lowest eigenvectors" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:66 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:33 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:62 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:62 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:66 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:33 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:33 +msgid "(eigvals, eigvecs)" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:33 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:33 +#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:33 msgid "" -"eigvals: A jax-array containing `numeig` lowest eigenvalues eigvecs: A " -"list of `numeig` lowest eigenvectors" +"eigvals: A list of `numeig` lowest eigenvalues eigvecs: A list of " +"`numeig` lowest eigenvectors" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.eigvalsh:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh:1 msgid "Get the eigenvalues of matrix ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.eigvalsh:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.eigvalsh:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.eigvalsh:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eigvalsh:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eigvalsh:5 msgid "eigenvalues of ``a``" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.einsum:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.einsum:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.einsum:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.einsum:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.einsum:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.einsum:1 msgid "Calculate sum of products of tensors according to expression." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eps:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eps:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eps:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps:1 msgid "Return machine epsilon for given `dtype`" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eps:3 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eps:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eps:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps:3 msgid "A dtype." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eps:5 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.eps:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eps:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eps:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eps:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.eps:5 @@ -8403,21 +9042,24 @@ msgstr "" msgid "Return elementwise exp of `tensor`. :param tensor: A tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.expm:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.expm:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.expm:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.expm:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.expm:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.expm:1 msgid "Return expm log of `matrix`, matrix exponential. :param matrix: A tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:4 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.eye:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.eye:4 #: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:4 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:4 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:4 msgid "Return an identity matrix of dimension `dim`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:2 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.eye:2 +#: tensorcircuit.backends.jax_backend.JaxBackend.eye:2 #: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:2 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:2 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:2 @@ -8427,7 +9069,9 @@ msgid "" "Block-sparse behavior is currently not supported" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:6 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.eye:6 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.eye:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.eye:6 #: tensorcircuit.backends.jax_backend.JaxBackend.eye:9 #: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:6 #: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:9 @@ -8438,7 +9082,8 @@ msgstr "" msgid "The dimension of the returned matrix." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.eye:8 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.eye:8 +#: tensorcircuit.backends.jax_backend.JaxBackend.eye:8 #: tensorcircuit.backends.numpy_backend.NumpyBackend.eye:8 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.eye:8 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.eye:8 @@ -8633,14 +9278,17 @@ msgid "" "convergence was achieved, the number of restarts otherwise." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.grad:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.grad:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:1 msgid "Return the function which is the grad function of input ``f``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:13 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.grad:13 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.value_and_grad:13 +#: tensorcircuit.backends.jax_backend.JaxBackend.grad:13 #: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:13 #: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:13 #: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:13 @@ -8651,7 +9299,9 @@ msgstr "" msgid "the function to be differentiated" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:15 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.grad:15 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.value_and_grad:15 +#: tensorcircuit.backends.jax_backend.JaxBackend.grad:15 #: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:15 #: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:15 #: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:15 @@ -8664,42 +9314,48 @@ msgid "" "be 0" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.grad:17 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.grad:17 +#: tensorcircuit.backends.jax_backend.JaxBackend.grad:17 #: tensorcircuit.backends.numpy_backend.NumpyBackend.grad:17 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.grad:17 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.grad:17 msgid "the grad function of ``f`` with the same set of arguments as ``f``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.i:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.i:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.i:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.i:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:1 msgid "Return 1.j in as a tensor compatible with the backend." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.i:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.i:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.i:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.i:3 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:3 msgid "\"complex64\" or \"complex128\"" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.i:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.i:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.i:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.i:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.i:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.i:5 msgid "1.j tensor" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.imag:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.imag:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.imag:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.imag:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag:1 msgid "Return the elementwise imaginary value of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.imag:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.imag:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.imag:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.imag:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.imag:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.imag:5 @@ -8709,6 +9365,8 @@ msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:1 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:1 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randc:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randn:1 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:1 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:1 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:1 @@ -8721,6 +9379,7 @@ msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:5 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randc:5 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:5 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:5 @@ -8730,6 +9389,7 @@ msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:7 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:7 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randc:7 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:7 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:7 @@ -8739,6 +9399,7 @@ msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randc:9 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randc:9 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randc:9 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randc:9 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randc:9 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randc:9 @@ -8763,6 +9424,8 @@ msgstr "" #: tensorcircuit.backends.abstract_backend.ExtendedBackend.implicit_randu:7 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:11 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:9 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randn:11 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randu:9 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:3 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randn:7 #: tensorcircuit.backends.jax_backend.JaxBackend.implicit_randu:3 @@ -8783,28 +9446,32 @@ msgstr "" msgid "[description], defaults to \"32\"" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.index_update:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update:1 msgid "Update `tensor` at elements defined by `mask` with value `assignee`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:3 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.index_update:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update:3 msgid "A `Tensor` object." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:4 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.index_update:4 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:4 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update:4 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update:4 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update:4 msgid "A boolean mask." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:5 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.index_update:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.index_update:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.index_update:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.index_update:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.index_update:5 @@ -8813,21 +9480,24 @@ msgid "" "`mask` is `True`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.inv:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.inv:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.inv:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv:1 msgid "Compute the matrix inverse of `matrix`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.inv:3 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.inv:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.inv:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv:3 msgid "A matrix." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.inv:5 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.inv:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.inv:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.inv:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.inv:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv:5 @@ -8835,6 +9505,7 @@ msgid "The inverse of `matrix`" msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.is_sparse:1 #: tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:1 @@ -8842,6 +9513,7 @@ msgid "Determine whether the type of input ``a`` is ``sparse``." msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.is_sparse:3 #: tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:3 @@ -8849,48 +9521,55 @@ msgid "input matrix ``a``" msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.is_sparse:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.is_sparse:5 #: tensorcircuit.backends.jax_backend.JaxBackend.is_sparse:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.is_sparse:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_sparse:5 msgid "a bool indicating whether the matrix ``a`` is sparse" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.is_tensor:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:1 msgid "Return a boolean on whether ``a`` is a tensor in backend package." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.is_tensor:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:3 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:3 msgid "a tensor to be determined" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.is_tensor:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.is_tensor:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.is_tensor:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.is_tensor:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.is_tensor:5 msgid "whether ``a`` is a tensor" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.item:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.item:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.item:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.item:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.item:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.item:1 msgid "Return the item of a 1-element tensor." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.item:3 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.item:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.item:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.item:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.item:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.item:3 msgid "A 1-element tensor" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.item:5 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.item:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.item:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.item:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.item:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.item:5 @@ -8926,7 +9605,8 @@ msgstr "" msgid "outer tuple for input args, inner tuple for outputs" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.jit:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.jit:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:1 @@ -8936,14 +9616,16 @@ msgid "" "Arguments to `fun`. :param kwargs: Keyword arguments to `fun`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jit:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.jit:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.jit:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.jit:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jit:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jit:7 msgid "jitted/graph-compiled version of `fun`, or just `fun`." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.jvp:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.jvp:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:1 @@ -8952,14 +9634,17 @@ msgid "" " Strictly speaking, this function is value_and_jvp." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:4 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.jvp:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.jvp:4 #: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:4 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:4 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:4 msgid "The function to compute jvp" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:6 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.jvp:6 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vjp:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.jvp:6 #: tensorcircuit.backends.jax_backend.JaxBackend.vjp:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:6 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:7 @@ -8970,14 +9655,16 @@ msgstr "" msgid "input for ``f``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:8 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.jvp:8 +#: tensorcircuit.backends.jax_backend.JaxBackend.jvp:8 #: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:8 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:8 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:8 msgid "tangents" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.jvp:10 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.jvp:10 +#: tensorcircuit.backends.jax_backend.JaxBackend.jvp:10 #: tensorcircuit.backends.numpy_backend.NumpyBackend.jvp:10 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.jvp:10 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.jvp:10 @@ -8986,28 +9673,34 @@ msgid "" "output of ``f``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.kron:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.kron:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.kron:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:1 msgid "Return the kronecker product of two matrices ``a`` and ``b``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.kron:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.kron:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.kron:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.kron:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.kron:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.kron:7 msgid "kronecker product of ``a`` and ``b``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.left_shift:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.left_shift:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.left_shift:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.left_shift:1 msgid "Shift the bits of an integer x to the left y bits." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.left_shift:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.mod:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.right_shift:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.left_shift:3 #: tensorcircuit.backends.jax_backend.JaxBackend.mod:3 #: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:3 @@ -9022,7 +9715,9 @@ msgstr "" msgid "input values" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.left_shift:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.right_shift:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.left_shift:5 #: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:5 @@ -9033,7 +9728,9 @@ msgstr "" msgid "Number of bits shift to ``x``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.left_shift:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.left_shift:7 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.right_shift:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.left_shift:7 #: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.left_shift:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:7 @@ -9052,6 +9749,7 @@ msgid "Return elementwise natural logarithm of `tensor`. :param tensor: A tensor msgstr "" #: of tensorcircuit.backends.tensorflow_backend._matmul_tf:1 +#: tensornetwork.backends.abstract_backend.AbstractBackend.matmul:1 #: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:1 @@ -9062,6 +9760,7 @@ msgid "" msgstr "" #: of tensorcircuit.backends.tensorflow_backend._matmul_tf:5 +#: tensornetwork.backends.abstract_backend.AbstractBackend.matmul:5 #: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:5 @@ -9069,6 +9768,7 @@ msgid "matrices." msgstr "" #: of tensorcircuit.backends.tensorflow_backend._matmul_tf:6 +#: tensornetwork.backends.abstract_backend.AbstractBackend.matmul:6 #: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:6 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:6 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:6 @@ -9078,6 +9778,7 @@ msgid "" msgstr "" #: of tensorcircuit.backends.tensorflow_backend._matmul_tf:8 +#: tensornetwork.backends.abstract_backend.AbstractBackend.matmul:8 #: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:8 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:8 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:8 @@ -9087,20 +9788,24 @@ msgid "" msgstr "" #: of tensorcircuit.backends.tensorflow_backend._matmul_tf:12 +#: tensornetwork.backends.abstract_backend.AbstractBackend.matmul:12 #: tensornetwork.backends.jax.jax_backend.JaxBackend.matmul:12 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.matmul:12 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.matmul:12 msgid "The result of performing the matmul." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.max:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.max:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.max:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.max:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.max:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.max:1 msgid "Return the maximum of an array or maximum along an axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.max:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.max:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.min:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.max:5 #: tensorcircuit.backends.jax_backend.JaxBackend.min:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.max:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.min:5 @@ -9112,42 +9817,49 @@ msgstr "" msgid "[description], defaults to None" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.mean:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.mean:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:1 msgid "Compute the arithmetic mean for ``a`` along the specified ``axis``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.mean:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.mean:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:3 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:3 msgid "tensor to take average" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.mean:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.mean:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:5 msgid "the axis to take mean, defaults to None indicating sum over flatten array" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mean:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.mean:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.mean:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.mean:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mean:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mean:7 +#: tensorcircuit.interfaces.torch.torch_interface_kws:26 msgid "_description_, defaults to False" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.min:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.min:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.min:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.min:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.min:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.min:1 msgid "Return the minimum of an array or minimum along an axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.mod:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.mod:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:1 @@ -9156,28 +9868,32 @@ msgid "" "consistent)" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.mod:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.mod:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:5 msgid "mod ``y``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.mod:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.mod:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.mod:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.mod:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.mod:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.mod:7 msgid "results" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.multiply:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.multiply:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.multiply:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.multiply:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.multiply:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.multiply:1 msgid "Return the default multiplication of `tensor`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.multiply:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.multiply:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.multiply:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.multiply:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.multiply:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.multiply:3 @@ -9186,14 +9902,16 @@ msgid "" ":param tensor2: A tensor." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.norm:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.norm:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.norm:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.norm:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.norm:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.norm:1 msgid "Calculate the L2-norm of the elements of `tensor`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.numpy:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.numpy:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.numpy:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.numpy:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.numpy:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.numpy:1 @@ -9202,7 +9920,8 @@ msgid "" "function." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.numpy:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.numpy:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.numpy:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.numpy:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.numpy:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.numpy:5 @@ -9213,7 +9932,8 @@ msgstr "" msgid "See doc for :py:meth:`onehot`" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.onehot:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.onehot:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:1 @@ -9223,28 +9943,32 @@ msgid "" "one:" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.onehot:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.onehot:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:5 msgid "input tensor" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.onehot:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.onehot:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:7 msgid "number of features in onehot dimension" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.onehot:9 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.onehot:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.onehot:9 #: tensorcircuit.backends.numpy_backend.NumpyBackend.onehot:9 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.onehot:9 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.onehot:9 msgid "onehot tensor with the last extra dimension" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.ones:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.ones:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.ones:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.ones:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.ones:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.ones:1 @@ -9256,7 +9980,8 @@ msgid "" "shape: int :param dtype: The dtype of the returned matrix." msgstr "" -#: of tensorcircuit.backends.tensorflow_backend._outer_product_tf:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.outer_product:1 +#: tensorcircuit.backends.tensorflow_backend._outer_product_tf:1 #: tensornetwork.backends.jax.jax_backend.JaxBackend.outer_product:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.outer_product:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.outer_product:1 @@ -9287,30 +10012,71 @@ msgstr "" msgid "The pivoted tensor." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 +msgid "Returns the exponentiation of tensor a raised to b." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:4 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:4 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:4 +msgid "If b is a tensor, then the exponentiation is element-wise" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:3 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:3 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:3 msgid "" -"Returns the power of tensor a to the value of b. In the case b is a " -"tensor, then the power is by element" +"between the two tensors, with a as the base and b as the power. Note that" +" a and b must be broadcastable to the same shape if b is a tensor." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:3 -msgid "with a as the base and b as the exponent." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 +msgid "If b is a scalar, then the exponentiation is each value in a" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:5 -msgid "In the case b is a scalar, then the power of each value in a" +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 +msgid "raised to the power of b." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:5 -msgid "is raised to the exponent of b." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:9 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:9 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:9 +msgid "The tensor containing the bases." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:7 -msgid "The tensor that contains the base." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:10 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:10 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:10 +msgid "The tensor containing the powers; or a single scalar as the power." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:8 -msgid "The tensor that contains the exponent or a single scalar." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:12 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:12 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:12 +msgid "" +"The tensor that is each element of a raised to the power of b. Note " +"that the shape of the returned tensor is that produced by the broadcast" +" of a and b." +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:15 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:15 +msgid "The tensor that is each element of a raised to the" +msgstr "" + +#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:15 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:15 +#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:15 +msgid "" +"power of b. Note that the shape of the returned tensor is that produced " +"by the broadcast of a and b." msgstr "" #: of @@ -9350,13 +10116,13 @@ msgstr "" msgid "The drawn sample as an int tensor" msgstr "" -#: of tensorcircuit.backends.jax_backend._qr_jax:1 -msgid "" -"Computes the QR decomposition of a tensor. See " -"tensornetwork.backends.tensorflow.decompositions for details." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.qr:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.qr:1 +msgid "Computes the QR decomposition of a tensor." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.randn:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.randn:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.randn:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.randn:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.randn:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.randn:1 @@ -9366,7 +10132,8 @@ msgid "" "`ShapeType` object (for block-sparse backends)." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.randn:5 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.randn:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.randn:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.randn:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.randn:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.randn:5 @@ -9386,14 +10153,16 @@ msgid "" "utility to write backend agnostic code instead of doing magic things." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.random_uniform:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.random_uniform:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.random_uniform:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform:1 msgid "Return a random uniform matrix of dimension `dim`." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:3 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.random_uniform:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.random_uniform:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.random_uniform:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform:3 @@ -9407,28 +10176,32 @@ msgid "" "random number generator" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:14 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.random_uniform:14 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.random_uniform:14 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.random_uniform:14 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.random_uniform:14 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform:14 msgid "random uniform initialized tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.real:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.real:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.real:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.real:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.real:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.real:1 msgid "Return the elementwise real value of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.real:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.real:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.real:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.real:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.real:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.real:5 msgid "real value of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.relu:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.relu:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:1 @@ -9437,28 +10210,32 @@ msgid "" "function:" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:4 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.relu:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.relu:4 #: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:4 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:4 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:4 msgid "\\mathrm{relu}(x)=\\max(x,0)" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.relu:11 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.relu:11 +#: tensorcircuit.backends.jax_backend.JaxBackend.relu:11 #: tensorcircuit.backends.numpy_backend.NumpyBackend.relu:11 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.relu:11 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.relu:11 msgid "Tensor after relu" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.reshape:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.reshape:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.reshape:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.reshape:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.reshape:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.reshape:1 msgid "Reshape tensor to the given shape." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.reshape:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.reshape:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.reshape:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.reshape:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.reshape:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.reshape:5 @@ -9493,20 +10270,27 @@ msgstr "" msgid "1D tensor in reverse order" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.right_shift:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.right_shift:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.right_shift:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.right_shift:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.right_shift:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.right_shift:1 msgid "Shift the bits of an integer x to the right y bits." msgstr "" -#: of tensorcircuit.backends.jax_backend._rq_jax:1 -msgid "" -"Computes the RQ (reversed QR) decomposition of a tensor. See " -"tensornetwork.backends.tensorflow.decompositions for details." +#: of tensornetwork.backends.abstract_backend.AbstractBackend.rq:1 +#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.rq:1 +msgid "Computes the RQ (reversed QR) decomposition of a tensor." +msgstr "" + +#: of tensorcircuit.backends.abstract_backend.ExtendedBackend.scan:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.scan:1 +#: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scan:1 +msgid "This API follows ``tf.scan`` covention, i.e. no ys supported as jax" msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.scatter:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.scatter:1 #: tensorcircuit.backends.jax_backend.JaxBackend.scatter:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.scatter:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.scatter:1 @@ -9515,28 +10299,32 @@ msgid "" "shape with rank 2 for now." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.searchsorted:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:1 msgid "Find indices where elements should be inserted to maintain order." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.searchsorted:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:3 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:3 msgid "input array sorted in ascending order" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.searchsorted:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:5 msgid "value to inserted" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.searchsorted:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:7 @@ -9546,7 +10334,8 @@ msgid "" "return either 0 or N (where N is the length of a), defaults to \"left\"" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:12 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.searchsorted:12 +#: tensorcircuit.backends.jax_backend.JaxBackend.searchsorted:12 #: tensorcircuit.backends.numpy_backend.NumpyBackend.searchsorted:12 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.searchsorted:12 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.searchsorted:12 @@ -9561,7 +10350,7 @@ msgstr "" msgid "Return a string that serializes the given tensor." msgstr "" -#: of +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sign:4 #: tensornetwork.backends.abstract_backend.AbstractBackend.serialize_tensor:3 #: tensornetwork.backends.jax.jax_backend.JaxBackend.sign:7 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.serialize_tensor:3 @@ -9579,6 +10368,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.set_random_state:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.set_random_state:1 #: tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:1 @@ -9587,6 +10377,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.set_random_state:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.set_random_state:3 #: tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:3 @@ -9595,6 +10386,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.set_random_state:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.set_random_state:5 #: tensorcircuit.backends.jax_backend.JaxBackend.set_random_state:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.set_random_state:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.set_random_state:5 @@ -9603,56 +10395,64 @@ msgid "" " the state on the backend" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_concat:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.shape_concat:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_concat:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_concat:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_concat:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_concat:1 msgid "Concatenate a sequence of tensors together about the given axis." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_prod:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.shape_prod:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_prod:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_prod:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_prod:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_prod:1 msgid "Take the product of all of the elements in values" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.shape_tensor:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tensor:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tensor:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tensor:1 msgid "Get the shape of a tensor." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor:5 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.shape_tensor:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tensor:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tensor:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tensor:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tensor:5 msgid "The shape of the input tensor returned as another tensor." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.shape_tuple:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tuple:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tuple:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple:1 msgid "Get the shape of a tensor as a tuple of integers." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.shape_tuple:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.shape_tuple:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.shape_tuple:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.shape_tuple:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple:5 msgid "The shape of the input tensor returned as a tuple of ints." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sigmoid:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sigmoid:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.sigmoid:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.sigmoid:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sigmoid:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sigmoid:1 msgid "Compute sigmoid of input ``a``" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.sign:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sign:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sign:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.sign:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sign:1 msgid "" @@ -9660,41 +10460,40 @@ msgid "" "tensor[i] > 0, == 0, and < 0 respectively." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.sign:4 -msgid "" -"For complex input the behaviour of this function may depend on the " -"backend. The Jax backend version returns y[i] = x[i]/sqrt(x[i]^2)." -msgstr "" - -#: of tensorcircuit.backends.jax_backend.JaxBackend.sin:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sin:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.sin:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.sin:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sin:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sin:1 msgid "Return sin of `tensor`. :param tensor: A tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sinh:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sinh:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.sinh:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh:1 msgid "Return the sinh of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.sinh:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sinh:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.sinh:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.sinh:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.sinh:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sinh:5 msgid "sinh of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.size:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.size:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.size:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.size:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size:1 msgid "Return the total number of elements in ``a`` in tensor form." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.size:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.size:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.size:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.size:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.size:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.size:5 @@ -9709,28 +10508,32 @@ msgstr "" msgid "the total number of elements in tensor ``a``" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.slice:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.slice:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.slice:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.slice:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.slice:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice:1 msgid "Obtains a slice of a tensor based on start_indices and slice_sizes." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.slice:4 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.slice:4 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.slice:4 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.slice:4 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.slice:4 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice:4 msgid "Tuple of integers denoting start indices of slice." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.slice:5 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.slice:5 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.slice:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.slice:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.slice:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice:5 msgid "Tuple of integers denoting size of slice along each axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.softmax:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.softmax:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:1 @@ -9739,14 +10542,16 @@ msgid "" "range [0,1] such that the elements along axis sum to 1." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:4 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.softmax:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.softmax:4 #: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:4 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:4 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:4 msgid "\\mathrm{softmax}(x) = \\frac{\\exp(x_i)}{\\sum_j \\exp(x_j)}" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:11 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.softmax:11 +#: tensorcircuit.backends.jax_backend.JaxBackend.softmax:11 #: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:11 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.softmax:11 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.softmax:11 @@ -9755,7 +10560,9 @@ msgid "" "all axis sum." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.softmax:13 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.softmax:13 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stack:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.softmax:13 #: tensorcircuit.backends.jax_backend.JaxBackend.stack:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.softmax:13 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:7 @@ -9766,28 +10573,32 @@ msgstr "" msgid "concatenated tensor" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.solve:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.solve:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:1 msgid "Solve the linear system Ax=b and return the solution x." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.solve:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.solve:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:3 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:3 msgid "The multiplied matrix." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.solve:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.solve:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:5 msgid "The resulted matrix." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.solve:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.solve:7 +#: tensorcircuit.backends.jax_backend.JaxBackend.solve:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.solve:7 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.solve:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.solve:7 @@ -9796,6 +10607,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.sparse_dense_matmul:1 #: tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:1 @@ -9805,6 +10617,8 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul:3 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.sparse_dense_matmul:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.to_dense:3 #: tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:3 #: tensorcircuit.backends.jax_backend.JaxBackend.to_dense:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:3 @@ -9816,6 +10630,7 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.sparse_dense_matmul:5 #: tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:5 @@ -9824,13 +10639,15 @@ msgstr "" #: of #: tensorcircuit.backends.abstract_backend.ExtendedBackend.sparse_dense_matmul:7 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.sparse_dense_matmul:7 #: tensorcircuit.backends.jax_backend.JaxBackend.sparse_dense_matmul:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.sparse_dense_matmul:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.sparse_dense_matmul:7 msgid "dense matrix" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.sqrt:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.sqrt:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.sqrt:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.sqrt:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.sqrt:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sqrt:1 @@ -9845,21 +10662,24 @@ msgstr "" msgid "sqrtm of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.stack:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.stack:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:1 msgid "Concatenates a sequence of tensors ``a`` along a new dimension ``axis``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:3 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.stack:3 +#: tensorcircuit.backends.jax_backend.JaxBackend.stack:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:3 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:3 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:3 msgid "List of tensors in the same shape" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stack:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.stack:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.stack:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stack:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stack:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stack:5 @@ -9868,6 +10688,8 @@ msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:5 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:3 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randn:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randu:3 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:5 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:3 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:5 @@ -9878,6 +10700,7 @@ msgid "stateful register for each package" msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:7 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randn:7 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:7 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:7 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randn:7 @@ -9886,6 +10709,8 @@ msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randn:13 #: tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:11 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randn:13 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randu:11 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randn:13 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:11 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randn:13 @@ -9896,6 +10721,7 @@ msgid "only real data type is supported, \"32\" or \"64\", defaults to \"32\"" msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randu:1 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:1 @@ -9903,20 +10729,23 @@ msgid "Uniform random sampler from ``low`` to ``high``." msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.stateful_randu:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.stateful_randu:5 #: tensorcircuit.backends.jax_backend.JaxBackend.stateful_randu:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stateful_randu:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stateful_randu:5 msgid "shape of output sampling tensor, defaults to 1" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.std:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.std:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.std:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.std:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std:1 msgid "Compute the standard deviation along the specified axis." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.std:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.std:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.std:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.std:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std:5 @@ -9925,7 +10754,8 @@ msgid "" "None, implying all axis" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.std:8 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.std:8 +#: tensorcircuit.backends.jax_backend.JaxBackend.std:8 #: tensorcircuit.backends.numpy_backend.NumpyBackend.std:8 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.std:8 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.std:8 @@ -9934,14 +10764,16 @@ msgid "" " as dimensions with size one, defaults to False" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.stop_gradient:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.stop_gradient:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.stop_gradient:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.stop_gradient:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.stop_gradient:1 msgid "Stop backpropagation from ``a``." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.subtraction:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.subtraction:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.subtraction:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.subtraction:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.subtraction:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.subtraction:1 @@ -9950,7 +10782,8 @@ msgid "" "implementation. :param tensor1: A tensor. :param tensor2: A tensor." msgstr "" -#: of tensorcircuit.backends.numpy_backend._sum_numpy:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sum:1 +#: tensorcircuit.backends.numpy_backend._sum_numpy:1 #: tensorcircuit.backends.pytorch_backend._sum_torch:1 #: tensornetwork.backends.jax.jax_backend.JaxBackend.sum:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum:1 @@ -9959,7 +10792,8 @@ msgid "" "Tensor with the summed axis removed. :param tensor: An input tensor." msgstr "" -#: of tensorcircuit.backends.numpy_backend._sum_numpy:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sum:5 +#: tensorcircuit.backends.numpy_backend._sum_numpy:5 #: tensorcircuit.backends.pytorch_backend._sum_torch:5 #: tensornetwork.backends.jax.jax_backend.JaxBackend.sum:5 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum:5 @@ -9968,14 +10802,16 @@ msgid "" " reduced by 1." msgstr "" -#: of tensorcircuit.backends.numpy_backend._sum_numpy:7 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sum:7 +#: tensorcircuit.backends.numpy_backend._sum_numpy:7 #: tensorcircuit.backends.pytorch_backend._sum_torch:7 #: tensornetwork.backends.jax.jax_backend.JaxBackend.sum:7 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum:7 msgid "The result of performing the summation. The order of the tensor" msgstr "" -#: of tensorcircuit.backends.numpy_backend._sum_numpy:8 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.sum:8 +#: tensorcircuit.backends.numpy_backend._sum_numpy:8 #: tensorcircuit.backends.pytorch_backend._sum_torch:8 #: tensornetwork.backends.jax.jax_backend.JaxBackend.sum:8 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum:8 @@ -9983,6 +10819,7 @@ msgid "will be reduced by 1." msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:1 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:1 @@ -9990,6 +10827,7 @@ msgid "Computes the singular value decomposition (SVD) of a tensor." msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:3 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:3 @@ -10001,6 +10839,7 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:8 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:8 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:8 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:8 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:8 @@ -10011,6 +10850,7 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:12 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:12 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:12 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:12 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:12 @@ -10020,6 +10860,7 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:15 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:15 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:15 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:15 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:15 @@ -10032,6 +10873,7 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:21 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:21 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:21 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:21 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:21 @@ -10044,6 +10886,7 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:27 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:27 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:27 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:27 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:27 @@ -10051,6 +10894,7 @@ msgid "The output consists of three tensors `u, s, vh` such that: ```python" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:29 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:29 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:29 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:29 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:29 @@ -10058,6 +10902,7 @@ msgid "u[i1,...,iN, j] * s[j] * vh[j, k1,...,kM] == tensor[i1,...,iN, k1,...,kM] msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:30 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:30 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:30 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:30 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:30 @@ -10071,6 +10916,7 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend._rq_torch:18 #: tensorcircuit.backends.tensorflow_backend._qr_tf:18 #: tensorcircuit.backends.tensorflow_backend._rq_tf:18 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:33 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:33 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:33 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:33 @@ -10082,6 +10928,7 @@ msgstr "" #: tensorcircuit.backends.pytorch_backend._rq_torch:20 #: tensorcircuit.backends.tensorflow_backend._qr_tf:20 #: tensorcircuit.backends.tensorflow_backend._rq_tf:20 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:34 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:34 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:34 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:34 @@ -10089,6 +10936,7 @@ msgid "Where to split the tensor's axes before flattening into a matrix." msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:36 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:36 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:36 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:36 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:36 @@ -10096,6 +10944,7 @@ msgid "The number of singular values to keep, or `None` to keep them all." msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:38 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:38 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:38 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:38 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:38 @@ -10105,6 +10954,7 @@ msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:40 #: tensorcircuit.cons.split_rules:7 #: tensorcircuit.mps_base.FiniteMPS.apply_two_site_gate:24 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:40 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:40 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:40 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:40 @@ -10112,6 +10962,7 @@ msgid "Multiply `max_truncation_err` with the largest singular value." msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:42 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:42 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:42 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:42 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:42 @@ -10122,6 +10973,7 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:42 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:42 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:42 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:42 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:42 @@ -10132,76 +10984,87 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:46 +#: tensornetwork.backends.abstract_backend.AbstractBackend.svd:46 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:46 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:46 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:46 msgid "truncation)." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.switch:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.switch:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.switch:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.switch:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.switch:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.switch:1 msgid "``branches[index]()``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tan:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tan:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.tan:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.tan:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan:1 msgid "Return the tan of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tan:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tan:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.tan:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.tan:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tan:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tan:5 msgid "tan of ``a``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tanh:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tanh:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.tanh:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.tanh:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh:1 msgid "Return the tanh of a tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tanh:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tanh:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.tanh:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.tanh:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tanh:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tanh:5 msgid "tanh of ``a``" msgstr "" -#: of tensorcircuit.backends.tensorflow_backend._tensordot_tf:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tensordot:1 +#: tensorcircuit.backends.tensorflow_backend._tensordot_tf:1 #: tensornetwork.backends.jax.jax_backend.JaxBackend.tensordot:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.tensordot:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.tensordot:1 msgid "Do a tensordot of tensors `a` and `b` over the given axes." msgstr "" -#: of tensorcircuit.backends.tensorflow_backend._tensordot_tf:4 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tensordot:4 +#: tensorcircuit.backends.tensorflow_backend._tensordot_tf:4 #: tensornetwork.backends.jax.jax_backend.JaxBackend.tensordot:4 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.tensordot:4 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.tensordot:4 msgid "Another tensor." msgstr "" -#: of tensorcircuit.backends.tensorflow_backend._tensordot_tf:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tensordot:5 +#: tensorcircuit.backends.tensorflow_backend._tensordot_tf:5 #: tensornetwork.backends.jax.jax_backend.JaxBackend.tensordot:5 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.tensordot:5 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.tensordot:5 msgid "Two lists of integers. These values are the contraction axes." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tile:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tile:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.tile:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:1 msgid "Constructs a tensor by tiling a given tensor." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.tile:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.tile:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.tile:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.tile:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.tile:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.tile:5 @@ -10209,6 +11072,7 @@ msgid "1d tensor with length the same as the rank of ``a``" msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense:1 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.to_dense:1 #: tensorcircuit.backends.jax_backend.JaxBackend.to_dense:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.to_dense:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense:1 @@ -10216,6 +11080,7 @@ msgid "Convert a sparse matrix to dense tensor." msgstr "" #: of tensorcircuit.backends.abstract_backend.ExtendedBackend.to_dense:5 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.to_dense:5 #: tensorcircuit.backends.jax_backend.JaxBackend.to_dense:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.to_dense:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.to_dense:5 @@ -10229,14 +11094,16 @@ msgstr "" msgid "Transform the tensor ``a`` as a dlpack capsule" msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.trace:1 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.trace:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:1 msgid "Return summed entries along diagonals." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.trace:3 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.trace:3 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:3 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:3 @@ -10247,14 +11114,16 @@ msgid "" " are used to determine the 2-D sub-array whose diagonal is summed." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.trace:19 +#: of tensornetwork.backends.abstract_backend.AbstractBackend.trace:19 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:19 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:19 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.trace:31 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:28 msgid "The batched summed diagonals." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.transpose:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.transpose:1 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.transpose:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.transpose:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.transpose:1 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.transpose:1 @@ -10264,7 +11133,8 @@ msgid "" "the axes." msgstr "" -#: of tensornetwork.backends.jax.jax_backend.JaxBackend.transpose:6 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.transpose:6 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.transpose:6 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.transpose:6 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.transpose:6 #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.transpose:6 @@ -10345,7 +11215,8 @@ msgstr "" msgid "Packed pytree" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.unique_with_counts:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.unique_with_counts:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.unique_with_counts:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts:1 @@ -10354,21 +11225,24 @@ msgid "" "tensor ``a``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.unique_with_counts:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.unique_with_counts:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.unique_with_counts:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.unique_with_counts:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.unique_with_counts:5 msgid "Unique elements, corresponding counts" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.value_and_grad:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:1 msgid "Return the function which returns the value and grad of ``f``." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:17 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.value_and_grad:17 +#: tensorcircuit.backends.jax_backend.JaxBackend.value_and_grad:17 #: tensorcircuit.backends.numpy_backend.NumpyBackend.value_and_grad:17 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.value_and_grad:17 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.value_and_grad:17 @@ -10377,7 +11251,9 @@ msgid "" "``f``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:1 +#: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:1 @@ -10394,7 +11270,9 @@ msgid "" "for argnum in argnums). The gradient for argnums=k is defined as" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:9 +#: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:9 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:9 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:9 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vectorized_value_and_grad:9 @@ -10404,6 +11282,7 @@ msgid "" msgstr "" #: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:13 #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:13 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:13 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:13 @@ -10412,6 +11291,7 @@ msgid "Therefore, if argnums=0, the gradient is reduced to" msgstr "" #: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:15 #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:15 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:15 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:15 @@ -10420,6 +11300,7 @@ msgid "g^0_i = \\frac{\\partial f(vargs[0][i])}{\\partial vargs[0][i]}" msgstr "" #: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:19 #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:19 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:19 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:19 @@ -10430,6 +11311,7 @@ msgid "" msgstr "" #: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:21 #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:21 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:21 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:21 @@ -10438,6 +11320,7 @@ msgid "And if argnums=1, the gradient is like" msgstr "" #: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:23 #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:23 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:23 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:23 @@ -10449,6 +11332,7 @@ msgid "" msgstr "" #: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:26 #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:26 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:26 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vectorized_value_and_grad:26 @@ -10460,6 +11344,8 @@ msgid "" msgstr "" #: of +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vectorized_value_and_grad:33 +#: tensorcircuit.backends.cupy_backend.CuPyBackend.vmap:6 #: tensorcircuit.backends.jax_backend.JaxBackend.vectorized_value_and_grad:33 #: tensorcircuit.backends.jax_backend.JaxBackend.vmap:6 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vectorized_value_and_grad:33 @@ -10473,7 +11359,8 @@ msgid "" "shape in the fist dimension" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.vjp:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.vjp:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:1 @@ -10483,14 +11370,16 @@ msgid "" " mode AD relevant) Strictly speaking, this function is value_and_vjp." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.vjp:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.vjp:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:5 msgid "the function to carry out vjp calculation" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:9 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.vjp:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.vjp:9 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:9 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:9 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:9 @@ -10499,14 +11388,16 @@ msgid "" "shape as return of function ``f``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vjp:12 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.vjp:12 +#: tensorcircuit.backends.jax_backend.JaxBackend.vjp:12 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vjp:12 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vjp:12 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vjp:12 msgid "(``f(*inputs)``, vjp_tensor), where vjp_tensor is the same shape as inputs" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.vmap:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.vmap:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:1 @@ -10516,21 +11407,24 @@ msgid "" "broadcast in the fist dimension." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:4 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.vmap:4 +#: tensorcircuit.backends.jax_backend.JaxBackend.vmap:4 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:4 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:4 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:4 msgid "function to be broadcasted." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.vmap:9 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.vmap:9 +#: tensorcircuit.backends.jax_backend.JaxBackend.vmap:9 #: tensorcircuit.backends.numpy_backend.NumpyBackend.vmap:9 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.vmap:9 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.vmap:9 msgid "vmap version of ``f``" msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.zeros:1 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.zeros:1 +#: tensorcircuit.backends.jax_backend.JaxBackend.zeros:1 #: tensorcircuit.backends.numpy_backend.NumpyBackend.zeros:1 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.zeros:1 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.zeros:1 @@ -10540,7 +11434,8 @@ msgid "" " object (for block-sparse backends)." msgstr "" -#: of tensorcircuit.backends.jax_backend.JaxBackend.zeros:5 +#: of tensorcircuit.backends.cupy_backend.CuPyBackend.zeros:5 +#: tensorcircuit.backends.jax_backend.JaxBackend.zeros:5 #: tensorcircuit.backends.numpy_backend.NumpyBackend.zeros:5 #: tensorcircuit.backends.pytorch_backend.PyTorchBackend.zeros:5 #: tensorcircuit.backends.tensorflow_backend.TensorFlowBackend.zeros:5 @@ -10550,311 +11445,376 @@ msgid "" "dtype of the returned matrix." msgstr "" -#: ../../source/api/backends/numpy_backend.rst:2 -msgid "tensorcircuit.backends.numpy_backend" +#: ../../source/api/backends/jax_backend.rst:2 +msgid "tensorcircuit.backends.jax_backend" msgstr "" -#: of tensorcircuit.backends.numpy_backend:1 -msgid "Backend magic inherited from tensornetwork: numpy backend" +#: of tensorcircuit.backends.jax_backend:1 +msgid "Backend magic inherited from tensornetwork: jax backend" msgstr "" -#: of tensorcircuit.backends.numpy_backend.NumpyBackend:1 +#: of tensorcircuit.backends.jax_backend.JaxBackend:1 msgid "" -"Bases: " -":py:class:`tensornetwork.backends.numpy.numpy_backend.NumPyBackend`, " -":py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +"Bases: :py:class:`~tensornetwork.backends.jax.jax_backend.JaxBackend`, " +":py:class:`~tensorcircuit.backends.abstract_backend.ExtendedBackend`" msgstr "" -#: of tensorcircuit.backends.numpy_backend.NumpyBackend:1 +#: of tensorcircuit.backends.jax_backend.JaxBackend:1 msgid "" -"see the original backend API at `numpy backend " -"`_" +"See the original backend API at `jax backend " +"`_" msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:16 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.diagonal:19 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:12 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.trace:15 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:16 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.diagonal:19 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:12 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.trace:15 msgid "" "Axis to be used as the first/second axis of the 2D sub-arrays from which " -"the diagonals should be taken. Defaults to second-last/last axis." +"the diagonals should be taken. Defaults to second last/last axis." msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:1 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:1 msgid "" -"Arnoldi method for finding the lowest eigenvector-eigenvalue pairs of a " -"linear operator `A`. If no `initial_state` is provided then `shape` and " -"`dtype` are required so that a suitable initial state can be randomly " -"generated. This is a wrapper for scipy.sparse.linalg.eigs which only " -"supports a subset of the arguments of scipy.sparse.linalg.eigs." +"Implicitly restarted Arnoldi method for finding the lowest eigenvector-" +"eigenvalue pairs of a linear operator `A`. `A` is a function implementing" +" the matrix-vector product." msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:8 -msgid "A (sparse) implementation of a linear operator" +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:6 +msgid "" +"WARNING: This routine uses jax.jit to reduce runtimes. jitting is " +"triggered at the first invocation of `eigs`, and on any subsequent calls " +"if the python `id` of `A` changes, even if the formal definition of `A` " +"stays the same. Example: the following will jit once at the beginning, " +"and then never again:" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:9 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:9 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:11 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:9 -msgid "" -"An initial vector for the algorithm. If `None`, a random initial `Tensor`" -" is created using the `numpy.random.randn` method." +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:12 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:12 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:10 +msgid "```python import jax import numpy as np def A(H,x):" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:13 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:13 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:11 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:15 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:13 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:11 -#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:11 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:16 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:31 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:16 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:31 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:14 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:29 +msgid "return jax.np.dot(H,x)" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:19 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:19 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:17 +msgid "for n in range(100):" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:18 msgid "" -"The dtype of the input `A`. If both no `initial_state` is provided, a " -"random initial state with shape `shape` and dtype `dtype` is created." +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigs(A, [H],x) #jitting is " +"triggerd only at `n=0`" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:16 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:16 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:14 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:18 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:16 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:14 -#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:14 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:23 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:23 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:21 msgid "" -"The nummber of eigenvector-eigenvalue pairs to be computed. If `numeig > " -"1`, `reorthogonalize` has to be `True`." +"The following code triggers jitting at every iteration, which results in " +"considerably reduced performance" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:18 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:18 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:20 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:18 -msgid "The desired precision of the eigenvalus. Uses" +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:26 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:26 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:24 +msgid "```python import jax import numpy as np for n in range(100):" msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:21 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:30 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:30 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:28 +msgid "def A(H,x):" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:32 msgid "" -"['LM' | 'SM' | 'LR' | 'SR' | 'LI'] Which `k` eigenvectors and eigenvalues" -" to find: 'LM' : largest magnitude 'SM' : smallest magnitude " -"'LR' : largest real part 'SR' : smallest real part 'LI' : largest" -" imaginary part" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigs(A, [H],x) #jitting is " +"triggerd at every step `n`" msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:21 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:37 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:37 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:35 msgid "" -"['LM' | 'SM' | 'LR' | 'SR' | 'LI'] Which `k` eigenvectors and eigenvalues" -" to find:" +"A (sparse) implementation of a linear operator. Call signature of `A` is " +"`res = A(vector, *args)`, where `vector` can be an arbitrary `Tensor`, " +"and `res.shape` has to be `vector.shape`." msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:23 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:42 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:42 msgid "" -"'LM' : largest magnitude 'SM' : smallest magnitude 'LR' : largest real " -"part 'SR' : smallest real part 'LI' : largest imaginary part" +"An initial vector for the algorithm. If `None`, a random initial `Tensor`" +" is created using the `backend.randn` method" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:28 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:28 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:28 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:28 -msgid "The maximum number of iterations." +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:45 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:45 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:43 +msgid "" +"The dtype of the input `A`. If no `initial_state` is provided, a random " +"initial state with shape `shape` and dtype `dtype` is created." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:30 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:30 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:30 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:30 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:48 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:48 +msgid "The number of eigenvector-eigenvalue pairs to be computed." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:49 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:49 msgid "" -"An array of `numeig` lowest eigenvalues `list`: A list of `numeig` lowest" -" eigenvectors" +"The desired precision of the eigenvalues. For the jax backend this has " +"currently no effect, and precision of eigenvalues is not guaranteed. This" +" feature may be added at a later point. To increase precision the caller " +"can either increase `maxiter` or `num_krylov_vecs`." msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:32 -msgid "`np.ndarray`" +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:53 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:53 +msgid "" +"Flag for targetting different types of eigenvalues. Currently supported " +"are `which = 'LR'` (larges real part) and `which = 'LM'` (larges " +"magnitude)." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:1 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:1 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:56 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:56 msgid "" -"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " -"symmetric (hermitian) linear operator `A`. `A` is a callable implementing" -" the matrix-vector product. If no `initial_state` is provided then " -"`shape` and `dtype` have to be passed so that a suitable initial state " -"can be randomly generated. :param A: A (sparse) implementation of a " -"linear operator :param arsg: A list of arguments to `A`. `A` will be " -"called as" +"Maximum number of restarts. For `maxiter=0` the routine becomes " +"equivalent to a simple Arnoldi method." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:8 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:8 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:8 -msgid "`res = A(initial_state, *args)`." +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:59 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:59 +msgid "" +"(eigvals, eigvecs) eigvals: A list of `numeig` eigenvalues eigvecs: A " +"list of `numeig` eigenvectors" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:19 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:19 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:19 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:62 +#: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:62 msgid "" -"['LM' | 'SM' | 'LR' | 'SR' | 'LI' | 'SI'] Which `k` eigenvectors and " -"eigenvalues to find: 'LM' : largest magnitude 'SM' : smallest " -"magnitude 'LR' : largest real part 'SR' : smallest real part " -"'LI' : largest imaginary part 'SI' : smallest imaginary part Note " -"that not all of those might be supported by specialized backends." +"eigvals: A list of `numeig` eigenvalues eigvecs: A list of `numeig` " +"eigenvectors" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:19 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:19 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:19 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:1 msgid "" -"['LM' | 'SM' | 'LR' | 'SR' | 'LI' | 'SI'] Which `k` eigenvectors and " -"eigenvalues to find:" +"Implicitly restarted Lanczos method for finding the lowest eigenvector-" +"eigenvalue pairs of a symmetric (hermitian) linear operator `A`. `A` is a" +" function implementing the matrix-vector product." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:21 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:21 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:21 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:6 msgid "" -"'LM' : largest magnitude 'SM' : smallest magnitude 'LR' : largest real " -"part 'SR' : smallest real part 'LI' : largest imaginary part 'SI' : " -"smallest imaginary part" +"WARNING: This routine uses jax.jit to reduce runtimes. jitting is " +"triggered at the first invocation of `eigsh`, and on any subsequent calls" +" if the python `id` of `A` changes, even if the formal definition of `A` " +"stays the same. Example: the following will jit once at the beginning, " +"and then never again:" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:27 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:27 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:27 -msgid "Note that not all of those might be supported by specialized backends." +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:18 +msgid "" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigsh(A, [H],x) #jitting is " +"triggerd only at `n=0`" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:32 -#: tensornetwork.backends.abstract_backend.AbstractBackend.eigsh:32 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh:32 -#: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator:12 -#: tensornetwork.matrixproductstates.base_mps.BaseMPS.get_tensor:10 -#: tensornetwork.matrixproductstates.base_mps.BaseMPS.position:10 -#: tensornetwork.matrixproductstates.finite_mps.FiniteMPS.canonicalize:9 -msgid "`Tensor`" +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:32 +msgid "" +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigsh(A, [H],x) #jitting is " +"triggerd at every step `n`" msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:1 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:1 msgid "" "Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " -"linear operator `A`. :param A: A (sparse) implementation of a linear " -"operator." +"hermitian linear operator `A`. `A` is a function implementing the matrix-" +"vector product. WARNING: This routine uses jax.jit to reduce runtimes. " +"jitting is triggered at the first invocation of `eigsh_lanczos`, and on " +"any subsequent calls if the python `id` of `A` changes, even if the " +"formal definition of `A` stays the same. Example: the following will jit " +"once at the beginning, and then never again:" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:4 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:4 -#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:4 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:16 msgid "" -"Call signature of `A` is `res = A(vector, *args)`, where `vector` can be " -"an arbitrary `Tensor`, and `res.shape` has to be `vector.shape`." +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigsh_lanczos(A, [H],x) " +"#jitting is triggerd only at `n=0`" msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:16 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:30 msgid "" -"The desired precision of the eigenvalus. Uses " -"`np.linalg.norm(eigvalsnew[0:numeig] - eigvalsold[0:numeig]) < tol` as " -"stopping criterion between two diagonalization steps of the tridiagonal " -"operator." +"H = jax.np.array(np.random.rand(10,10)) x = " +"jax.np.array(np.random.rand(10,10)) res = eigsh_lanczos(A, [H],x) " +"#jitting is triggerd at every step `n`" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:25 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:25 -#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:25 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:46 +msgid "" +"The number of eigenvector-eigenvalue pairs to be computed. If `numeig > " +"1`, `reorthogonalize` has to be `True`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:48 +msgid "" +"The desired precision of the eigenvalues. For the jax backend this has " +"currently no effect, and precision of eigenvalues is not guaranteed. This" +" feature may be added at a later point. To increase precision the caller " +"can increase `num_krylov_vecs`." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:57 msgid "" "The tridiagonal Operator is diagonalized every `ndiag` iterations to " -"check convergence." +"check convergence. This has currently no effect for the jax backend, but " +"may be added at a later point." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:30 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:30 -#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:30 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:63 msgid "" -"(eigvals, eigvecs) eigvals: A list of `numeig` lowest eigenvalues " -"eigvecs: A list of `numeig` lowest eigenvectors" +"(eigvals, eigvecs) eigvals: A jax-array containing `numeig` lowest " +"eigenvalues eigvecs: A list of `numeig` lowest eigenvectors" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:33 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:33 -#: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:33 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh_lanczos:66 msgid "" -"eigvals: A list of `numeig` lowest eigenvalues eigvecs: A list of " -"`numeig` lowest eigenvectors" +"eigvals: A jax-array containing `numeig` lowest eigenvalues eigvecs: A " +"list of `numeig` lowest eigenvectors" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 -msgid "Returns the exponentiation of tensor a raised to b." +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:1 +msgid "" +"Returns the power of tensor a to the value of b. In the case b is a " +"tensor, then the power is by element" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:4 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:4 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:4 -msgid "If b is a tensor, then the exponentiation is element-wise" +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:3 +msgid "with a as the base and b as the exponent." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:3 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:3 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:3 +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:5 +msgid "In the case b is a scalar, then the power of each value in a" +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:5 +msgid "is raised to the exponent of b." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:7 +msgid "The tensor that contains the base." +msgstr "" + +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.power:8 +msgid "The tensor that contains the exponent or a single scalar." +msgstr "" + +#: of tensorcircuit.backends.jax_backend._qr_jax:1 msgid "" -"between the two tensors, with a as the base and b as the power. Note that" -" a and b must be broadcastable to the same shape if b is a tensor." +"Computes the QR decomposition of a tensor. See " +"tensornetwork.backends.tensorflow.decompositions for details." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 -msgid "If b is a scalar, then the exponentiation is each value in a" +#: of tensorcircuit.backends.jax_backend._rq_jax:1 +msgid "" +"Computes the RQ (reversed QR) decomposition of a tensor. See " +"tensornetwork.backends.tensorflow.decompositions for details." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:7 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:7 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:7 -msgid "raised to the power of b." +#: of tensornetwork.backends.jax.jax_backend.JaxBackend.sign:4 +msgid "" +"For complex input the behaviour of this function may depend on the " +"backend. The Jax backend version returns y[i] = x[i]/sqrt(x[i]^2)." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:9 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:9 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:9 -msgid "The tensor containing the bases." +#: ../../source/api/backends/numpy_backend.rst:2 +msgid "tensorcircuit.backends.numpy_backend" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:10 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:10 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:10 -msgid "The tensor containing the powers; or a single scalar as the power." +#: of tensorcircuit.backends.numpy_backend:1 +msgid "Backend magic inherited from tensornetwork: numpy backend" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:12 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:12 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:12 +#: of tensorcircuit.backends.numpy_backend.NumpyBackend:1 msgid "" -"The tensor that is each element of a raised to the power of b. Note " -"that the shape of the returned tensor is that produced by the broadcast" -" of a and b." +"Bases: " +":py:class:`~tensornetwork.backends.numpy.numpy_backend.NumPyBackend`, " +":py:class:`~tensorcircuit.backends.abstract_backend.ExtendedBackend`" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:15 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:15 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:15 -msgid "The tensor that is each element of a raised to the" +#: of tensorcircuit.backends.numpy_backend.NumpyBackend:1 +msgid "" +"see the original backend API at `numpy backend " +"`_" msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.power:15 -#: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.power:15 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.power:15 +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:1 msgid "" -"power of b. Note that the shape of the returned tensor is that produced " -"by the broadcast of a and b." +"Arnoldi method for finding the lowest eigenvector-eigenvalue pairs of a " +"linear operator `A`. If no `initial_state` is provided then `shape` and " +"`dtype` are required so that a suitable initial state can be randomly " +"generated. This is a wrapper for scipy.sparse.linalg.eigs which only " +"supports a subset of the arguments of scipy.sparse.linalg.eigs." msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.qr:1 -msgid "Computes the QR decomposition of a tensor." +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:8 +msgid "A (sparse) implementation of a linear operator" msgstr "" -#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.rq:1 -msgid "Computes the RQ (reversed QR) decomposition of a tensor." +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:21 +msgid "" +"['LM' | 'SM' | 'LR' | 'SR' | 'LI'] Which `k` eigenvectors and eigenvalues" +" to find: 'LM' : largest magnitude 'SM' : smallest magnitude " +"'LR' : largest real part 'SR' : smallest real part 'LI' : largest" +" imaginary part" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:21 +msgid "" +"['LM' | 'SM' | 'LR' | 'SR' | 'LI'] Which `k` eigenvectors and eigenvalues" +" to find:" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:23 +msgid "" +"'LM' : largest magnitude 'SM' : smallest magnitude 'LR' : largest real " +"part 'SR' : smallest real part 'LI' : largest imaginary part" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigs:32 +msgid "`np.ndarray`" +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:1 +msgid "" +"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of a " +"linear operator `A`. :param A: A (sparse) implementation of a linear " +"operator." +msgstr "" + +#: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.eigsh_lanczos:16 +msgid "" +"The desired precision of the eigenvalus. Uses " +"`np.linalg.norm(eigvalsnew[0:numeig] - eigvalsold[0:numeig]) < tol` as " +"stopping criterion between two diagonalization steps of the tridiagonal " +"operator." msgstr "" #: of tensornetwork.backends.numpy.numpy_backend.NumPyBackend.sign:1 @@ -10880,8 +11840,8 @@ msgstr "" #: of tensorcircuit.backends.pytorch_backend.PyTorchBackend:1 msgid "" "Bases: " -":py:class:`tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend`," -" :py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +":py:class:`~tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend`," +" :py:class:`~tensorcircuit.backends.abstract_backend.ExtendedBackend`" msgstr "" #: of tensorcircuit.backends.pytorch_backend.PyTorchBackend:1 @@ -10906,16 +11866,6 @@ msgid "" "(note this differs from the NumPy defaults)." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigs:1 -msgid "" -"Arnoldi method for finding the lowest eigenvector-eigenvalue pairs of a " -"linear operator `A`. `A` is a callable implementing the matrix-vector " -"product. If no `initial_state` is provided then `shape` and `dtype` have " -"to be passed so that a suitable initial state can be randomly generated." -" :param A: A (sparse) implementation of a linear operator :param arsg: A " -"list of arguments to `A`. `A` will be called as" -msgstr "" - #: of #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.eigsh_lanczos:1 msgid "" @@ -11032,6 +11982,12 @@ msgid "" "raised if they are specified." msgstr "" +#: of tensorcircuit.backends.pytorch_backend.torch_jit_func:1 +msgid "" +"Delay the tracing of torch jit to the first run time: consistent with tf " +"and jax mechanism" +msgstr "" + #: ../../source/api/backends/tensorflow_backend.rst:2 msgid "tensorcircuit.backends.tensorflow_backend" msgstr "" @@ -11043,8 +11999,8 @@ msgstr "" #: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend:1 msgid "" "Bases: " -":py:class:`tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend`," -" :py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +":py:class:`~tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend`," +" :py:class:`~tensorcircuit.backends.abstract_backend.ExtendedBackend`" msgstr "" #: of tensorcircuit.backends.tensorflow_backend.TensorFlowBackend:1 @@ -11072,20 +12028,6 @@ msgid "" "will be raised if they are specified." msgstr "" -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:1 -msgid "" -"Lanczos method for finding the lowest eigenvector-eigenvalue pairs of " -"`A`. :param A: A (sparse) implementation of a linear operator." -msgstr "" - -#: of tensornetwork.backends.abstract_backend.AbstractBackend.eigsh_lanczos:16 -msgid "" -"The desired precision of the eigenvalus. Uses " -"`backend.norm(eigvalsnew[0:numeig] - eigvalsold[0:numeig]) < tol` as " -"stopping criterion between two diagonalization steps of the tridiagonal " -"operator." -msgstr "" - #: of #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sign:4 msgid "" @@ -11121,7 +12063,7 @@ msgstr "" #: of tensorcircuit.basecircuit.BaseCircuit:1 #: tensorcircuit.mpscircuit.MPSCircuit:1 -msgid "Bases: :py:class:`tensorcircuit.abstractcircuit.AbstractCircuit`" +msgid "Bases: :py:class:`~tensorcircuit.abstractcircuit.AbstractCircuit`" msgstr "" #: of tensorcircuit.basecircuit.BaseCircuit.amplitude:1 @@ -11152,6 +12094,7 @@ msgid "" msgstr "" #: of tensorcircuit.basecircuit.BaseCircuit.expectation_before:4 +#: tensorcircuit.interfaces.torch.torch_interface_kws:24 #: tensorcircuit.quantum.sample2count:7 tensorcircuit.utils.benchmark:7 msgid "_description_, defaults to True" msgstr "" @@ -11265,6 +12208,7 @@ msgid "" msgstr "" #: of tensorcircuit.basecircuit.BaseCircuit.sample:13 +#: tensorcircuit.cloud.abstraction.Task.results:5 #: tensorcircuit.quantum.measurement_counts:45 #: tensorcircuit.quantum.sample2all:10 msgid "alias for the argument ``format``" @@ -11599,7 +12543,8 @@ msgid ":math:`p_z`" msgstr "" #: of tensorcircuit.channels.depolarizingchannel:36 -#: tensorcircuit.channels.generaldepolarizingchannel:15 +#: tensorcircuit.channels.generaldepolarizingchannel:39 +#: tensorcircuit.channels.isotropicdepolarizingchannel:28 msgid "Sequences of Gates" msgstr "" @@ -11628,15 +12573,50 @@ msgid "The dynamic evolution according to Superoperator." msgstr "" #: of tensorcircuit.channels.generaldepolarizingchannel:1 -msgid "Return a Depolarizing Channel for 1 qubit or 2 qubits" +msgid "" +"Return a depolarizing channel. If :math:`p` is a float number, the one " +"qubit channel is" +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:4 +msgid "\\mathcal{E}(\\rho) = (1 - 3p)\\rho + p(X\\rho X + Y\\rho Y + Z\\rho Z)" +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:8 +msgid "Or alternatively" +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:10 +msgid "\\mathcal{E}(\\rho) = 4p \\frac{I}{2} + (1 - 4p) \\rho" +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:16 +msgid "" +"The definition of ``p`` in this method is different from " +":func:`isotropicdepolarizingchannel`." +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:19 +msgid "And if :math:`p` is a sequence, the one qubit channel is" +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:21 +msgid "" +"\\mathcal{E}(\\rho) = (1 - \\sum_i p_i) \\rho + p_1 X\\rho X + p_2 Y\\rho" +" Y + p_3 \\rho Z" +msgstr "" + +#: of tensorcircuit.channels.generaldepolarizingchannel:25 +msgid "The logic for two-qubit or more-qubit channel follows similarly." msgstr "" -#: of tensorcircuit.channels.generaldepolarizingchannel:11 +#: of tensorcircuit.channels.generaldepolarizingchannel:35 msgid "parameter for each Pauli channel" msgstr "" -#: of tensorcircuit.channels.generaldepolarizingchannel:13 -msgid "number of qubits, 1 and 2 are avaliable, defaults 1" +#: of tensorcircuit.channels.generaldepolarizingchannel:37 +#: tensorcircuit.channels.isotropicdepolarizingchannel:26 +msgid "number of qubits, defaults 1" msgstr "" #: of tensorcircuit.channels.is_hermitian_matrix:1 @@ -11655,6 +12635,36 @@ msgstr "" msgid "_description_, defaults to 1e-5" msgstr "" +#: of tensorcircuit.channels.isotropicdepolarizingchannel:1 +msgid "Return an isotropic depolarizing channel." +msgstr "" + +#: of tensorcircuit.channels.isotropicdepolarizingchannel:3 +msgid "\\mathcal{E}(\\rho) = (1 - p)\\rho + p/(4^n-1)\\sum_j P_j \\rho P_j" +msgstr "" + +#: of tensorcircuit.channels.isotropicdepolarizingchannel:7 +msgid "" +"where $n$ is the number of qubits and $P_j$ are $n$-qubit Pauli strings " +"except $I$. Or alternatively" +msgstr "" + +#: of tensorcircuit.channels.isotropicdepolarizingchannel:10 +msgid "" +"\\mathcal{E}(\\rho) = \\frac{4^n}{4^n-1}p \\frac{I}{2} + (1 - " +"\\frac{4^n}{4^n-1}p) \\rho" +msgstr "" + +#: of tensorcircuit.channels.isotropicdepolarizingchannel:16 +msgid "" +"The definition of ``p`` in this method is different from " +":func:`generaldepolarizingchannel`." +msgstr "" + +#: of tensorcircuit.channels.isotropicdepolarizingchannel:24 +msgid "error probability" +msgstr "" + #: of tensorcircuit.channels.kraus_identity_check:1 msgid "Check identity of Kraus operators." msgstr "" @@ -11885,7 +12895,7 @@ msgid "Quantum circuit: the state simulator" msgstr "" #: of tensorcircuit.circuit.Circuit:1 tensorcircuit.densitymatrix.DMCircuit:1 -msgid "Bases: :py:class:`tensorcircuit.basecircuit.BaseCircuit`" +msgid "Bases: :py:class:`~tensorcircuit.basecircuit.BaseCircuit`" msgstr "" #: of tensorcircuit.circuit.Circuit:1 @@ -12710,6 +13720,15 @@ msgstr "" msgid "The bool indicating whether the circuit is legal" msgstr "" +#: of +#: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:1 +#: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:1 +msgid "" +"Apply isotropicdepolarizing quantum channel on the circuit. See " +":py:meth:`tensorcircuit.channels.isotropicdepolarizingchannel`" +msgstr "" + #: of tensorcircuit.circuit.Circuit.matrix:1 msgid "" "Get the unitary matrix for the circuit irrespective with the circuit " @@ -12803,54 +13822,506 @@ msgstr "" msgid "List of ``tc.gates.Gate`` or just Tensors" msgstr "" -#: of tensorcircuit.circuit.Circuit.unitary_kraus:6 -msgid "prob list with the same size as ``kraus``, defaults to None" +#: of tensorcircuit.circuit.Circuit.unitary_kraus:6 +msgid "prob list with the same size as ``kraus``, defaults to None" +msgstr "" + +#: of tensorcircuit.circuit.Circuit.unitary_kraus:8 +msgid "random seed between 0 to 1, defaults to None" +msgstr "" + +#: of tensorcircuit.circuit.Circuit.unitary_kraus:10 +msgid "shape [] int dtype tensor indicates which kraus gate is actually applied" +msgstr "" + +#: of tensorcircuit.circuit.expectation:1 +msgid "Compute :math:`\\langle bra\\vert ops \\vert ket\\rangle`." +msgstr "" + +#: of tensorcircuit.circuit.expectation:3 +msgid "Example 1 (:math:`bra` is same as :math:`ket`)" +msgstr "" + +#: of tensorcircuit.circuit.expectation:24 +msgid "Example 2 (:math:`bra` is different from :math:`ket`)" +msgstr "" + +#: of tensorcircuit.circuit.expectation:42 +msgid ":math:`ket`. The state in tensor or ``QuVector`` format" +msgstr "" + +#: of tensorcircuit.circuit.expectation:44 +msgid ":math:`bra`, defaults to None, which is the same as ``ket``." +msgstr "" + +#: of tensorcircuit.circuit.expectation:46 +msgid "" +":math:`bra` changes to the adjoint matrix of :math:`bra`, defaults to " +"True." +msgstr "" + +#: of tensorcircuit.circuit.expectation:48 +msgid "Normalize the :math:`ket` and :math:`bra`, defaults to False." +msgstr "" + +#: of tensorcircuit.circuit.expectation:51 +msgid "The result of :math:`\\langle bra\\vert ops \\vert ket\\rangle`." +msgstr "" + +#: ../../source/api/cloud.rst:2 +msgid "tensorcircuit.cloud" +msgstr "" + +#: ../../source/api/cloud/abstraction.rst:2 +msgid "tensorcircuit.cloud.abstraction" +msgstr "" + +#: of tensorcircuit.cloud.abstraction:1 +msgid "Abstraction for Provider, Device and Task" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Device:1 +msgid "Device abstraction for cloud connection, eg. quantum chips" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Device.list_properties:1 +msgid "List all device properties in as dict" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Device.native_gates:1 +msgid "List native gates supported for the device, str conforms qiskit convention" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Device.topology:1 +msgid "Get the bidirectional topology link list of the device" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Device.topology_graph:1 +msgid "Get the qubit topology in ``nx.Graph`` or directly visualize it" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Device.topology_graph:3 +#: tensorcircuit.vis.render_pdf:23 +msgid "[description], defaults to False" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Provider:1 +msgid "Provider abstraction for cloud connection, eg. \"tencent\", \"local\"" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.TCException:1 +msgid "Bases: :py:class:`BaseException`" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.TCException.with_traceback:1 +#: tensorcircuit.cloud.abstraction.TaskException.with_traceback:1 +#: tensorcircuit.cloud.abstraction.TaskFailed.with_traceback:1 +#: tensorcircuit.cloud.abstraction.TaskUnfinished.with_traceback:1 +#: tensorcircuit.cloud.utils.HttpStatusError.with_traceback:1 +msgid "" +"Exception.with_traceback(tb) -- set self.__traceback__ to tb and return " +"self." +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task:1 +msgid "Task abstraction for quantum jobs on the cloud" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.details:1 +msgid "Get the current task details" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.details:4 +msgid "whether return until task is finished, defaults to False" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.details:6 +#: tensorcircuit.cloud.abstraction.Task.results:10 +msgid "alias for the argument ``blocked``" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.get_device:1 +msgid "Query which device the task is run on" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.resubmit:1 +msgid "resubmit the task" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.resubmit:3 +msgid "the resubmitted task" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.results:1 +msgid "get task results of the qjob" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.results:3 +msgid "unsupported now, defaults to None, which is \"count_dict_bin\"" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.results:7 +msgid "" +"whether blocked to wait until the result is returned, defaults to False, " +"which raise error when the task is unfinished" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.results:12 +msgid "whether enable readout error mitigation, defaults to False" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.results:14 +msgid "option dict for ``ReadoutMit.cals_from_system``, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.results:17 +msgid "" +"if given, directly use the calibriation info on ``readout_mit``, defaults" +" to None" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.results:20 +msgid "option dict for ``ReadoutMit.apply_correction``, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.results:22 +msgid "count dict results" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.Task.state:1 +msgid "Query the current task status" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.TaskException:1 +msgid "Bases: :py:class:`~tensorcircuit.cloud.abstraction.TCException`" +msgstr "" + +#: of tensorcircuit.cloud.abstraction.TaskFailed:1 +#: tensorcircuit.cloud.abstraction.TaskUnfinished:1 +msgid "Bases: :py:class:`~tensorcircuit.cloud.abstraction.TaskException`" +msgstr "" + +#: ../../source/api/cloud/apis.rst:2 +msgid "tensorcircuit.cloud.apis" +msgstr "" + +#: of tensorcircuit.cloud.apis:1 +msgid "main entrypoints of cloud module" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_device:1 +#: tensorcircuit.cloud.apis.set_device:1 +msgid "set the default device" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_device:3 +#: tensorcircuit.cloud.apis.set_device:3 +msgid "provider of the device, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_device:5 +#: tensorcircuit.cloud.apis.set_device:5 +msgid "the device, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_device:7 +#: tensorcircuit.cloud.apis.set_device:7 +msgid "" +"whether set, defaults to True, if False, equivalent to ``get_device``, " +"defaults to True" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_provider:1 +#: tensorcircuit.cloud.apis.set_provider:1 +msgid "set default provider for the program" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_provider:5 +#: tensorcircuit.cloud.apis.set_provider:5 +msgid "whether set, defaults to True, if False, equivalent to ``get_provider``" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_task:1 +msgid "" +"Get ``Task`` object from task string, the binding device can also be " +"provided" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_task_details:1 +msgid "Get task details dict given task id" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_task_details:7 +msgid "" +"whether make the returned dict more readable and more phythonic, defaults" +" to False" +msgstr "" + +#: of tensorcircuit.cloud.apis.get_token:1 +msgid "" +"Get API token setted for given provider or device, if no device token " +"saved, the corresponding provider tken is returned" +msgstr "" + +#: of tensorcircuit.cloud.apis.list_devices:1 +msgid "List all devices under a provider" +msgstr "" + +#: of tensorcircuit.cloud.apis.list_properties:1 +msgid "List properties of a given device" +msgstr "" + +#: of tensorcircuit.cloud.apis.list_properties:9 +msgid "Propeties dict" +msgstr "" + +#: of tensorcircuit.cloud.apis.list_providers:1 +msgid "list all cloud providers that tensorcircuit supports" +msgstr "" + +#: of tensorcircuit.cloud.apis.list_tasks:1 +msgid "List tasks based on given filters" +msgstr "" + +#: of tensorcircuit.cloud.apis.list_tasks:9 +msgid "list of task object that satisfy these filter criteria" +msgstr "" + +#: of tensorcircuit.cloud.apis.resubmit_task:1 +msgid "Rerun the given task" +msgstr "" + +#: of tensorcircuit.cloud.apis.set_token:1 +msgid "Set API token for given provider or specifically to given device" +msgstr "" + +#: of tensorcircuit.cloud.apis.set_token:3 +msgid "the API token, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.apis.set_token:9 +msgid "whether save on the disk, defaults to True" +msgstr "" + +#: of tensorcircuit.cloud.apis.set_token:11 +msgid "if True, clear all token saved, defaults to False" +msgstr "" + +#: of tensorcircuit.cloud.apis.submit_task:1 +msgid "submit task to the cloud platform, batch submission default enabled" +msgstr "" + +#: of tensorcircuit.cloud.apis.submit_task:5 +msgid ":py:meth:`tensorcircuit.cloud.tencent.submit_task`" +msgstr "" + +#: of tensorcircuit.cloud.apis.submit_task:13 +msgid "" +"all necessary keywords arguments for task submission, see detailed API in" +" each provider backend: 1. tencent - " +":py:meth:`tensorcircuit.cloud.tencent.submit_task`" +msgstr "" + +#: of tensorcircuit.cloud.apis.submit_task:17 +msgid "The task object" +msgstr "" + +#: ../../source/api/cloud/config.rst:2 +msgid "tensorcircuit.cloud.config" +msgstr "" + +#: ../../source/api/cloud/local.rst:2 +msgid "tensorcircuit.cloud.local" +msgstr "" + +#: of tensorcircuit.cloud.local:1 +msgid "Cloud provider from local machine" +msgstr "" + +#: ../../source/api/cloud/quafu_provider.rst:2 +msgid "tensorcircuit.cloud.quafu_provider" +msgstr "" + +#: ../../source/api/cloud/tencent.rst:2 +msgid "tensorcircuit.cloud.tencent" +msgstr "" + +#: of tensorcircuit.cloud.tencent:1 +msgid "Cloud provider from Tencent" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:1 +msgid "" +"Submit task via tencent provider, we suggest to enable one of the " +"compiling functionality: either in tc: frontend or in qos: backend. If " +"both are enabled, try on your own risk, some qubit mapping may fail " +"silently. If the user directly provide ``source`` or qiskit Circuit in " +"``circuit``, the qubit mapping should be taken care of by the users." +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:10 +msgid "language choice for ``source``, defaults to \"OPENQASM\"" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:12 +msgid "number of measurement shots, defaults to 1024" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:14 +msgid "submit task protocol version, defaults to \"1\"" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:16 +msgid "priority for the task queue, defaults to 1" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:18 +msgid "tensorcircuit or qiskit circuit object, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:20 +msgid "directly given circuit representation, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:22 +msgid "remarks on the task, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:24 +msgid "whether compiling in tc via qiskit compiling system, defaults to False" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:27 +msgid "alias for the argument ``compiling``" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:29 +msgid "compiling options for qiskit ``transpile`` method, defaults to None" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:32 +msgid "alias for the argument ``compiled_options``" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:34 +msgid "whether to insert swap if necessary in qos, defaults to True" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:36 +msgid "whether to compile the gate in qos, defaults to True" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:38 +msgid "whether to run an initial qubit mapping in qos, defaults to False" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:41 +msgid "" +"when dry run, only compiled circuit is returned (no real circuit " +"execution), defaults to False" +msgstr "" + +#: of tensorcircuit.cloud.tencent.submit_task:44 +msgid "Task object or List of Task for batch submission" +msgstr "" + +#: ../../source/api/cloud/utils.rst:2 +msgid "tensorcircuit.cloud.utils" +msgstr "" + +#: of tensorcircuit.cloud.utils:1 +msgid "utility functions for cloud connection" +msgstr "" + +#: of tensorcircuit.cloud.utils.HttpStatusError:1 +msgid "Bases: :py:class:`Exception`" +msgstr "" + +#: of tensorcircuit.cloud.utils.HttpStatusError:1 +msgid "Used when the return request has http code beyond 200" +msgstr "" + +#: of tensorcircuit.cloud.utils.set_proxy:1 +msgid "" +"str. format as \"http://user:passwd@host:port\" user passwd part can be " +"omitted if not set. None for turning off the proxy." +msgstr "" + +#: ../../source/api/cloud/wrapper.rst:2 +msgid "tensorcircuit.cloud.wrapper" +msgstr "" + +#: of tensorcircuit.cloud.wrapper:1 +msgid "higher level wrapper shortcut for submit_task" +msgstr "" + +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:1 +msgid "" +"Unified interface to compute the Pauli string expectation lists or sums " +"via simulation or on real qpu. Error mitigation, circuit compilation and " +"Pauli string grouping are all built-in." +msgstr "" + +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:4 +msgid "" +"One line access to unlock the whole power or real quantum hardware on " +"quantum cloud." msgstr "" -#: of tensorcircuit.circuit.Circuit.unitary_kraus:8 -msgid "random seed between 0 to 1, defaults to None" +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:18 +msgid "The target circuit to compute expectation" msgstr "" -#: of tensorcircuit.circuit.Circuit.unitary_kraus:10 -msgid "shape [] int dtype tensor indicates which kraus gate is actually applied" +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:20 +msgid "" +"List of Pauli string list, eg. [[0, 1, 0], [2, 3, 3]] represents [X1, " +"Y0Z1Z2]." msgstr "" -#: of tensorcircuit.circuit.expectation:1 -msgid "Compute :math:`\\langle bra\\vert ops \\vert ket\\rangle`." +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:22 +msgid "" +"The device str or object for quantum cloud module, defaults to None, None" +" is for analytical exact simulation" msgstr "" -#: of tensorcircuit.circuit.expectation:3 -msgid "Example 1 (:math:`bra` is same as :math:`ket`)" +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:25 +msgid "" +"List of float to indicate the final return is the weighted sum of Pauli " +"string expectations, e.g. [2., -0.3] represents the final results is 2* " +"``pss`` [0]-0.3* ``pss`` [1] defaults to None, None indicate the list of " +"expectations for ``pss`` are all returned" msgstr "" -#: of tensorcircuit.circuit.expectation:24 -msgid "Example 2 (:math:`bra` is different from :math:`ket`)" +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:29 +msgid "measurement shots for each expectation estimation, defaults to 8192" msgstr "" -#: of tensorcircuit.circuit.expectation:42 -msgid ":math:`ket`. The state in tensor or ``QuVector`` format" +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:31 +msgid "whether enable readout error mitigation for the result, defaults to True" msgstr "" -#: of tensorcircuit.circuit.expectation:44 -msgid ":math:`bra`, defaults to None, which is the same as ``ket``." +#: of tensorcircuit.cloud.wrapper.batch_expectation_ps:33 +msgid "" +"List of Pauli string expectation or a weighted sum float for Pauli " +"strings, depending on ``ws``" msgstr "" -#: of tensorcircuit.circuit.expectation:46 +#: of tensorcircuit.cloud.wrapper.sample_expectation_ps:1 msgid "" -":math:`bra` changes to the adjoint matrix of :math:`bra`, defaults to " -"True." +"Deprecated, please use " +":py:meth:`tensorcircuit.cloud.wrapper.batch_expectation_ps`." msgstr "" -#: of tensorcircuit.circuit.expectation:48 -msgid "Normalize the :math:`ket` and :math:`bra`, defaults to False." +#: ../../source/api/compiler.rst:2 +msgid "tensorcircuit.compiler" msgstr "" -#: of tensorcircuit.circuit.expectation:51 -msgid "The result of :math:`\\langle bra\\vert ops \\vert ket\\rangle`." +#: ../../source/api/compiler/composed_compiler.rst:2 +msgid "tensorcircuit.compiler.composed_compiler" msgstr "" -#: ../../source/api/compiler.rst:2 -msgid "tensorcircuit.compiler" +#: of tensorcircuit.compiler.composed_compiler:1 +msgid "object oriented compiler pipeline" msgstr "" #: ../../source/api/compiler/qiskit_compiler.rst:2 @@ -13121,7 +14592,7 @@ msgid "wavefunction vector" msgstr "" #: of tensorcircuit.densitymatrix.DMCircuit2:1 -msgid "Bases: :py:class:`tensorcircuit.densitymatrix.DMCircuit`" +msgid "Bases: :py:class:`~tensorcircuit.densitymatrix.DMCircuit`" msgstr "" #: ../../source/api/experimental.rst:2 @@ -13194,7 +14665,7 @@ msgid "" msgstr "" #: of tensorcircuit.gates.Gate:1 -msgid "Bases: :py:class:`tensornetwork.network_components.Node`" +msgid "Bases: :py:class:`~tensornetwork.network_components.Node`" msgstr "" #: of tensorcircuit.gates.Gate:1 @@ -13352,7 +14823,7 @@ msgid "Returns: A dict object." msgstr "" #: of tensorcircuit.gates.GateVF:1 -msgid "Bases: :py:class:`tensorcircuit.gates.GateF`" +msgid "Bases: :py:class:`~tensorcircuit.gates.GateF`" msgstr "" #: of tensorcircuit.gates.any_gate:1 @@ -13931,6 +15402,13 @@ msgstr "" msgid "Wrap a quantum function on different ML backend with a pytorch interface." msgstr "" +#: of tensorcircuit.interfaces.torch.torch_interface_kws:1 +msgid "" +"similar to py:meth:`tensorcircuit.interfaces.torch.torch_interface`, but " +"now the interface support static arguments for function ``f``, which is " +"not a tensor and can be used with keyword arguments" +msgstr "" + #: ../../source/api/keras.rst:2 msgid "tensorcircuit.keras" msgstr "" @@ -13939,6 +15417,16 @@ msgstr "" msgid "Keras layer for tc quantum function" msgstr "" +#: of tensorcircuit.keras.HardwareLayer:1 +msgid "Bases: :py:class:`~tensorcircuit.keras.QuantumLayer`" +msgstr "" + +#: of tensorcircuit.keras.HardwareLayer:1 +msgid "" +"Keras Layer wrapping quantum function with cloud qpu access (using " +":py:mod:`tensorcircuit.cloud` module)" +msgstr "" + #: of tensorcircuit.keras.QuantumLayer.__init__:1 msgid "" "`QuantumLayer` wraps the quantum function `f` as a `keras.Layer` so that " @@ -13958,6 +15446,10 @@ msgstr "" msgid "The initializer of the weights, defaults to \"glorot_uniform\"" msgstr "" +#: of tensorcircuit.keras.QuantumLayer.__init__:13 +msgid "The regularizer of the weights, defaults to None" +msgstr "" + #: of tensorcircuit.keras.load_func:1 msgid "" "Load function from the files in the ``tf.savedmodel`` format. We can load" @@ -14020,7 +15512,7 @@ msgid "FiniteMPS from tensornetwork with bug fixed" msgstr "" #: of tensorcircuit.mps_base.FiniteMPS:1 -msgid "Bases: :py:class:`tensornetwork.matrixproductstates.finite_mps.FiniteMPS`" +msgid "Bases: :py:class:`~tensornetwork.matrixproductstates.finite_mps.FiniteMPS`" msgstr "" #: of tensornetwork.matrixproductstates.finite_mps.FiniteMPS.__init__:4 @@ -14732,6 +16224,34 @@ msgid "" "channel on all qubits" msgstr "" +#: of tensorcircuit.noisemodel.NoiseConf.add_noise_by_condition:1 +msgid "Add noise based on specified condition" +msgstr "" + +#: of tensorcircuit.noisemodel.NoiseConf.add_noise_by_condition:3 +msgid "a function to decide if the noise should be added to the qir." +msgstr "" + +#: of tensorcircuit.noisemodel.NoiseConf.add_noise_by_condition:5 +msgid "the error channel" +msgstr "" + +#: of tensorcircuit.noisemodel.NoiseConf.add_noise_by_condition:7 +msgid "the name of the condition. A metadata that does not affect the numerics." +msgstr "" + +#: of tensorcircuit.noisemodel.NoiseConf.channel_count:1 +msgid "Count the total number of channels in a given circuit" +msgstr "" + +#: of tensorcircuit.noisemodel.NoiseConf.channel_count:3 +msgid "the circuit to be counted" +msgstr "" + +#: of tensorcircuit.noisemodel.NoiseConf.channel_count:5 +msgid "the count" +msgstr "" + #: of tensorcircuit.noisemodel.apply_qir_with_noise:1 msgid "A newly defined circuit" msgstr "" @@ -14883,7 +16403,7 @@ msgstr "" #: of tensorcircuit.quantum.QuAdjointVector:1 tensorcircuit.quantum.QuScalar:1 #: tensorcircuit.quantum.QuVector:1 -msgid "Bases: :py:class:`tensorcircuit.quantum.QuOperator`" +msgid "Bases: :py:class:`~tensorcircuit.quantum.QuOperator`" msgstr "" #: of tensorcircuit.quantum.QuAdjointVector:1 @@ -15626,6 +17146,14 @@ msgstr "" msgid "The mutual information between AB subsystem described by ``cut``." msgstr "" +#: of tensorcircuit.quantum.ps2xyz:1 +msgid "pauli string list to xyz dict" +msgstr "" + +#: of tensorcircuit.quantum.ps2xyz:3 +msgid "# ps2xyz([1, 2, 2, 0]) = {\"x\": [0], \"y\": [1, 2], \"z\": []}" +msgstr "" + #: of tensorcircuit.quantum.quantum_constructor:1 msgid "" "Constructs an appropriately specialized QuOperator. If there are no " @@ -15844,6 +17372,10 @@ msgstr "" msgid "The :math:`k` th order of the truncated free energy." msgstr "" +#: of tensorcircuit.quantum.xyz2ps:1 +msgid "xyz dict to pauli string list" +msgstr "" + #: ../../source/api/results.rst:2 msgid "tensorcircuit.results" msgstr "" @@ -15884,6 +17416,12 @@ msgstr "" msgid "the expectation value" msgstr "" +#: of tensorcircuit.results.counts.plot_histogram:1 +msgid "" +"See ``qiskit.visualization.plot_histogram``: " +"https://qiskit.org/documentation/stubs/qiskit.visualization.plot_histogram.html" +msgstr "" + #: ../../source/api/results/readout_mitigation.rst:2 msgid "tensorcircuit.results.readout_mitigation" msgstr "" @@ -16278,6 +17816,36 @@ msgstr "" msgid "Quantum machine learning related data preprocessing and embedding" msgstr "" +#: ../../source/api/templates/ensemble.rst:2 +msgid "tensorcircuit.templates.ensemble" +msgstr "" + +#: of tensorcircuit.templates.ensemble:1 +msgid "Useful utilities for ensemble" +msgstr "" + +#: of tensorcircuit.templates.ensemble.bagging.append:1 +msgid "Add model to the voting method" +msgstr "" + +#: of tensorcircuit.templates.ensemble.bagging.eval:1 +msgid "" +"Expect input data to be a 2D array which a 1D array of yTrue followed by " +"a 1D array of yPred is expected to be the components of the 2D array" +msgstr "" + +#: of tensorcircuit.templates.ensemble.bagging.predict:1 +msgid "" +"Input data is expected to be a 2D array that the first layer is different" +" input data (into the trained models)" +msgstr "" + +#: of tensorcircuit.templates.ensemble.bagging.train:1 +msgid "" +"Train all models in the class, **kwargs expect to receive the argus that " +"can be directly sent to tf.fit Expected to be run after finishing compile" +msgstr "" + #: ../../source/api/templates/graphs.rst:2 msgid "tensorcircuit.templates.graphs" msgstr "" @@ -16510,47 +18078,62 @@ msgstr "" msgid "PyTorch nn Module wrapper for quantum function" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet:1 -msgid "Bases: :py:class:`torch.nn.modules.module.Module`" +#: of tensorcircuit.torchnn.HardwareNet:1 +msgid "Bases: :py:class:`~tensorcircuit.torchnn.QuantumNet`" +msgstr "" + +#: of tensorcircuit.torchnn.HardwareNet:1 +msgid "" +"PyTorch Layer wrapping quantum function with cloud qpu access (using " +":py:mod:`tensorcircuit.cloud` module)" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:1 +#: of tensorcircuit.torchnn.HardwareNet.__init__:1 +#: tensorcircuit.torchnn.QuantumNet.__init__:1 msgid "PyTorch nn Module wrapper on quantum function ``f``." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:32 +#: of tensorcircuit.torchnn.HardwareNet.__init__:32 +#: tensorcircuit.torchnn.QuantumNet.__init__:32 msgid "Quantum function with tensor in (input and weights) and tensor out." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:34 +#: of tensorcircuit.torchnn.HardwareNet.__init__:34 +#: tensorcircuit.torchnn.QuantumNet.__init__:34 msgid "" "list of shape tuple for different weights as the non-first parameters for" " ``f``" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:36 +#: of tensorcircuit.torchnn.HardwareNet.__init__:36 +#: tensorcircuit.torchnn.QuantumNet.__init__:36 msgid "function that gives the shape tuple returns torch tensor, defaults to None" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:38 +#: of tensorcircuit.torchnn.HardwareNet.__init__:38 +#: tensorcircuit.torchnn.QuantumNet.__init__:38 msgid "whether apply vmap (batch input) on ``f``, defaults to True" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:40 +#: of tensorcircuit.torchnn.HardwareNet.__init__:40 +#: tensorcircuit.torchnn.QuantumNet.__init__:40 msgid "" "which position of input should be batched, need to be customized when " "multiple inputs for the torch model, defaults to be 0." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:43 +#: of tensorcircuit.torchnn.HardwareNet.__init__:43 +#: tensorcircuit.torchnn.QuantumNet.__init__:43 msgid "whether transform ``f`` with torch interface, defaults to True" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:45 +#: of tensorcircuit.torchnn.HardwareNet.__init__:45 +#: tensorcircuit.torchnn.QuantumNet.__init__:45 msgid "whether jit ``f``, defaults to True" msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.__init__:47 +#: of tensorcircuit.torchnn.HardwareNet.__init__:47 +#: tensorcircuit.torchnn.QuantumNet.__init__:47 msgid "whether enbale dlpack in interfaces, defaults to False" msgstr "" @@ -16589,6 +18172,7 @@ msgstr "" #: torch.nn.modules.module.Module.double:6 #: torch.nn.modules.module.Module.eval:13 #: torch.nn.modules.module.Module.float:6 torch.nn.modules.module.Module.half:6 +#: torch.nn.modules.module.Module.ipu:14 #: torch.nn.modules.module.Module.requires_grad_:17 #: torch.nn.modules.module.Module.to:45 #: torch.nn.modules.module.Module.to_empty:7 @@ -16600,13 +18184,13 @@ msgstr "" #: of torch.nn.modules.module.Module.apply:11 #: torch.nn.modules.module.Module.buffers:10 #: torch.nn.modules.module.Module.modules:10 -#: torch.nn.modules.module.Module.named_buffers:13 +#: torch.nn.modules.module.Module.named_buffers:15 #: torch.nn.modules.module.Module.named_children:6 #: torch.nn.modules.module.Module.named_modules:16 -#: torch.nn.modules.module.Module.named_parameters:13 +#: torch.nn.modules.module.Module.named_parameters:16 #: torch.nn.modules.module.Module.parameters:12 #: torch.nn.modules.module.Module.register_buffer:25 -#: torch.nn.modules.module.Module.state_dict:10 +#: torch.nn.modules.module.Module.state_dict:38 msgid "Example::" msgstr "" @@ -16618,8 +18202,8 @@ msgstr "" #: torch.nn.modules.module.Module.cpu:4 torch.nn.modules.module.Module.cuda:8 #: torch.nn.modules.module.Module.double:4 #: torch.nn.modules.module.Module.float:4 torch.nn.modules.module.Module.half:4 -#: torch.nn.modules.module.Module.to:29 torch.nn.modules.module.Module.type:4 -#: torch.nn.modules.module.Module.xpu:8 +#: torch.nn.modules.module.Module.ipu:8 torch.nn.modules.module.Module.to:29 +#: torch.nn.modules.module.Module.type:4 torch.nn.modules.module.Module.xpu:8 msgid "This method modifies the module in-place." msgstr "" @@ -16628,7 +18212,6 @@ msgid "Returns an iterator over module buffers." msgstr "" #: of torch.nn.modules.module.Module.buffers:3 -#: torch.nn.modules.module.Module.named_buffers:6 msgid "" "if True, then yields buffers of this module and all submodules. " "Otherwise, yields only buffers that are direct members of this module." @@ -16673,7 +18256,7 @@ msgid "" msgstr "" #: of torch.nn.modules.module.Module.cuda:10 -#: torch.nn.modules.module.Module.xpu:10 +#: torch.nn.modules.module.Module.ipu:10 torch.nn.modules.module.Module.xpu:10 msgid "if specified, all parameters will be copied to that device" msgstr "" @@ -16681,23 +18264,6 @@ msgstr "" msgid "Casts all floating point parameters and buffers to ``double`` datatype." msgstr "" -#: ../../docstring of tensorcircuit.torchnn.QuantumNet.dump_patches:1 -msgid "" -"This allows better BC support for :meth:`load_state_dict`. In " -":meth:`state_dict`, the version number will be saved as in the attribute " -"`_metadata` of the returned state dict, and thus pickled. `_metadata` is " -"a dictionary with keys that follow the naming convention of state dict. " -"See ``_load_from_state_dict`` on how to use this information in loading." -msgstr "" - -#: ../../docstring of tensorcircuit.torchnn.QuantumNet.dump_patches:7 -msgid "" -"If new parameters/buffers are added/removed from a module, this number " -"shall be bumped, and the module's `_load_from_state_dict` method can " -"compare the version number and do appropriate changes if the state dict " -"is from before the change." -msgstr "" - #: of torch.nn.modules.module.Module.eval:1 msgid "Sets the module in evaluation mode." msgstr "" @@ -16736,15 +18302,18 @@ msgstr "" msgid "Casts all floating point parameters and buffers to ``float`` datatype." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.forward:1 +#: of tensorcircuit.torchnn.HardwareNet.forward:1 +#: tensorcircuit.torchnn.QuantumNet.forward:1 msgid "Defines the computation performed at every call." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.forward:3 +#: of tensorcircuit.torchnn.HardwareNet.forward:3 +#: tensorcircuit.torchnn.QuantumNet.forward:3 msgid "Should be overridden by all subclasses." msgstr "" -#: of tensorcircuit.torchnn.QuantumNet.forward:6 +#: of tensorcircuit.torchnn.HardwareNet.forward:6 +#: tensorcircuit.torchnn.QuantumNet.forward:6 msgid "" "Although the recipe for forward pass needs to be defined within this " "function, one should call the :class:`Module` instance afterwards instead" @@ -16792,10 +18361,10 @@ msgstr "" #: of torch.nn.modules.module.Module.get_extra_state:6 msgid "" -"Note that extra state should be pickleable to ensure working " -"serialization of the state_dict. We only provide provide backwards " -"compatibility guarantees for serializing Tensors; other objects may break" -" backwards compatibility if their serialized pickled form changes." +"Note that extra state should be picklable to ensure working serialization" +" of the state_dict. We only provide provide backwards compatibility " +"guarantees for serializing Tensors; other objects may break backwards " +"compatibility if their serialized pickled form changes." msgstr "" #: of torch.nn.modules.module.Module.get_extra_state:11 @@ -16880,6 +18449,17 @@ msgstr "" msgid "Casts all floating point parameters and buffers to ``half`` datatype." msgstr "" +#: of torch.nn.modules.module.Module.ipu:1 +msgid "Moves all model parameters and buffers to the IPU." +msgstr "" + +#: of torch.nn.modules.module.Module.ipu:3 +msgid "" +"This also makes associated parameters and buffers different objects. So " +"it should be called before constructing optimizer if the module will live" +" on IPU while being optimized." +msgstr "" + #: of torch.nn.modules.module.Module.load_state_dict:1 msgid "" "Copies parameters and buffers from :attr:`state_dict` into this module " @@ -16949,8 +18529,19 @@ msgstr "" msgid "prefix to prepend to all buffer names." msgstr "" -#: of torch.nn.modules.module.Module.named_buffers:11 -msgid "*(string, torch.Tensor)* -- Tuple containing the name and buffer" +#: of torch.nn.modules.module.Module.named_buffers:6 +msgid "" +"if True, then yields buffers of this module and all submodules. " +"Otherwise, yields only buffers that are direct members of this module. " +"Defaults to True." +msgstr "" + +#: of torch.nn.modules.module.Module.named_buffers:10 +msgid "whether to remove the duplicated buffers in the result. Defaults to True." +msgstr "" + +#: of torch.nn.modules.module.Module.named_buffers:13 +msgid "*(str, torch.Tensor)* -- Tuple containing the name and buffer" msgstr "" #: of torch.nn.modules.module.Module.named_children:1 @@ -16960,7 +18551,7 @@ msgid "" msgstr "" #: of torch.nn.modules.module.Module.named_children:4 -msgid "*(string, Module)* -- Tuple containing a name and child module" +msgid "*(str, Module)* -- Tuple containing a name and child module" msgstr "" #: of torch.nn.modules.module.Module.named_modules:1 @@ -16982,7 +18573,7 @@ msgid "whether to remove the duplicated module instances in the result or not" msgstr "" #: of torch.nn.modules.module.Module.named_modules:9 -msgid "*(string, Module)* -- Tuple of name and module" +msgid "*(str, Module)* -- Tuple of name and module" msgstr "" #: of torch.nn.modules.module.Module.named_parameters:1 @@ -17002,8 +18593,14 @@ msgid "" "Otherwise, yields only parameters that are direct members of this module." msgstr "" -#: of torch.nn.modules.module.Module.named_parameters:11 -msgid "*(string, Parameter)* -- Tuple containing the name and parameter" +#: of torch.nn.modules.module.Module.named_parameters:10 +msgid "" +"whether to remove the duplicated parameters in the result. Defaults to " +"True." +msgstr "" + +#: of torch.nn.modules.module.Module.named_parameters:14 +msgid "*(str, Parameter)* -- Tuple containing the name and parameter" msgstr "" #: of torch.nn.modules.module.Module.parameters:1 @@ -17031,18 +18628,22 @@ msgid "" msgstr "" #: of torch.nn.modules.module.Module.register_backward_hook:6 -#: torch.nn.modules.module.Module.register_forward_hook:14 -#: torch.nn.modules.module.Module.register_forward_pre_hook:14 -#: torch.nn.modules.module.Module.register_full_backward_hook:25 +#: torch.nn.modules.module.Module.register_forward_hook:37 +#: torch.nn.modules.module.Module.register_forward_pre_hook:40 +#: torch.nn.modules.module.Module.register_full_backward_hook:39 +#: torch.nn.modules.module.Module.register_full_backward_pre_hook:34 +#: torch.nn.modules.module.Module.register_load_state_dict_post_hook:21 msgid "" "a handle that can be used to remove the added hook by calling " "``handle.remove()``" msgstr "" #: of torch.nn.modules.module.Module.register_backward_hook:8 -#: torch.nn.modules.module.Module.register_forward_hook:16 -#: torch.nn.modules.module.Module.register_forward_pre_hook:16 -#: torch.nn.modules.module.Module.register_full_backward_hook:27 +#: torch.nn.modules.module.Module.register_forward_hook:39 +#: torch.nn.modules.module.Module.register_forward_pre_hook:42 +#: torch.nn.modules.module.Module.register_full_backward_hook:41 +#: torch.nn.modules.module.Module.register_full_backward_pre_hook:36 +#: torch.nn.modules.module.Module.register_load_state_dict_post_hook:23 msgid ":class:`torch.utils.hooks.RemovableHandle`" msgstr "" @@ -17090,16 +18691,45 @@ msgstr "" #: of torch.nn.modules.module.Module.register_forward_hook:3 msgid "" "The hook will be called every time after :func:`forward` has computed an " -"output. It should have the following signature::" +"output." +msgstr "" + +#: of torch.nn.modules.module.Module.register_forward_hook:5 +msgid "" +"If ``with_kwargs`` is ``False`` or not specified, the input contains only" +" the positional arguments given to the module. Keyword arguments won't be" +" passed to the hooks and only to the ``forward``. The hook can modify the" +" output. It can modify the input inplace but it will not have effect on " +"forward since this is called after :func:`forward` is called. The hook " +"should have the following signature::" +msgstr "" + +#: of torch.nn.modules.module.Module.register_forward_hook:14 +msgid "" +"If ``with_kwargs`` is ``True``, the forward hook will be passed the " +"``kwargs`` given to the forward function and be expected to return the " +"output possibly modified. The hook should have the following signature::" +msgstr "" + +#: of torch.nn.modules.module.Module.register_forward_hook:20 +#: torch.nn.modules.module.Module.register_forward_pre_hook:23 +msgid "The user defined hook to be registered." +msgstr "" + +#: of torch.nn.modules.module.Module.register_forward_hook:22 +msgid "" +"If ``True``, the provided ``hook`` will be fired before all existing " +"``forward`` hooks on this :class:`torch.nn.modules.Module`. Otherwise, " +"the provided ``hook`` will be fired after all existing ``forward`` hooks " +"on this :class:`torch.nn.modules.Module`. Note that global ``forward`` " +"hooks registered with :func:`register_module_forward_hook` will fire " +"before all hooks registered by this method. Default: ``False``" msgstr "" -#: of torch.nn.modules.module.Module.register_forward_hook:8 +#: of torch.nn.modules.module.Module.register_forward_hook:32 msgid "" -"The input contains only the positional arguments given to the module. " -"Keyword arguments won't be passed to the hooks and only to the " -"``forward``. The hook can modify the output. It can modify the input " -"inplace but it will not have effect on forward since this is called after" -" :func:`forward` is called." +"If ``True``, the ``hook`` will be passed the kwargs given to the forward " +"function. Default: ``False``" msgstr "" #: of torch.nn.modules.module.Module.register_forward_pre_hook:1 @@ -17107,28 +18737,54 @@ msgid "Registers a forward pre-hook on the module." msgstr "" #: of torch.nn.modules.module.Module.register_forward_pre_hook:3 +msgid "The hook will be called every time before :func:`forward` is invoked." +msgstr "" + +#: of torch.nn.modules.module.Module.register_forward_pre_hook:6 msgid "" -"The hook will be called every time before :func:`forward` is invoked. It " -"should have the following signature::" +"If ``with_kwargs`` is false or not specified, the input contains only the" +" positional arguments given to the module. Keyword arguments won't be " +"passed to the hooks and only to the ``forward``. The hook can modify the " +"input. User can either return a tuple or a single modified value in the " +"hook. We will wrap the value into a tuple if a single value is returned " +"(unless that value is already a tuple). The hook should have the " +"following signature::" +msgstr "" + +#: of torch.nn.modules.module.Module.register_forward_pre_hook:16 +msgid "" +"If ``with_kwargs`` is true, the forward pre-hook will be passed the " +"kwargs given to the forward function. And if the hook modifies the input," +" both the args and kwargs should be returned. The hook should have the " +"following signature::" +msgstr "" + +#: of torch.nn.modules.module.Module.register_forward_pre_hook:25 +msgid "" +"If true, the provided ``hook`` will be fired before all existing " +"``forward_pre`` hooks on this :class:`torch.nn.modules.Module`. " +"Otherwise, the provided ``hook`` will be fired after all existing " +"``forward_pre`` hooks on this :class:`torch.nn.modules.Module`. Note that" +" global ``forward_pre`` hooks registered with " +":func:`register_module_forward_pre_hook` will fire before all hooks " +"registered by this method. Default: ``False``" msgstr "" -#: of torch.nn.modules.module.Module.register_forward_pre_hook:8 +#: of torch.nn.modules.module.Module.register_forward_pre_hook:35 msgid "" -"The input contains only the positional arguments given to the module. " -"Keyword arguments won't be passed to the hooks and only to the " -"``forward``. The hook can modify the input. User can either return a " -"tuple or a single modified value in the hook. We will wrap the value into" -" a tuple if a single value is returned(unless that value is already a " -"tuple)." +"If true, the ``hook`` will be passed the kwargs given to the forward " +"function. Default: ``False``" msgstr "" #: of torch.nn.modules.module.Module.register_full_backward_hook:3 msgid "" -"The hook will be called every time the gradients with respect to module " -"inputs are computed. The hook should have the following signature::" +"The hook will be called every time the gradients with respect to a module" +" are computed, i.e. the hook will execute if and only if the gradients " +"with respect to module outputs are computed. The hook should have the " +"following signature::" msgstr "" -#: of torch.nn.modules.module.Module.register_full_backward_hook:8 +#: of torch.nn.modules.module.Module.register_full_backward_hook:10 msgid "" "The :attr:`grad_input` and :attr:`grad_output` are tuples that contain " "the gradients with respect to the inputs and outputs respectively. The " @@ -17140,7 +18796,8 @@ msgid "" ":attr:`grad_output` will be ``None`` for all non-Tensor arguments." msgstr "" -#: of torch.nn.modules.module.Module.register_full_backward_hook:17 +#: of torch.nn.modules.module.Module.register_full_backward_hook:19 +#: torch.nn.modules.module.Module.register_full_backward_pre_hook:14 msgid "" "For technical reasons, when this hook is applied to a Module, its forward" " function will receive a view of each Tensor passed to the Module. " @@ -17148,12 +18805,100 @@ msgid "" "Module's forward function." msgstr "" -#: of torch.nn.modules.module.Module.register_full_backward_hook:22 +#: of torch.nn.modules.module.Module.register_full_backward_hook:24 msgid "" "Modifying inputs or outputs inplace is not allowed when using backward " "hooks and will raise an error." msgstr "" +#: of torch.nn.modules.module.Module.register_full_backward_hook:27 +#: torch.nn.modules.module.Module.register_full_backward_pre_hook:22 +msgid "The user-defined hook to be registered." +msgstr "" + +#: of torch.nn.modules.module.Module.register_full_backward_hook:29 +msgid "" +"If true, the provided ``hook`` will be fired before all existing " +"``backward`` hooks on this :class:`torch.nn.modules.Module`. Otherwise, " +"the provided ``hook`` will be fired after all existing ``backward`` hooks" +" on this :class:`torch.nn.modules.Module`. Note that global ``backward`` " +"hooks registered with :func:`register_module_full_backward_hook` will " +"fire before all hooks registered by this method." +msgstr "" + +#: of torch.nn.modules.module.Module.register_full_backward_pre_hook:1 +msgid "Registers a backward pre-hook on the module." +msgstr "" + +#: of torch.nn.modules.module.Module.register_full_backward_pre_hook:3 +msgid "" +"The hook will be called every time the gradients for the module are " +"computed. The hook should have the following signature::" +msgstr "" + +#: of torch.nn.modules.module.Module.register_full_backward_pre_hook:8 +msgid "" +"The :attr:`grad_output` is a tuple. The hook should not modify its " +"arguments, but it can optionally return a new gradient with respect to " +"the output that will be used in place of :attr:`grad_output` in " +"subsequent computations. Entries in :attr:`grad_output` will be ``None`` " +"for all non-Tensor arguments." +msgstr "" + +#: of torch.nn.modules.module.Module.register_full_backward_pre_hook:19 +msgid "" +"Modifying inputs inplace is not allowed when using backward hooks and " +"will raise an error." +msgstr "" + +#: of torch.nn.modules.module.Module.register_full_backward_pre_hook:24 +msgid "" +"If true, the provided ``hook`` will be fired before all existing " +"``backward_pre`` hooks on this :class:`torch.nn.modules.Module`. " +"Otherwise, the provided ``hook`` will be fired after all existing " +"``backward_pre`` hooks on this :class:`torch.nn.modules.Module`. Note " +"that global ``backward_pre`` hooks registered with " +":func:`register_module_full_backward_pre_hook` will fire before all hooks" +" registered by this method." +msgstr "" + +#: of torch.nn.modules.module.Module.register_load_state_dict_post_hook:1 +msgid "" +"Registers a post hook to be run after module's ``load_state_dict`` is " +"called." +msgstr "" + +#: of torch.nn.modules.module.Module.register_load_state_dict_post_hook:5 +msgid "It should have the following signature::" +msgstr "" + +#: of torch.nn.modules.module.Module.register_load_state_dict_post_hook:5 +msgid "hook(module, incompatible_keys) -> None" +msgstr "" + +#: of torch.nn.modules.module.Module.register_load_state_dict_post_hook:7 +msgid "" +"The ``module`` argument is the current module that this hook is " +"registered on, and the ``incompatible_keys`` argument is a ``NamedTuple``" +" consisting of attributes ``missing_keys`` and ``unexpected_keys``. " +"``missing_keys`` is a ``list`` of ``str`` containing the missing keys and" +" ``unexpected_keys`` is a ``list`` of ``str`` containing the unexpected " +"keys." +msgstr "" + +#: of torch.nn.modules.module.Module.register_load_state_dict_post_hook:13 +msgid "The given incompatible_keys can be modified inplace if needed." +msgstr "" + +#: of torch.nn.modules.module.Module.register_load_state_dict_post_hook:15 +msgid "" +"Note that the checks performed when calling :func:`load_state_dict` with " +"``strict=True`` are affected by modifications the hook makes to " +"``missing_keys`` or ``unexpected_keys``, as expected. Additions to either" +" set of keys will result in an error being thrown when ``strict=True``, " +"and clearing out both missing and unexpected keys will avoid an error." +msgstr "" + #: of torch.nn.modules.module.Module.register_module:1 msgid "Alias for :func:`add_module`." msgstr "" @@ -17179,6 +18924,14 @@ msgid "" "parameter is **not** included in the module's :attr:`state_dict`." msgstr "" +#: of torch.nn.modules.module.Module.register_state_dict_pre_hook:1 +msgid "" +"These hooks will be called with arguments: ``self``, ``prefix``, and " +"``keep_vars`` before calling ``state_dict`` on ``self``. The registered " +"hooks can be used to perform pre-processing before the ``state_dict`` " +"call is made." +msgstr "" + #: of torch.nn.modules.module.Module.requires_grad_:1 msgid "Change if autograd should record operations on parameters in this module." msgstr "" @@ -17225,7 +18978,9 @@ msgid "See :meth:`torch.Tensor.share_memory_`" msgstr "" #: of torch.nn.modules.module.Module.state_dict:1 -msgid "Returns a dictionary containing a whole state of the module." +msgid "" +"Returns a dictionary containing references to the whole state of the " +"module." msgstr "" #: of torch.nn.modules.module.Module.state_dict:3 @@ -17235,7 +18990,47 @@ msgid "" "and buffers set to ``None`` are not included." msgstr "" -#: of torch.nn.modules.module.Module.state_dict:7 +#: of torch.nn.modules.module.Module.state_dict:8 +msgid "" +"The returned object is a shallow copy. It contains references to the " +"module's parameters and buffers." +msgstr "" + +#: of torch.nn.modules.module.Module.state_dict:12 +msgid "" +"Currently ``state_dict()`` also accepts positional arguments for " +"``destination``, ``prefix`` and ``keep_vars`` in order. However, this is " +"being deprecated and keyword arguments will be enforced in future " +"releases." +msgstr "" + +#: of torch.nn.modules.module.Module.state_dict:18 +msgid "" +"Please avoid the use of argument ``destination`` as it is not designed " +"for end-users." +msgstr "" + +#: of torch.nn.modules.module.Module.state_dict:21 +msgid "" +"If provided, the state of module will be updated into the dict and the " +"same object is returned. Otherwise, an ``OrderedDict`` will be created " +"and returned. Default: ``None``." +msgstr "" + +#: of torch.nn.modules.module.Module.state_dict:26 +msgid "" +"a prefix added to parameter and buffer names to compose the keys in " +"state_dict. Default: ``''``." +msgstr "" + +#: of torch.nn.modules.module.Module.state_dict:29 +msgid "" +"by default the :class:`~torch.Tensor` s returned in the state dict are " +"detached from autograd. If it's set to ``True``, detaching will not be " +"performed. Default: ``False``." +msgstr "" + +#: of torch.nn.modules.module.Module.state_dict:35 msgid "a dictionary containing a whole state of the module" msgstr "" @@ -17340,6 +19135,10 @@ msgid "" ":meth:`torch.optim.Optimizer.zero_grad` for details." msgstr "" +#: of tensorcircuit.torchnn.QuantumNet:1 +msgid "Bases: :py:class:`~torch.nn.modules.module.Module`" +msgstr "" + #: ../../source/api/translation.rst:2 msgid "tensorcircuit.translation" msgstr "" @@ -17413,6 +19212,10 @@ msgid "" msgstr "" #: of tensorcircuit.translation.qir2qiskit:21 +msgid "Circuit initial state in qiskit format" +msgstr "" + +#: of tensorcircuit.translation.qir2qiskit:23 msgid "qiskit QuantumCircuit object" msgstr "" @@ -17625,10 +19428,6 @@ msgstr "" msgid "File path, defaults to current working place `os.getcwd()`" msgstr "" -#: of tensorcircuit.vis.render_pdf:23 -msgid "[description], defaults to False" -msgstr "" - #: of tensorcircuit.vis.render_pdf:25 msgid "if notebook is True, return `Image` object; otherwise return `None`" msgstr "" @@ -22103,3 +23902,142 @@ msgstr "" #~ msgid "tensorcircuit.cloud.config" #~ msgstr "" +#~ msgid "gate name list to be counted, defaults to None (counting all gates)" +#~ msgstr "" + +#~ msgid "" +#~ "Bases: " +#~ ":py:class:`tensornetwork.backends.jax.jax_backend.JaxBackend`, " +#~ ":py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +#~ msgstr "" + +#~ msgid "" +#~ "Bases: " +#~ ":py:class:`tensornetwork.backends.numpy.numpy_backend.NumPyBackend`," +#~ " " +#~ ":py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +#~ msgstr "" + +#~ msgid "" +#~ "Bases: " +#~ ":py:class:`tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend`," +#~ " " +#~ ":py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +#~ msgstr "" + +#~ msgid "" +#~ "Bases: " +#~ ":py:class:`tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend`," +#~ " " +#~ ":py:class:`tensorcircuit.backends.abstract_backend.ExtendedBackend`" +#~ msgstr "" + +#~ msgid "Bases: :py:class:`tensorcircuit.abstractcircuit.AbstractCircuit`" +#~ msgstr "" + +#~ msgid "Return a Depolarizing Channel for 1 qubit or 2 qubits" +#~ msgstr "" + +#~ msgid "number of qubits, 1 and 2 are avaliable, defaults 1" +#~ msgstr "" + +#~ msgid "Bases: :py:class:`tensorcircuit.basecircuit.BaseCircuit`" +#~ msgstr "" + +#~ msgid "Bases: :py:class:`torch.nn.modules.module.Module`" +#~ msgstr "" + +#~ msgid "" +#~ "This allows better BC support for " +#~ ":meth:`load_state_dict`. In :meth:`state_dict`, the" +#~ " version number will be saved as " +#~ "in the attribute `_metadata` of the " +#~ "returned state dict, and thus pickled." +#~ " `_metadata` is a dictionary with " +#~ "keys that follow the naming convention" +#~ " of state dict. See " +#~ "``_load_from_state_dict`` on how to use " +#~ "this information in loading." +#~ msgstr "" + +#~ msgid "" +#~ "If new parameters/buffers are added/removed" +#~ " from a module, this number shall " +#~ "be bumped, and the module's " +#~ "`_load_from_state_dict` method can compare the" +#~ " version number and do appropriate " +#~ "changes if the state dict is from" +#~ " before the change." +#~ msgstr "" + +#~ msgid "" +#~ "Note that extra state should be " +#~ "pickleable to ensure working serialization " +#~ "of the state_dict. We only provide " +#~ "provide backwards compatibility guarantees for" +#~ " serializing Tensors; other objects may " +#~ "break backwards compatibility if their " +#~ "serialized pickled form changes." +#~ msgstr "" + +#~ msgid "*(string, torch.Tensor)* -- Tuple containing the name and buffer" +#~ msgstr "" + +#~ msgid "*(string, Module)* -- Tuple containing a name and child module" +#~ msgstr "" + +#~ msgid "*(string, Module)* -- Tuple of name and module" +#~ msgstr "" + +#~ msgid "*(string, Parameter)* -- Tuple containing the name and parameter" +#~ msgstr "" + +#~ msgid "" +#~ "The hook will be called every time" +#~ " after :func:`forward` has computed an " +#~ "output. It should have the following " +#~ "signature::" +#~ msgstr "" + +#~ msgid "" +#~ "The input contains only the positional" +#~ " arguments given to the module. " +#~ "Keyword arguments won't be passed to " +#~ "the hooks and only to the " +#~ "``forward``. The hook can modify the " +#~ "output. It can modify the input " +#~ "inplace but it will not have " +#~ "effect on forward since this is " +#~ "called after :func:`forward` is called." +#~ msgstr "" + +#~ msgid "" +#~ "The hook will be called every time" +#~ " before :func:`forward` is invoked. It " +#~ "should have the following signature::" +#~ msgstr "" + +#~ msgid "" +#~ "The input contains only the positional" +#~ " arguments given to the module. " +#~ "Keyword arguments won't be passed to " +#~ "the hooks and only to the " +#~ "``forward``. The hook can modify the " +#~ "input. User can either return a " +#~ "tuple or a single modified value " +#~ "in the hook. We will wrap the " +#~ "value into a tuple if a single " +#~ "value is returned(unless that value is" +#~ " already a tuple)." +#~ msgstr "" + +#~ msgid "" +#~ "The hook will be called every time" +#~ " the gradients with respect to module" +#~ " inputs are computed. The hook should" +#~ " have the following signature::" +#~ msgstr "" + +#~ msgid "Returns a dictionary containing a whole state of the module." +#~ msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/index.po b/docs/source/locale/zh/LC_MESSAGES/index.po index 1ee54686..b16d6b4b 100644 --- a/docs/source/locale/zh/LC_MESSAGES/index.po +++ b/docs/source/locale/zh/LC_MESSAGES/index.po @@ -6,17 +6,18 @@ # msgid "" msgstr "" -"Project-Id-Version: tensorcircuit\n" +"Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-02-02 13:41+0800\n" -"PO-Revision-Date: 2022-04-16 22:37+0800\n" +"POT-Creation-Date: 2023-05-07 10:47+0800\n" +"PO-Revision-Date: 2023-05-07 11:00+0800\n" "Last-Translator: Xinghan Yang\n" -"Language: cn\n" "Language-Team: \n" +"Language: cn\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.9.1\n" +"X-Generator: Poedit 3.2.2\n" #: ../../source/index.rst:2 msgid "Guide to TensorCircuit" @@ -42,129 +43,144 @@ msgstr "先进张量网络引擎赋能。🔋" #: ../../source/index.rst:15 msgid "" +"It is ready for quantum hardware access with CPU/GPU/QPU hybrid deployment " +"solutions. 🖥" +msgstr "量子硬件支持，优雅 CPU/GPU/QPU 混合部署方案。 🖥" + +#: ../../source/index.rst:17 +msgid "" "It is implemented with industry-standard machine learning frameworks: " "TensorFlow, JAX, and PyTorch. 🤖" msgstr "业界标准机器学习框架 TensorFlow，JAX，PyTorch 实现。🤖" -#: ../../source/index.rst:17 +#: ../../source/index.rst:19 msgid "" "It is compatible with machine learning engineering paradigms: automatic " -"differentiation, just-in-time compilation, vectorized parallelism and GPU" -" acceleration. 🛠" +"differentiation, just-in-time compilation, vectorized parallelism and GPU " +"acceleration. 🛠" msgstr "与机器学习工程实践兼容：自动微分，即时编译，向量并行化和 GPU 加速。🛠" -#: ../../source/index.rst:20 +#: ../../source/index.rst:23 msgid "Links" msgstr "重要链接" -#: ../../source/index.rst:22 +#: ../../source/index.rst:25 msgid "" -"TensorCircuit is created and maintained by `Shi-Xin Zhang " -"`_ and this version of the software is" -" released by `Tencent Quantum Lab `_. The " -"current core authors of TensorCircuit are `Shi-Xin Zhang " -"`_ and `Yu-Qin Chen " -"`_. We also thank `contributions " -"`_ from the lab and the open source" -" community." +"TensorCircuit is created and maintained by `Shi-Xin Zhang `_ and this version of the software is released by `Tencent " +"Quantum Lab `_. The current core authors of " +"TensorCircuit are `Shi-Xin Zhang `_ and `Yu-" +"Qin Chen `_. We also thank `contributions `_ from the " +"lab and the open source community." msgstr "" -#: ../../source/index.rst:26 +#: ../../source/index.rst:29 msgid "Source code: https://github.com/tencent-quantum-lab/tensorcircuit" msgstr "源代码: https://github.com/tencent-quantum-lab/tensorcircuit" -#: ../../source/index.rst:28 -#, fuzzy -msgid "Software Whitepaper: https://arxiv.org/abs/2205.10091" -msgstr "白皮书文章: https://arxiv.org/abs/2205.10091" - -#: ../../source/index.rst:30 +#: ../../source/index.rst:31 msgid "Documentation: https://tensorcircuit.readthedocs.io" msgstr "文档: https://tensorcircuit.readthedocs.io" -#: ../../source/index.rst:32 +#: ../../source/index.rst:33 +msgid "" +"Software Whitepaper (published in Quantum): https://quantum-journal.org/papers/" +"q-2023-02-02-912/" +msgstr "" +"软件白皮书 (发表于 Quantum): https://quantum-journal.org/papers/" +"q-2023-02-02-912/" + +#: ../../source/index.rst:35 msgid "Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues" msgstr "问题跟踪: https://github.com/tencent-quantum-lab/tensorcircuit/issues" -#: ../../source/index.rst:34 +#: ../../source/index.rst:37 msgid "Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" -msgstr "论坛社区: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" +msgstr "" +"论坛社区: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" -#: ../../source/index.rst:36 +#: ../../source/index.rst:39 msgid "PyPI page: https://pypi.org/project/tensorcircuit" msgstr "PyPI 页面: https://pypi.org/project/tensorcircuit" -#: ../../source/index.rst:38 +#: ../../source/index.rst:41 msgid "" -"DockerHub page: " -"https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit" +"DockerHub page: https://hub.docker.com/repository/docker/tensorcircuit/" +"tensorcircuit" msgstr "" -"DockerHub 页面: " -"https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit" +"DockerHub 页面: https://hub.docker.com/repository/docker/tensorcircuit/" +"tensorcircuit" #: ../../source/index.rst:43 +msgid "" +"Research and projects based on TensorCircuit: https://github.com/tencent-" +"quantum-lab/tensorcircuit#research-and-applications" +msgstr "" +"基于 TensorCircuit 的研究和项目: https://github.com/tencent-quantum-lab/" +"tensorcircuit#research-and-applications" + +#: ../../source/index.rst:45 +msgid "Tencent Quantum Cloud Service: https://quantum.tencent.com/cloud/" +msgstr "腾讯量子云服务: https://quantum.tencent.com/cloud/" + +#: ../../source/index.rst:47 +msgid "" +"If you have any further questions or collaboration ideas in terms of " +"TensorCircuit, please send email to shixinzhang#tencent.com." +msgstr "" +"如果关于 TensorCircuit 有任何其他问题咨询或合作意向，请发送邮件到 " +"shixinzhang#tencent.com。" + +#: ../../source/index.rst:51 msgid "Reference Documentation" msgstr "参考文档" -#: ../../source/index.rst:45 +#: ../../source/index.rst:53 msgid "" -"The following documentation sections briefly introduce TensorCircuit to " -"the users and developpers." +"The following documentation sections briefly introduce TensorCircuit to the " +"users and developpers." msgstr "以下文档向用户和开发者简要介绍了 TensorCircuit 软件。" -#: ../../source/index.rst:58 +#: ../../source/index.rst:66 msgid "Tutorials" msgstr "教程" -#: ../../source/index.rst:60 +#: ../../source/index.rst:68 msgid "" -"The following documentation sections include integrated examples in the " -"form of Jupyter Notebook." -msgstr "以下 Jupyter Notebook 格式的文档包括了一系列使用 TensorCircuit 的集成案例。" +"The following documentation sections include integrated examples in the form of " +"Jupyter Notebook." +msgstr "" +"以下 Jupyter Notebook 格式的文档包括了一系列使用 TensorCircuit 的集成案例。" -#: ../../source/index.rst:74 +#: ../../source/index.rst:82 msgid "API References" msgstr "API 参考" -#: ../../source/index.rst:83 +#: ../../source/index.rst:91 msgid "Indices and Tables" msgstr "索引和表格" -#: ../../source/index.rst:85 +#: ../../source/index.rst:93 msgid ":ref:`genindex`" msgstr ":ref:`genindex`" -#: ../../source/index.rst:86 +#: ../../source/index.rst:94 msgid ":ref:`modindex`" msgstr ":ref:`modindex`" -#: ../../source/index.rst:87 +#: ../../source/index.rst:95 msgid ":ref:`search`" msgstr ":ref:`search`" #~ msgid "" -#~ "Binder online: https://mybinder.org/v2/gh/refraction-" -#~ "ray/tc-env/master?urlpath=git-pull?repo=https://github.com" -#~ "/tencent-quantum-" -#~ "lab/tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" -#~ msgstr "" -#~ "在线 Binder Jupyter: https://mybinder.org/v2/gh" -#~ "/refraction-ray/tc-env/master?urlpath=git-" -#~ "pull?repo=https://github.com/tencent-quantum-" -#~ "lab/tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" - -#~ msgid "" -#~ "This project is released by `Tencent " -#~ "Quantum Lab `_ and " -#~ "is created and maintained by `Shi-" -#~ "Xin Zhang `_ " -#~ "The current core authors are `Shi-" -#~ "Xin Zhang `_ " -#~ "and `Yu-Qin Chen " -#~ "`_. We also thank " -#~ "`contributions `_ from the " -#~ "lab and the open source community." +#~ "Binder online: https://mybinder.org/v2/gh/refraction-ray/tc-env/master?" +#~ "urlpath=git-pull?repo=https://github.com/tencent-quantum-lab/" +#~ "tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" #~ msgstr "" +#~ "在线 Binder Jupyter: https://mybinder.org/v2/gh/refraction-ray/tc-env/master?" +#~ "urlpath=git-pull?repo=https://github.com/tencent-quantum-lab/" +#~ "tensorcircuit&urlpath=lab/tree/tensorcircuit/&branch=master" +#~ msgid "Software Whitepaper: https://arxiv.org/abs/2205.10091" +#~ msgstr "白皮书文章: https://arxiv.org/abs/2205.10091" diff --git a/docs/source/locale/zh/LC_MESSAGES/infras.po b/docs/source/locale/zh/LC_MESSAGES/infras.po index 6a2077b5..a24e7660 100644 --- a/docs/source/locale/zh/LC_MESSAGES/infras.po +++ b/docs/source/locale/zh/LC_MESSAGES/infras.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-01-13 11:04+0800\n" +"POT-Creation-Date: 2023-05-07 10:47+0800\n" "PO-Revision-Date: 2022-04-18 20:44+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -120,10 +120,11 @@ msgid "**ML Interfaces Related Modules:**" msgstr "**机器学习接口相关模块：**" #: ../../source/infras.rst:35 +#, fuzzy msgid "" ":py:mod:`tensorcircuit.interfaces`: Provide interfaces when quantum " "simulation backend is different from neural libraries. Currently include " -"PyTorch and scipy optimizer interfaces." +"PyTorch, TensorFlow, NumPy and SciPy optimizer interfaces." msgstr "" ":py:mod:`tensorcircuit.interfaces`: 当量子模拟后端与神经库不同时提供接口。 目前包括 PyTorch 和 " "scipy 优化器接口。" @@ -216,30 +217,46 @@ msgstr "" #: ../../source/infras.rst:65 msgid "" ":py:mod:`tensorcircuit.results`: Provide tools to process count dict and " -"to apply error mitigation" +"to apply error mitigation." msgstr "" #: ../../source/infras.rst:67 +msgid "**Cloud quantum hardware access module:**" +msgstr "" + +#: ../../source/infras.rst:69 +msgid "" +":py:mod:`tensorcircuit.cloud`: Provide quantum cloud SDK that can access " +"and program the real quantum hardware." +msgstr "" + +#: ../../source/infras.rst:71 +msgid "" +":py:mod:`tensorcircuit.compiler`: Provide compiler chains to compile and " +"transform quantum circuits." +msgstr "" + +#: ../../source/infras.rst:73 msgid "**Shortcuts and Templates for Circuit Manipulation:**" msgstr "**电路操作的快捷方式和模板：**" -#: ../../source/infras.rst:69 +#: ../../source/infras.rst:75 msgid "" ":py:mod:`tensorcircuit.templates`: provide handy shortcuts functions for " "expectation or circuit building patterns." msgstr ":py:mod:`tensorcircuit.templates`: 为期望或电路构建模式提供方便的快捷函数。" -#: ../../source/infras.rst:71 +#: ../../source/infras.rst:77 msgid "**Applications:**" msgstr "**应用：**" -#: ../../source/infras.rst:73 +#: ../../source/infras.rst:79 msgid "" ":py:mod:`tensorcircuit.applications`: most code here is not maintained " "and deprecated, use at your own risk." msgstr ":py:mod:`tensorcircuit.applications`: 这里的大多数代码都没有维护并且被弃用了，使用风险自负。" -#: ../../source/infras.rst:77 +#: ../../source/infras.rst:83 msgid "" "Recommend reading order -- only read the part of code you care about for " "your purpose. If you want to get an overview of the codebase, please read" @@ -248,11 +265,11 @@ msgstr "" "推荐阅读顺序——只阅读你关心的部分代码。如果您想了解代码库的概述，之后可以阅读 ``tc.circuit`` 后面的 ``tc.cons`` 和 " "``tc.gates``。" -#: ../../source/infras.rst:82 +#: ../../source/infras.rst:88 msgid "Relation between TensorCircuit and TensorNetwork" msgstr "TensorCircuit 和 TensorNetwork 之间的关系" -#: ../../source/infras.rst:84 +#: ../../source/infras.rst:90 msgid "" "TensorCircuit has a strong connection with the `TensorNetwork package " "`_ released by Google. Since the" @@ -266,7 +283,7 @@ msgstr "" "包的文档和教程很差，大多数时候，我们需要深入研究 TensorNetwork 的代码库来弄清楚发生了什么。换句话说，要阅读 " "TensorCircuit 代码库，可能需要经常参考 TensorNetwork 代码库。" -#: ../../source/infras.rst:86 +#: ../../source/infras.rst:92 msgid "" "Inside TensorCircuit, we heavily utilize TensorNetwork-related APIs from " "the TensorNetwork package and highly customized several modules from " @@ -275,7 +292,7 @@ msgstr "" "在 TensorCircuit 内部，我们大量使用了 TensorNetwork 包中与 TensorNetwork 相关的 " "API，并通过继承和重写从 TensorNetwork 中高度定制了几个模块：" -#: ../../source/infras.rst:88 +#: ../../source/infras.rst:94 msgid "" "We implement our own /backends from TensorNetwork's /backends by adding " "much more APIs and fixing lots of bugs in TensorNetwork's implementations" @@ -285,7 +302,7 @@ msgstr "" "我们从 TensorNetwork 的后端实现我们自己的后端，方法是添加更多 API，并通过猴子补丁修复 TensorNetwork " "在某些后端的实现中的许多错误。（上游是不活跃的，反馈不够灵敏）" -#: ../../source/infras.rst:90 +#: ../../source/infras.rst:96 msgid "" "We borrow TensorNetwork's code in /quantum to our ``tc.quantum`` module, " "since TensorNetwork has no ``__init__.py`` file to export these MPO and " @@ -296,7 +313,7 @@ msgstr "" "TensorNetwork 没有 ``__init__.py`` 文件来导出这些 MPO 和 MPS " "相关对象。当然，从那时起，我们已经取得了实质性的代码改进。" -#: ../../source/infras.rst:92 +#: ../../source/infras.rst:98 msgid "" "We borrow the TensorNetwork's code in /matrixproductstates as " "``tc.mps_base`` for bug fixing and jit/AD compatibility, so that we have " @@ -305,15 +322,15 @@ msgstr "" "我们借用 /matrixproductstates 中 TensorNetwork 的代码作为 ``tc.mps_base`` " "用于错误修复和即时编译/自动微分兼容性，以便我们更好地支持基于 MPS 的量子电路模拟器。" -#: ../../source/infras.rst:96 +#: ../../source/infras.rst:102 msgid "Relations of Circuit-like classes" msgstr "" -#: ../../source/infras.rst:108 +#: ../../source/infras.rst:114 msgid "QuOperator/QuVector and MPO/MPS" msgstr "QuOperator/QuVector 和 MPO/MPS" -#: ../../source/infras.rst:110 +#: ../../source/infras.rst:116 msgid "" ":py:class:`tensorcircuit.quantum.QuOperator`, " ":py:class:`tensorcircuit.quantum.QuVector` and " @@ -327,19 +344,19 @@ msgstr "" ":py:class:`tensorcircuit.quantum.QuAdjointVector` 是从 TensorNetwork " "包中采用的类。它们的行为类似于与其他成分交互时的矩阵/向量（列或行），而内部结构由张量网络维护以提高效率和紧凑性。" -#: ../../source/infras.rst:113 +#: ../../source/infras.rst:119 msgid "" "We use code examples and associated tensor diagrams to illustrate these " "object abstractions." msgstr "我们使用代码示例和相关的张量图来说明这些对象抽象。" -#: ../../source/infras.rst:117 +#: ../../source/infras.rst:123 msgid "" "``QuOperator`` can express MPOs and ``QuVector`` can express MPSs, but " "they can express more than these fixed structured tensor networks." msgstr "``QuOperator`` 可以表达 MPO，``QuVector`` 可以表达 MPS，但它们可以表达的不仅仅是这些固定的结构化张量网络。" -#: ../../source/infras.rst:145 +#: ../../source/infras.rst:151 msgid "" "Note how in this example, ``matrix`` is not a typical MPO but still can " "be expressed as ``QuOperator``. Indeed, any tensor network with two sets " @@ -351,7 +368,7 @@ msgstr "" "``QuOperator``。事实上，任何具有两组相同维度的悬边的张量网络都可以被视为 `` QuOperator``。``QuVector`` " "更加灵活，因为我们可以将所有悬空边视为向量维度。" -#: ../../source/infras.rst:147 +#: ../../source/infras.rst:153 msgid "" "Also, note how ``^`` is overloaded as ``tn.connect`` to connect edges " "between different nodes in TensorNetwork. And indexing the node gives the" @@ -360,7 +377,7 @@ msgstr "" "还要注意 ``^`` 是如何被重载为 ``tn.connect`` 以连接 TensorNetwork " "中不同节点之间的边。索引节点给出了节点的边，例如 ``n1[0]`` 意味着 ``节点 n1`` 的第一条边。" -#: ../../source/infras.rst:149 +#: ../../source/infras.rst:155 msgid "" "The convention to define the ``QuOperator`` is firstly giving " "``out_edges`` (left index or row index of the matrix) and then giving " @@ -370,7 +387,7 @@ msgstr "" "定义 ``QuOperator`` 的惯例是首先给出 ``out_edges``（矩阵的左索引或行索引），然后给出 " "``in_edges``（矩阵的右索引或列索引)。边列表包含来自 TensorNetwork 库的边对象。" -#: ../../source/infras.rst:151 +#: ../../source/infras.rst:157 msgid "" "Such QuOperator/QuVector abstraction support various calculations only " "possible on matrix/vectors, such as matmul (``@``), adjoint " @@ -397,3 +414,9 @@ msgstr "" #~ ":py:obj:`tensorcircuit.densitymatrix2.DMCircuit2` " #~ "类的高效实现，总是比参考的实现更适用。" +#~ msgid "" +#~ ":py:mod:`tensorcircuit.results`: Provide tools to" +#~ " process count dict and to apply " +#~ "error mitigation" +#~ msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/quickstart.po b/docs/source/locale/zh/LC_MESSAGES/quickstart.po index fb97d394..75a6f3e5 100644 --- a/docs/source/locale/zh/LC_MESSAGES/quickstart.po +++ b/docs/source/locale/zh/LC_MESSAGES/quickstart.po @@ -6,17 +6,18 @@ # msgid "" msgstr "" -"Project-Id-Version: tensorcircuit\n" +"Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-02-02 14:19+0800\n" -"PO-Revision-Date: 2022-04-11 08:23+0800\n" +"POT-Creation-Date: 2023-05-07 10:47+0800\n" +"PO-Revision-Date: 2023-05-07 11:01+0800\n" "Last-Translator: Xinghan Yang\n" -"Language: cn\n" "Language-Team: Xinghan Yang\n" +"Language: cn\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.9.1\n" +"X-Generator: Poedit 3.2.2\n" #: ../../source/quickstart.rst:3 msgid "Quick Start" @@ -24,7 +25,7 @@ msgstr "快速上手" #: ../../source/quickstart.rst:6 msgid "Installation" -msgstr "" +msgstr "安装" #: ../../source/quickstart.rst:8 msgid "For x86 Linux or Mac," @@ -36,14 +37,13 @@ msgstr "" #: ../../source/quickstart.rst:12 msgid "" -"is in general enough. Either pip from conda or other python env managers " -"is fine." +"is in general enough. Either pip from conda or other python env managers is fine." msgstr "" #: ../../source/quickstart.rst:15 msgid "" -"Since there are many optional packages for various features, the users " -"may need to install more pip packages when required." +"Since there are many optional packages for various features, the users may need " +"to install more pip packages when required." msgstr "" #: ../../source/quickstart.rst:18 @@ -52,10 +52,9 @@ msgstr "" #: ../../source/quickstart.rst:19 msgid "" -"please refer to the GPU aware installation guide of corresponding machine" -" learning frameworks: `TensorFlow " -"`_, `Jax " -"`_, or `PyTorch " +"please refer to the GPU aware installation guide of corresponding machine " +"learning frameworks: `TensorFlow `_, " +"`Jax `_, or `PyTorch " "`_." msgstr "" @@ -65,712 +64,741 @@ msgstr "" #: ../../source/quickstart.rst:26 msgid "" -"``sudo docker run -it --network host --gpus all " -"tensorcircuit/tensorcircuit``." +"``sudo docker run -it --network host --gpus all tensorcircuit/tensorcircuit``." msgstr "" #: ../../source/quickstart.rst:28 msgid "" -"For Windows, due to the lack of support for Jax, we recommend to use " -"docker or WSL, please refer to `TC via windows docker " -"`_ or `TC via WSL " -"`_." +"For more details on docker setup, please refer to `docker readme `_." msgstr "" #: ../../source/quickstart.rst:30 msgid "" -"For Mac with M series chips (arm architecture), please refer to `TC on " -"Mac M series `_." +"For Windows, due to the lack of support for Jax, we recommend to use docker or " +"WSL, please refer to `TC via windows docker `_ or `TC via WSL `_." msgstr "" #: ../../source/quickstart.rst:32 msgid "" -"Overall, the installation of TensorCircuit is simple, since it is purely " -"in Python and hence very portable. As long as the users can take care of " -"the installation of ML frameworks on the corresponding system, " -"TensorCircuit will work as expected." +"For Mac with M series chips (arm architecture), please refer to `TC on Mac M " +"series `_." +msgstr "" + +#: ../../source/quickstart.rst:34 +msgid "" +"Overall, the installation of TensorCircuit is simple, since it is purely in " +"Python and hence very portable. As long as the users can take care of the " +"installation of ML frameworks on the corresponding system, TensorCircuit will " +"work as expected." msgstr "" -#: ../../source/quickstart.rst:36 +#: ../../source/quickstart.rst:37 msgid "" -"We also provide a nightly build of tensorcircuit via PyPI which can be " -"accessed by ``pip uninstall tensorcircuit``, then ``pip install " -"tensorcircuit-nightly``" +"To debug the installation issue or report bugs, please check the environment " +"information by ``tc.about()``." msgstr "" -#: ../../source/quickstart.rst:42 +#: ../../source/quickstart.rst:40 +msgid "" +"We also provide a nightly build of tensorcircuit via PyPI which can be accessed " +"by ``pip uninstall tensorcircuit``, then ``pip install tensorcircuit-nightly``" +msgstr "" + +#: ../../source/quickstart.rst:46 msgid "Circuit Object" msgstr "电路对象" -#: ../../source/quickstart.rst:44 +#: ../../source/quickstart.rst:48 msgid "The basic object for TensorCircuit is ``tc.Circuit``." msgstr "TensorCircuit的基本对象是 ``tc.Circuit``。" -#: ../../source/quickstart.rst:46 +#: ../../source/quickstart.rst:50 msgid "Initialize the circuit with the number of qubits ``c=tc.Circuit(n)``." msgstr "用量子比特数(n) ``c=tc.Circuit(n)`` 来初始化电路。" -#: ../../source/quickstart.rst:48 +#: ../../source/quickstart.rst:52 msgid "**Input States:**" msgstr "**输入状态:**" -#: ../../source/quickstart.rst:50 +#: ../../source/quickstart.rst:54 msgid "" -"The default input function for the circuit is :math:`\\vert 0^n " -"\\rangle`. One can change this to other wavefunctions by directly feeding" -" the inputs state vectors w: ``c=tc.Circuit(n, inputs=w)``." +"The default input function for the circuit is :math:`\\vert 0^n \\rangle`. One " +"can change this to other wavefunctions by directly feeding the inputs state " +"vectors w: ``c=tc.Circuit(n, inputs=w)``." msgstr "" -"电路的默认输入函数是 :math:`\\vert 0^n \\rangle` 。可以通过直接输入输入状态向量 w 将其更改为其他波函数: " -"``c=tc.Circuit(n, inputs=w)``。" +"电路的默认输入函数是 :math:`\\vert 0^n \\rangle` 。可以通过直接输入输入状态向量 " +"w 将其更改为其他波函数: ``c=tc.Circuit(n, inputs=w)``。" -#: ../../source/quickstart.rst:52 +#: ../../source/quickstart.rst:56 msgid "" -"One can also feed matrix product states as input states for the circuit, " -"but we leave MPS/MPO usage for future sections." -msgstr "也可以将矩阵乘积状态作为电路的输入状态，但我们将矩阵乘积状态/矩阵乘积算子的使用留待后续讲解。" +"One can also feed matrix product states as input states for the circuit, but we " +"leave MPS/MPO usage for future sections." +msgstr "" +"也可以将矩阵乘积状态作为电路的输入状态，但我们将矩阵乘积状态/矩阵乘积算子的使用留" +"待后续讲解。" -#: ../../source/quickstart.rst:54 +#: ../../source/quickstart.rst:58 msgid "**Quantum Gates:**" msgstr "**量子门:**" -#: ../../source/quickstart.rst:56 +#: ../../source/quickstart.rst:60 msgid "" -"We can apply gates on circuit objects. For example, using ``c.H(1)`` or " -"``c.rx(2, theta=0.2)``, we can apply Hadamard gate on qubit 1 (0-based) " -"or apply Rx gate on qubit 2 as :math:`e^{-i\\theta/2 X}`." +"We can apply gates on circuit objects. For example, using ``c.H(1)`` or ``c." +"rx(2, theta=0.2)``, we can apply Hadamard gate on qubit 1 (0-based) or apply Rx " +"gate on qubit 2 as :math:`e^{-i\\theta/2 X}`." msgstr "" -"我们可以将门应用于电路对象。 例如，使用 ``c.H(1)`` 或 ``c.rx(2, theta=0.2)``，我们可以将 Hadamard " -"门应用于量子比特1 （基于0）或将 Rx 门应用于量子比特2 :math:`e^{-i\\theta/2 X}`。" +"我们可以将门应用于电路对象。 例如，使用 ``c.H(1)`` 或 ``c.rx(2, theta=0.2)``，我" +"们可以将 Hadamard 门应用于量子比特1 （基于0）或将 Rx 门应用于量子比特2 :math:" +"`e^{-i\\theta/2 X}`。" -#: ../../source/quickstart.rst:58 +#: ../../source/quickstart.rst:62 msgid "The same rule also applies to multi-qubit gates, such as ``c.cnot(0, 1)``." msgstr "同样的规则亦适用于多量子比特门，例如 ``c.cnot(0, 1)`` 。" -#: ../../source/quickstart.rst:60 +#: ../../source/quickstart.rst:64 msgid "There are also highly customizable gates, two instances are:" msgstr "这些量子门也是高度可定制的，下面是两个例子" -#: ../../source/quickstart.rst:62 +#: ../../source/quickstart.rst:66 msgid "" -"``c.exp1(0, 1, unitary=m, theta=0.2)`` which is for the exponential gate " -":math:`e^{i\\theta m}` of any matrix m as long as :math:`m^2=1`." +"``c.exp1(0, 1, unitary=m, theta=0.2)`` which is for the exponential gate :math:" +"`e^{i\\theta m}` of any matrix m as long as :math:`m^2=1`." msgstr "" -"``c.exp1(0, 1, unitary=m, theta=0.2)`` 用于任何矩阵 m 的指数门 :math:`e^{i\\theta " -"m}`，只要 m 满足 :math:`m^2=1`。" +"``c.exp1(0, 1, unitary=m, theta=0.2)`` 用于任何矩阵 m 的指数门 :math:" +"`e^{i\\theta m}`，只要 m 满足 :math:`m^2=1`。" -#: ../../source/quickstart.rst:64 +#: ../../source/quickstart.rst:68 msgid "" -"``c.any(0, 1, unitary=m)`` which is for applying the unitary gate m on " -"the circuit." +"``c.any(0, 1, unitary=m)`` which is for applying the unitary gate m on the " +"circuit." msgstr "``c.any(0, 1, unitary=m)`` 在电路上作用任意的幺正量子门。" -#: ../../source/quickstart.rst:66 +#: ../../source/quickstart.rst:70 msgid "These two examples are flexible and support gates on any number of qubits." msgstr "这两个例子很灵活，支持任意数量的量子比特上的门。" -#: ../../source/quickstart.rst:68 +#: ../../source/quickstart.rst:72 msgid "**Measurements and Expectations:**" msgstr "**测量与期望**" -#: ../../source/quickstart.rst:70 +#: ../../source/quickstart.rst:74 msgid "" -"The most straightforward way to get the output from the circuit object is" -" by getting the output wavefunction in vector form as ``c.state()``." -msgstr "从电路对象中获取输出的最直接的方法是通过 ``c.state()`` 以向量形式获取输出波函数。" +"The most straightforward way to get the output from the circuit object is by " +"getting the output wavefunction in vector form as ``c.state()``." +msgstr "" +"从电路对象中获取输出的最直接的方法是通过 ``c.state()`` 以向量形式获取输出波函数。" -#: ../../source/quickstart.rst:72 +#: ../../source/quickstart.rst:76 msgid "" -"For bitstring sampling, we have ``c.perfect_sampling()`` which returns " -"the bitstring and the corresponding probability amplitude." -msgstr "对于位串采样，我们有 ``c.perfect_sampling()``，它返回位串和相应的概率幅度。" +"For bitstring sampling, we have ``c.perfect_sampling()`` which returns the " +"bitstring and the corresponding probability amplitude." +msgstr "" +"对于位串采样，我们有 ``c.perfect_sampling()``，它返回位串和相应的概率幅度。" -#: ../../source/quickstart.rst:74 +#: ../../source/quickstart.rst:78 msgid "" -"To measure part of the qubits, we can use ``c.measure(0, 1)``, if we want" -" to know the corresponding probability of the measurement output, try " -"``c.measure(0, 1, with_prob=True)``. The measure API is by default non-" -"jittable, but we also have a jittable version as ``c.measure_jit(0, 1)``." +"To measure part of the qubits, we can use ``c.measure(0, 1)``, if we want to " +"know the corresponding probability of the measurement output, try ``c.measure(0, " +"1, with_prob=True)``. The measure API is by default non-jittable, but we also " +"have a jittable version as ``c.measure_jit(0, 1)``." msgstr "" -"要测量部分量子比特，我们可以使用 ``c.measure(0, 1)``，如果我们想知道测量的结果的对应概率，可以尝试 " -"``c.measure(0, 1, with_prob=True)``。 测量 API 在默认情况下是不可即时编译的 " -"，但我们也有一个可即时编译的版本，如 ``c.measure_jit(0, 1)``。" +"要测量部分量子比特，我们可以使用 ``c.measure(0, 1)``，如果我们想知道测量的结果的" +"对应概率，可以尝试 ``c.measure(0, 1, with_prob=True)``。 测量 API 在默认情况下是" +"不可即时编译的 ，但我们也有一个可即时编译的版本，如 ``c.measure_jit(0, 1)``。" -#: ../../source/quickstart.rst:76 +#: ../../source/quickstart.rst:80 msgid "" -"The measurement and sampling utilize advanced algorithms based on " -"tensornetwork and thus require no knowledge or space for the full " -"wavefunction." -msgstr "测量和采样使用了基于张量网络的高级算法，因此不需要任何相关知识或者空间来获取全波函数。" +"The measurement and sampling utilize advanced algorithms based on tensornetwork " +"and thus require no knowledge or space for the full wavefunction." +msgstr "" +"测量和采样使用了基于张量网络的高级算法，因此不需要任何相关知识或者空间来获取全波" +"函数。" -#: ../../source/quickstart.rst:78 +#: ../../source/quickstart.rst:82 msgid "See the example below:" msgstr "请看下面的例子：" -#: ../../source/quickstart.rst:96 +#: ../../source/quickstart.rst:100 msgid "" -"To compute expectation values for local observables, we have " -"``c.expectation([tc.gates.z(), [0]], [tc.gates.z(), [1]])`` for " -":math:`\\langle Z_0Z_1 \\rangle` or ``c.expectation([tc.gates.x(), " -"[0]])`` for :math:`\\langle X_0 \\rangle`." +"To compute expectation values for local observables, we have ``c.expectation([tc." +"gates.z(), [0]], [tc.gates.z(), [1]])`` for :math:`\\langle Z_0Z_1 \\rangle` or " +"``c.expectation([tc.gates.x(), [0]])`` for :math:`\\langle X_0 \\rangle`." msgstr "" -"为了计算局部可观察量的期望值，我们有 ``c.expectation([tc.gates.z(), [0]], [tc.gates.z(), " -"[1]])`` 对应的期望为 :math:`\\langle Z_0Z_1 \\rangle` 时，或 " -"``c.expectation([tc.gates.x(), [0]])`` 对应的期望为 :math:`\\langle X_0 " -"\\rangle`时." +"为了计算局部可观察量的期望值，我们有 ``c.expectation([tc.gates.z(), [0]], [tc." +"gates.z(), [1]])`` 对应的期望为 :math:`\\langle Z_0Z_1 \\rangle` 时，或 ``c." +"expectation([tc.gates.x(), [0]])`` 对应的期望为 :math:`\\langle X_0 \\rangle`时." -#: ../../source/quickstart.rst:98 +#: ../../source/quickstart.rst:102 msgid "" -"This expectation API is rather flexible, as one can measure an m on " -"several qubits as ``c.expectation([m, [0, 1, 2]])``." -msgstr "因为可以在几个量子比特上测量一个 m，这种计算期望值的 API 相当灵活：``c.expectation([m, [0, 1, 2]])``。" +"This expectation API is rather flexible, as one can measure an m on several " +"qubits as ``c.expectation([m, [0, 1, 2]])``." +msgstr "" +"因为可以在几个量子比特上测量一个 m，这种计算期望值的 API 相当灵活：``c." +"expectation([m, [0, 1, 2]])``。" -#: ../../source/quickstart.rst:100 +#: ../../source/quickstart.rst:104 msgid "" -"We can also extract the unitary matrix underlying the whole circuit as " -"follows:" +"We can also extract the unitary matrix underlying the whole circuit as follows:" msgstr "我们还可以提取整个电路下面的幺正矩阵，如下所示：" -#: ../../source/quickstart.rst:113 +#: ../../source/quickstart.rst:117 msgid "**Circuit Transformations:**" msgstr "**电路可视化**" -#: ../../source/quickstart.rst:115 +#: ../../source/quickstart.rst:119 msgid "" "We currently support transform ``tc.Circuit`` from and to Qiskit " "``QuantumCircuit`` object." -msgstr "我们目前支持 ``tc.Circuit`` 与 Qiskit ``QuantumCircuit`` 对象之间的互相转换。" +msgstr "" +"我们目前支持 ``tc.Circuit`` 与 Qiskit ``QuantumCircuit`` 对象之间的互相转换。" -#: ../../source/quickstart.rst:117 +#: ../../source/quickstart.rst:121 msgid "" -"Export to Qiskit (possible for further hardware experiment, compiling, " -"and visualization): ``c.to_qiskit()``." -msgstr "导出到 Qiskit（可能用于进一步的硬件实验、编译和可视化）：``c.to_qiskit()``。" +"Export to Qiskit (possible for further hardware experiment, compiling, and " +"visualization): ``c.to_qiskit()``." +msgstr "" +"导出到 Qiskit（可能用于进一步的硬件实验、编译和可视化）：``c.to_qiskit()``。" -#: ../../source/quickstart.rst:119 +#: ../../source/quickstart.rst:123 msgid "" "Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``. " -"Parameterized Qiskit circuit is supported by passing the parameters to " -"the ``binding_parameters`` argument of the ``from_qiskit`` function, " -"similar to the ``assign_parameters`` function in Qiskit." +"Parameterized Qiskit circuit is supported by passing the parameters to the " +"``binding_parameters`` argument of the ``from_qiskit`` function, similar to the " +"``assign_parameters`` function in Qiskit." msgstr "" -#: ../../source/quickstart.rst:123 +#: ../../source/quickstart.rst:127 msgid "**Circuit Visualization:**" msgstr "**电路可视化**" -#: ../../source/quickstart.rst:125 +#: ../../source/quickstart.rst:129 msgid "" -"``c.vis_tex()`` can generate tex code for circuit visualization based on " -"LaTeX `quantikz `__ package." +"``c.vis_tex()`` can generate tex code for circuit visualization based on LaTeX " +"`quantikz `__ package." msgstr "" "``c.vis_tex()`` 可以基于 `quantikz `__ " "package 生成用于电路可视化的 tex 代码。" -#: ../../source/quickstart.rst:127 +#: ../../source/quickstart.rst:131 msgid "" -"There are also some automatic pipeline helper functions to directly " -"generate figures from tex code, but they require extra installations in " -"the environment." -msgstr "还有一些自动辅助函数可以直接从 tex 代码生成图形，但它们需要在环境中进行额外安装。" +"There are also some automatic pipeline helper functions to directly generate " +"figures from tex code, but they require extra installations in the environment." +msgstr "" +"还有一些自动辅助函数可以直接从 tex 代码生成图形，但它们需要在环境中进行额外安装。" -#: ../../source/quickstart.rst:129 +#: ../../source/quickstart.rst:133 msgid "" -"``render_pdf(tex)`` function requires full installation of LaTeX locally." -" And in the Jupyter environment, we may prefer ``render_pdf(tex, " -"notebook=True)`` to return jpg figures, which further require wand " -"magicwand library installed, see `here `__." +"``render_pdf(tex)`` function requires full installation of LaTeX locally. And in " +"the Jupyter environment, we may prefer ``render_pdf(tex, notebook=True)`` to " +"return jpg figures, which further require wand magicwand library installed, see " +"`here `__." msgstr "" -"``render_pdf(tex)`` 函数需要在本地完全安装 LaTeX。 在 Jupyter 环境中，我们可能会偏好 " -"``render_pdf(tex, notebook=True)`` 来返回 jpg 图形，这需要安装 wand magicwand 库，请参阅 " -"`这里 `__ 。" +"``render_pdf(tex)`` 函数需要在本地完全安装 LaTeX。 在 Jupyter 环境中，我们可能会" +"偏好 ``render_pdf(tex, notebook=True)`` 来返回 jpg 图形，这需要安装 wand " +"magicwand 库，请参阅 `这里 `__ 。" -#: ../../source/quickstart.rst:131 +#: ../../source/quickstart.rst:135 msgid "" -"Or since we can transform ``tc.Circuit`` into QuantumCircuit easily, we " -"have a simple pipeline to first transform ``tc.Circuit`` into Qiskit and " -"then call the visualization built in Qiskit. Namely, we have ``c.draw()``" -" API." +"Or since we can transform ``tc.Circuit`` into QuantumCircuit easily, we have a " +"simple pipeline to first transform ``tc.Circuit`` into Qiskit and then call the " +"visualization built in Qiskit. Namely, we have ``c.draw()`` API." msgstr "" -"从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)`` " -"或者因为我们可以轻松地将 ``tc.Circuit`` 转换为 QuantumCircuit，我们有一个简单的管道来首先转换 " -"``tc.Circuit`` 为 Qiskit，然后调用 Qiskit 中内置的可视化。 也就是说，我们有 ``c.draw()`` API。" +"从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)`` 或者因为我们可" +"以轻松地将 ``tc.Circuit`` 转换为 QuantumCircuit，我们有一个简单的管道来首先转换 " +"``tc.Circuit`` 为 Qiskit，然后调用 Qiskit 中内置的可视化。 也就是说，我们有 ``c." +"draw()`` API。" -#: ../../source/quickstart.rst:133 +#: ../../source/quickstart.rst:137 msgid "**Circuit Intermediate Representation:**" msgstr "**电路中间表示:**" -#: ../../source/quickstart.rst:135 +#: ../../source/quickstart.rst:139 msgid "" -"TensorCircuit provides its own circuit IR as a python list of dicts. This" -" IR can be further utilized to run compiling, generate serialization " -"qasm, or render circuit figures." -msgstr "TensorCircuit 提供自己的中间表示是元素是字典的列表。此中间表示可进一步用于运行编译、生成序列化 qasm 或渲染电路图。" +"TensorCircuit provides its own circuit IR as a python list of dicts. This IR can " +"be further utilized to run compiling, generate serialization qasm, or render " +"circuit figures." +msgstr "" +"TensorCircuit 提供自己的中间表示是元素是字典的列表。此中间表示可进一步用于运行编" +"译、生成序列化 qasm 或渲染电路图。" -#: ../../source/quickstart.rst:137 +#: ../../source/quickstart.rst:141 msgid "" -"The IR is given as a list, each element is a dict containing information " -"on one gate that is applied to the circuit. Note gate attr in the dict is" -" a python function that returns the gate's node." +"The IR is given as a list, each element is a dict containing information on one " +"gate that is applied to the circuit. Note gate attr in the dict is a python " +"function that returns the gate's node." msgstr "" -"中间表示以列表形式给出，每个元素都是一个字典，其中包含应用于电路的一个量子门的信息。 注意字典中的 gate atrr " -"实际上是一个返回此量子门的节点的 python 函数。" +"中间表示以列表形式给出，每个元素都是一个字典，其中包含应用于电路的一个量子门的信" +"息。 注意字典中的 gate atrr 实际上是一个返回此量子门的节点的 python 函数。" -#: ../../source/quickstart.rst:149 +#: ../../source/quickstart.rst:153 msgid "Programming Paradigm" msgstr "编程范式" -#: ../../source/quickstart.rst:151 +#: ../../source/quickstart.rst:155 msgid "" -"The most common case and the most typical programming paradigm for " -"TensorCircuit are to evaluate the circuit output and the corresponding " -"quantum gradients, which is common in variational quantum algorithms." -msgstr "TensorCircuit 最常见的情况和最典型的编程范式是评估电路的输出以及相应的量子梯度，这在变分量子算法中很常见。" +"The most common case and the most typical programming paradigm for TensorCircuit " +"are to evaluate the circuit output and the corresponding quantum gradients, " +"which is common in variational quantum algorithms." +msgstr "" +"TensorCircuit 最常见的情况和最典型的编程范式是评估电路的输出以及相应的量子梯度，" +"这在变分量子算法中很常见。" -#: ../../source/quickstart.rst:178 +#: ../../source/quickstart.rst:182 #, fuzzy msgid "" -"Also for a non-quantum example (linear regression) demonstrating the " -"backend agnostic feature, variables with pytree support, AD/jit/vmap " -"usage, and variational optimization loops. Please refer to the example " -"script: `linear regression example `_. This example " -"might be more friendly to the machine learning community since it is " -"purely classical while also showcasing the main features and paradigms of" -" tensorcircuit." +"Also for a non-quantum example (linear regression) demonstrating the backend " +"agnostic feature, variables with pytree support, AD/jit/vmap usage, and " +"variational optimization loops. Please refer to the example script: `linear " +"regression example `_. This example might be more friendly to the " +"machine learning community since it is purely classical while also showcasing " +"the main features and paradigms of tensorcircuit." msgstr "" -"同样对于演示后端不可知特性的非量子示例（线性回归），pytree 支持变量、自动微分/即时编译/矢量并行化 用法和变分优化循环。请参考示例脚本: " -"`线性回归示例 `_ 。 " -"这个例子可能对机器学习的用户更友好，因为它纯粹是经典的，同时也展示了 TensorCircuit 的主要特征和范式。" +"同样对于演示后端不可知特性的非量子示例（线性回归），pytree 支持变量、自动微分/即" +"时编译/矢量并行化 用法和变分优化循环。请参考示例脚本: `线性回归示例 `_ 。 这" +"个例子可能对机器学习的用户更友好，因为它纯粹是经典的，同时也展示了 TensorCircuit " +"的主要特征和范式。" -#: ../../source/quickstart.rst:181 +#: ../../source/quickstart.rst:185 msgid "" -"If the user has no intention to maintain the application code in a " -"backend agnostic fashion, the API for ML frameworks can be more handily " -"used and interleaved with the TensorCircuit API." +"If the user has no intention to maintain the application code in a backend " +"agnostic fashion, the API for ML frameworks can be more handily used and " +"interleaved with the TensorCircuit API." msgstr "" -"如果用户无意以与后端无关的方式维护应用程序代码，则可以更方便地使用用于机器学习框架的 API 并将其与 TensorCircuit API " -"交替使用。" +"如果用户无意以与后端无关的方式维护应用程序代码，则可以更方便地使用用于机器学习框" +"架的 API 并将其与 TensorCircuit API 交替使用。" -#: ../../source/quickstart.rst:216 +#: ../../source/quickstart.rst:220 msgid "Automatic Differentiation, JIT, and Vectorized Parallelism" msgstr "自动微分、即时编译和矢量化并行 " -#: ../../source/quickstart.rst:218 +#: ../../source/quickstart.rst:222 msgid "" -"For concepts of AD, JIT and VMAP, please refer to `Jax documentation " -"`__ ." +"For concepts of AD, JIT and VMAP, please refer to `Jax documentation `__ ." msgstr "" -"关于自动微分、即时编译和向量并行化，请参考 `Jax 文档 " -"`__ 。" +"关于自动微分、即时编译和向量并行化，请参考 `Jax 文档 `__ 。" -#: ../../source/quickstart.rst:220 +#: ../../source/quickstart.rst:224 msgid "" "The related API design in TensorCircuit closely follows the functional " -"programming design pattern in Jax with some slight differences. So we " -"strongly recommend users learn some basics about Jax no matter which ML " -"backend they intend to use." +"programming design pattern in Jax with some slight differences. So we strongly " +"recommend users learn some basics about Jax no matter which ML backend they " +"intend to use." msgstr "" -"TensorCircuit 中的相关 API 设计与 Jax 中的函数式编程的设计模式密切相关，但是略有不同。因此，我们强烈建议用户学习一些有关 " -"Jax 的基础知识，无论他们打算使用哪种机器学习后端。" +"TensorCircuit 中的相关 API 设计与 Jax 中的函数式编程的设计模式密切相关，但是略有" +"不同。因此，我们强烈建议用户学习一些有关 Jax 的基础知识，无论他们打算使用哪种机器" +"学习后端。" -#: ../../source/quickstart.rst:222 +#: ../../source/quickstart.rst:226 msgid "**AD Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:224 +#: ../../source/quickstart.rst:228 msgid "" -"Gradients, vjps, jvps, natural gradients, Jacobians, and Hessians. AD is " -"the base for all modern machine learning libraries." -msgstr "梯度、矢量雅可比乘积、自然梯度、 Jacobian 矩阵和 Hessian 矩阵。自动微分是所有现代机器学习库的基础。" +"Gradients, vjps, jvps, natural gradients, Jacobians, and Hessians. AD is the " +"base for all modern machine learning libraries." +msgstr "" +"梯度、矢量雅可比乘积、自然梯度、 Jacobian 矩阵和 Hessian 矩阵。自动微分是所有现代" +"机器学习库的基础。" -#: ../../source/quickstart.rst:228 +#: ../../source/quickstart.rst:232 msgid "**JIT Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:230 -msgid "" -"Parameterized quantum circuits can run in a blink. Always use jit if the " -"circuit will get evaluations multiple times, it can greatly boost the " -"simulation with two or three order time reduction. But also be cautious, " -"users need to be familiar with jit, otherwise, the jitted function may " -"return unexpected results or recompile on every hit (wasting lots of " -"time). To learn more about the jit mechanism, one can refer to " -"documentation or blogs on ``tf.function`` or ``jax.jit``, though these " -"two still have subtle differences." -msgstr "" -"参数化的量子电路可以在瞬间完成运行。如果电路将得到多次运行，请始终使用即时编译，它可以大大提高仿真速度，减少两到三个数量级的运行时间。但也要小心，用户需要熟悉" -" 即时编译，否则，即时编译的函数可能会返回意外结果或每次在点击时都重新编译（浪费大量时间）。要了解更多关于即时编译机制的信息，可以参考关于 " -"``tf.function`` 或 ``jax.jit`` 的文档或博客，即使这两者仍然存在细微差别。" - #: ../../source/quickstart.rst:234 +msgid "" +"Parameterized quantum circuits can run in a blink. Always use jit if the circuit " +"will get evaluations multiple times, it can greatly boost the simulation with " +"two or three order time reduction. But also be cautious, users need to be " +"familiar with jit, otherwise, the jitted function may return unexpected results " +"or recompile on every hit (wasting lots of time). To learn more about the jit " +"mechanism, one can refer to documentation or blogs on ``tf.function`` or ``jax." +"jit``, though these two still have subtle differences." +msgstr "" +"参数化的量子电路可以在瞬间完成运行。如果电路将得到多次运行，请始终使用即时编译，" +"它可以大大提高仿真速度，减少两到三个数量级的运行时间。但也要小心，用户需要熟悉 即" +"时编译，否则，即时编译的函数可能会返回意外结果或每次在点击时都重新编译（浪费大量" +"时间）。要了解更多关于即时编译机制的信息，可以参考关于 ``tf.function`` 或 ``jax." +"jit`` 的文档或博客，即使这两者仍然存在细微差别。" + +#: ../../source/quickstart.rst:238 msgid "**VMAP Support:**" msgstr "**自动微分支持**" -#: ../../source/quickstart.rst:236 +#: ../../source/quickstart.rst:240 msgid "" -"Inputs, parameters, measurements, circuit structures, and Monte Carlo " -"noise can all be evaluated in parallel. To learn more about vmap " -"mechanism, one can refer to documentation or blogs on " -"``tf.vectorized_map`` or ``jax.vmap``." +"Inputs, parameters, measurements, circuit structures, and Monte Carlo noise can " +"all be evaluated in parallel. To learn more about vmap mechanism, one can refer " +"to documentation or blogs on ``tf.vectorized_map`` or ``jax.vmap``." msgstr "" -"输入、参数、测量、电路结构、蒙特卡洛噪声都可以并行测算。 要了解有关矢量并行化机制的更多信息，可以参考 ``tf.vectorized_map``" -" 或 ``jax.vmap`` 上的文档或博客。" +"输入、参数、测量、电路结构、蒙特卡洛噪声都可以并行测算。 要了解有关矢量并行化机制" +"的更多信息，可以参考 ``tf.vectorized_map`` 或 ``jax.vmap`` 上的文档或博客。" -#: ../../source/quickstart.rst:241 +#: ../../source/quickstart.rst:245 msgid "Backend Agnosticism" msgstr "后端无关特性" -#: ../../source/quickstart.rst:243 +#: ../../source/quickstart.rst:247 msgid "" -"TensorCircuit supports TensorFlow, Jax, and PyTorch backends. We " -"recommend using TensorFlow or Jax backend since PyTorch lacks advanced " -"jit and vmap features." +"TensorCircuit supports TensorFlow, Jax, and PyTorch backends. We recommend using " +"TensorFlow or Jax backend since PyTorch lacks advanced jit and vmap features." msgstr "" -"TensorCircuit 支持 TensorFlow、Jax 和 PyTorch 后端。 我们建议使用 TensorFlow 或 Jax " -"后端，因为 PyTorch 缺乏高级 jit 和 vmap 功能。" +"TensorCircuit 支持 TensorFlow、Jax 和 PyTorch 后端。 我们建议使用 TensorFlow 或 " +"Jax 后端，因为 PyTorch 缺乏高级 jit 和 vmap 功能。" -#: ../../source/quickstart.rst:245 +#: ../../source/quickstart.rst:249 msgid "" -"The backend can be set as ``K=tc.set_backend(\"jax\")`` and ``K`` is the " -"backend with a full set of APIs as a conventional ML framework, which can" -" also be accessed by ``tc.backend``." +"The backend can be set as ``K=tc.set_backend(\"jax\")`` and ``K`` is the backend " +"with a full set of APIs as a conventional ML framework, which can also be " +"accessed by ``tc.backend``." msgstr "" -"后端可以设置为 ``K=tc.set_backend(\"jax\")`` ，``K``作为常规机器学习框架的全套API的后端，也可以通过``tc" -" .backend`` 被访问。" +"后端可以设置为 ``K=tc.set_backend(\"jax\")`` ，``K``作为常规机器学习框架的全套API" +"的后端，也可以通过``tc .backend`` 被访问。" -#: ../../source/quickstart.rst:268 +#: ../../source/quickstart.rst:272 #, fuzzy msgid "" -"The supported APIs in the backend come from two sources, one part is " -"implemented in `TensorNetwork package " -"`__" -" and the other part is implemented in `TensorCircuit package " -"`__. To see all the backend " -"agnostic APIs, try:" +"The supported APIs in the backend come from two sources, one part is implemented " +"in `TensorNetwork package `__ and the other part is implemented " +"in `TensorCircuit package `__. To " +"see all the backend agnostic APIs, try:" +msgstr "" +"在后端支持的 APIs 有两个来源 , 一个来自 `TensorNetwork `__ " +"另一个来自 `TensorCircuit package `__。" + +#: ../../source/quickstart.rst:427 +msgid "​" msgstr "" -"在后端支持的 APIs 有两个来源 , 一个来自 `TensorNetwork " -"`__" -" 另一个来自 `TensorCircuit package `__。" -#: ../../source/quickstart.rst:422 +#: ../../source/quickstart.rst:430 msgid "Switch the Dtype" msgstr "转换 dtype" -#: ../../source/quickstart.rst:424 +#: ../../source/quickstart.rst:432 msgid "" -"TensorCircuit supports simulation using 32/64 bit precession. The default" -" dtype is 32-bit as \"complex64\". Change this by " -"``tc.set_dtype(\"complex128\")``." +"TensorCircuit supports simulation using 32/64 bit precession. The default dtype " +"is 32-bit as \"complex64\". Change this by ``tc.set_dtype(\"complex128\")``." msgstr "" "TensorCircuit 支持使用 32/64 bit 精确度的模拟。默认的 dtype 是 32-bit 的 " -"\"complex64\"。可以通过 ``tc.set_dtype(\"complex128\")`` 把 dtype 改为 \"complex" -" 128\" 。" +"\"complex64\"。可以通过 ``tc.set_dtype(\"complex128\")`` 把 dtype 改为 " +"\"complex 128\" 。" -#: ../../source/quickstart.rst:427 +#: ../../source/quickstart.rst:435 msgid "" -"``tc.dtypestr`` always returns the current dtype string: either " -"\"complex64\" or \"complex128\"." -msgstr "``tc.dtypestr`` 总会返回当前的 dtype 字符串: 不是 \"complex64\" 就是 \"complex128\"." +"``tc.dtypestr`` always returns the current dtype string: either \"complex64\" or " +"\"complex128\"." +msgstr "" +"``tc.dtypestr`` 总会返回当前的 dtype 字符串: 不是 \"complex64\" 就是 " +"\"complex128\"." -#: ../../source/quickstart.rst:431 +#: ../../source/quickstart.rst:439 msgid "Setup the Contractor" msgstr "设置 contractor" -#: ../../source/quickstart.rst:433 +#: ../../source/quickstart.rst:441 msgid "" -"TensorCircuit is a tensornetwork contraction-based quantum circuit " -"simulator. A contractor is for searching for the optimal contraction path" -" of the circuit tensornetwork." -msgstr "TensorCircuit 是一个基于张量网络收缩的量子电路模拟器。 contractor 用于搜索电路张量网络的最佳收缩路径。" +"TensorCircuit is a tensornetwork contraction-based quantum circuit simulator. A " +"contractor is for searching for the optimal contraction path of the circuit " +"tensornetwork." +msgstr "" +"TensorCircuit 是一个基于张量网络收缩的量子电路模拟器。 contractor 用于搜索电路张" +"量网络的最佳收缩路径。" -#: ../../source/quickstart.rst:435 +#: ../../source/quickstart.rst:443 msgid "" -"There are various advanced contractors provided by third-party packages, " -"such as `opt-einsum `__ and " -"`cotengra `__." +"There are various advanced contractors provided by third-party packages, such as " +"`opt-einsum `__ and `cotengra `__." msgstr "" -"有各种第三方包提供的高级 contractor ，例如 `opt-einsum " -"`__ 和 `cotengra " -"`__ 。" +"有各种第三方包提供的高级 contractor ，例如 `opt-einsum `__ 和 `cotengra `__ 。" -#: ../../source/quickstart.rst:437 +#: ../../source/quickstart.rst:445 msgid "" -"`opt-einsum` is shipped with TensorNetwork package. To use cotengra, one " -"needs to pip install it; kahypar is also recommended to install with " -"cotengra." +"`opt-einsum` is shipped with TensorNetwork package. To use cotengra, one needs " +"to pip install it; kahypar is also recommended to install with cotengra." msgstr "" -"`opt-einsum` 随 TensorNetwork 软件包一起。如要使用 cotengra，则需要 pip 安装它； 还建议安装 " -"cotengra 随 kahypar 一起使用。" +"`opt-einsum` 随 TensorNetwork 软件包一起。如要使用 cotengra，则需要 pip 安装它； " +"还建议安装 cotengra 随 kahypar 一起使用。" -#: ../../source/quickstart.rst:439 +#: ../../source/quickstart.rst:447 msgid "Some setup cases:" msgstr "一些设置案例：" -#: ../../source/quickstart.rst:465 +#: ../../source/quickstart.rst:473 #, fuzzy msgid "" -"For advanced configurations on cotengra contractors, please refer to " -"cotengra `doc " -"`__ and more " -"fancy examples can be found at `contractor tutorial `__." +"For advanced configurations on cotengra contractors, please refer to cotengra " +"`doc `__ and more fancy " +"examples can be found at `contractor tutorial `__." msgstr "" -"有关 cotengra contractor 的高级配置，请参阅 cotengra `doc " -"`__ 更多精彩示例在 " -"`contractor 教程 `__." +"有关 cotengra contractor 的高级配置，请参阅 cotengra `doc `__ 更多精彩示例在 `contractor 教程 " +"`__." -#: ../../source/quickstart.rst:467 +#: ../../source/quickstart.rst:475 msgid "**Setup in Function or Context Level**" msgstr "**函数和上下文级别的设置**" -#: ../../source/quickstart.rst:469 +#: ../../source/quickstart.rst:477 msgid "" -"Beside global level setup, we can also setup the backend, the dtype, and " -"the contractor at the function level or context manager level:" -msgstr "除了全局级别设置，我们还可以在函数级别或上下文管理器级别设置后端、dtype 和contractor：" +"Beside global level setup, we can also setup the backend, the dtype, and the " +"contractor at the function level or context manager level:" +msgstr "" +"除了全局级别设置，我们还可以在函数级别或上下文管理器级别设置后端、dtype 和" +"contractor：" -#: ../../source/quickstart.rst:487 +#: ../../source/quickstart.rst:495 msgid "Noisy Circuit Simulation" msgstr "噪声电路模拟" -#: ../../source/quickstart.rst:489 +#: ../../source/quickstart.rst:497 msgid "**Monte Carlo State Simulator:**" msgstr "**蒙特卡洛态模拟器**" -#: ../../source/quickstart.rst:491 +#: ../../source/quickstart.rst:499 msgid "" -"For the Monte Carlo trajectory noise simulator, the unitary Kraus channel" -" can be handled easily. TensorCircuit also supports fully jittable and " -"differentiable general Kraus channel Monte Carlo simulation, though." +"For the Monte Carlo trajectory noise simulator, the unitary Kraus channel can be " +"handled easily. TensorCircuit also supports fully jittable and differentiable " +"general Kraus channel Monte Carlo simulation, though." msgstr "" -"对于蒙特卡洛轨迹噪声模拟器，可以轻松处理幺正的 Kraus 通道。 不过，TensorCircuit 还支持完全可即时编译和可微分的通用 " -"Kraus 通道蒙特卡罗模拟。" +"对于蒙特卡洛轨迹噪声模拟器，可以轻松处理幺正的 Kraus 通道。 不过，TensorCircuit " +"还支持完全可即时编译和可微分的通用 Kraus 通道蒙特卡罗模拟。" -#: ../../source/quickstart.rst:518 +#: ../../source/quickstart.rst:526 msgid "**Density Matrix Simulator:**" msgstr "**密度矩阵模拟器**" -#: ../../source/quickstart.rst:520 +#: ../../source/quickstart.rst:528 msgid "" -"Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full " -"form, but takes twice qubits to do noiseless simulation. The API is the " -"same as ``tc.Circuit``." -msgstr "密度矩阵模拟器``tc.DMCircuit`` 以完整形式模拟噪声，但需要两倍的量子比特。API 与 ``tc.Circuit`` 基本相同。" +"Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full form, " +"but takes twice qubits to do noiseless simulation. The API is the same as ``tc." +"Circuit``." +msgstr "" +"密度矩阵模拟器``tc.DMCircuit`` 以完整形式模拟噪声，但需要两倍的量子比特。API 与 " +"``tc.Circuit`` 基本相同。" -#: ../../source/quickstart.rst:539 +#: ../../source/quickstart.rst:547 msgid "**Experiment with quantum errors:**" msgstr "" -#: ../../source/quickstart.rst:541 +#: ../../source/quickstart.rst:549 msgid "Multiple quantum errors can be added on circuit." msgstr "" -#: ../../source/quickstart.rst:557 +#: ../../source/quickstart.rst:565 msgid "**Experiment with readout error:**" msgstr "" -#: ../../source/quickstart.rst:559 +#: ../../source/quickstart.rst:567 msgid "" -"Readout error can be added in experiments for sampling and expectation " -"value calculation." +"Readout error can be added in experiments for sampling and expectation value " +"calculation." msgstr "" -#: ../../source/quickstart.rst:585 +#: ../../source/quickstart.rst:593 msgid "MPS and MPO" msgstr "矩阵乘积状态和矩阵乘积算子" -#: ../../source/quickstart.rst:587 +#: ../../source/quickstart.rst:595 msgid "" -"TensorCircuit has its class for MPS and MPO originally defined in " -"TensorNetwork as ``tc.QuVector``, ``tc.QuOperator``." +"TensorCircuit has its class for MPS and MPO originally defined in TensorNetwork " +"as ``tc.QuVector``, ``tc.QuOperator``." msgstr "" -"TensorCircuit 有自己的 MPS 和 MPO 类，起初在 TensorNetwork 中定义为“tc.QuVector” 和 " -"“tc.QuOperator”。" +"TensorCircuit 有自己的 MPS 和 MPO 类，起初在 TensorNetwork 中定义为“tc.QuVector” " +"和 “tc.QuOperator”。" -#: ../../source/quickstart.rst:589 +#: ../../source/quickstart.rst:597 msgid "" -"``tc.QuVector`` can be extracted from ``tc.Circuit`` as the tensor " -"network form for the output state (uncontracted) by ``c.quvector()``." +"``tc.QuVector`` can be extracted from ``tc.Circuit`` as the tensor network form " +"for the output state (uncontracted) by ``c.quvector()``." msgstr "" -"作为``c.quvector()`` 的输出状态（未收缩）的张量网络形式，``tc.QuVector`` 可以从``tc.Circuit`` " -"中提取。" +"作为``c.quvector()`` 的输出状态（未收缩）的张量网络形式，``tc.QuVector`` 可以从" +"``tc.Circuit`` 中提取。" -#: ../../source/quickstart.rst:591 +#: ../../source/quickstart.rst:599 msgid "" -"The QuVector forms a wavefunction w, which can also be fed into Circuit " -"as the inputs state as ``c=tc.Circuit(n, mps_inputs=w)``." +"The QuVector forms a wavefunction w, which can also be fed into Circuit as the " +"inputs state as ``c=tc.Circuit(n, mps_inputs=w)``." msgstr "" -"QuVector 形成一个波函数 w，它也可以作为 ``c=tc.Circuit(n, mps_inputs=w)`` 的输入状态输入到 " -"Circuit 中。" +"QuVector 形成一个波函数 w，它也可以作为 ``c=tc.Circuit(n, mps_inputs=w)`` 的输入" +"状态输入到 Circuit 中。" -#: ../../source/quickstart.rst:593 +#: ../../source/quickstart.rst:601 msgid "MPS as input state for circuit" msgstr "MPS 作为电路的输入状态" -#: ../../source/quickstart.rst:595 +#: ../../source/quickstart.rst:603 msgid "" -"The MPS/QuVector representation of the input state has a more efficient " -"and compact form." +"The MPS/QuVector representation of the input state has a more efficient and " +"compact form." msgstr "输入状态的 MPS/QuVector 表示具有更高效和紧凑的形式。" -#: ../../source/quickstart.rst:607 +#: ../../source/quickstart.rst:615 msgid "MPS as (uncomputed) output state for circuit" msgstr "MPS 作为电路的（未计算的）输出状态" -#: ../../source/quickstart.rst:609 +#: ../../source/quickstart.rst:617 msgid "" "For example, a quick way to calculate the wavefunction overlap without " "explicitly computing the state amplitude is given as below:" msgstr "例如，在不显式计算状态幅度的情况下，计算波函数重叠的快速方法如下：" -#: ../../source/quickstart.rst:626 +#: ../../source/quickstart.rst:634 msgid "MPO as the gate on the circuit" msgstr "MPO 作为电路上的门" -#: ../../source/quickstart.rst:628 +#: ../../source/quickstart.rst:636 msgid "" -"Instead of a common quantum gate in matrix/node format, we can directly " -"apply a gate in MPO/QuOperator format." +"Instead of a common quantum gate in matrix/node format, we can directly apply a " +"gate in MPO/QuOperator format." msgstr "代替矩阵/节点格式的普通量子门，我们可以直接应用 MPO/QuOperator 格式的门。" -#: ../../source/quickstart.rst:639 -msgid "" -"The representative gate defined in MPO format is the ``multicontrol`` " -"gate." +#: ../../source/quickstart.rst:647 +msgid "The representative gate defined in MPO format is the ``multicontrol`` gate." msgstr "以 MPO 格式定义的代表门是 ``multicontrol`` 门。" -#: ../../source/quickstart.rst:641 +#: ../../source/quickstart.rst:649 msgid "MPO as the operator for expectation evaluation on a circuit" msgstr "MPO作为电路期望估测算子" -#: ../../source/quickstart.rst:643 +#: ../../source/quickstart.rst:651 msgid "" -"We can also measure operator expectation on the circuit output state " -"where the operator is in MPO/QuOperator format." +"We can also measure operator expectation on the circuit output state where the " +"operator is in MPO/QuOperator format." msgstr "我们还可以测量运算符对 MPO/QuOperator 格式的电路输出状态的期望。" -#: ../../source/quickstart.rst:655 +#: ../../source/quickstart.rst:663 msgid "Interfaces" msgstr "接口" -#: ../../source/quickstart.rst:657 +#: ../../source/quickstart.rst:665 msgid "**PyTorch Interface to Hybrid with PyTorch Modules:**" msgstr "**与 PyTorch 模块混合的 PyTorch 接口：**" -#: ../../source/quickstart.rst:659 +#: ../../source/quickstart.rst:667 msgid "" -"As we have mentioned in the backend section, the PyTorch backend may lack" -" advanced features. This doesn't mean we cannot hybrid the advanced " -"circuit module with PyTorch neural module. We can run the quantum " -"function on TensorFlow or Jax backend while wrapping it with a Torch " -"interface." +"As we have mentioned in the backend section, the PyTorch backend may lack " +"advanced features. This doesn't mean we cannot hybrid the advanced circuit " +"module with PyTorch neural module. We can run the quantum function on TensorFlow " +"or Jax backend while wrapping it with a Torch interface." msgstr "" -"正如我们在后端部分提到的，PyTorch 后端可能缺少高级功能。 这并不意味着我们不能将高级量子电路模块与 PyTorch 神经模块混合。 " -"我们可以在 TensorFlow 或 Jax 后端运行量子函数，同时使用 Torch 接口包装它。 " +"正如我们在后端部分提到的，PyTorch 后端可能缺少高级功能。 这并不意味着我们不能将高" +"级量子电路模块与 PyTorch 神经模块混合。 我们可以在 TensorFlow 或 Jax 后端运行量子" +"函数，同时使用 Torch 接口包装它。 " -#: ../../source/quickstart.rst:686 +#: ../../source/quickstart.rst:694 msgid "" -"For a GPU/CPU, torch/tensorflow, quantum/classical hybrid machine " -"learning pipeline enabled by tensorcircuit, see `example script " -"`__." +"For a GPU/CPU, torch/tensorflow, quantum/classical hybrid machine learning " +"pipeline enabled by tensorcircuit, see `example script `__." msgstr "" -#: ../../source/quickstart.rst:688 +#: ../../source/quickstart.rst:696 msgid "" -"We also provider wrapper of quantum function for torch module as " -":py:meth:`tensorcircuit.TorchLayer` alias to " -":py:meth:`tensorcircuit.torchnn.QuantumNet`." +"There is also a more flexible torch interface that support static non-tensor " +"inputs as keyword arguments, which can be utilized as below:" msgstr "" -#: ../../source/quickstart.rst:690 +#: ../../source/quickstart.rst:710 msgid "" -"For ``TorchLayer``, ``use_interface=True`` is by default, which natively " -"allow the quantum function defined on other tensorcircuit backends, such " -"as jax or tf for speed consideration." +"We also provider wrapper of quantum function for torch module as :py:meth:" +"`tensorcircuit.TorchLayer` alias to :py:meth:`tensorcircuit.torchnn.QuantumNet`." msgstr "" -#: ../../source/quickstart.rst:692 +#: ../../source/quickstart.rst:712 msgid "" -"``TorchLayer`` can process multiple input arguments as multiple function " -"inputs, following torch practice." +"For ``TorchLayer``, ``use_interface=True`` is by default, which natively allow " +"the quantum function defined on other tensorcircuit backends, such as jax or tf " +"for speed consideration." msgstr "" -#: ../../source/quickstart.rst:720 +#: ../../source/quickstart.rst:714 +msgid "" +"``TorchLayer`` can process multiple input arguments as multiple function inputs, " +"following torch practice." +msgstr "" + +#: ../../source/quickstart.rst:742 msgid "**TensorFlow interfaces:**" msgstr "" -#: ../../source/quickstart.rst:722 +#: ../../source/quickstart.rst:744 msgid "" -"Similar rules apply similar as torch interface. The interface can even be" -" used within jit environment outside. See " -":py:meth:`tensorcircuit.interfaces.tensorflow.tensorflow_interface`." +"Similar rules apply similar as torch interface. The interface can even be used " +"within jit environment outside. See :py:meth:`tensorcircuit.interfaces." +"tensorflow.tensorflow_interface`." msgstr "" -#: ../../source/quickstart.rst:725 +#: ../../source/quickstart.rst:747 msgid "" -"We also provider ``enable_dlpack=True`` option in torch and tf " -"interfaces, which allow the tensor transformation happen without memory " -"transfer via dlpack, higher version of tf or torch package required." +"We also provider ``enable_dlpack=True`` option in torch and tf interfaces, which " +"allow the tensor transformation happen without memory transfer via dlpack, " +"higher version of tf or torch package required." msgstr "" -#: ../../source/quickstart.rst:728 +#: ../../source/quickstart.rst:750 msgid "" -"We also provider wrapper of quantum function for keras layer as " -":py:meth:`tensorcircuit.KerasLayer` alias to " -":py:meth:`tensorcircuit.keras.KerasLayer`." +"We also provider wrapper of quantum function for keras layer as :py:meth:" +"`tensorcircuit.KerasLayer` alias to :py:meth:`tensorcircuit.keras.KerasLayer`." msgstr "" -#: ../../source/quickstart.rst:730 +#: ../../source/quickstart.rst:752 msgid "" -"``KerasLayer`` can process multiple input arguments with the input as a " -"dict, following the common keras practice, see example below." +"``KerasLayer`` can process multiple input arguments with the input as a dict, " +"following the common keras practice, see example below." msgstr "" -#: ../../source/quickstart.rst:752 +#: ../../source/quickstart.rst:774 msgid "**Scipy Interface to Utilize Scipy Optimizers:**" msgstr "**使用 scipy接口使用scipy优化器：**" -#: ../../source/quickstart.rst:754 +#: ../../source/quickstart.rst:776 msgid "" -"Automatically transform quantum functions as scipy-compatible values and " -"grad functions as provided for scipy interface with ``jac=True``." -msgstr "为带有 jac=True 的 scipy 接口自动将量子函数转换为与 scipy 兼容的 value 和 grad 函数。" +"Automatically transform quantum functions as scipy-compatible values and grad " +"functions as provided for scipy interface with ``jac=True``." +msgstr "" +"为带有 jac=True 的 scipy 接口自动将量子函数转换为与 scipy 兼容的 value 和 grad 函" +"数。" -#: ../../source/quickstart.rst:780 +#: ../../source/quickstart.rst:802 msgid "Templates as Shortcuts" msgstr "捷径模板" -#: ../../source/quickstart.rst:782 +#: ../../source/quickstart.rst:804 msgid "**Measurements:**" msgstr "**测量**" -#: ../../source/quickstart.rst:784 +#: ../../source/quickstart.rst:806 msgid "Ising type Hamiltonian defined on a general graph" msgstr "在一般图上定义的伊辛型哈密顿量" -#: ../../source/quickstart.rst:786 -msgid "" -"See " -":py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" -msgstr "参考 :py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" +#: ../../source/quickstart.rst:808 +msgid "See :py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" +msgstr "" +"参考 :py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" -#: ../../source/quickstart.rst:788 +#: ../../source/quickstart.rst:810 msgid "Heisenberg Hamiltonian on a general graph with possible external fields" msgstr "具有可能存在的外场的一般图上的海森堡哈密顿量" -#: ../../source/quickstart.rst:790 -msgid "" -"See " -":py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" -msgstr "参考 :py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" +#: ../../source/quickstart.rst:812 +msgid "See :py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" +msgstr "" +"参考 :py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" -#: ../../source/quickstart.rst:792 +#: ../../source/quickstart.rst:814 msgid "**Circuit Blocks:**" msgstr "**电路块**" @@ -784,61 +812,45 @@ msgstr "**电路块**" #~ msgstr "从GitHub安装" #~ msgid "" -#~ "For beta version usage, one needs " -#~ "to install tensorcircuit package from " -#~ "GitHub. For development and PR workflow," -#~ " please refer to `contribution " +#~ "For beta version usage, one needs to install tensorcircuit package from " +#~ "GitHub. For development and PR workflow, please refer to `contribution " #~ "`__ instead." #~ msgstr "" -#~ "如需使用测试版本，则需要从 GitHub 安装 tensorcircuit。对于开发和 PR" -#~ " 工作流程，请另外参考 `贡献 `__ 。" +#~ "如需使用测试版本，则需要从 GitHub 安装 tensorcircuit。对于开发和 PR 工作流程，" +#~ "请另外参考 `贡献 `__ 。" #~ msgid "" -#~ "For private tensorcircuit-dev repo, one" -#~ " needs to first configure the SSH " -#~ "key on GitHub and locally, please " -#~ "refer to `GitHub doc " -#~ "`__" +#~ "For private tensorcircuit-dev repo, one needs to first configure the SSH key " +#~ "on GitHub and locally, please refer to `GitHub doc `__" #~ msgstr "" -#~ "对于私有 tensorcircuit 开发库，首先需要在 GitHub 和本地配置 " -#~ "SSH 密钥, 请参考 `GitHub 文档 " -#~ "`__" +#~ "对于私有 tensorcircuit 开发库，首先需要在 GitHub 和本地配置 SSH 密钥, 请参考 " +#~ "`GitHub 文档 `__" #~ msgid "" -#~ "Then try ``pip3 install --force-" -#~ "reinstall git+ssh://git@github.com/quclub/tensorcircuit-" -#~ "dev.git`` in shell." +#~ "Then try ``pip3 install --force-reinstall git+ssh://git@github.com/quclub/" +#~ "tensorcircuit-dev.git`` in shell." #~ msgstr "" -#~ "然后尝试在命令行窗口中输入 ``pip3 install --force-reinstall" -#~ " git+ssh://git@github.com/quclub/tensorcircuit-dev.git`` " -#~ "。" +#~ "然后尝试在命令行窗口中输入 ``pip3 install --force-reinstall git+ssh://" +#~ "git@github.com/quclub/tensorcircuit-dev.git`` 。" #~ msgid "" -#~ "Depending on one's need, one may " -#~ "further pip install tensorflow (for " -#~ "TensorFlow backend) or jax and jaxlib" -#~ " (for jax backend) or `cotengra " -#~ "`__ (for more " -#~ "advanced tensornetwork contraction path " -#~ "solver)." +#~ "Depending on one's need, one may further pip install tensorflow (for " +#~ "TensorFlow backend) or jax and jaxlib (for jax backend) or `cotengra `__ (for more advanced tensornetwork contraction " +#~ "path solver)." #~ msgstr "" -#~ "基于个人情况，用户可能需要进一步安装 tensorflow, jax 或 jaxlib" -#~ " 或 `cotengra `_" -#~ " 以满足后端要求。" +#~ "基于个人情况，用户可能需要进一步安装 tensorflow, jax 或 jaxlib 或 `cotengra " +#~ "`_ 以满足后端要求。" #~ msgid "" -#~ "If one needs circuit visualization on" -#~ " JupyterLab, python package `wand " -#~ "`__ and its " -#~ "binary bindings, as well as LaTeX " -#~ "installation, are required." +#~ "If one needs circuit visualization on JupyterLab, python package `wand " +#~ "`__ and its binary bindings, as well as " +#~ "LaTeX installation, are required." #~ msgstr "" -#~ "如果需要在 JupyterLab 中进行电路可视化，则需要 python 库 " -#~ "`wand `__ " -#~ "及其二进制绑定以及 LaTeX 的安装。" +#~ "如果需要在 JupyterLab 中进行电路可视化，则需要 python 库 `wand `__ 及其二进制绑定以及 LaTeX 的安装。" #~ msgid "Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``" #~ msgstr "从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``" - diff --git a/docs/source/locale/zh/LC_MESSAGES/sharpbits.po b/docs/source/locale/zh/LC_MESSAGES/sharpbits.po index 95459bb9..5b2bfadc 100644 --- a/docs/source/locale/zh/LC_MESSAGES/sharpbits.po +++ b/docs/source/locale/zh/LC_MESSAGES/sharpbits.po @@ -9,7 +9,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit \n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2022-06-27 20:10+0800\n" +"POT-Creation-Date: 2023-05-07 10:47+0800\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" @@ -27,9 +27,7 @@ msgid "" "Be fast is never for free, though much cheaper in TensorCircuit, but you " "have to be cautious especially in terms of AD, JIT compatibility. We will" " go through the main sharp edges 🔪 in this note." -msgstr "" -"虽然在TensorCircuit中速度很快，但是你必须小心，尤其是在AD和JIT兼容性" -"方面。" +msgstr "虽然在TensorCircuit中速度很快，但是你必须小心，尤其是在AD和JIT兼容性方面。" #: ../../source/sharpbits.rst:9 msgid "Jit Compatibility" @@ -45,10 +43,7 @@ msgid "" " otherwise the recompilation is incurred which is time-consuming. " "Therefore, if there are input args that are non-tensor or varying shape " "tensors and frequently change, jit is not recommend." -msgstr "" -"输入必须是张量形式，且输入张量的形状必须固定，否则会重新编译，这是非常耗" -"时的。因此，如果有输入参数是非张量或者变化形状的张量，且经常变化，不建议" -"使用jit。" +msgstr "输入必须是张量形式，且输入张量的形状必须固定，否则会重新编译，这是非常耗时的。因此，如果有输入参数是非张量或者变化形状的张量，且经常变化，不建议使用jit。" #: ../../source/sharpbits.rst:38 msgid "Mix use of numpy and ML backend APIs" @@ -63,17 +58,14 @@ msgid "" "For numpy ops, they will be only called in jit staging time (the first " "run)." msgstr "" -"为了使函数可jit和可AD，函数中的每个操作都应该通过ML后端（``tc.backend`` API" -"或者直接调用后端API ``tf`` 或者 ``jax``）。这是因为ML后端必须创建计算" -"图来"进行AD和JIT转换。对于numpy操作，它们只会在jit编译阶段被调用（第一" -"次运行）。" +"为了使函数可jit和可AD，函数中的每个操作都应该通过ML后端（``tc.backend`` API或者直接调用后端API ``tf`` 或者 " +"``jax``）。这是因为ML后端必须创建计算图来\"进行AD和JIT转换。对于numpy操作，它们只会在jit编译阶段被调用（第一次运行）。" #: ../../source/sharpbits.rst:54 msgid "" "Numpy call inside jitted function can be helpful if you are sure of the " "behavior is what you expect." -msgstr "" -"如果你确定numpy调用的行为是你期望的，那么在jit函数中调用numpy是有帮助的。" +msgstr "如果你确定numpy调用的行为是你期望的，那么在jit函数中调用numpy是有帮助的。" #: ../../source/sharpbits.rst:83 msgid "list append under if" @@ -84,37 +76,77 @@ msgid "" "Append something to a Python list within if whose condition is based on " "tensor values will lead to wrong results. Actually values of both branch " "will be attached to the list. See example below." -msgstr "" -"在if条件基于张量值的情况下，将内容附加到Python列表中会导致错误的结果。实际" -"上，两个分支的值都会被附加到列表中。参见下面的例子。" +msgstr "在if条件基于张量值的情况下，将内容附加到Python列表中会导致错误的结果。实际上，两个分支的值都会被附加到列表中。参见下面的例子。" #: ../../source/sharpbits.rst:108 msgid "" "The above code raise ``ConcretizationTypeError`` exception directly for " "Jax backend since Jax jit doesn't support tensor value if condition." -msgstr "" -"上面的代码直接为Jax后端引发了``ConcretizationTypeError``异常，因为Jax " -"jit不支持张量值if条件。" +msgstr "上面的代码直接为Jax后端引发了``ConcretizationTypeError``异常，因为Jax jit不支持张量值if条件。" #: ../../source/sharpbits.rst:110 msgid "Similarly, conditional gate application must be takend carefully." msgstr "类似地，必须小心地应用条件门。" #: ../../source/sharpbits.rst:145 +msgid "Tensor variables consistency" +msgstr "" + +#: ../../source/sharpbits.rst:148 +msgid "" +"All tensor variables' backend (tf vs jax vs ..), dtype (float vs " +"complex), shape and device (cpu vs gpu) must be compatible/consistent." +msgstr "" + +#: ../../source/sharpbits.rst:150 +msgid "Inspect the backend, dtype, shape and device using the following codes." +msgstr "" + +#: ../../source/sharpbits.rst:162 +msgid "" +"If the backend is inconsistent, one can convert the tensor backend via " +":py:meth:`tensorcircuit.interfaces.tensortrans.general_args_to_backend`." +msgstr "" + +#: ../../source/sharpbits.rst:173 +msgid "" +"If the dtype is inconsistent, one can convert the tensor dtype using " +"``tc.backend.cast``." +msgstr "" + +#: ../../source/sharpbits.rst:184 +msgid "" +"Also note the jax issue on float64/complex128, see `jax gotcha " +"`_." +msgstr "" + +#: ../../source/sharpbits.rst:186 +msgid "" +"If the shape is not consistent, one can convert the shape by " +"``tc.backend.reshape``." +msgstr "" + +#: ../../source/sharpbits.rst:188 +msgid "" +"If the device is not consistent, one can move the tensor between devices " +"by ``tc.backend.device_move``." +msgstr "" + +#: ../../source/sharpbits.rst:192 msgid "AD Consistency" msgstr "AD一致性" -#: ../../source/sharpbits.rst:147 +#: ../../source/sharpbits.rst:194 msgid "" "TF and JAX backend manage the differentiation rules differently for " "complex-valued function (actually up to a complex conjuagte). See issue " "discussion `tensorflow issue " "`_." msgstr "" -"TF和JAX后端对复值函数的微分规则的管理方式不同（实际上是复共轭）。参见讨论 " -"`tensorflow issue `_。" +"TF和JAX后端对复值函数的微分规则的管理方式不同（实际上是复共轭）。参见讨论 `tensorflow issue " +"`_。" -#: ../../source/sharpbits.rst:149 +#: ../../source/sharpbits.rst:196 msgid "" "In TensorCircuit, currently we make the difference in AD transparent, " "namely, when switching the backend, the AD behavior and result for " @@ -124,18 +156,18 @@ msgid "" "careful when dealing with AD on complex valued function in a backend " "agnostic way in TensorCircuit." msgstr "" -"在TensorCircuit中，我们目前使AD的差异透明，即在切换后端时，复值函数的AD行为" -"和结果可能不同，并由相应后端框架的本质行为决定。所有与AD相关的操作，如 " -"``grad`` 或者 ``jacrev`` 都可能受到影响。因此，用户在TensorCircuit中以后端" -"无关的方式处理复值函数的AD时必须小心。" +"在TensorCircuit中，我们目前使AD的差异透明，即在切换后端时，复值函数的AD行为和结果可能不同，并由相应后端框架的本质行为决定。所有与AD相关的操作，如" +" ``grad`` 或者 ``jacrev`` " +"都可能受到影响。因此，用户在TensorCircuit中以后端无关的方式处理复值函数的AD时必须小心。" -#: ../../source/sharpbits.rst:152 +#: ../../source/sharpbits.rst:199 msgid "" "See example script on computing Jacobian with different modes on " "different backends: `jacobian_cal.py `_. Also see the " "code below for a reference:" msgstr "" -"参考不同后端的不同模式下计算Jacobian的示例脚本：`jacobian_cal.py `_。" -"另外请参考下面的代码:" +"参考不同后端的不同模式下计算Jacobian的示例脚本：`jacobian_cal.py `_。另外请参考下面的代码:" + From 1f0ad290bbbc64b3e04c7e38b5402ad599119822 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 8 May 2023 11:34:06 +0800 Subject: [PATCH 431/725] add cotengra shortcut --- CHANGELOG.md | 6 + examples/training_deep_tunable_structures.py | 172 +++++++++++++++++++ tensorcircuit/cloud/apis.py | 12 +- tensorcircuit/cons.py | 26 +++ 4 files changed, 212 insertions(+), 4 deletions(-) create mode 100644 examples/training_deep_tunable_structures.py diff --git a/CHANGELOG.md b/CHANGELOG.md index b3789458..31acacf6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ ## Unreleased +### Added + +- Add `tc.TorchHardwarLayer` for shortcut layer construction of quantum hardware experiments + +- Add cotengra contractor setup shortcut + ### Changed - Add compiler and cloud namespace to the global tensorcircuit namespace diff --git a/examples/training_deep_tunable_structures.py b/examples/training_deep_tunable_structures.py new file mode 100644 index 00000000..9f084870 --- /dev/null +++ b/examples/training_deep_tunable_structures.py @@ -0,0 +1,172 @@ +""" +An integrated script demonstrating: +1. shortcut setup of cotengra contractor (with correct interplay with multiprocessing); +2. jit scan acceleration for deep structured circuit with multiple variables; +3. tensor controlled tunable circuit structures all in one jit; +4. batched trainable parameters via vmap/vvag; +and yet anonther demonstration of infras for training with incremental random activation +""" + +import time +import numpy as np +import jax +import optax +import tensorcircuit as tc + + +def main(): + tc.set_contractor("cotengra-40-64") + K = tc.set_backend("jax") + tc.set_dtype("complex128") + + ii = tc.gates._ii_matrix + xx = tc.gates._xx_matrix + yy = tc.gates._yy_matrix + zz = tc.gates._zz_matrix + + n = 12 + nlayers = 7 + g = tc.templates.graphs.Line1D(n) + ncircuits = 10 + heih = tc.quantum.heisenberg_hamiltonian( + g, hzz=1.0, hyy=1.0, hxx=1.0, hx=0, hy=0, hz=0 + ) + + def energy(params, structures, n, nlayers): + def one_layer(state, others): + params, structures = others + # print(state.shape, params.shape, structures.shape) + l = 0 + c = tc.Circuit(n, inputs=state) + for i in range(1, n, 2): + matrix = structures[3 * l, i] * ii + (1.0 - structures[3 * l, i]) * ( + K.cos(params[3 * l, i]) * ii + 1.0j * K.sin(params[3 * l, i]) * zz + ) + c.any( + i, + (i + 1) % n, + unitary=matrix, + ) + + ### YY + for i in range(1, n, 2): + matrix = structures[3 * l + 1, i] * ii + ( + 1.0 - structures[3 * l + 1, i] + ) * ( + K.cos(params[3 * l + 1, i]) * ii + + 1.0j * K.sin(params[3 * l + 1, i]) * yy + ) + c.any( + i, + (i + 1) % n, + unitary=matrix, + ) + + ### XX + for i in range(1, n, 2): + matrix = structures[3 * l + 2, i] * ii + ( + 1.0 - structures[3 * l + 2, i] + ) * ( + K.cos(params[3 * l + 2, i]) * ii + + 1.0j * K.sin(params[3 * l + 2, i]) * xx + ) + c.any( + i, + (i + 1) % n, + unitary=matrix, + ) + + ### Even layer + ### ZZ + for i in range(0, n, 2): + matrix = structures[3 * l, i] * ii + (1.0 - structures[3 * l, i]) * ( + K.cos(params[3 * l, i]) * ii + 1.0j * K.sin(params[3 * l, i]) * zz + ) + c.any( + i, + (i + 1) % n, + unitary=matrix, + ) + ### YY + + for i in range(0, n, 2): + matrix = structures[3 * l + 1, i] * ii + ( + 1.0 - structures[3 * l + 1, i] + ) * ( + K.cos(params[3 * l + 1, i]) * ii + + 1.0j * K.sin(params[3 * l + 1, i]) * yy + ) + c.any( + i, + (i + 1) % n, + unitary=matrix, + ) + + ### XX + for i in range(0, n, 2): + matrix = structures[3 * l + 2, i] * ii + ( + 1.0 - structures[3 * l + 2, i] + ) * ( + K.cos(params[3 * l + 2, i]) * ii + + 1.0j * K.sin(params[3 * l + 2, i]) * xx + ) + c.any( + i, + (i + 1) % n, + unitary=matrix, + ) + s = c.state() + return s, s + + params = K.cast(K.real(params), dtype="complex128") + structures = (K.sign(structures) + 1) / 2 # 0 or 1 + structures = K.cast(structures, dtype="complex128") + + c = tc.Circuit(n) + + for i in range(n): + c.x(i) + for i in range(0, n, 2): + c.H(i) + for i in range(0, n, 2): + c.cnot(i, i + 1) + s = c.state() + s, _ = jax.lax.scan( + one_layer, + s, + ( + K.reshape(params, [nlayers, 3, n]), + K.reshape(structures, [nlayers, 3, n]), + ), + ) + c = tc.Circuit(n, inputs=s) + # e = tc.templates.measurements.heisenberg_measurements( + # c, g, hzz=1, hxx=1, hyy=1, hx=0, hy=0, hz=0 + # ) + e = tc.templates.measurements.operator_expectation(c, heih) + return K.real(e) + + vagf = K.jit(K.vvag(energy, argnums=0, vectorized_argnums=0), static_argnums=(2, 3)) + + structures = tc.array_to_tensor( + np.random.uniform(low=0.0, high=1.0, size=[3 * nlayers, n]), dtype="complex128" + ) + structures -= 1.0 * K.ones([3 * nlayers, n]) + params = tc.array_to_tensor( + np.random.uniform(low=-0.1, high=0.1, size=[ncircuits, 3 * nlayers, n]), + dtype="float64", + ) + + # opt = K.optimizer(tf.keras.optimizers.Adam(1e-2)) + opt = K.optimizer(optax.adam(1e-2)) + + for _ in range(50): + time0 = time.time() + e, grads = vagf(params, structures, n, nlayers) + time1 = time.time() + params = opt.update(grads, params) + print(K.numpy(e), time1 - time0) + + +if __name__ == "__main__": + main() diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 1fa1a9be..8449ec74 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -205,10 +205,14 @@ def set_token( saved_token = {} if token is None: if cached and os.path.exists(authpath): - with open(authpath, "r") as f: - file_token = json.load(f) - file_token = {k: b64decode_s(v) for k, v in file_token.items()} - # file_token = backend.tree_map(b64decode_s, file_token) + try: + with open(authpath, "r") as f: + file_token = json.load(f) + file_token = {k: b64decode_s(v) for k, v in file_token.items()} + # file_token = backend.tree_map(b64decode_s, file_token) + except json.JSONDecodeError: + logger.warning("token file loading failure, set empty token instead") + file_token = {} else: file_token = {} file_token.update(saved_token) diff --git a/tensorcircuit/cons.py b/tensorcircuit/cons.py index c733d8e0..5c3fb78d 100644 --- a/tensorcircuit/cons.py +++ b/tensorcircuit/cons.py @@ -758,6 +758,32 @@ def set_contractor( method = "greedy" # auto for small size fallbacks to dp, which has bug for now # see: https://github.com/dgasmith/opt_einsum/issues/172 + if method.startswith("cotengra"): + # cotengra shortcut + import cotengra + + if method == "cotengra": + method = "custom" + optimizer = cotengra.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel=True, + minimize="combo", + max_time=30, + max_repeats=64, + progbar=True, + ) + else: # "cotengra-30-64" + _, mt, mr = method.split("-") + method = "custom" + optimizer = cotengra.ReusableHyperOptimizer( + methods=["greedy", "kahypar"], + parallel=True, + minimize="combo", + max_time=int(mt), + max_repeats=int(mr), + progbar=True, + ) + if method == "plain": cf = plain_contractor elif method == "plain-experimental": From 855852ca057454c8e0b00bf50f5599b593512be0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 9 May 2023 16:00:41 +0800 Subject: [PATCH 432/725] enhanced compile module --- CHANGELOG.md | 4 + docs/source/api/compiler.rst | 3 +- docs/source/api/compiler/simple_compiler.rst | 7 + tensorcircuit/compiler/__init__.py | 4 +- tensorcircuit/compiler/composed_compiler.py | 30 ++- tensorcircuit/compiler/qiskit_compiler.py | 21 +- tensorcircuit/compiler/simple_compiler.py | 246 +++++++++++++++++++ tests/test_compiler.py | 54 +++- 8 files changed, 360 insertions(+), 9 deletions(-) create mode 100644 docs/source/api/compiler/simple_compiler.rst create mode 100644 tensorcircuit/compiler/simple_compiler.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 31acacf6..78e726cf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,10 +8,14 @@ - Add cotengra contractor setup shortcut +- Add simplecompiler module to assite qiskit compile for better performance when targeting rz native basis + ### Changed - Add compiler and cloud namespace to the global tensorcircuit namespace +- Refactor composed compiler pipeline interface to include simple_compiler (breaking) + ## 0.9.0 ### Added diff --git a/docs/source/api/compiler.rst b/docs/source/api/compiler.rst index 43370b18..c83bc2bd 100644 --- a/docs/source/api/compiler.rst +++ b/docs/source/api/compiler.rst @@ -2,4 +2,5 @@ tensorcircuit.compiler ================================================== .. toctree:: compiler/composed_compiler.rst - compiler/qiskit_compiler.rst \ No newline at end of file + compiler/qiskit_compiler.rst + compiler/simple_compiler.rst \ No newline at end of file diff --git a/docs/source/api/compiler/simple_compiler.rst b/docs/source/api/compiler/simple_compiler.rst new file mode 100644 index 00000000..0578d8e5 --- /dev/null +++ b/docs/source/api/compiler/simple_compiler.rst @@ -0,0 +1,7 @@ +tensorcircuit.compiler.simple_compiler +================================================== +.. automodule:: tensorcircuit.compiler.simple_compiler + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/tensorcircuit/compiler/__init__.py b/tensorcircuit/compiler/__init__.py index 9d8f25a0..48fdb2b9 100644 --- a/tensorcircuit/compiler/__init__.py +++ b/tensorcircuit/compiler/__init__.py @@ -2,4 +2,6 @@ Experimental module, no software agnostic unified interface for now, only reserve for internal use """ -from .composed_compiler import Compiler, default_compiler +from .composed_compiler import Compiler, DefaultCompiler +from . import simple_compiler +from . import qiskit_compiler diff --git a/tensorcircuit/compiler/composed_compiler.py b/tensorcircuit/compiler/composed_compiler.py index 30c30057..034570b4 100644 --- a/tensorcircuit/compiler/composed_compiler.py +++ b/tensorcircuit/compiler/composed_compiler.py @@ -7,6 +7,7 @@ from ..utils import is_sequence from ..abstractcircuit import AbstractCircuit from .qiskit_compiler import qiskit_compile +from .simple_compiler import simple_compile class Compiler: @@ -36,8 +37,33 @@ def __call__( self, circuit: AbstractCircuit, info: Optional[Dict[str, Any]] = None ) -> Any: for f, d in zip(self.compile_funcs, self.compiled_options): - circuit, info = f(circuit, info, compiled_options=d) # type: ignore + result = f(circuit, info, compiled_options=d) # type: ignore + if not isinstance(result, tuple): + result = (result, None) + circuit, info = result return circuit, info -default_compiler = Compiler(qiskit_compile) +class DefaultCompiler(Compiler): + def __init__(self, qiskit_compiled_options: Optional[Dict[str, Any]] = None): + """ + A fallback choice to compile circuit running on tencent quantum cloud with rz as native gate + + :param qiskit_compiled_options: qiskit compiled options to be added + options documented in `qiskit.transpile` method, + to use tencent quantum cloud, `{"coupling_map": d.topology()}` is in general enough, + where d is a device object, + defaults to None, i.e. no qubit mapping is applied + :type qiskit_compiled_options: Optional[Dict[str, Any]], optional + """ + compiled_options = { + "optimization_level": 3, + "basis_gates": ["u3", "h", "cx", "cz"], + } + # rz target is bad for qiskit + if qiskit_compiled_options: + compiled_options.update(qiskit_compiled_options) + super().__init__( + [qiskit_compile, simple_compile], + [compiled_options, None], # type: ignore + ) diff --git a/tensorcircuit/compiler/qiskit_compiler.py b/tensorcircuit/compiler/qiskit_compiler.py index 9a56b5b4..e54dd1a4 100644 --- a/tensorcircuit/compiler/qiskit_compiler.py +++ b/tensorcircuit/compiler/qiskit_compiler.py @@ -22,7 +22,10 @@ def _free_pi(s: str) -> str: else: v = r[inc.start() : inc.end()] v = eval(v) - r = r[: inc.start()] + "(" + str(v) + ")" + r[inc.end() :] + if not isinstance(v, tuple): + r = r[: inc.start()] + "(" + str(v) + ")" + r[inc.end() :] + else: # u gate case + r = r[: inc.start()] + str(v) + r[inc.end() :] rs.append(r) return "\n".join(rs) @@ -120,6 +123,20 @@ def qiskit_compile( output: str = "tc", compiled_options: Optional[Dict[str, Any]] = None, ) -> Any: + """ + compile the circuit using ``qiskit.transpile`` method with some tricks and hacks + + :param circuit: circuit in ``tc.Circuit`` or ``qiskit.QuantumCircuit`` form + :type circuit: Any + :param info: info for qubit mappings, defaults to None + :type info: Optional[Dict[str, Any]], optional + :param output: output circuit format, defaults to "tc" + :type output: str, optional + :param compiled_options: ``qiskit.transpile`` options in a dict, defaults to None + :type compiled_options: Optional[Dict[str, Any]], optional + :return: Tuple containing the output circuit and the qubit mapping info dict + :rtype: Any + """ from qiskit.compiler import transpile from qiskit.transpiler.passes import RemoveBarriers @@ -132,7 +149,7 @@ def qiskit_compile( if compiled_options is None: compiled_options = { "basis_gates": ["h", "rz", "cx"], - "optimization_level": 2, + "optimization_level": 2, # 3 can induce bugs... } ncircuit = transpile(circuit, **compiled_options) ncircuit = RemoveBarriers()(ncircuit) diff --git a/tensorcircuit/compiler/simple_compiler.py b/tensorcircuit/compiler/simple_compiler.py new file mode 100644 index 00000000..a7616b20 --- /dev/null +++ b/tensorcircuit/compiler/simple_compiler.py @@ -0,0 +1,246 @@ +""" +Very simple transformations that qiskit may even fail or hard to control +""" + +from typing import Any, Dict, List, Optional, Tuple +from copy import copy + +import numpy as np + +from ..abstractcircuit import AbstractCircuit +from ..cons import backend +from ..quantum import QuOperator +from .. import gates +from ..utils import is_sequence + + +def replace_r(circuit: AbstractCircuit, **kws: Any) -> AbstractCircuit: + qir = circuit.to_qir() + c: Any = type(circuit)(**circuit.circuit_param) + for d in qir: + if "parameters" not in d: + c.apply_general_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( + c, *d["index"], split=d["split"] + ) + else: + if d["gatef"].n == "rx": + c.h(*d["index"]) + c.rz(*d["index"], theta=d["parameters"].get("theta", 0.0)) + c.h(*d["index"]) + + elif d["gatef"].n == "ry": + c.sd(*d["index"]) + c.h(*d["index"]) + c.rz(*d["index"], theta=d["parameters"].get("theta", 0.0)) + c.h(*d["index"]) + c.s(*d["index"]) + + elif d["gatef"].n == "rzz": + c.cx(*d["index"]) + c.rz(d["index"][1], theta=d["parameters"].get("theta", 0.0)) + c.cx(*d["index"]) + + elif d["gatef"].n == "rxx": + c.h(d["index"][0]) + c.h(d["index"][1]) + c.cx(*d["index"]) + c.rz(d["index"][1], theta=d["parameters"].get("theta", 0.0)) + c.cx(*d["index"]) + c.h(d["index"][0]) + c.h(d["index"][1]) + + elif d["gatef"].n == "ryy": + c.sd(d["index"][0]) + c.sd(d["index"][1]) + c.h(d["index"][0]) + c.h(d["index"][1]) + c.cx(*d["index"]) + c.rz(d["index"][1], theta=d["parameters"].get("theta", 0.0)) + c.cx(*d["index"]) + c.h(d["index"][0]) + c.h(d["index"][1]) + c.s(d["index"][0]) + c.s(d["index"][1]) + + else: + c.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], **d["parameters"], split=d["split"]) + + return c # type: ignore + + +def replace_u(circuit: AbstractCircuit, **kws: Any) -> AbstractCircuit: + qir = circuit.to_qir() + c: Any = type(circuit)(**circuit.circuit_param) + for d in qir: + if "parameters" not in d: + c.apply_general_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( + c, *d["index"], split=d["split"] + ) + else: + if d["gatef"].n == "u": + c.rz(*d["index"], theta=d["parameters"].get("lbd", 0) - np.pi / 2) + c.h(*d["index"]) + c.rz(*d["index"], theta=d["parameters"].get("theta", 0)) + c.h(*d["index"]) + c.rz(*d["index"], theta=np.pi / 2 + d["parameters"].get("phi", 0)) + else: + c.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], **d["parameters"], split=d["split"]) + + return c # type: ignore + + +def prune( + circuit: AbstractCircuit, rtol: float = 1e-3, atol: float = 1e-3, **kws: Any +) -> AbstractCircuit: + qir = circuit.to_qir() + c = type(circuit)(**circuit.circuit_param) + for d in qir: + if isinstance(d["gate"], QuOperator): + m = backend.numpy(d["gate"].eval_matrix()) + else: + m = backend.numpy(backend.reshapem(d["gate"].tensor)) + if not np.allclose( + m / (m[0, 0] + 1e-8), np.eye(m.shape[0]), rtol=rtol, atol=atol + ): + # upto a phase + if "parameters" not in d: + c.apply_general_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( + c, *d["index"], split=d["split"] + ) + else: + c.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], **d["parameters"], split=d["split"]) + + return c + + +# upto global phase +default_merge_rules = { + ("s", "s"): "z", + ("sd", "sd"): "z", + ("t", "t"): "s", + ("td", "td"): "sd", + ("x", "y"): "z", + ("y", "x"): "z", + ("x", "z"): "y", + ("z", "x"): "y", + ("z", "y"): "x", + ("y", "z"): "x", + ("x", "x"): "i", + ("y", "y"): "i", + ("z", "z"): "i", + ("h", "h"): "i", + ("rz", "rz"): "rz", + ("rx", "rx"): "rx", + ("ry", "ry"): "rx", + ("rzz", "rzz"): "rzz", + ("rxx", "rxx"): "rxx", + ("ryy", "ryy"): "ryy", + ("crz", "crz"): "crz", + ("crx", "crx"): "crx", + ("cry", "cry"): "crx", + ("cnot", "cnot"): "i", + ("cz", "cz"): "i", + ("cy", "cy"): "i", +} + + +def _find_next(qir: List[Dict[str, Any]], i: int) -> Optional[int]: + index = qir[i]["index"] + for j, item in enumerate(qir[i + 1 :]): + if item["index"] == index: + return j + i + 1 + for ind in item["index"]: + if ind in index: + return None + return None + + +def _get_theta(qir_item: Dict[str, Any]) -> float: + theta = qir_item["parameters"].get("theta", 0.0) + if is_sequence(theta) and len(theta) == 1: + return theta[0] # type: ignore + return theta # type: ignore + + +def _merge( + qir: List[Dict[str, Any]], rules: Dict[Tuple[str, ...], str] +) -> Tuple[List[Dict[str, Any]], bool]: + i = 0 + while i < len(qir) - 1: + j = _find_next(qir, i) + + if j is not None: + if (qir[i]["gatef"].n, qir[j]["gatef"].n) in rules: + nn = rules[(qir[i]["gatef"].n, qir[j]["gatef"].n)] + if nn == "i": + del qir[i] + del qir[j - 1] + else: + param = {} + if nn.startswith("r") or nn.startswith("cr"): + param = {"theta": _get_theta(qir[i]) + _get_theta(qir[j])} + qir[i] = { + "gatef": getattr(gates, nn), + "name": nn, + "mpo": False, + "split": False, + "parameters": param, + "index": qir[i]["index"], + } + del qir[j] + return qir, True + elif ( + qir[i]["gatef"].n == qir[j]["gatef"].n + "d" + or qir[i]["gatef"].n + "d" == qir[j]["gatef"].n + ): + del qir[i] + del qir[j - 1] + return qir, True + i += 1 + return qir, False + + +def merge( + circuit: AbstractCircuit, + rules: Optional[Dict[Tuple[str, ...], str]] = None, + **kws: Any +) -> AbstractCircuit: + merge_rules = copy(default_merge_rules) + if rules is not None: + merge_rules.update(rules) # type: ignore + + qir = circuit.to_qir() + flg = True + while flg: + qir, flg = _merge(qir, merge_rules) # type: ignore + c = type(circuit).from_qir(qir, circuit.circuit_param) + return c + + +def simple_compile( + circuit: Any, + info: Optional[Dict[str, Any]] = None, + output: str = "tc", + compiled_options: Optional[Dict[str, Any]] = None, +) -> Any: + if compiled_options is None: + compiled_options = {} + c = replace_r(circuit, **compiled_options) + c = replace_u(circuit, **compiled_options) + qasm = c.to_openqasm() + c = merge(c, **compiled_options) + c = prune(c, **compiled_options) + qasm1 = c.to_openqasm() + while qasm1 != qasm: + qasm = qasm1 + c = merge(c, **compiled_options) + c = prune(c, **compiled_options) + qasm1 = c.to_openqasm() + + return (c, info) diff --git a/tests/test_compiler.py b/tests/test_compiler.py index 6559b476..5b297289 100644 --- a/tests/test_compiler.py +++ b/tests/test_compiler.py @@ -1,6 +1,7 @@ import sys import os import pytest +import numpy as np # from pytest_lazyfixture import lazy_fixture as lf @@ -73,7 +74,7 @@ def test_qsikit_compiler(): def test_composed_compiler(): - from tensorcircuit.compiler import default_compiler + from tensorcircuit.compiler import DefaultCompiler c = tc.Circuit(3) c.rx(0) @@ -82,18 +83,65 @@ def test_composed_compiler(): c.rxx(0, 2, theta=0.2) c.measure_instruction(2) c.measure_instruction(0) + default_compiler = DefaultCompiler() c1, info = default_compiler(c) print(c1.draw()) - assert c1.gate_count_by_condition(lambda qir: qir["name"] == "cnot") == 4 + assert c1.gate_count_by_condition(lambda qir: qir["name"] == "cnot") == 3 assert info["positional_logical_mapping"][0] == 2 - default_compiler.add_options( + default_compiler = DefaultCompiler( { "basis_gates": ["h", "rz", "cz"], "optimization_level": 2, "coupling_map": [[0, 1], [1, 2]], } ) + c1, info = default_compiler(c) assert c1.gate_count_by_condition(lambda qir: qir["name"] == "cnot") == 0 print(info) + + +def test_replace_r(): + c = tc.Circuit(3) + c.rz(0, theta=0.1) + c.cx(0, 2) + c.ry(1) + c.rxx(1, 0, theta=0.2) + c.rx(0, theta=3.9) + c.ry(1, theta=-0.2) + c.rzz(1, 0, theta=-0.3) + c.ryy(1, 0, theta=-0.6) + c.rx(2) + + print(c.draw()) + c1 = tc.compiler.simple_compiler.replace_r(c) + print(c1.draw()) + np.testing.assert_allclose(c.matrix(), c1.matrix(), atol=1e-5) + + +def test_default_compiler(): + c = tc.Circuit(3) + c.cx(0, 1) + c.rx(0, theta=1e-5) + c.x(1) + c.y(1) + c.z(1) + c.h(1) + c.cz(2, 0) + c.h(1) + c.cz(2, 0) + c.s(2) + c.sd(2) + c.s(2) + c.s(2) + c.y(2) + c.ry(2, theta=0.1) + c.t(2) + c.td(2) + c.ry(2, theta=-0.1) + c.rz(1, theta=0.3) + + c1, _ = tc.compiler.simple_compiler.simple_compile(c) + print(c1.draw()) + assert c1.gate_count() == 3 From 72913b18e1bc5921717d4a46ebbb3fd1d592ca94 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 9 May 2023 19:24:25 +0800 Subject: [PATCH 433/725] add compiler example --- examples/circuit_compiler.py | 77 +++++++++++++++++++++ tensorcircuit/cloud/wrapper.py | 5 +- tensorcircuit/compiler/composed_compiler.py | 11 ++- 3 files changed, 88 insertions(+), 5 deletions(-) create mode 100644 examples/circuit_compiler.py diff --git a/examples/circuit_compiler.py b/examples/circuit_compiler.py new file mode 100644 index 00000000..349eac9a --- /dev/null +++ b/examples/circuit_compiler.py @@ -0,0 +1,77 @@ +""" +compilation utilities in tensorcircuit +""" + +import tensorcircuit as tc + + +c = tc.Circuit(3) +c.rx(0, theta=0.2) +c.rz(0, theta=-0.3) +c.ry(1, theta=0.1) +c.h(2) +c.cx(0, 1) +c.cz(2, 1) +c.x(0) +c.y(0) +c.rxx(1, 2, theta=1.7) + + +c0, _ = tc.compiler.qiskit_compiler.qiskit_compile( + c, + compiled_options={"optimization_level": 0, "basis_gates": ["cx", "cz", "h", "rz"]}, +) + +c1, _ = tc.compiler.qiskit_compiler.qiskit_compile( + c, + compiled_options={"optimization_level": 1, "basis_gates": ["cx", "cz", "h", "rz"]}, +) + + +c2, _ = tc.compiler.qiskit_compiler.qiskit_compile( + c, + compiled_options={"optimization_level": 2, "basis_gates": ["cx", "cz", "h", "rz"]}, +) + + +c3, _ = tc.compiler.qiskit_compiler.qiskit_compile( + c, + compiled_options={"optimization_level": 3, "basis_gates": ["cx", "cz", "h", "rz"]}, +) + +print( + "qiskit can become worse with higher level optimization when the target gate is not U3 but rz" +) +print("level 0:\n") +print(c0.draw()) +print("level 1:\n") +print(c1.draw()) +print("level 2:\n") +print(c2.draw()) +print("level 3:\n") +print(c3.draw()) + + +compiler_wo_mapping = tc.compiler.DefaultCompiler() +c4, _ = compiler_wo_mapping(c) +print( + "compiled with tc default compiler: combining the good from qiskit and our tc own" +) +# we always uuggest using DefaultCompiler for tasks on qcloud +# internally we run optimized compiling using U3 basis with qiskit which has good performance +# and we unroll u3 with rz and apply replace/prune/merge loop developed in tc to further optimize the circuit +print(c4.draw()) + +print("gate number comparison (last ours vs before qiskit (0, 1, 2, 3))") +for c in [c0, c1, c2, c3, c4]: + print(c.gate_count()) + +# if we want to apply routing/qubit mapping + +compiler_w_mapping = tc.compiler.DefaultCompiler( + {"coupling_map": [[0, 2], [2, 0], [1, 0], [0, 1]]} +) +c5, info = compiler_w_mapping(c) +print("circuit with qubit mapping") +print(c5.draw()) +print(info) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 68a396f9..6e1d720f 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -154,12 +154,13 @@ def batch_expectation_ps( c1, info = qiskit_compile( c1, compiled_options={ - "basis_gates": device.native_gates(), + "basis_gates": device.native_gates() + ["cx"], # whether + "cx" here? - "optimization_level": 3, + "optimization_level": 2, "coupling_map": device.topology(), }, ) + # change the compiler to DefaultCompiler when it matures cs.append(c1) infos.append(info) exps.append(exp) diff --git a/tensorcircuit/compiler/composed_compiler.py b/tensorcircuit/compiler/composed_compiler.py index 034570b4..c89fd90e 100644 --- a/tensorcircuit/compiler/composed_compiler.py +++ b/tensorcircuit/compiler/composed_compiler.py @@ -25,13 +25,18 @@ def __init__( def add_options( self, compiled_options: Optional[List[Dict[str, Any]]] = None ) -> None: - if not is_sequence(compiled_options): - self.compiled_options = [compiled_options for _ in self.compile_funcs] + if compiled_options is None: + self.compiled_options = [{} for _ in range(len(self.compile_funcs))] # type: ignore + elif not is_sequence(compiled_options): + self.compiled_options = [compiled_options for _ in self.compile_funcs] # type: ignore else: assert len(compiled_options) == len( # type: ignore self.compile_funcs ), "`compiled_options` must have the same list length as `compile_funcs`" self.compiled_options = list(compiled_options) # type: ignore + for i, c in enumerate(self.compiled_options): + if c is None: + self.compiled_options[i] = {} def __call__( self, circuit: AbstractCircuit, info: Optional[Dict[str, Any]] = None @@ -39,7 +44,7 @@ def __call__( for f, d in zip(self.compile_funcs, self.compiled_options): result = f(circuit, info, compiled_options=d) # type: ignore if not isinstance(result, tuple): - result = (result, None) + result = (result, info) circuit, info = result return circuit, info From f2e18f423a194a0791b367d57d93f4390f6d3f59 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 9 May 2023 20:10:05 +0800 Subject: [PATCH 434/725] update changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 78e726cf..e2d0c5d5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,7 +14,7 @@ - Add compiler and cloud namespace to the global tensorcircuit namespace -- Refactor composed compiler pipeline interface to include simple_compiler (breaking) +- Refactor composed compiler pipeline interface to include simple_compiler, using `DefaultCompiler` for now (breaking) ## 0.9.0 From f7e3cba875d14db4f8980f8eb7e46167e9e4b10e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 10 May 2023 15:57:19 +0800 Subject: [PATCH 435/725] refactor simple compiler to reduce more than half of the compiling time --- tensorcircuit/compiler/__init__.py | 2 +- tensorcircuit/compiler/composed_compiler.py | 12 +- tensorcircuit/compiler/simple_compiler.py | 135 ++++++++++++++------ 3 files changed, 106 insertions(+), 43 deletions(-) diff --git a/tensorcircuit/compiler/__init__.py b/tensorcircuit/compiler/__init__.py index 48fdb2b9..43f92b99 100644 --- a/tensorcircuit/compiler/__init__.py +++ b/tensorcircuit/compiler/__init__.py @@ -2,6 +2,6 @@ Experimental module, no software agnostic unified interface for now, only reserve for internal use """ -from .composed_compiler import Compiler, DefaultCompiler +from .composed_compiler import Compiler, DefaultCompiler, default_compile from . import simple_compiler from . import qiskit_compiler diff --git a/tensorcircuit/compiler/composed_compiler.py b/tensorcircuit/compiler/composed_compiler.py index c89fd90e..d49c4fe4 100644 --- a/tensorcircuit/compiler/composed_compiler.py +++ b/tensorcircuit/compiler/composed_compiler.py @@ -2,7 +2,7 @@ object oriented compiler pipeline """ -from typing import Any, Callable, Dict, List, Optional, Union +from typing import Any, Callable, Dict, List, Optional, Tuple, Union from ..utils import is_sequence from ..abstractcircuit import AbstractCircuit @@ -72,3 +72,13 @@ def __init__(self, qiskit_compiled_options: Optional[Dict[str, Any]] = None): [qiskit_compile, simple_compile], [compiled_options, None], # type: ignore ) + + +def default_compile( + circuit: AbstractCircuit, + info: Optional[Dict[str, Any]] = None, + compiled_options: Optional[Dict[str, Any]] = None, +) -> Tuple[AbstractCircuit, Dict[str, Any]]: + dc = DefaultCompiler(compiled_options) + c, info = dc(circuit, info) + return c, info # type: ignore diff --git a/tensorcircuit/compiler/simple_compiler.py b/tensorcircuit/compiler/simple_compiler.py index a7616b20..a10d422d 100644 --- a/tensorcircuit/compiler/simple_compiler.py +++ b/tensorcircuit/compiler/simple_compiler.py @@ -2,7 +2,7 @@ Very simple transformations that qiskit may even fail or hard to control """ -from typing import Any, Dict, List, Optional, Tuple +from typing import Any, Dict, List, Optional, Tuple, Union from copy import copy import numpy as np @@ -93,30 +93,61 @@ def replace_u(circuit: AbstractCircuit, **kws: Any) -> AbstractCircuit: return c # type: ignore +def _get_matrix(qir_item: Dict[str, Any]) -> Any: + if "gate" in qir_item: + op = qir_item["gate"] + else: + op = qir_item["gatef"](**qir_item["parameters"]) + if isinstance(op, QuOperator): + m = backend.numpy(op.eval_matrix()) + else: + m = backend.numpy(backend.reshapem(op.tensor)) + return m + + def prune( - circuit: AbstractCircuit, rtol: float = 1e-3, atol: float = 1e-3, **kws: Any -) -> AbstractCircuit: - qir = circuit.to_qir() - c = type(circuit)(**circuit.circuit_param) - for d in qir: - if isinstance(d["gate"], QuOperator): - m = backend.numpy(d["gate"].eval_matrix()) - else: - m = backend.numpy(backend.reshapem(d["gate"].tensor)) - if not np.allclose( - m / (m[0, 0] + 1e-8), np.eye(m.shape[0]), rtol=rtol, atol=atol - ): - # upto a phase - if "parameters" not in d: - c.apply_general_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( - c, *d["index"], split=d["split"] - ) - else: - c.apply_general_variable_gate_delayed( - d["gatef"], d["name"], mpo=d["mpo"] - )(c, *d["index"], **d["parameters"], split=d["split"]) + circuit: Union[AbstractCircuit, List[Dict[str, Any]]], + rtol: float = 1e-3, + atol: float = 1e-3, + **kws: Any +) -> Any: + if isinstance(circuit, list): + qir = circuit + output = "qir" + else: + qir = circuit.to_qir() + output = "tc" + if output in ["tc", "circuit"]: + c: Any = type(circuit)(**circuit.circuit_param) # type: ignore + for d in qir: + m = _get_matrix(d) + + if not np.allclose( + m / (m[0, 0] + 1e-8), np.eye(m.shape[0]), rtol=rtol, atol=atol + ): + # upto a phase + if "parameters" not in d: + c.apply_general_gate_delayed(d["gatef"], d["name"], mpo=d["mpo"])( + c, *d["index"], split=d["split"] + ) + else: + c.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], **d["parameters"], split=d["split"]) + return c + + elif output in ["qir"]: + nqir = [] + for d in qir: + m = _get_matrix(d) + + if not np.allclose( + m / (m[0, 0] + 1e-8), np.eye(m.shape[0]), rtol=rtol, atol=atol + ): + nqir.append(d) + # upto a phase - return c + return nqir # upto global phase @@ -151,8 +182,11 @@ def prune( def _find_next(qir: List[Dict[str, Any]], i: int) -> Optional[int]: + # if qir[i] is None: + # return None index = qir[i]["index"] for j, item in enumerate(qir[i + 1 :]): + # if item is not None: if item["index"] == index: return j + i + 1 for ind in item["index"]: @@ -172,6 +206,7 @@ def _merge( qir: List[Dict[str, Any]], rules: Dict[Tuple[str, ...], str] ) -> Tuple[List[Dict[str, Any]], bool]: i = 0 + flg = False while i < len(qir) - 1: j = _find_next(qir, i) @@ -181,6 +216,8 @@ def _merge( if nn == "i": del qir[i] del qir[j - 1] + # qir[i] = None + # qir[j] = None else: param = {} if nn.startswith("r") or nn.startswith("cr"): @@ -194,33 +231,45 @@ def _merge( "index": qir[i]["index"], } del qir[j] - return qir, True + # qir[j] = None + flg = True + # return qir, flg elif ( qir[i]["gatef"].n == qir[j]["gatef"].n + "d" or qir[i]["gatef"].n + "d" == qir[j]["gatef"].n ): del qir[i] del qir[j - 1] - return qir, True + # qir[i] = None + # qir[j] = None + flg = True + # return qir, True i += 1 - return qir, False + return qir, flg def merge( - circuit: AbstractCircuit, + circuit: Union[AbstractCircuit, List[Dict[str, Any]]], rules: Optional[Dict[Tuple[str, ...], str]] = None, **kws: Any -) -> AbstractCircuit: +) -> Any: merge_rules = copy(default_merge_rules) if rules is not None: merge_rules.update(rules) # type: ignore - - qir = circuit.to_qir() + if isinstance(circuit, list): + qir = circuit + output = "qir" + else: + qir = circuit.to_qir() + output = "tc" flg = True while flg: qir, flg = _merge(qir, merge_rules) # type: ignore - c = type(circuit).from_qir(qir, circuit.circuit_param) - return c + if output in ["qir"]: + return qir + elif output in ["tc", "circuit"]: + c: Any = type(circuit).from_qir(qir, circuit.circuit_param) # type: ignore + return c def simple_compile( @@ -233,14 +282,18 @@ def simple_compile( compiled_options = {} c = replace_r(circuit, **compiled_options) c = replace_u(circuit, **compiled_options) - qasm = c.to_openqasm() - c = merge(c, **compiled_options) - c = prune(c, **compiled_options) - qasm1 = c.to_openqasm() - while qasm1 != qasm: - qasm = qasm1 - c = merge(c, **compiled_options) - c = prune(c, **compiled_options) - qasm1 = c.to_openqasm() + qir = c.to_qir() + len0 = len(qir) + qir = merge(qir, **compiled_options) + qir = prune(qir, **compiled_options) + len1 = len(qir) + while len1 != len0: + len0 = len1 + qir = merge(qir, **compiled_options) + if len(qir) == len0: + break + qir = prune(qir, **compiled_options) + len1 = len(qir) + c = type(circuit).from_qir(qir, circuit.circuit_param) return (c, info) From a17c85ef1037f2710f3f982a27b5985b67590fd1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 10 May 2023 17:10:03 +0800 Subject: [PATCH 436/725] replace compiling engine in batch_expectation_ps with default_compiler --- tensorcircuit/cloud/wrapper.py | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 6e1d720f..ef8c21bc 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -13,7 +13,7 @@ from ..utils import is_sequence from ..cons import backend from ..quantum import ps2xyz -from ..compiler.qiskit_compiler import qiskit_compile +from ..compiler import DefaultCompiler from .apis import submit_task, get_device from .abstraction import Device @@ -137,6 +137,12 @@ def batch_expectation_ps( exps = [] if isinstance(device, str): device = get_device(device) + + dc = DefaultCompiler( + { + "coupling_map": device.topology(), + } + ) for ps in pss: # TODO(@refraction-ray): Pauli string grouping # https://docs.pennylane.ai/en/stable/_modules/pennylane/pauli/grouping/group_observables.html @@ -151,16 +157,8 @@ def batch_expectation_ps( exp.append(j) elif i == 3: exp.append(j) - c1, info = qiskit_compile( - c1, - compiled_options={ - "basis_gates": device.native_gates() + ["cx"], - # whether + "cx" here? - "optimization_level": 2, - "coupling_map": device.topology(), - }, - ) - # change the compiler to DefaultCompiler when it matures + c1, info = dc(c1) + # TODO(@refraction-ray): two steps compiling with pre compilation cs.append(c1) infos.append(info) exps.append(exp) From d1e1ef83e60d1185456e1645d254c8b8df4bed66 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 10 May 2023 21:16:07 +0800 Subject: [PATCH 437/725] update doc index --- docs/source/conf.py | 1 + docs/source/index.rst | 28 +++++++++++++++++++--------- 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/docs/source/conf.py b/docs/source/conf.py index 8b057226..181dda0e 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -146,6 +146,7 @@ # Output file base name for HTML help builder. htmlhelp_basename = "tensorcircuitdoc" +html_title = "TensorCircuit Documentation" # -- Options for LaTeX output ------------------------------------------------ diff --git a/docs/source/index.rst b/docs/source/index.rst index d8958657..01a4a22c 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,31 +1,41 @@ -Guide to TensorCircuit -================================== +TensorCircuit Documentation +=========================================================== .. image:: https://github.com/tencent-quantum-lab/tensorcircuit/blob/master/docs/source/statics/logov2.jpg?raw=true :target: https://github.com/tencent-quantum-lab/tensorcircuit -TensorCircuit is an open source quantum circuit and algorithm simulation framework. -* It is built for human beings. 👽 +**Welcome and congratulations! You have found TensorCircuit.** 👏 + +TensorCircuit is an open-source high-performance quantum computing software framework in Python. + +* It is built for humans. 👽 * It is designed for speed, flexibility and elegance. 🚀 * It is empowered by advanced tensor network simulator engine. 🔋 -* It is ready for quantum hardware access with CPU/GPU/QPU hybrid deployment solutions. 🖥 +* It is ready for quantum hardware access with CPU/GPU/QPU (local/cloud) hybrid solutions. 🖥 * It is implemented with industry-standard machine learning frameworks: TensorFlow, JAX, and PyTorch. 🤖 * It is compatible with machine learning engineering paradigms: automatic differentiation, just-in-time compilation, vectorized parallelism and GPU acceleration. 🛠 +With the help of TensorCircuit, now get ready to efficiently and elegantly solve interesting and challenging quantum computing problems from academic research prototype to industry application deployment. + + -Links ----------- +Relevant Links +-------------------- + +TensorCircuit is created and maintained by `Shi-Xin Zhang `_ and this version is released by `Tencent Quantum Lab `_. -TensorCircuit is created and maintained by `Shi-Xin Zhang `_ and this version of the software is released by `Tencent Quantum Lab `_. The current core authors of TensorCircuit are `Shi-Xin Zhang `_ and `Yu-Qin Chen `_. We also thank `contributions `_ from the lab and the open source community. +If you have any further questions or collaboration ideas, please use the issue tracker or forum below, or send email to shixinzhang#tencent.com. + + * Source code: https://github.com/tencent-quantum-lab/tensorcircuit * Documentation: https://tensorcircuit.readthedocs.io @@ -44,7 +54,7 @@ We also thank `contributions Date: Wed, 10 May 2023 22:09:03 +0800 Subject: [PATCH 438/725] update readme and add cn doc index --- README.md | 4 +- README_cn.md | 4 +- docs/source/locale/zh/LC_MESSAGES/api.po | 58 ++++++++- docs/source/locale/zh/LC_MESSAGES/index.po | 130 ++++++++++++--------- 4 files changed, 141 insertions(+), 55 deletions(-) diff --git a/README.md b/README.md index 412b10d9..0795945e 100644 --- a/README.md +++ b/README.md @@ -105,7 +105,9 @@ We also have [Docker support](/docker). - Tensor network simulation engine based -- JIT, AD, vectorized parallelism compatible, GPU support +- JIT, AD, vectorized parallelism compatible + +- GPU support, quantum device access support, hybrid deployment support - Efficiency diff --git a/README_cn.md b/README_cn.md index f85108e6..bc49327d 100644 --- a/README_cn.md +++ b/README_cn.md @@ -103,7 +103,9 @@ pip install tensorcircuit-nightly - 基于张量网络模拟引擎 -- 即时编译、自动微分、向量并行化兼容，GPU 支持 +- 即时编译、自动微分、向量并行化兼容 + +- GPU 支持、量子硬件支持、混合部署方案支持 - 效率 diff --git a/docs/source/locale/zh/LC_MESSAGES/api.po b/docs/source/locale/zh/LC_MESSAGES/api.po index d3e040dd..c3ed832b 100644 --- a/docs/source/locale/zh/LC_MESSAGES/api.po +++ b/docs/source/locale/zh/LC_MESSAGES/api.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-05-07 10:47+0800\n" +"POT-Creation-Date: 2023-05-10 22:01+0800\n" "PO-Revision-Date: 2022-04-13 14:58+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -587,6 +587,8 @@ msgstr "" #: tensorcircuit.cloud.apis.submit_task tensorcircuit.cloud.tencent.submit_task #: tensorcircuit.cloud.utils.set_proxy #: tensorcircuit.cloud.wrapper.batch_expectation_ps +#: tensorcircuit.compiler.composed_compiler.DefaultCompiler.__init__ +#: tensorcircuit.compiler.qiskit_compiler.qiskit_compile #: tensorcircuit.cons.get_contractor tensorcircuit.cons.get_dtype #: tensorcircuit.cons.plain_contractor tensorcircuit.cons.runtime_backend #: tensorcircuit.cons.runtime_dtype tensorcircuit.cons.set_contractor @@ -1526,6 +1528,7 @@ msgstr "" #: tensorcircuit.cloud.apis.submit_task tensorcircuit.cloud.tencent.submit_task #: tensorcircuit.cloud.utils.set_proxy #: tensorcircuit.cloud.wrapper.batch_expectation_ps +#: tensorcircuit.compiler.qiskit_compiler.qiskit_compile #: tensorcircuit.cons.get_contractor tensorcircuit.cons.get_dtype #: tensorcircuit.cons.plain_contractor tensorcircuit.cons.set_contractor #: tensorcircuit.cons.set_dtype tensorcircuit.cons.set_function_backend @@ -2307,6 +2310,7 @@ msgstr "" #: tensorcircuit.cloud.apis.set_provider tensorcircuit.cloud.apis.set_token #: tensorcircuit.cloud.apis.submit_task tensorcircuit.cloud.tencent.submit_task #: tensorcircuit.cloud.wrapper.batch_expectation_ps +#: tensorcircuit.compiler.qiskit_compiler.qiskit_compile #: tensorcircuit.cons.get_contractor tensorcircuit.cons.get_dtype #: tensorcircuit.cons.plain_contractor tensorcircuit.cons.runtime_backend #: tensorcircuit.cons.runtime_contractor tensorcircuit.cons.runtime_dtype @@ -14324,6 +14328,24 @@ msgstr "" msgid "object oriented compiler pipeline" msgstr "" +#: of tensorcircuit.compiler.composed_compiler.DefaultCompiler:1 +msgid "Bases: :py:class:`~tensorcircuit.compiler.composed_compiler.Compiler`" +msgstr "" + +#: of tensorcircuit.compiler.composed_compiler.DefaultCompiler.__init__:1 +msgid "" +"A fallback choice to compile circuit running on tencent quantum cloud " +"with rz as native gate" +msgstr "" + +#: of tensorcircuit.compiler.composed_compiler.DefaultCompiler.__init__:3 +msgid "" +"qiskit compiled options to be added options documented in " +"`qiskit.transpile` method, to use tencent quantum cloud, " +"`{\"coupling_map\": d.topology()}` is in general enough, where d is a " +"device object, defaults to None, i.e. no qubit mapping is applied" +msgstr "" + #: ../../source/api/compiler/qiskit_compiler.rst:2 msgid "tensorcircuit.compiler.qiskit_compiler" msgstr "" @@ -14332,6 +14354,40 @@ msgstr "" msgid "compiler interface via qiskit" msgstr "" +#: of tensorcircuit.compiler.qiskit_compiler.qiskit_compile:1 +msgid "" +"compile the circuit using ``qiskit.transpile`` method with some tricks " +"and hacks" +msgstr "" + +#: of tensorcircuit.compiler.qiskit_compiler.qiskit_compile:3 +msgid "circuit in ``tc.Circuit`` or ``qiskit.QuantumCircuit`` form" +msgstr "" + +#: of tensorcircuit.compiler.qiskit_compiler.qiskit_compile:5 +msgid "info for qubit mappings, defaults to None" +msgstr "" + +#: of tensorcircuit.compiler.qiskit_compiler.qiskit_compile:7 +msgid "output circuit format, defaults to \"tc\"" +msgstr "" + +#: of tensorcircuit.compiler.qiskit_compiler.qiskit_compile:9 +msgid "``qiskit.transpile`` options in a dict, defaults to None" +msgstr "" + +#: of tensorcircuit.compiler.qiskit_compiler.qiskit_compile:11 +msgid "Tuple containing the output circuit and the qubit mapping info dict" +msgstr "" + +#: ../../source/api/compiler/simple_compiler.rst:2 +msgid "tensorcircuit.compiler.simple_compiler" +msgstr "" + +#: of tensorcircuit.compiler.simple_compiler:1 +msgid "Very simple transformations that qiskit may even fail or hard to control" +msgstr "" + #: ../../source/api/cons.rst:2 msgid "tensorcircuit.cons" msgstr "" diff --git a/docs/source/locale/zh/LC_MESSAGES/index.po b/docs/source/locale/zh/LC_MESSAGES/index.po index b16d6b4b..ce4c9beb 100644 --- a/docs/source/locale/zh/LC_MESSAGES/index.po +++ b/docs/source/locale/zh/LC_MESSAGES/index.po @@ -8,8 +8,8 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-05-07 10:47+0800\n" -"PO-Revision-Date: 2023-05-07 11:00+0800\n" +"POT-Creation-Date: 2023-05-10 22:01+0800\n" +"PO-Revision-Date: 2023-05-10 22:06+0800\n" "Last-Translator: Xinghan Yang\n" "Language-Team: \n" "Language: cn\n" @@ -20,70 +20,98 @@ msgstr "" "X-Generator: Poedit 3.2.2\n" #: ../../source/index.rst:2 -msgid "Guide to TensorCircuit" -msgstr "TensorCircuit 指南" +#, fuzzy +msgid "TensorCircuit Documentation" +msgstr "参考文档" + +#: ../../source/index.rst:8 +msgid "**Welcome and congratulations! You have found TensorCircuit.** 👏" +msgstr "**祝贺你发现了 TensorCircuit！** 👏" -#: ../../source/index.rst:7 +#: ../../source/index.rst:10 msgid "" -"TensorCircuit is an open source quantum circuit and algorithm simulation " -"framework." -msgstr "TensorCircuit 是开源的量子线路和量子算法模拟软件框架。" +"TensorCircuit is an open-source high-performance quantum computing software " +"framework in Python." +msgstr "TensorCircuit 是 Python 编写的开源高性能量子计算软件框架。" -#: ../../source/index.rst:9 -msgid "It is built for human beings. 👽" +#: ../../source/index.rst:12 +#, fuzzy +msgid "It is built for humans. 👽" msgstr "适合人类。👽" -#: ../../source/index.rst:11 +#: ../../source/index.rst:14 msgid "It is designed for speed, flexibility and elegance. 🚀" msgstr "速度，灵活，优雅。🚀" -#: ../../source/index.rst:13 +#: ../../source/index.rst:16 msgid "It is empowered by advanced tensor network simulator engine. 🔋" msgstr "先进张量网络引擎赋能。🔋" -#: ../../source/index.rst:15 +#: ../../source/index.rst:18 +#, fuzzy msgid "" -"It is ready for quantum hardware access with CPU/GPU/QPU hybrid deployment " +"It is ready for quantum hardware access with CPU/GPU/QPU (local/cloud) hybrid " "solutions. 🖥" msgstr "量子硬件支持，优雅 CPU/GPU/QPU 混合部署方案。 🖥" -#: ../../source/index.rst:17 +#: ../../source/index.rst:20 msgid "" "It is implemented with industry-standard machine learning frameworks: " "TensorFlow, JAX, and PyTorch. 🤖" msgstr "业界标准机器学习框架 TensorFlow，JAX，PyTorch 实现。🤖" -#: ../../source/index.rst:19 +#: ../../source/index.rst:22 msgid "" "It is compatible with machine learning engineering paradigms: automatic " "differentiation, just-in-time compilation, vectorized parallelism and GPU " "acceleration. 🛠" msgstr "与机器学习工程实践兼容：自动微分，即时编译，向量并行化和 GPU 加速。🛠" -#: ../../source/index.rst:23 -msgid "Links" -msgstr "重要链接" +#: ../../source/index.rst:24 +msgid "" +"With the help of TensorCircuit, now get ready to efficiently and elegantly " +"solve interesting and challenging quantum computing problems from academic " +"research prototype to industry application deployment." +msgstr "" +"有了 TensorCircuit，你现在可以高效和优雅的解决量子计算中的各种问题：从学术研究的" +"原型开发到工业应用的部署。" -#: ../../source/index.rst:25 +#: ../../source/index.rst:29 +msgid "Relevant Links" +msgstr "相关链接" + +#: ../../source/index.rst:31 msgid "" "TensorCircuit is created and maintained by `Shi-Xin Zhang `_ and this version of the software is released by `Tencent " -"Quantum Lab `_. The current core authors of " -"TensorCircuit are `Shi-Xin Zhang `_ and `Yu-" -"Qin Chen `_. We also thank `contributions `_ from the " -"lab and the open source community." +"refraction-ray>`_ and this version is released by `Tencent Quantum Lab `_." msgstr "" -#: ../../source/index.rst:29 +#: ../../source/index.rst:33 +msgid "" +"The current core authors of TensorCircuit are `Shi-Xin Zhang `_ and `Yu-Qin Chen `_. We also " +"thank `contributions `_ from the lab and the open source community." +msgstr "" + +#: ../../source/index.rst:36 +msgid "" +"If you have any further questions or collaboration ideas, please use the issue " +"tracker or forum below, or send email to shixinzhang#tencent.com." +msgstr "" +"如果关于 TensorCircuit 有任何问题咨询或合作意向，请在 issue 或 discussion 提问，" +"或发送邮件到 shixinzhang#tencent.com。" + +#: ../../source/index.rst:39 msgid "Source code: https://github.com/tencent-quantum-lab/tensorcircuit" msgstr "源代码: https://github.com/tencent-quantum-lab/tensorcircuit" -#: ../../source/index.rst:31 +#: ../../source/index.rst:41 msgid "Documentation: https://tensorcircuit.readthedocs.io" msgstr "文档: https://tensorcircuit.readthedocs.io" -#: ../../source/index.rst:33 +#: ../../source/index.rst:43 msgid "" "Software Whitepaper (published in Quantum): https://quantum-journal.org/papers/" "q-2023-02-02-912/" @@ -91,20 +119,20 @@ msgstr "" "软件白皮书 (发表于 Quantum): https://quantum-journal.org/papers/" "q-2023-02-02-912/" -#: ../../source/index.rst:35 +#: ../../source/index.rst:45 msgid "Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues" msgstr "问题跟踪: https://github.com/tencent-quantum-lab/tensorcircuit/issues" -#: ../../source/index.rst:37 +#: ../../source/index.rst:47 msgid "Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" msgstr "" "论坛社区: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" -#: ../../source/index.rst:39 +#: ../../source/index.rst:49 msgid "PyPI page: https://pypi.org/project/tensorcircuit" msgstr "PyPI 页面: https://pypi.org/project/tensorcircuit" -#: ../../source/index.rst:41 +#: ../../source/index.rst:51 msgid "" "DockerHub page: https://hub.docker.com/repository/docker/tensorcircuit/" "tensorcircuit" @@ -112,7 +140,7 @@ msgstr "" "DockerHub 页面: https://hub.docker.com/repository/docker/tensorcircuit/" "tensorcircuit" -#: ../../source/index.rst:43 +#: ../../source/index.rst:53 msgid "" "Research and projects based on TensorCircuit: https://github.com/tencent-" "quantum-lab/tensorcircuit#research-and-applications" @@ -120,56 +148,48 @@ msgstr "" "基于 TensorCircuit 的研究和项目: https://github.com/tencent-quantum-lab/" "tensorcircuit#research-and-applications" -#: ../../source/index.rst:45 +#: ../../source/index.rst:55 msgid "Tencent Quantum Cloud Service: https://quantum.tencent.com/cloud/" msgstr "腾讯量子云服务: https://quantum.tencent.com/cloud/" -#: ../../source/index.rst:47 -msgid "" -"If you have any further questions or collaboration ideas in terms of " -"TensorCircuit, please send email to shixinzhang#tencent.com." -msgstr "" -"如果关于 TensorCircuit 有任何其他问题咨询或合作意向，请发送邮件到 " -"shixinzhang#tencent.com。" - -#: ../../source/index.rst:51 +#: ../../source/index.rst:61 msgid "Reference Documentation" msgstr "参考文档" -#: ../../source/index.rst:53 +#: ../../source/index.rst:63 msgid "" "The following documentation sections briefly introduce TensorCircuit to the " "users and developpers." msgstr "以下文档向用户和开发者简要介绍了 TensorCircuit 软件。" -#: ../../source/index.rst:66 +#: ../../source/index.rst:76 msgid "Tutorials" msgstr "教程" -#: ../../source/index.rst:68 +#: ../../source/index.rst:78 msgid "" "The following documentation sections include integrated examples in the form of " "Jupyter Notebook." msgstr "" "以下 Jupyter Notebook 格式的文档包括了一系列使用 TensorCircuit 的集成案例。" -#: ../../source/index.rst:82 +#: ../../source/index.rst:92 msgid "API References" msgstr "API 参考" -#: ../../source/index.rst:91 +#: ../../source/index.rst:101 msgid "Indices and Tables" msgstr "索引和表格" -#: ../../source/index.rst:93 +#: ../../source/index.rst:103 msgid ":ref:`genindex`" msgstr ":ref:`genindex`" -#: ../../source/index.rst:94 +#: ../../source/index.rst:104 msgid ":ref:`modindex`" msgstr ":ref:`modindex`" -#: ../../source/index.rst:95 +#: ../../source/index.rst:105 msgid ":ref:`search`" msgstr ":ref:`search`" @@ -184,3 +204,9 @@ msgstr ":ref:`search`" #~ msgid "Software Whitepaper: https://arxiv.org/abs/2205.10091" #~ msgstr "白皮书文章: https://arxiv.org/abs/2205.10091" + +#~ msgid "Guide to TensorCircuit" +#~ msgstr "TensorCircuit 指南" + +#~ msgid "Links" +#~ msgstr "重要链接" From b2c2186a9e9eceb90391621355468583116b374e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 10 May 2023 22:32:06 +0800 Subject: [PATCH 439/725] further update cn doc index --- docs/source/index.rst | 2 +- docs/source/locale/zh/LC_MESSAGES/index.po | 17 ++++++++++------- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/docs/source/index.rst b/docs/source/index.rst index 01a4a22c..6732f8fc 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -21,7 +21,7 @@ TensorCircuit is an open-source high-performance quantum computing software fram * It is compatible with machine learning engineering paradigms: automatic differentiation, just-in-time compilation, vectorized parallelism and GPU acceleration. 🛠 -With the help of TensorCircuit, now get ready to efficiently and elegantly solve interesting and challenging quantum computing problems from academic research prototype to industry application deployment. +With the help of TensorCircuit, now get ready to efficiently and elegantly solve interesting and challenging quantum computing problems: from academic research prototype to industry application deployment. diff --git a/docs/source/locale/zh/LC_MESSAGES/index.po b/docs/source/locale/zh/LC_MESSAGES/index.po index ce4c9beb..b7bd09a9 100644 --- a/docs/source/locale/zh/LC_MESSAGES/index.po +++ b/docs/source/locale/zh/LC_MESSAGES/index.po @@ -9,7 +9,7 @@ msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-05-10 22:01+0800\n" -"PO-Revision-Date: 2023-05-10 22:06+0800\n" +"PO-Revision-Date: 2023-05-10 22:30+0800\n" "Last-Translator: Xinghan Yang\n" "Language-Team: \n" "Language: cn\n" @@ -20,7 +20,6 @@ msgstr "" "X-Generator: Poedit 3.2.2\n" #: ../../source/index.rst:2 -#, fuzzy msgid "TensorCircuit Documentation" msgstr "参考文档" @@ -32,10 +31,9 @@ msgstr "**祝贺你发现了 TensorCircuit！** 👏" msgid "" "TensorCircuit is an open-source high-performance quantum computing software " "framework in Python." -msgstr "TensorCircuit 是 Python 编写的开源高性能量子计算软件框架。" +msgstr "TensorCircuit 是基于 Python 的开源高性能量子计算软件框架。" #: ../../source/index.rst:12 -#, fuzzy msgid "It is built for humans. 👽" msgstr "适合人类。👽" @@ -48,7 +46,6 @@ msgid "It is empowered by advanced tensor network simulator engine. 🔋" msgstr "先进张量网络引擎赋能。🔋" #: ../../source/index.rst:18 -#, fuzzy msgid "" "It is ready for quantum hardware access with CPU/GPU/QPU (local/cloud) hybrid " "solutions. 🖥" @@ -73,8 +70,8 @@ msgid "" "solve interesting and challenging quantum computing problems from academic " "research prototype to industry application deployment." msgstr "" -"有了 TensorCircuit，你现在可以高效和优雅的解决量子计算中的各种问题：从学术研究的" -"原型开发到工业应用的部署。" +"有了 TensorCircuit，你现在可以高效优雅地解决量子计算中的各种问题：从学术研究的原" +"型开发到工业应用的部署。" #: ../../source/index.rst:29 msgid "Relevant Links" @@ -86,6 +83,8 @@ msgid "" "refraction-ray>`_ and this version is released by `Tencent Quantum Lab `_." msgstr "" +"TensorCircuit 由 `Shi-Xin Zhang `_ 创造和维" +"护；此版本由 `腾讯量子实验室 `_ 发布。" #: ../../source/index.rst:33 msgid "" @@ -94,6 +93,10 @@ msgid "" "thank `contributions `_ from the lab and the open source community." msgstr "" +"TensorCircuit 当前主要作者为 `Shi-Xin Zhang `_ ，`Yu-Qin Chen `_。 同时感谢来自实验室和开源" +"社区的 `贡献 `_ 。" #: ../../source/index.rst:36 msgid "" From 8091968024ef2328f589ef7ef4380fae280a9214 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 10 May 2023 22:56:14 +0800 Subject: [PATCH 440/725] further fix cn doc index --- docs/source/locale/zh/LC_MESSAGES/index.po | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/source/locale/zh/LC_MESSAGES/index.po b/docs/source/locale/zh/LC_MESSAGES/index.po index b7bd09a9..08959a7d 100644 --- a/docs/source/locale/zh/LC_MESSAGES/index.po +++ b/docs/source/locale/zh/LC_MESSAGES/index.po @@ -8,8 +8,8 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-05-10 22:01+0800\n" -"PO-Revision-Date: 2023-05-10 22:30+0800\n" +"POT-Creation-Date: 2023-05-10 22:52+0800\n" +"PO-Revision-Date: 2023-05-10 22:54+0800\n" "Last-Translator: Xinghan Yang\n" "Language-Team: \n" "Language: cn\n" @@ -67,7 +67,7 @@ msgstr "与机器学习工程实践兼容：自动微分，即时编译，向量 #: ../../source/index.rst:24 msgid "" "With the help of TensorCircuit, now get ready to efficiently and elegantly " -"solve interesting and challenging quantum computing problems from academic " +"solve interesting and challenging quantum computing problems: from academic " "research prototype to industry application deployment." msgstr "" "有了 TensorCircuit，你现在可以高效优雅地解决量子计算中的各种问题：从学术研究的原" @@ -83,7 +83,7 @@ msgid "" "refraction-ray>`_ and this version is released by `Tencent Quantum Lab `_." msgstr "" -"TensorCircuit 由 `Shi-Xin Zhang `_ 创造和维" +"TensorCircuit 由 `Shi-Xin Zhang `_ 创建和维" "护；此版本由 `腾讯量子实验室 `_ 发布。" #: ../../source/index.rst:33 @@ -94,9 +94,9 @@ msgid "" "graphs/contributors>`_ from the lab and the open source community." msgstr "" "TensorCircuit 当前主要作者为 `Shi-Xin Zhang `_ ，`Yu-Qin Chen `_。 同时感谢来自实验室和开源" -"社区的 `贡献 `_ 。" +"ray>`_，`Yu-Qin Chen `_。同时感谢来自实验室和开源社" +"区的 `贡献 `_。" #: ../../source/index.rst:36 msgid "" From 5e4321cf005fdd6d113336e1d457506e84982a96 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 12 May 2023 11:23:18 +0800 Subject: [PATCH 441/725] update cloud infra with another middle layer abstraction --- CHANGELOG.md | 7 ++ tensorcircuit/applications/vqes.py | 9 +- tensorcircuit/cloud/tencent.py | 2 +- tensorcircuit/cloud/wrapper.py | 149 ++++++++++++++++++++++------- tests/test_cloud.py | 16 ++++ 5 files changed, 144 insertions(+), 39 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e2d0c5d5..291fec65 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,13 @@ - Refactor composed compiler pipeline interface to include simple_compiler, using `DefaultCompiler` for now (breaking) +- Refactor `batch_submit_template` wrapper to make it a standard abstraction layer between tc cloud infras and `batch_expectation_ps` abstraction, providing another way to adpot other cloud providers with only `batch_submit_template` implemented + +### Fixed + +- `submit_task` return (list of dict vs dict) follows the data type of provided circuit instead of the number of circuits + + ## 0.9.0 ### Added diff --git a/tensorcircuit/applications/vqes.py b/tensorcircuit/applications/vqes.py index 8eb6c510..8cf5b0d5 100644 --- a/tensorcircuit/applications/vqes.py +++ b/tensorcircuit/applications/vqes.py @@ -28,6 +28,9 @@ dtype = np.complex128 # only guarantee compatible with float64 mode # only support tf backend +# i.e. use the following setup in the code +# tc.set_backend("tensorflow") +# tc.set_dtype("complex128") x = np.array([[0, 1.0], [1.0, 0]], dtype=dtype) y = np.array([[0, -1j], [1j, 0]], dtype=dtype) @@ -376,7 +379,11 @@ def create_circuit( return self.create_hea2_circuit(**kws) if choose == "hn": return self.create_hn_circuit(**kws) - raise ValueError("no such choose option: %s" % choose) + return self.create_functional_circuit(**kws) + + def create_functional_circuit(self, **kws: Any): + func = kws.get("func") + return func def create_hn_circuit(self, **kws: Any) -> Callable[[Tensor], Tensor]: def circuit(a: Tensor) -> Tensor: diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 95497779..dc99ed80 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -288,7 +288,7 @@ def c2qasm(c: Any, compiling: bool) -> str: else: ti = Task(id_=t["id"], device=device) rtn.append(ti) - if len(rtn) == 1: + if not is_sequence(source): return rtn[0] # type: ignore elif len(rtn) == 0: raise ValueError("All tasks submitted failed") diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index ef8c21bc..f216f9d8 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -22,9 +22,13 @@ Tensor = Any -def batch_submit_template(device: str) -> Callable[..., List[counts.ct]]: +def batch_submit_template( + device: str, batch_limit: int = 64, **kws: Any +) -> Callable[..., List[counts.ct]]: # TODO(@refraction-ray): adpative batch - def run(cs: Union[Circuit, Sequence[Circuit]], shots: int) -> List[counts.ct]: + def run( + cs: Union[Circuit, Sequence[Circuit]], shots: int = 8192, **nkws: Any + ) -> List[counts.ct]: """ batch circuit running alternative """ @@ -32,12 +36,36 @@ def run(cs: Union[Circuit, Sequence[Circuit]], shots: int) -> List[counts.ct]: if not is_sequence(cs): cs = [cs] # type: ignore single = True - ts = [] # for c in cs: # type: ignore # ts.append(submit_task(circuit=c, shots=shots, device=device)) # time.sleep(0.3) - ts = submit_task(circuit=cs, shots=shots, device=device) - l = [t.results(blocked=True) for t in ts] # type: ignore + kws.update(nkws) + if len(cs) <= batch_limit: + css = [cs] + else: + ntimes = len(cs) // batch_limit + if ntimes * batch_limit == len(cs): + css = [ + cs[i * batch_limit : (i + 1) * batch_limit] for i in range(ntimes) + ] + else: + css = [ + cs[i * batch_limit : (i + 1) * batch_limit] for i in range(ntimes) + ] + [cs[ntimes * batch_limit :]] + tss = [] + logger.info(f"submit task on {device} for {len(cs)} circuits") + time0 = time.time() + for i, cssi in enumerate(css): + tss += submit_task(circuit=cssi, shots=shots, device=device, **kws) + if i < len(css) - 1: + time.sleep(1.5) + # TODO(@refraction-ray) whether the sleep time is enough for tquk? + # incase duplicae request error protection + l = [t.results() for t in tss] + time1 = time.time() + logger.info( + f"finished collecting count results of {len(cs)} tasks in {round(time1-time0, 4)} seconds" + ) if single is False: return l return l[0] # type: ignore @@ -80,6 +108,39 @@ def sample_expectation_ps( return counts.expectation(raw_counts, x + y + z) +def reduce_and_evaluate( + cs: List[Circuit], shots: int, run: Callable[..., Any] +) -> List[counts.ct]: + reduced_cs = [] + reduced_dict = {} + recover_dict = {} + # merge the same circuit + for j, c in enumerate(cs): + key = hash(c.to_openqasm()) + if key not in reduced_dict: + reduced_dict[key] = [j] + reduced_cs.append(c) + recover_dict[key] = len(reduced_cs) - 1 + else: + reduced.dict[key].append([j]) + + # for j, ps in enumerate(pss): + # ps = [i if i in [1, 2] else 0 for i in ps] + # if tuple(ps) not in reduced_dict: + # reduced_dict[tuple(ps)] = [j] + # reduced_cs.append(cs[j]) + # recover_dict[tuple(ps)] = len(reduced_cs) - 1 + # else: + # reduced_dict[tuple(ps)].append(j) + + reduced_raw_counts = run(reduced_cs, shots) + raw_counts: List[Dict[str, int]] = [None] * len(cs) # type: ignore + for i, c in enumerate(cs): + key = hash(c.to_openqasm()) + raw_counts[i] = reduced_raw_counts[recover_dict[key]] + return raw_counts + + def batch_expectation_ps( c: Circuit, pss: List[List[int]], @@ -87,6 +148,8 @@ def batch_expectation_ps( ws: Optional[List[float]] = None, shots: int = 8192, with_rem: bool = True, + batch_limit: int = 64, + batch_submit_func: Optional[Callable[..., List[counts.ct]]] = None, ) -> Union[Any, List[Any]]: """ Unified interface to compute the Pauli string expectation lists or sums via simulation or on real qpu. @@ -163,43 +226,55 @@ def batch_expectation_ps( infos.append(info) exps.append(exp) - reduced_cs = [] - reduced_dict = {} - recover_dict = {} - # merge the same circuit - for j, ps in enumerate(pss): - ps = [i if i in [1, 2] else 0 for i in ps] - if tuple(ps) not in reduced_dict: - reduced_dict[tuple(ps)] = [j] - reduced_cs.append(cs[j]) - recover_dict[tuple(ps)] = len(reduced_cs) - 1 - else: - reduced_dict[tuple(ps)].append(j) + # reduced_cs = [] + # reduced_dict = {} + # recover_dict = {} + # # merge the same circuit + # for j, ps in enumerate(pss): + # ps = [i if i in [1, 2] else 0 for i in ps] + # if tuple(ps) not in reduced_dict: + # reduced_dict[tuple(ps)] = [j] + # reduced_cs.append(cs[j]) + # recover_dict[tuple(ps)] = len(reduced_cs) - 1 + # else: + # reduced_dict[tuple(ps)].append(j) - def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: - logger.info(f"submit task on {device.name} for {len(cs)} circuits") - time0 = time.time() - ts = submit_task( - circuit=cs, - device=device, - shots=shots, + if batch_submit_func is None: + run = batch_submit_template( + device, + batch_limit, enable_qos_qubit_mapping=False, enable_qos_gate_decomposition=False, ) - if not is_sequence(ts): - ts = [ts] # type: ignore - raw_counts = [t.results(blocked=True) for t in ts] - time1 = time.time() - logger.info( - f"finished collecting count results of {len(cs)} tasks in {round(time1-time0, 4)} seconds" - ) - return raw_counts + else: + run = batch_submit_func - reduced_raw_counts = run(reduced_cs, shots) - raw_counts: List[Dict[str, int]] = [None] * len(cs) # type: ignore - for i in range(len(cs)): - ps = [i if i in [1, 2] else 0 for i in pss[i]] - raw_counts[i] = reduced_raw_counts[recover_dict[tuple(ps)]] + raw_counts = reduce_and_evaluate(cs, shots, run) + + # def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: + # logger.info(f"submit task on {device.name} for {len(cs)} circuits") + # time0 = time.time() + # ts = submit_task( + # circuit=cs, + # device=device, + # shots=shots, + # enable_qos_qubit_mapping=False, + # enable_qos_gate_decomposition=False, + # ) + # if not is_sequence(ts): + # ts = [ts] # type: ignore + # raw_counts = [t.results(blocked=True) for t in ts] + # time1 = time.time() + # logger.info( + # f"finished collecting count results of {len(cs)} tasks in {round(time1-time0, 4)} seconds" + # ) + # return raw_counts + + # reduced_raw_counts = run(reduced_cs, shots) + # raw_counts: List[Dict[str, int]] = [None] * len(cs) # type: ignore + # for i in range(len(cs)): + # ps = [i if i in [1, 2] else 0 for i in pss[i]] + # raw_counts[i] = reduced_raw_counts[recover_dict[tuple(ps)]] if with_rem: if getattr(device, "readout_mit", None) is None: diff --git a/tests/test_cloud.py b/tests/test_cloud.py index c3f3e7ee..07bbccad 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -161,3 +161,19 @@ def test_batch_exp_ps(): [1, -1], atol=1e-1, ) + + +def test_batch_submit_template(): + run = tc.cloud.wrapper.batch_submit_template( + device="simulator:tc", batch_limit=2, prior=10 + ) + cs = [] + for i in range(4): + c = tc.Circuit(4) + c.h(i) + cs.append(c) + + rs = run(cs[:3], prior=1) + assert len(rs) == 3 + rs = run(cs[:4]) + assert len(rs) == 4 From dc3047ba3917ae15bd330bf8a8c63ff18f38433f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 12 May 2023 13:22:19 +0800 Subject: [PATCH 442/725] fix qubit routing in simple compiler and batch exp ps --- CHANGELOG.md | 1 + tensorcircuit/applications/vqes.py | 6 ++-- tensorcircuit/cloud/wrapper.py | 25 ++++++++++------- tensorcircuit/compiler/simple_compiler.py | 12 ++++++++ tests/test_cloud.py | 34 +++++++++++++++++++++++ 5 files changed, 65 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 291fec65..f671e2a2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,7 @@ - `submit_task` return (list of dict vs dict) follows the data type of provided circuit instead of the number of circuits +- Fix qubit mapping related bug when using `batch_expectation_ps` or `simple_compile` ## 0.9.0 diff --git a/tensorcircuit/applications/vqes.py b/tensorcircuit/applications/vqes.py index 8cf5b0d5..ba279365 100644 --- a/tensorcircuit/applications/vqes.py +++ b/tensorcircuit/applications/vqes.py @@ -379,11 +379,11 @@ def create_circuit( return self.create_hea2_circuit(**kws) if choose == "hn": return self.create_hn_circuit(**kws) - return self.create_functional_circuit(**kws) + return self.create_functional_circuit(**kws) # type: ignore - def create_functional_circuit(self, **kws: Any): + def create_functional_circuit(self, **kws: Any) -> Callable[[Tensor], Tensor]: func = kws.get("func") - return func + return func # type: ignore def create_hn_circuit(self, **kws: Any) -> Callable[[Tensor], Tensor]: def circuit(a: Tensor) -> Tensor: diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index f216f9d8..85d35e9a 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -40,20 +40,22 @@ def run( # ts.append(submit_task(circuit=c, shots=shots, device=device)) # time.sleep(0.3) kws.update(nkws) - if len(cs) <= batch_limit: + if len(cs) <= batch_limit: # type: ignore css = [cs] else: - ntimes = len(cs) // batch_limit - if ntimes * batch_limit == len(cs): + ntimes = len(cs) // batch_limit # type: ignore + if ntimes * batch_limit == len(cs): # type: ignore css = [ - cs[i * batch_limit : (i + 1) * batch_limit] for i in range(ntimes) + cs[i * batch_limit : (i + 1) * batch_limit] for i in range(ntimes) # type: ignore ] else: css = [ - cs[i * batch_limit : (i + 1) * batch_limit] for i in range(ntimes) - ] + [cs[ntimes * batch_limit :]] + cs[i * batch_limit : (i + 1) * batch_limit] for i in range(ntimes) # type: ignore + ] + [ + cs[ntimes * batch_limit :] # type: ignore + ] tss = [] - logger.info(f"submit task on {device} for {len(cs)} circuits") + logger.info(f"submit task on {device} for {len(cs)} circuits") # type: ignore time0 = time.time() for i, cssi in enumerate(css): tss += submit_task(circuit=cssi, shots=shots, device=device, **kws) @@ -64,7 +66,7 @@ def run( l = [t.results() for t in tss] time1 = time.time() logger.info( - f"finished collecting count results of {len(cs)} tasks in {round(time1-time0, 4)} seconds" + f"finished collecting count results of {len(cs)} tasks in {round(time1-time0, 4)} seconds" # type: ignore ) if single is False: return l @@ -122,7 +124,7 @@ def reduce_and_evaluate( reduced_cs.append(c) recover_dict[key] = len(reduced_cs) - 1 else: - reduced.dict[key].append([j]) + reduced_dict[key].append(j) # for j, ps in enumerate(pss): # ps = [i if i in [1, 2] else 0 for i in ps] @@ -220,7 +222,10 @@ def batch_expectation_ps( exp.append(j) elif i == 3: exp.append(j) + for i in range(c1._nqubits): + c1.measure_instruction(i) c1, info = dc(c1) + # bug for measure instruction! # TODO(@refraction-ray): two steps compiling with pre compilation cs.append(c1) infos.append(info) @@ -249,7 +254,7 @@ def batch_expectation_ps( else: run = batch_submit_func - raw_counts = reduce_and_evaluate(cs, shots, run) + raw_counts = reduce_and_evaluate(cs, shots, run) # type: ignore # def run(cs: List[Any], shots: int) -> List[Dict[str, int]]: # logger.info(f"submit task on {device.name} for {len(cs)} circuits") diff --git a/tensorcircuit/compiler/simple_compiler.py b/tensorcircuit/compiler/simple_compiler.py index a10d422d..f1641594 100644 --- a/tensorcircuit/compiler/simple_compiler.py +++ b/tensorcircuit/compiler/simple_compiler.py @@ -280,6 +280,14 @@ def simple_compile( ) -> Any: if compiled_options is None: compiled_options = {} + len0 = len(circuit.to_qir()) + for d in circuit._extra_qir: + if d["pos"] < len0 - 1: + raise ValueError( + "TC's simple compiler doesn't support measurement/reset instructions \ + in the middle of the circuit" + ) + c = replace_r(circuit, **compiled_options) c = replace_u(circuit, **compiled_options) qir = c.to_qir() @@ -296,4 +304,8 @@ def simple_compile( len1 = len(qir) c = type(circuit).from_qir(qir, circuit.circuit_param) + + for d in circuit._extra_qir: + d["pos"] = len1 + c._extra_qir.append(d) return (c, info) diff --git a/tests/test_cloud.py b/tests/test_cloud.py index 07bbccad..5814b75f 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -177,3 +177,37 @@ def test_batch_submit_template(): assert len(rs) == 3 rs = run(cs[:4]) assert len(rs) == 4 + + +def test_allz_batch(): + n = 5 + + def makec(inputs, params): + c = tc.Circuit(n) + for i in range(n): + c.rx(i, theta=inputs[i]) + for i in range(n): + c.rz(i, theta=params[0, i]) + for i in range(n - 1): + c.cx(i, i + 1) + for i in range(n): + c.rx(i, theta=params[1, i]) + return c + + pss = [] + for i in range(n): + ps = [0 for _ in range(n)] + ps[i] = 3 + pss.append(ps) + + def exp_val(c, device=None): + rs = tc.cloud.wrapper.batch_expectation_ps(c, pss, device) + return tc.backend.stack(rs) + + def qmlf(inputs, params, device=None): + c = makec(inputs, params) + return exp_val(c, device) + + inputs = tc.array_to_tensor(np.array([0, 1, 0, 1, 0])) + params = np.ones([2, n]) + print(qmlf(inputs, params, device="9gmon")) From ba6ec5bc21e4f165c206d1a8ea6138f619a5d85f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 12 May 2023 14:36:18 +0800 Subject: [PATCH 443/725] add qpu call sdk design doc --- docs/source/infras.rst | 27 ++++++++++++++++++++++++++- tests/test_cloud.py | 1 + 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/docs/source/infras.rst b/docs/source/infras.rst index 748438d4..576de2a9 100644 --- a/docs/source/infras.rst +++ b/docs/source/infras.rst @@ -155,4 +155,29 @@ Also, note how ``^`` is overloaded as ``tn.connect`` to connect edges between di The convention to define the ``QuOperator`` is firstly giving ``out_edges`` (left index or row index of the matrix) and then giving ``in_edges`` (right index or column index of the matrix). The edges list contains edge objects from the TensorNetwork library. Such QuOperator/QuVector abstraction support various calculations only possible on matrix/vectors, such as matmul (``@``), adjoint (``.adjoint()``), scalar multiplication (``*``), tensor product (``|``), and partial trace (``.partial_trace(subsystems_to_trace_out)``). -To extract the matrix information of these objects, we can use ``.eval()`` or ``.eval_matrix()``, the former keeps the shape information of the tensor network while the latter gives the matrix representation with shape rank 2. \ No newline at end of file +To extract the matrix information of these objects, we can use ``.eval()`` or ``.eval_matrix()``, the former keeps the shape information of the tensor network while the latter gives the matrix representation with shape rank 2. + + +Quantum Cloud SDK: Layerwise API design +----------------------------------------------------- + +From lower level to higher level, a view of API layers invoking QPU calls + +- Vendor specific implementation of functional API in, e.g., :py:mod:`tensorcircuit.cloud.tencent` + +- Provider agnostic functional lower level API for task/device management in :py:mod:`tensorcircuit.cloud.apis` + +- Object oriented abstraction for Provider/Device/Task in :py:mod:`tensorcircuit.cloud.abstraction` + +- Unified batch submission interface as standarized in :py:meth:`tensorcircuit.cloud.wrapper.batch_submit_template` + +- Numerical and experimental unified all-in-one interface as :py:meth:`tensorcircuit.cloud.wrapper.batch_expectation_ps` + +- Application level code with QPU calls built directly on ``batch_expectation_ps`` or more fancy algorithms can be built on ``batch_submit_func`` so that these algorithms can be reused as long as one function ``batch_submit_func`` is defined for a given vendor (cheaper than defining a new provider from lower level). + + +.. Note:: + + For compiler, error mitigation and results post-processing parts, they can be carefully designed to decouple with the QPU calls, + so they are separately implemented in :py:mod:`tensorcircuit.compiler` and :py:mod:`tensorcircuit.results`, + and they can be independently useful even without tc's cloud access. diff --git a/tests/test_cloud.py b/tests/test_cloud.py index 5814b75f..f71e8e4d 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -211,3 +211,4 @@ def qmlf(inputs, params, device=None): inputs = tc.array_to_tensor(np.array([0, 1, 0, 1, 0])) params = np.ones([2, n]) print(qmlf(inputs, params, device="9gmon")) + print(qmlf(inputs, params)) From ec3a86a54faff8598d77429c33ad8fcac1cb00fb Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Sat, 13 May 2023 14:19:27 +0800 Subject: [PATCH 444/725] Update qaoa.ipynb --- docs/source/tutorials/qaoa.ipynb | 683 ++++++++++++++++++++++++++----- 1 file changed, 583 insertions(+), 100 deletions(-) diff --git a/docs/source/tutorials/qaoa.ipynb b/docs/source/tutorials/qaoa.ipynb index 647818e9..372b7e1a 100644 --- a/docs/source/tutorials/qaoa.ipynb +++ b/docs/source/tutorials/qaoa.ipynb @@ -18,27 +18,130 @@ }, { "cell_type": "markdown", - "id": "ddada0ca", + "id": "eaf8cd3f", "metadata": {}, "source": [ - "QAOA is a hybrid classical-quantum algorithm that combines quantum circuits, and classical optimization of those circuits. In this tutorial, we utilize QAOA to solve the maximum cut (MAX CUT) combinatorial optimization problem: Given a graph $G=(V, E)$ with nodes $V$ and edges $E$, find a subset $S \\in V$ such that the number of edges between $S$ and $S \\backslash V$ is maximized. And this problem can be reduced to that of finding the ground state of an antiferromagnetic Ising model whose Hamiltonian reads:\n", + "QAOA is a hybrid classical-quantum algorithm that combines quantum circuits, and classical optimization of those circuits. In this tutorial, we utilize QAOA to solve the maximum cut (Max-Cut) combinatorial optimization problem, as proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028)." + ] + }, + { + "cell_type": "markdown", + "id": "16ad937f", + "metadata": {}, + "source": [ + "## Max-Cut Problem" + ] + }, + { + "cell_type": "markdown", + "id": "197d6df4", + "metadata": {}, + "source": [ + "In graph theory, a graph is composed of $n$ nodes, also known as vertices, and $m$ edges that connect the nodes. Note that there is not necessarily a link between any pair of nodes. Those $n$ nodes are divided into two sets. The number of edges that are cut by a partition/partitions of the nodes is what is going to be maximized." + ] + }, + { + "attachments": { + "16c7f2fb-b981-4798-8346-da54e3bcbaeb.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB6wAAAJgCAIAAACx3QrqAAAEuGlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNS41LjAiPgogPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iCiAgICB4bWxuczp0aWZmPSJodHRwOi8vbnMuYWRvYmUuY29tL3RpZmYvMS4wLyIKICAgIHhtbG5zOnBob3Rvc2hvcD0iaHR0cDovL25zLmFkb2JlLmNvbS9waG90b3Nob3AvMS4wLyIKICAgIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIKICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIgogICAgeG1sbnM6c3RFdnQ9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZUV2ZW50IyIKICAgZXhpZjpQaXhlbFhEaW1lbnNpb249IjE5NjQiCiAgIGV4aWY6UGl4ZWxZRGltZW5zaW9uPSI2MDgiCiAgIGV4aWY6Q29sb3JTcGFjZT0iMSIKICAgdGlmZjpJbWFnZVdpZHRoPSIxOTY0IgogICB0aWZmOkltYWdlTGVuZ3RoPSI2MDgiCiAgIHRpZmY6UmVzb2x1dGlvblVuaXQ9IjIiCiAgIHRpZmY6WFJlc29sdXRpb249IjE0NC8xIgogICB0aWZmOllSZXNvbHV0aW9uPSIxNDQvMSIKICAgcGhvdG9zaG9wOkNvbG9yTW9kZT0iMyIKICAgcGhvdG9zaG9wOklDQ1Byb2ZpbGU9InNSR0IgSUVDNjE5NjYtMi4xIgogICB4bXA6TW9kaWZ5RGF0ZT0iMjAyMy0wNC0yMVQxMzozMDoyOSswMTowMCIKICAgeG1wOk1ldGFkYXRhRGF0ZT0iMjAyMy0wNC0yMVQxMzozMDoyOSswMTowMCI+CiAgIDx4bXBNTTpIaXN0b3J5PgogICAgPHJkZjpTZXE+CiAgICAgPHJkZjpsaQogICAgICBzdEV2dDphY3Rpb249InByb2R1Y2VkIgogICAgICBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZmZpbml0eSBQaG90byAxLjEwLjUiCiAgICAgIHN0RXZ0OndoZW49IjIwMjMtMDQtMjFUMTM6MzA6MjkrMDE6MDAiLz4KICAgIDwvcmRmOlNlcT4KICAgPC94bXBNTTpIaXN0b3J5PgogIDwvcmRmOkRlc2NyaXB0aW9uPgogPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KPD94cGFja2V0IGVuZD0iciI/PpKdWA8AAAGAaUNDUHNSR0IgSUVDNjE5NjYtMi4xAAAokXWR3yuDURjHP7aJmKZQLqglXG2aqcWNMmnUkmbKr5vt3S+1H2/vO0lulVtFiRu/LvgLuFWulSJScss1ccN6Pe+22pI9p+c8n/M953k65zlgCaeVjG7zQCab10IBv3N+YdHZ8IqNDux0Q0TR1bGZmSA17euBOjPeuc1atc/9a82xuK5AXaPwqKJqeeFJ4eBaXjV5V7hdSUViwufCLk0uKHxv6tESv5mcLPGPyVo4NA6WVmFnsoqjVayktIywvJzeTHpVKd/HfIk9np2bldgj3oVOiAB+nEwxwTg+BhmR2YcbLwOyoka+p5g/TU5yFZlV1tFYIUmKPC5RV6V6XGJC9LiMNOtm///2VU8MeUvV7X6ofzGMjz5o2IHCtmF8HxtG4QSsz3CVreTnjmD4U/TtitZ7CI5NuLiuaNE9uNyCzic1okWKklXckkjA+xm0LEDbLTQtlXpW3uf0EcIb8lU3sH8A/XLesfwLC4tnvJTYXoMAAAAJcEhZcwAAFiUAABYlAUlSJPAAACAASURBVHic7N15fFz1ee/x58yZfdHiRd7lBRtjjDcpGBOPgkm6xMEpThOWXMgN0NxmARK4aUmgLTi5DYSEBgLclm4hyS1pIUkDqYPTpA0mGrOYSN4QYPAi29h41zIzGs1y5tw/RpZlWbZG0jlzzpz5vP/gNTOac37Py2Dx01fPPD9F13UBAAAAAAAAAMCJXFYXAAAAAAAAAACAWQjBAQAAAAAAAACORQgOAAAAAAAAAHAsQnAAAAAAAAAAgGMRggMAAAAAAAAAHIsQHAAAAAAAAADgWITgAAAAAAAAAADHIgQHAAAAAAAAADgWITgAAAAAAAAAwLEIwQEAAAAAAAAAjkUIDgAAAAAAAABwLEJwAAAAAAAAAIBjEYIDAAAAAAAAAByLEBwAAAAAAAAA4FiE4AAAAAAAAAAAxyIEBwAAAAAAAAA4FiE4AAAAAAAAAMCxCMEBAAAAAAAAAI5FCA4AAAAAAAAAcCxCcAAAAAAAAACAYxGCAwAAAAAAAAAcixAcAAAAAAAAAOBYhOAAAAAAAAAAAMciBAcAAAAAAAAAOBYhOAAAAAAAAADAsQjBAQAAAAAAAACORQgOAAAAAAAAAHAsQnAAAAAAAAAAgGMRggMAAAAAAAAAHIsQHAAAAAAAAADgWITgAAAAAAAAAADHIgQHAAAAAAAAADgWITgAAAAAAAAAwLEIwQEAAAAAAAAAjkUIDgAAAAAAAABwLEJwAAAAAAAAAIBjEYIDAAAAAAAAAByLEBwAAAAAAAAA4FiE4AAAAAAAAAAAxyIEBwAAAAAAAAA4FiE4AAAAAAAAAMCxCMEBAAAAAAAAAI5FCA4AAAAAAAAAcCxCcAAAAAAAAACAYxGCAwAAAAAAAAAcixAcAAAAAAAAAOBYhOAAAAAAAAAAAMciBAcAAAAAAAAAOBYhOAAAAAAAAADAsQjBAQAAAAAAAACORQgOAAAAAAAAAHAsQnAAAAAAAAAAgGMRggMAAAAAAAAAHIsQHAAAAAAAAADgWITgAAAAAAAAAADHIgQHAAAAAAAAADgWITgAAAAAAAAAwLEIwQEAAAAAAAAAjkUIDgAAAAAAAABwLEJwAAAAAAAAAIBjEYIDAAAAAAAAAByLEBwAAAAAAAAA4FiE4AAAAAAAAAAAxyIEBwAAAAAAAAA4FiE4AAAAAAAAAMCxCMEBAAAAAAAAAI5FCA4AAAAAAAAAcCxCcAAAAAAAAACAYxGCAwAAAAAAAAAcixAcAAAAAAAAAOBYhOAAAAAAAAAAAMciBAcAAAAAAAAAOBYhOAAAAAAAAADAsQjBAQAAAAAAAACORQgOAAAAAAAAAHAsQnAAAAAAAAAAgGMRggMAAAAAAAAAHIsQHAAAAAAAAADgWITgAAAAAAAAAADHIgQHAAAAAAAAADgWITgAAAAAAAAAwLEIwQEAAAAAAAAAjkUIDgAAAAAAAABwLEJwAAAAAAAAAIBjEYIDAAAAAAAAAByLEBwAAAAAAAAA4FiE4AAAAAAAAAAAxyIEBwAAAAAAAAA4FiE4AAAAAAAAAMCxCMEBAAAAAAAAAI5FCA4AAAAAAAAAcCxCcAAAAAAAAACAYxGCAwAAAAAAAAAcixAcAAAAAAAAAOBYhOAAAAAAAAAAAMciBAcAAAAAAAAAOBYhOAAAAAAAAADAsQjBAQAAAAAAAACORQgOAAAAAAAAAHAsQnAAAAAAAAAAgGMRggMAAAAAAAAAHIsQHAAAAAAAAADgWG6rCwAAAIABNE3TNC2fz4tINpsVEV3X8/m8qqoi4nK5Cg9UVVVV1eWiEwIAAAAYm/Z2aW+Xo0dFRF5/XUSkp0eOHpVZs0RE6uqkrk5EZNYsmT1bJk60rE6IKLquW10DAAAARkPX9ewpI9rUqarq9Xo9Hk8hGQcAAABQlJ4e2bxZXn9dNm+WZHIEF86eLcuXy/LlfRE5SosQHAAAoPxkMpl0Op3L5cZ4H0VRPB5PIBCgNxwAAAA4n40b5Te/kba2sd4nFJLly+W66+gNLyVCcAAAgHKSy+WSyWRh7ImBvF4vUTgAAAAwhLY2efzxvrEnBrrySqLwkiEEBwAAKA+5XC6VSo29+/tcFEXx+/0+n09RFJOWAAAAAMpJW5s8/bQB3d/nEgrJmjWyZo0Eg2YtAREhBAcAALA/XdeTyWThuEuzKYoSDAa9Xm8J1gIAAABsqqdHHntMNm8uxVqhkNxyi6xaVYq1KhUhOAAAgK1pmpZMJjVNK+WiPp8vSDcKAAAAKlN7uzz+uOzdW9JF16yRm28u6YqVhBAcAADAvnK5XCKRsGTD5vF4QqEQo1EAAABQWdra5MEHJZm0YOnly+X22xmNYgZCcAAAAJvKZDJJSzbfp6iqGg6HOS0TAAAAlWLjRnnsMSsLmD1bvvIVTss0HCE4AACAHSWTyUwmY3UVoihKJBJRVdXqQgAAAACTPf64vPCC1UWIhELy9a/LrFlW1+Eo9PUAAADYTm9vrx0ScBHRdT0ej+fzeasLAQAAAMz0zDO2SMBFJJmUe++VY8esrsNRCMEBAADsJZPJpFIpq6s4Tdd1q+aSAwAAAKWwcaM8/bTVRQyQTMqDD0pPj9V1OAchOAAAgI1omtZjv82upmnWTicHAAAAzNLeLt/7ntVFnGXvXounkzsLITgAAIBd2LnnOpvN2jCdBwAAAMakp0cefFDs2fCxebM8+aTVRTgEITgAAIBd2Hz6djqdzmazVlcBAAAAGOfee+XoUauLOLf162XzZquLcAJCcAAAAFvIZDKaplldxTCSyaQ9G9UBAACAEdu4UfbutbqI4Tz+OMPBx44QHAAAwHq6rtvqMMxz0XU9nU5bXQUAAAAwZj099joM81ySSVm/3uoiyh4hOAAAgPXS6bSdB6EM1NvbSzM4AAAAyt769bYehDLQ+vU0g48RITgAAIDFdF3v7e21uopilUvTOgAAAHBOPT3l1F6dTJZH07qNEYIDAABYLJVKlVdvdRn1rQMAAABDePppSSatLmIk1q+XY8esLqKMEYIDAABYqUynbJdR6zoAAABwhvJqA+9XjjXbBiE4AACAlXK5nNUljEY2m7W6BAAAAGBUXn/d6gpGZfNmqysoY4TgAAAAVspkMlaXMBr5fF7TNKurAAAAAEauTNPko0elvd3qIsqV2+oCAAAAKpqxneC7du3P5c6ZTfv83tmzphm1Vi6XU1XVqLsBAAAAJdLWZuTdli4V97kj1lTKyOXa2mTWLMPuVkkIwQEAACyjaZqxJ0x+8Pf+JJHoOddXJ06o3fmWYZME0+m0z+cz6m4AAABAKbS3y9GjRt7wL/9SFOWcX9V1+cQnDFvrhRfkqqsMu1slYRwKAACAZcp6sramabquW10FAAAAMBJlOgulYO9e6TlnywvOg05wAAAAyxgegv/kme+kUr0DX3np5W3ffujJwuM1a64wdjlN09zn+ewnAAAAYDeGn4r5938vweAZr1x6qSxY0Pf44EGDl9u7VxYuNPieFYAfWgAAAJxj+fJFA59uemlLfwL+2T+95ht//UVjlzN2lgsAAABQfn796zOeXnXV6QS8vV3+/M8NXu7YMYNvWBkYhwIAAGAZY0/FHOTFF1/76B/dVnh85x2feuD+O1wug/d+hOAAAAAoM8aeijnI1VfLLbf0Pd65U778ZTF8w2zsQPOKQSc4AACAA/3q1y9d/8m+rpO/+svP3XnHp6ytBwAAAHC4a66R66/ve7xtm3z965ZWgzPQCQ4AAGAN806VXP+LF/sT8IkTalesWNzT03v+S0bH1E52AAAAwGDmnSp5442nE3Bdl9dek6oqUxbau9eU2zodITgAAIA1NE0z6c4//H8/73987HjHVWu+ML3+Q489/iPDFzIvxwcAAACMZ16C/KEPnX6sKPKZz8iTT8o99xi/UDJp/D0rgLpu3TqrawAAAKhE+Xw+k8mYcecli+fX1lavueqK5csXVUVC7+zaLyIbN74WCYcuvfQSAxdyuVw+n8/AGwIAAAAmOnZMXnjBlDsfOCATJ8qePdLRIT6f+P0iIlOnypw5EosZuVBdnVx5pZE3rAwK/TsAAACWyOVy8Xi8BAu99PLWNR+9tfD46OHfut2qUXd2u92RSMSouwEAAADmamuTe+8txUKrV8tnPtP3+PrrJZs17M4LFzJtfBQYhwIAAGANl6tEO7H3X770f33m44XHO3cyQxAAAACVauLEEi20YYPs29f3uLGxRIvi3AjBAQAArFGyEFxE5s6dWXiwbfvbBt5WVQ1rKgcAAABMV1dXurUOHep7sGyZkbedPdvIu1UMQnAAAADnOHr0RC43xHmbr732euHBnNnTDVyulDk+AAAAYEf19eLxDPH63Ll9D/bsMXK5UMjIu1UMfm4BAACwjLGd1N3diQ+v/txHr75t//73Br6+4Zexn/z0V4XHDQ0LDFwRAAAAKDPGdlKPHy8PPSRPPikXXXTG65/85OnRKy++aOSKGBW31QUAAABULkVRDLzbtx/6fvu+Q+37Di1t+MQnPv4HK1YsVlXXK69sf/qZXxbe8MnrV3u9Q3WpjJbbzWYSAAAAZSUYNPJuX/mKqKoEAvKNb8ixY7Jzp+TzctFFp+euHDkivb1GrrhwoZF3qxiKrutW1wAAAFChkslkJpMx6m7xePLLf/ZQf9P3IJ/4+B889tg9PkND8OrqaiaiAAAAoJw8/ri88IJhdxs3Tu6//5znbR47JnfeKamUYcuJyN/9XUknmzuFum7dOqtrAAAAqFCKohgYgvt83o9+dNX0aZPi8eT+A4f7X7/sssX/6zMf//rXbvUY2rjtcrkCgYCBNwQAAABKYdMmw26VSsn69TJxotTVidd7xus7dsjdd0s2a9haIlJXJ9ddZ+QNKwad4AAAAMbYvn1nc6w1FmuZP3/WuvtuK/Kqjo4OM4rRtHz7voPp3swFc+uN7f7u5/P5gsZ+mBQAAAAYidHtwOXjHzelGlWVhQvF75cdOwzu/u63Zo3cfLMpd3Y6xjgCAACM3mu/ez0Wa4nFWppjrceOnSy8+MEPrij+Dh6PJ2tse4iIiKiq64I5Mwy/7UAejynZOgAAAHAeY9+By/Llsnmz8ZVpmmzfbvxtB2Ig+GgRggMAAIzMpk2thX6T2KaWrq7E2W+IxVp0XS/y0Euv12tGCG42RVEIwQEAAFAaxu7A5bLLTAnBzRYKyfLlVhdRrgjBAQAAhpHN5ppjLbFYSyzW2hxr6e1Nn//9mUw2FmtpanpfMTd3Gzqnu2TKtGwAAACUBVN34HLxxQaUWHq0gY8BP70AAAAMIZHoKXzEMrapJRZryeeHP0altrYqurIxGm1oijZefvnSIhdyuVxutzuXy42t3lLz+/1WlwAAAABHKdkOXOrqZOFCaWsbU7mlt2aN1RWUMUJwAACAPidPdvX3m7zy6rZiLpk0aXxTtDEabYxGGxobRtmaEQgE4vH46K61hNvtphMcAAAAY2fVDlyuu07uvXeU11pi4UI6wceCn14AAEBFe++9Y7FYS/Om1lisZcuWN4u5pH7GlMKeuynaeMkl88Zeg9vt9nq9mUxm7LcqjUAgYHUJAAAAKFd22IHLwoVy5ZXywgsG3Ko0rrvO6grKGyE4AACoOPv2HervN2l7Y1cxl8ydW9/fb3LhvFmGlxQIBMolBPd6vbSBAwAAYERsuAOXa68tmxD8yitpAx8jfoABAAAV4e2322ObWgs771279hdzycKL50ajDdFoY1O0cebMqaaW53K5fD5fOj3MgT92QBs4AAAAimHzHbjU1cmaNbJ+vbmrGOLaa62uoOwRggMAAMd6/fV3+vtN9h94r5hLli1b0N9vMmXyRLMrHKjQDK7rw5//YyGfz+dyuayuAgAAADZVXjvwvmbwZLKki47UmjVSV2d1EWVPsfkPWgAAACPS0toWi/X1mxw5cqKYS1ZctqS/32TcuGqzKzyPXC5n5xMyVVWtqqqyugoAAADYS1nvwKWtzdYnZM6eLQ89ZHURTkAIDgAAyt7LL29tjrXEYq2xWEtHZ/ew73e5XIVDdaLRxujKhnA4WIIii5TJZJK2bEVxuVxVVVWKolhdCAAAAKznpB24vPCCPP641UUMpa5OHnpIQiGr63ACxqEAAIDyo2laYc9d6Dfp6ekd9hK/39cUbezvN/F4bLoL8nq92WzWbodkKooSDodJwAEAACqWg3fgcuWV0tZmu0MyQyG56y4ScKPY9T8+AACAM/X09MZiLX39Jptacjlt2Euqq8OFDXd0ZcPKlQ0lKNIQoVAon8/ncjmrCzktFAqpqmp1FQAAACipytmBy223ydGj0tZmdR0D3HabzJ5tdRHOwTgUAABgX52d3c2x1sLO++WXtxZzycSJ4/r7TS593yVmV2gSXdfj8bimDf9jRgkEg0Gfz2d1FQAAACiFit2BSzIp990ne/daXYeIiNx8s6xZY3URjkIIDgAA7OXIkROxWEvzppZYrLWlpahejOnTJ0WjjU0rG6PRhsWL55tdYWnoup5IJCzvBw+FQl6v19oaAAAAYCp24H2SSXnwQev7wW+7Ta680uIaHIcQHAAAWO/AgfcK/SaxWMuO198p5pI5c2b095tcNN+xnxNMJpNWzQdXFCUSiTAFBQAAwJHYgZ/T449bNh88FJKvfY0pKGYgBAcAANbYtWt/bFNLYef99tvtxVyyYMGc6MrGws579uzpJhdoF5lMJplMlnhRVVXD4bDL5SrxugAAADAPO/BivfCCPP54qRedPVvuukvq6kq9bmUgBAcAAKXzxhu7+vtN2vcdKuaSJUsuaoo2RKON0WjjtKkVuiPM5XKJRKJk2zaPxxMKhRRFKc1yAAAAMA878FFqa5MHH5SSNaMsXy633SahUImWqzyE4AAAwFxbtr4Zi/X1m7z33rFiLll+6aK+M+WjDRMm1JpdYVnQdb23t7e3t9fUVVwuVygUcrvdpq4CAAAAU7EDN0YyKevXyzPPmLtKXZ3cdpssXGjuKhWPEBwAABjv1Ve3N8daYrGWWKz1xMnOYi6JRhv7+k1WNlZV0QExtHw+n0qlzJgS7nK5AoEAZ2ACAACUKXbgZjl6VJ5+WjZuNP7OdXVy7bWcgVkahOAAAMAAuq4X9tyFfpNEomfYS3xeT+EjloWdt89H/FqsfD6fTCZzuZwhd1MUxefz+f1+5p8AAACUEXbgJXX0qDz+uLS1GXO3UEiuukrWrGH+SckQggMAgFHq7U3HYq19/SabWjOZ7LCXRCKhAf0mDaSuY6HrejabzWQyuVxuFDs6VVXdbrfX62X4CQAAQLlgB26xZFI2b5bNm6WtbTTjwmfPlosvlssuY/hJ6RGCAwCAEejuTjTHWgo7702bWou5ZML4mv5+k+XLF5tdYWXKZrPZbFbTNBHRNG3IDZ6qqoqiKIri8Xg8Ho/L5Sp5mQAAABgxduA2tXmzvP66tLeLiLS3D52Jz54twaCEQrJwoSxfLnWVesqoDRCCAwCAYRw7drKv32RTy2uvvV7MJVOn1vX1m6xsXLr0IrMrxJAK81JcLhd5NwAAQHlhB16uCvNSJk4k77YbQnAAADCEgweP9PebbN++s5hLZs+a1t9vsmDBBWZXCAAAADgJO3DAPIyABAAAffbseTcWa2ne1BKLtb711p5iLpk/f3Y02tAUbYyubLzgghlmVwgAAAA4CTtwoDQIwQEAqGhvvbWnv99k7953i7lk8aILC/0m0WjDjOmTza4QAAAAcBJ24EDpEYIDAFBxtm3bGdvUUth5Hzx4pJhL3ve+S6LRhqaVjdFoQ13deLMrBAAAAJyEHThgLUJwAAAqwmuv7WiOtcZiLc2xluPHO4q5ZOX7lxWaTaLRxprqiNkVAgAAAE7CDhywD0Jw6+Xz+Xw+LyK5XK7wVNM0EVEUxe12i4jL5XK5XCJSeAoAQJFim/r23LFYa3d3Ytj3ezzuaLQxurKhKdoYjTYEAv4SFAkApbdfy+zXMiLSnEmISFde255NiUi1S13sCYhIveqdqXpFJOoNW1opAKDMsAMH7EnRdd3qGiqUpmnpdDqXyxUi72IUYnGv1+vxeBRFMbU8AEA5ymSysVhLod8kFmvpTWeGvSQUCjSdGi8YXdmoqq4S1AkAltiRTT2VOtmcSRQi72JUu9Qmb3iNv/qj/uoqRTW1PABAOWIHDpQFQvBSy2azmUwmm82O8U9eVVWfz+f1eknDAaDCJRI9zbGW/p13Mf9/GTeuOrqysXCm/IoVS0pQJABY6Be9Xf/R27U+3dWVL7b7ZEiLPYEbAuNuDI4jDQeACscOHCg7hOClk8vlUqlUYeaJURRF8fv9Pp+PKBwAKsqJE539e+5XN28v5pLJkyf095s0LLvY7AoBwA5imcT98cOFmSdGqXapt4Ym3hqaSBQOABWFHThQ1gjBSyGfzyeTSWPj74EURQkGg16v16T7AwDs4L33jvX3m2zd+mYxl8ysn1o4VKcp2rhw4VyzKwQA+9ivZT7Xud/Y+Hugapf6YNW0GwLjTLo/AMAO2IEDjkEIbi5d13t6ejKZ4QdCjZ3L5QoGgx6PpwRrAQBKo739YCzW2hxriW1qeeON3cVcMm/ezL5+k5UN8+bNNLtCALCbbl27q+vgU6mTJVirXvV+q2raVf7qEqwFACgNduCAIxGCm0jTtEQikc/nS7loIBDw+zlKGADK2Ntvt/f3m+zevb+YSy5ZOO9Uv0lDff1UsysEANvakU1d37F3v1aKHpR+90Qm3x2eXMoVAQDGYgcOOB4huFmy2WwymbTkj9fr9QaDQaaEA0AZ2bHj7dim1sLO+8CBw8Vc0tBwcdOpA+UnT55gdoUAYH+/6O36bNf+MZ5+OTo3BMZ9q3oaU8IBoIywAwcqCiG4KdLpdE9Pj4UFqKoaiUTIwQHAzlpa2vr7TY4ePVHMJZevWFroN4lGG8bV8ul7ADjtb5PHvtJ90MICFnsCG8bPJQcHADtjBw5ULEJw4yWTydIMAT8/RVEikYiqsgsHABt56eUtfRMGYy2dnfFh36+qrsKhOtGVDdFoYygUKEGRAFB2Pte5vzRDwM+v2qVuGDd3kYfv1QBgI+zAAQghuOFskoAXkIMDgOVyOS0Wa2mOtRR23qlU77CXBAL+vk9ZRhujKxs8HncJ6gSA8mWTBLyAHBwALMcOHMDZCMGN1Nvbm0qlrK7iDC6Xq6qqirkoAFBKyZ5U7NSeOxZr0bThT0iuqYlEo41NKxuj0Yb3v39ZCYoEAGd4IHH4/nhRg1xLpl71vjxxPnNRAKCU2IEDOD9CcMNks9lEImF1FUNQVbWqqsrqKgDA4To6uvv7TV5+ZWsxl9TVjW/qGy/Y+L7GhWZXCADO84verus79lpdxRAWewKbJsy3ugoAcDh24ACKRwhuDE3T4vG4bf8wvV5vKBSyugoAcJrDR47HYq2FnXdr6xvFXDJjxuTCRyyboo2LFl1odoUA4GA7sqnVJ3d15TWrCxnaDYFxT9TUW10FADgNO3AAo0MIbgBd17u7u/P54T9rY6FgMOjz+ayuAgDK3v797/X1m2xqff31d4q55IIL6ptOjRecP3+22RUCQCXo1rXLj+3cr9nlMJ4hPVg17QuhiVZXAQBljx04gLEjBDeArQ7DPI/q6mqXy2V1FQBQft7Zta+/3+Sdd/YVc8nFF18QXdkYjTY0RRtnzZpmdoUAUGlsdRjmebTVXVyveq2uAgDKDztwAMYiBB+rXC4Xj8etrqIoHo8nHA5bXQUAlIe2tl2xWEvzptZYrGXfvkPFXLJ06YL+fpOpU+vMrhAAKlYsk1h9YpfVVRRljb/6X2vpQASAorADB2Aet9UFlL1UKmV1CcXKZrO5XM7t5l86AAxty5Y3mk/1mxw+fLyYSy5bvjga7es3GT++xuwKAQAicn/8sNUlFGt9b1csk4h66UQBgKGxAwdQGnSCj0kZtYEXuN3uSCRidRUAYCOvvLIttqmlsPM+ebJr2PcrihKNNjZFGwqftYxEOHYYAEqqjNrAC5q84efHz7W6CgCwEXbgAEqPpuAxSSaTVpcwMrlcjmZwABUun8/HYq3NsZZYrKU51ppM9gx7id/njUYbC/0m0Wijz+spQZ0AgCF9tnO/1SWMTHMmQTM4gArHDhyA5QhDRy+TyeTzeaurGLFkMlldXW11FQBQUqlUOrapb88di7Vks7lhL6mqChc+Yhld2RCNNpagSADAsJ5KndyvlcGJ9IN8tnN/W93FVlcBACXFDhyArRCCj14mU377bxHJ5/OapqmqanUhAGCurq54f7/Jppe2FHPJxAm1/c0myy9dZHaFAICRWt87/KfmbWi/ltmRTS3yBKwuBADMxQ4cgG0Rgo9eNpu1uoRRyuVyhOCAsTRN03Vd13VN0wpPC58Ucblchb9uhTFELpfL5XJZW6qzHT12MhZrKey8f/e714u5ZNq0SdFoQ9PKxmi0YcmSi8yuEAAwFmUagotIcyZBCA4YbNc2SXRKolPe2Soi8l67HG4XEZk8S6bMEhFZtqrv6eSZ1lRYGdiBAygLhOCjZFICns3m3n67fdv2t99998iCi2YvXjy/vn6yoijGrpJOp30+n7H3BCpTNpvNZDK5XK744Uiqqrrdbp/Px++ijPLuu4f7+02273i7mEvmzJ7e12+ysnHBgjlmVwgAMMQvTErAc1r+nYPajnb94HHX/OmuS2a7ZkwQo3fgT6VOfiE00dh7AhUq9pz89lnZsrEv8i7GvKWybJWsvknmLjGxsErCDhxA2VF0Xbe6hrKUTCYNH4eyZ++7n/jEne37Dg18cc1VV/z9E/cGAn5j16qpqTE8WwcqRyaTyWQyY/xlmKIoHo/H5/NxVu0o7N5zoL/fZOfOvcVcctFFcwp77qZow5w5M8yuEABguM917n8qddLYe+bbj/T+jwfy+48OfNH94Uv9j31BAgZ3jRycvKhK4VfgwGht+IE0J2ytqQAAIABJREFUPyvNz47pJuEaaVorH7lJll5hUFkVhB04gLJGCD5KXV1dxp6KuX3H22s+emsiMcQRycuWLXjuZ4+Gw0EDlwuFQl6v18AbAhUik8mkUilj//q73e5AIEAUPqw339wTi7U0x1pim1r37n23mEuWLJ7f328yffoksysEAJhq4dE3jD0VM/96e+oTX9cTvWd/ybXkgsDTf6GEjexEeaKm/obAOANvCFSKDT+Q760bQd93MZatklvWEYUPix04AMcgcxmN/mm/Bvrrb/x9IQH/QFPjd75zV/2MKVu3vnXDjV85drxjy5Y3n37ml39yyx8buFw2myUEB0Ykl8ulUqlcbvgzzUdx53g87vF4gsEgE8MH2brtrf5+k0OHjg5/gcilly4qnCbfFG2YOJGsAQAcYkc2ZWwCLiLpB58pJODqyoW+Bz/jmj5B276395aH9OPd+W27cz9t9nz69w1crjmdIAQHRmbri/K9dbJlo/F33rJRbl8lTWvli48wMXwQduAAHIlO8NEoJFYG3nDXrv3LV3xSRKZOrXt5079EIqHC621tu5qu+LSIXHDBjFdf/pGB6Zjb7Y5EIkbdDXC2fD6fTCbNiL/P5vV6g8FghU8r2rx5RyzW0rypJRZrPX68o5hLoisbCs0m0WhDdTXf3ADAgWKZxOoTuwy8YX73ez1XfFlElCnjgr/5thLpO7Uy/+b+nt//qoi45kwJbnxIXIb9T7nJG35+/Fyj7gY43OF9cv9NpsTfZ1t9k3zpEQlVl2Itu2IHDsDx6AQfDcOzsJ/++68LD2769NX9CbiILFw49/IVS15+Zdvu3QdaW9983/sWGrWipmlG3QpwNk3T4vF4yX5fmMlkNE0Lh8OV1hLeHGuJxVoLn7WMx5PDvt/r9fTvuZuijX4/h/0CgMM1ZxLG3jD33EuFB54bP9SfgIuIa0G9etlF2qtv5fe8p23drTYYFltvz6WMuhXgcLu2ye2rJNFZouU2fF92bZX7n620lnB24AAqCiG4LbS39x2GufrD0UFfuvrqD778yjYR2X/gPQNDcD4BABQjk8kkk8NvB42laVp3d3ckElFVJ5+dlU5nYpv69tyxWGs6Pfwn3MPhYNOp8YLRaEOl/Z4AAGCs/L6+z/i7/6Bx0Jfcay7TXn1LRPQDx8S4ELwrTxsKUIQNP5D7byr1ou9slZuXymMbZe6SUi9dQuzAAVQyQvDRMHwg+MGDRwoPZs6cOuhLM2ZMLjw4cviEsYsCOL+enp50Om3J0rqud3d3O+8A23g8ObDfpJhLxo+vKYwXjEYbVlzm5J9JAADnZ3iCrB/q210rM+oGfUmZNqHvPUeLmgkAwDCP3SnPPGLN0olOuXmp3PN9Wf1pawowBztwACggBB8Nw2eJvPtuXwgeDgcHfWlcbVXhweEjx41dNJfLud38BwAMQdf1ZDKZzWatLaMwiDwYHPxtobwcP9EZi7XEYi3NsdbNm7cXc8mUKROj0camlQ3RaOOyZQvMrhAAUBa2Zw2eJaIf7NtdK2H/oC8ptX3DbfWjBk9jiGUSUW/Y2HsCDpHskm/cJM3PWlzG/TfJrq1y+8MWlzE27MAB4GxkoLZw/ESniEycUHv2lwLBvk15V5fBYxABnEtPT4/lCXhBOp1WVdXnK7Nxe4cOHS3suWOxlq3b3irmklkzp0Wjff0mCy/m0DAAgOn0k90iokyoOvtLSqDvk1h6V09JawIq2XfvsD4BL3jmEZk8S675ktV1jAw7cAA4P0JwW5g2rW7nzvZjQx3B3HGyq/Cgrm5caYsCKlRvb28mM/x0vJLp6elxuVwej8fqQoaxt/1gf7/Jm2/uLuaSCy+c1d9vMnduvdkVAgAwkDJ1vP72Qf1499lf0jv6uk+UidWlLQqoVE9+TTZ83+oiBnj0DpkyS6JXW13HMNiBA0DxCMFtYdq0STt3totIPJ6MREIDv1RoEheRSZPGl76wgv/8VSwcCtbUVtXWVNXURILBgFWVAGbLZDKplMGfth67ZDJpz3Myd+7cG4u1NsdaYptadu8+UMwliy65MBptKBytU18/xewKAQA4F2XKeHn7oIjo8ZQSOWN/q5/oS8aVuhoLKhMRke7X9qoBrxr2qWG/Gva5/Hb/dTgweht+IN9bZ3URZ/nGTfY8J5MdOACMDiG4LUydOrHw4J139jU0XDzwS2+80ffrXMND8OKPdX7ssad+8fyL/U99Pm9NTaSmpqqmpqq270Gktraq8KCmpi8rr6mpqqmtqq2JMHkc5ULTtJ4eO37qWdf1RCJRVVWlKIrVtcj2HW/395u8++7hYi5pbFxYOFqnKdowadIEsysEAKAYrqnjCuf85HcfUpdeMPBL+bf6ciVlksEheL1a7JHXx37W2v3q6b5OxaOqYb/7VCY+6J/usE+NnPGKoha71QcstmubPHqH1UUMJdEpd6+V72+VkPWfCGEHDgBjRzo5Gh6PJ5fLGXjDBfPnFB6s/8VvB4bguq4//cx/Fh5fOG+mgSvKSELwzs4zPiWaTmeOHDlx5MiJIi+PhEM1taey8pozs/LaQWF6VXU1JwXBGrqux+NxXdetLmRo+Xw+Ho9XVQ0xt7QEfve712Ox1uZNLbFYy9GjJ4u55P2XLy2MF4yubKyttaZsAICTNPnCzRkjz8hxXTi98EDb8NoZIbiuZ3/a3PeeC6YauKKMJATXEr0Dn+pZLdeRzHUki7zcFfCekZhHBibmZ8XooTI7fQTOkeyS21dJwuATaA1zuF1uXyXf22LJ4uzAAcBYhOC2cM21f/gXf/WoiPzTP//0lps/Nn36pMLrP3v2vw8dOioil69YcuGFs6wqr6MzPpbL44lkPJE8cKCo31e7XK7TWXntmX3lhay89ozQPBBgyw5j9PT02DYBL9A0LZPJeL3F/vA8Rpte2hKLtRQ+a9nVNfw3AbdbjUYb+/tNmJsEALA59x9H01/7FxHJ/uBXnv/5e8q0vk7J3M9f0d87KSLqZRe55k2zqjwtkR7L5flUJpPKyLHitvEu5VRiPjgfHyIxD/tdPn6KhEG+e4d9E/CCd7bKhh/I6k+XZjV24ABgHrYvo2H4RIIJ42tuuGHNU0+tTyR6PvbxL/2fr98+a+bUV17d9r+//O3CGz77p9cYu+KIhgvPmjm1ujrc2dnd2Rnv6Oju7R3Tjvz88vn8yZNdJ08dBzosv993xgyW2oGh+YDG81Ov23CqMuwgn8/b6jDMc0mlUh6Px6ShKNlsLhZriW1qbY61xGItqdTwf9ODwUBT4UD5lQ3RaKPbzd8vAIBZqhWD/y+jjK/yXL8q+28b9URv6pMPeP/qBtfMOm3zzvRX/7nwBs8tf2jsios9I8invJOr1JBPS/RqiV4tkc5njPwc6mB5Pdfdm+vuHf6dIiLi8rrPTsYHJ+aR05G64rJ+nhvs6PA+ex2GeS7fWycfWGvSUBR24ABQMorNOx/tKZfLxeNjao4+2+HDx6+57sttbbvO/tINN6x5+G/uMvb/bW63OxKJjO7a3t50R2d3Z2e8s6O7s7O7ozPe2dndH5H3PTj1Smdnt6blDax8jKqqwqdC875e8nMNNK+trRp0SCkcLJFIZLNZq6soSiAQ8Pv9Rt0tmUwVNtyFfpN8fvi/rbW1VdGVjdFoQzTa+P7LlxpVCQAA5xfLJFafGGKrPBb6kY7UjQ/m39x/9pc816/yffNPxNAdeJM3/Pz4uaO7Np/JaYl0IRDv+2e8V0v05ga9mOjVEulcolfyNvopTw16ByfmkXPON1eDJfrQG6x3z8ek+VmriyjOLevk5vuMuhk7cACwBCH4aOTz+a6uYluVixePJ2+97Rvrf/HiwBfv/upn/uzLNxne+Onz+YLBoLH3PJfu7sTprLzjzNC8s7uz44zQPB4vdtBhCaiq2j+AZfBA89qzTgGtqfL72bKXJTN+rWUeRVGqq6vH8j3h5Mmu2KbWWKylOdbyyivbirlk0qQJ/f0mjY0LR700AACjtl/LLDz6huG31eOp9J1P5H752sAXvX92jfdLa8XoHfitoYnfrCrRfBWtJ63FB+fj50rM8z02+jyc4nINnGB++uTPc5wIqnj5cHN52vqi3L7K6iKKFq6Rn7SPpRmcHTgAWI4QfJS6u7s1TTPjzul05o03dh8+cmLuBTPmzJmhmnOweyQScbvtuF/M5bRCRH4qNI93dnZ3nGoqP7sDPZ220ZY9EPD3ZeVnReT901oGNqG7+GSoPcTjcWOPujXbKH6Jdfjw8f5+k9YtRSUI9fVTTvWbNCy65MJRVQoAgJFWHt+5PZsy5dbpbP6t/fkjna45U1yzJ4s5O/AN4+dGvXY8BF7X8oPbzE8n5v1d56df1LOm/Bw0Oi6f+7yJ+emjQQvTWgz/3QZG6YtXypaNVhcxEtfeIbc/PKIr2IEDgK0Qgo9Sb29vKmXOFtx8iqLU1NRYXYUxenp6Bw9g6TgrNB/QgW6r/+CrqyNnDS4fMKTl1OmghQfhcIk69yuNpmnd3d1WVzFiNTU1RTaDP7/ht3d95aEhRy2dbe7c+mi0sWllQzTaaOFhvAAADOmBxOH740WdtW5D1S713UmLrK7CGPl09oy4/KyW80ExuthoAy5qyDcwH3efnmA+xHxzV4APeppj1za5uQxnevyys8hmcHbgAGBDhOCjVKbBWYHH4wmH7diEUgJ9mfiZEXlHx6msfMCI846OeDLZY3W9p3k87gGDy09l5bWnM/RBp4B6vR6rSy4PPT096bSJZ72aJBwOezxF/Svujieray49zxsWXjw3euqDlrNmlegz2gAAjML2bGrl8Z1WVzFKa/zV/1o72+oqrDHcSJa+qSyFlvN8r42OaVFUV6GLfIiTPwcn5n417FM8HFFYnMfulGcesbqIkXvgWYleXcwb2YEDgA3ZcSBGWVBV1eVyFXOEhQ15vZXb0VBTE6mpKfZE0Gw21z+1/Iy+8s7ujo7BoXlnRzxj5smK2Wzu2LGTx46dLPL9wWBgyIHmQ09rqa0yr3KbK69BKP0ymUyRIXhVJLR8+aLNm3cMfHHZsgX9/SZTpkw0p0YAAAy22BOoV737NRtNwyveGv/opwmXOzXsU8O+It+s5/KDk/HBx4Ge8bqeM3E2i67lc109ua5iO2Ncfs+gXvIzRrL0T2s51XhuXuV2V16DUPr9ttgQnB04ANgQIfjoud3uTKYst+BFZmfweNx1E8fVTRxX5PuTyVTHqUB8cGh+5ijzQje6qcX39KR6elIHDx0t8v2nG8xrzzoFtKaqpvaM0DwUCphafMnk83kzhvufONG1Zcube/a+W1MTWbpk/gUX1Bs+3D87kt+4RKONmzfvWHHZkv5+k/HjHTIQCQBQaZq84adSxfYE2MoaX+WG4COiuF3umqC7pthJgPnebF9iHh9iJMvZveemFp/vzeZ7s9njiSLff86TPyNDvO7yO+WHuMP75J2txt92xoXywWtl3lLpOCovrZfXfi05o1uUmp8VebLI97IDBwC7YRzK6JXpRBSv1xsKhayuAqLr+qDTPgeH5qea0AvBek9Pr9Uln+b1egYNLj/zFNDBYbrHY9Pft6XT6Z4eI4fe9PamH/zW97776L8Mev2rX/nMXX9+s4ELiUhVVZWqFvWR2xd/+1pjw0LGygMAHKBMJ6LcEBj3RE291VVARJcBPebnmWPe13KeT9tpNotbPd1mftYQczXsHzStRXGbcr6rAX78XXn0DiNvGKmVhzbIxZcNfr31BfnSB41cSESe3CpzlxTzRnbgAGA3hOBjkkwmy64ZvLq62uWy634I55ZOZ8512uegqSyF0Dxn5idDRyocDtacmmPeP9C8tnboU0Crq4udVzN2iURiRC3V59fZGb/hxq+8/Mq2Ib/6pS/eeN+9nzdqLRHx+XzBILtqAEDF+Vzn/rJrBm+ru7herdyBhOVLz2pDzzGPn3Hy5+nZLJqNpmW6Ap5BI8vPPvnz9MTzULHzagxwz8ek+VnD7jZ5lnx/m4TOMd3xjVflsysMW0tErr1Dbn/YyBsCAEqFEHxM8vl8V1eX1VWMAKlZ5YjHk+cJzfsbzAuheXd3sZ/ZLAFFUfoHsJxxCmhNpPasEec1tVXBwOjHKXZ0dBhVdi6n/Y8b7/qv/3ql/5Wbb1q7e/eB3za39L/y/Pq/W7FisVErut3uSKR0vzAAAMAm9muZhUffsLqKEbg1NPGbVRx8VxHyqUwuPvjMz3PON0/a6Wx2RRl6MEvYr0aGmG/u8o3hg55NimFle3zys3elesLpV/a9KeMmS6T29Ct/8wV59u8MW3HZKnn0BcPuBgAoIZvOKCgXLpfL5/Ol03bavpyboiiBgENGOWNYkUgoEgnNmDG5mDfn8/mO857/eTo074x3dnSnek38b17X9ZMdXSc7iv31ks/n7cvKa/tC8x899ZB55Z3Lhl/G+hPwtWs/+O0H/2z8+GoRaWvb1XTFpwuvt7S2GRiC8ytMAEBlqle9t4Ym/t/kMasLKUq1S707XNR+DA7gCni9Aa/UFdemkNeHSMbPTszjfWF6PmPmce66rsV7tXhvkR9zVjzq6cQ84lPD/ll/8VETyzuXP/na6QT86AG54/fkwNsiIld8XP76J32vr1htZAie6DTsVgCA0qITfKx0Xe/q6iqLP8ZAIOD3V/AR5DBOb2+649T5n4NO++zoGBia972ulfCToddf/5F/LS4EN3asv67rX/8/T3z30X9ZterSf/vRt73e0ycX/dHVt8U2bRGRNVdd8cMf3G/UiiJSW1s7/JsAAHCcrry28NgbXXkbDX87l3sikwnBYYh8JjfozM8zp7IM/qeeL92PqLUfXFBsCL5rm9y81LCFXS75u5fk4suk+6R8YqakBny8dUOHhGtERE68J2unGraiiDSXwc/+AICz0Qk+Voqi+P3+VCpldSHDUBTF5yvhoDc4mt/vmzJ54pTJE4t8f3d3ov/8z8Gh+VlhejyeHEtttTXnGAh4FmN/d6Uoyn33fn7BgjmrPxwdmICLyLx5Mwsh+IkTdI4AAGCAapd6a2ji/fHDVhcyjGqX+oVgsfsl4PxcXrdrnNszLlTk+7Vk+nwN5me+nu8Z00lXarjonzSN7aTO5+WzK+TLfys//MYZCbiInHivLwT3F/snBgBwNkJwA/j9/lwuZ+DxeoZTFCUSiSiKccPXgJGoqgpXVYVn1hf15lxOG26U+Rlhejp9xpa9pugQ3AzXXvOHg145ebLrxz/5VeHx0mUXGbtcPp/nnFsAQGW6Ozx5eza1vte+x/NUu9Tnx82tdqlWF4IKpYZ8asgnk4raG+tafqjEfNBUltON53r2jM9hqGFLP3D8N18Y/Mr0uVJ/auN9aLfByx3eJ5NnGnxPAID5CMGNEQqF4vG4ptn0I5nBYFBV2X+jPLjd6oQJtRMmFDvoo6end2AjeaDoczJzOTPnKvYtod355W8lEj2Fp5/+1B8Ze39CcABAJXuiuv4j2q7tWZt+IvPBqmmLPZzHg/KgqC53dcBdXex/sfl0ti8fj6e1RK/i8wx/TcGWjaOrcAQ8PnnsRenvAPvHvzT4/ofbCcEBoBwRghtDUZRwONzd3W3D4eCBQMDr9VpdBWCWYNAfDPqnTq2zupDB8vn8nV/+1n/8x8bC01u/8MkLL5xlZUEAADhLtUv919rZ7z++04bDwe+JTL4hMM7qKgCzuHwel8/jGR+2upCzuFT54Q6ZcGoI+M4Wefl5SwsCANgFLYSGcblckUhx54CXkNfr5TBMoPR0Xb/7nkeeemp94ekf/P7777v389aWBACA89Sr3ufHzbW6isFuCIzjMEzAAi6XPLlFps/re9pxVD6/0tKCAAA2QghuJFVVQyEbHbuhqmowGLS6CsCmzJsRlEr1fvZzX//Hf/pp4en8+bP+8R/Wud2MJAIAwHiLPYEnaoo7eKQkFnsCD1ZNs7oKwK7mLTXrztXj5ek9MmdR39NsWv6kQbJps5YDAJQbQnCDeb3ecDhshyMovV4vh2EC52HS347Dh4+v+aPbfvLTvsMwL7hgxk+eeTgSMeXXY243I60AAJAbAuP+tXa2HY6gvCEwjsMwgfMJ15hy23lL5ScDzqvMZuTWD8ixg6astfQKU24LADAZIbjxPB5PJBKx9rQ6v98fCoVIwIES27Z95xWrbtqy5c3C08tXLPnVL/9h2jTbzSsHAMBh1virnx83t1618iCcu8OTn6ipJwEHSu33Pin/1CL+U00nyW65cYG8udnSmgAAtkMIbgpVVauqqswbtnAeiqKEQqFAgJPogWEY3kb93HO/ufKDtxw73lF4+scf+71//+kjtbVVxq7Sz9rftAEAYDeLPYGXJsxf7LFgG1ztUp+oqb8nwhxwYDiGt1Hf/h2570fSvzE+sl8+Xi+H9hi8Sr/Js8y6MwDAZIqu61bX4GTJZDKTyZRsOUVRIpGIJeE7UI46OjqMutXBg0cXLfnYwFcuuGCG263mcpqIaDlNRDLZ3K//8x+mTJloyIput9uGh/ECAGC5z3Xufyp1smTLVbvU58fNtSR8B8pSk3GfV16wXP7h1TNeyWZEdBFFREQ59c/PrpCdLcasuGyVPPqCMbcCAJQW82TNFQqFfD5fT0+PpmmmLqQois/n8/v9jEABiqeqqlF/Nwth90C7dx84+229acN+K0YnOAAAQ3qipv6G4Livdh/cnk2ZulC1S/1CcOKtoYmMQAFGYN5SeWerMbfynDUB6exXRCQQNmY5oRMcAMoYGYrp3G53VVVVKBQyL7Hyer1VVVWBQIAEHBgRAyeiuFxF/e1zKYZ9H/B6rRx7CgCAnTV5w5smzH+ipt68KeE3BMa9NGH+PZHJJODAyCxbZdit8sW1sxT5tmJ8YK1htwIAlBbjUEoqlUql02kD/8zdbrep8TrgbJqmdXd3W13FKNXU1PB7LwAAhnV//PDf9hzrMi4Fa/KGTY3XAYd7Z6vcsszqIkZrQ4eEa6wuAgAwGoTgFshms5lMJpfL5fP50d3BcwrxNzBGnZ2d5fht0OPxhMPGfa4TAACnW9/btb63qzmT2K+NcjTZVf7qJm/4o/5q4m9grFbXSqLT6iJGrmmt3P8zq4sAAIwSM8EtUMivRUTTtFwul8lkNE0bNoZTVVVVVa/X63a7af8EjOLxeEp5eq1RCt9DAABAkdb4q9f4q0VkezbVnEms7+3akUsN2x6+2BNY5A6s8Vc3ecOMPQEM07RWNnzf6iJGzsBBLgCAkqMT3F5yuZyI6Lqez+dVVRURl8tFuzdgnmw2m0gkrK5ixKqrq/nOAACAIZozCRHpymv7tMxiT0BEZqpe2r0BE8Wek7vLcLj2j/dyMCYAlC86we3FwGP6ABTD7Xa7XK5RzyayRKFmq6sAAMAhmrxMGANKa+kVMnmWHG63uo6RWLaKBBwAyhoxCoCKpihKIBCwuoqRKbuCAQAAgNPCNXLLOquLGKGb77O6AgDAmBCCA6h0Xq+3jBqrCwcDWF0FAAAAMAarP11OjdWrb2IgOACUu7LJfTB2qVSv1SUANhUMBq0uoVi0gQMAUEbYgQPn9MWHra6gaLfQBg4AZY8QvFKs/8XGRUuu/sEPn7W6EMCOPB5PWbRX+3y+MmpaBwCgwrEDB86naW15tFdfe0c5Na0DAM5B0XXd6hpgujv/9zcf+e4PRaSmJrJj28+nT59kdUWA7eRyuXg8bnUV56MoSnV1taIoVhcCAACGxw4cGN6WjfLFK60u4rzCNfLjvRKusboOAMBY0VHofK1b3ijsv0WkszN+x50PWFsPYE9utzsUClldxfmEw2EScAAAygI7cKAoy1bJPU9aXcR53f8zEnAAcAZ13bp1VtcAc02ZMjEUCvz6v14qPH3zzd2TJo2/9H2XWFsVYEOqqubzeU3TrC5kCKFQyOPxWF0FAAAoCjtwoFjzlsrhfbJrq9V1DOWeJ6VprdVFAACMwTiUSrH6I3/6y/+MFR57vZ4d25+7cN4sSysCbCoej+dyOaurOIPX67V5lzoAADgbO3CgWF+8UrZstLqIM62+ye5d6gCAkWAcSqV4+Dt3ezx95/5lMtk77vymtfUAthUOh1VVtbqK0+w/pwUAAAyJHThQrPt/JvOWWl3EAPaf0wIAGCHGoVSKCRNqx42rfn7DbwtPd+3aF4mE3n+5nfYZgD0oiuJ2uzOZjNWFiIioqhqJRBgFDgBAOWIHDhTL65eLV8h/Py2ZXqtLEZm3VB7aIF6/1XUAAIzEOJTK8sef+OLPfvZf/U+3tv77kiUXWVgPYFv5fD6RSFg7H9zj8YRCIRJwAADKGjtwoFiH2+Wej8k7ls4Hb1or9zzJYZgA4DyE4JVl//73Fi25urs7UXi66opLX/jND6wtCbAtXdeTyWQ2m7VkdZ/PFwwGLVkaAAAYiB04MAKJTrn/Zml+1prVr/mSfPERa5YGAJiMcSiVpbo6MnnyhOd+/pvC0/Z9h9xu9QMfeJ+1VQH2pCiK1+vVdb30/eChUMjv5wOYAAA4ATtwYAS8fvnQ9ZLolDdeLfXS9zwpN3611IsCAEqFTvBKdOOn7nrqR+v7n74U+9HljCYEzi2TyfT09JTmu6XL5bLbyZwAAGDs2IEDI7Ph+/LonZLoLMVak2fZ7mROAIDRCMEr0fHjHYuWXH348PHC0+WXLnr1laetLQmwOV3XU6lUOp02bwlFUXw+n9/vZwg4AADOww4cGLFEp3xvnfz4uyYuEa6Ra74k197BEHAAcDzGoVSiYDAwY/rkn/z0V4WnBw8dzWQyH/rQ5dZWBdiZoigej8fn85k0HcXv94fDYY/HQwIOAIAjsQMHRszrl8s+LB+5SRKdsmub8fe/+T752r/JZR8WL3MIAcD5CMEr1CWXzDt06Ghr6xuFp7FYa1O0cc6c6dZWBdhcYUq4x+PRdT2fzxt1w3A47PV6ib8BAHA2duDAaIRrpGmtLFsl8U7Zv9P2PE+zAAAgAElEQVSYG37oOnngWWlaS/wNAJWDcSiVK5lMLV66ds+eA4Wnl1wyb8e256wtCSgjuq7ncrlMJpPNZkf6jdTlcnlOMak8AABgQ+zAgTFJdMqWjdL8rDQ/N+Jx4ZNnSdPVsmyVNK01pzgAgK0Rgle0//iPF/5o7a39T7/0xU898vDdFtYDlClN0zKZTP+klHw+P7BPXFXVQpe32+0uxN8ul8uyWgEAgKXYgQPGeGerND8riU55Z6uIyOF9crj99FfnLZVQtYjIslUSrpEPrJXJs6yoEgBgF4Tgle6OOx/47qP/r//pz5/724+uWWVdOQAAAIDDsQMHAAAoMULwSqfr+uIla19ve6fwdM6cGTu2PRcMMhkNAAAAMAU7cAAAgBLjI/mVTlGUhx/+av/TPXsO3HHnAxbWAwAAADgbO3AAAIASU9etW2d1DbDYnDkz0ulMbFNr4Wlr6xsLFsy5ZOE8a6sCAAAAnIodOAAAQCkxDgV9Lltx3ebXdhQeT548Ycf2n08YX2NtSQAAAICDsQMHAAAoDcahoM/D3zn9kczDh4/zkUwAAADAVOzAAQAASoNxKOgzY8YUVXW9sHFz4emOHW/Pmjl16dIF1lYFAAAAOBU7cAAAgNKgExyn/dVffv6KKy7tf3rHnQ8cOPCehfUApbdz597LV37yP38Vs7oQAABQEdiBA70HTr59+790v7bX6kIAAE5GCI4zPPKdu/sfd3Un7rjzmxYWA5TefV97/JVXtn149Z9+6n9+ZffuA1aXAwAAnI8dOCrc4R/Ekm8c2v3VH+97YH36UKfV5QAAnIlxKDjD5MkTIpHgr379UuHpm2/tqasbd+mli6ytCiiNXzz/4l/8xSOFx9t3vL10yUXLlvF5ZAAAYC524Khk3a/sPvTPzYXHqT3HAnPrgnMnWVsSAMCRFF3Xra4BtvORqz674Zd9GxGPx71j23Pz58+2tiSgBC5dfs3vWtoKj69ctfw3//19S8sBAAAVhB04KtPOz/+w5+3DhcfhpfXz/uZ6a+sBADgV41AwhEcevtvr9RQeZ7M5zqlHJfj/7d15nNV1vT/wMzPMDDMM+w4yKosLJCq5g0uWuWTuljtWWl0hA6yEFjloKd26DLmU6fV28dJN/V0FUjH3FHAHZREFlU2UUZQdBmaYOb8/TvcL1xRZ5sznnO95Pv/6vHvYzMtHmZ9efr6fz+9u/q+oAU8kEsnk0IBhAIB8YwdOHlr5wMyoAU8kEl0HDwwYBoB4cx0Kn6J9+zYdOrR9eOoz6fHtd5ZVVJQfc8yhYVNB5qxatfacc3+weXNterzyivOGDrk4bCQAIK/YgZNv6tdvXjR6Uqq2Pj22/9rBHc8aEDYSADHmOhQ+03nn//D+Bx6Pxlmv3O9+ZOLq6h/+6pZb/5xeN29e+s5bj3br1ilsJAAgD9mBkz+W3/rEykmz0uuCkmb9Jn63uH1F2EgAxJjrUPhMVVWj2rRpGY3DRvgkk3h6+eW5UQOeSCSSo4dowAGAIOzAyROb3lwRNeCJRKLr4IEacAAyynUofKbWrSq6dOk4ZcqT6XHp0vcLCwuOP/7wsKmg0V35vevefntZet2vX+//nvibsHkAgLxlB06eWPZvj255b3V63XyfDvv87Oth8wAQe06CsyOXDz7r0kvOiMbRyVtnPPdqwDzQ6P5yz8OPPDItGsd4DxMACMoOnNhb/dQb615aFI1dBw8KGAaAPOFOcD7Hxx+v6X/wWe+v+DA9HnbYF15+8b6wkaAR7X/AqQvfWppen3nmiZMfuDVsHgAAO3Dibf7gO7cs/8cx8NYD+/S8/uyweQDIB06C8znat29TVTUyGl95Zd7IUeMC5oFGdMMv/xA14IlEYsxox8ABgPDswImx6onPRQ14IpHoOnhgwDAA5A93gvP5+vXrvaJ65cyZr6fHGTNmDRo4oGfPHmFTwR5asuS9c869Ovoa5poRl1926ZlhIwEApNmBE0u11WsXXTc5Gjudf3i7r34hYB4A8ofrUNgpNTWbDzr4rHfe+cfjgX379p47e0phYUHYVLAnLv/WqAl3T0mvO3Vq985bj1VUlIeNBAAQsQMnfpb+euqqx+al183alPeb+L3CsuKwkQDIE65DYaeUlTUfv90nmfPnvz18xE0B88AeeuLJ56MGPJFIjBk9VAMOAGQVO3BiZv2spVEDnkgkul4+SAMOQJNxHQo7a7/99lm7dv0LL85Ojy++NGfAoQfuv/++YVPB7rns8pHvvludXh9z9CF/+P3osHkAAP6ZHThxsnTsw3Ufrk+vW/Tr3mPYV8PmASCvOAnOLqgaN/Kgg/aLxmHDb9q4cVPAPLB7/njHvTNmvBqNyaT3MAGALGUHTjx89OBrG+e9F43ewwSgiSnB2TXjx237JHPxkveGDR8bMAzsho0ba0Ynb4vGSy8946SvHBMwDwDAjtmBk+saNtetmDAjGtud1K/lF/cJFweAfOQ6FHbNvvvuVVdXN236zPQ469X5Bxyw7xe+0CdsKth5P/v5+Mcffy69LihITLr/lrZtW4WNBACwA3bg5Lr375q2fuaSaOx5/TlFLZuHiwNAPipIpVKhM5B7jjrmghdfnJNed+7cfu7sKR07tgsbCXbGnDkLDj707Ggckxx63S+uCpgHAGAn2YGTo2oWrXzzyj9FY9fLB3W51IeYADQ116GwO6rGjYrWH3zwsU8yyRWjx2y7CKV370oNOACQK+zAyVErJkyP1qXd22rAAQjCdSjsjh57dSkuLnrq6RfT49x5Cysrux566IFhU8GOPTDp8euv/3003vK7n23/zBQAQDazAycXrZm2sPru56Kxxw++UtazY8A8AOQt16Gw+0788uVP//2l9LplyxZzZ0/Ze+9uQRPBjvQ/+Ky58xam16ecPOiRqXeEzQMAsKtOtAMnp7x5xZ9qFq9Mr1sdvm+vseeHzQNA3nIdCruvqmrbJ5nr128cNuKmgGFgx37zm7uiBjyRSCSTQwOGAQDYPXbg5JAP7n0pasATiUTXywcFDANAnnMdCruvS+cOrVpVPPbYjPT45puLO3Roe8QRB4VNBf9sxYqVZ5979datW9Pj0CEXXXmFQygAQO6xAydX1K3auHj0pFR9Q3rseNaA9l87OGwkAPKZ61DYU1/7+r9MnfpMel1UVDR3zpQDD+gZNhJ8wve+n7zjzvvS69atK95567H27duEjQQAsNvswMl+71Y9+tFDs9ProhalfSd+t1mrsrCRAMhnrkNhT40fN7J585L0ur6+fthwn2SSXaZPnxk14IlEIjl6qAYcAMhpduBkuQ1zl0cNeCKR6Dp4oAYcgLBch8Keat++TYcObR9++B9HUd55590W5c0HDhwQNhVEvvWdny9evDy9HjCg75/u+lXYPAAAe8gOnCy37DeP1FavTa/L+3Su/MlpYfMAgJPgNILvf++b5513cjT+ZOS/zZo1P2AeiPznhElPPfVCNI7xHiYAEAt24GStVY/OW//q0mjs4j1MALKAEpzGMX7cyLZtW0ejTzLJBvX19cnkbdH4jfNPOf1rJ4SLAwDQmOzAyUKp+oYVE6ZHY9sTDmh9VK+AeQAgzXUoNI5WrSq6du04efKT6XHZshUFBYkTjj8ibCry3HWjb33woaej8X/+3/gOHdoGzAMA0IjswMlC1f85fe3z70TjvqPPbNa6PGAeAEhzEpxGc9mlZ1526ZnRmBxz2/TpMwPmIc8tWLD4VzfeHo0/HfXdAw7oGTAPAECjswMnq2x5d1X1n5+Pxs4XHdW8sn3APAAQKUilUqEzEB+rV6896OCz3nvvg/T4xQH9Xnn5/4WNRN668KIf3XPv1PS6R48u77z1WHFxs7CRAAAanR042WPJLx9c/fQb6XVJp5Z9/+t7Bc0cvAMgK/gbEo2pbdvW48eNjMaZs16/duS/BcxD3np46jNRA55IJMaMHqoBBwBiyQ6cLLHuxUVRA55IJLoMHqQBByB7+HsSjey8807+/ve+GY3/+pu7Hnt8RsA85KfkmG3vYX7phCO+9a1zAoYBAMgoO3CywfbvYVYcUtn+lIMChgGAT1CC0/iqxo3q02fvaBw2/Kb6+vqAecg3N98y8ZVX5kVjMjk0YBgAgCZgB05YKx+YuWlBdTR2HTwwYBgA+GdKcBpf8+YlVdt9kvnGG4uGDR8bMA95ZdXqtaOTt0bjFVecd9yxhwXMAwDQBOzACah+/eYVE7Z9fND+tP4V/XsEzAMA/6womUyGzkAM7ddnn/XrNzz/wuz0+NLLcw855IADDugZNhX54NqR45599uX0unnzkkn339KyZYuwkQAAmoAdOKG8f+czG+a8m14XlDTref3ZReUlYSMBwCcUpFKp0BmIrUMOPXv2nAXp9d57d5s7e4o6kox6+eW5Rxy17ULMsTeNuPYnVwTMAwDQxOzAaWKbFqxYcNV/RWO3K4/vfMGRAfMAwKdyHQoZVFU1KlovXfr+sBE+ySSztn8Ps1+/3hpwACDf2IHTxLa/CKX5Ph004ABkJ9ehkEH77tN969at06bNTI+vvvrGfvvtc9BB+4VNRVz95Z6pY399ZzT+4bbr+vbtFTAPAEDTswOnKa1+6o0P/vJiNPb44UnN9+4QMA8AfBbXoZBxRw+88IX/vZqwY8d2c+dM6dypfdhIxNL+B562cOGS9PrMM06cPOnWHf7hAACxZQdO05g/+N+3LF+VXrce2Kfn9WeHzQMAn8V1KGTc+HHbPslcuXLV8OE3BQxDXP3yV7dHDXgikUgmh4bLAgAQmB04TaB64nNRA55IJLoOHhgwDADsmOtQyLi99upcUlL81FMvpMd5897qsVeXAQP6hk1FnCxZ+t7Z51wdfddyzYjLL7v0zLCRAAACsgMn02qr1y4aPTnxvx+Wdzr/8HZf/ULQRACwI65DoYl8+aRvR7vwioryubOn7LNP97CRiI3Lv/XTCXdPTq87dWr3zluPVVSUh40EABCcHTiZs/TXU1c9Ni+9btamvN/E7xaWlYSNBAA74DoUmsj4cSOj9YYNm4b5JJNG8uSTL0QNeCKRSI4eqgEHAEjYgZMx62ctjRrwRCLRdfAgDTgAWc51KDSRzp3bt2nT8tFHp6fHBQsWt2/f+sgj+odNRQxcdvnId99dkV4fc/Qhf/j96LB5AACyhB04GbJ07MN1H65Pr1v0695j2FfD5gGAz+UkOE1n2A8vO/1rJ2wbh4+dP/+dcHGIgz/ecd+MGbOi0XuYAADbswOn0X300Gsb570Xjd7DBCAnKMFpUlVVI8vKmqfXDQ0NPslkT2zaVJMcc2s0XnrJGSd95ZiAeQAAspAdOI2oYXNd9YQZ0djupH4tv7hPuDgAsLNch0KTateudccObR96+O/pcdGid8vKSgcNHBA0FLnqZz//3WOPbduCT37glrZtWwXMAwCQhezAaUTv3zVt/StLorHn9ecUtWweLg4A7KyCVCoVOgN555sXjLjv//0tGl9+8b7DDvtCwDzkojlzFhx86NnROCY59LpfXBUwDwBANrMDZ8/VLFr55pV/isaulw/qcqkPMQHIDa5DIYCqcSPbt28TjcNGjA0YhhyVHHNbtO7du1IDDgCwA3bg7LnqCdOjdWn3thpwAHKIEpwAunXrVDVuZDTOmDFrdPLWHfzx8AmTJj0xafIT0ThmtPcwAQB2xA6cPbRm+sI109+KRu9hApBblOCEceklZwwefFY0Xn/D75+d9krAPOSW0du9h3nKyYMuuuj0gGEAAHKCHTh7Yvv3MFsdvm/bL/cNGAYAdpUSnGDGjxvVY68u0eidenbSb377H3PnLozGZNIxcACAnWIHzu758N6XahatjMYugwcFDAMAu0EJTjBt2rSsqtr2Searr77x42t/GzAPOWFF9crkdsfAhwy56Mgj+gfMAwCQQ+zA2Q11qzau2O428I5nDWhxYNeAeQBgNxQlk8nQGchffQ/s9eGHH7/yyrz0+Nxzrx511MG9e1eGTUU2+9GPf/PCC7PT69atKybdf0t5efOwkQAAcogdOLvq/duf3vjGivS6qEXpvtefXVhaHDYSAOyqglQqFToDea22tu6gg89cuHBJejxg/33nzJ5SXNwsaCiy1PTps449/pJorBo3ctgPLwuYBwAgF9mBs/M2zF3+1rD/jsa9rjqx47mHBcwDALvHdSgEVlJSPH7cqGh8c8Hi4SPGBsxDNtv+IpQBA/pqwAEAdoMdODtv+/cwy/t01oADkKOU4IR36qnHXjPi8mi87ff/PWnSE+HikKX+c8LkJ596IRrHjPYeJgDAbrIDZ2esenTe+leXRqP3MAHIXa5DIVsc+sVzXnvtzfS6srLr3NlTWrWqCBuJ7FFfX9+rz8lLl76fHr9x/in33jMubCQAgFxnB84OpBpS8y/5Y+0H69Jj2xMO2OcXZ4SNBAC7zUlwssX2n2QuW7Zi2PCbAoYh2yTH3BY14IlEIpl0DBwAYE/ZgbMD1ROmRw14IpHoMnhgwDAAsIeKkslk6AyQSCQS++zTvaGh4dlnX0mPr732Zp8+e/c/aL+wqcgGCxYu+cY3h0fjT0d995vfODVgHgCAeLAD57NseXfV4uv/Go2dLzqq7ZcODJgHAPaQ61DILgMHXfzc86+m1x06tJ07e0qXLh3CRiK4Cy/60T33Tk2ve/To8s5bjxUXNwsbCQAgNuzA+WdLfvng6qffSK9LOrbsO/F7Bc18Rw5ADvO3MbJLVdXIaP3RR6t9ksnUqc9GDXgikUiOHqoBBwBoRHbgfMK6FxdFDXgikehy+SANOAC5znUoZJfu3TuXlpY8+dQL6fH119/u3r3TFwf0C5uKgC6+5Mfvv/9hev2lE44YXzVqx388AAC7xA6cT1hy44N1H29IrysOqdxryJfD5gGAPecf55J1Ro288itfPjoahw0fu2jRuwHzENDNt0x8+ZV50Zgc7T1MAIDGZwdOZOWkmZsWVEdjV+9hAhALSnCyUdW4kQUFBen1pk01w0aMDZuHIFavXpscc2s0XvGd84477rCAeQAAYswOnEQiUb9+84oJM6Kx/Wn9K/r3CJgHABqL61DIRp06tW/TptXfHp2eHhcuXNK2baujjjw4bCqa2MhR45555uX0urS0ZNIDt7Rq2SJsJACAuLIDJ5FIvH/nMxtm/+MjgIKSop5jzikqLwkbCQAaRUEqlQqdAT7dGWcNefDBp6Nx7pwpX+jXJ2AemtLLr8w74shvROPYm0Zc+5MrAuYBAMgHduD5bNOC6gVX3R2N3a48vvMFRwbMAwCNyHUoZK/x40aWl5dF4/DhPsnMI8nktotQ+vXrrQEHAGgCduD5bMWE6dG6+T4dNOAAxIkSnOzVs2eP8VUjo/GJJ58f++s7A+ahydxzz9Spjzwbjd7DBABoGnbgeWv102+se3FRNHoPE4CYcR0K2e6CC6+5975HovHFF+494vCDAuahCex/4GkLFy5Jr88848TJk27d4R8OAEBjsgPPQ/MH//uW5avS69bH9O55wzlh8wBA43ISnGw3vmpUhw5to3H48JsChqEJ/PJXt0cNeMIxcACAJmcHnm+qJz4fNeCJRKLr4EEBwwBAJhQlk8nQGWBHKirKu3fr9MCkJ9Lju8urGxoavvQl99PF05Kl759z7g+iL1RGjLh88GVnho0EAJBv7MDzSu0HaxePnpT430/EO51/eLuvfiFoIgBofE6CkwMuvvjr37r87Gi84Zd/eOaZlwPmIXOSY26tr29Irzt1bDfGMXAAgBDswPPHigkzUg3/qMCbtSl3GzgAsaQEJzdUVY2qrOwajcNG+CQzhp586oUJEyZHYzI5tKKiPGAeAIB8ZgeeD9bPWrrq0XnR2HXwwMKykoB5ACBDlODkhtatKsaPGxWNr7325o9+/JuAeciEZHLbA5hHH33Iv3z/goBhAADynB14PqieMCNat+jXvcMZhwYMAwCZowQnZ5x99leGXHVRNP7buD898rdpAfPQuO64477pM2ZFo4tQAACCswOPt48emr1h3vJodBEKADFWED1AB9mvrm5r/4PPfHPB4vS43377zJ09paSkOGwq9tymTTW9+pxcXf1Rerz0kjPunjA2bCQAABJ24PHVsLlu/qV31K3amB7bndRv75FfCxsJADLHSXBySXFxs6qqbZ9kLly4ZNhwVxPGQXLMbVEDnkgkko6BAwBkBzvwuFpx94yoAU8kEl0cAwcg1oqSyWToDLALeveu3Lix5rnnX02Pr7wy76CD+vQ9sFfYVOyJOXMXXnrZtdE4Jjn0rLO+HDAPAADbswOPn5pFK5fe9HA0dh08qM2gPgHzAECmuQ6FnPTFw86b9er89HqvvbrMnT2lTZuWYSOx28457+pJk55Ir3v3rnxrwd/C5gEA4J/ZgcfJ4tGT10xfmF6Xdm/b9+4rw+YBgExzHQo5qapqZLRevrx62AifZOaqSZOeiBrwhItQAACylR14bKyZvjBqwBPewwQgP7gOhZy0997dUqnUM8++nB5nz36zV68eB/ffP2wqdsMFF4744MOP0+tTTh7067HXhM0DAMCnsgOPjSU3/HXr6k3pdavD9+323ROCxgGApuA6FHLYoOMumTFjVnrdvl2bObMnd+vWKWwkdslvfvsfP7n2t9H4wnP3HHlk/4B5AADYMTvwXPfhfS+998e/R+N+t17S4sBu4eIAQBNxHQo5bPy4bZ9kfrxqzfARYwOGYVdVV3+UHHNrNA656iINOABAlrMDz2l1qzau+M8Z0djxrAEacADyhOtQyGHdunUqKyt94snn0+Pr89/u1rXjF7/YL2wqdtKPfvyvL7wwO71u1api0v03l5eXhY0EAMCO2YHntPdv//vGN95Pr4talO475uzC5sVhIwFA03AdCjnvq6dc8fjjz6XXZWWlc2ZP6d2rMmwkPtf0GbOOPe6SaKwaN3LYDy8LmAcAgJ1nB56LNs5bvvCH/x2N3a86sdO5hwXMAwBNyXUo5Lzx40YWFv7jv8k1NVuGD/dJZg7Y/iKUAQP6asABAHKIHXguWjFh20Uo5X06a8AByCtKcHJe3769x1dtu5rwoYf/Pv53dwfMw+eaMGHyk0++EI3J0UMDhgEAYFfZgeecVY/OWz9raTR2GTwoYBgAaHquQyEmzjp76JS/PhWNc16bfNBB+wXMw2epr6/v3efkJUv/cRfhN84/5d57xoWNBADAbrADzxWphtT8S+6o/WBtemxzwgH7/uKMsJEAoIk5CU5MVFWNqqgoj8ZhI24KGIYdSI65LWrAE4lEcvSQgGEAANhtduC5onrC9KgBTyQSXQcPDBgGAIIoSiaToTNAI2jbplWnTu0efPDp9Lh48XslJcXHHvvFsKn4hIULl3zjm8OjcdSo717wzdMC5gEAYLfZgeeELe+uWnz9X6Ox80VHtf3SgQHzAEAQrkMhVi66+Ed/uWdqNL7w3D1HHtk/YB4+Yfv/gHrs1eXttx4tKSkOGwkAgD1hB57llvzqwdVPvZFel3Rs2XfidwuaFYWNBABNz3UoxErVuFGdOrWLRp9kZpWpjzy7/f9BSiaHasABAHKdHXg2W/fioqgBTyQSXQYP0oADkJ9ch0KsVFSUd+/e+YEHHk+Py5d/sHXr1hNPPCpsKtIuvvTH77//YXp9wglH/K5qVNg8AADsOTvwbLbkxofqPt6QXlccUrnXkC+HzQMAoTgJTtxcdOHXvv3tc6PxVzf+8em/vxQwD2m33DLx5ZfnReOY0UMDhgEAoBHZgWenlZNmblqwIhq9hwlAPnMnODG0fv3Ggw4+c+nS99Nj//77z351UthIeW716nW9+py8evU/nqS/4jvn3XnH9WEjAQDQiOzAs039+s2vX3pH/frN6bH9af0rrzklbCQACMhJcGKoZcsW47e7amPOnAXX/OjXAfOQHHNr1ICXlpYkRw8JmwcAgMZlB55tVtw9I2rAC4qLug4eFDYPAISlBCeezjrzy0OHXByN46omPDz1mYB58tnLr8y7+ZaJ0TgmObR7984B8wAAkAl24Nlj04LqlQ/MjMaugwcVd6gImAcAgnMdCrFVX19/0MFnvfHGO+mxT++958ye3Lx5adhUeehrX//+1KnPptf9+vWeN+evYfMAAJAhduBZ4p2f/s+6Fxel18336XDgXd8OmwcAgnMSnNgqKioaP25kNL719tLhI8YGzJOf7rl3atSAJxKJpPcwAQDiyw48G6x++o2oAU94DxMAEolEIlGUTCZDZ4BM6dWrsqZm84znXk2Pr8x8/Qv9evft2ztsqrxy3jeGffzxmvT6zDNOvH7MD8LmAQAgo+zAg1s8Zkr9upr0uvUxvbt+69iweQAgG7gOhfg77IjzZ858Pb3u3r3znNmT27VtHTZSnvjlr27/xXU3R+OrM+8/5JADA+YBAKBp2IGHUj3x+RV/mhaNB/zx8rLenQLmAYAs4ToU4m/7TzLfe++D4cN9ktkUli59PznmtmgcMfxyDTgAQJ6wAw+i9oN11ROmR2On8w/XgANAmutQiL/Kym4FBYm/P/Nyepw9Z0HPnnsdfPABYVPF3vARN7366hvpdceO7Sbdf3NpaUnYSAAANA078CCW//7Jmrc/TK+btSnvOebsguKisJEAIEu4DoV8cdzxl06bPjO9btu21dzZU7p37xw2Uow9+dQLXzlp2xv0v7/tun/5/gUB8wAA0PTswJvS+llL3/7xvdHY44cndTjj0IB5ACCruA6FfFFVte2TzNWr1w3zTn0mbX8RytFHH6IBBwDIQ3bgTan67hnRukXfbhpwANie61DIF926diovb/7EE8+nx/nz3+nSpcNhh30hbKpYuuPO+37/+79E413/fkOvXpUB8wAAEIQdeJP56KHZH015NRr3/tGppd3aBMwDANnGdSjkl5NPvfKxx/5xRKK0tGTu7Cl9+uwdNlLMbNq0uXefk1dUr0yPl5N+RsMAAB4ASURBVF5yxt0THPkBAMhfduCZ1rClbv4ld9St2pge253Ub++RXwsbCQCyjetQyC/jx41q1uwfj8Ns2VI7bMRNYfPET3LMrVEDnkgkkqOHBAwDAEBwduCZVj1hRtSAJxKJLoMHBgwDANnJdSjkl44d27Zr1/qRR6alx7feWtqqVcXRRx8SNlVszJ278NLLro3G5OihZ5/1lYB5AAAIzg48o2oWrVx608PR2HXwwDaD9guYBwCyk+tQyEdnn/uDyZOfjMbXXp10cP/9A+aJjXPP++EDkx5Pr3v3qnxr4d/C5gEAIEvYgWfI4uTkNdMWptel3dr2/a8rw+YBgOzkOhTy0fhxo1q2bBGNw4f7JLMRTJr8RNSAJxKJZHJowDAAAGQVO/BMWDP9ragBT7gIBQA+m+tQyEdt2rTs3LnDX//6VHpcsuS94mZFxx13WNhUue6CC6/54IOP0+uTTx70r2OvCZsHAIDsYQeeCUtu+OvW1ZvS61aH79v9uycEjQMA2ctJcPLUt791zkUXnh6NP7/u5udfeC1gnlz329/+x5w5C6LRe5gAAHyCHXjj+vC+l2oWbXuR3jFwANgBd4KTv1auXHXQwWdGh5ePPKL/C8/fEzZSjqqu/qhXn5M3bapJj0OuuujWW34eNhIAAFnIDryx1K3aOP/SOxo216XHjmceutfVJ4WNBADZzElw8lfHju3GjxsVjS++NOdnPx8fME/uSo65NWrAW7WqcAwcAIBPZQfeWKonzIga8KIWpV0GDwqbBwCynBKcvHbBBadd8Z3zovHGm+546qkXAubJRdNnzPrjHfdFY3L00A4d2gbMAwBANrMD33Mb5y3/6KFtN8l0GTywWeuygHkAIPu5DoV8t2HDpv6HnLV48fL0eNBB+815bXLYSLnlpK9+54knn0+vBwzoO/Pl/wmbBwCALGcHvofe/vG962ctTa/L+3Te//bBYfMAQPZzEpx8V1FRXjVuZDTOnbtw+IixAfPklgl3T44a8IT3MAEA2Al24Hti1WPzogY84T1MANg5RclkMnQGCOyA/fddvXrtiy/NSY8vvDj7sC/222+/fYKGygH19Q3nnHf1mjXr0+M3zj/lZz/9fthIAADkBDvw3ZNqSC0ePbl+w5b02Ob4A7pccnTYSACQE1yHAolEItHQ0ND/4LNen/92euzVq3Lu7MllZc3Dpspyv7ju5l/+6vZonD/vwQMP7BUwDwAAOcQOfDes+NP06onPReOB//Gd5nu3D5gHAHKF61AgkUgkCgsLq6q2fZL5zjvLhg33SeaOLFy4ZPsGfNTI72rAAQDYeXbgu2rL8lXbN+CdLzpKAw4AO8l1KPAPvXr22Lx5y4wZs9LjzFmv9+3bq1+/3mFTZa0fXP2refPeSq977NXlgftvLioqChsJAIDcYge+S5bf8sTmxR+l18UdW/a8/uyCQsfaAGCnuA4F/o/Dj/zGK6/MS6+7du04d/aU9u3bhI2UhaY+8uzXTt92/fddd97w7W+fGzAPAAC5yw58Z6x7cdE7P/2faKz80SntT+0fMA8A5Bb/3Bj+j/HbvVO/YsXKYd6p/zTJMbdF6xNOOEIDDgDAbrMD3xkr7p4RrSsOqdSAA8AucR0K/B+VlV0LCwv+/veX0uOcOQv22af7IYccEDZVVrnl1ol33XV/NP7nn27cZ+/uAfMAAJDT7MA/18pJMz+eOica9/7JaSVdWgfMAwA5x3Uo8CmO/9Jlzz77Snrdpk3LOa9N6dGjS9hIWWL16nW99zt51aq16fGK75x35x3Xh40EAEAM2IF/lvr1m1+/9I769ZvTY/vT+ldec0rYSACQc1yHAp9i/LhR0XrNmvXDR9wUMExWSY65LWrAS0tLkqOHhM0DAEA82IF/lhV3z4ga8ILioq6DB4bNAwC5yHUo8Cm6du1YUVH++OPPpcc33ljUuVO7ww8/KGyq4F55Zd4VV/4iGn95w9WnnXpcwDwAAMSGHfin2rSgetlv/xaN3b59XKsjewbMAwA5ynUo8JlOPe27f3t0enpdUlI8Z/aU/ffbJ2iiwE7/+r88PPWZ9Lpf397z5v41bB4AAGLGDvwT3vnp/etefCe9br5PhwPv+nbYPACQo1yHAp9pfNWo4uJm6XVtbd3w4Xn9SeY9906NGvBEIuEiFAAAGp0d+PZWP/1G1IAnEgkXoQDAbnMdCnymDh3atm/XZuojz6bHt99e1rJl+TFHHxo2VSjnfWPYxx+vSa/POOPEG66/OmweAADixw58e0vGTNm6ria9bn1M767fOjZsHgDIXU6Cw45cddWF55x9UjT+6Me/ee21NwLmCeVXN96+YMHiaHQMHACADLEDT6v+8/Ob310VjY6BA8CeUILD56iqGtm6dUU0DhsxNmCYIJYufT855rZoHDH88kMPOTBgHgAA4s0OvPaDddUTZkRjp/MOL+vdOWAeAMh1rkOBz9G6dcvOnTtM+etT6XHp0veLigqPP+7wsKma0vARY2e9Oj+97tix3aT7by4tLQkbCQCAGLMDX/77J2ve+iC9btamfN8xZxcWF4WNBAA5zUlw+Hzfuvzsiy/+ejReN/qW5557NWCepvTkUy/854RJ0ZgcPaRlyxYB8wAAkA/yeQe+/tWlqx6dF41dBw8sKncGBQD2SEEqlQqdAXLARx+t7n/wWSuqV6bHww8/6KUX7g0bqWkcd/yl06bPTK+PPuqQ52b8d9g8AADkibzdgb817L83zF2eXrfo222/Wy4JmwcAYsBJcNgpHTq0raoaGY0vvzx31E+rAuZpGnfceV/UgCe8hwkAQBPKzx34Rw/NjhrwRCLRdfCggGEAIDaU4LCzvvmNU6+84vxoHPvrO5948vmAeTJt06bN27+HecklZ3z1q56kBwCg6eTbDrxhS1313dvew2x3Ur+Wh+0TLg4AxIcSHHbB+KqRPXv2iMbhw8fG+EKh5PW3rVixctvoGDgAAE0ur3bg1RNm1H28IRq7XOYMCgA0DiU47ILy8rLx232SOe/1t4aNGBswT+bMnbvwN7+5KxqTo4f02u7/ewAAQNPInx14zaKVH9z7UjR2HTywtFubgHkAIE6Kkslk6AyQS/bfb981a9a9+OKc9Pjii3MGDOi7//77hk3V6K4acv0bby5Kr3v3qrz/f24OmwcAgLyVJzvw5b97fPOyj9Pr0m5t9h1zdtg8ABAnToLDLhtfNeoLX+gTjcNH3LRxY03API1u0uQnHpj0eDSOdhEKAABBxX4Hvmb6W2umLYzGLt7DBIBGpQSH3TF+3KhovWjR8uEjbgoYptFt/x7myV8ddMnFXw8YBgAAEnHfgVdPmB6tWx2+b7uv9A0YBgDix3UosDt69tyrtrZ2+vRZ6XHWrPkHHtBz+8Mpueu3//YfEyc+GI0T7/71Xnt1CZgHAAASsd6Bf3jfS6uemB+Ne486vaRjy4B5ACB+CmL8sjZk2pFHffOll+em1126dJgze0rHDm3DRtpD1dUf9d7v5Ojb0iFXXXjrLb8IGwkAACLx24HXrdo4/9I7GjbXpccOZx7a4+qTwkYCgPhxHQrsvqqqbZ9kVld/NHx4zn+SmRxzW9SAt2pVkRw9NGweAADYXvx24NV3z4ga8KLy0q5uAweADHAdCuy+Hj26NGtW9PTTL6bHuXMX7l3Z9dBDDwybarfNmDFryNAbovGmG4d/+cSjAuYBAIBPiNkOfOO899793bYX6btdcXzLAXsHzAMAceU6FNhTXzpx8N+feTm9btWqYu7syZWV3cJG2j0nffU7Tzz5fHo94NC+M1/5n7B5AADgU8VmB/72j+9dP2tpel3ep/P+tw8OmwcA4sp1KLCntv8kc926DcOGjw0YZrdNuHty1IAnEonk6CEBwwAAwA7EYwe+6rF5UQOeSCS6DB4YMAwAxJvrUGBPdenSoWXLFo89PiM9vvnmoo4d2x5x+EFhU+2S+vqGc867es2a9enx/PNP/vnPvh82EgAAfJYY7MATDalFoyfXb9iSntocv3+XS44JmwgAYsx1KNA4Tjv9+4888mx63axZs7mzJx9wQM+wkXbedaNvueGXf4jG1+c+2Ldvr4B5AADgc+X0DnzFn6ZXT3wuGg/8j+8037t9wDwAEG+uQ4HGMX7cyNKS4vR669atw0bkzCeZCxcu2b4BHzXySg04AADZL3d34FuWr9q+Ae984VEacADIKNehQONo375N+w5tH576THp8551lLVqUDTzm0LCpdsYPrv7VvHlvpdd77dVl0v23FBUVhY0EAACfK3d34MtveWLz4o/S6+KOLXuOObugyAE1AMggf6OFRvMv37/g3HO/Go0/ufa3s2bND5hnZ0x95Nm/3PNwNCZHDyn539M0AACQ5XJxB77uxUWrn3ojGrsOHlhQ7AwKAGSWEhwa0/hxI9u0aRWNw7P+k8wxY26L1iccf8R3vn1uwDAAALCrcm4HvuLuGdG64uDK9qf2DxgGAPKEEhwa0157dRlfNTIan532ypjrfx8wz47dcuvEl16eG43J0UMChgEAgN2QWzvwlZNmbXpzRTR2HTwwYBgAyB8FqVQqdAaIm8sGj/yviX+NxmnPThw0cEDAPJ9q9ep1vfc7edWqtenxO98599/vuCFsJAAA2D05sQOv37D59UvuqF+/OT22P61/5TWnhI0EAHnCSXBofOOrRnbr1ikahw+/KWCYz5K8/raoAS8tLUleNzRsHgAA2G05sQNfMWFG1IAXFBd1vcwxcABoIkpwaHzt2rUZP27bJ5mvzHx95KhxAfP8s9dmv/nAA49HY3L0kL326hwwDwAA7Ins34HXvPPhmmkLo7Hr4IHFHVsGzAMAeaUomUyGzgAx1K9f7+rqlTNnvp4eZ8yYNfCYQ3v16hE2VaRLlw5Dh1xUX98wffrMvn17/+XPvw2dCAAA9kiW78CL27XoeNaAVENq49zlzffusM/Pvx46EQDkEXeCQ6bU1Gzpf8iZb7+9LD327dtrzmtTioqy6/OL+W+88/rrb59/3smhgwAAwJ7KiR345qUfb17yUZvj9w8dBADySHbtBiBOyspKq8aNSq+PO+6wiXf/a7btvxOJRN8De2nAAQCIh5zYgTffu70GHACamJPgkFnDrxnbtk2r635xVeggAACQF+zAAYBPUIIDAAAAABBbWfdpGAAAAAAANBYlOAAAAAAAsaUEBwAAAAAgtpqFDgDslK1btyYSiVQqVV9fH/2LBQUFRUVFiUSisLCwsNA/0wIAgEYzvXZDIpFY21A/Z2tN9C+2LijqX1yWSCQqi0oqi0qChQMAdoUSHLJUKpXaunVrbW1tXV3dTj5gW1RU1KxZs9LS0nQzDgAA7Lx1qfppWzY8uHntQ1vWrm2o//x/QyLRv7js2JKKi8vaHVRclul4AMBuK9jJcg1oGg0NDXV1dbW1temj37unoKCguLi4pKSkuLi4EbMBAED8LKuvfWjz2oc2r51Wu2G3f0jrwqLTS1t/vXnrrzVv3YjZAIBGoQSHbJFKpWpqarZs2dKIP7OwsLCsrKykxHeaAADwSetS9Teur75t48pG/JmVRSU/bdnl4rJ2jfgzAYA9pASH8FKp1JYtWzZv3pyhvx6LiorKy8ubNXP9EQAAJBKJxLpU/W0bV962ceVOXnuyq/oXl/26VfdBJRWZ+OEAwK5SgkNgtbW1mzZtaoK/Eps1a1ZeXu66cAAA8tyfa1Zdu+69DNXf2zu2pOLXrbq7LhwAglOCQzCpVGrjxo11dXVN+UtbtGjhdhQAAPLTulT999Yse2jz2qb8pbe3qXQ7CgCEpQSHMBoaGjZs2FBfn/HjJ/+stLS0vLy86X8vAAAEtKy+9sLVi+fU1TT9rx7SouPYVt2b/vcCAGlKcAigvr5+/fr1Af/qKy4ubtGiRUFBQagAAADQlObW1Zy66u0muALls5zevPUf21S2KnA5IQAEoASHplZbW7tx48bQKRJFRUUVFRWFhYWhgwAAQGb9uWbV99csC50i0b+47C9t960scjkhADQ1JTg0qSxpwNMKCwtbtWrlPDgAADGWJQ14WmVRyfMd93ceHACamBIcmk59ff26detCp/g/ioqKWrVqFToFAABkxNy6mmM+WhA6xf/Rv7hsRof9Q6cAgPziJgRoIg0NDevXrw+d4pPq6+uz52Q6AAA0omX1taeuejt0ik+aU1eTPSfTASBPKMGhKaRSqQ0bNmTnhxe1tbVbtmwJnQIAABrTulT9hasXB3wJcwf+XLPq9xtXhk4BAHlECQ5NYePGjfX12bj/Ttu0aVNdXV3oFAAA0Gi+t2bZnLqa0Ck+07Xr3nt489rQKQAgXyjBIeNqa2uzv2LeuHFjdh5UBwCAXfXnmlUPZX3F/L21y9alsvegDADEiRIcMiuVSm3atCl0is+XSqVqarL3pAwAAOykdan6a9e9FzrF51vbUH/j+urQKQAgLyjBIbO2bNmSKyest2zZ0tDQEDoFAADskds2rszOq8D/2W0bVy6rrw2dAgDiTwkOGZRKpTZv3hw6xS5wGBwAgJy2LlV/W069OekwOAA0ASU4ZFBNTU2uHANPq62tzeYHPAEAYMduXF+dK8fA0/5cs2puFj/gCQDxoASHTGloaNiyZUvoFLssJ24wBwCAf7asvja3joGn5cQN5gCQ05TgkCl1dXWhI+yOrVu35tbpdQAASHto89rQEXbHtNoN61K5dHodAHKOEhwypbY2V5+4ydH6HgCAPJejJXgikXgwZ5MDQE5oFjoAxFMqldq6dWuj/9gPP/x41ap16XWLFmU9enRp9F+RSCTq6upKSkoy8ZMBACBD1qXqp9VuaPQfm1q5JrX6Hz+2oLx5wV4dGv1XJBKJaVs2XFzWLhM/GQBIKMEhQzJ0mPrfxk2489/vT68HDTz0r1NuzcRvcRIcAICck6HD1LU3T67702PpddHRfcv+388z8Vse2uIkOABkkOtQICNyukfO0DF2AADInGlbGv8YeJNZ21A/PQPH2AGANCU4ZESGSvArrzhv4n+NzcRP/oTcvdAcAID8lKHD1MWXn9z8rmsy8ZM/IXcvNAeA7Oc6FGh8qVQqlUpl4if37l3ZtWvHTPzkT6iv9zw9AAA5Y12qfm1DRnawhb26FnRpm4mf/Alz6mqa4LcAQH5yEhwanwYZAACakgYZANgBJTjwKRoaGkJHAACAPLK03oWEAJApSnBofDFokGPwpwAAQP6IQYO8LPf/FAAgaynBofFpkAEAoClpkAGAHVCCA5/OzeYAANCU5rrZHAAyQwkOfLpUKhU6AgAA5JG1KcdQACAjlODApyss9L8PAADQdCqLSkJHAIB4UnIBn04JDgAATUkJDgAZouSCxtesWbPQEQAAII8cW1IROgIAkL2U4MCnKCoqCh0BAADySP/istARACC2lODQ+AoKCkJH2FMx+FMAACB/tCrI+TMcrXP/TwEAspYSHBqfY9QAANCUHKMGAHZACQ4ZkblXJaMz2hl9uLKkxJs8AADkkgy+Khl9JVmYwc8lT2/eOnM/HADyXEEqlQqdAWJo06ZNW7ZsCZ1i97Vu3TqjJTsAADSukeveu23jytApdt/rnfpmsMcHgPym5IKMyOmT1IWFhRpwAAByS06fpK4sKtGAA0Dm6LkgI5o1a5a7b0sWFxeHjgAAALtmUElF68JcfZvn67nc4ANA9lOCQ6bkbpWc08fYAQDIW6eX5mqVnNPH2AEg+ynBIVNytAQvKCho1qxZ6BQAALDLji2tCB1hd7QuLBpUkpPJASBXKMEhU4qLi3PxZu3mzZuHjgAAALvj9NLWuXiz9pAWHUNHAICYy72GDnJFQUFBWVlZ6BS7pqCgoLS0NHQKAADYHa0Li37askvoFLumdWHRVeVKcADILCU4ZFBJSUluHQZv3rx57r7nCQAAF5e1y63D4ENadMzd9zwBIFfkUj0Huai8vDx0hJ1VWFjoLhQAAHLdr1t1Dx1hZ1UWlYyqyLGj6wCQi5TgkFnFxcW58s5kzl3eAgAA/+z05q2PzZF3JnPu8hYAyFFKcMi4nCiXi4qKSkpy6btRAAD4LKNyoVzuX1x2cVm70CkAIC8owSHjmjVr1qJFi9ApdqSgoKBly5ahUwAAQOM4tqTi9jaVoVPsSOvCoqnteodOAQD5QgkOTaGkpCSbz1m3bNnSe5gAAMTJxWXtsvmc9dR2vb2HCQBNRgkOTaRFixbZeTl4ixYtiorsvwEAiJvb21Rm5+Xgt7ep7F+cA1cmAkBsKMGh6VRUVGRb3VxaWprNR9QBAGBP/KXtvtlWNw9p0TGbj6gDQCwpwaHpFBQUtGjRInsuHikpKSkvLw+dAgAAMqV1YdEfWldmz8UjF5e1G9uqe+gUAJB3lODQpIqKilq1apUN58FLS0uz/LlOAADYc/2Ly57rsH82nAe/qkXHLH+uEwDiqiCVSoXOAHknlUpt2rSptrY2VIAWLVq4BQUAgPyxtqH+2nXv/blmVagAt7epdAsKAISiBIdgampqNm/e3MS/tKCgoGXLltlwFB0AAJrYjeurb9pQ3cS/tHVh0dR2vbPhKDoA5C0lOIRUW1u7adOmJvvLsKioqKKiorDQPUgAAOSpP9esunbde2sb6pvm1/UvLvtL230ri3yFCQAhKcEhsIaGhpqamkxfjVJYWFhWVuYKFAAAWFZfe+P66kxfjVJZVPLTll1cgQIA2UAJDlmhoaFh06ZNdXV1jf6TCwoKSktLmzdvXlBQ0Og/HAAActSy+tpr17330Oa1jf6TWxcWXVXecUiLjq0LXUIIAFlBCQ5ZZOvWrTU1NVu3bm2Un6b+BgCAHZtWu+Gm9dXTajc0yk9TfwNAdlKCQ9ZpaGjYunVrbW3t7h0MLywsLP5fjZ4NAADiZ1l97bTaDQ9uXvvwbh0MrywqOb1562NLKk5v3rrRswEAe04JDlmtrq6utra2oaEhkUh81gnxwsLC9FuXJSUlzZo1Kypy6gQAAHbTQ5vXPrR57dL62kQiMf0zTohXFpWk37pMd9/9i8uaNCIAsIuU4JBjUqlUfX19IpEoKCjQdwMAQKatbaifs7UmkUi0LijSdwNALlKCAwAAAAAQW4WhAwAAAAAAQKYowQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADElhIcAAAAAIDYUoIDAAAAABBbSnAAAAAAAGJLCQ4AAAAAQGwpwQEAAAAAiC0lOAAAAAAAsaUEBwAAAAAgtpTgAAAAAADE1v8HZx/KmtpMpkoAAAAASUVORK5CYII=" + } + }, + "cell_type": "markdown", + "id": "10c267f3", + "metadata": {}, + "source": [ + "As illustrated in the graph on the left below, a graph consists of nodes (or vertices) represented by grey circles, and edges, which are black lines that connect the nodes. Max-Cut problem is to find the maximum number of cut when nodes are divided into two set. \n", + "\n", + "For instance, in the right graph, nodes 0 and 1 are in set 0 (light blue), and nodes 2 and 3 are in set 1 (red). If we partition the nodes between these two sets, it will cut two edges (colored pink). Therefore, the number of cut edges in this case is 2. Basically, to find the maximum cut, we need to find the maximum number of edges where the corresponding nodes belong to different sets.\n", + "\n", + "If we write down the set numbers that follow the node sequence, we can represent this instance as a bit string \"0011\". Since switching the names of the sets doesn't influence the results, the bit string \"1100\" gives the same number of edge cut. In general, we can use a binary string of length $n$ to represent a partition of $n$ nodes into two disjoint sets. This representation is commonly used in graph theory and combinatorial optimization, and it enables us to apply various computational techniques, including classical and quantum algorithms, to solve problems such as Max-Cut.\n", + "\n", + "![network1.png](attachment:16c7f2fb-b981-4798-8346-da54e3bcbaeb.png)" + ] + }, + { + "cell_type": "markdown", + "id": "2908c43d", + "metadata": {}, + "source": [ + "The Max-Cut problem is a NP-complete problem. Classically, one way to approach this problem is to test every possible bit string, which takes an exponential amount of time as the number of nodes, denoted by $n$, grows. Specifically, for $n$ nodes, there are $2^n$ combinations to test. However, recent advancements in quantum computing offer a more efficient way to solve this problem, where $n$ qubits are used to represent $n$ nodes. Nodes are divided according to the energy level of the qubits." + ] + }, + { + "cell_type": "markdown", + "id": "4d28f719", + "metadata": {}, + "source": [ + "A cost (objective) function of the $\\alpha$-th edge (which connects $j$-th and $k$-th nodes) is defined\n", + "\n", + "$$C_\\alpha=\\frac12(1-\\sigma_z^j\\sigma_z^k)$$\n", + "\n", + "When $C_\\alpha = 1$, the $\\alpha$-th is accounted a cut edge. It will happen if and only if $j$-th and $k$-th nodes are in different set. The total number of edge cut is written as\n", "\n", - "$$H_C = \\frac{1}{2} \\sum_{i,j\\in E} C_{ij} \\sigma^{z}_{i} \\sigma^{z}_{j},$$\n", + "$$ C(z)=\\sum_\\alpha^mC_\\alpha(z)$$\n", "\n", - "where $\\sigma^{z}_{i}$ is the Pauli-z matrix on $i$th qubit and $C_{ij}$ is the weight of the edge between nodes $i$ and $j$. We set $C_{ij}=1$ for simplicity. If $\\sigma^{z}_{i}=\\sigma^{z}_{j}$, $i,j\\in S$ or $i,j\\in S \\backslash V$; if $\\sigma^{z}_{i}= -\\sigma^{z}_{j}$, $i\\in S, j\\in S \\backslash V$ or $i\\in S \\backslash V, j \\in S$. Obviously, the number of edges between $S$ and $S \\backslash V$ is maximized with the graph structure decoded from the ground state." + "where $z = z_1z_2 . . . z_n$ is the bit string. Max-Cut asks for a string $z$ for which $C(z)$ is maximized. This problem is equivlant to finding the ground state of a cost Hamiltonian\n", + "\n", + "$$H_C = \\frac{1}{2} \\sum_{i,j} \\sigma^{j}_{z} \\sigma^{k}_{z}$$" + ] + }, + { + "cell_type": "markdown", + "id": "871bff2e", + "metadata": {}, + "source": [ + "## QAOA for Max-Cut" ] }, { + "attachments": {}, + "cell_type": "markdown", + "id": "598dc69e", + "metadata": {}, + "source": [ + "The Quantum Approximate Optimization Algorithm (QAOA) utilizes a parameterized quantum circuit ([PQC](https://tensorcircuit.readthedocs.io/en/latest/textbook/chap5.html?highlight=变分)) to generate a quantum state that represents a potential solution to the Max Cut problem. The initial state, denoted as $|s\\rangle$, is a uniform superposition over computational basis states.\n", + "\n", + "$$|s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle$$\n", + "\n", + "This state is then evolved by a unitary operator that consists of $q$ layers, denoted as\n", + "\n", + "$$U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},$$\n", + "\n", + "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ and $V_{j}= e^{-i \\beta_{j} H_m}$. $H_C$ is the cost Hamiltonian introduced in previous section and the mixer Hamiltonian $H_m=\\sum_j\\sigma^j_x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1\\gamma_2 \\dots\\gamma_p=\\gamma$ and $\\beta_1\\beta_2 \\dots \\beta_p=\\beta$. It is worth noting that $\\gamma$ is restricted to lie between $0$ and $2\\pi$, and $\\beta$ is restricted to lie between $0$ and $\\pi$ due to the integer eigenvalues of $H_C$.\n", + "\n", + "It is important and also tricky to find a proper $p$. As introduced by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028), $p$ should be equal to the maximum steps between any pair of nodes. For example, in the graph above, the max steps are found between node 3 and node 1 or 0, and this number is 2. Therefore, a 2-layer PQC should be used.\n", + "\n", + "Begin with a set of initial parameters, the quantum state is calculate using the PQC and then the expected value of the cost Hamiltonian is calculated. A classical optimizer is then used to vary the parameters until a lower exptected value is found. This process is iterated a certain number of times, and the lowest expected value is approximated as the ground state energy of the cost Hamiltonian. By using the parameters that correspond to the lowest expected value, an approximate solution to the Max-Cut problem can be obtained.\n", + "\n", + "In summary, a general QAOA algorithm follows these steps:\n", + "\n", + "1. Define the cost fucntion according to the problem.\n", + "\n", + "2. Define the parameterized quantum circuit with cost Hamiltonian and mixer Hamiltonian.\n", + "\n", + "3. Define a group of initial parameters.\n", + "\n", + "4. calculate the cost function of this group of parameters.\n", + "\n", + "5. If a lower cost is found, accept it. Otherwise, keep the previously found cost.\n", + "\n", + "6. Find a new group of parameters with an optimizer.\n", + "\n", + "7. Repreat procedures 4-6 for given times. Then output the lowest cost and corresponding parameters." + ] + }, + { + "attachments": {}, "cell_type": "markdown", "id": "940fa22b", "metadata": {}, "source": [ - "## Setup" + "## The code" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 73, "id": "b0def04d", "metadata": {}, "outputs": [], @@ -46,32 +149,46 @@ "import tensorcircuit as tc\n", "import tensorflow as tf\n", "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from IPython.display import clear_output\n", + "import random\n", "\n", "K = tc.set_backend(\"tensorflow\")\n", "\n", "nlayers = 3 # the number of layers\n", - "ncircuits = 2 # the number of circuits with different initial parameters" + "ncircuits = 2 # two circuits with different initial parameters are going to be optimized at the same time\n", + "nnodes = 8 # the number of nodes" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "6e407437", "metadata": {}, "source": [ - "## Define the Graph" + "### Define the Graph" + ] + }, + { + "cell_type": "markdown", + "id": "c82972a4", + "metadata": {}, + "source": [ + "The degree of a graph is defined as the maximum number of edges connected to single nodes. For example, the graph below has a fixed degree of 3." ] }, { "cell_type": "code", - "execution_count": 2, - "id": "14a19854", + "execution_count": 74, + "id": "f1532831", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -79,15 +196,6 @@ } ], "source": [ - "def dict2graph(d):\n", - " g = nx.to_networkx_graph(d)\n", - " for e in g.edges:\n", - " if not g[e[0]][e[1]].get(\"weight\"):\n", - " g[e[0]][e[1]][\"weight\"] = 1.0\n", - " nx.draw(g, with_labels=True)\n", - " return g\n", - "\n", - "\n", "# a graph instance\n", "# each node is connected to three nodes\n", "# for example, node 0 is connected to nodes 1,7,3\n", @@ -95,48 +203,44 @@ " 0: {1: {\"weight\": 1.0}, 7: {\"weight\": 1.0}, 3: {\"weight\": 1.0}},\n", " 1: {0: {\"weight\": 1.0}, 2: {\"weight\": 1.0}, 3: {\"weight\": 1.0}},\n", " 2: {1: {\"weight\": 1.0}, 3: {\"weight\": 1.0}, 5: {\"weight\": 1.0}},\n", - " 4: {7: {\"weight\": 1.0}, 6: {\"weight\": 1.0}, 5: {\"weight\": 1.0}},\n", - " 7: {4: {\"weight\": 1.0}, 6: {\"weight\": 1.0}, 0: {\"weight\": 1.0}},\n", " 3: {1: {\"weight\": 1.0}, 2: {\"weight\": 1.0}, 0: {\"weight\": 1.0}},\n", - " 6: {7: {\"weight\": 1.0}, 4: {\"weight\": 1.0}, 5: {\"weight\": 1.0}},\n", + " 4: {7: {\"weight\": 1.0}, 6: {\"weight\": 1.0}, 5: {\"weight\": 1.0}},\n", " 5: {6: {\"weight\": 1.0}, 4: {\"weight\": 1.0}, 2: {\"weight\": 1.0}},\n", + " 6: {7: {\"weight\": 1.0}, 4: {\"weight\": 1.0}, 5: {\"weight\": 1.0}},\n", + " 7: {4: {\"weight\": 1.0}, 6: {\"weight\": 1.0}, 0: {\"weight\": 1.0}},\n", "}\n", + "pos = nx.spring_layout(nx.to_networkx_graph(example_graph_dict))\n", + "colors = ['c' for key in example_graph_dict.items()]\n", "\n", - "example_graph = dict2graph(example_graph_dict)" + "# convert to a NetworkX graph\n", + "example_graph = nx.to_networkx_graph(example_graph_dict) \n", + "nx.draw_networkx(example_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "c944f6dd", "metadata": {}, "source": [ - "## Parameterized Quantum Circuit (PQC)" - ] - }, - { - "cell_type": "markdown", - "id": "021d2cb8", - "metadata": {}, - "source": [ - "The PQC with $p$ layers can be written as:\n", - "$$\n", - "U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", - "$$\n", - "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ and $V_{j}= e^{-i \\beta_{j} \\sum_{k} \\sigma^{x}_{k}}$." + "### Parameterized Quantum Circuit (PQC)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 75, "id": "055d1257", "metadata": {}, "outputs": [], "source": [ - "def QAOAansatz(params, g=example_graph):\n", + "def QAOAansatz(params, g=example_graph, circuit=False):\n", " n = len(g.nodes) # the number of nodes\n", " c = tc.Circuit(n)\n", " for i in range(n):\n", " c.H(i)\n", + " \n", " # PQC\n", " for j in range(nlayers):\n", " # U_j\n", @@ -150,26 +254,42 @@ " # V_j\n", " for i in range(n):\n", " c.rx(i, theta=params[2 * j + 1])\n", + " \n", + " # whether to return the circuit\n", + " if circuit == True:\n", + " return c\n", "\n", " # calculate the loss function\n", " loss = 0.0\n", " for e in g.edges:\n", - " loss += c.expectation_ps(z=[e[0], e[1]])\n", + " loss += c.expectation_ps(z=[e[0], e[1]]) * g[e[0]][e[1]].get(\"weight\", 1.0)\n", "\n", " return K.real(loss)" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "5b159920", "metadata": {}, "source": [ - "## Main Optimization Loop" + "### Optimization" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "6d07ee61", + "metadata": {}, + "source": [ + "Here, two circuite with different initial parameters are optimized/trained at the same time.\n", + "\n", + "Optimizers are used to find the minimum value." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 76, "id": "b8d63c5d", "metadata": {}, "outputs": [], @@ -180,77 +300,440 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 77, "id": "c51b17a7", "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "params = K.implicit_randn(\n", + " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", + ") # initial parameters\n", + "# for M1/M2 chips, legacy.Adam is recommanded\n", + "# for other CPUs, please use tf.keras.optimizers.Adam\n", + "opt = K.optimizer(tf.keras.optimizers.legacy.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(300):\n", + " loss, grads = QAOA_vvag(params, example_graph)\n", + " params = opt.update(grads, params) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Loss\")\n", + " plt.plot(range(i+1), list_of_loss[0])\n", + " plt.plot(range(i+1), list_of_loss[1])\n", + " plt.legend([\"circuit 1\", \"circuit 2\"])\n", + " plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "98a6b152", + "metadata": {}, + "source": [ + "### Results" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "fc1c257d", + "metadata": {}, + "source": [ + "After inputing the optimized parameters back to the ansatz circuit, we can measure the probablitiy distribution of the quantum states. The states with highest probability are supposed to be the ones corresponding to Max Cut." + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "843c0ad3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #1\n", + "cost: -5.7345343 \n", + "bit strings: ['01010101', '10101010']\n", + "\n", + "Circuit #2\n", + "cost: -6.0113034 \n", + "bit strings: ['01010101', '10101010']\n" + ] + } + ], + "source": [ + "## circuit 1\n", + "c = QAOAansatz(params=params[0], g=example_graph, circuit=True)\n", + "loss = QAOAansatz(params=params[0], g=example_graph)\n", + "\n", + "# find the states with max probabilities\n", + "probs = K.numpy(c.probability())\n", + "index = np.where(probs==max(probs))[0]\n", + "states = []\n", + "for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + "print(\"Circuit #1\")\n", + "print('cost:', K.numpy(loss), '\\nbit strings:', states)\n", + "\n", + "## circuit 2\n", + "c = QAOAansatz(params=params[1], g=example_graph, circuit=True)\n", + "loss = QAOAansatz(params=params[1], g=example_graph)\n", + "\n", + "# find the states with max probabilities\n", + "probs = K.numpy(c.probability())\n", + "index = np.where(probs==max(probs))[0]\n", + "states = []\n", + "for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + "print(\"\\nCircuit #2\")\n", + "print('cost:', K.numpy(loss), '\\nbit strings:', states)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c27fb3f6", + "metadata": {}, + "source": [ + "Based on the results, quantum states with the highest probabilities are $\\ket{01010101}$ and $\\ket{10101010}$. This outcome aligns with our intuition, as swapping the labels of the groups would have an impact on the final result.\n", + "\n", + "The network plot corresponding to $\\ket{01010101}$ is:" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "fb183e97", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "colors = [\"r\" if states[0][i] == '0' else \"c\" for i in range(nnodes)]\n", + "nx.draw_networkx(example_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "4ae99ab9", + "metadata": {}, + "source": [ + "## Classical Method" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "720dd1a4", + "metadata": {}, + "source": [ + "In classial method, all situation will be checked one-by-one (brutal force). " + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "2115bb6d", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[-0.23837963 -1.1651934 ]\n", - "[-0.5175445 -1.4539642]\n", - "[-0.7306818 -1.6646069]\n", - "[-0.91530037 -1.8384367 ]\n", - "[-1.0832287 -1.9884492]\n", - "[-1.2398103 -2.120449 ]\n", - "[-1.3878661 -2.2374902]\n", - "[-1.5290209 -2.341291 ]\n", - "[-1.6642232 -2.4328852]\n", - "[-1.7940071 -2.5128942]\n", - "[-1.9186544 -2.5888019]\n", - "[-2.0382538 -2.6627793]\n", - "[-2.152771 -2.735217]\n", - "[-2.2620971 -2.8060198]\n", - "[-2.3657765 -2.8749723]\n", - "[-2.4635859 -2.942443 ]\n", - "[-2.5571456 -3.0074604]\n", - "[-2.6474872 -3.071116 ]\n", - "[-2.7343643 -3.1320357]\n", - "[-2.8174913 -3.1904984]\n", - "[-2.896546 -3.2464304]\n", - "[-2.971222 -3.298626]\n", - "[-3.0411685 -3.3485155]\n", - "[-3.1060221 -3.3945203]\n", - "[-3.1671162 -3.4365993]\n", - "[-3.2244647 -3.47741 ]\n", - "[-3.2800133 -3.51378 ]\n", - "[-3.328074 -3.5467668]\n", - "[-3.3779154 -3.5716858]\n", - "[-3.42378 -3.6026983]\n", - "[-3.4665916 -3.6264663]\n", - "[-3.5065007 -3.6452012]\n", - "[-3.5436964 -3.6676104]\n", - "[-3.5783873 -3.6827888]\n", - "[-3.6107998 -3.696251 ]\n", - "[-3.6411772 -3.710956 ]\n", - "[-3.6697989 -3.725151 ]\n", - "[-3.6969085 -3.739223 ]\n", - "[-3.7227716 -3.753837 ]\n", - "[-3.747642 -3.7637105]\n", - "[-3.7717733 -3.7778597]\n", - "[-3.7953677 -3.7897499]\n", - "[-3.8185773 -3.8026254]\n", - "[-3.8415692 -3.8186839]\n", - "[-3.864397 -3.8288355]\n", - "[-3.887118 -3.8470592]\n", - "[-3.9089546 -3.8578553]\n", - "[-3.9298224 -3.8789082]\n", - "[-3.9531326 -3.898365 ]\n", - "[-3.9759274 -3.9132624]\n" + "bit string: ['01010101', '10101010'] \n", + "max cut: 10.0\n" ] } ], "source": [ + "def classical_solver(graph):\n", + " num_nodes = len(graph)\n", + " max_cut = [0]\n", + " best_case = [0] # \"01\" series with max cut\n", + " for i in range(2**num_nodes):\n", + " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + " cat1, cat2 = [], []\n", + " for j in range(num_nodes):\n", + " if str(case)[j] == '0':\n", + " cat1.append(j)\n", + " else:\n", + " cat2.append(j)\n", + "\n", + " # calculate the cost function\n", + " cost = 0\n", + " for node1 in cat1:\n", + " for node2 in cat2:\n", + " if graph[node1].get(node2):\n", + " cost += graph[node1][node2][\"weight\"]\n", + " cost = round(cost, 4) # elimate minor error\n", + " if max_cut[-1] <= cost:\n", + " max_cut.append(cost)\n", + " best_case.append(case)\n", + " \n", + " # optimal cases maybe more than 1, but they are all at the end\n", + " index = max_cut.index(max_cut[-1])\n", + " \n", + " return max_cut[-1], best_case[index:]\n", + " \n", + "max_cut, best_case = classical_solver(example_graph_dict)\n", + "print('bit string:', best_case, '\\nmax cut:', max_cut)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "e9b8619b", + "metadata": {}, + "source": [ + "## Weighted Max-Cut Problem" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "9f8cb1da", + "metadata": {}, + "source": [ + "When an edge is cut, the total cost increase a certain number instead of 1, we say that this edge has a \"weight\".\n", + "\n", + "Let's define a graph with random weights:" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "b0a1f778", + "metadata": {}, + "outputs": [], + "source": [ + "weighted_graph_dict = {\n", + " 0: {1: {\"weight\": 0.1756}, 7: {\"weight\": 2.5664}, 3: {\"weight\": 1.8383}},\n", + " 1: {0: {\"weight\": 0.1756}, 2: {\"weight\": 2.2142}, 3: {\"weight\": 4.7169}},\n", + " 2: {1: {\"weight\": 2.2142}, 3: {\"weight\": 2.0984}, 5: {\"weight\": 0.1699}},\n", + " 3: {1: {\"weight\": 4.7169}, 2: {\"weight\": 2.0984}, 0: {\"weight\": 1.8383}},\n", + " 4: {7: {\"weight\": 0.9870}, 6: {\"weight\": 0.0480}, 5: {\"weight\": 4.2509}},\n", + " 6: {7: {\"weight\": 4.7528}, 4: {\"weight\": 0.0480}, 5: {\"weight\": 2.2879}},\n", + " 5: {6: {\"weight\": 2.2879}, 4: {\"weight\": 4.2509}, 2: {\"weight\": 0.1699}},\n", + " 7: {4: {\"weight\": 0.9870}, 6: {\"weight\": 4.7528}, 0: {\"weight\": 2.5664}}, \n", + "}\n", + "\n", + "weighted_graph = nx.to_networkx_graph(weighted_graph_dict) " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "264289c1", + "metadata": {}, + "source": [ + "The classical algorithm is used to find the corresponding maximum cut" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "f9f5ce41", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bit string: ['00010101', '11101010'] \n", + "max cut: 23.6685\n" + ] + } + ], + "source": [ + "max_cut, best_case = classical_solver(weighted_graph_dict)\n", + "print('bit string:', best_case, '\\nmax cut:', max_cut)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "35dea0fb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "colors = [\"r\" if best_case[0][i] == '0' else \"c\" for i in range(nnodes)]\n", + "weighted_graph = nx.to_networkx_graph(weighted_graph_dict) \n", + "nx.draw_networkx(weighted_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "d62faa79", + "metadata": {}, + "source": [ + "The quantum algorithm is then used, and the same result is supposed to be found." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "22db40be", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "QAOA_vvag = K.jit(tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0))\n", "params = K.implicit_randn(\n", " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", ") # initial parameters\n", - "opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "# for M1/M2 chips, legacy.Adam is recommanded\n", + "# for other CPUs, please use tf.keras.optimizers.Adam\n", + "opt = K.optimizer(tf.keras.optimizers.legacy.Adam(1e-2))\n", "\n", - "for i in range(50):\n", - " loss, grads = QAOA_vvag(params, example_graph)\n", - " print(K.numpy(loss))\n", - " params = opt.update(grads, params) # gradient descent" + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(300):\n", + " loss, grads = QAOA_vvag(params, weighted_graph)\n", + " params = opt.update(grads, params) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Loss\")\n", + " plt.plot(range(i+1), list_of_loss[0])\n", + " plt.plot(range(i+1), list_of_loss[1])\n", + " plt.legend([\"circuit 1\", \"circuit 2\"])\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "d2cf1b57", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #1\n", + "cost: -17.294533 \n", + "bit strings: ['00010101']\n", + "\n", + "Circuit #2\n", + "cost: -15.386024 \n", + "bit strings: ['00110101']\n" + ] + } + ], + "source": [ + "## circuit 1\n", + "c = QAOAansatz(params=params[0], g=weighted_graph, circuit=True)\n", + "loss = QAOAansatz(params=params[0], g=weighted_graph)\n", + "\n", + "# find the states with max probabilities\n", + "probs = K.numpy(c.probability())\n", + "index = np.where(probs==max(probs))[0]\n", + "states = []\n", + "for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + "print(\"Circuit #1\")\n", + "print('cost:', K.numpy(loss), '\\nbit strings:', states)\n", + "\n", + "## circuit 2\n", + "c = QAOAansatz(params=params[1], g=weighted_graph, circuit=True)\n", + "loss = QAOAansatz(params=params[1], g=weighted_graph)\n", + "\n", + "# find the states with max probabilities\n", + "probs = K.numpy(c.probability())\n", + "index = np.where(probs==max(probs))[0]\n", + "states = []\n", + "for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + "print(\"\\nCircuit #2\")\n", + "print('cost:', K.numpy(loss), '\\nbit strings:', states)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "492d215f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OS info: macOS-13.3.1-arm64-arm-64bit\n", + "Python version: 3.10.10\n", + "Numpy version: 1.23.2\n", + "Scipy version: 1.10.1\n", + "Pandas version: 2.0.1\n", + "TensorNetwork version: 0.4.6\n", + "Cotengra is not installed\n", + "TensorFlow version: 2.12.0\n", + "TensorFlow GPU: [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n", + "TensorFlow CUDA infos: {'is_cuda_build': False, 'is_rocm_build': False, 'is_tensorrt_build': False}\n", + "Jax is not installed\n", + "JaxLib is not installed\n", + "PyTorch is not installed\n", + "Cupy is not installed\n", + "Qiskit version: 0.23.3\n", + "Cirq is not installed\n" + ] + } + ], + "source": [ + "tc.about()" ] } ], @@ -270,7 +753,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.0" + "version": "3.10.10" } }, "nbformat": 4, From 218ed4f7e6c030c7038a6a266f798a2139bb6a98 Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Sat, 13 May 2023 14:53:01 +0800 Subject: [PATCH 445/725] Update qaoa.ipynb --- docs/source/tutorials/qaoa.ipynb | 79 ++++++++++++++++++++------------ 1 file changed, 49 insertions(+), 30 deletions(-) diff --git a/docs/source/tutorials/qaoa.ipynb b/docs/source/tutorials/qaoa.ipynb index 372b7e1a..cff5aeeb 100644 --- a/docs/source/tutorials/qaoa.ipynb +++ b/docs/source/tutorials/qaoa.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "dc0db886", "metadata": {}, @@ -9,6 +10,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "aecf6615", "metadata": {}, @@ -17,6 +19,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "eaf8cd3f", "metadata": {}, @@ -25,6 +28,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "16ad937f", "metadata": {}, @@ -33,6 +37,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "197d6df4", "metadata": {}, @@ -60,6 +65,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "2908c43d", "metadata": {}, @@ -68,24 +74,32 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "4d28f719", "metadata": {}, "source": [ "A cost (objective) function of the $\\alpha$-th edge (which connects $j$-th and $k$-th nodes) is defined\n", "\n", - "$$C_\\alpha=\\frac12(1-\\sigma_z^j\\sigma_z^k)$$\n", + "$$\n", + "C_\\alpha=\\frac12(1-\\sigma_z^j\\sigma_z^k)\n", + "$$\n", "\n", "When $C_\\alpha = 1$, the $\\alpha$-th is accounted a cut edge. It will happen if and only if $j$-th and $k$-th nodes are in different set. The total number of edge cut is written as\n", "\n", - "$$ C(z)=\\sum_\\alpha^mC_\\alpha(z)$$\n", + "$$\n", + "C(z)=\\sum_\\alpha^mC_\\alpha(z)\n", + "$$\n", "\n", "where $z = z_1z_2 . . . z_n$ is the bit string. Max-Cut asks for a string $z$ for which $C(z)$ is maximized. This problem is equivlant to finding the ground state of a cost Hamiltonian\n", "\n", - "$$H_C = \\frac{1}{2} \\sum_{i,j} \\sigma^{j}_{z} \\sigma^{k}_{z}$$" + "$$\n", + "H_C = \\frac{1}{2} \\sum_{i,j} \\sigma^{j}_{z} \\sigma^{k}_{z}\n", + "$$" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "871bff2e", "metadata": {}, @@ -101,11 +115,15 @@ "source": [ "The Quantum Approximate Optimization Algorithm (QAOA) utilizes a parameterized quantum circuit ([PQC](https://tensorcircuit.readthedocs.io/en/latest/textbook/chap5.html?highlight=变分)) to generate a quantum state that represents a potential solution to the Max Cut problem. The initial state, denoted as $|s\\rangle$, is a uniform superposition over computational basis states.\n", "\n", - "$$|s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle$$\n", + "$$\n", + "|s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle\n", + "$$\n", "\n", "This state is then evolved by a unitary operator that consists of $q$ layers, denoted as\n", "\n", - "$$U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},$$\n", + "$$\n", + "U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", + "$$\n", "\n", "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ and $V_{j}= e^{-i \\beta_{j} H_m}$. $H_C$ is the cost Hamiltonian introduced in previous section and the mixer Hamiltonian $H_m=\\sum_j\\sigma^j_x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1\\gamma_2 \\dots\\gamma_p=\\gamma$ and $\\beta_1\\beta_2 \\dots \\beta_p=\\beta$. It is worth noting that $\\gamma$ is restricted to lie between $0$ and $2\\pi$, and $\\beta$ is restricted to lie between $0$ and $\\pi$ due to the integer eigenvalues of $H_C$.\n", "\n", @@ -141,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 17, "id": "b0def04d", "metadata": {}, "outputs": [], @@ -171,6 +189,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "c82972a4", "metadata": {}, @@ -180,13 +199,13 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 18, "id": "f1532831", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -230,7 +249,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 19, "id": "055d1257", "metadata": {}, "outputs": [], @@ -289,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 20, "id": "b8d63c5d", "metadata": {}, "outputs": [], @@ -300,13 +319,13 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 21, "id": "c51b17a7", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGwCAYAAABRgJRuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABWD0lEQVR4nO3dd3hUZd4+8Hsyk8mkzKT3BunU0DvSi6519QXrRtx19beroouIqCuIryL2fV11bYC4FlTELj2gdAkQQgvphPRJ722e3x+TTBgyhCTMzMlM7s91PVcmp813ToK5fc7znCMDIEBERERk4xykLoCIiIjIHBhqiIiIyC4w1BAREZFdYKghIiIiu8BQQ0RERHaBoYaIiIjsAkMNERER2QWF1AVYW1BQEKqrq6Uug4iIiHpArVYjPz+/y236VagJCgpCXl6e1GUQERFRLwQHB3cZbPpVqGnvoQkODmZvDRERkY1Qq9XIy8u74t/ufhVq2lVXVzPUEBER2RkOFCYiIiK7wFBDREREdoGhhoiIiOxCvxxTQ0RE/ZOLiwt8fHwgk8mkLoXaCCGg1WpRV1d31cdiqCEiIrsnk8mwaNEiTJ8+XepS6DJ2796NdevWQQjR62Mw1BARkd1btGgRpk2bho0bN+Ls2bNoaWmRuiRqo1AoEBcXhwULFgAA1q5d2/tjmasoIiKivsjV1RXTp0/Hxo0b8dNPP0ldDpmQkZEBAFi4cCG++OKLXl+K4kBhIiKya97e3gCAs2fPSlwJdaX95+Pj49PrYzDUEBGRXWsfFMxLTn1b+8/nagZxM9QQERGRXWCoISIiIrvAUENERGRjwsPDIYRAfHy8Rd8nISEB5eXlFn0Pc2KoMQOlUoHY2BCo1c5Sl0JERP1Abm4uAgICcPLkSYu+z8aNGxETE2P4fsWKFTh27NgV9xs8eDC+/vprZGVlQQiBxYsXW7JMA4YaM9jz60s4c/ZdzJpl2cRMREQEADqdDkVFRWhtbb3sNnK5/Krfp6GhASUlJT3ez8XFBZmZmXjyySdRUFBw1XV0F0ONGWRmFgIAIiMDJa6EiIi6Q+mskqT1hEwmw9KlS5GWloaGhgbk5OTgqaeeAtD58tO0adMghMD8+fNx5MgRNDY2YsqUKV0eo30fd3d3w3vGx8dDCIHw8HAAxpefEhISsHLlSowYMQJCCAghkJCQYLL2I0eO4IknnsDGjRvR2NjYsx/OVeDN98wgM0MfaiIiAiSuhIiIrkTprMLqw4mSvPfycTPQVN/QrW1Xr16N+++/H4899hj27t2LwMBAxMXFdbnPSy+9hMcffxyZmZkoLy/v1TEuZ+PGjRg6dCjmz5+P2bNnAwAqKyt7dSxLYagxg4wMfddaRCRDDRERXT03NzcsXrwYDz30EDZs2AAAyMzMxL59+7rc79lnn8WOHTuu6hiX09DQgJqaGrS0tKCoqKhXx7A0mws1f/vb37B06VIEBAQgOTkZDz/8MH7//XdJa8rM1P9wIxlqiIj6vKb6BiwfN0Oy9+6OQYMGQaVSYefOnT06/pEjR676GLbMpkLNggUL8Prrr+PBBx/EoUOH8Oijj2Lr1q2IjY3t1UAmc2nvqQkP94Nc7oDWVp1ktRAR0ZV1N1xIpb6+vlf71dbWdvsYOp3+b9XFd/B1dHTs1fv2FTY1UPgf//gHPvjgA6xfvx5nzpzBgw8+iLq6Otx3332S1pWfX4aGhiY4OioQGuoraS1ERGT70tLSUFdXh1mzZlnsGO2dAYGBHZNcRowY0eUxm5qazDKrylJsJtQ4Ojpi9OjRhmuFACCEwI4dOzBx4kST+yiVSqjVaqNmCUIIZGXxEhQREZlHY2Mj1qxZg5dffhn33HMPIiIiMH78+B79T/yVjpGeno7z589j5cqViIqKwnXXXYclS5Z0eczs7GwMHDgQ8fHx8Pb2hlKpNLmdo6Mj4uPjER8fD6VSieDgYMTHxyMyMrL7J6EXbCbU+Pj4QKFQdBqcVFRUhIAA00Fi+fLlqKqqMrS8vDyL1ZeRwWndRERkPs8//zxee+01rFq1CmfOnMHGjRvh5+dntmO0tLTgjjvuQFxcHE6cOIFly5bhmWee6fJ4mzZtwpYtW5CYmAitVos77rjD5HZBQUE4fvw4jh8/jqCgICxduhTHjx/Hhx9+2KP6e0PYQgsMDBRCCDFhwgSj5WvWrBEHDx40uY9SqRRqtdrQgoKChBBCqNVqs9f35pv3C534Qbz0UoLk54qNjY2NraOFh4eLDRs2iPDwcMlrYevdz0mtVnfr77fNDBTWarVoaWmBv7+/0XJ/f38UFhaa3KepqQlNTU3WKM9wA74I9tQQERFJwmYuPzU3NyMpKclowJNMJsOsWbNw4MABCSvT67j8xDE1REREUrCZnhoAeP311/Hxxx/jyJEjOHz4MB599FG4urpi3bp1UpfWcQM+3lWYiIhIEjYVar788kv4+vpi1apVCAgIwPHjxzF//nwUFxdLXZph9pO7uyu8vTUoLa2SuCIiIqL+xaZCDQC8/fbbePvtt6Uuo5PGxmZcuKBFSIgPIiMDGGqIiIiszGbG1NgCTusmIiKSDkONGWUaxtX4X2FLIiIiMjeGGjPitG4iIiLpMNSYEad1ExGRNYSHh0MIgfj4eIu+T0JCAsrLyy36HubEUGNGnNZNRETWkJubi4CAAJw8edKi77Nx40bExMQYvl+xYgWOHTt2xf3+8pe/4Ndff0VZWRnKysqwfft2jB071pKlAmCoMavMTP207pAQH6hUph/yRUREdLV0Oh2KiorQ2tp62W3M8TTthoYGw9O8e2L69On4/PPPMWPGDEycOBG5ubnYtm0bgoKCrrqmrjDUmFFpaRUqK2sBAAMHcrAwERH1nkwmw9KlS5GWloaGhgbk5OTgqaeeAtD58tO0adMghMD8+fNx5MgRNDY2YsqUKV0eo30fd3d3w3vGx8dDCIHw8HAAxpefEhISsHLlSowYMQJCCAghkJCQYLL2u+++G++++y6Sk5ORmpqKv/zlL3BwcDB6KoAl2Nx9avq6jIxCjBoVicjIAJw5kyt1OUREZIKLi5Mk71tX19jtbVevXo37778fjz32GPbu3YvAwEDExcV1uc9LL72Exx9/HJmZmSgvL+/VMS5n48aNGDp0KObPn4/Zs2cDACorK7u1r4uLCxwdHVFWVtar9+4uhhozuOmJRxE5ZiS+f/X/kJFRgFGjIhEVZdkuNiIi6h0XFyfU1H4tyXu7ud7WrWDj5uaGxYsX46GHHsKGDRsAAJmZmdi3b1+X+z377LPYsWPHVR3jchoaGlBTU4OWlhYUFRX1aN81a9YgPz/fUJulMNSYgU9YCIIHxcAnLATpafkAgKgoTusmIqLeGTRoEFQqFXbu3Nmj/Y4cOXLVxzC3ZcuW4fbbb8f06dPR2Nj9nqreYKgxg4pCfWL1CPBHWloGACAqmj01RER9UV1dI9xcb5Psvbujvr6+V8evra3t9jF0Oh0A/diddo6Ojr1638tZsmQJnnzyScyePRspKSlmPbYpDDVmUFGof6CmR4Af0n7ZCwCIZqghIuqzejK2RQppaWmoq6vDrFmz8NFHH1nkGO2zmgIDA1FRUQEAGDFiRJfHbGpq6vasqqVLl+Lpp5/GvHnzkJSU1KPae4uhxgzae2rc/f2wq+3yU1iYD5RKBZqaWqQsjYiIbFBjYyPWrFmDl19+GU1NTdi3bx98fX0xZMgQrF271izHSE9Px/nz57Fy5Uo8/fTTiImJwZIlS7o8ZnZ2NgYOHIj4+HhcuHAB1dXVaGpq6rTdE088gVWrVuHOO+9EdnY2/P31M4JramqMepPMjVO6zcBw+cnfD8XFFaiuroNcLudN+IiIqNeef/55vPbaa1i1ahXOnDmDjRs3ws/Pz2zHaGlpwR133IG4uDicOHECy5YtwzPPPNPl8TZt2oQtW7YgMTERWq0Wd9xxh8nt/t//+39wcnLCpk2bUFhYaGiPP/54j+rvDdFfmlqtFkIIoVarzXpc75Bg8VrKAbH6cKIAII4kvSl04gdxww3jJP/MbGxsbP29hYeHiw0bNojw8HDJa2Hr3c+pu3+/2VNjBpXF+uuSSmcVXNw1SGu7BMVxNURERNbDUGMGLU1NqC7V31DII8DfMK2boYaIiMh6GGrMpKJIPwPK3d/P0FPDad1ERETWw1BjJpWGe9X48fITERGRBBhqzKTjXjX+hlATFubLp3UTEUlMCAEAUCh4F5O+rP3n0/7z6g2GGjNpv/zkEeAHrbYKFRU1AIDISE7rJiKSUmlpKQD0+kGOZB3tPx+tVtvrYzC2msnFPTUAkJZWgLFjoxEdHYRTp85LWRoRUb9WW1uL3bt3Y8GCBQCAs2fPoqWFN0btKxQKBeLi4rBgwQLs3r0bdXV1vT+WGevq1youGlMDAGlp+YZQQ0RE0lq3bh0AYOHChRJXQpeze/duw8+ptxhqzKT9XjUaHx8A4LRuIqI+RAiBtWvX4osvvoCPj4/RQxxJWkIIaLXaq+qhacdQYyZVJfprtkpnFVRqN07rJiLqg+rq6nD+PIcE2CsOFDaTlsZG1FZUAgDc/Xw5rZuIiMjKGGrMqKpEP2Lb3c/HEGqCg73h4uIkZVlERET9AkONGVW1j6vx9UV5eQ1KS6sAAFFRgVKWRURE1C8w1JhRZVtPjca3bbBwegEAXoIiIiKyBoYaM6oq7rj8BADnznFcDRERkbUw1JhR1SU9NWnn8gAA0THBktVERETUXzDUmFGloafGFwBwri3UxMSwp4aIiMjSGGrMqKqkbaBw2+Wn1NT2UMOeGiIiIktjqDGji+8qLJPJDAOFfX3d4enpJmVpREREdo+hxoyqS8ug0+kgd1TA1dMDtbUNuHBBf0mKg4WJiIgsi6HGjHQtragpKwfQMVi4fVxNbCwvQREREVkSQ42ZtU/rbh9Xk9Y2rZvjaoiIiCyLocbMOh6VYDwDitO6iYiILIuhxsyqtfqndau9vQB03ICP07qJiIgsi6HGzKpK20KNjzcAIDX1AgD9QGGZTCZZXURERPaOocbMqrVlADp6arKzi9Hc3AJXVxWCgrykLI2IiMiuMdSYWXWpPtRo2npqWlpakZlZCICDhYmIiCyJocbM2sfUuHl39MpwXA0REZHlMdSYmWGgsE9HqEkz3KsmRJKaiIiI+gObCTVPPfUU9u3bh9raWpSXl0tdzmW1j6lRubpC6ewMoKOnJpo9NURERBZjM6FGqVTiq6++wrvvvit1KV1qrKtDY109gIundfPBlkRERJamkLqA7lq5ciUAICEhQdpCuqG6tBROLiFQ+3ij9EKe4WndAwf6w9FRgebmFokrJCIisj8201PTG0qlEmq12qhZQ02p/vJY+7iagoIy1NTUQ6GQY+BAf6vUQERE1N/YdahZvnw5qqqqDC0vL88q71vVNli4fVo3wBlQREREliZpqFm9ejWEEF222NjYqzq+RqMxtOBg64xpMT2tm+NqiIiILEnSMTWvvfYa1q9f3+U2mZmZvT5+U1MTmpqaer1/b7XfgM94Wre+pyY2lqGGiIjIEiQNNVqtFlqtVsoSLKK9p0bjffHlJz6tm4iIyJJsZvZTaGgovLy8EBYWBrlcjvj4eABAeno6amtrJa7OWMcN+DqHGo6pISIisgybCTWrVq3Cvffea/j++PHjAIDp06djz5490hR1GaYuP7UPFA4K8oabmzNqauolqY2IiMhe2czsp0WLFkEmk3VqfS3QABc9qfuinprKyloUFemnekdHs7eGiIjI3Gwm1NiS9p4ahaMjnDUaw3JO6yYiIrIchhoLaGlqQl1VFQBA7e1pWJ7Gad1EREQWw1BjIaYuQfHBlkRERJbDUGMh1SbvKqzvqYmNDZGkJiIiInvGUGMhpqd1c0wNERGRpTDUWEj1JQ+1BICsrCIAgLu7Kzw93SSpi4iIyF4x1FhIdWlbT81FdxWur29Efr5+eUREgCR1ERER2SuGGgvpGFPjZbQ8M1PfW8NQQ0REZF4MNRZSZWL2EwBkZhYCYKghIiIyN4YaC2nvqXHzNu6pyWoLNZGRDDVERETmxFBjIYZQ4+kBmUPHac7I0IeageypISIiMiuGGgupraiETqeDg1wON08Pw3JefiIiIrIMhhoL0bW2ora8AoDxuJr2UBMW5gOFQi5FaURERHaJocaCTN2Ar7CwHPX1jZDL5QgL85WqNCIiIrvDUGNBhmndvpfOgOK0biIiInNjqLEgw7Ru70vvVcNxNURERObGUGNBNaX6UHO5ad0REf5Wr4mIiMheMdRYUFXboxI0l4Sa9mndEZGBVq+JiIjIXjHUWFA17ypMRERkNQw1FnS5y0+ZvKswERGR2THUWFCV4aGWxj012dnFAAB3d1d4erpZvS4iIiJ7xFBjQe1Tul3cNZA7OhqW19c3Ij9fv46XoIiIiMyDocaC6quq0dLcDABQe3kareO9aoiIiMyLocaChBCoKSsHwMHCRERElsZQY2GmHpUAAJkZBQA4WJiIiMhcGGoszDCt29v05aeB7KkhIiIyC4YaC6su7fpeNeypISIiMg+GGgu73OWnrCx9T01IiA/kcv4YiIiIrhb/mlpYddujEi59qGVhYTmampqhUMgRGOhlalciIiLqAYYaC7vck7qFELhwQR94wsJ8rV4XERGRvWGosbCay4ypAYDz50sAMNQQERGZA0ONhVUZxtR0vsSUk6N/XEJ4uJ9VayIiIrJHDDUW1j5QWOXqCqWzymhdLntqiIiIzIahxsIaa+vQ3NAIoPPTutsvP4Uy1BAREV01hhorMDyt29t4XE3HmBofq9dERERkbxhqrKB9WvelPTU5OfpQwzE1REREV4+hxgoMj0q4ZLBwbq4+1Li7u0KjcbF6XURERPaEocYK2h+VoLlkWnddXSO02ioAHCxMRER0tRhqrKB9BtSll58A3quGiIjIXBhqrKD98pOG96ohIiKyGIYaKzA8qdu7812Fea8aIiIi82CosYLLzX4CeK8aIiIic2GosYL2MTWXDhQGOKaGiIjIXBhqrKD98pOjygkqN1ejde1jahhqiIiIro5NhJrw8HB8+OGHyMzMRF1dHdLT07Fy5Uo4OjpKXVq3NDc0oqGmFsDlH5UQHOwFhUJu9dqIiIjshULqArojLi4ODg4OeOCBB5Ceno6hQ4figw8+gKurK5YuXSp1ed1SrS2Fys0VGh9vaHNyDcuLiyvR2NgMJydHBAV5GUIOERER9YxN9NRs3boV9913H7Zv346srCz88MMPePXVV/HHP/6xy/2USiXUarVRk0pV22Bh9SXjaoQQhjsL8xIUERFR79lEqDHF3d0dZWVlXW6zfPlyVFVVGVpeXp6Vquus4141nQcLtz8DiqGGiIio92wy1ERGRuLhhx/Ge++91+V2q1evhkajMbTg4GArVdhZVYkWAKDxvfwMKN6Aj4iIqPckDTWrV6+GEKLLFhsba7RPUFAQtmzZgq+++goffvhhl8dvampCdXW1UZNKR6jp3BvDG/ARERFdPUkHCr/22mtYv359l9tkZmYaXgcGBiIxMRH79+/HX//6VwtXZ15VxW2hxs+n0zregI+IiOjqSRpqtFottFptt7YNCgpCYmIikpKSsGjRIgghLFydeRl6akyOqeG9aoiIiK6WTUzpDgoKwu7du5GTk4PHH38cvhddwikqKpKwsu6rLNb3xnTVUxMezlBDRETUWzYRaubMmYPo6GhER0d3msEkk8kkqqpn2ntqXDQaOKqc0NzQaFiXm6tfp1a7wN3dFZWVtZLUSEREZMtsYvbTxx9/DJlMZrLZioaaWjTW1QMAND7GvTUNDU0oKakEwEtQREREvWUTocZeGMbVdHEJiqGGiIiodxhqrKg91Lj7djEDKrTzOiIiIroyhhorqjIMFu7cG3OhbVwNe2qIiIh6h6HGiioNN+C7fE9NCHtqiIiIeoWhxorab8DnbmJMDR9qSUREdHUYaqyoqhs9NQw1REREvcNQY0XdufwUHOwNBwf+WIiIiHqKfz2tqH2gsLt/596YwsIKNDe3wNFRgYAADytXRkREZPsYaqyookgfapxcXOCsURut0+l0yMsrBcBLUERERL3BUGNFLY2NqCkrBwB4BPh1Wt9xrxqGGiIiop5iqLGyikL9E7k9AgI6rcvlvWqIiIh6jaHGyioKCwGY7qnJ5V2FiYiIeo2hxso6emr8O61r76kJZU8NERFRjzHUWFlFYREAwDOwc6jhvWqIiIh6j6HGysoL9KHGVE8NH2pJRETUeww1VtZx+cnEmJq2RyX4+XlApVJatS4iIiJbx1BjZe2Xn9z9/SCTyYzXVdSiuroOAHtriIiIeoqhxsqqSrTQtbZC4egIN2+vTusNg4UZaoiIiHqEocbKdK2thgdbdjWuhoOFiYiIeoahRgJdjqvhXYWJiIh6haFGAuUF+hvweQbxrsJERETmwlAjgdIL+QAA75DgTusM07oZaoiIiHqEoUYCZRfyAADeoV2EGg4UJiIi6hGGGgloc9tCTXBQp3W8/ERERNQ7DDUSKGu7/OQVEgSZg/GPIDe3BDqdDq6uKvj4aKQoj4iIyCYx1EigoqgYLc3NUDg6wsPfeAZUU1ML8vPLAAADBnSe8k1ERESmMdRIQOh0Rr01l8rO1k/5HjCg85RvIiIiMo2hRiKlefpQ42NisHB2tv5RCgw1RERE3cdQI5HS9sHCoSGd1uUYemp4+YmIiKi7GGokYgg1XV1+GshQQ0RE1F0MNRIp7eJeNbz8RERE1HMMNRJp76nxMXH5KZuXn4iIiHqMoUYiJTm5aG1pgbNGDY2v8d2D2+9V4+LiBF9fd4kqJCIisi29CjUhISEIDu64bDJ27Fi88cYbuP/++81WmL1rbW429NYERA00Wmd8rxpegiIiIuqOXoWazz77DDNmzAAA+Pv7Y/v27Rg3bhxeeOEF/POf/zRrgfasMD0TAOAfGdFpHS9BERER9UyvQs3QoUNx+PBhAMCCBQtw8uRJTJ48GXfddRfuvfdec9Zn1wozsgAAgVGmQo1+sPBAzoAiIiLqll6FGkdHRzQ2NgIAZs+eje+//x4AcPbsWQQGBpqvOjtn6Km55PITAGRmFAIAIiMDrFoTERGRrepVqDl16hQefPBBTJkyBXPmzMGWLVsAAEFBQSgtLTVrgfbMEGoiOoea9PQCAEBkFEMiERFRd/Qq1CxbtgwPPPAAdu/ejc8//xwnTpwAANx4442Gy1J0ZdqcXLQ2t8BZ7dbpwZbp6frHKERFdb45HxEREXWm6M1Oe/bsgY+PDzQaDSoqKgzL33//fdTV1ZmrNrvX2tKCkpzzCIiKgH9UBCqKig3r0tL0PTVhYb5QqZRoaGiSqkwiIiKb0KueGpVKBScnJ0OgCQsLw+LFixEbG4uSkhJz1mf32i9BBcVEGi0vLa1CRUUNAA4WJiIi6o5ehZrvvvsOf/rTnwAA7u7uOHToEJYsWYJvv/0WDz74oFkLtHe5J88AAMKGD+20rn1cTRTH1RAREV1Rr0LNqFGj8NtvvwEAbrvtNhQVFSE8PBx/+tOf8Mgjj5i1QHuXc+IkAGBAPEMNERHR1ehVqHFxcUF1dTUAYO7cufjmm28ghMDBgwcRHh5u1gLbfffdd8jJyUF9fT3y8/OxYcMGu5g+nns6Fa3NLdD4+sAz0Hj6dkZbqImO5mBhIiKiK+lVqElPT8fNN9+MkJAQzJs3D9u2bQMA+Pn5oaqqyqwFtktMTMSCBQsQGxuLW2+9FZGRkfj6668t8l7W1NLYiLzUcwCA8OFDjNZxWjcREVH39SrUrFq1Cq+++iqys7Nx+PBhHDx4EIC+1+bYsWNmLbDdm2++iUOHDuH8+fM4cOAAXnrpJUyYMAEKRa8mcPUp50+cAgCExw8zWt5x+Yk9NURERFfSq0SwadMmhIWFITAwEMnJyYblO3fuxObNm81W3OV4enrirrvuwv79+9HS0nLZ7ZRKJZycnAzfq9Vqi9fWG9nJJzHlzv/p1FOTlqa/V014OKd1ExERXUmvemoAoKioCMePH0dQUJDhid2///47UlNTzVbcpV566SXU1NSgrKwMYWFhuOmmm7rcfvny5aiqqjK0vLw8i9V2NXKSUwAAIYPjoHJzNSwvLq5AWVk1HBwcEBsbfLndiYiICL0MNTKZDP/85z9RUVGBnJwc5OTkoLy8HM888wxkMlm3j7N69WoIIbpssbGxhu1feeUVjBw5EnPmzEFrays2bNhwxeNrNBpDaw9ffU1ZXgGKs3Igd1QgZuI4o3WnTp0HAAwZEiZFaURERDajV5efXnjhBfz5z3/Gk08+iX379gEApkyZgpUrV0KlUuGZZ57p1nFee+01rF+/vsttMjMzDa9LS0tRWlqKtLQ0nDlzBhcuXMCECRMMY3ou1dTUhKYm27hkc/rXffAbGI7B0ybjxPbEjuWnzmPq1CEMNURERFfQq1CTkJCAv/zlL/jhhx8My1JSUpCXl4d33nmn26FGq9VCq9X2pgQ4OOg7mS4eM2PLTu/Zh+kJdyJuykTIZDIIIQB09NQMZqghIiLqUq9CjZeXF86ePdtp+dmzZ+Hl5XXVRV1q3LhxGDt2LPbu3Yvy8nJERkbi+eefR3p6Og4cOGD295NC1rFk1FfXQO3thdChg3A+5TQAXn4iIiLqrl6NqUlOTsZDDz3UaflDDz1keGK3OdXV1eGPf/wjdu7cidTUVHz00Uc4ceIEpk2bZjOXl65E19KK1H36y2jx82YZlreHmoiIADg720evFBERkSXIAIie7nTNNdfgp59+MtwzBgAmTpyI0NBQXHfdddi7d6+56zQLtVqNqqoqaDQawx2R+5LB06bgz/9+BbXlFXhu1o1obW4GABSXfAofHw1Gj3oUx45lSFwlERGRdXX373evemp+/fVXxMTEYPPmzfDw8ICHhwe++eYbDBkyBPfcc0+vi+7vzu49gMqiErh6emDYzGsMy3kJioiI6Mp6fZ+agoICPPPMM7jttttw22234Z///Cc8PT3x5z//2Zz19Su61lYc/vZHAMD42zruwXMyJRsAEB8/UIqyiIiIbEKvQw1ZxqFvvoeutRUxE8YiOC4GAHDkSDoAYOy4aClLIyIi6tMYavqY8vxCHPtlOwBg9gOLAACHDunv0jx6dBTkcv7IiIiITOFfyD5ox/vrodPpMHz2dATGRCE1NQ8VFTVwdVVh6NBwqcsjIiLqk3p0n5pNmzZ1ud7Dw+NqaqE2xVk5SN66EyOvnYMbljyE9x94FL//noY5c0Zi/PhYJCdnSV0iERFRn9OjnprKysouW05OzhWfx0Td88v/vYeWpibEThqPIdOn4PfDaQCAcRxXQ0REZFKPemruu+8+S9VBlyi9kIc9G77ArL/8CTcuXYzfP3wDADBufOwV9iQiIuqfOKamD9v5wceoLC6BT1gI5AMGAwAGDw6Fj49G4sqIiIj6HoaaPqyxrg4/vfEOAGDM7XfgREoOHBwccO21oyWujIiIqO9hqOnjjv60FdnJKXBycUFmtRIA8Ifrx0lcFRERUd/DUNPHCSHwzQuvQtfaijr/OADAvHkj4ejYqwesExER2S2GGhuQd+Yc9n72NYrqFahpFHB3d8XUqYOlLouIiKhPYaixEVv+/T4qikqQXacCANx9z0yJKyIiIupbGGpsRGNdHTa/+DpSyvSh5s47pyE42FviqoiIiPoOhhobcnLXHuz4+QByaxVQKhVY/OhNV96JiIion2CosTHfvPAq9p+XAQD+/vANGDZsgLQFERER9REMNTamsqgEbzz1b+TUOMLZSYGffnkOUVGBRtvIZDKEhfli5szhuOGGcZg2bSi8vNQSVUxERGQdMgBC6iKsRa1Wo6qqChqNBtXV1VKXc1Uefv81rPxTHDyddGht1WHv3tOoq2tEeLgvIiICoFIpO+1z9GgGPnh/Cz7+eBcaGpokqJqIiKjnuvv3m6HGRrl6uOP5Hz/BTcOVGKhu7rS+qakZmZlFqKyshY+PBpGRHb052dlFeHTxB/j++0PWLJmIiKhXGGpMsKdQAwARo0fgwQ/egp8bkL93J9J+24vcXC3S0vKRm6uFTqczbOvjo8Fdd03HP5bcjNBQXwDA2//+EUuWfISmphapPgIREdEVdffvN8fU2LDMpOP4etUalDYq4DR2Hs4rgrFjx3Hk5BQbBRoA0Gqr8K9/fY9Bcf8Pr7y8CQDw94eux5atq+Du7ipF+URERGbFUGPjDn/7I3556z0AwHWPPIg/Pv04FMrO42na1dU1Ytmy9bju2pWorKzF9OnDkLj7RXh6ulmrZCIiIotgqLEDO95fjx9e+zcAYPLtt+LRL9YidtL4LvfZsiUJ06ctR2FhOUaMiMBPP6+Aq6vKGuUSERFZBMfU2JG4KRNwxwvPws3LEwCQfy4dR3/ainP7DyM/NQ1CdP5RDx4chj2/roa3twbbtx/DDdev4hgbIiLqUzhQ2AR7DzUA4OKuwey/3otJC/8IRycnw/KasnKkHTqCcwd+x7kDh1FRWGRYN3ZsNHbuegFubs74+ut9uH3hy53G5BAREUmFocaE/hBq2jlr1BgxbzYGT5uMyLEj4eTiYrQ+/1w6Dn79HX7/9kc01Tdg5szh+OnnlXBycsTrr23G44+vlahyIiIiYww1JvSnUHMxuUKBsOFDEDNxHGImjEXo0EGQKxQAgCptKba9+xEOfv0d/ue2Sfhi4zIAwAN//Tc++GCrlGUTEREBYKgxqb+Gmks5a9QY9Yd5uOaehfAJDQEAZCen4POnn8eD90zCqufvRktLK66dvwI7dyZLXC0REfV3vE8NXVZ9VTX2ff41Xr7xDnzz4mtoqKnFgPhhePTztdi8Nw+ffJIIhUKOr75+EnFxIVKXS0RE1C0MNf1Ya0sL9n3+NV65+U5kJh2Hs9oN9731Cr46UoO9e0/Dw8MNP/z4LLy9NVKXSkREdEUMNYSKomL85y8PY+9nXwEAZty/CF+ddkBmZiEiIwOx+dunoVQqJK6SiIioaww1BEDfa7N59ev47KlVaGlqwoBJU/DFKTkqKmsxZcpgfPDhI1KXSERE1CWGGjKS9MMv+M/9j6CusgrOAwfhm7OOaGlpxT33zMAzzyyUujwiIqLLYqihTrKOJuOte/6K0gv5qHQNwrYsRwDAqufvxoIFUySujoiIyDSGGjKpOCsH/3f3X3D+5GmkNnrh90J9sFn/8WMYPz5W4uqIiIg6Y6ihy6opLce79/0dpxJ/wz6tBhlVjlCplPj2u6cRG8up3kRE1Lcw1FCXmuobsO7RJ7H3i2/wywUNiurl8Pf3xK7EFxATEyx1eURERAYMNXRFQqfDNy+8im9eeRvfZLujpEGOwEAvJO5ezWBDRER9BkMNddvu9Z/ig8eexcZU57Zg44k9v61BfPxAqUsjIiJiqKGeOb51J96471F8fFSgpF4Ofz937N3/KubNGyV1aURE1M8x1FCPZR1Nxv/enIA132TjfI0jXF2U+PHnlXjwb9dLXRoREfVjDDXUK1UlWryZ8DD+/tQmnCpTQu4gwztvP4CPv3iKj1QgIiJJMNRQr+laW/HTWx/gprnLsDO9FQBwz8KJSE79COED/CWujoiI+hubCzVKpRLHjh2DEALx8fFSl0MAMpOO44ZRd+OVr9JQ3yJD7AAvpJx5D7feNVvq0oiIqB+xuVDz8ssvIz8/X+oy6BIN1TVYtuAfWPDXdSiokcFNJceXnyzGu5/+EzKZTOryiIioH7CpUDN//nzMnTsXjz/+uNSl0GX8tG4TRg9/EHtTayCTAQ/cOQ5JaZ/AP9hX6tKIiMjO2Uyo8fPzwwcffIB77rkHdXV13dpHqVRCrVYbNbK8wqwLmDb4Lryy7nc064ARke44mfohps0bL3VpRERkx2wm1Kxfvx7/+c9/kJSU1O19li9fjqqqKkPLy8uzYIV0MaHTYdl9q3Dz7f9Ceb2At6sDtvz0DBYtvkPq0oiIyI4Jqdrq1avFlcTGxoqHH35Y/Pbbb8LBwUEAEOHh4UIIIeLj47s8vlKpFGq12tCCgoKEEEKo1WrJPnN/bGFRYeJswddCJ34QzbofxIp//UPymtjY2NjYbKep1epu/f2Wtb2QhI+PD7y9vbvcJjMzE19++SVuuOEGCNFRqkKhQEtLCz799FPce++93Xo/tVqNqqoqaDQaVFdXX03p1EPOrs7YfvAdTBrqAwD4z8Zj+Nvtz0pcFRER2YLu/v2WNNR0V2hoKDQajeH7oKAgbNu2DbfeeisOHTrU7ctKDDXSkslk+GrHm/jjzAgAwEffncH9Nz8hcVVERNTX9eTvt+TdSj1t3b38dGnrbvcVm2Xb2s0vCp34QejED+KNz16QvB42NjY2tr7duvv322YGCpP9uO+Wp/DJt8kAgIdvH45lr3OKPhERXT2bDDU5OTmQyWRITk6WuhTqpYRbnsGWvVlwkAHPPTIdCx+5R+qSiIjIxtlkqCH7cOOMx5CcVgqlXODtl2/H2GunS10SERHZMIYakkxLSytmT3wEJRUN8HLSYf2GpfAJD5W6LCIislEMNSSp0tIq3HTds2jVCQzy0eHdb1+Hk6uL1GUREZENYqghyR08cAYrV20EANwwzBkPv/W/fAgmERH1GEMN9QkvrvoMh5OyoJQL/L/bBmNawp1Sl0RERDaGoYb6BCEEEu56GU3NrRiobsY/VixCcFyM1GUREZENYaihPiM19QJWrfwMADArpAH3v/4cHFVOEldFRES2gqGG+pRXXvkGJ0+dh7NC4LYJ3rj+Hw9JXRIREdkIhhrqU5qbW3DfvW9CpxMY7NmIW++7CTETx0ldFhER2QCGGupzjhxJw4YNuwAA0wJqcduzT/AyFBERXRFDDfVJzzy9AXV1jQh2bcH4wT6Y+//+LHVJRETUxzHUUJ+Un1+G117dDACY6l+LGQm3IzAmSuKqiIioL2OooT7r5Zc3oaCgDB5OOozya8GClcshc+CvLBERmca/ENRn1dY24Nl/fgoAGOdTi6j4OEy47SaJqyIior6KoYb6tPXrdyA19QJcHIER3g249qG/wlmjlrosIiLqgxhqqE9rbdVh1XNfAABGetbC01uDOQ/eJ3FVRETUFzHUUJ+3ceNvOHXqPFyUMozybsCU22+D38BwqcsiIqI+hqGG+jydTofn2h6fEO9RDRcnB9y49BGJqyIior6GoYZswqZN+3HiRBZcnOQY6VWLQVMnIW7KBKnLIiKiPoShhmyCEAIrV7T31tRCJdfhxqWL4aCQS1wZERH1FQw1ZDO+/fYgjh/PhItKgaGu5fCPGIDJC2+VuiwiIuojGGrIpjy/Sj8TapRPI5zkOsz925/h6uEucVVERNQXMNSQTfn224M4cSILri5KRIs8uGg0mPf3+6Uui4iI+gCGGrIpQghDb82EMBmcHHSY+D83IyAqQuLKiIhIagw1ZHO++eYAUlKyoXZTIajyDBzkctz0xGKpyyIiIokx1JDNubi3ZsZgNeStjYiZOA5Dpk+RuDIiIpISQw3ZpE2b9uPkyRy4u7vAOz8JAHDj0sWQOzpKXBkREUmFoYZskhAC//u8vrfmuglBaCzTwicsBFPvWiBxZUREJBWGGrJZX3+9H6dPn4enpxv8CvW9NXMeWAQ3b0+JKyMiIikw1JDN0ul0eObpTwAAt18/FJUZZ6Fyc8WNj/O5UERE/RFDDdm0b789iL17T8PFxQmDdVnQtbZi9PXzETtpvNSlERGRlTHUkM17fMlHAIDbbhqN3MRf9K+fXQYnVxcpyyIiIitjqCGbd/jwOWzc+BscHBzwhyEqlF7Ig1dwIG5+8jGpSyMiIitiqCG78NTyj9HU1Iw5c0ag4KcvoNPpMO7m6zFi/mypSyMiIithqCG7kJVVhP/71w8AgGcfvxb7N3wKAFjw3FMIiI6UsjQiIrIShhqyGytXfoasrCKEh/thengrzh04DCcXZ9z3fy9D4+crdXlERGRhDDVkN+rqGvHgA28DAB5++HoUb98E7fkL8A4JwgPv/4v3ryEisnMMNWRXtm8/hv/71/cAgPfffQA/rlyBisIiBEQOxCP//RD+kQMlrpCIiCyFoYbszhNPrMPvv6fB21uDLz5+CF8sWYaSnFx4hwThsS/WYXrCnZArFFKXSUREZiYDIKQuwlrUajWqqqqg0WhQXV0tdTlkQcHB3th/4BWEhvri99/TsODONzBv6RLDTfkqCotw4KtvcXLXryjKyIIQ/eafARGRzenu32+GGrJbgwaFYs+vL8HHR4OMjAIs+J81cAwfhPkP/xXuFw0cbqipRUnOeVQVa1FZokVNaRlqyitQU1aub6VlKM0rQEtjo4Sfhoio/2KoMYGhpv+Jjg7Cz7+sRGRkIFpaWvGvN7/Hq69/h7Bx4zF8zkxEjx8DR5XTFY+j0+lQUVCEkuwclOTkojAjCwXnMlCQlo7G2jorfBIiov6LocYEhpr+ydtbg3+//SAWLpwKQD9L6ptv9uOrL/cicfdJuPkHwDMoEO5+PnD384WblydcPT3g5u0JN09PaHy84axRX/b4pRfyUXAuDfnnMlBwLh3559JRmpsHodNZ6yMSEdk1hhoTGGr6t+uuG4MVK+/E2LHRhmUNDU3YvTsFv/ychJ9++h2ZmYUm93X19IDfgDD4hofBd2AYAqIiEBQTBY8Af5PbN9bVozA90xBySrLPo7q0DDVl5WioqUFrSwt0La0W+ZxERPbG7kJNVlYWBgwYYLTsySefxJo1a7p9DIYaAoDx42Nx553TcMON4zBggHEoSU29gJ9/OoKffz6C3347haamli6P5azRICgmEoExUQiKiUJgTBQCoiKgdFZ1q5bW5ha0trRACJ1+sLJA21cBAf33Lc3NaKyt07c6/deG2lr91+oa1NfUoKGmFg3VNWhof11Tq19erf9e18oARUS2yy5DzUcffYQPPvjAsKy6uhp1dd0fz8BQQ5caNCgU1103BtdeNxpTpw6Bo2PHVO/q6jr88stRfLJhF7ZuPYqWbvasyBwc4BMWog86sVEIiomGZ1AA3Lw84ebpAQe53FIf57Ia6+rRWFeH5oYGNNU3oLmhEc2NjWhqaEBzfcNFrzsvb25oQFNDo36fhgb9uoa2bRoa0FSvX97S1GT1z0VE/YNdhpo333wT//rXv3p9DIYa6opG44LZs0fgD38Yg2uvG4OAgI47EBcVlePzz37FJ58k4tixjF6/h8zBAY5OTpA7KvRNoW+QySCDTP/VQQaZTN8AQO7oCJWrC5xcXaBydYWTqwucXF2hcnWBSu0Glaur/qubK1RubnBue+3k6gonF+erPi/dpdPpDKFJH5wuCkD19YYw1RGGLt3ucvs26PdvaOQMNKJ+yi5DjUqlgqOjI86fP4/PPvsMb7zxBlq76FZXKpVwcuqY2aJWq5GXl8dQQ1ckk8kwalQk7rxzGu68axr8/TsCTk5OMX75+Qi2bDmKw4fPobCwXMJKu+agkBtCj5OLCxxVTlCqVHBUqTpeOznB0fni16qO1yqnrvdxdobC0dGqn6mxrr4jADVcFIDq28LTxT1J9aa2u2RZ/UXBq6EBLY1NvG8RUR9jd6Hmsccew9GjR1FWVoZJkyZh9erVWLduHZYsWXLZfVasWIGVK1d2Ws5QQz2hUMgxd+5I3POnmbjxxnFwdjaeAl5SUomUlGzk5mpRVFiOwsIKlJZWoby8BuXltSgrq257XYPGxmaJPoXlOMjlRiGnPQApVW0BybCsLRA5q+Dk3L6Nqi1E6fc1LFM5QenSsZ+j05Wn3ZtTe29RY329UUDSL7skSF3cy9Qemi5aduk4qOYG9jYR9ZRNhJrVq1fjySef7HKbuLg4pKamdlq+aNEivPfee3Bzc0PTZa7ls6eGzM3Z2QnTpw/FddeNwcxZ8YiJCYK8B2Nk6uoaDQGnI+zUoqK8BqWlVSgurkRJSSWKiytRXFyBkpIqVFbWWvAT2Yb2y3ZKF9VFoaktEDlfusypU5DSBySni0JT234Xh6tu3K/IHFpbWgxB5+Kw05vXTfX17FWifsEmQo2Pjw+8vb273CYzMxPNzZ3/73bw4ME4deoUYmNjce7cuW69H8fUkLmpVEoMGRKGwYNDERjohcBAT/gHeMLT0w2enm7w8tJ/9fBw7VH4uVhTUzNKSqoMIae4uAIlF4WfS7/W1NSb+VP2D4bg5KwyuuR2aSBSOjt3XK4zLLs4ILVt6+wMpbMKTi5t46HcXM1es06nQ2NNLeqra1BfVY366mr96+rqtu/bllddurwa9VU1aKrn7wrZhu7+/Zb0qX5arRZarbZX+44YMQKtra0oLi42c1VE3dfQ0ISkpHQkJaV3uZ1MJoNG49Ip7Ohfq+Hp6QofHw18fN3h6+sOPz/9V43GBUqlI4KDvREc3PX/ALSrr2/sFIK0hu87B6G6Ol4OAQCh07UNaLbMH3qZTAals7Mh4Fwcdq74um2A+MXLHORyODg4wFmj1t8cMjiwxzW1Nrd0BKG2sFNXUYnaikrUllegtrJK/7WiUr+8vAI1FZUcsE19lk2MqZkwYQLGjx+PxMREVFdXY+LEiXjjjTfwyy+/4N577+32cdhTQ7ZGpVLC19cdvr4a+Pl5GL76+bnD56Lw4+fnDj8/D7i49PwSSl1doyEAlZTog057T5C+VRmFoNraBgt8Uuqp9l4glVo/481Zo9F/Vavbgk7ba7Wb/vtLXssde///tE31DaitqEBteSXqKisNwae6tAzV2lJUafVfq0tLUVNajtaWru/3RHQlNnH5qbtGjhyJd955B3FxcXByckJWVhY++eQTvP7665cdT2MKQw3ZOxcXJ0PoMQ5D7vD1M+4F8vNzh0ql7PF7tPcEGfX6FFWgsLDc0AoK9F/Ly2ss8CnJHJTOKqjUarho9GFHpVbDxV0DVw93uHho4OrhAVcPd33zbH/t0aswVFtRqQ852jJUl5aiSluKmtKytvCjRUVhMSoKi9BUz8BMptlVqDEXhhoiY25uzkYBSB929D1C7ZfCOpa7d5r5dSVNTc0oLLwo8BSUG4WfwrbZYoWF5Who4M37bIGTq0tbyPGAa3v48dQ3tbeXvvl4Qe3jDbWXV49CUF1lFSoKiwwhp6KouON1YTEqi4p5k8d+iqHGBIYaoqvj6qoyCjrtYcff3wP+AZ4IMDQPeHtrenRsrbYKubklyM3V4kKuFrm5WsP3ubla5OWVormZlzFsiUwmg7NGDbWPNzQ+3lD7eMHN2wsab2996PHxgsbXBx4B/nBWu3XrmNWlZSjNzYM29wJKc/NQeiFf/zX3AqpLyyz8iUgqDDUmMNQQWY9SqYCfnwcCAy8OO/rmH+BheB0Y6NntHqDCwnLk5mpx/nwJsrOKkJlZiIyMAmRmFiInp4Shx4Y5ubrAI8C/rfkZf/X3g7u/3xXvkN1YV3dRyMlDcXYOijKyUZSZjfqqKit9ErIEhhoTGGqI+iYPD1eEhPggNNQHoaG+CA31QUio8fdXGv+j0+mQm6tFZmYhsjILkZmpDz3p6QVITb2A6mpOX7Z1zhoNvIID4B0aAu+QIHiHBsMnJATeocHwCPDr8rlqVdpSFGVkoTgrB0UZWSjKzEZRRhZ7d2wEQ40JDDVEtsvHR2MIOGFhvhg40B8DIwIQEeGPiIgAuLl1/X/xeXmlOHv2AlLPXsDZi1peXilvYGcH5AoFPIMD4RMaDO+QYHiHhcBvYDj8IwbAK+jy092rS8uQn5qGvLPnkHfmHPJT01CSkwuh01mxeroShhoTGGqI7JevrzsiIgIQGRmAiIgADGx7HRUViKCgy9/jp7a2AWfO5CLlRDZOnMhGcnIWTpzIRlkZ/xthL5TOzvqAEzkQAZED4BcxAP4RA+EdEmSyd6exrg4F5zJw4Uwqzp84hZwTJ6E9f0GCyqkdQ40JDDVE/ZNG44LY2GDExYUgLi4EsW1fo6OD4HiZ2TkXLmhx4kQ2UtqCzvHjmTh3Lh86/h+83VA4OSEwKgLBg2IQHBeDoLhoBMVEQ+ms6rRtbXkFctoCTs6JUzifcgqNtXUSVN0/MdSYwFBDRBdTKOSIiAjAkCFhiI8fiGHDByA+fiAiIgJMbl9dXYekpAwc+T0Nhw+fw++/pyEnh3c1tycyBwf4hocieFAsQofEIXz4UIQMjoVCaTymS6fToeBcOjJ+P4b035OQmXQc9VX8u2IpDDUmMNQQUXeo1c4YOjQc8fEDMXz4AAyPH4j4+IFwde38f/AlJZX4/fc0Q9DZv/8MKir4EFJ7Ind0RFBsNMKHD0F4/FCEDx8K75Ago210Oh3yz6Yh48hRpB8+isyjx9FQzZtPmgtDjQkMNUTUW3K5AwYNCsXYsdEYOzYaY8ZGY/jwAVAqHTtte+rUeezbexr79p3Gvn1nkJlZKEHFZElqby9EjBmJqLGjEDl2FPwjBhit17W24nzKaZzZewBnfzuAvDOpHJB+FRhqTGCoISJzcnJyxPDhAzBuXAzGjI3GhAmxiI0N6bRdQUEZ9u07g/37zmDv3tM4diwDra0cm2NP1D7eiBwzElHjRiNyzEj4DQw3Wl9dWobU/Ydwdu9BnNt/CLUVlRJVapsYakxgqCEiS/P1dcekSYMwefIgTJ4yGKNHR3bqzamqqsNvv53C7sQU7N6dgmPHMjkA2c54BPgjdvJ4xE2ZiJgJY6FyczWs0+l0OJ9yCid37kHKrl+hzcmVsFLbwFBjAkMNEVmbSqXEmDFRmDJlMCZNHowpUwbBw8P4kQCVlbX49ddT2LNbH3KOH89iyLEjcoUC4SOGYdCUCYibMhFBsdFG6wvTM3Fy169I2bkHF06flajKvo2hxgSGGiKSmoODA+LjB2L69KGYNn0YrrlmSKeQU1FRc1HIOYnkZIYce6Lx88WQ6VMwbOY1iBo3xuihnxWFRTi561ec3PUrMpKOQdfSKmGlfQdDjQkMNUTU1zg4OGDEiIGYPn2YIeS4u7sabVNeXoNffz2JPbtPIjHxBE6cyOagUzuhUrth0NRJGDZrGuKmTICTi4thXW1FJVJ27Ebytp1IP3wUutb+G3AYakxgqCGivs7BwQEjR0YYhRyNxsVom7Kyavz66ynsTjyB3btTkJKSw5BjBxROTogePwbDZk3DkOlT4OblaVhXU1aOlJ17cHzLDmQmHe93AYehxgSGGiKyNXK5A0aOjDRcrpo6tXPIKS2tags5+jE5J08y5Ng6B7kckWNGIn7eLAyfPR2unh6GddWlZTixPRHJW3ci82hyv3hOFUONCQw1RGTr5HIHjBoVaejJmTp1MNRq45Cj1VZhz56ThoHHp06dZ8ixYQ5yOaLGjUL83FkYNns6XD3cDeuqtKWGgJN1NNluf84MNSYw1BCRvVEo5IaQM33GMEyZMrjTE8tLSioNIScxMQWnT5+XqFq6Wg4KOaLHjUH8vFkYNnsaXDQaw7rK4hIkb9uF5K27kJOcYlcBh6HGBIYaIrJ3CoUco0dHGYWcSx/vUFxcgT17ThouV505w/uk2CK5QoHoiWMxYt4sDJ1xDZw1asO6iqLitoCzE+dPnLL5gMNQYwJDDRH1NwqFHGPGRGHGjOGYNn0YJk8eZDLk7N7dcbmKIcf2yB0dETNxnD7gzLzG6GZ/5QWFHQEn5bSEVfYeQ40JDDVE1N85Oiowdmx025icoZg8eTBcXJyMtmHIsW0KpRKxk8Yhft4sDJkxFSrXjoBTlldgCDi5p85IWGXPMNSYwFBDRGRMqVRg7NgYw+yqSZMGMeTYEYWTE+Imj9cHnOlTjO6DU3ohH8nbdiJ5605cOJ0qYZVXxlBjAkMNEVHXuhtyEhNTsG3rUWzdehT5+WUSVUs9oXBywqApExA/bxYGT5sCJ5eOAeXa3AtI3qrvwck7e07CKk1jqDGBoYaIqGe6E3JSUrKxbesxbNmShL17T6OxsVmiaqm7HFVOGDR1kj7gXDMZSueOcVYlOblI3roTx7fuRMG5dAmr7MBQYwJDDRHR1VEqFRg3LgazZ4/AvPmjMHZsNBwcHAzr6+oakZh4Aj/9+Du+//4Qe3FsgNJZhUHXTEb83JkYfM1kOKo6QmtxVg6St+3C8a07UZiWIVmNDDUmMNQQEZmXl5cac+aMwNx5ozBv3kgEBXkbrT98+By+/+4QvvvuIE6d4v1x+jqlszMGT5uM+HmzMGjqRDg6dQScosxsQw9OUUaWVetiqDGBoYaIyLKGDRuAa68djRtvGo8JE2KNenEyMgrw/XeHsHnzAezbd8bm751i75xcXDB4+hSMmDcTcVMmQqFUGtYVpGXg0KbvceSHX1BfZfm/pww1JjDUEBFZj7+/B66/fhxuunkCZs+Oh0rV8UfxwgUtvvpyLzZu/A2HD/e9galkzMnVBUNmTMWIubMQO3m8IeA0NzTi+NYdOPDVt8hJPmmx92eoMYGhhohIGq6uKsydOxI33TwBN944Dh4eboZ1WVlF+HLjb9i48TccP54pYZXUHSq1G0ZeOweTFtyCoNhow/L8c+k48OVmHP1pKxpqas36ngw1JjDUEBFJT6lUYN68UVh4+zW48cZxRs+qSk29gM8+3YMNG3YhJ6dYwiqpO8KGD8GkBbdgxLzZhgHGXz33Eg5+/Z1Z34ehxgSGGiKivsXZ2Ql/+MMYLLz9GvzhD2OMLlHt3p2Cj9fvxKZN+1FTUy9hlXQlzho1Rl8/H6P+MA/v3f8IGuvqzHp8hhoTGGqIiPoutdoZN988AX9KmIUZM4YZBhnX1jZg06b92PDxTiQm2tfTp6l7GGpMYKghIrINoaG+uOeeGfhTwkzExAQblp8/X4KP1+/EunU7kJ1dJGGFZE0MNSYw1BAR2Z4JE2KRkDALCxZOhadnxwDjnTuTsW7tdnzzzQE0NDRJWCFZGkONCQw1RES2y8nJETffPAGL7puD2bPjDZenKipq8Plnv2Lt2u1ISuobt/Un82KoMYGhhojIPoSF+SIhYRbuXTQbAwf6G5afOJGFdWt34L//3Y3S0ioJKyRzYqgxgaGGiMi+yGQyzJgxDIvum4Nbb51kmD3V1NSM7747hHVrd2DbtmPQ6XQSV0pXg6HGBIYaIiL75eHhittvvwaL7puDsWM7bgp34YIWGz7ehXXrdiAjo0DCCqm3GGpMYKghIuofhg8fgEWLZuOuu2fAx0djWL5nz0ms/WgbNm3aj7q6RgkrpJ5gqDGBoYaIqH9RKhW44YZxWHTfHMybNxJyuRwAUFVVh41f/Iq1a3fg0KFUiaukK2GoMYGhhoio/woO9kZCwiwsum82IiMDDcvPnMnFV1/uxddf78PJkzkSVkiXw1BjAkMNERHJZDJMnToEi+6bjf/5nylwcXEyrDt3Lg+bvt6H7747hCNH0jnAuI9gqDGBoYaIiC6m0bjgxhvH49bbJmHevFFGz54qLa3Ctm3HsHXLUWzdehRFRRXSFdrPMdSYwFBDRESX4+bmjD/8YQxu+eMkzJ07Ah4ebkbrU1MvYN/e09jb1tLTOZPKWuwy1Fx33XV49tlnMXz4cDQ0NGDPnj245ZZbur0/Qw0REXWHXO6A8eNjce21ozFv/iiMGRPdaZuysmokJ2ch+XgWjh/PRHJyFtLS8jmrygLsLtT88Y9/xAcffICnnnoKu3btgkKhwNChQ/HVV191+xgMNURE1Buenm6YODEOU6YMxuQpgzFuXAycnBxNbpuXV4r09AKkp+UjJ6cY+fllKCgoa/tajpKSSj5pvIfsKtTI5XJkZ2djxYoVWLt2bbf3UyqVcHLqGACmVquRl5fHUENERFdFqVRg0KBQjBgRgREjBiJ+RASGDQuHt7fmivs2N7egtLQaFRW1qKioaftai8qKWtTUNKC+vhENDc1GX+vrmwyvm5tb0dqqa2ut0OnERd/roNPpjL63doAqLKxAfb15e6u6G2oUZn1XCxk1ahRCQkKg0+lw9OhRBAQE4Pjx41i6dClOnTp12f2WL1+OlStXWq9QIiLqF5qaWvSXnpKz8PHHHcs9Pd0QFRWIqKggREcHIiTEB4FBXggM9EJQkBf8/Nzh6KhAQIAnAgI8pfsAFjRv7rPYvv2YJO9tEz01CxcuxBdffIGcnBz84x//QHZ2NpYsWYK5c+ciJiYG5eXlJvdjTw0REfUlCoUc/v4e8PZWw8PDDR4erobm6ekGV1cVVCpHODs7wantq/57JVQqJZydlXB0VEAud4Bc7gAHBxnkcvkl3ztc9L1+mTV7a265+QXs2nXCrMfsyfARIVVbvXq1uJLY2Fhxxx13CCGEuP/++w37KpVKUVxcLP761792+/3UarUQQgi1Wi3ZZ2ZjY2NjY2PrWevu329JLz+99tprWL9+fZfbZGZmIjBQf+fH06dPG5Y3NTUhMzMTYWFhliyRiIiIbISkoUar1UKr1V5xu6SkJDQ0NCA2Nhb79u0DACgUCgwYMAA5ObylNREREdnIQOHq6mr85z//wXPPPYfc3Fzk5ORg6dKlANCjKd1ERERkv2wi1ADA0qVL0dLSgk8++QTOzs44dOgQZs6ciYqKCqlLIyIioj7AJmY/mQtvvkdERGR7uvv328GKNRERERFZDEMNERER2QWGGiIiIrILDDVERERkFxhqiIiIyC4w1BAREZFdYKghIiIiu8BQQ0RERHaBoYaIiIjsgs08JsGc1Gq11CUQERFRN3X373a/CjXtJyUvL0/iSoiIiKin1Gp1l49J6FfPfgKAoKAgsz/3Sa1WIy8vD8HBwXymVDfwfHUfz1XP8Hx1H89V9/Fc9YylzpdarUZ+fn6X2/SrnhoAVzwhV6O6upq/8D3A89V9PFc9w/PVfTxX3cdz1TPmPl/dORYHChMREZFdYKghIiIiu8BQYwaNjY1YuXIlGhsbpS7FJvB8dR/PVc/wfHUfz1X38Vz1jJTnq98NFCYiIiL7xJ4aIiIisgsMNURERGQXGGqIiIjILjDUEBERkV1gqDGDv/3tb8jKykJ9fT0OHjyIsWPHSl2S5FasWAEhhFE7c+aMYb2TkxP+/e9/Q6vVorq6Gl9//TX8/PwkrNi6pk6diu+//x55eXkQQuCmm27qtM1zzz2H/Px81NXVYfv27YiKijJa7+npif/+97+orKxEeXk5PvzwQ7i6ulrrI1jNlc7VunXrOv2u/fLLL0bb9Jdz9eSTT+Lw4cOoqqpCUVERNm/ejJiYGKNtuvNvLzQ0FD/++CNqa2tRVFSEl19+GXK53JofxeK6c64SExM7/W69++67Rtv0h3MFAA8++CCSk5NRWVmJyspK7N+/H/Pnzzes70u/V4Kt923BggWioaFB3HvvvWLQoEHivffeE2VlZcLX11fy2qRsK1asECkpKcLf39/QvL29DevfeecdkZOTI2bMmCFGjRol9u/fL/bu3St53dZq8+fPF88//7y4+eabhRBC3HTTTUbrn3jiCVFeXi5uvPFGMWzYMPHtt9+KjIwM4eTkZNjm559/FseOHRPjxo0TkydPFufOnROffvqp5J/N2udq3bp14ueffzb6XfPw8DDapr+cq19++UUkJCSIwYMHi+HDh4sff/xRZGdnCxcXF8M2V/q35+DgIE6cOCG2bdsm4uPjxfz580VxcbF44YUXJP981j5XiYmJ4r333jP63VKr1f3uXAEQ119/vbj22mtFVFSUiI6OFv/7v/8rGhsbxeDBg/va75X0J8uW28GDB8Vbb71l+F4mk4kLFy6IZcuWSV6blG3FihXi2LFjJtdpNBrR2Ngobr31VsOy2NhYIYQQ48ePl7x2azdTf6jz8/PFkiVLjM5ZfX29WLhwoQAg4uLihBBCjB492rDNvHnzRGtrqwgMDJT8M1nzXK1bt05s3rz5svv013MFQPj4+AghhJg6darh9+hK//bmz58vWlpahJ+fn2GbBx54QFRUVAhHR0fJP5O1zhWgDzVvvPHGZffpr+eqvZWWlor77ruvT/1e8fLTVXB0dMTo0aOxY8cOwzIhBHbs2IGJEydKWFnfEB0djby8PGRkZOC///0vQkNDAQCjR4+GUqk0Om+pqanIycnheQMwcOBABAYGGp2fqqoqHDp0yHB+Jk6ciPLyciQlJRm22bFjB3Q6HcaPH2/1mqU2ffp0FBUV4ezZs3jnnXfg5eVlWNefz5W7uzsAoKysDED3/u1NnDgRKSkpKC4uNmyzdetWuLu7Y8iQIVas3rouPVft7rrrLpSUlCAlJQUvvvginJ2dDev667lycHDAwoUL4erqigMHDvSp36t+90BLc/Lx8YFCoUBRUZHR8qKiIsTFxUlUVd9w6NAh3HvvvUhNTUVgYCBWrFiB3377DUOHDkVAQAAaGxtRWVlptE9RURECAgIkqrjvaD8Hpn6v2tcFBAQY/ccBAFpbW1FWVtbvzuGWLVvwzTffICsrC5GRkXjxxRfxyy+/YOLEidDpdP32XMlkMrz55pvYu3cvTp06BQDd+rcXEBBg8nevfZ09MnWuAOCzzz5DTk4O8vPzMXz4cKxZswaxsbG49dZbAfS/czV06FAcOHAAKpUKNTU1uOWWW3DmzBmMGDGiz/xeMdSQRWzZssXwOiUlBYcOHUJOTg4WLFiA+vp6CSsje7Nx40bD65MnT+LEiRPIzMzE9OnTsWvXLgkrk9bbb7+NoUOHYsqUKVKX0udd7lx98MEHhtcnT55EQUEBdu3ahYiICGRmZlq7TMmlpqZixIgRcHd3x2233YaPP/4Y06ZNk7osI7z8dBW0Wi1aWlrg7+9vtNzf3x+FhYUSVdU3VVZW4ty5c4iKikJhYSGcnJwM3b3teN702s9BV79XhYWFnWYWyOVyeHl59ftzmJWVhZKSEsNssf54rt566y1cf/31mDFjBvLy8gzLu/Nvr7Cw0OTvXvs6e3O5c2XKoUOHAMDod6s/navm5mZkZGTg6NGjeOqpp5CcnIzFixf3qd8rhpqr0NzcjKSkJMyaNcuwTCaTYdasWThw4ICElfU9rq6uiIyMREFBAZKSktDU1GR03mJiYhAeHs7zBv0f5YKCAqPzo1arMX78eMP5OXDgADw9PTFq1CjDNjNnzoSDg4PhP7z9VXBwMLy9vVFQUACg/52rt956C7fccgtmzpyJ7Oxso3Xd+bd34MABDBs2DL6+voZt5syZg8rKSpw+fdoqn8FaujpXpowYMQIAjH63+su5MsXBwQFOTk597vdK8hHUttwWLFgg6uvrxZ/+9CcRFxcn/vOf/4iysjKjEd79sb3yyivimmuuEeHh4WLixIli27Ztori4WPj4+AhAP/0vOztbTJ8+XYwaNUrs27dP7Nu3T/K6rdVcXV1FfHy8iI+PF0II8eijj4r4+HgRGhoqAP2U7rKyMnHDDTeIoUOHis2bN5uc0p2UlCTGjh0rJk2aJFJTU+1ymnJX58rV1VW8/PLLYvz48SI8PFzMnDlTHDlyRKSmpgqlUtnvztXbb78tysvLxTXXXGM0DVmlUhm2udK/vfapt1u2bBHDhw8Xc+fOFUVFRXY3TflK5yoiIkI888wzYtSoUSI8PFzccMMNIj09XezevbvfnSsA4sUXXxRTp04V4eHhYujQoeLFF18Ura2tYvbs2X3t90r6k2Xr7e9//7vIzs4WDQ0N4uDBg2LcuHGS1yR1+/zzz0VeXp5oaGgQubm54vPPPxcRERGG9U5OTuLf//63KC0tFTU1NWLTpk3C399f8rqt1aZNmyZMWbdunWGb5557ThQUFIj6+nqxfft2ER0dbXQMT09P8emnn4qqqipRUVEhPvroI+Hq6ir5Z7PmuVKpVGLLli2iqKhINDY2iqysLPHee+91+p+K/nKuLichIcGwTXf+7YWFhYmffvpJ1NbWiuLiYvHKK68IuVwu+eez5rkKCQkRu3fvFlqtVtTX14tz586JNWvWGN2npr+cKwDiww8/FFlZWaKhoUEUFRWJ7du3GwJNX/q9krW9ICIiIrJpHFNDREREdoGhhoiIiOwCQw0RERHZBYYaIiIisgsMNURERGQXGGqIiIjILjDUEBERkV1gqCEiIiK7wFBDRP1KVlYWFi9eLHUZRGQBDDVEZDHr1q3D5s2bAQCJiYl44403rPbeCQkJKC8v77R87NixeP/9961WBxFZj0LqAoiIesLR0RHNzc293l+r1ZqxGiLqS9hTQ0QWt27dOkyfPh2PPvoohBAQQiA8PBwAMGTIEPz888+orq5GYWEhNmzYAG9vb8O+iYmJeOutt/DGG2+gpKQEW7duBQA89thjOHHiBGpqanD+/Hm8/fbbcHV1BQBMmzYN69evh4eHh+H9VqxYAaDz5afQ0FB8++23qK6uRmVlJTZu3Ag/Pz/D+hUrVuDYsWO4++67kZWVhYqKCnz++edwc3Oz+Hkjop5hqCEii1u8eDH279+P999/HwEBAQgICEBubi7c3d2xa9cuHDt2DGPGjMH8+fPh7++PL7/80mj/hIQENDU1YfLkyXjwwQcBADqdDo888giGDBmChIQEzJw5Ey+//DIAYP/+/Vi8eDEqKysN7/fqq692qksmk+G7776Dl5cXpk2bhjlz5iAiIgIbN2402i4yMhI333wzrr/+elx//fWYNm0annzySQudLSK6GpI/0pyNjc0+27p168TmzZsFAJGYmCjeeOMNo/VPP/202LJli9Gy4OBgIYQQ0dHRhv2SkpKu+F633nqrKCkpMXyfkJAgysvLO22XlZUlFi9eLACI2bNni+bmZhESEmJYP2jQICGEEGPGjBEAxIoVK0RNTY1wc3MzbLNmzRpx4MAByc8vGxubceOYGiKSTHx8PGbMmIHq6upO6yIjI5GWlgYASEpK6rR+1qxZWL58OeLi4qDRaKBQKODs7AxnZ2fU19d36/0HDRqE3NxcXLhwwbDszJkzKC8vx6BBg3DkyBEAQHZ2NmpqagzbFBQUGF2iIqK+gaGGiCTj5uaGH374AcuWLeu0rqCgwPC6trbWaF14eDh+/PFHvPvuu3j66adRVlaGKVOmYO3atVAqld0ONd116cBkIQQcHHj1nqivYaghIqtoamqCXC43Wnb06FHceuutyM7ORmtra7ePNXr0aDg4OGDJkiUQQgAAFixYcMX3u9SZM2cQGhqKkJAQQ2/NoEGD4OnpidOnT3e7HiLqG/i/GkRkFdnZ2Rg/fjzCw8Ph7e0NmUyGt99+G15eXvj8888xZswYREREYO7cuVi7dm2XPSHp6elQKpV4+OGHMXDgQNx9992GAcQXv59arcbMmTPh7e0NZ2fnTsfZsWMHUlJS8Omnn2LkyJEYO3YsNmzYgN27d5u85EVEfRtDDRFZxauvvorW1lacPn0aWq0WYWFhKCgowOTJkyGXy7Ft2zakpKTgzTffREVFBXQ63WWPdeLECTz22GNYtmwZTp48ibvuugvLly832ubAgQN49913sXHjRmi1WjzxxBMmj3XTTTehvLwcv/76K3bs2IHMzEwsXLjQrJ+diKxDBv2IYSIiIiKbxp4aIiIisgsMNURERGQXGGqIiIjILjDUEBERkV1gqCEiIiK7wFBDREREdoGhhoiIiOwCQw0RERHZBYYaIiIisgsMNURERGQXGGqIiIjILvx/e6rguoacbBAAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -360,7 +379,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 22, "id": "843c0ad3", "metadata": {}, "outputs": [ @@ -369,11 +388,11 @@ "output_type": "stream", "text": [ "Circuit #1\n", - "cost: -5.7345343 \n", + "cost: -5.6885176 \n", "bit strings: ['01010101', '10101010']\n", "\n", "Circuit #2\n", - "cost: -6.0113034 \n", + "cost: -6.0111885 \n", "bit strings: ['01010101', '10101010']\n" ] } @@ -419,13 +438,13 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 23, "id": "fb183e97", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -461,7 +480,7 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 24, "id": "2115bb6d", "metadata": {}, "outputs": [ @@ -530,7 +549,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 25, "id": "b0a1f778", "metadata": {}, "outputs": [], @@ -560,7 +579,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 26, "id": "f9f5ce41", "metadata": {}, "outputs": [ @@ -580,13 +599,13 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 27, "id": "35dea0fb", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgQAAAGFCAYAAACCBut2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABe9ElEQVR4nO3dd1iT1/vH8XfCVAS3ooDirqt1F8RZ3AvFiaPujQJttfvb8dMOrRXUOmoddRQcuMWtuLGOWq17ouCeqICM5PdHKnVAWIEnJPfrurzQ8Iw7HebDec65jwrQIoQQQgizpla6ACGEEEIoTwKBEEIIISQQCCGEEEICgRBCCCGQQCCEEEIIJBAIIYQQAgkEQgghhAAsM3pg6dKlefLkSU7WIoQQQggDs7e358aNG+kel6FAULp0aaKjo7NdlBBCCCFyn5OTU7qhIEOPDGRkQAghhMi7MvI5LnMIhBBCCCGBQAghhBASCIQQQgiBBAIhhBBCIIFACCGEEEggEEIIIQQSCIQQQgiBBAIhhBBCIIFACCGEEEggEEIIIQQSCIQQQgiBBAIhhBBCIIFACCGEEEggEEIIIQQSCIQQQgiBBAIhhBBCIIFACCGEEICl0gUIExEXB2fPwpMnYGkJLi7g7AwqldKVCSGEyAAJBCLrbtyAuXNh+XJdGNBoXv1+4cLQuDEMGwZt2oCFhTJ1CiGESJcK0KZ3kL29PTExMblQjsgTHj+GceNg3jzdn18PAi+zsIDkZChTBn79FVq3zp0ahRBCpHBwcODJkyd6j5E5BCJz9uyBt96C+fN1QUBfGABdGACIitKNEgwZAs+f53ydQgghMkUCgci4TZugRQu4c+e/D/qMehEcFiyAdu0gPt7w9QkhhMgyCQQiY44dg86dISkp/VEBfTQaCA+Hvn1Bm+7TKiGEELlEAoFI3/Pn0KePblQgAx/iE9FNTqmR1gEaDYSGQnCwAYsUQgiRHRIIRPqmTIFz5zL0mCAK+A6wS+9AlQpGjdJNUBRCCKE4CQRCv8REmDo1w8P7HwFuQL30DtRqISYGFi/OZoFCCCEMQQKB0G/tWrh3L0OH7gFWAoGZuf706ZmvSQghhMFJIBD67dgBVlbpHpYMjAGGADUzem2tFs6fh1u3sl6fEEIIg5BAIPQ7dEj32CAds4FI4P+yco+jR7NylhBCCAOSQCD0u3Ah3UPuA/8DvgSKZ/b6arVulEAIIYSiJBAI/RIS0j3kC6AIukcGmaZWS+dCIYQwArK5kdDP2lpvKLgA/IpuIuGNl16PBxKBq4ADusCQKo0GbG0NUKgQQojskBECod9bb+n9djSgAcYC5V76dQg4/+/vv9V3AY0m3XsIIYTIeTJCIPRKqF0by7/+Qp1GU6IawOpUXv8CeAIEARXSu0ndutkpUQghhAFIIBBviI+PJywsjODgYLRr17JST4fCYkDnVF4P/Pdrat97QQMkVKyIbfFMT0UUQghhYPLIQACQmJjI5s2bGTBgACVLlqRr165cunQJt2+/JalEiRy5pwoYe/EirVu3JiwsDE12Nk0SQgiRLRIIzJhGo2Hv3r2MGjWK0qVL07ZtWw4ePEhAQABnzpzh2LFjfPTJJ1h+/LFu74FMCAf+0XeASgVFi+L52288ePCA9u3bU7VqVWbOnMnTp0+z8a6EEEJkhQpIt0m9vb09MTExuVCOyGlarZZjx44RHBzMsmXLiIqKwsXFhV69etGrVy9q166N6vUP/6QkqF8fTp7M0AZHGbZ6NXTujFar5cCBAwQFBREaGoqDgwNDhgzB19eXsmXLGu5+QghhphwcHHjy5IneYyQQmImzZ88SHBxMSEgI58+fp3jx4nTv3h0fHx8aNmyIWp3OYNGpU7pQ8Py5bmVAdqhU8P77sHDhG9+KjIzkl19+Ye7cucTExODt7Y2fnx8eHh5vBhUhhBAZIoHAzEVGRrJs2TKCg4M5fvw4Dg4OeHt74+Pjw3vvvYelZSbnlO7eDW3a6FoZZ3WkQKWCjh1h5Uq9eyQ8e/aMRYsWERQUxLlz56hbty7+/v706NEDa2vrrN1bCCHMlAQCM3T79m1WrFhBcHAwBw4cwNbWlo4dO+Lj40Pbtm2xzW4ToCNHoGdPuHo1cyMFFha64wMC4IcfMrRhEujmOWzZsoWgoCC2bNmCo6Mjo0aNYvjw4ZTIocmOQghhaiQQmIlHjx6xatUqQkJC2LFjB2q1mtatW+Pj40OnTp2wt7c37A3j4ogJCMB6zhxsVCpUWj3/CVla6uYgVK8Oc+aAh0eWb3v69GmmTZvGokWL0Gg09OnTBz8/P95+++0sX1MIIcxBRgKBrDLIo2JjY1m2bBmdO3emZMmSDBkyhMTERGbNmsWtW7fYsGEDffr0MXwYAMiXj2/s7HjLwYGE776Dhg0hX743jytTBnr3hr17dRMSsxEGAKpVq8bs2bOJiorim2++YevWrbzzzju89957rFu3jmRDTngUQggzIyMEeUhCQgJbtmwhJCSEtWvX8uzZMxo0aECvXr3o0aMHTk5OuVLHo0ePcHFxYezYsUycOFH3okYDV67A06e6xwPOzlCoUI7WkZiYyKpVqwgMDCQiIoIKFSowZswYBg4ciIODQ47eWwgh8hJ5ZGACkpOT2b17N8HBwYSGhvLw4UOqV6+Oj48PvXr1okKFdBsDG9wPP/zA119/zdWrV3F0dMz1+6fm0KFDBAUFsWLFCvLly8fgwYMZM2YM5cuXV7o0IYRQnASCPEqr1XLo0CGCg4NZvnw5t27doly5cikhoGbNmorVFh8fT7ly5ejUqRNz5sxRrI60REdHM3PmTGbPns3Dhw/p1KkT/v7+NG3aVJYtCiHMlgSCPObkyZMpvQKuXLmCo6MjPXv2xMfHhwYNGhjFB9pvv/3GsGHDOHv2LJUrV1a6nDTFxsaydOlSAgMDOX36NO+88w5+fn74+Phkf6WFEELkMRII8oBLly6lhIBTp05RuHBhunbtio+PD02bNsXCwkLpElNoNBqqVq1KjRo1CA0NVbqcDNFqtezYsYPAwEA2btxI8eLFGTlyJCNHjjSaxx1CCJHTJBAYqRs3bqQ0DDp8+DB2dnZ4eXnh4+NDq1atjLbxzpo1a+jSpQsHDx7Ezc1N6XIy7fz580ybNo2FCxeSkJBAr1698Pf3p06dOkqXJoQQOUoCgRG5f/8+K1euJCQkhN27d2NlZUW7du3o1asXHTp0wM7OTukS09WwYUMsLS3Zs2eP0qVky6NHj5g3bx7Tp08nMjKSxo0b4+fnh5eXV+a7NwohRB5gdoFAq9WSqNWiBaxVKsWfuT958oS1a9cSHBzM1q1b0Wg0eHp64uPjQ5cuXSiUw8vyDGn//v00atSI9evX06FDB6XLMYikpCTWrVtHYGAge/fupWzZsowZM4bBgwfnqX83QgiRHrMIBP88fcri27c5GBPDsSdPePZvO11btZpaBQrg7uBA7xIlqJdL69Lj4+MJCwsjODiYDRs2EB8fj4eHBz4+PnTr1o2SJUvmSh2G5uXlxcWLFzl58mT6GyHlQceOHSMoKIjg4GCsra0ZMGAAY8eONeqJk0IIkVEmHQgOxcTw4cWL7I+JwVKlIimN9rkvvlenQAEmVaiAZ+HCBq8lKSmJHTt2EBwczOrVq4mJiaFWrVr4+PjQs2fPPL+F75kzZ6hWrRoLFixgwIABSpeTo27dusWsWbOYNWsWd+/epX379vj7++Pp6an4iJMQQmSVSQaCBI2GL69cYfL166iBjDarVQMaYFipUvxcsSJ22Zy9r9Fo2L9/PyEhIaxYsYK7d+9SqVIlfHx88PHx4a233srW9Y3J4MGD2bx5M1euXDHaCY+GFh8fT0hICIGBgfz9999Ur14dPz8/+vbtS77U2jQLIYQRM7lAEJecTKd//mHnw4dkYp+9V6iBevb2bH3nHQpmcgKZVqvlr7/+Ijg4mGXLlnH9+nWcnZ3p1asXPj4+1K5d2+R+irxx4waurq5MnDiRcePGKV1OrtNqtezevZvAwEDWrVtHkSJFGD58OKNGjcq1VtFCCJFdJhUINFotnU6eZNODB1kOAy9YAO86OBBeqxZWGXgefvbs2ZReAefPn6d48eJ0796dXr164eHhYZLP1F/4+OOPmT17NteuXaNgwYJKl6OoS5cuMWPGDObNm0dcXBzdu3fH39+fBg0aKF2aEELoZVKB4JfoaHwvXNB/0Pnz8Pvvup31EhKgVCno0AG6dn3jUBXwlasrX7m6pnqpa9euERISQnBwMMePH8fBwYEuXbrg4+ODp6enWSxPi4mJwcXFhREjRvDjjz8qXY7RiImJYeHChUybNo1Lly7h5uaGv78/3t7eWFlZKV2eEEK8wWQCwbX4eKr8+SfxGj1jA4cPw+efQ8WK0Ly5bjveGzd0u/CNGJHqKRbA8Xr1qFGgAAC3b99mxYoVBAcHc+DAAWxtbenQoQM+Pj60a9fO7Fre/vTTT3z22WdcvXqV0qVLK12O0UlOTmbjxo0EBgaya9cunJ2d8fX1ZejQoRQpUkTp8oQQIoXJBIJxly4x9fr1tCcQPnsG/fpBjRrw9deQwSF8S6B74cK0PHaM4OBgduzYgVqtplWrVvj4+ODl5YW9vb2B3kXekpCQQLly5WjTpg3z5s1Tuhyjd+LECYKCgli6dClqtZr333+fsWPHUq1aNaVLE0II0wgE8cnJOB44wONkPesJ1q2DqVNh4UIoWxbi4sDGJmPBIDERunenWe3a9OrVi65du1KsWDGD1Z9XLVy4kIEDB3L69GmqVq2qdDl5xp07d5gzZw4zZ87k1q1btG7dGj8/P1q3bm3Sc02EEMbNJALBzocP8fz7b/0HffUVHD0K33wDQUFw/TrY2kKrVjB6NKSzVG6moyMjTWiZYHZpNBpq1qxJhQoVWLdundLl5EkJCQksX76cwMBAjh49SpUqVfDz8+P999/PE22qhRCmJSOBwOh/ZDny5En6RUZFQXIyfPEF1KunCwZt2+pGDtKZDGelUnFFJoK9IiwsjNOnTzN+/HilS8mzrK2t6du3L4cPH2bfvn3UrFkTX19fnJ2dGT9+PNeuXVO6RCGEeIXRB4JTz56R7sr++Hjdr1atYOxYaNJE97VjR9i5UxcY0pCo1XLy6VOD1pzXTZ48GXd3dzw8PJQuJc9TqVR4eHiwYsUKLl++zJAhQ/j1118pX7483bt3Z//+/WjT6LIphBC5yegDwbPk5PT7Drx4JPDee6++7ump+3rqlN7T9c5PMDMRERHs2bOH8ePHm1yTJaWVLVuWyZMnExUVxbRp0zhx4gSNGjWiQYMGLF26lISEBKVLFEKYMaMPBJYqVfojBC8mAb6+T8GLP6fz3OTCmTP4+/vz008/ERISwr59+7hy5QrPnz/PUs152eTJk6lcuTKdOnVSuhSTVaBAAUaNGsWZM2cICwujSJEi9O3bF1dXVyZMmMDdu3eVLlEIYYaMvrtOWVtbLFQqNPqGVStXhiNH4N49KFPmv9fv3dN91bOVrUqjwfruXbZs2UJUVBRPX3t8UKJECZydnXFycsLZ2TnV3xf4t49BXnf+/HlWr17NnDlzZEZ8LlCr1bRt25a2bdty6tQppk2bxnfffceECRPo27cvfn5+1KxZU+kyhRBmwuhXGay4c4cep0/rP+jCBRg2TPeI4Isv/nv9//4Pdu+GkJD/RhFeowJmVKrEqH/70sfExBAVFZXyKzo6+o3f379//5VrFCxYMCUgvB4YXvy5cOHCRj8EP3z4cNauXcvVq1fNrgmTsbh//z5z585lxowZREdH89577+Hv70/79u0lpAkhsswklh3eeP4c54MH0y9y0iTYtAmaNYN33oHjx3VhoHdvGDpU76kn6tWjZiZ+yo+LiyM6OjrVsPDi161bt16ZLJYvX740w8KL35coUUKxv/Rv375N2bJl+eqrr/j0008VqUH8JzExkVWrVhEYGEhERAQVKlRg7NixDBw40GybZQkhss4kAgFAx5Mn2Xz/Pkn6DkpKgqVLdaHg/n0oWRI6d4Zu3dI85cXOh4fq1jVwxbq/0G/duqV3pCE6OprExMSUcywtLSldurTekYbSpUvnSL/8L774gqCgIK5du0bh1+diCEVFREQQFBTEypUryZ8/P4MHD8bX15fy5csrXZoQIo8wmUCw/cEDWp44kSPX/qNqVXxKlsyRa6dHo9Fw9+5dvSMNUVFRxMbGppyjUqkoWbKk3pEGJycn8ufPn+E6nj59iouLC4MGDWLKlCk58VaFAURFRTFz5kzmzJnDw4cP8fLywt/fnyZNmhj94yghhLJMJhAA9Dh1ilV376a9n0EmWQIeBQuyq1Yto/7LVKvV8vjxY70jDVFRUTx8+PCV8woXLqx3pMHZ2ZmCBQuiUqkIDAxk3LhxXL58GRcXF4Xeqcio2NhYlixZQlBQEKdPn6ZWrVr4+fnRq1cvmfshhEiVSQWCuwkJVP3zTx4lJWU7FKiBfGo1/9Svj2u+fIYoT3GxsbF6Rxqio6O5ffv2K/Ma7OzscHJyIjIyEicnJ3r16vVGeChWrJhMZjNSWq2W7du3ExgYSFhYGCVKlGDkyJGMGDECR0dHpcsTQhgRkwoEAH89eULT48eJTU7OcihQA9ZqNZvffpumepYjmqKEhARu3rz5SmDYtm0bmzdvplatWjx48IAbN26QlPTfbA0rKyu9Sy6dnZ0pVaoUlpZGv4LVpJ07d47p06ezYMECEhMT8fHxwc/Pjzp16ihdmhDCCJhcIAA48fQpnU6e5Prz5+l3MHyNBVDUyorVNWrQsGDBnCgvT9FqtdSqVQsnJyfCwsIA3byGO3fu6B1piIqKIi4uLuU6arUaR0fHdOc1yHB2znv48CHz5s1jxowZREZG0qRJE/z8/PDy8sLCwkLp8oQQCjHJQAC6dsafXr7MjOho1JD+aEFSElha8n7JkgRWrEhh2cwIgC1bttCmTRt27dpFs2bNMnyeVqvl4cOHeuc0REVF8fjx41fOK1q0aLrzGhwcHAz8Ls1TUlISa9euJTAwkH379uHq6sqYMWMYPHgwBSUMC2F2TDYQvHAlLo45N24w/9Yt7r60fO9lhSwtcYiIoGB4OCc2bMjlCo2bp6cnT5484dChQzkysfLp06dpBoYXv79z584r59jb2+sdaXB2dqZo0aJGPRHU2Bw9epSgoCBCQkKwsbFhwIABjB07lkqVKuXsjW/ehHPnIC4ObGygYkVwcQH5dydErjP5QPCCVqsl+vlzjj19yt3ERDRaLUWtrKhToABlbW3ZuHEjHTt25NChQzRo0EDpco3CkSNHqF+/PsuXL6d79+6K1fH8+XNu3Lihd6Th5s2bJL+0AZWNjU1KSEgrPDg6OsoQ+Wtu3rzJrFmzmDVrFvfv36d9+/b4+/vz3nvvGS5gHT4MM2fCxo2Q2p4MhQpBy5YwcqSuiZiEAyFyhdkEgvQkJydTqVIlGjVqxKJFi5Quxyj07NmTI0eOcP78eaP/4ExOTub27dvpLr18eTMqCwsLSpUqleaESGdnZ0qXLo2NjY2C70wZ8fHxBAcHExgYyIkTJ6hRowZ+fn706dOHfFlddXPuHAweDPv3g6Wl7jFdWl58v0YNWLAA6tXL2j2FEBkmgeAlP/30E59//jnXr1+nRIkSSpejqMuXL1OpUiVmzJjByJEjlS7HILRaLffv30936eXr/x0XL15c7woKZ2dnk9m86nVarZbw8HCCgoJYt24dRYoUYfjw4YwaNQqnf/f2yJCZMyEgADQa/UHgdRYWoNXCl1/CV1/JaIEQOUgCwUsePHiAk5MTX375JZ999pnS5SjK19eX5cuXExkZmfWfCPOomJiYV1pHpxYe7r3YJfNfBQsWTHcFRZEiRfL0vIZLly4xffp05s+fT1xcHD169MDPzy/9R2zffANff539AoYOhTlzJBQIkUMkELxmyJAhbNmyhStXrpjtuvm7d+9StmxZPv30U7788kulyzFK8fHx3LhxQ+9Iw82bN9Fo/lv4amtrm+4KihIlShj945mYmBgWLFjAtGnTuHz5Mu7u7vj7++Pt7f3m/zPz5sGQIYa7+ddf60YKhBAGJ4HgNcePH6d27dqEhobi7e2tdDmK+Prrr5k8eTLXrl2jaNGiSpeTZyUlJaVsXqVvJUVCQkLKOZaWlpQqVUrvCopSpUphbW2t4DvTSU5OZsOGDQQFBbFr1y5cXFwYPXo0Q4cOpUiRInD1KlSrpltBkIpwoHka1z4IuKX2DbUa/vwTcmCzMSHMnQSCVDRu3BgrKyt27typdCm57tmzZ5QtW5bevXszbdo0pcsxeVqtlnv37ukdabh+/TrPnj175bySJUvqHWlwcnLCzs4u197H33//TVBQEEuXLsXCwoL+/fsz6fRp7A8cSHPOQDi6QDAWqP/a99oAxVI7ycJCFzL+/lseHQhhYBIIUrFs2TJ69erFyZMnqVGjhtLl5KoZM2bg7+/PxYsXcXV1VbocgS40xMTEpNvk6cGDB6+cV7hw4XTnNRQqVMig8xru3LnDnDlzCJs2jYOvzbN4XTi6QLACSHsD8jTs2QONG2epRiFE6iQQpCIhIQFXV1e8vLyYNWuW0uXkmqSkJCpVqoS7uzt//PGH0uWITIqLi0t1MuTLf75169Yrm1flz58/3XkNxYsXz/TmVUkffog6MBC1Ju3m4eH8FwhaA/nQ7TCaLktL6NYNgoMzVZMQQj8JBGn45ptvmDRpEtHR0RQykw2OXoyMHDt2jNq1aytdjsgBiYmJ3Lx5U+9Iw40bN0h8qaunlZUVpUuX1jvSUKpUKaxebvddq5ZuWF+PcHSBoADwFN0+Io2ByUC6XQeKFUu9qZEQIsskEKTh5s2blClThp9++gk/Pz+ly8lxWq2WevXqUbRoUbZu3ap0OUJBGo2Gu3fv6h1piIqKIjY2NuUclUqFo6Mjzs7OlHV0JGTDBiy0+v/aOAD8DLRDN1/gNPAT8Ozf76UbSaOjoXTprL9RIcQrJBDo0bt3b44cOcLZs2czPWSa1+zYsYMWLVqwbds2WrRooXQ5wshptVoePXqU6khD8rlzzN+7N0vXvQi8DTQBNqd3cHg4NG2apfsIId4kgUCPAwcO4OHhwaZNm2jTpo3S5eSo1q1bc+fOHY4dO5anm+cII3D6NFSvnuXTfYBVQCy6xwhp2rpVt+eBEMIgMhIITPtHYz3c3d2pXbs2M2bMULqUHHX8+HG2bt3K+PHjJQyI7MtmZ0sXIAHdo4OcvI8QIvPMNhCoVCp8fX0JCwvj0qVLSpeTYyZPnkzZsmUV3dFQmBAXF91Wxll0GbBFN9lQr6pVs3wPIUTWmG0gAPDx8aFw4cImu/wwMjKSZcuW8eGHH5ptq2ZhYJaW8M476R6W2hqBv4F1QCvS+YundGmQLppC5DqzDgT58uVj8ODBzJs375VZ1aZi6tSpFCxYkEGDBildijAlHTro2gzr0RNoD0wE5gIBQEMgP/CDvhMtLXXXF0LkOrMOBACjRo3i8ePHJtes5/79+8ydO5fRo0fnaptbYQYGD063tXBn4B66pYejgGWAN3AE0PswICkJTGRLbiHyGrMPBK6urnTs2JHp06e/0uUtr5s1axYajQZfX1+lSxGmpnRp6NNHt/dAGsYCh4D7QCJwA1gMVNR3XQsLaN5c1/hICJHrzD4QAPj6+nLixAn27dundCkGERcXx7Rp0xg4cCAlSpRQuhxhin7+GQoVMtgmRFpAa2UFv/1mkOsJITJPAgHg6elJlSpVTGYJ4qJFi7h//z4ffPCB0qUIU1W0KPz+u8EupwK+LlqU6y+3SBZC5CoJBIBarWb06NGsWrWK6OhopcvJluTkZH766Se6du1KxYp6B2iFyJ727WHhQt0oQTa7fd4OCOB3S0veffdd/vrrL8PUJ4TIFAkE/+rfvz+2trb8+uuvSpeSLWvWrOHixYuMGzdO6VKEOXj/fdiwAYoU0TunIFWWllCgACxaRMmffyYiIgInJycaN25MWFhYztQrhEiTBIJ/OTg40L9/f+bMmUNCQoLS5WSJVqvlxx9/pFmzZtSvX1/pcoS5aNcOzp3ThQNLy/RHCywsdKMKHTvCmTPQrx8Ajo6OhIeH4+npSceOHU22P4gQxkoCwUtGjx7N7du3WblypdKlZMmePXs4fPgw48ePV7oUYW6KFIH58yEqCv7v/8DD4832w9bWUK8efPwxXL4Mq1aBs/Mrh9jZ2bFq1Sp8fX0ZNWoU48aNQ6PR5OIbEcJ8me3mRmlp0aIFsbGxHDhwQOlSMq19+/Zcu3aNEydOyL4FQnkajW4b4/h4XRhwctKNIGRQUFAQAQEBeHt7s3jxYvLJ/gZCZJlsbpQFvr6+HDx4kKNHjypdSqb8888/hIWFySZGwnio1bq9DypVgrJlMxUGAPz8/Fi9ejVhYWG899573LlzJ4cKFUKAjBC8ISkpiQoVKuDp6cn8+fOVLifDBgwYwM6dO7l06RJWsnRLmJDDhw/TsWNH7OzsCAsLo0qVKkqXJESeIyMEWWBpacmoUaP4448/uHfvntLlZEhUVBRLly4lICBAwoAwOfXr1yciIgIbGxvc3d3Zs2eP0iUJYZIkEKRi8ODBAMybN0/hSjImMDAQOzs7hgwZonQpQuQIV1dXDhw4QO3atWnZsqXJ7T0ihDGQQJCKYsWK4ePjw8yZM0lOTla6HL0ePXrEnDlzGDVqFPb29kqXI0SOKVSoEJs2bcLHx4c+ffowYcIEk9p/RAilSSBIg6+vL9euXWPDhg1Kl6LX7NmzSUhIYOzYsUqXIkSOs7a2ZsGCBXzzzTd8+eWXDBkyhMTERKXLEsIkyKRCPdzd3SlQoADbtm1TupRUPX/+PGW3xrzeYVGIzFq8eDGDBw+madOmrFy5koIFCypdkhBGSyYVZpOvry/bt2/nzJkzSpeSqiVLlnD79m0+/PBDpUsRItf169ePrVu3cuTIETw8PLh27ZrSJQmRp0kg0KN79+6ULFmSX375RelS3qDRaJg8eTJeXl6yDEuYrWbNmnHgwAGePXvGu+++m+f6hwhhTCQQ6GFtbc2wYcP4/fffje6Ryfr16zl37py0KRZmr2rVqkRERFCmTBmaNGnC+vXrlS5JiDxJAkE6hg8fTlxcHIsWLVK6lFdMmjSJRo0a4e7urnQpQiiuZMmS7Nq1i9atW9O5c2ejHNUTwthJIEiHk5MT3t7ezJgxw2iWOO3fv58DBw7I6IAQL8mfPz8rVqzAz88PX19fPvjgA6NfNiyEMZFAkAG+vr6cO3eOHTt2KF0KAJMnT6Zq1aq0b99e6VKEMCoWFhb8/PPPTJ8+naCgILp3705sbKzSZQmRJ8iywwzQarXUqlULV1dX1q5dq2gtZ8+epWrVqsyfP5+BAwcqWosQxmz9+vX06tWLGjVqsG7dOkqWLKl0SUIoRpYdGohKpcLX15f169dz9epVRWv56aefKFWqFL1791a0DiGMXceOHdmzZw/Xrl3Dzc3NaJcPC2EsJBBkUO/evSlYsCCzZs1SrIYbN26wePFi/P39sbGxUawOIfKKunXrEhERgZ2dHQ0bNiQ8PFzpkoQwWhIIMsjOzo5Bgwbx22+/ERcXp0gN06ZNw8bGhuHDhytyfyHyorJly7J//37q1q1Lq1atWLJkidIlCWGUJBBkwsiRI3n48CEhISG5fu+YmBhmzZrFiBEjpEWrEJlUsGBBwsLC6Nu3L/369ePbb781mlVDQhgLCQSZULFiRdq2bcv06dNz/S+TuXPnEhcXh5+fX67eVwhTYW1tzbx585gwYQJfffUVgwYNIiEhQemyhDAaEggyacyYMfz1118cPHgw1+6ZkJDA1KlT6du3L05OTrl2XyFMjUql4vPPP2fJkiX88ccftG3blkePHildlhBGQQJBJrVq1YqKFSsyY8aMXLtncHAw0dHRfPTRR7l2TyFMWZ8+fdi6dSt//fUXHh4eiq8eEsIYSCDIJLVazejRo1mxYgU3b97M8fu92MSoQ4cOVKtWLcfvJ4S5aNq0KQcPHiQuLg43NzeOHDmidElCKEoCQRYMGDAAa2tr5s6dm+P32rRpE6dOnZI2xULkgCpVqhAREYGrqytNmzZl3bp1SpckhGIkEGRBoUKF6NevH7NnzyYxMTFH7zVp0iTc3Nxo1KhRjt5HCHNVokQJdu3aRdu2bencuTPTpk1TuiQhFCGBIItGjx7NzZs3WbVqVY7d49ChQ+zZs4fx48ejUqly7D5CmLt8+fKxfPlyPvzwQ/z8/PD395eNkYTZkb0MsqF58+YkJSWxd+/eHLl+t27dOHnyJKdPn8bCwiJH7iGEeNXMmTMZM2YMHTt2ZOnSpdjZ2SldkhDZJnsZ5DBfX1/27dvH8ePHDX7tCxcusGrVKj788EMJA0LkolGjRrFu3Tq2b99Os2bNuHXrltIlCZErJBBkg5eXF87Ozvzyyy8Gv/aUKVMoXrw477//vsGvLYTQr3379uzZs4fo6Gjc3Nw4ffq00iUJkeMkEGSDpaUlI0aMYOnSpTx48MBg1719+zYLFy7Ez88PW1tbg11XCJFxderU4dChQzg4ONCwYUN27typdElC5CgJBNk0dOhQkpOTmT9/vsGuOWPGDCwtLRk5cqTBrimEyDwXFxf27dtHgwYNaN26Nb///rvSJQmRYyQQZFOJEiXo2bMnM2fONMis5KdPn/LLL78wbNgwChcubIAKhRDZ4eDgwMaNGxkwYAADBgzg66+/lo2RhEmSQGAAvr6+XLlyhU2bNmX7WvPmzSMmJgZ/f//sFyaEMAgrKyt+/fVXvvvuO7755hv69+8vGyMJkyPLDg2kQYMGFClShM2bN2f5GomJiVSsWJEmTZqwePFiA1YnhDCUkJAQ+vfvT8OGDVm1apWM5Ik8QZYd5iJfX1+2bNnC+fPns3yN5cuXc+3aNcaNG2fAyoQQhtSrVy+2b9/OiRMnaNiwIVeuXFG6JCEMQgKBgfTo0YNixYpleQmiVqtl0qRJtGnThrffftvA1QkhDKlx48YcPHiQxMRE3Nzc+PPPP5UuSYhsk0BgILa2tgwdOpSFCxemOyyTmm3btnHixAnZxEiIPKJy5cocPHiQChUq0KxZM1avXq10SUJkiwQCAxo5ciRPnz5lyZIlmT530qRJ1KtXj2bNmhm+MCFEjihevDg7duygQ4cOdO3alcDAQFmBIPIsCQQG5OLiQufOnZkxY0am/lI4evQoO3bsYNy4cbKJkRB5TL58+QgJCWHcuHEEBATg5+cnGyOJPEkCgYH5+vpy+vRpwsPDM3zO5MmTKV++PN7e3jlXmBAix6jVan788Udmz57NzJkz6dKlC8+ePVO6LCEyRQKBgTVr1oxq1aoxY8aMDB1/+fJlVqxYwYcffoilpWUOVyeEyEnDhw9n/fr17Nq1i6ZNm3Lz5k2lSxIiw6QPQQ6YNWsWo8eMYfE///CXpSV/PnnC6WfPeK7VYq1SUSV/fhrY2+NZuDCbvv6aFcuWERkZSf78+ZUuXQhhAMePH6d9+/ZYWloSFhZG9erVlS5JmLmM9CGQQGBgGq2WaVeu8MHhw2hLlsRSpSIplfkEVioViVot3L9Pq0eP2DBwIFZqGbARwlRERUXRvn17rl69SmhoKC1atFC6JGHGpDFRLrsYG0ujv/4i4No1tCVKAKQaBgBdGAAoUoRtFSpQ9+hRTjx9mlulCiFymLOzM3v37sXd3Z22bduyYMECpUsSQi8JBAYS8fgxdY4e5fCLkZSMrhZQqdACp589491jx9hmwG2UhRDKcnBwYP369QwaNIhBgwbx5ZdfyrJEYbQkEBjAiadPafH338QmJ5OUxWskAwkaDR1OnmT/48eGLE8IoSArKytmz57Njz/+yIQJE+jXrx/Pnz9Xuiwh3iBzCLLpuUbDO4cPczEujlRXHv/wA2zZkvYFli+H4sVT/qgGHK2tOdugAfay6kAIk7Js2TL69+/Pu+++y+rVqylSpIjSJQkzIZMKc8GXV64wMTIy7X+Ip07BjRuvvqbVwtSpULIkLFz4xilqYGipUsyuUsXA1QohlLZ//368vLwoVqwYYWFhlC9fXumShBmQSYU5LCYpiZ+uX9efqKpXh5YtX/1VqhTEx0Mas441wG83b3JDhhWFMDkeHh5ERESQnJyMm5sbERERSpckBCCBIFsW377Nc40m8ydu366bdKhnGZIWXSgQQpieihUrcvDgQSpXrkzz5s0JDQ1VuiQhJBBkx/I7dzJ/UlIShIfrRg4cHdM8TAOEZOX6Qog8oVixYmzfvh0vLy+6d+/Ozz//LCsQhKJk1loWabVajj19mv4EjNcdPgwxMXpHB144FxtLXHIy+SwsslSjEMK42dra8scff1CuXDk+/PBDLl26RFBQkLQxF4qQ/+qy6Nrz5zzNyo5m27eDpSVkYJtjDXA6Npa69vaZv48QIk9Qq9V8//33lC9fnpEjRxIZGUlISAgFChRQujRhZuSRQRbFJGWh40BcHBw4APXrQ8GCOXcfIUSeM3ToUDZu3MiePXto0qQJN15fnSREDpNAkEUWGe1E+LJ9+/SuLkiNZVbuI4TIk1q3bs2+ffu4e/cubm5unDx5UumShBmRQJBFTjY2mT9p+3bIlw8aNszwKc5ZuY8QIs96++23iYiIoGjRonh4eLBt2zalSxJmQgJBFhW0tKRsZj6sHz2Co0ehUSOwtc3QKfYWFrhm8FghhOlwcnJiz549NGrUiHbt2jFv3jylSxJmQAJBNjQtVCjjQ/q7dkFycoYfF1gAjQoWRCWPDIQwS/b29qxbt44hQ4YwZMgQPv/8czRZ6XsiRAbJKoNsGFKqFItu387Ywdu3Q+HCULduhg5PBoaVKpX14oQQeZ6lpSUzZ86kQoUKjBs3jitXrrBgwQJs5FGiyAGyl0E2aLVaahw+zLnY2NQ3NsoiNVDS2pprbm5YqmUQRwgBK1eupF+/ftSvX5/Vq1dTtGhRpUsSeYjsZZDDVCoVsypXNmgYAF3/gVmVK0sYEEKk6NatGzt37uTMmTO4u7tz6dIlpUsSJkY+cbKpSaFC+Dk5YbAn/cnJ1Lx9m06S/oUQr3F3dyciIgKVSoWbmxsHDx5UuiRhQiQQGMDkChVoW6RItv9hWgBlnj3jZP/+DBw4kISEBEOUJ4QwIRUqVODAgQNUrVqV5s2bs2LFCqVLEiZCAoEBWKnVrKpRg54lSgBkebSgdZEinG7fnqXz5xMcHEybNm149OiRweoUQpiGokWLsm3bNry9venRoweTJ0+WjZFEtkkgMBAbtZqlVauyrFo1CllaoiJjwUAN2KnV/FalChtq1sTOwoLevXuzbds2jh8/joeHB1evXs3Z4oUQeY6NjQ1Llizh888/Z/z48YwaNYokaXUuskFWGeSAx0lJLLp1i2nR0VyMiwN0jwPUKhVaIOnfJO9iY8MYJycGOjpSzNr6jeucO3eOtm3bEhsby4YNG6hXr14uvgshRF4xf/58hg8fTsuWLVm2bBn2siGaeE1GVhlIIMhBWq2WqOfPOfrkCWdjY4nXaLBRq6mULx/17O0pa2ubbuOhO3fu0KlTJ06ePElISAgdO3bMpeqFEHnJtm3b6NatG+XLl2fDhg04OTkpXZIwIhIITERsbCx9+/Zl7dq1BAUF4evrq3RJQggjdPLkSdq3b49Go2Hjxo288847SpckjIT0ITAR+fPnZ8WKFfj7+zNmzBg++OADkpMN3f1ACJHX1axZk4iICEqWLEmjRo3YsmWL0iWJPEQCQR5hYWHBlClTmD59OkFBQXTv3p3Y2FilyxJCGJnSpUuze/dumjZtSvv27fn111+VLknkERII8hhfX1/WrFnDli1baN68ObczupeCEMJsFChQgDVr1jBixAiGDx/Op59+KhsjiXRJIMiDOnbsyJ49e7h27Rru7u6cPXtW6ZKEEEbG0tKS6dOn8/PPP/Pjjz/Su3dv4uPjlS5LGDEJBHlU3bp1iYiIIH/+/Li7u7N7926lSxJCGBmVSkVAQAArV65k7dq1tGjRgnv37ildljBSEgjysLJly7Jv3z7q1KlDy5YtWbp0qdIlCSGMkLe3N+Hh4Zw/fx53d3cuXLigdEnCCEkgyOMKFSrEpk2b6NOnD3379mXChAnSwlQI8YZ3332XiIgILCwscHd3Z//+/UqXJIyMBAITYG1tzfz58/n222/58ssvGTJkCImJiUqXJYQwMuXLl+fAgQPUqFEDT09Pli1bpnRJwohIIDARKpWKL7/8kkWLFrF48WLatWvH48ePlS5LCGFkihQpwpYtW+jevTu9evXixx9/lFFFAUggMDn9+vVjy5YtHD58mEaNGnHt2jWlSxJCGBkbGxsWLVrEl19+ySeffMLw4cNlVFFIIDBFzZs358CBAzx58gQ3NzeOHTumdElCCCOjUqn49ttvWbBgAQsWLKBjx47Sot7MSSAwUdWqVSMiIgJnZ2eaNGnCxo0blS5JCGGEBgwYwObNmzl48CCNGzcmKipK6ZKEQiQQmDBHR0fCw8Np0aIFnTp1YubMmUqXJIQwQp6enhw4cIBHjx7x7rvvcvz4caVLEgqQQGDi8ufPT2hoKGPGjGH06NGMGzdOWpgKId5QvXp1Dh06RKlSpWjcuDGbNm1SuiSRyyQQmAELCwsCAwMJDAxkypQp9OjRg7i4OKXLEkIYGUdHR3bv3k3z5s3p2LEjs2fPVrokkYskEJgRPz8/Vq9eTVhYGO+99x53795VuiQhhJGxs7Nj9erVjBo1ipEjRzJ+/HgZVTQTEgjMjJeXF7t37+by5cu4ublx/vx5pUsSQhgZCwsLpk2bRmBgID/99BO9evWSUUUzIIHADNWvX5+IiAhsbGxwd3dn7969SpckhDBCfn5+rFq1ig0bNuDp6SmjiiZOAoGZKleuHPv37+ftt9+mRYsWhISEKF2SEMIIde7cmd27d3Pp0iXc3d1lVNGESSAwY4ULF2bz5s306NEDHx8fvv/+e2lhKoR4w4tRRWtraxlVNGESCMzcixam//vf//jss88YNmyYtDAVQrzhxajiO++8Q4sWLQgODla6JGFgEggEKpWKb775hoULF7Jw4UI6dOggLUyFEG94MarYq1cvevfuzXfffSejiiZEAoFI0b9/fzZv3syhQ4do1KiRtDAVQrzB2tqahQsX8vXXX/P5558zdOhQGVU0ERIIxCs8PT3Zv38/jx8/lhamQohUqVQqvvrqK37//XcWLVpE+/btZbt1EyCBQLyhevXqRERE4OjoKC1MhRBpev/999myZQt//vmnbLduAiQQiFSVKlWK3bt306xZMzp27Mivv/6qdElCCCPUvHlzDh48yNOnT2W79TxOAoFIU4ECBVizZg0jRoxg+PDhfPLJJ9LCVAjxhqpVq8p26yZAAoHQy8LCgunTp/Pzzz8zadIkfHx8iI+PV7osIYSRKVmyJOHh4bRs2VK2W8+jJBCIdKlUKgICAli5ciXr1q3D09OTe/fuKV2WEMLI5M+fn5UrVzJ27FhGjx7NRx99JKOKeYgEApFh3t7ehIeHc+HCBdzd3blw4YLSJQkhjIyFhQVTp05l2rRpTJ06le7duxMbG6t0WSIDVEC6XSXs7e2lUY1IcfnyZdq1a8e9e/dYu3YtHh4eSpckhDBC69atw8fHh5o1a7Ju3TpKlCiRsROfP4ezZyEmBiwswNkZXFxApcrZgk2Yg4MDT5480XuMjBCITCtfvjwHDhygevXqeHp6snz5cqVLEkIYoU6dOrFnzx4iIyNxc3Pj7NmzaR98+zZMnAjvvAMFCkCtWtCkCXh4QNmyUKQIdOwI69ZBcnKuvQdzIoFAZEmRIkXYunUrXbt2pWfPnkyaNElamAoh3lC3bl0iIiLInz8/DRs2ZM+ePa8e8PQp+PrqRgH+9z84cQKSkt680KNHsGkTeHmBqyts2JAb5ZsVCQQiy2xsbFiyZAlffPEFH3/8MaNGjSIptf+RhRBmrWzZsuzbt4/atWvTsmVLli5dqvtGRARUqwazZulCQHoTEF+MDNy4oRst6N8f4uJytngzInMIhEHMmzeP4cOH06pVK5YtW4a9vb3SJQkhjExCQgLDhw9n4cKFLB44kD5//IEqMTH9IJAWtRoaNoTNm8HOzrDFmpiMzCGQQCAMZuvWrXTr1o0KFSqwYcMGnJyclC5JCGFktFotc8aO5f0ZM7DFAMPUajW0a6ebWyCTDtMkkwpFrmrVqhX79+/n3r17uLm5ceLECaVLEkIYGVVyMiP278dWrU71A+gw4AtUB+yAMkAP4HxaF9RodPMJFi7MiXLNigQCYVA1a9bk0KFDFC9enEaNGrFlyxalSxJCGJPp0+H4cdRpPCb4EQgFPIEgYBiwB6gD/KPvumPGwP37hq3VzEggEAZXunRp9uzZQ+PGjWnfvj2//fab0iUJIYxBcjJMmQJ6ViR9AEQC04AhwBfAXiAJ+EHftePiYMECw9VqhiQQiBxRoEAB1q5dy9ChQxk6dCiff/65tDAVwtxt3gzR0XoPaQhYv/ZaJXSPEM7oO1Gj0Y0+yPLnLLNUugBhuiwtLZk5cyYVKlRg3LhxXLlyhQULFmBjY6N0aUIIJWzfDlZWkJiYqdO0wG10oUCva9fg6lUoVy5r9Zk5GSEQOUqlUvHRRx+xfPlyVq1aRcuWLbkvz/mEME9//pnpMACwFIgGembk4KNHM319oSOBQOSK7t27s3PnTs6cOUPDhg25dOmS0iUJIXLbuXOZPuUsMBpwB/qnd7ClJZxPcz2CSIcEApFrGjZsyMGDB9Fqtbi5uREREaF0SUKI3JSQkKnDbwHtgYLASsAivRNUKt3GSCJLJBCIXFWxYkUOHjxIlSpVaN68OaGhoUqXJITILZmYP/QYaAs8AjYDpTNyklYLtrZZqUwggUAooGjRomzfvp3OnTvTvXt3pkyZIhsjCWEO3norQ4fFAx3RNSPaAFTL6PWTkqBKlSyVJmSVgVCIra0tS5cupVy5cnz00UdcvnyZoKAgLC3lP0khTNa778KhQ3onFiajmzx4EFiLbu5AptSrl+XyzJ387SsUo1ar+e677yhXrhwjR44kMjKSkJAQChQooHRpQoic0LKlrjGRHh8C69CNEDwAlrz2/b5pnahSQfny4OKS3SrNlmxuJIzCli1b6NatG5UqVWLDhg2ULp2hJ4ZCiLxEo9F9aEdGpnlIM2C3nkuk+YGlUsHUqeDnl/X6TJhsbiTyjNatW7Nv3z7u3LmDm5sb//yjt2u5ECIvUqth/Hi9h4Sj+9BP61eqVCpwcID+6S5MFHpIIBBG45133iEiIoLChQvj4eHB9u3blS5JCGFow4eDm5uuZ4ChaLUwaxYUKmS4a5ohCQTCqDg7O7N3717c3d1p27YtC2SzEiFMi4UFLFqkWx6oNsBHkFoNPXpAr17Zv5aZk0AgjI6DgwPr169n4MCBDBo0iP/973+yLFEIU1KpEmzZogsFFum2G0qbWg0tWsDvv+seG4hskUAgjJKVlRVz5szhhx9+4P/+7/94//33eS4dyIQwHQ0bwv79UL482syOFLw4fsQIWL9emhEZiAQCYbRUKhUff/wxISEhrFixgtatW/Pw4UOlyxJCGEqtWnDiBBe9vYkDtOn8lK/5NwgklC0LO3fCL7+A9eubJYuskkAgjF7Pnj3Zvn07J0+epGHDhly5ckXpkoQQBqK1saHf9et4u7nplg16eEC+fG8e6OyMpls3OtrZ8b/u3aF589wv1sRJHwKRZ1y4cIG2bdvy5MkT1q9fT4MGDZQuSQiRTdu3b6dly5Zs2rSJNm3a6F7UaODKFYiJ0a1GcHKCIkUACAgIYPHixURFRWErjwoyLCN9CCQQiDzl7t27eHl5cfz4cZYuXUqXLl2ULkkIkQ3NmzfnyZMnHD58GFUGJgaeP3+eKlWqsGjRIvr165cLFZoGaUwkTE7x4sXZsWMHHTp0oGvXrgQGBipdkhAii/bv3094eDiff/55hsIAQOXKlWnZsiUzZ87M4erMjwQCkefky5ePkJAQPvroIwICAvDz8yM5OVnpsoQQmTRx4kSqV6+Ol5dXps4bNWoUERERHDt2LIcqM08SCESepFarmTRpEjNnzmTGjBl4e3vz7NkzpcsSQmTQsWPH2LRpE5999hnqTC477NChAy4uLjJKYGASCESeNnLkSNavX8+OHTto1qwZt27dUrokIUQGTJw4kQoVKtCjR49Mn2tpacnw4cP5448/ZCmyAUkgEHleu3bt2Lt3L9HR0bi5uXHq1CmlSxJC6HHq1ClWrVrFJ598gmUW9zQYPHgwSUlJLFy40LDFmTEJBMIk1K5dm0OHDuHg4ICHhwc7d+5UuiQhRBq+//57nJ2def/997N8DUdHR7p27cqsWbPQaDQGrM58SSAQJsPFxYV9+/bRoEED2rRpw6JFi5QuSQjxmkuXLhEcHMz48eOxzmaXwdGjR3PhwgV27NhhoOrMmwQCYVIcHBzYuHEj77//Pv379+ebb76RjZGEMCI//vgjxYoVY8iQIdm+loeHBzVr1uSXX34xQGVCAoEwOVZWVsydO5eJEyfy9ddfM2DAABISEpQuSwizd/36dRYuXMiHH35IvtTaE2eSSqVi1KhRrF+/nmvXrhmgQvMmgUCYJJVKxWeffcbSpUsJCQmhTZs2PHr0SOmyhDBrP/30EwUKFGDkyJEGu2bfvn2xs7Pj119/Ndg1zZUEAmHSevfuzbZt2zh+/DgeHh5cvXpV6ZKEMEu3b99m7ty5+Pn5YW9vb7DrFihQgP79+zN37lzZIj2bJBAIk9ekSRMOHjxIXFwcbm5uHDlyROmShDA7U6dOxcLCgjFjxhj82iNHjuTOnTusWrXK4Nc2JxIIhFmoUqUKERERuLq60rRpU9atW6d0SUKYjQcPHvDLL78wevRoivy7a6EhVatWjebNm0vnwmySQCDMRokSJdi1axdt2rShc+fOTJ8+XemShDAL06dPJykpiYCAgBy7x6hRo9i3bx8nTpzIsXuYOgkEwqzky5ePFStW8MEHHzB27FgCAgJkYyQhctCTJ08ICgpi6NChlCxZMsfu4+XlRalSpWSUIBskEAizo1ar+emnn5gxYwbTpk2jW7duxMbGKl2WECZp9uzZPH36lHHjxuXofaysrBg2bBhLlizh8ePHOXovUyWBQJit0aNHs3btWrZu3Urz5s25ffu20iUJYVLi4uKYMmUK/fv3x8XFJcfvN2zYMOLj46VLaRZJIBBmrUOHDuzZs4dr167h7u7O2bNnlS5JCJMxb9487t69y8cff5wr9ytdujRdunRh5syZ0qE0CyQQCLNXt25dIiIiyJ8/P+7u7uzevVvpkoTI8xISEvjxxx/x8fGhYsWKuXbfUaNGcfbsWcLDw3PtnqZCAoEQQNmyZdm3bx916tShZcuWLF26VOmShMjTFi9eTFRUFJ9++mmu3rdZs2ZUrVpV9jfIAgkEQvyrUKFCbNq0iT59+tC3b18mTJggw45CZEFSUhI//PAD3t7eVK9ePVfv/WJ/gzVr1hAdHZ2r987rJBAI8RJra2vmz5/Pt99+y5dffsngwYNJTExUuiwh8pTly5dz8eJFPvvsM0Xu369fP2xtbZk7d64i98+rVEC6PwLZ29sTExOTC+UIYTyWLFnCoEGDaNq0KStXrqRgwYJKlySE0dNoNLz99tu4uLiwadMmxeoYOXIka9euJTIyEisrK8XqMBYODg48efJE7zEyQiBEGvr27cvWrVs5cuQIHh4esr2qEBmwdu1aTp06xRdffKFoHSNHjuTmzZusWbNG0TryEhkhECIdZ86coV27dsTHx7Nx40bq1KmjdElCGCWtVkv9+vUpUKCAUczyb9y4MZaWluzatUvpUhQnIwRCGEDVqlWJiIjAxcWFJk2asGHDBqVLEsIobd26laNHjyo+OvDC6NGjCQ8P59SpU0qXkidIIBAiA0qWLEl4eDgtWrTAy8tL+qULkYoJEybQoEEDPD09lS4FAG9vb0qUKMGsWbOULiVPkEAgRAblz5+f0NBQxowZw+jRoxk3bhwajUbpsoQwCnv27GHfvn18/vnnqFQqpcsBdKuGhg4dyqJFi9IdLhcyh0CILAkKCiIgIABvb28WL15Mvnz5lC5JCEW1bt2aW7du8ddff6FWG8/PmtevX8fV1ZUZM2YwcuRIpctRjMwhECKH+Pn5sXr1asLCwnjvvfe4c+eO0iUJoZjDhw+zdetWPvvsM6MKAwAuLi506tRJ9jfIAOP6NydEHuLl5cXu3bu5cuUK7u7unDt3TumShFDExIkTqVy5Mt26dVO6lFSNGjWKf/75h3379ildilGTQCBENtSvX5+IiAhsbGxwd3dn7969SpckRK46efIka9eu5dNPP8XCwkLpclLl6elJ5cqVZX+DdEggECKbXF1d2b9/P++88w4tWrQgODhY6ZKEyDXfffcdZcuWpU+fPkqXkia1Ws3IkSMJDQ3l1q1bSpdjtCQQCGEAhQsXZsuWLfTs2ZPevXvz/fffy/NKYfLOnz/P8uXL+fjjj42+PXD//v2xsrLit99+U7oUoyWBQAgDsba25vfff+err77is88+Y9iwYbIxkjBpP/zwAyVLlmTgwIFKl5KuwoUL06dPH+bMmUNSUpLS5RglCQRCGJBKpeLrr79m4cKFLFy4kA4dOsiSXWGSIiMjWbx4MR999BG2trZKl5MhI0eOJCoqivXr1ytdilGSPgRC5JAdO3bQtWtXypQpQ1hYGM7OzkqXJITBjB49mmXLlhEZGYmdnZ3S5WSYu7s7BQoUYNu2bUqXkqukD4EQCvL09GT//v08fvyYd999l+PHjytdkhAGcfPmTebNm4e/v3+eCgOgCzLbt2+XZcKpkBECIXLYzZs36dixI+fOnWP58uW0bdtW/wn370N4OBw5AmfPwrNnYGsLFSpA3brQtCm4uORK7UKkZty4cfz6669ERkZSqFAhpcvJlPj4eFxcXOjTpw+BgYFKl5NrMjJCIIFAiFzw7NkzfHx8CAsL45dffmH48OFvHnT8OEyZAsuWQWIiWFpCcjK8WK1gZaV7XaWCtm3hgw/ASDaREebj/v37lC1bFj8/PyZOnKh0OVnyySefMHv2bKKjo/PcCEdWySMDIYyEnZ0dq1evZuTIkYwYMYKPP/74v42R4uPh00+hTh0ICdF96AMkJf0XBuC/17Va2LoVWrSAfv3g4cPcfTPCrAUFBaHVavH391e6lCwbMWIEMTEx/PHHH0qXYlRkhECIXKTVagkKCuKDDz6gW7duLJoyBduOHeHkScjKzokWFlCiBOzcCW+9ZfiChXjJ48ePcXV1ZeDAgfz8889Kl5MtHTt2JCoqimPHjhnN7ow5SUYIhDAyKpUKf39/Vq5cyd5167hZpQraf/7JWhgA3SOFO3egUSO4eNGwxQrxmpkzZxIbG8tHH32kdCnZNmrUKI4fP05ERITSpRgNGSEQQiEPmjfHITwcS0NczMICqlWDo0d1cw2EMLBnz57h6upKt27dmDVrltLlZJtGo6FSpUq4u7uzZMkSpcvJcTJCIISxWrGCInrCwHPgY6A0kA94F9C7ajo5Gf75B77/3rB1CvGvuXPn8vDhQ8aPH690KQbxYn+DFStWyPbl/5JAIERu02jgww91qwXSMAD4GegDBAEWQDtA7+atWi1MnAgPHhiuViGA58+fM3nyZPr06UO5cuWULsdgBg4ciFqtZv78+UqXYhQkEAiR27ZsgevXX11B8JI/gRDge2AyMAzYCZQF0v3ZLDERFi40WKlCAPz+++/cvHmTTz/9VOlSDKpo0aL06tWL2bNnk5ycrHQ5ipNAIERuW7xY98w/DSvRjQgMe+k1W2AwcBC4nt71FyzIZoFC/CcpKYkffviBbt268ZYJrmQZNWoUkZGRhIWFKV2K4iQQCJHb9u/XPfNPw19AZcDhtdcb/Pv1uL5ra7Vw+jTExWWnQiFSBAcHc+XKFT7//HOlS8kR9evXp169esycOVPpUhQngUCI3BQTA9eu6T3kJlAqlddfvHYjvXtoNLq+BkJkk0aj4bvvvqNDhw688847SpeTY0aPHs3mzZu5aOZLdyUQCJGb7t9P95A4wCaV121f+n667t3LeE1CpGHVqlWcPXvWZEcHXujZsyeFCxdm9uzZSpeiKAkEQuSmDHREy4du2eHr4l/6fnrOnjvHjRs3/muPLEQmabVaJk6ciKenJ25ubkqXk6Py5cvHoEGDmD9/PnFm/LhNGhMJkZtiYqBgQb2HtASigdOvvb4DaAGsAzqmc5sGwGHA0tISZ2dnXFxcKFOmDC4uLq/8vkyZMhQqVMgsWreKzNm4cSMdOnRg586dNG/eXOlyctylS5eoWLEi8+fPZ+DAgUqXY3Cy26EQxsjVFSIj0/z2OGAq8IBXJxZ+B3wOXAP0bX6sVas5eeAA1+7e5dq1a1y/fp3r16+n/D4qKoqkpKSU4+3s7F4JCK+HBhcXF/Lly8i4hDAVWq0WDw8PVCoV+/btM5vA2LZtW+7du8fhw4eVLsXgMhIIDNI1VQiRCR4eEBWV5kqDbsBPwK/Ai47xz4EF6DoW6g0DKhWqatV4+913eTuNY5KTk7l9+3ZKQHg5NBw/fpz169dz+/btV84pVqyY3tBQqlQpLC3lrxNTER4ezsGDB9m4caPZhAHQLUHs1KkThw8fpn79+kqXk+tkhECI3LZpE7Rrp/eQHsBqIACoCPyOrmHRDqCJnvM0wGZPT2otWkTp0qWzXGJ8fDzR0dGphoZr165x7dq1V37asLCwoHTp0npDQ9GiRc3qwyUv8/T05OHDhxw9etSs/p0lJydToUIFmjVrxkITa/AljwyEMEYaDZQrp7dbYTzwJbAEeAi8Dfwf0DqdSyep1VTIn58b8fH07NmTgIAA6tata8jqUzx+/DjVsPDia1RUFAkJCSnH58uX7435C6+HBjs7uxypVWTcwYMHadiwIStXrqRr165Kl5PrfvjhB77++muio6MpWrSo0uUYjAQCIYzVypXQvbthr6lSwTffEOPnx/z585k2bRpXrlyhcePG+Pv74+XlhYWeDomGptFouHPnzhtB4eXwcOvWLbQvhaIiRYqkGhpefC1dujRWsptjjurQoQOXL1/mn3/+Qa02v4Vod+/exdnZmYkTJ5rENs8vSCAQwph16wZr1ujtWphhFhZQvTocOZKy/XFycjJr164lMDCQvXv34urqytixYxk8eDAODq/3QVRGQkIC0dHRekPDo0ePUo5Xq9WUKlVKb2goXry4WQ1zG9Lx48epXbs2ixcvpm/fvkqXo5h+/fpx4MABLly4YDKhSAKBEMbs4UNo1AjOncteKLC0hEKFICICKlRI9ZCjR48SGBhISEgI+fLlY/DgwYwZM4by5ctn/b655MmTJ6k+knj5tefP/+vcYGNjk+ryypdfs7e3V/AdGa8ePXpw9OhRzp07Z9aTRF88NgkLC6Nt27ZKl2MQEgiEMHZ370KrVvD332nOJ9DLwgJKloSdO6FKlXQPv3HjBr/88guzZ8/m0aNHeHl54e/vT+PGjfPsT9VarZZ79+6lGRauX7/+RpOmggULpjnC4OLigrOzM9bW1gq+q9x35swZqlevzuzZsxk2bFj6J5gwrVZLnTp1cHZ2Zv369UqXYxASCITIC54/h2+/hR9+ALUaXuoRkCZLS91x/fpBUBAULpypW8bGxrJkyRICAwM5c+YMderUISAggB49epjkB2FiYiI3b958IzS8HB7uv9RWWqVSUbJkyTRDQ5kyZShRooTJDCcD9O/fnx07dnDp0iVsbFJrnm1efvvtN4YNG8alS5coV66c0uVkmwQCIfKSv/+GwED44w9ISNB96Ccn/zdyYGUFiYm6yYMdOkBAAGSzg5xWq2Xr1q1MnTqVLVu2UKpUKUaPHs3w4cMpVqxY9t9THvLs2TOioqL0hobY2NiU462srHB2dtYbGgqm05XSWFy+fJnKlSszZcoU/Pz8lC7HKDx79gwnJydGjBjBDz/8oHQ52SaBQIi86MED2L0bjh6FM2cgNhZsbKBiRahbFxo3Bmdng9/29OnTBAUFsWjRIkA3scrf359q1aoZ/F55kVar5cGDB6mGhRdfo6OjSX5pPoi9vb3eCZDOzs7Y2trquWvuGDFiBKtWreLq1avkz59f6XKMhr+/P0uXLuX69etG8e8pOyQQCCEy7d69e/z666/MmDGDmzdv0qpVKwICAmjdunWenWeQW5KTk7l586beCZB379595ZwSJUroDQ2Ojo45ulw0Ojqa8uXL88033/DJJ5/k2H3yonPnzvHWW2+lrLp4kJjI8adPuZ+YiAooYW1NrQIFcMgDEzAlEAghsiwhIYEVK1YwdepUjh49StWqVfHz86Nfv37yU2Q2xMXFERUVpXek4enTpynHW1pa4uTkpDc0FC5cOMthLSAggIULFxIZGWk0y1GNSWNvb65Ur45Fu3Zce57aPqRQ0daWQaVKMbhUKUoY6RwcCQRCiGzTarXs27ePwMBA1qxZQ6FChRg+fDijR4/GyclJ6fJMjlar5fHjx2mGhRddIF/foCqtpZYvvqa2QdXdu3cpW7Ys48aN45tvvsnNt2n0YpOT+fzKFYKuX0er0ehW9OihBtQqFZ+VKcPnZctibWQTTiUQCCEM6sqVK0yfPp3ffvuNuLg4evbsib+/P/Xq1VO6NLOi0WhS3aDq5a+vb1BVtGjRN0LCgQMH2Lp1KxEREVSrVs2sew+87PiTJ3T+5x+uP3+OJv3DX6ECqubPz9oaNahoRCNpEgiEEDkiJibmlfbIjRo1wt/fn86dO+dqe2SRtufPn6e6QdWLr5GRka98QKjV6lQ3qHr5qzlsUHU4Job3/v6buORkstouzAIoZGnJvtq1ectI9ueQQCCEyFHJycmsW7eOwMBA9uzZk9IeedCgQXlmyZ25mjBhAhMmTGDLli3ExsamORHy5Q2qbG1t9T6WcHFxoUCBAgq+q+y58fw51Q8f5klSUpbDwAuWKhUlrKw4Vb8+hYxg/w0JBEKIXHP06FGCgoIICQnB1taWQYMGMWbMGCqk0U5ZKOfp06eULVsWHx8fZsyYkeZxGo2Gu3fv6p0AefPmzVc2qCpcuHCqO1m++Ork5GSUG1RptVranzzJ1gcPUg8DV67A77/D+fO6pcE2NuDqCj17QsOGqV7TAujn6MiCt97KwcozRgKBECLX3bhxg1mzZjFr1iwePHiAl5cXAQEBebo9sqmZMmUKn3zyCZcuXaJMmTLZulZCQgI3btzQGxoePnyYcrxKpUp3g6oSJUrk+n8rq+7epeupU2kfEBEBq1bpNhErWhTi42HvXjhxAj74ADp2TPPUPbVq0bhQIcMXnQkSCIQQiomLi0tpj3z69Glq165NQEAAPXv2NMn2yHlFfHw85cqVo127dsybNy9X7vn06dM0N6h68TU+Pj7leBsbG5ydnfWGBkMvkWx07BgRMTGZe1SQnAzDh+s6i/7b0Ot1lkDnYsVYUaOGIcrMMgkEQgjFabVatm3bRmBgIJs2bcLR0ZHRo0czYsQIs2uPbAxmzpzJmDFjOHv2LJUqVVK6HOC/Dar0hYbUNqhKbSfLF1+dnJwyvCfDmWfPqHb4cNaK/+wzOHtWN3qQBgsgumFDSioYhCUQCCGMypkzZ1LaI2u1Wvr27Yu/vz/Vq1dXujSzkJiYSMWKFfHw8OCPP/5QupxMSUpKSnk0kVZoeHmDKgBHR0e9oaFkyZKo1WpmR0cz6sKF9D8MAeLidCMCT5/CgQMwe7ZuT5EvvtB72qrq1elSvHjW/wFkkwQCIYRRun//fkp75Bs3btCyZcuU9simtIOgsVmwYAGDBg3i5MmT1FB4CDsnvFgtoS80pLZBVdzo0dyuVQttRpbM/vwzvNgSWa3W7S3y4Ydgb5/mKZYqFR+7uDChfPnsvsUsk0AghDBqiYmJKe2Rjxw5wltvvYWfnx/vv/++tEc2sOTkZKpWrUr16tVZvXq10uUoQqvV8vDhwzf2l1jw9tvcKV06Yxe5dg3u3oV79yA8XLcLqb8/FCmS5ikWQPcSJQhWcKMwCQRCiDxBq9Vy4MABpk6dyurVqylUqBDDhg3D19dX2iMbyLJly+jVqxeHDx+WzpKvaXjsGAez+hk3bpzu8cHMmbqtyVOhAryLFWOlgqMyGQkEMjYnhFCcSqXCw8ODlStXcunSJQYMGMDMmTNxdXWld+/eHM7qhC8B6PoJTJw4kVatWkkYSEWB7HTXbNJEN6nw+vU0D1ED+fNAB08JBEIIo+Lq6sqUKVOIiopiypQpHDp0iAYNGqQEhpc39REZs2HDBk6ePMkX6Ux8M1fV7eywymrfgxc7ID57pvewanngEZgEAiGEUbK3t2fs2LGcP3+eNWvWYGVlRffu3alYsSJTpkzh8ePHSpeYJ2i1WiZMmEDjxo1p3Lix0uUYnadPn6I5c4ZEbTpPz19qrpQiKQm2bv2va2EakoG6eiYdGguZQyCEyDOOHTtGUFAQwcHB2NjYMHDgQPz8/KQ9sh7btm2jVatWbNmyhVatWildjlF49OgR69evZ9WqVWzevJn4fPlgxQr9Wxx/+aVuFOCdd6BYMV374u3bdZMMR46EHj3SPLWAhQW3GjbETsHHBjKpUAhhkm7evJnSHvn+/ft06tQJf39/mjZtKu2RX9OsWTOePXvGn3/+adb/bO7evcvatWsJDQ1lx44dJCYm4ubmRteuXfH29uazuDhC790jKa2Rgp07ISwMLl+GmBjInx8qV4YuXcDDI837WqpUjC5dmkCFm0BJIBBCmLS4uDiWLl1KYGAgp06dolatWintkTPapc6U7du3j8aNG7N69Wo6d+6sdDm5Ljo6mtWrVxMaGsqePXsAaNKkCV27dqVz5844OzunHHv0yRPqHz2aseZEmWClUnGmQQMq5Mtn4CtnjgQCIYRZ0Gq1bN++ncDAQMLCwnB0dGTUqFGMGDGC4gp2h1Na27ZtiYqK4u+//zabhk+XL19m1apVhIaGEhERgZWVFZ6ennTt2pVOnTpRokSJNM8df+kSU65fR5PmEZk3uXx5PsrmBlKGIIFACGF2zp49S1BQEL///jsajSalPbIpdubT5+jRo9SrV48//vgDHx8fpcvJUWfOnCE0NJTQ0FCOHz+Ora0tbdq0oWvXrnTo0IFCGdxpMC45Gbdjxzj17FnmNjlKhQXQqGBBdtSqhYURPKqRQCCEMFsPHjxIaY8cHR1NixYtCAgIoE2bNmbx07K3tzcnT57k7NmzWOSBNfCZodVq+euvv1JGAs6ePUuBAgXo0KED3t7etG3blgIFCmTp2ncTEmh2/DjnYmOzHArUQAMHB7a+/Tb2lpZZvIphSSAQQpi9xMREVq5cydSpUzl8+DBVqlRJaY9sZ2endHk54tSpU9SoUYN58+YxaNAgpcsxCI1Gw6FDhwgNDWXVqlVcuXKFwoUL4+Xlhbe3Ny1btsTW1tYg93qUmMiI8+dZdvduxj4k/6UGNMCwUqWYWrGiUTUjkkAghBD/0mq1HDx4kKlTp7Jq1SoKFiyY0h755cllpqBPnz7s3buXixcvYq3glrvZlZSUxN69ewkNDWX16tXcuHGDkiVL0qVLF7y9vWnWrBlWVlY5dv9Vd+8y7tIlLsfHYwmk1RLLUqUiSaulev78BFasSAs9+xooRQKBEEKk4urVq8yYMYO5c+fy7NkzunfvTkBAAA0aNFC6tGy7ePEiVapUYdq0aYwePVrpcjLt+fPn7Ny5k9DQUNauXcu9e/dwcXFJWR7YsGHDXH0EotVq2fnoEUtv3+bA48dciItLmXRoAVS1s8PDwYH3HR1xd3Aw2qWdEgiEEEKPJ0+esHDhQoKCgrh06RINGzbE39+fLl26YGkkz34za+jQoaxfv54rV66QT+GlbhkVGxvLli1bCA0NZf369cTExFCxYkW6du1K165dqVevntF80MYnJ/M4ORk14GBpiU0emY8igUAIITIgOTmZDRs2EBgYSHh4OGXKlGHMmDEMGTIkwzPUjcH169epUKECEydOZNy4cUqXo1dMTAwbN24kNDSUTZs2ERsbS82aNfH29qZr167UqFHDaEKAKZBAIIQQmfTXX38RFBTEH3/8gbW1NYMGDWLs2LFUrFhR6dLSNXbsWJYuXcrVq1exN8Le+ffv32fdunWEhoaybds2EhISqFevXsrjgMqVKytdosmSQCCEEFl069YtZs6cmdIeuWPHjvj7+9OsWTOj/Mn19u3buLq68umnn/K///1P6XJS3Lx5kzVr1hAaGkp4eDgajYZGjRrh7e2Nt7c3ZYygaY85kEAghBDZFB8fn9Ie+Z9//qFWrVr4+/vTq1cvo2qP/PHHHzNr1iwiIyMpXLiworVERkam9Ag4cOAAarWa5s2bp7QMdnR0VLQ+cySBQAghDESr1bJjxw6mTp1KWFgYJUuWTGmPrK8dbm548OABZcuWxdfXl++//16RGs6fP5/SLfDo0aNYW1vTqlWrlJbBRYxwKZ45kUAghBA54Ny5cyntkZOTk+nTpw/+/v7UrFnTsDfSauHQIdi7F44e1e20l5gIDg66bXjr1oW2bfl65kwmTZrE1atXcy2caLVaTp48mRICTp06Rf78+WnXrh1du3alXbt2ODg45EotIn0SCIQQIgc9ePCAuXPnMn36dKKjo/H09CQgIIC2bdtmrz1yUhLMnw9Tp8LZs6BWg0oFyS8107WygsREtBYWrFSrudK9O+OXLs3+m9JDq9Vy+PDhlG6BFy9epGDBgnTs2JGuXbvSqlUr8ufPn6M1iKyRQCCEELkgMTGR0NBQpk6dyp9//knlypXx8/Ojf//+mW+PfOYM9OunGxFQqXSjBOndH7BUq1F9/jl88QUYsDthcnIy+/fvTwkBUVFRFCtWjM6dO9O1a1fee++9PN0N0VxIIBBCiFyk1WqJiIhg6tSphIaG4uDgkNIe2cXFJf0LhIVBly6g0ehGCTJLpQI3N911stE/ITExkV27dhEaGsqaNWu4c+cOpUuXTukR0KhRozzbuMlcSSAQQgiFREZGprRHfvr0Kd26dSMgIIB333039RO2bYN27XSPBTIwKpAmCwvd3IKdOyEToxNxcXFs27aN0NBQ1q1bx6NHjyhXrlxKt8AGDRqYxS6RpkoCgRBCKOzJkyf8/vvvBAUFcfHiRdzd3fH398fb2/u/n7Jv34a33oLHj7MXBl5Qq2HECPjlF72HPX36lLCwMEJDQ9m4cSPPnj2jatWqKY2CatWqZZQ9F0TmSSAQQggjkZyczMaNGwkMDGTXrl2vtkceOBDWr3910uBLngKTgUPAn8BDYAEwIL2b7toFzZq98tLDhw9Zv349oaGhbNmyhefPn1O7du2UEFC1atXsvVFhlCQQCCGEETp+/HhKe+QGajV74+P1Hn8VKAeUAcoD4WQgEKjV0KABHDzInTt3UroF7ty5k6SkJNzd3enatStdunShfPnyhnhbwohJIBBCCCN269YtbrRtS83jx7HSc9xzdKMCjsARoD4ZHCEABtWpw+/HjwPQtGlTvL296dKlC05OTtmqXeQtGQkEMk1UCCEU4li8OI7nzqV7nA26MJBZiUCbR49oOGcOXl5eFC9ePAtXEeZCAoEQQijl7FmIi8uxy1sCPcqUgSFDcuwewnTIGhIhhFDKX3/l6OVVAMeO5eg9hOmQQCCEEEp5+FA3+S8nPXlimKWMwuRJIBBCCKXkxhp/6SMgMkgCgRBCKKVECV2b4pxUuLCEApEhEgiEEEIpderk7PVVKl0vAiEyQAKBEEIopUKFbG1ClC61WrfZkRAZIMsOhRBCKSoVDBoEQUFpti1+YQbwCLjx75/XA1H//n4MUDC1kzQa3VbKQmSAdCoUQgglXbgAlSune5grEJnG9678+/1XWFhAy5awaVN2qhMmIiOdCuWRgRBCKKlSJRg5Mt3lh1fR/fSW2i/X1E5QqWDSJENWKkycBAIhhFDapEng5KT7qd4QVCr4+muoWdMw1xNmQQKBEEIorUAB2LAB7OyyHwpUKvD2hk8+MUxtwmxIIBBCCGPw9tuwe7eub0BWQsGLXgO9e0NwsOFGG4TZkEAghBDGolYt3YZH3bvr/myZwYVgFhZgbw+LF+t+WenbTFmI1EkgEEIIY1K0qO4n/F27oGPH/yYbWlrqfllY6D7wX4wIlCgB//sfnD8PfftKV0KRZbLsUAghjNmdOxARAUeOwLVrkJSkm3NQsybUrav7JSMCIh0ZWXYogUAIIYQwcdKHQAghhBAZIoFACCGEEBIIhBBCCCGBQAghhBBIIBBCCCEEEgiEEEIIgQQCIYQQQiCBQAghhBBIIBBCCCEEEgiEEEIIgQQCIYQQQiCBQAghhBBIIBBCCCEEEgiEEEIIgQQCIYQQQiCBQAghhBBIIBBCCCEEEgiEEEIIQQYDgb29fU7XIYQQQogckpHPcRWgzcjFSpcuzZMnT7JbkxBCCCFykb29PTdu3Ej3uAwHAiGEEEKYLplDIIQQQggJBEIIIYSQQCCEEEIIJBAIIYQQAgkEQgghhEACgRBCCCGQQCCEEEII4P8BfOVaRtPvIAIAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -614,13 +633,13 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 47, "id": "22db40be", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -657,7 +676,7 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 48, "id": "d2cf1b57", "metadata": {}, "outputs": [ @@ -666,12 +685,12 @@ "output_type": "stream", "text": [ "Circuit #1\n", - "cost: -17.294533 \n", - "bit strings: ['00010101']\n", + "cost: -17.480106 \n", + "bit strings: ['00010101', '11101010']\n", "\n", "Circuit #2\n", - "cost: -15.386024 \n", - "bit strings: ['00110101']\n" + "cost: -17.480623 \n", + "bit strings: ['00010101']\n" ] } ], @@ -705,7 +724,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 49, "id": "492d215f", "metadata": {}, "outputs": [ From 02b782444b5710bd5563aa07e374862dad71fc7b Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Sat, 13 May 2023 14:58:54 +0800 Subject: [PATCH 446/725] Update qaoa.ipynb change the vertical axis of two cost figure from "loss" to "cost" --- docs/source/tutorials/qaoa.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorials/qaoa.ipynb b/docs/source/tutorials/qaoa.ipynb index cff5aeeb..70106198 100644 --- a/docs/source/tutorials/qaoa.ipynb +++ b/docs/source/tutorials/qaoa.ipynb @@ -352,7 +352,7 @@ " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", " plt.xlabel(\"Iteration\")\n", - " plt.ylabel(\"Loss\")\n", + " plt.ylabel(\"Cost\")\n", " plt.plot(range(i+1), list_of_loss[0])\n", " plt.plot(range(i+1), list_of_loss[1])\n", " plt.legend([\"circuit 1\", \"circuit 2\"])\n", @@ -667,7 +667,7 @@ " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", " plt.xlabel(\"Iteration\")\n", - " plt.ylabel(\"Loss\")\n", + " plt.ylabel(\"Cost\")\n", " plt.plot(range(i+1), list_of_loss[0])\n", " plt.plot(range(i+1), list_of_loss[1])\n", " plt.legend([\"circuit 1\", \"circuit 2\"])\n", From 40b286fda21f621a88b2d45795626f037b82e068 Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Sun, 14 May 2023 23:51:13 +0800 Subject: [PATCH 447/725] Update qaoa.ipynb resolved all conversions --- docs/source/tutorials/qaoa.ipynb | 218 +++++++++++++++---------------- 1 file changed, 108 insertions(+), 110 deletions(-) diff --git a/docs/source/tutorials/qaoa.ipynb b/docs/source/tutorials/qaoa.ipynb index 70106198..ff664650 100644 --- a/docs/source/tutorials/qaoa.ipynb +++ b/docs/source/tutorials/qaoa.ipynb @@ -81,21 +81,15 @@ "source": [ "A cost (objective) function of the $\\alpha$-th edge (which connects $j$-th and $k$-th nodes) is defined\n", "\n", - "$$\n", - "C_\\alpha=\\frac12(1-\\sigma_z^j\\sigma_z^k)\n", - "$$\n", + "$$C_\\alpha=\\frac12(1-\\sigma_z^j\\sigma_z^k)$$\n", "\n", "When $C_\\alpha = 1$, the $\\alpha$-th is accounted a cut edge. It will happen if and only if $j$-th and $k$-th nodes are in different set. The total number of edge cut is written as\n", "\n", - "$$\n", - "C(z)=\\sum_\\alpha^mC_\\alpha(z)\n", - "$$\n", + "$$ C(z)=\\sum_\\alpha^mC_\\alpha(z)$$\n", "\n", "where $z = z_1z_2 . . . z_n$ is the bit string. Max-Cut asks for a string $z$ for which $C(z)$ is maximized. This problem is equivlant to finding the ground state of a cost Hamiltonian\n", "\n", - "$$\n", - "H_C = \\frac{1}{2} \\sum_{i,j} \\sigma^{j}_{z} \\sigma^{k}_{z}\n", - "$$" + "$$H_C = \\frac{1}{2} \\sum_{i,j} \\sigma^{j}_{z} \\sigma^{k}_{z}$$" ] }, { @@ -115,15 +109,11 @@ "source": [ "The Quantum Approximate Optimization Algorithm (QAOA) utilizes a parameterized quantum circuit ([PQC](https://tensorcircuit.readthedocs.io/en/latest/textbook/chap5.html?highlight=变分)) to generate a quantum state that represents a potential solution to the Max Cut problem. The initial state, denoted as $|s\\rangle$, is a uniform superposition over computational basis states.\n", "\n", - "$$\n", - "|s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle\n", - "$$\n", + "$$|s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle$$\n", "\n", "This state is then evolved by a unitary operator that consists of $q$ layers, denoted as\n", "\n", - "$$\n", - "U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", - "$$\n", + "$$U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},$$\n", "\n", "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ and $V_{j}= e^{-i \\beta_{j} H_m}$. $H_C$ is the cost Hamiltonian introduced in previous section and the mixer Hamiltonian $H_m=\\sum_j\\sigma^j_x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1\\gamma_2 \\dots\\gamma_p=\\gamma$ and $\\beta_1\\beta_2 \\dots \\beta_p=\\beta$. It is worth noting that $\\gamma$ is restricted to lie between $0$ and $2\\pi$, and $\\beta$ is restricted to lie between $0$ and $\\pi$ due to the integer eigenvalues of $H_C$.\n", "\n", @@ -159,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 89, "id": "b0def04d", "metadata": {}, "outputs": [], @@ -175,7 +165,7 @@ "K = tc.set_backend(\"tensorflow\")\n", "\n", "nlayers = 3 # the number of layers\n", - "ncircuits = 2 # two circuits with different initial parameters are going to be optimized at the same time\n", + "ncircuits = 6 # two circuits with different initial parameters are going to be optimized at the same time\n", "nnodes = 8 # the number of nodes" ] }, @@ -199,13 +189,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 90, "id": "f1532831", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -249,12 +239,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 91, "id": "055d1257", "metadata": {}, "outputs": [], "source": [ - "def QAOAansatz(params, g=example_graph, circuit=False):\n", + "def QAOAansatz(params, g=example_graph, return_circuit=False):\n", " n = len(g.nodes) # the number of nodes\n", " c = tc.Circuit(n)\n", " for i in range(n):\n", @@ -275,7 +265,7 @@ " c.rx(i, theta=params[2 * j + 1])\n", " \n", " # whether to return the circuit\n", - " if circuit == True:\n", + " if return_circuit is True:\n", " return c\n", "\n", " # calculate the loss function\n", @@ -301,31 +291,31 @@ "id": "6d07ee61", "metadata": {}, "source": [ - "Here, two circuite with different initial parameters are optimized/trained at the same time.\n", + "Here, several circuits with different initial parameters are optimized/trained at the same time.\n", "\n", "Optimizers are used to find the minimum value." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 92, "id": "b8d63c5d", "metadata": {}, "outputs": [], "source": [ "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0))" + "QAOA_vvag = K.jit(tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2))" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 93, "id": "c51b17a7", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -338,9 +328,7 @@ "params = K.implicit_randn(\n", " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", ") # initial parameters\n", - "# for M1/M2 chips, legacy.Adam is recommanded\n", - "# for other CPUs, please use tf.keras.optimizers.Adam\n", - "opt = K.optimizer(tf.keras.optimizers.legacy.Adam(1e-2))\n", + "opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", "\n", "list_of_loss = [[] for i in range(ncircuits)]\n", "\n", @@ -352,10 +340,11 @@ " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", " plt.xlabel(\"Iteration\")\n", - " plt.ylabel(\"Cost\")\n", - " plt.plot(range(i+1), list_of_loss[0])\n", - " plt.plot(range(i+1), list_of_loss[1])\n", - " plt.legend([\"circuit 1\", \"circuit 2\"])\n", + " plt.ylabel(\"Loss\")\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i+1), list_of_loss[index])\n", + " legend = ['circuit %d' %leg for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", " plt.show()" ] }, @@ -379,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 94, "id": "843c0ad3", "metadata": {}, "outputs": [ @@ -387,42 +376,47 @@ "name": "stdout", "output_type": "stream", "text": [ + "Circuit #0\n", + "cost: -6.0114803 \n", + "bit strings: ['01010101', '10101010'] \n", + "\n", "Circuit #1\n", - "cost: -5.6885176 \n", - "bit strings: ['01010101', '10101010']\n", + "cost: -6.0112667 \n", + "bit strings: ['01010101', '10101010'] \n", "\n", "Circuit #2\n", - "cost: -6.0111885 \n", - "bit strings: ['01010101', '10101010']\n" + "cost: -5.96354 \n", + "bit strings: ['01010101', '10101010'] \n", + "\n", + "Circuit #3\n", + "cost: -6.011477 \n", + "bit strings: ['01010101', '10101010'] \n", + "\n", + "Circuit #4\n", + "cost: -4.913675 \n", + "bit strings: ['01010101', '10101010'] \n", + "\n", + "Circuit #5\n", + "cost: -6.011479 \n", + "bit strings: ['01010101', '10101010'] \n", + "\n" ] } ], "source": [ - "## circuit 1\n", - "c = QAOAansatz(params=params[0], g=example_graph, circuit=True)\n", - "loss = QAOAansatz(params=params[0], g=example_graph)\n", - "\n", - "# find the states with max probabilities\n", - "probs = K.numpy(c.probability())\n", - "index = np.where(probs==max(probs))[0]\n", - "states = []\n", - "for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - "print(\"Circuit #1\")\n", - "print('cost:', K.numpy(loss), '\\nbit strings:', states)\n", - "\n", - "## circuit 2\n", - "c = QAOAansatz(params=params[1], g=example_graph, circuit=True)\n", - "loss = QAOAansatz(params=params[1], g=example_graph)\n", + "# print all results\n", + "for num_circuit in range(ncircuits):\n", + " c = QAOAansatz(params=params[num_circuit], g=example_graph, return_circuit=True)\n", + " loss = QAOAansatz(params=params[num_circuit], g=example_graph)\n", "\n", - "# find the states with max probabilities\n", - "probs = K.numpy(c.probability())\n", - "index = np.where(probs==max(probs))[0]\n", - "states = []\n", - "for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - "print(\"\\nCircuit #2\")\n", - "print('cost:', K.numpy(loss), '\\nbit strings:', states)" + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability()).round(decimals=4)\n", + " index = np.where(probs==max(probs))[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " print(\"Circuit #%d\" %num_circuit)\n", + " print('cost:', K.numpy(loss), '\\nbit strings:', states, \"\\n\")" ] }, { @@ -438,13 +432,13 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 95, "id": "fb183e97", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -480,7 +474,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 96, "id": "2115bb6d", "metadata": {}, "outputs": [ @@ -549,7 +543,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 97, "id": "b0a1f778", "metadata": {}, "outputs": [], @@ -579,7 +573,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 98, "id": "f9f5ce41", "metadata": {}, "outputs": [ @@ -599,13 +593,13 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 99, "id": "35dea0fb", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -633,13 +627,13 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 100, "id": "22db40be", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -649,13 +643,11 @@ } ], "source": [ - "QAOA_vvag = K.jit(tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0))\n", + "QAOA_vvag = K.jit(tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2))\n", "params = K.implicit_randn(\n", " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", ") # initial parameters\n", - "# for M1/M2 chips, legacy.Adam is recommanded\n", - "# for other CPUs, please use tf.keras.optimizers.Adam\n", - "opt = K.optimizer(tf.keras.optimizers.legacy.Adam(1e-2))\n", + "opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", "\n", "list_of_loss = [[] for i in range(ncircuits)]\n", "\n", @@ -667,16 +659,17 @@ " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", " plt.xlabel(\"Iteration\")\n", - " plt.ylabel(\"Cost\")\n", - " plt.plot(range(i+1), list_of_loss[0])\n", - " plt.plot(range(i+1), list_of_loss[1])\n", - " plt.legend([\"circuit 1\", \"circuit 2\"])\n", + " plt.ylabel(\"Loss\")\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i+1), list_of_loss[index])\n", + " legend = ['circuit %d' %leg for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", " plt.show()" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 101, "id": "d2cf1b57", "metadata": {}, "outputs": [ @@ -684,47 +677,52 @@ "name": "stdout", "output_type": "stream", "text": [ + "Circuit #0\n", + "cost: -17.48183 \n", + "bit strings: ['00010101', '11101010'] \n", + "\n", "Circuit #1\n", - "cost: -17.480106 \n", - "bit strings: ['00010101', '11101010']\n", + "cost: -17.487226 \n", + "bit strings: ['00010101', '11101010'] \n", "\n", "Circuit #2\n", - "cost: -17.480623 \n", - "bit strings: ['00010101']\n" + "cost: -17.374956 \n", + "bit strings: ['00110101', '11001010'] \n", + "\n", + "Circuit #3\n", + "cost: -17.486227 \n", + "bit strings: ['00010101', '11101010'] \n", + "\n", + "Circuit #4\n", + "cost: -17.480951 \n", + "bit strings: ['00010101', '11101010'] \n", + "\n", + "Circuit #5\n", + "cost: -17.452002 \n", + "bit strings: ['00010101', '11101010'] \n", + "\n" ] } ], "source": [ - "## circuit 1\n", - "c = QAOAansatz(params=params[0], g=weighted_graph, circuit=True)\n", - "loss = QAOAansatz(params=params[0], g=weighted_graph)\n", - "\n", - "# find the states with max probabilities\n", - "probs = K.numpy(c.probability())\n", - "index = np.where(probs==max(probs))[0]\n", - "states = []\n", - "for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - "print(\"Circuit #1\")\n", - "print('cost:', K.numpy(loss), '\\nbit strings:', states)\n", - "\n", - "## circuit 2\n", - "c = QAOAansatz(params=params[1], g=weighted_graph, circuit=True)\n", - "loss = QAOAansatz(params=params[1], g=weighted_graph)\n", + "# print all results\n", + "for num_circuit in range(ncircuits):\n", + " c = QAOAansatz(params=params[num_circuit], g=weighted_graph, return_circuit=True)\n", + " loss = QAOAansatz(params=params[num_circuit], g=weighted_graph)\n", "\n", - "# find the states with max probabilities\n", - "probs = K.numpy(c.probability())\n", - "index = np.where(probs==max(probs))[0]\n", - "states = []\n", - "for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - "print(\"\\nCircuit #2\")\n", - "print('cost:', K.numpy(loss), '\\nbit strings:', states)" + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability()).round(decimals=4)\n", + " index = np.where(probs==max(probs))[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " print(\"Circuit #%d\" %num_circuit)\n", + " print('cost:', K.numpy(loss), '\\nbit strings:', states, \"\\n\")" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 102, "id": "492d215f", "metadata": {}, "outputs": [ From 408e973ba1899dac45c3c25b91efc1c23a2c5851 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 15 May 2023 11:12:04 +0800 Subject: [PATCH 448/725] version0.9.1 --- CHANGELOG.md | 2 ++ tensorcircuit/__init__.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index f671e2a2..d922b381 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.9.1 + ### Added - Add `tc.TorchHardwarLayer` for shortcut layer construction of quantum hardware experiments diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 2cfc536f..558439de 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.9.0" +__version__ = "0.9.1" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From d540d7fef8637feb24c592a1f0e91c896e0e4dce Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Mon, 15 May 2023 23:11:00 +0800 Subject: [PATCH 449/725] enrich this tutorial checked with HTML format --- docs/source/tutorials/qaoa.ipynb | 102 +++++++++++++++++-------------- 1 file changed, 56 insertions(+), 46 deletions(-) diff --git a/docs/source/tutorials/qaoa.ipynb b/docs/source/tutorials/qaoa.ipynb index ff664650..5b9f2d7c 100644 --- a/docs/source/tutorials/qaoa.ipynb +++ b/docs/source/tutorials/qaoa.ipynb @@ -55,11 +55,11 @@ "id": "10c267f3", "metadata": {}, "source": [ - "As illustrated in the graph on the left below, a graph consists of nodes (or vertices) represented by grey circles, and edges, which are black lines that connect the nodes. Max-Cut problem is to find the maximum number of cut when nodes are divided into two set. \n", + "As illustrated in the graph on the left below, a graph consists of 4 nodes (or vertices) represented by grey circles, and 4 edges, which are black lines that connect the nodes. Max-Cut problem is to find the maximum number of cut when nodes are divided into two set. \n", "\n", "For instance, in the right graph, nodes 0 and 1 are in set 0 (light blue), and nodes 2 and 3 are in set 1 (red). If we partition the nodes between these two sets, it will cut two edges (colored pink). Therefore, the number of cut edges in this case is 2. Basically, to find the maximum cut, we need to find the maximum number of edges where the corresponding nodes belong to different sets.\n", "\n", - "If we write down the set numbers that follow the node sequence, we can represent this instance as a bit string \"0011\". Since switching the names of the sets doesn't influence the results, the bit string \"1100\" gives the same number of edge cut. In general, we can use a binary string of length $n$ to represent a partition of $n$ nodes into two disjoint sets. This representation is commonly used in graph theory and combinatorial optimization, and it enables us to apply various computational techniques, including classical and quantum algorithms, to solve problems such as Max-Cut.\n", + "If we write down the set numbers that follow the node sequence (from 0 to 3), we can represent this instance as a bit string \"0011\". Since switching the names of the sets doesn't influence the results, the bit string \"1100\" gives the same number of edge cut. In general, we can use a binary string of length $n$ to represent a partition of $n$ nodes into two disjoint sets. This representation is commonly used in graph theory and combinatorial optimization, and it enables us to apply various computational techniques, including classical and quantum algorithms, to solve problems such as Max-Cut.\n", "\n", "![network1.png](attachment:16c7f2fb-b981-4798-8346-da54e3bcbaeb.png)" ] @@ -70,7 +70,7 @@ "id": "2908c43d", "metadata": {}, "source": [ - "The Max-Cut problem is a NP-complete problem. Classically, one way to approach this problem is to test every possible bit string, which takes an exponential amount of time as the number of nodes, denoted by $n$, grows. Specifically, for $n$ nodes, there are $2^n$ combinations to test. However, recent advancements in quantum computing offer a more efficient way to solve this problem, where $n$ qubits are used to represent $n$ nodes. Nodes are divided according to the energy level of the qubits." + "The Max-Cut problem is a NP-complete problem. Classically, one way to approach this problem is to brutally test every possible bit string, which takes an exponential amount of time as the number of nodes, denoted by $n$, grows. Specifically, for $n$ nodes, there are $2^n$ combinations to test. However, QAOA offers a more efficient way to solve this problem, where $n$ qubits are used to represent $n$ nodes. Nodes are divided according to the energy level of the qubits." ] }, { @@ -81,15 +81,21 @@ "source": [ "A cost (objective) function of the $\\alpha$-th edge (which connects $j$-th and $k$-th nodes) is defined\n", "\n", - "$$C_\\alpha=\\frac12(1-\\sigma_z^j\\sigma_z^k)$$\n", + "$$\n", + "C_\\alpha=\\frac12(1-\\sigma_z^j\\sigma_z^k)\n", + "$$\n", "\n", "When $C_\\alpha = 1$, the $\\alpha$-th is accounted a cut edge. It will happen if and only if $j$-th and $k$-th nodes are in different set. The total number of edge cut is written as\n", "\n", - "$$ C(z)=\\sum_\\alpha^mC_\\alpha(z)$$\n", + "$$ \n", + "C(z)=\\sum_\\alpha^mC_\\alpha(z)\n", + "$$\n", "\n", "where $z = z_1z_2 . . . z_n$ is the bit string. Max-Cut asks for a string $z$ for which $C(z)$ is maximized. This problem is equivlant to finding the ground state of a cost Hamiltonian\n", "\n", - "$$H_C = \\frac{1}{2} \\sum_{i,j} \\sigma^{j}_{z} \\sigma^{k}_{z}$$" + "$$\n", + "H_C = \\frac{1}{2} \\sum_{i,j} \\sigma^{j}_{z} \\sigma^{k}_{z}\n", + "$$" ] }, { @@ -109,17 +115,21 @@ "source": [ "The Quantum Approximate Optimization Algorithm (QAOA) utilizes a parameterized quantum circuit ([PQC](https://tensorcircuit.readthedocs.io/en/latest/textbook/chap5.html?highlight=变分)) to generate a quantum state that represents a potential solution to the Max Cut problem. The initial state, denoted as $|s\\rangle$, is a uniform superposition over computational basis states.\n", "\n", - "$$|s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle$$\n", + "$$\n", + "|s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle\n", + "$$\n", "\n", "This state is then evolved by a unitary operator that consists of $q$ layers, denoted as\n", "\n", - "$$U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},$$\n", + "$$\n", + "U(\\vec{\\beta}, \\vec{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", + "$$\n", "\n", - "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ and $V_{j}= e^{-i \\beta_{j} H_m}$. $H_C$ is the cost Hamiltonian introduced in previous section and the mixer Hamiltonian $H_m=\\sum_j\\sigma^j_x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1\\gamma_2 \\dots\\gamma_p=\\gamma$ and $\\beta_1\\beta_2 \\dots \\beta_p=\\beta$. It is worth noting that $\\gamma$ is restricted to lie between $0$ and $2\\pi$, and $\\beta$ is restricted to lie between $0$ and $\\pi$ due to the integer eigenvalues of $H_C$.\n", + "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ and $V_{j}= e^{-i \\beta_{j} H_m}$. $H_C$ is the cost Hamiltonian introduced in previous section and the mixer Hamiltonian $H_m=\\sum_j\\sigma^j_x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$. It is worth noting that every $\\gamma$ is restricted to lie between $0$ and $2\\pi$, and every $\\beta$ is restricted to lie between $0$ and $\\pi$ due to the integer eigenvalues of $H_C$.\n", "\n", "It is important and also tricky to find a proper $p$. As introduced by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028), $p$ should be equal to the maximum steps between any pair of nodes. For example, in the graph above, the max steps are found between node 3 and node 1 or 0, and this number is 2. Therefore, a 2-layer PQC should be used.\n", "\n", - "Begin with a set of initial parameters, the quantum state is calculate using the PQC and then the expected value of the cost Hamiltonian is calculated. A classical optimizer is then used to vary the parameters until a lower exptected value is found. This process is iterated a certain number of times, and the lowest expected value is approximated as the ground state energy of the cost Hamiltonian. By using the parameters that correspond to the lowest expected value, an approximate solution to the Max-Cut problem can be obtained.\n", + "Begin with a set of initial parameters, the quantum state is obtained from the PQC and then the expected value of the cost Hamiltonian is calculated. A classical optimizer is then used to vary the parameters until a lower exptected value is found. This process is iterated a certain number of times, and the lowest expected value is approximated as the ground state energy of the cost Hamiltonian. By using the parameters that correspond to the lowest expected value, an approximate solution to the Max-Cut problem can be obtained.\n", "\n", "In summary, a general QAOA algorithm follows these steps:\n", "\n", @@ -149,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 103, "id": "b0def04d", "metadata": {}, "outputs": [], @@ -165,7 +175,7 @@ "K = tc.set_backend(\"tensorflow\")\n", "\n", "nlayers = 3 # the number of layers\n", - "ncircuits = 6 # two circuits with different initial parameters are going to be optimized at the same time\n", + "ncircuits = 6 # six circuits with different initial parameters are going to be optimized at the same time\n", "nnodes = 8 # the number of nodes" ] }, @@ -189,13 +199,13 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 104, "id": "f1532831", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -239,7 +249,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 105, "id": "055d1257", "metadata": {}, "outputs": [], @@ -298,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 106, "id": "b8d63c5d", "metadata": {}, "outputs": [], @@ -309,13 +319,13 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 107, "id": "c51b17a7", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -340,7 +350,7 @@ " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", " plt.xlabel(\"Iteration\")\n", - " plt.ylabel(\"Loss\")\n", + " plt.ylabel(\"Cost\")\n", " for index in range(ncircuits):\n", " plt.plot(range(i+1), list_of_loss[index])\n", " legend = ['circuit %d' %leg for leg in range(ncircuits)]\n", @@ -368,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 108, "id": "843c0ad3", "metadata": {}, "outputs": [ @@ -377,27 +387,27 @@ "output_type": "stream", "text": [ "Circuit #0\n", - "cost: -6.0114803 \n", + "cost: -6.011465 \n", "bit strings: ['01010101', '10101010'] \n", "\n", "Circuit #1\n", - "cost: -6.0112667 \n", + "cost: -6.0114813 \n", "bit strings: ['01010101', '10101010'] \n", "\n", "Circuit #2\n", - "cost: -5.96354 \n", + "cost: -6.0113897 \n", "bit strings: ['01010101', '10101010'] \n", "\n", "Circuit #3\n", - "cost: -6.011477 \n", + "cost: -6.001644 \n", "bit strings: ['01010101', '10101010'] \n", "\n", "Circuit #4\n", - "cost: -4.913675 \n", + "cost: -6.011491 \n", "bit strings: ['01010101', '10101010'] \n", "\n", "Circuit #5\n", - "cost: -6.011479 \n", + "cost: -5.1607475 \n", "bit strings: ['01010101', '10101010'] \n", "\n" ] @@ -432,13 +442,13 @@ }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 109, "id": "fb183e97", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABqNklEQVR4nO3dd3xN9x/H8dfNtBK7ghaxN4mVoITaQuytWm1paakOo0a1irZU1ShVW6lV97o39t4xktib2HtFkMg6vz9u9aea3Kx777k39/N8PPLAved+zzuquZ/7nRpAQQghhBAOy0ntAEIIIYRQlxQDQgghhIOTYkAIIYRwcFIMCCGEEA5OigEhhBDCwUkxIIQQQjg4KQaEEEIIB+eS2gsLFSpEVFSUJbMIIYQQwsw8PDy4ceOGyWtSVQwUKlSI69evmyWUEEIIIayrcOHCJguCVA0TSI+AEEIIYb9Seh+XOQNCCCGEg5NiQAghhHBwUgwIIYQQDk6KASGEEMLBSTEghBBCODgpBoQQQggHJ8WAEEII4eCkGBBCCCEcnBQDQgghhIOTYkAIIYRwcFIMCCGEEA5OigEhhBDCwUkxIIQQQjg4KQaEEEIIByfFgBBCCOHgpBgQQgghHJwUA0IIIYSDc1E7gBBCWFN0QgKnnj3jSUICLhoNRdzdKezujkajUTuaEKqRYkAIkeldi4lh1s2brLh7l7PPnpH4yvN5XFyolysXfQsWpEmePDhJYSAcjAZQUrrIw8ODx48fWyGOEEKYz8O4OD6/cIEFt26hARJMXOv89/PeWbIwq3RpGuXJY52QwjyuXoV9+yA0FK5dg4QE8PSEypWhWjWoUQNcHPfzr6enJ1FRUck+L8WAECJT2vrwIV1PnuR+XJzJIuBVTkAi8GGhQvxSsiRuTjK1ymYpCgQHw5QpsHmz8TFXV0hMND7n7Azx8cbfe3lB//7w4YeQL5+6uVUgxYAQwuHo792j/YkTJCrKf4YEUssJaJI7N7pKlXCXgsD2XLsG778PGzYY3/QTUlHyOTlBzpwwaxZ06GD5jDYkpWJA/oULITKV/Y8f0/7ECRIyUAiAsXdg48OH9D592lzRhLns3AnlysGWLcY/p6YQAGOPwaNH0LEj9O2b+tc5AMcdQBFCZDrRCQl0P3kSRVGS7vL8/nvjJ8nkLF8O+fP/88dEYMmdO7TLn5/2Lz0uVLR7NzRpAnFxxjf3tFL+/pfx++8QGwtz5hh7DBycFANCiEzj+ytXiIiJSb5HoFUr42SylykK/PwzFCjwr0LgBQ3Q58wZmuXJQ3ZnZ3NHFmlx9y60bp3+QuBligLz5xv/PXz8sVni2TMph4QQmUJMQgJTrl83PTRQoQI0bvzvr4IFISYGGjVK8iUK8CA+niW3b1sitkiL/v3h8WOThUAY0BrIA2QDKgJTTLX55Zdw4YI5U9olKQaEEJnCX/fu8Sg+Pu0v3LwZNJpkiwEw9g5MvX49/eFExu3fDytWmBzn3wj4A3eAkcAvQCBwzVS78fEwapQZg9onGSYQQmQKWx4+xAVIUzkQHw/btxt7DLy8kr1MAY49fcqDuDjyuLpmLKhIn+nTjfsEJFPwPQbeBloCK0nDJ934eONckZ9/htdeM0tUeyQ9A0KITCHk8eO0FQIABw8au51N9Aq8LMzE0ixhQTExsHRpsoUAwBLgNjAW4xvbU0j9apLERFi2LKMp7ZoUA0KITOFCdHTaX7R5s/HTZkBAipdqgCMPH/L06VNiYmKIj49HUVLcpkWYw9GjxkmDJmwGPIHrQBkgx99//giISal9jQYOHMh4TjsmwwRCiEwhLq1vzNHRsHevcZvanDlTvFxJSOCLoUP5YuXKfz3u5OSEs7Mzzs7OuLi4/OtXaz9mCxlMPeaU3iV8YWHGN2wT/43PYRwiCgLeA8YD24GpwCPgT1PtJyRASEj6smUSUgwIITIFN42G52kpCHbvNrmK4D+cnHjv7bdp2LYtCQkJJCQkEB8f/69fzf1YbGysRe6RmNFleRmQnkLio7t3eR8wNVvjCfAM+JD/rx5oB8QCvwHfAqVMBbt3L+PfnB2TYkAIkSmUypaN40+fpv4FmzdD1qxQu3bqrtdo6F63Lg1y505fQBuiKMo/xUF6igtrFEIv//6NffvQ3Lljsmcg69+/dn3l8W4Yi4F9pFAMqFgg2QIpBoQQmYKfpyennz0jPjW9A48eGU+3a9gQsmRJ9T18PTzSH9CGaDQaXFxccLGXU/ymTjUOFZhQCDgBFHjl8RfrAx6mdA8HP6VSJhAKITKFJrlzp64QANi2zThOnMohAifAN0cOctrLm2dm4+OT4if3F/tKvrobxI2/fzW5mbSzM9Ssmb5smYQUA0KITKFSVBTuMSnOGzfavBly5/7v1sTJSAQGvP56+sOJjKlaNcXzAzr9/eucVx6fjbELPMDUixUFqldPZ7jMQYoBIYRdu3z5Mn369KFS2bK4aLUmx5X/MX06rFpl/ESYAieggKsrneSgIvXkyGE8k8BEz4wP0BvjfgOdgV8xFgh/Al9iHEZIlqJA585mi2uPpBgQQtila9eu0a9fP0qVKoVWq2X8+PFcnTiR8tmzY87jhBKBIRoNWeWQInV9/LHJTYcAZgKjgf3Ap0A48DMwztSLnJ2hZUsoUsQsMe2VFANCCLty48YNBgwYQIkSJVi2bBnffvstERERfPHFF+T28GBxuXK4OjmZ5YebBnjtwAGGBAQwZcoU2WRITQ0bQv36JnsHXIGvgUsYlxSew1gUpGjMmIzns3NSDAgh7MKtW7cYNGgQJUqUYNGiRYwaNYqIiAiGDh1Kjhw5/rmuqocHhooVcdVoMtRDoAHa58tHxMCB9O/fn4EDB9K5c2ceP36c4e9FpINGYzxy2NXV+HtztTlihHFOgoPTYDyDwyQPDw/5H0AIoYq7d+/y448/Mn36dFxdXfnss88YOHAguXLlMvm6kMhIOp88ybXnz1O/Rz3gjHFoYPAbbzC2eHGc/37j+euvv+jduzcFChRg5cqVVK5cOb3fksgIrRbatzf+PiM9NU5OxiOsDQZjgZHJeXp6EmXibA3pGRBC2KT79+8zbNgwvL29mTlzJp9//jmXLl3i66+/TrEQAPDLmZOTNWsy4PXXcdNoUvxh96LzuUL27Ozz9eX7EiX+KQQA2rdvT2hoKNmyZaNWrVrMmzcv3d+byIC2bY2HCjk7p2oCaLKaNjUWFg5QCKSG9AwIIWzKw4cPmTRpEpMnT0ZRFD755BO++OIL8ubNm+4278fFMe/mTVbdu0f4kyfEvLJmvZi7OwG5ctGnUCH8PD3RmOiGjo6OZsCAAcyePZt3332XadOmkS1btnRnE+l05Aj06AEnThj/nJpeAhcXY4/A+PEwcGDGigk7k1LPgBQDQgibEBkZyeTJk5k0aRJxcXH079+fL7/8ktfMfMZ8gqJwKSaGqPh4XDQa3siSJV2bCS1YsICPPvqIkiVLsnLlSkqXLm3WnCIV4uLg99+JmzgR14gIFI0GjZOTcUMpjG9ucYAbGHeafPtt+OILKGVyY+JMSYoBIYRNe/z4MVOmTOGnn34iJiaGjz76iMGDB+Pl5aV2tBQdO3aMjh07cuPGDebMmUPHjh3VjuSQfpk8mb++/JKNo0eT5fhxuHzZuAwxVy7+PHWKm4UK8dnGjak6nTKzkmJACGGTnjx5wrRp05gwYQJPnjyhb9++DB06lEKFTG4PY3OioqL44IMPWLZsGZ988gkTJ07Ezc1N7VgOJSAggGzZsrF27dr/PDdkyBAWL17MtWvXVEhmO2QCoRDCpjx79oyJEyfi7e3NqFGj6Ny5MxcuXGDKlCl2VwiA8cPSn3/+ybRp05g5cyZvvvkmly9fVjuWw7h79y67du2iTZs2ST7v7+/P9evXuXr1qnWD2RkpBoQQVhEdHc3PP/9M8eLFGTZsGO3atePcuXP8+uuvvG7n+/5rNBr69+/Pnj17uH37Nr6+vkl+ShXmFxwcjKIoBAUFJfm8n58fACEhIdaMZXekGBBCWFRMTAxTp06lRIkSfPnll7Rs2ZKzZ8/y22+/UbRoUbXjmVWNGjUICwvD39+fli1bMnz4cOJT2EJXZIxWq6V27doUKPDq4cVGXl5eFCtWjH379lk5mX2RYkAIYRHPnz9nxowZlCxZkk8//ZTGjRtz+vRp5syZg7e3t9rxLCZPnjzo9XrGjx/P999/T+PGjbl165basTKlJ0+esHHjxmSHCF7w8/OTnoEUSDEghDCruLg4fv/9d0qXLk3//v2pX78+J0+eZMGCBZQsWVLteFbh5OTE0KFD2bp1K6dPn8bHx4cdO3aoHSvT2bBhA8+fP0+xGPD39yc0NJTnz59bJ5gdkmJACGEW8fHxzJs3jzJlytCnTx/8/f05fvw4ixcvpkyZMmrHU0X9+vUJDw+nXLlyNGzYkPHjx5OYmJbNkYUpWq2WihUrplhk+vn5ERsby+HDh60TzA5JMSCEyJD4+HgWLVpE2bJl6d27N76+vhw9epSlS5dSvnx5teOpzsvLi02bNjFs2DC++uorWrduzYMHD9SOZffi4uIIDg6mbdu2KV5btWpV3N3dZd6ACVIMCCHSJSEhgSVLllChQgXefvttKlasSHh4OCtXrqRSpUpqx7Mpzs7OfPfdd6xdu5Z9+/bh6+vLgQMH1I5l17Zv305kZGSqigE3NzeqVasm8wZMkGJACJEmiYmJLF++nEqVKtG9e3dKlSrFoUOH0Ol0VJWjYE1q3rw54eHheHl5UbduXaZNm4aSkZP3HJhOp6No0aKp/jfn7+8vPQMmSDEghEiVxMREVq1aRZUqVejcuTNFihQhJCSE4OBgqlWrpnY8u1GkSBF27txJv379+OSTT+jSpYvJneHEfyUmJqLT6WjTpo3JQ6Ve5ufnx5UrV7hx44aF09knKQaEECYpisLq1aupVq0a7du3x8vLiz179rB+/Xpq1aqldjy75ObmxuTJk1m+fDnr1q2jevXqHDt2TO1YduPgwYPcuHEjxVUEL/P39wdk86HkSDEghEiSoiisWbOGGjVq0KZNG3LmzMmOHTvYtGkTtWvXVjteptCxY0cOHTpElixZqFWrFgsWLFA7kl3Q6XTkzZuXunXrpvo1hQsX5vXXX5diIBlSDAgh/kVRFDZs2ICfnx+BgYFkzZqVrVu3sn37durVq6d2vEyndOnShISE0LVrV9555x3ef/99oqOj1Y5l07RaLa1bt8YljUdPy7yB5EkxIIQAjEXAli1bqFu3Ls2aNcPJyYmNGzeyc+dOGjRooHa8TC1r1qzMmTOHefPmsWTJEvz9/Tl37pzasWzS6dOnOXPmTJqGCF7w8/Pj0KFDxMXFmT+YnZNiQAjBjh07CAgIoFGjRsTFxbF27Vr27t1L48aNUz1BS2TcO++8w/79+4mOjqZatWr89ddfakeyOVqtluzZs9O4ceM0v9bf35+YmBiOHDligWT2TYoBIRzY7t27eeuttwgICCAqKgqDwcD+/ftp3ry5FAEqqVSpEgcPHqR58+Z06NCBTz/9lNjYWLVj2QytVkuzZs3ImjVrml/r4+ODq6urzBtIghQDQjigffv20aRJE958803u3buHVqslNDSUwMBAKQJsgKenJ0uXLmXq1Kn8+uuv1K9fnytXrqgdS3XXrl3j4MGD6RoiAMiSJQu+vr4ybyAJUgwI4UAOHjxIixYtqF27Njdu3GDFihWEh4enab22sA6NRsPHH3/M7t27uXHjBj4+Pqxbt07tWKpavXo1Li4utGzZMt1tyAmGSZNiQAgHEB4eTuvWralZsyYREREsXbqUo0eP0qFDB5yc5MeALatZsyZhYWH4+fnRokULRo4cSUJCgtqxVKHT6QgICCB37tzpbsPf35+LFy9y584dMyazf/JTQIhM7OjRo7Rr1w5fX19Onz7NH3/8wfHjx+ncubMUAXYkb968GAwGxo0bx7hx42jSpAm3b99WO5ZVPXz4kO3bt6fqLAJT/Pz8ANl86FXy00CITOjEiRN07NiRKlWqcOTIEebPn8/Jkyfp3r07zs7OascT6eDk5MSwYcPYsmULJ06cwMfHh507d6ody2qCg4OJj48nKCgoQ+0UKVKEggULyryBV0gxIEQmcvr0abp27frPjPTZs2dz+vRpevXqleYNWoRtCggI4PDhw5QpU4aGDRvyww8/kJiYqHYsi9PpdNSsWZPChQtnqB2NRiPzBpIgxYAQmcC5c+fo2bMnFSpUYPfu3cyYMYOzZ8/y3nvv4erqqnY8YWZeXl5s2rSJIUOGMHToUIKCgnjw4IHasSwmOjqa9evXZ3iI4AV/f38OHDhAfHy8WdrLDKQYEMKOXbx4kXfffZdy5cqxdetWpkyZwvnz5+nbty9ubm5qxxMW5OLiwtixY1mzZg179+7F19eXgwcPqh3LIjZt2sSzZ8/SvaTwVX5+fjx79ozjx4+bpb3MQIoBIezQpUuXeP/99yldujTr169n0qRJXLhwgf79++Pu7q52PGFFLVq0ICwsjAIFClC3bl2mT5+OoihqxzIrrVZL2bJlKVu2rFnaq1atGi4uLjJv4CVSDAhhR65evcqHH35IqVKl0Ov1/Pjjj1y4cIEBAwaQJUsWteMJlRQtWpRdu3bRt29fPv74Y7p160ZUVJTascwiPj4eg8FgtiECgGzZslGlShWZN/ASKQaEsAPXr1/n448/pmTJkqxcuZKxY8cSERHBZ599RrZs2dSOJ2yAm5sbU6ZMYdmyZQQHB1OjRo1M0Q2+e/du7t+/b7YhghfkBMN/k2JACBt269YtPv30U0qUKMGSJUsYPXo0ERERDB48mOzZs6sdT9igTp06ERoaipubGzVr1mThwoVqR8oQrVZL4cKFqV69ulnb9fPz49y5c9y/f9+s7dorKQaEsEF37tzh888/p3jx4syfP5/hw4cTERHBsGHD8PDwUDuesHGlS5cmJCSELl260KtXLz744AOio6PVjpVmiqKg0+kICgoy+yZZ/v7+gGw+9IIUA0LYkHv37jFkyBC8vb35/fff+fLLL7l06RIjR44kZ86cascTdiRbtmzMnTuXOXPm8Mcff1C7dm3Onz+vdqw0CQ8P58qVK2adL/CCt7c3+fPnl2Lgb1IMCGEDHjx4wPDhw/H29mb69Ol8+umnXLp0iW+++YZcuXKpHU/Ysd69exMSEsLTp0+pVq0aq1atUjtSqmm1WnLlykX9+vXN3rZGo5F5Ay+RYkAIFT169Iivv/6aYsWKMXnyZPr378+lS5cYO3YsefLkUTueyCSqVKnCoUOHaNKkCe3bt2fQoEHExsaqHStFOp2OwMBAi22c5efnx4EDBxz24KeXSTEghAoeP37MmDFjKFasGD/++CN9+vQhIiKC77//nnz58qkdT2RCnp6eLF++nF9++YXp06cTEBDA1atX1Y6VrPPnz3P8+HGLDBG84O/vT1RUFCdPnrTYPeyFFANCWFFUVBTjxo2jWLFijB07lnfeeYeLFy8yceJEXnvtNbXjiUxOo9EwYMAAdu3axbVr1/Dx8WH9+vVqx0qSVqslS5YsNG3a1GL3qF69Ok5OTjJvACkGhLCKp0+f8uOPP+Lt7c0333xDt27duHDhApMnT6ZgwYJqxxMOplatWoSHh1OzZk1atGjBqFGjbK6rXKfT0aRJE4suoc2RIweVK1eWeQNIMSCERT179oxJkyZRvHhxRowYQceOHTl//jzTpk3L8OlrQmRE3rx5CQ4OZsyYMYwdO5amTZty584dtWMBxv019u3bZ9EhghfkBEMjKQaEsICYmBimTJlCiRIlGDx4MK1bt+bs2bPMmDGDN954Q+14QgDg5OTE8OHD2bx5M8ePH6dq1ars2rVL7Vjo9Xo0Gg2BgYEWv5e/vz+nTp3i4cOHFr+XLZNiQAgzev78OdOnT6dEiRIMGjSIZs2acebMGX7//XeKFSumdjwhktSgQQPCw8MpVaoUDRo04Mcff1T1sCOtVku9evWsMpnWz88PgAMHDlj8XrZMigEhzCA2NpbffvuNUqVKMWDAABo2bMipU6eYN28eJUqUUDueECkqWLAgW7Zs4csvv2TIkCG0adNGlU/LkZGRbNmyxSpDBAClSpUiT548Dj9vQIoBITIgLi6OOXPmULp0aT766CPq1KnD8ePHWbRoEaVLl1Y7nhBp4uLiwvjx4zEYDOzatQtfX19CQ0OtmmHdunXExcURFBRklftpNBqZN4AUA0KkS3x8PAsWLKBs2bK8//771KxZk2PHjvHnn39Srlw5teMJkSGBgYGEhYWRP39+ateuzYwZM6w2bKDVavH19aVo0aJWuR8Y5w2EhISQmJhotXvaGikGhEiDhIQEFi9eTPny5XnnnXeoUqUKR44cYfny5VSoUEHteEKYTbFixdi1axd9+vShX79+dO/enSdPnlj0ns+fP2ft2rVmP644JX5+fkRGRnLmzBmr3teWSDEgRCokJiaydOlSKlasSI8ePShbtiyhoaGsWrWKypUrqx1PCItwd3dn6tSpLF26FIPBQI0aNThx4oTF7rdlyxaePHlitfkCL9SsWRONRuPQ8wakGBDChMTERFauXEnlypXp2rUr3t7eHDhwAL1ej6+vr9rxhLCKzp07c+jQIVxcXKhZsyZ//PGHRe6j1WopWbKk1XvZPD09qVChgkPPG5BiQIgkvDhH3cfHh44dO1K4cGH27dvH2rVrqVGjhtrxhLC6MmXKsH//fjp27EjPnj3p27cvMTExZms/ISEBvV5PmzZt0Gg0Zms3tRz9BEMpBoR4iaIoBAcHU61aNdq2bUu+fPnYtWsXGzZs+Gc9shCOKlu2bMybN4/Zs2ezcOFCateuzYULF8zS9r59+7hz547Vhwhe8PPz48SJEzx+/FiV+6tNigEhMBYB69ato1atWrRq1QoPDw+2bdvGli1bqFu3rtrxhLAZGo2G9957j5CQEKKioqhWrRparTbD7ep0OgoUKKBa0e3v74+iKA67+ZAUA8KhKYrCpk2bqF27Ni1atMDV1ZXNmzezfft2AgIC1I4nhM2qUqUKhw4dolGjRrRr147PP/+cuLi4dLWlKAparZagoCCcnNR5WypTpgy5cuVy2HkDUgwIh7Vt2zbq1atHkyZNUBSF9evXs3v3bt566y1VxiyFsDc5c+ZkxYoVTJ48mSlTphAQEMC1a9fS3M6xY8e4ePGiakMEYDynoVatWg47b0CKAeFwdu7cSYMGDWjYsCHR0dGsWbOGffv20bRpUykChEgjjUbDwIED2blzJ1euXMHHx4eNGzemqQ2dToeHhwcNGjSwUMrUebEToZrnMqhFigHhMPbu3Uvjxo2pX78+Dx8+ZPXq1Rw8eJAWLVpIESBEBvn7+xMeHk61atVo1qwZo0ePJiEhIVWv1Wq1tGzZEnd3dwunNM3f358HDx5w7tw5VXOoQYoBkent37+fZs2aUadOHW7dusVff/1FWFgYrVu3liJACDPKly8fa9eu5dtvv2XMmDE0a9aMO3fumHzNpUuXOHz4sKpDBC/UrFkTwCHnDUgxIDKt0NBQAgMD8fPz48qVKyxfvpwjR47Qrl071SYpCZHZOTk5MWLECDZt2sTRo0fx8fFh9+7dyV6v0+lwc3OjWbNmVkyZtNy5c1OuXDmHnDcgPxFFpnP48GHatGlD9erVOXfuHEuWLOHYsWN07NhRigAhrKRhw4aEh4dTokQJAgICmDhxYpJj8VqtlkaNGuHp6alCyv9y1BMM5SejyDSOHz9Ohw4d8PHx4fjx4yxcuJATJ07QtWtXnJ2d1Y4nhMMpVKgQW7du5YsvvuDLL7+kbdu2PHr06J/n7969y+7du61+MJEp/v7+HD161OKHMtkaKQaE3Tt16hRdunShcuXKhIaGMnfuXE6fPk3Pnj1xcXFRO54QDs3FxYXvv/8evV7Pjh078PX1JTQ0FACDwYCiKLRu3VrllP/n5+dHYmIihw4dUjuKVUkxIOzWmTNn6N69OxUqVGDfvn389ttvnD17lnfffVeKACFsTKtWrQgLCyNv3rzUrl2bmTNnotPpqFOnDgUKFFA73j/Kly+Ph4eHw80bkJ+Ywu6cP3+eMWPG8Mcff1CwYEGmT59O7969VV+WJIQwzdvbm927d/PZZ5/x0Ucf4eTkxJgxY9SO9S/Ozs7UrFnT4eYNSM+AsBsRERG89957lC1blk2bNvHLL79w/vx5PvroIykEhLAT7u7uTJ8+nYEDB5KYmMjcuXM5efKk2rH+5cUJho60+ZAUA8LmXblyhb59+1K6dGmCg4OZOHEiFy5c4OOPPyZLlixqxxNCpMO9e/coXbo0WbJkoUaNGixevFjtSP/w8/Pj7t27REREqB3FaqQYEGmXkAAnToBWC0uXGn89fhzi4816m2vXrtGvXz9KlizJqlWrGD9+PBcvXuTTTz8la9asZr2XEMJ6YmNjCQ4OpkuXLuzfv5/27dvTo0cPPvzwQ2JiYtSO98/JiY42b0BJ6cvDw0MRDi4hQVHWrlWUli0VJUsWRYH/fmXJoijNmytKcLCixMen+1Y3btxQPvnkE8XNzU3JkyeP8v333ytRUVFm/GaEEGrasGGDAijh4eGKoihKYmKiMmvWLMXd3V3x9fVVLly4oG5ARVFKly6tfPzxx2rHMBsPDw+T7/PSMyBStn8/lCsHLVrA+vWQXOUeEwMbN0JgIJQtC3v3puk2t2/f5rPPPqN48eIsWrSIUaNGERERwZAhQ8iRI4cZvhEhhC3Q6XQULVqUKlWqAMbDjj744AP27dtHZGQkvr6+6HQ6VTP6+fk5VM+AFAMieYoCo0aBvz9cuGB8LKWDR148HxEBdevCsGGQmGjyJXfv3mXw4MF4e3szZ84chg4dyqVLlxg+fLjN7EomhDCPxMREdDodbdu2/c/ZID4+PoSGhtKwYUPatm3LF198QVxcnCo5/f39OXLkCM+ePVPl/mqQYQLxX4mJivLBB0kPB6T16513jMMMr7h3754ydOhQJXv27EqOHDmUESNGKA8ePFDhmxVCWEtISIgCKDt27Ej2msTERGXSpEmKi4uLUqdOHeXatWtWTGgUHh6uAMrOnTutfm9LkGECkT7jx8Pvv5unrfnz4aW1xA8fPmTkyJF4e3szdepUBgwYwKVLlxgzZgy5c+c2zz2FEDZJq9WSL18+6tSpk+w1Go2GQYMGsWPHDi5fvkzVqlXZtGmTFVNCxYoVyZ49u8PsNyDFgPivo0fh66+Tffo5MAQoBGQFagEp/m/67bdE7djBN998Q7Fixfjpp5/48MMPiYiIYNy4ceTNm9dc6YUQNkpRFLRaLa1bt07VeSG1a9cmLCwMX19fmjZtyjfffENCSkOVZuLi4kKNGjUcZt6AFAPiv95/39jBn4x3gElAd+AXwBloASR/SCkkKAoRDRvy/fjxvPfee1y8eJEff/yR/PnzmzG4EMKWnT59mrNnz6bpYKL8+fOzdu1aRo8ezTfffEPz5s25e/eu5UK+xJE2H5JiQPzbwYPGr2Sq7wPAUmA8MAHoA2wFigKDTTTrrChUTkzkyvLlTJo0CS8vLzMHF0LYOq1WS/bs2WncuHGaXufs7MyoUaPYuHEjhw8fxsfHhz179lgo5f/5+flx69Ytrly5YvF7qU2KAfFvv/0GJg75WYmxJ6DPS49lAd4D9gFXTbXt4kL+v/4yQ0ghhD3S6XQ0b9483TuHNmrUiPDwcLy9vQkICGDSpEkW/dT+YvMhR5g3IMWA+LctW0zuJBgOlAZeXfBX8+9fD5tqOz7e2L4QwuFcu3aNgwcPpmmIICmFCxdm69atDBo0iM8//5z27dvz6NEjs2R81WuvvUbx4sUdYt6AFAPi/yIj4dIlk5fcBAom8fiLx26kdI/r1+H+/TRHE0LYN51Oh4uLCy1btsxwW66urvz444+sXr2abdu2Ua1aNcLDw82Q8r/8/f2lZ0A4mBQKAYBoIKnzAbO89HyKLl5MdSQhROag0+lo0KABuXLlMlubrVu3JiwsjNy5c+Pv78+sWbPMPmzg5+dHWFiYTZyZYElSDIj/S8VOX1kxLi18VcxLz5vjPkKIzOPBgwds376dtm3bmr1tb29vdu/eTe/evenbty9vv/02T58+NVv7/v7+xMXFWaznwVZIMSD+LxUnARbEOFTwqhePFUrNfbJlS30mIYTdW7NmDQkJCQQFBVmk/SxZsvDrr7+yePFitFotNWvW5NSpU2Zpu3LlymTNmjXTzxuQYkD8X8mSJlcSAFQFzgKPX3l8/0vPm+TkBGXKpCOcEMJeabVaatWqRaFCqfq4kG7dunXj4MGDANSoUYMlS5ZkuE1XV1eqV6+e6ecNSDEg/s/dHcqXN3lJByABmPXSY8+BeRh3InwjpXuULp2qHgghRObw7Nkz1q9fb5EhgqSUK1eOAwcO0LZtW7p3706/fv14/jypwc3Uc4QTDKUYEP8WFAQmtgmtBXQEhmHcZGgW0BC4BPyYUtvOzsb2hRAOY9OmTURHR2d4SWFaZM+enYULF/Lbb78xd+5c6tSpQ0RERLrb8/f359q1a1y7ds2MKW2LFAPi3/r0MbkVMcBC4FNgETAAiAOCgXoptZ2YCB9+mPGMQgi7odVqKVeuHGWsPDyo0Wjo06cPe/fu5eHDh/j6+qLX69PVliNsPiTFgPi311+Hrl1N9g5kwbgV8U2MqwgOAE1TatfZGTp2hGLFzBRUCGHr4uPjMRgMVhsiSIqvry+hoaEEBAQQFBTE4MGDiUvjiqaCBQtStGhRKQaEg5k8GXLmBI3GPO1pNODpCVOnmqc9IYRd2LVrFw8ePLDqEEFScuXKxapVq/jpp5/4+eefadiwIdevX09TG//MG4iLg4cP4dEjk7u12hspBsR/5csHixaBRoPZtu+YPx9ee81crQkh7IBWq+X111+nevXqakdBo9Hw2WefsX37diIiIvDx8WHz5s0pv1BRYOdOhl+9ysx9+1CyZYM8eSB3buMy6WrV4JNPjAe82TEpBkTSWrTgytixJAKJ6W3DycnYKzBvHrRubcZwQghbpygKOp2ONm3aoDFXL6MZ1KlTh/DwcKpWrUqTJk349ttvSUxM5qdccLBxhVX9+lTYv59KioLm5d6AuDgIC4OZM6FmTfDxgR07rPONmJkUAyJJt2/f5s0ZM+hXogR4eZmcQ5AkZ2djD8O6ddCrl2VCCiFsVlhYGFevXlV9iCAp+fPnZ926dXz99deMHj2aFi1acO/evf9f8Pgx9OwJrVrB2bMAOCVzrDvw/+GCo0chIAA+/hiiU7U5u82QYkD8R3R0NEFBQcTFxTFy+3acTp+Gvn3B3R0FEz0FGo3xy80N3n8fzpyBpilOLRRCZEI6nY7cuXNTr16K64xU4ezszNdff82GDRsIDQ3Fx8fHOCfg/n2oWxf+/NN4YXK9Bkl5ce2MGcaffU+emD+4hWgg5WFhDw8PHj9+dc85kRkpikLXrl3R6/Xs3LnzX2N9yoMHjPb2pnOePJR/8gRerqTz5oUaNaBxY3jnHeOYmhDCYVWsWBFfX18WLlyodpQUXb9+nc6dOxMeEsLFggV57eZNNKZ6AlLD2RkaNID169Pes2oBnp6eREVFJfu89AyIfxk9ejTLli1j0aJF/5n0ExYRwbePH3Nn3jy4e9d45PHt28Zf7941Dgl89pkUAkI4uHPnznHixAlVlxSmReHChdm2bRv66tXJf+1aqgqBsRg/TVdM7oKEBNi82W5WUUkxIP6xePFivv32W8aNG0f79u3/87xerydXrlzUqVPH+ICnp3GFgKen+ZYhCiHsnk6nI2vWrDS1o2FC1+PHeevAgVS9KV4DxgHZU9Pw0KGQgd0PrUWKAQHA3r176d27N7169WLo0KFJXqPX62nRogWurq5WTieEsCdarZYmTZqQzZ5OKJ0wIdXd+V8AfkCqFkzGx9tF74AUA4KIiAjatGlDrVq1+O2335JcBnT16lUOHz5Ma1kiKIQw4ebNm4SEhNjNEAEAd+7AihWp2kRoJ7ASmJzathMSYPZsePYs/fmsQIoBBxcZGUlgYCCenp6sWrUKd3f3JK8zGAy4uLjQrFkzKycUQtgTvV6Pk5MTgYGBakdJvc2bU1UIJACfAO8DldLSflQU7N2bvmxWIsWAA4uPj6dz585cv36d4OBg8uXLl+y1er2e+vXrkzNnTismFELYG61WS7169cibN6/aUVIvNBRSMfw5E7gMjElr+87OxnvYMCkGHNigQYPYvHkzK1eupGzZssleFxUVxbZt22SIQAhhUmRkJFu3brWvIQKAY8eMuwmacB8YBYwE8qe1fY0GTpxIXzYrcVE7gFDHtGnTmDZtGr/99huNGjUyee3GjRuJjY2lVatWVkonhLBHa9euJS4ujqCgILWjpE0qNgcaAeTBOEyQZgkJNj9nQIoBB7R+/XoGDhzIoEGD6NOnT4rX6/V6KlasiLe3txXSCSHslVarpVq1ahQpUkTtKGnj5mby6XPALIyTBm+89HgMEAdcAjwxFgtJ0mhSNQyhJhkmcDDHjx+nU6dOtGjRggkTJqR4fUJCAmvWrJEhAiGESTExMaxbt87+hggASpYEl+Q/G1/HuA37AMD7pa/9wNm/f/+tqfadnMDGP0xJz4ADuXPnDoGBgXh7e7NkyRKcU7Gmdt++fdy/f1+GCIQQJm3ZsoUnT57Y5MFEKapWDebOTfbpioA2icdHAFHAL0AJU+3Hx4MNHONsihQDDiImJoY2bdrw/PlzgoOD8fDwSNXr9Ho9r732GjVr1rRwQiGEPdPpdJQqVYry5curHSXt6tcHJfljevIBbZJ4fPLfvyb13L84OUHt2ukIZj0yTOAAFEWhd+/ehIeHs3r1at54441Uv9ZgMNCqVSucnOSfihAiaQkJCaxevZo2bdokuWmZzStfHvz9LXOgkIsLBAUZj4K3YfIT3gGMGTOGP//8k4ULF6bpE/7Zs2c5ffq0DBEIIUzau3cvd+/etc/5Ai8MGmSc9Z8G24HjKV0UHw8DB6YzlPVIMZDJLV26lK+//prvvvuOjh07pum1BoOBLFmypLj0UAjh2HQ6HV5eXtSqVUvtKOnXoQM0aWJyImGaOTtDjx7GYQgbpwGSHyj5m4eHB48fP7ZCHGFOISEhBAQE0KlTJxYsWJDm7ruAgAA8PDwwGAwWSiiEsHeKolCiRAmaNGnCzJkz1Y6TMdeuQYUKKE+fpuoYY5OcnSFfPjh1CnLnNk++DPD09CQqKirZ56VnIJO6dOkSQUFBVK9end9//z3NhcD9+/fZvXu3DBEIIUw6duwYERER9j1E8MLrr8OGDcQ5OZHySQUmODsbj3bfssUmCoHUkGIgE3r8+DGtWrUiR44caLXaZA8fMmXdunUkJCTY12EjQgir02q1eHp60qBBA7WjmMWKq1fxj4vjqaencRVAWmk0UKIE7NsHFSqYP6CFSDGQycTHx9OlSxeuXr1KcHAw+fOneRdtwDhfoEaNGhQqVMjMCYUQmYlWq6Vly5a4pbCLnz04cOAAb7/9NmW6dsXz6lXo08f45p6aVQZOTsbrhgyBI0egTBnLBzYjKQYymc8//5yNGzeyYsUKypUrl642YmNjWbdunQwRCCFMioiI4MiRI5liiODy5cu0bt0aX19f5s6di8bTE2bMgIsX4csvoWDB5F9cpAh8/TVcuQLjx0OWLNYLbiay6VAm8uuvvzJlyhRmzJhB48aN093Ojh07iIqKki2IhRAm6XQ63N3dadasmdpRMuTF0GrWrFnRarVkefnNvFgx4xv8+PFw+zaEh8P9+8aegPz5wccH7Om45mRIMZBJbNiwgQEDBjBw4EA+/PDDDLVlMBgoUqQIlStXNlM6IURmpNPpaNSoUap3NLVFL4ZWL1++zL59+3jttdeSv7hAAbDzwic5MkyQCZw8eZJOnTrRtGlTfvrppwy1pSgKer2eVq1a2edOYkIIq7h79y67d++2z7MIXvLZZ5+xceNGVq5caZ9bKZuJ9AzYubt37xIYGEjRokVZunRpqg4fMuXYsWP/jJ0JIURy9Ho9gF3/rJg2bRpTp05l5syZGRpazQykGLBjLw4fevbsGdu2bTNLV53BYMDDw4P6drBjlhBCPTqdjjp16pjuVrdh69atY+DAgQwaNIi+ffuqHUd1MkxgpxRF4YMPPiA0NJTVq1dTtGhRs7Sr1+tp2rRpuvYmEEI4hqioKDZt2mS3QwTHjh2jc+fOtGzZkgkTJqgdxyZIMWCnxo4dyx9//MGCBQvMth/4zZs3OXDggF13+wkhLG/Dhg08f/7cLpcU3rp1i8DAQEqUKMGSJUsyPLSaWUgxYIeWL1/OyJEj+fbbb+ncubPZ2l2zZg1OTk60aNHCbG0KITIfrVZLlSpV8Pb2VjtKmkRHRxMUFERcXBwGg4EcOXKoHclmSDFgZ/bv30+vXr3o3r07I0aMMGvber2eOnXqkDcTrJkVQlhGbGwsa9assbshgsTERHr16sXx48cxGAy8/vrrakeyKVIM2JHLly8TFBSEr68vs2fPNuvSv2fPnrFp0yYZIhBCmLR9+3YiIyPtbohg1KhRrFy5kj/++INq1aqpHcfmyGoCOxEVFZX8DllmsGXLFmJiYqQYEEKYpNVqKVasmF1tSrZw4ULGjh3LDz/8YHdFjLVIMWAHEhIS6Nq1K5cvX2bv3r0WWcqj1+spXbo0pUuXNnvbQojMITExkdWrV9OlSxe72ZRs586dvP/++7z33nt8+eWXasexWTJMYAe++OIL1q1bx/Lly6lggSMxExMTMRgM0isghDDpwIED3Lx5024+XZ8/f562bdtSt25dfv31V7spYNQgPQM2bubMmUyePJlp06bRtGlTi9zj0KFD3L59W4oBIYRJWq2W/PnzU7t2bbWjpOjBgwe0bNmS/Pnz89dff2WKI5YtSYoBG7Zp0yY+/vhjPvnkE/r372+x++j1evLkyYO/v7/F7iGEsG+KoqDVamndurXNr82PjY2lQ4cO3Lt3j/3795M7d261I9k8GSawUadOnaJjx440adKESZMmWfReer2eli1b4uIitaEQImmnTp3i3LlzNr+kUFEU+vXrx+7du9FqtZQsWVLtSHZBigEbdO/ePQIDA3n99ddZunSpRd+kL126xLFjx2SIQAhhkk6nI0eOHDRq1EjtKCZNmDCBOXPmMHv2bOrVq6d2HLshHwVtzIstPp88ecKWLVvw9PS06P0MBgOurq40adLEovcRQtg3rVZL8+bNzb6s2ZxWrVrF0KFDGT58OG+//bbaceyK9AzYkBeHDx08eBCdTkexYsUsfk+9Xk+DBg0sXnQIIezX1atXOXTokE0PERw6dIgePXrQsWNHvv32W7Xj2B0pBmzI+PHjWbRoEfPmzbPKZL7IyEh27NghQwRCCJNWr16Nq6srLVu2VDtKkq5du0br1q2pXLky8+fPx8lJ3trSSv7GbMSKFSsYPnw4o0ePpmvXrla554YNG4iLiyMwMNAq9xNC2CetVkuDBg3ImTOn2lH+48mTJwQGBuLq6srq1avJmjWr2pHskhQDNuDgwYO8/fbbdO3alVGjRlntvnq9nipVqlC0aFGr3VMIYV/u37/Pjh07bHKjoRe7s168eJHg4GAKFCigdiS7JcWAyq5evUrr1q2pWrUqc+fOtdoOWfHx8axdu1aGCIQQJq1Zs4aEhASCgoLUjvIfX375JWvXrmX58uVUqlRJ7Th2TVYTqOjJkye0atUKd3d3dDqdVWfp7tmzh4cPH9KqVSur3VMIYX+0Wi1+fn4ULFhQ7Sj/MnPmTH7++WemTZtGs2bN1I5j96RnQCUJCQl069ZNte4tvV5PwYIF5ShPIUSynj17xoYNG2xuiGDjxo1W2Z3VkUjPgEoGDx7MmjVrCA4OpmLFila9t6Io6PV6WrVqJbNuhRDJ2rhxI9HR0TZVDJw8edJqu7M6EnknUMGsWbOYNGkSkydPpnnz5la//5kzZzh//rwMEQghTNJqtZQvX55SpUqpHQWAO3fu0LJlS4oWLWrx3VkdjRQDVrZlyxb69+9P//79+eSTT1TJoNfryZo1K2+99ZYq9xdC2L74+HgMBoPN9ArExMTQpk0boqOjCQ4Olo3SzEzKKis6ffo07du356233mLy5Mmq5TAYDDRp0kTW4wohkrVz504ePnxoE7sOKopC7969CQ8PZ8eOHRQpUkTtSJmO9AxYyYvDhwoXLsyyZctU6966e/cue/fulSECIYRJOp2ON954wyYmGX/zzTf8+eefLFq0iJo1a6odJ1OSngEreP78Oe3atSMyMpIDBw6ouovX2rVrURRFdh0UQiRLURR0Oh1t2rSx2t4nyVm8eDHffPMNY8eOpUOHDqpmycykGLAwRVHo27cv+/fvZ+vWrXh7e6uax2AwUKtWLdmpSwiRrNDQUK5evar6EMGePXvo3bs3vXr1YtiwYapmyexkmMDCfvjhBxYsWMDcuXOpU6eOqlliYmJYv369DBEIIUzS6XTkzp2bevXqqZbh4sWLtGnTBj8/P2bNmqV6D0VmJ8WABa1atYphw4YxcuRIunfvrnYctm/fztOnT2ULYiGESVqtllatWqk2t+nRo0e0bNmSXLlysWrVKtzc3FTJ4UikGLCQF2drd+7cmW+++UbtOIBxiMDb25sKFSqoHUUIYaPOnj3LyZMnVVtSGBcXR8eOHbl9+zZr1qwhb968quRwNDJnwAJePlt73rx5NtG99WLXwXbt2tlEHiGEbdLpdGTNmpUmTZpY/d6KovDJJ5+wfft2Nm7cSOnSpa2ewVFJMWBmLw4fcnV1/ed/Kltw+PDhf4oUIYRIjlarpWnTpmTLls3q9/7555/57bffmDt3Lg0aNLD6/R2ZFANmlJCQQPfu3Tl//jx79uzBy8tL7Uj/0Ov15MyZU9UJQUII23bz5k1CQkJYsGCB1e+t1+v54osvGDJkCO+++67V7+/opBgwo6FDhxIcHIxer6dy5cpqx/kXg8FAs2bNcHV1VTuKEMJGrV69GmdnZ6vvQxIeHk7Xrl1p27Yt48aNs+q9hZFMIDST2bNnM3HiRCZNmkTLli3VjvMv165dIzQ0VIYIhBAm6XQ66tevT548eax2z+vXr9OqVSvKly/PokWL5CRVlcjfuhls27aNjz76iI8++ogBAwaoHec/goODcXZ2VuWERCGEfYiMjGTr1q1WXUXwYqmzRqNBr9erMk9BGMkwQQadPXuW9u3b06BBA3755RebnKlvMBh48803yZ07t9pRhBA2as2aNcTFxREUFGSV+yUmJtKjRw/Onj3L7t27KViwoFXuK5ImPQMZcP/+fVq2bImXlxfLly+3yfH4J0+esGXLFhkiEEKYpNPpqF69Om+88YZV7jd06FD0ej1//vknVapUsco9RfKkGEin2NhY2rdvz8OHDwkODiZXrlxqR0rSpk2beP78uRQDQohkxcTEsG7dOqsNEcyePZsJEyYwadIkOTTNRsgwQTooisJHH33Evn372LJlC8WLF1c7UrIMBgPlypWjRIkSakcRQtioLVu28OTJE6scTLRlyxabnmPlqKRnIB0mTJjA3LlzmT17NnXr1lU7TrISEhIIDg6WXgEhhElarZbSpUtTrlw5i97n9OnTdOjQgYYNGzJlyhSbnGPlqKQYSCOtVsvQoUMZPnw4PXv2VDuOSfv37+fu3btSDAghkpWQkIBer6dNmzYWfXO+d+8eLVu2pFChQixfvly1Q5BE0uS/RhqEhYXRo0cPOnTowLfffqt2nBQZDAby5ctHrVq11I4ihLBRe/fu5e7duxadL/D8+XPatm1LVFQUmzdvJmfOnBa7l0gfKQZS6cXGGBUqVGD+/Pl2sTGGXq8nMDAQZ2dntaMIIWyUVqulYMGC1KxZ0yLtK4rC+++/z8GDB9m2bRve3t4WuY/IGNt/R7MBLzbGcHZ2tpuNMS5cuMDJkydliEAIkSxFUdBqtQQFBVnsA87YsWP5448/mD9/Pv7+/ha5h8g46RlIwYuNMc6cOWNzhw+ZYjAYcHNzo3HjxmpHEULYqKNHj3Lp0iWLDREsW7aMkSNH8u2339KlSxeL3EOYhxQDKfjqq69YvXo1q1evtquNMfR6PW+99RY5cuRQO4oQwkZptVpy5sxJQECA2dsOCQmhV69e9OjRgxEjRpi9fWFeMkxgwrx58/jhhx/46aefaNWqldpxUu3hw4fs3LlThgiEECbpdDpatmyJm5ubWdu9dOkSQUFBVK9endmzZ8sSQjsgxUAytm/fTp8+fejTpw+ffvqp2nHSZP369SQkJMjOXkKIZEVERHDkyBGzDxFERkYSGBhIjhw50Gq1uLu7m7V9YRkyTJCEc+fO0b59e+rXr8+0adPsrqrV6/X4+vry+uuvqx1FCGGjXrxRN2vWzGxtxsfH07lzZ65du0ZISAj58+c3W9vCsqRn4BUPHjwgMDCQ/Pnzs2LFCps8fMiUuLg41q1bJ0MEQgiTdDodjRs3Ntu8IkVRGDhwIFu2bOGvv/6ibNmyZmlXWIf0DLwkNjaWDh06cP/+ffbv32+XR/7u2rWLyMhIu5rjIISwrjt37rB7925mz55ttjanTp3Kr7/+yqxZs3jrrbfM1q6wDikG/qYoCv369WP37t1s3rzZbg/20ev1FC5cGB8fH7WjCCFslMFgQKPRmO1Dw5o1axg0aBCff/45H3zwgVnaFNYlxcDffvrpJ+bMmcP8+fOpV6+e2nHSRVEU9Ho9rVu3trt5DkII69FqtdStW9csY/pHjx6lS5cutGrVih9++MEM6YQaZM4AsHr1agYPHsywYcPo1auX2nHS7eTJk0RERMgQgRAiWVFRUWzatMksxxXfvHmTwMBASpUqxeLFi2Xrczvm8MVAeHg43bp1o127dnz33Xdqx8kQvV5P9uzZadCggdpRhBA2av369cTGxmZ4SeGzZ88ICgoiISEBg8FA9uzZzZRQqMGhhwlu3LhBq1atKFeuHAsXLrSLw4dM0ev1NG3alCxZsqgdRQhho7RaLVWrVqVYsWLpbiMxMZG3336bEydOsGvXLgoXLmy+gEIV9v3u94oHcXGcefaM00+fcjc21uS1z549+2ds3V4OHzLl9u3b7N+/X4YIhBDJio2NZc2aNRkeIhgxYgSrVq1iyZIl+Pr6miecUJVd9wwkKArr7t9nwe3b7I2M5MYrBcBrrq74e3rSvUAB2uTLh+vfn/wTExPp2bMnp0+fZvfu3RQqVEiN+Ga1Zs0aAFq2bKlyEiGErdq2bRuPHz/O0BDBvHnzGD9+PBMnTiQoKMiM6YSa7LYYWHHnDp9duMC1589xBhKSuOZOXBzB9++z+v598ru6Mr54cXp7eTFixAi0Wi06nY6qVataObll6PV6ateuLTt+CSGSpdVq8fb2plKlSul6/Y4dO+jbty8ffPABn332mZnTCTXZ3TDBo7g4Ohw/TqeTJ7n+/DmQdCHwwovn7sbF8f6ZM1Rcv57xM2cyYcKETLNLX3R0NJs2bZIhAiFEshITE1m9ejVt27ZN19Ljs2fP0rZtW+rVq8f06dNl+XImY1c9A/fj4gg4fJhTT58CoKSjjZOuruRYuJBOjRqZN5yKtm7d+s8cCCGESMr+/fu5detWuoYIXmzTXqBAAVauXGl327SLlNlNz0BsYiLNjhzh1NOnJnsCUuTiQkyOHDQ8coQn8fHmiqcqvV5PyZIlZS9wIUSydDod+fPnx9/fP02vi42NpV27djx48IDg4GBy5cplmYBCVXbTMzD28mVCnzxJujcgIgIWLICzZ+HBA3B3h2LFoHNnqF37P5fHAxejoxl88SK/li5t4eSWlZiYSHBwMJ07d5ZuOyFEkhRFQavVEhQUlKaNgRRFoW/fvuzbt48tW7bY7TbtImV20TNw8ulTxl6+nPywwO3b8OwZNG0KH38MPXsaHx8+HAyGJF+SCMy4cYM9kZGWiGw1YWFh3LhxQ4YIhBDJOnnyJOfOnUvzksIffviB+fPnM3fuXOrWrWuZcMIm2EXPwJRr14yfepVkygE/P+PXy9q2hb59YcUKSGZinYtGw8SrV6mTM6eZE1uPXq8nd+7c1KlTR+0oQggbpdPpyJEjR5pOE1y5ciXDhg1j1KhRdO/e3YLphC2w+Z6Bx/HxLLh9m/jkCoHkODvDa6/BkyfJXhKvKOjv3ftnVYI9MhgMNG/eXCb0CCGSpdVqadGiRap3Jz148CA9e/akS5cujB492rLhhE2w+WJgT2QkMYmJqbs4OhoiI+H6dWOPwP79kMLuWInAlocPMx5UBVeuXOHw4cMyRCCESNbVq1cJDQ1N9RDBlStXaN26NVWrVmXevHkyF8lB2PwwQWhUVLKbCv3HjBn/nyPg5ARvvgkDB5p8iatGQ2hUFG97eWU0qtUZDAZcXFxo1qyZ2lGEEDZKp9Ph6upKixYtUrw2KiqKwMBAsmTJgk6nk3NOHIjNFwOnnz1L/cUdOkD9+nDvHmzfDomJEBdn8iVxisLJtNzDhhgMBurXr09OO57zIISwLK1Wy1tvvZXiz4mEhAS6du3K5cuX2bt3LwUKFLBSQmELbH6YIDoxkVQOEkCRIlCtmnFVwfjxxmGD4cOTn3j4t6cJGdq5QBWPHz9m69atMkQghEjW/fv32blzZ6qGCD7//HPWr1/P8uXLqVChguXDCZti88WAu5MT6R6xqlcPTp+Gq1dNXpbVDo8u3rhxI3FxcbIFsRAiWcHBwSQmJqZ4oNCvv/7KL7/8wtSpU2natKmV0glbYvPvgiWzZsUpvRNYXqwS+Hv74qS4ajSUscPjiw0GAxUrVsTb21vtKEIIG6XT6fDz88PLxJyo9evXM2DAAAYOHMhHH31kxXTClth8MVDNwyPlZYVJrQaIj4eNG/+/G2Ey4hSFah4eGQtpZfHx8axZs0aGCIQQyXr27BkbNmwweRbB8ePH6dSpE82aNeOnn36yYjpha2x+AmHdnDlx0WhMFwSTJhk//VepAvnyGbck3rwZrlyBjz6CrFlN3iPAzvba3rdvH/fv35diQAiRrA0bNhAdHZ3sfIHbt28TGBiIt7c3f/75Z5q2KRaZj80XA3ldXemUPz/L79wh2WOFGjSAtWth9Wp4/BiyZYPSpaFPHzCxM58z0CBXLkqkUCzYGoPBQIECBahRo4baUYQQNkqn01GhQgVKlSr1n+eio6MJCgri+fPnBAcH42FnvaPC/Gy+GAD49PXXWXLnTvIXNGxo/EqjBOCzN95IfzCV6PV6AgMDcbLDiY9CCMuLi4vDYDDQv3///zyXmJjIu+++y9GjR9m5cydv2OHPQGF+dvFuUsPTk/6FCpk3bEICFe/epYmdDRGcPXuWM2fOyBCBEAKAO7GxhERGsuvRIw49fsyT+Hh27tzJw4cPkxwiGD16NMuWLeOPP/6gevXq1g8sbJJd9AwAfF+8OOsfPOByTEzywwWp5AxkSUjg+Acf0GzWLP744w+72WDDYDCQJUsWGjVqpHYUIYQKFEVhT2QkM2/cYMujR9yKjf3X8xrAMzoaj8GD8Shb9l/PLVq0iDFjxvD999/Trl07K6YWtk4DyZ8M/IKHhwePHz+2QhzTLsfEUCcsjNuxsekuCFwATxcXdvn4cDMkhO7du6PRaFiyZAkNGjQwZ1yLqF+/Pp6enhiSOZpZCJF5hUZF0fv0aY4+fZrixGpNYiKKkxNt8uXj11KlOH/gAI0aNaJHjx7Mnj1bzhxwMJ6enkRFRSX7vF0ME7xQNEsWQnx9qe7pma7Xa4Cy2bMT4utL+ezZeeuttzh8+DDly5enUaNGfPvttyTY8G6E9+/fZ/fu3TJEIISDSVQURkdEUDM0lBN/75uS0pJr5e85RcH37lE6JIQWP/xA7dq1mTFjhhQC4j/sqhgAeD1LFnb7+DCpRAmy/b07ocl/1oqCBnDXaBhdrBhh1apR6qVNhry8vNi4cSNff/01o0ePpkmTJty6dcvC30X6rFu3jsTERAIDA9WOIoSwkkRF4f0zZ/jm8mUSSeWhbS+JB54kJvLk888JmjULNzc3C6QU9s6uhgle9SQ+nsV37jD35k0OP3lC7CuVsiYxkWy3b/Nd3br08vIit6uryfa2bdtGt27dUBSFJUuW0DAdKxQsqVOnTly6dIkDBw6oHUUIYSXDL15k3JUrZmlLA+grViQwXz6ztCfsR0rDBHZdDLwsLjGRU8+ecS8ujkRFIa+rK1vnzWP44ME8evQo1Udx3r59mx49erBlyxZGjRrFyJEjbWIzjtjYWPLly8fgwYMZMWKE2nGEEFawLzKSOuHhSf+QPnwYBg1K+oXTp0P58v95WAPkcXHhTK1a5E3hw5HIXFIqBuxmNUFKXJ2cqJwjx78ec6pfny+ePyckJISAgIBUtVOgQAHWr1/PuHHjGD16NDt37mTJkiUm9/a2hh07dhAVFSUHEwnhIBIVhV6nT+NECkMD7drBK6sGKFw4yUsV4FF8PIMvXGDOq68RDs3u5gykRaVKlcidOzfbt29P0+ucnZ0ZOXIkW7Zs4dSpU1SpUoXNmzdbJmQq6fV6ihQpQuXKlVXNIYSwjg0PHnAuOjrlOQKVK0Pjxv/+ypkz2csTgIW3b3P3lSWJwrFl6mLAycmJ+vXrp7kYeCEgIIDDhw9TpUoVmjRpwtdff63KagNFUdDr9bRu3VpmAQvhIKZfv576rttnzyANP5sSFYW5NjpRWqgjUxcDYHxDDwkJISYmJl2vfzFsMGbMGL777jsaNWrEzZs3zZzStGPHjnHlyhUZIhDCQSQoClsePUrdfio//AAtW0KTJsY5BGfOpPgSBdj04EFGY4pMxCGKged/zxtILycnJ4YPH87WrVs5e/YsVatWZdOmTWZMaZper8fDw4P69etb7Z5CCPWcffaMmMRE0xe5uEC9evDxx/Ddd/Dee3DxIgwYAOfOmXypAhyMikJJ6Xh44TAyfTFQqVIl8uTJk+6hgpfVr1+fw4cP4+PjQ9OmTRk5ciTx8RndHDller2eZs2a4e7ubvF7CSHUdy46OuWLKlaEb76BFi2Mp7N26wa//goaDfz+e4ovf5yQwAMr/PwS9iHTFwMZnTfwqvz587N27VrGjh3LuHHjaNSoETdu3DBL20m5efMmBw8elCECIRzI85R6BZJTuLCxMDh8OFVzCNJ9H5HpZPpiAIxDBfv27SM6NdV2Kjg5OTFs2DC2b9/O+fPnqVq1Khs2bDBL268KDg7GycmJFi1aWKR9IYTtyZKR48nz54e4OEjFPKkM3UdkKg7xLyEgIIDY2NgMzRtIyptvvkl4eDjVqlWjWbNmDB8+3OzDBnq9nrp165I3b16ztiuEsF2lX9oyPc1u3gQ3N8ia1eRluVxcyO2SabaaERnkEMVAxYoVzTZv4FX58+dnzZo1fP/99/zwww80bNiQ69evm6XtZ8+esXnzZhkiEMLBlMqalWwpfWp/9Oi/j50/D3v3QvXqYOL1GqCmh4csVRb/cIiy0NzzBpJqf8iQIdSpU4cuXbpQtWpVFi1aRLNmzTLU7ubNm4mJiZFTCoVwME4aDU3y5CH4/v3kTyf89ltjD0DFipArF1y+DMHB4O4OffqkeI+mefKYN7Swaw7RMwD/32/AXPMGklK3bl0OHz5MzZo1ad68OcOGDcvQsIFer6dMmTKULl3ajCmFEPag7r17po8prlMHIiNhxQqYPBm2bYM334TffoOiRU227arR8I7KW6wL2+JQxYAl5g28Kl++fBgMBn744QcmTJhAgwYNuHbtWprbSUxMJDg4WIYIhHAwe/fu5a233uKLhg3JcvMmTskVBO3bw4wZsHo1bN4MK1fCV18ley7BC85A74IFySMHFYmXOEwxULFiRfLmzWuxoYKXOTk5MXjwYHbs2MGlS5eoWrUq69atS1MbBw8e5Pbt2zJEIISDOHDgAM2aNaNOnTrcu3cPnVbLrpYtjfsGmIkTkN/Nje+LFzdbmyJzcJhiwNLzBpJSp04dDh8+jJ+fHy1atGDo0KHExcWl6rV6vZ68efPi7+9v4ZRCCDWFh4fTqlUratWqxdWrV1mxYgXh4eEEBQVR3dOTb4oVM+v9FpYtS05ZRSBe4TDFAFhn3sCr8ubNi16vZ8KECUycOJGAgACuXr2a4uv0ej0tWrTARf6nFSJTOnbsGO3atcPX15ezZ8+yePFijh49SocOHXB6aSXA8KJF+TiFrv+UaDD+sF9YrhyNZeKgSILDFQOxsbHs27fPqvd1cnLiiy++YNeuXVy9epWqVauyZs2aZK+PiIjg+PHjMkQgRCZ08uRJOnfuTOXKlTly5AgLFizgxIkTdOvWDWdn5/9cr9FomFKyJBOKF8dFo+G/V5jmDORxccFQqRLdCxQwy/cgMh+HKgYqVKhgtXkDSfH39+fw4cPUqVOHwMBABg8enOSwgcFgwM3NjaZNm6qQUghhCefOnaNHjx5UrFiR/fv3M3v2bE6fPs3bb7+dYg+gRqPhiyJFOFK9Ov6engC4pDCXwOnvr+4FCnCmVi1ayMZlwgQNxgOsTPLw8ODx48dWiGN57du35+7du+zcuVO1DIqi8PPPPzNkyBBq1KjB0qVLKVKkyD/PN2rUCGdnZ4ttcSyEsJ6LFy8yZswYFi1ahJeXFyNGjKB37964ubmlu83DUVHMunmTzQ8fcj46+l8/xF01Gipmz07rvHn5oFAhCssBZwLw9PQkKioq2ecdrhiYOnUqX3zxBQ8fPiRbRrb8NIOQkBA6d+5MVFQUCxYsoFWrVkRGRpIvXz4mT55M//79Vc0nhEi/y5cvM3bsWObNm0e+fPn46quv+OCDD8iSJYtZ7/MkPp7Lz58Tm5hINmdnimfJgqucOSBekVIx4HCz017eb6Bhw4aqZvHz8yM8PJx3332X1q1b8/nnn+Pj40N8fLzsLyCEnbp+/Trjxo3j999/J1euXPzwww98+OGHFvvwkcPFhQoy0VhkkMP9C6pQoQL58uVj+/btqhcDAHny5EGn0zF58mQGDx5Mzpw5KVeu3L+GDYQQtu/WrVt8//33zJw5k+zZszNmzBj69+9Pjhw51I4mRIocri/pxX4D27ZtUzvKPzQaDYMGDWL79u08ePCAiIgI9Hq92rGEEKlw9+5dvvzyS4oXL86CBQsYMWIEERERDBkyRAoBYTccrhgA41DB/v37efbsmdpR/iUuLg5FUahVqxZBQUF8/vnnxMbGqh1LCJGE+/fv89VXX+Ht7c1vv/3Gl19+SUREBCNGjMDz7xn/QtgLhy0G4uLirL7fQEr0ej0FCxZky5YtTJ48malTp/Lmm29y6dIltaMJIf726NEjvv76a7y9vZkyZQoDBgwgIiKCb775hly5cqkdT4h0cchioHz58v/MG7AViqKg1+tp1aoVzs7ODBw4kD179nDnzh18fHxYvXq12hGFcGiPHz/mu+++w9vbmwkTJtC3b18uXrzIuHHjyCtr+IWdc8hiQI1zClJy+vRpLly48K9dB2vUqEF4eDgNGjSgTZs2DBo0SIYNhLCyp0+f8sMPP+Dt7c13331Hr169uHjxIhMmTOC1115TO54QZuGQxQDY3rwBvV5P1qxZ/7PCIVeuXPz111/88ssvTJ8+nbp16xIREaFSSiEcR3R0NJMmTcLb25uRI0fSpUsXzp8/z+TJk/Hy8lI7nhBm5bDFQIMGDWxq3oDBYKBJkyZkzZr1P89pNBoGDBjAnj17uHfvHj4+Pmi1WhVSCpH5xcTEMHXqVIoXL86QIUNo06YN586dY/r06bz++utqxxPCIhy2GLCleQN3795l7969KR5MVKNGDcLCwmjUqBHt2rVj4MCBPH/+3EophcjcYmNjmTlzJqVKleLTTz+lWbNmnDlzhlmzZlG0aFG14wlhUQ5bDGg0GgICAmxiv4EXJxi2bNkyxWtz5crFihUrmDZtGjNnzqROnTpcvHjR0hGFyLTi4uKYM2cOpUuXpl+/ftSvX59Tp04xb948ihcvrnY8IazCYYsBMM4bOHDgAE+fPlU1h8FgoFatWhRI5fGiGo2G/v37s3fvXh4+fIiPjw9//fWXhVMKkbnEx8ezcOFCypUrx/vvv0+tWrU4fvw4f/zxB6VLl1Y7nhBW5fDFgNrzBmJiYtiwYUOKQwRJqVatGmFhYTRt2pQOHTrwySefyLCBEClISEjgzz//pGLFivTq1YvKlStz5MgRli1bRvny5dWOJ4QqHLoYsIV5A9u2bePp06fpPpgoZ86cLFu2jOnTpzNr1izq1KnDhQsXzJxSCPuXmJjIypUrqVy5Mt26daNUqVKEhoayatUqKleurHY8IVTl0MXAi3kDahYDBoMBb29vKlSokO42NBoN/fr1Y9++fTx69AhfX19WrlxpxpRC2C9FUVi9ejW+vr507NiRN954g5CQEAwGA76+vmrHE8ImOHQxAOrOG3ix62Dr1q3RaDQZbs/X15ewsDCaNWtGx44d+fjjj4mJiTFDUiHsj6IorF27lho1atCmTRvy5s3L7t27Wb9+PbVq1VI7nhA2xeGLATX3GwgPD+f69evpHiJIiqenJ0uXLmXGjBnMnj2b2rVrc/78ebO1L4StUxSFTZs2Ubt2bVq2bEnWrFnZtm0bW7ZsoU6dOmrHE8ImOXwxUK5cOfLnz6/KUIHBYCBnzpzUq1fPrO1qNBo+/PBD9u3bR1RUFL6+vixfvtys9xDCFm3bto169erRpEkTFEVh48aN7Ny5k4CAALWjCWHTHL4YUHO/Ab1eT/PmzXF1dbVI+z4+PoSGhtKiRQs6d+5Mv379ZNhAZEp79uyhYcOGNGzYkOjoaNasWcO+ffto3LixWYbghMjsHL4YAHXmDVy7do2wsDCzDhEkxdPTkz///JOZM2cyd+5c/P39OXfunEXvKYS17N+/n6ZNm1K3bl0ePHiATqfj4MGDtGjRQooAIdJAigGMxUB8fDx79+612j2Dg4NxdnamefPmFr+XRqOhb9++hISE8PTpU3x9fVm6dKnF7yuEpYSGhhIYGIifnx/Xr19n5cqVhIWFERQUJEWAEOkgxQDqzBvQ6/XUq1eP3LlzW+2eVatWJTQ0lFatWtG1a1c+/PBDoqOjrXZ/ITLq6NGjtG3blurVq3Pu3DmWLFnCkSNHaN++PU5O8uNMiPSS/3uw/n4DT548YcuWLRYfIkiKh4cHixcvZtasWSxYsAB/f3/Onj1r9RxCpMXJkyfp1KkTVapU4ejRoyxYsIATJ07QtWtXnJ2d1Y4nhN2TYuBv1pw3sGnTJmJjY9O1BbE5aDQaPvjgA/bv3090dDTVqlXjzz//VCWLEKacPXuW7t27U7FiRQ4cOMCcOXM4ffo0b7/9Ni4uLmrHEyLTkGLgbw0aNLDavAG9Xk/58uUpUaKExe9lSuXKlTl06BBBQUF069aNvn37yrCBsAkXLlzgnXfeoVy5cuzcuZMZM2Zw9uxZevfubbHVN0I4MikG/la2bFlee+01iw8VJCQkEBwcrMoQQVI8PDxYtGgRs2fPZuHChfj5+XHmzBm1YwkHdfnyZT744APKlCnDxo0b+eWXXzh37hx9+/bFzc1N7XhCZFpSDPzNWvsN7N+/n3v37qk2RJAUjUbDe++9x4EDB4iNjaVatWosXrxY7VjCgVy7do1+/fpRqlQp9Ho9EyZM4MKFC3z88cdkyZJF7XhCZHpSDLwkICCAgwcP8uTJE4vdQ6/Xkz9/fpvcG71SpUocPHiQtm3b0qNHDz744AMZNhAWdfPmTQYOHEjJkiVZtmwZY8aM4eLFiwwaNIisWbOqHU8IhyHFwEussd+AXq+nZcuWNjsDOkeOHCxcuJA5c+awePFiatWqxenTp9WOJTKZO3fu8MUXX1CiRAkWLlzIyJEjiYiIYMiQIWTPnl3teEI4HCkGXmLpeQPnz5/n1KlTNjVEkBSNRkPv3r05cOAAcXFxVK9enT/++EPtWCITuH//PsOGDaN48eL8/vvvDB48mIiICIYPH46np6fa8YRwWFIMvMTS+w0YDAbc3d1p3LixRdo3t4oVK3Lw4EHat29Pz549ee+993j27JnasYQdevToEaNGjcLb25upU6cycOBAIiIiGD16NLly5VI7nhAOT4qBV1hy3oBer6dhw4bkyJHD7G1bSo4cOViwYAHz5s3jzz//pGbNmpw8eVLtWMJOPH78mDFjxlCsWDEmTpzIhx9+SEREBGPHjiVPnjxqxxNC/E2KgVdYar+Bhw8fsmvXLpsfIkjOO++8w8GDB0lMTKRGjRosXLhQ7UjChj158oTvv/8eb29vxo4dy7vvvsvFixf58ccfyZ8/v9rxhBCvkGLgFWXKlKFAgQJmX2K4bt06EhISCAwMNGu71lShQgUOHjxIp06d6NWrF++++65VT3oUtu/Zs2dMnDgRb29vRo0aRdeuXblw4QI///wzXl5eascTQiRDioFXWGregF6vx9fXl9dff92s7Vpb9uzZmTdvHvPnz2f58uUybCAAiImJYcqUKZQoUYJhw4bRrl07zp8/z7Rp0yhcuLDa8YQQKZBiIAnmnjcQGxvL+vXr7XaIICm9evXi4MGDaDQaatSowfz589WOJFTw/PlzZsyYQcmSJfnss89o3rw5Z86c4bfffqNIkSJqxxNCpJIUA0kICAggISGBPXv2mKW9Xbt2ERkZmamKAYDy5ctz4MABunTpwrvvvss777wjwwYOIi4ujtmzZ1O6dGn69+9PgwYNOHXqFHPnzqV48eJqxxNCpJEUA0l4MW/AXEMFer2e119/napVq5qlPVuSLVs25syZw8KFC1mxYgU1atTgxIkTascSFhIfH8/8+fMpU6YMH3zwAf7+/pw4cYJFixZRqlQpteMJIdJJioEkmHPegKIoGAwGWrVqhUajyXg4G9WzZ08OHTqEs7MzNWrUYN68eSiKonYsYSYJCQksXryY8uXL8+677+Lj48PRo0dZunQp5cqVUzueECKDpBhIhrnmDZw4cYKIiIhMN0SQlHLlyrF//366d+9O79696dWrl0XPeRCWl5iYyIoVK6hcuTI9evSgbNmyhIWF8ddff1GpUiW14wkhzESKgWQ0aNDALPMG9Ho92bNnJyAgwDzBbFy2bNn4/fffWbRoEatWraJGjRocP35c7VgijRRFQafT4ePjQ6dOnShSpAj79+9Hr9fj4+OjdjwhhJlJMZCM0qVL4+XlleH9BgwGA02bNnW4Y1h79OjBoUOHcHV1pUaNGsyZM0eGDeyAoiisWbOG6tWr07ZtW/Lnz8/u3btZt24dNWvWVDueEMJCpBhIhjnmDdy6dYv9+/c7xBBBUsqWLcv+/fvp2bMn77//Pj179pRhAxulKAobNmzAz8+PwMBAsmfPzvbt29m8eTN16tRRO54QwsKkGDAhICCAQ4cOERUVla7Xr1mzBoAWLVqYM5ZdyZo1K7NmzWLx4sWsXr2a6tWrc/ToUbVjiZds3bqVN998k2bNmuHk5MSmTZvYsWMH9evXVzuaEMJKpBgwIaP7DRgMBmrXri17sQPdunXj0KFDuLu7U6tWLX7//XcZNlDZ7t27adCgAW+99RbPnz9n7dq17N27l0aNGmXqlS9CiP+SYsCEF/MG0jNUEB0dzcaNGx12iCApZcqUISQkhF69etGnTx969OiR7l4XkX4hISE0adKEN998k4cPH7J69WoOHDhA8+bNpQgQwkFJMWBCRuYNbNmyhejoaFq1amX+YHYsa9aszJw5kz///BO9Xk/16tU5cuSI2rEcwqFDh2jZsiX+/v7cuHGDlStXEhYWRuvWraUIEMLBSTGQgvTOGzAYDJQsWZKyZctaKJl969KlC2FhYWTNmpVatWoxa9YsGTawkCNHjtCmTRtq1KjBxYsXWbp0KUePHqV9+/Y4OcmPACGEFAMpSs9+A4mJiRgMBvnElYJSpUoREhJC79696du3L926dePx48dqx8o0Tpw4QceOHalatSrHjx9n4cKFHD9+nM6dO0sRIIT4F/mJkIJSpUpRsGDBNO03EBoays2bN2WIIBWyZMnCr7/+yrJly/5Z33748GG1Y9m1M2fO0K1bNypVqsShQ4eYM2cOp0+fpmfPnjg7O6sdTwhhg6QYSEF65g3o9Xpy584t67PToFOnToSFhZEjRw78/PyYOXOmDBuk0fnz5+nVqxfly5dn9+7dzJw5kzNnztC7d29cXFzUjieEsGFSDKRCQEAAoaGhqe7CNhgMtGjRAldXVwsny1xKlizJ3r17ee+99/joo4/o0qWLDBukwqVLl3j//fcpW7YsmzZtYsqUKZw7d44+ffrg5uamdjwhhB2QYiAV0rLfwOXLlzly5IgMEaRTlixZmD59OsuXL2fdunX4+voSHh6udiybdPXqVT766CNKly6NwWBg4sSJXLhwgf79++Pu7q52PCGEHZFiIBVezBtIzVCBwWDAxcWFZs2aWT5YJtaxY0fCwsLImTMnfn5+/PrrrzJs8LebN28yYMAASpYsyYoVK/juu++4ePEin376KVmzZlU7nhDCDkkxkAppmTdgMBgICAggZ86clg+Wyb0YNujTpw/9+/enU6dOREZGqh1LNXfu3OGzzz6jePHiLFq0iFGjRhEREcHgwYPJnj272vGEEHZMioFUatCgQYrzBh4/fsy2bdtkiMCM3N3dmTp1KitWrGDjxo34+voSGhqqdiyrunfvHkOHDsXb25s5c+YwdOhQLl26xPDhw/Hw8FA7nhAiE5BiIJVezBvYvXt3stds2LCBuLg4KQYsoEOHDoSFhZE7d25q167NtGnTMv2wwcOHDxk5ciTe3t5Mnz6dQYMGERERwddffy09T0IIs5JiIJVKlixJoUKFTA4VGAwGKlWqhLe3t/WCOZASJUqwZ88e+vbtyyeffELHjh0z5bBBZGQk3377Ld7e3vz000/069ePiIgIvvvuO/LkyaN2PCFEJiTFQCqlNG8gPj6eNWvWSK+Ahbm7uzNlyhT++usvNm/ejK+vL4cOHVI7llk8efKEcePG4e3tzbhx43j33XeJiIjghx9+IF++fGrHE0JkYlIMpMGL/QbO3b/PjkePWH//PlsfPuRKTAx79uzhwYMHckqhlbRr147w8HDy5s1L7dq1mTp1qt0OGzx79owJEybg7e3NN998Q/fu3bl48SI///wzBQoUUDueEMIByLZkqRQaFcXGKlVIXLGC0seO/ed597g43MeN40mpUiiKImcSWIG3tze7d+9myJAhDBgwgO3btzNnzhxy5cqldrRUiYmJ4bfffmP8+PHcv3+f9957j6+++ooiRYqoHU0I4WA0QIofpzw8PBx2J7jzz57R+8wZdkVG4qLREG/i06cmMRHFyYkK2bIxv2xZqnt6WjGpY9PpdLz77rvkzp2bZcuWUaNGDbUjJev58+fMnj2bcePGcfv2bXr16sWIESNkrokQwmI8PT1Nnr4rxYAJv924wcBz50hQFOLT8DpnjH+pI4sW5etixaSXwEouXbpE586dCQ8PZ8KECQwYMCB1f/ePH8O6dXDoEISHw4MH4OQEb7wB1aqBvz8EBEAGD/mJi4tj3rx5fPfdd1y/fp3u3bszcuRISpUqlaF2hRAiJVIMpNPYy5cZERGR4Xbe8/Li9zJlpCCwktjYWIYOHcrPP/9MmzZtmDt3Lrlz50764kuX4McfYf58iI4GV1eIi/v/805OoNFAQgIULgyffGL8ypYtTZni4+NZtGgRY8aM4dKlS3Tq1Imvv/6acuXKpfv7FEKItEipGJAJhElYcOuWWQoBgDm3bvHNpUtmaUukzM3NjUmTJqHT6di+fTs+Pj4cOHDg3xclJsKvv0K5cvD778ZCAP5dCLy4LiHB+Pvr1+Grr6BiRUjFGRUACQkJ/PHHH5QrV47evXvj6+vLkSNHWLp0qRQCQgibIsXAK67ExNDv7NnkL4iOhnnzYPBgaN0aGjSA9etNtjnm8mUOOVjPitqCgoIIDw/Hy8uLOnXq8PPPPxtXG8TGQpcu0L8/xMRAfBoGgBIT4coVePNN+O03E5clsmzZMipWrEjPnj0pX748YWFhrFy5kkqVKpnhuxNCCPOSYuAVH587R6ypJWqRkbBwofFNoUSJVLWpAd45fdpul77Zq2LFirFz504GDhzIZ599RrugIJ536AB//ZX+RhMSQFHgww9hzpx/PaUoCqtWraJKlSp06dIFb29vDhw4wOrVq/Hx8cngdyOEEJYjxcBLLkZHE3z/vskVA+TJY3wzWbrU+IaQCgnAiWfP2PHokVlyitRzc3Nj4sSJrF69mnKbN+NuMBg/4ZvDhx/CsWMoioLBYKBatWq0b98eLy8v9uzZw9q1a216VYMQQrwg+wy85PebN3HC+OadLDc3Y0GQRi7ArzduEJDcZDZhUa3LlaNVQvL/ZQ8CC4BtwCUgL+AHfAeUTuY1ChAVFETTvHkJOXSIevXqsX37durXr2/W7EIIYWlSDLxkw4MHpguBDIgHNj98KBsSqWXMGDQmegR+APYAHYHKwC1gGuALhAAVk3iNJj4ez4gI3nJx4bvNm2nYsKH8txVC2CUpBv4Wl5jI8adPLXqPh/HxXHv+nDeyZLHofcQr7t0zDuuYmCz4GbAEcHvpsc5AJeB74I9kXqc4OTGmQAE0b71lrrRCCGF1Mmfgb9eePyfOChP8zr9YxiasR6f777LBV9Tm34UAQCmgAnDKxOs0iYlodu+GGzcyFFEIIdQkPQN/M7mCwIzeat4ct8OHcXNzw9XVFVdX139+b43HMtKOi4uLfXaDHzwILi5pW0aIcU7AbYwFQYoOHTIuNRVCCDskxcDfsjpZp5NkUL9+eD9+TFxcHLGxsf/6NaXHnjx5kqrrXn3enEsazVFcWLsAyn7gAE5pLAQAFgPXgW9TutDFBcLCpBgQQtgtKQb+VtjdnSxOTsSYa9lZMgZ36UIBt1c7pC0rISEhXcVHRh579fnY2FiePn2a5nbi0/Em/qoIoFgaX3Ma6A/4A71SulijgYcP0x5MCCFshBQDf3PWaPDJkYN9FtwpsICrq9ULAQBnZ2ecnZ3JYocTFxVFSVfx8fJj+T7+2DiJMJVuAS2BnMBKjAdPpchKPUtCCGEJUgy8pGXevOx//JgU+wa0Wnjy5P9vMHv3wt27xt+3bQs5cvznJS4aDS3z5jVrXkeg0Whwc3PDzc2N7Nmzp6+RX35JdTEQCTQHHgG7gEKpeVFiIuTPn75sQghhA6QYeMl7Xl58nZoDipYtg9u3///nXbuMXwCNGydZDMQrCv0LFzZTUpEmNWoYJ/ilsKIgBmgFnAU2A+VT235CgvGoYyGEsFNSDLzEy92dnl5eLLp1y/TmQ0uXpqldF6B2zpz4enhkJJ5Ir1q1YMoUk5ckYNxXYB+wGuNcgVTTaKB69XTHE0IItUkx8IqfSpQg+P59HsTFpTxckErOGg1zypQxU2sizYKCIHt2MLGp1OeAHmPPwAP+u8lQj+Re6OICzZuDDAEJIeyYzHp6RR5XVxaWLYs5dx2YUqoUJbNlM2OLIk2yZ4f33gPn5KcCHv77VwPQM4mvZMXHG49DFkIIOybFQBKa583L/LJl0ZDxv6DvvL3pUyhV09CEJX31FXh4GLv0k7Ad4yZDyX0lycUFmjQxfgkhhB2TYiAZb3t5saZSJfK4uqZuadlLXIDsTk7ML1uW4UWLWiKeSKsCBWDGDDDXBkxOTuDuDrNnJ1tgCCGEvZBiwITmefNypmZN3vbywpmU/7KcAQ3QIm9eTtWsSS8vL8uHFKnXpQsMHpzxdpycjF+rVsEbb2S8PSGEUJkGE72gL3h4ePDYgpvx2INbz58z++ZN1j14QNiTJ//aqdBVo6FS9uw0zp2bPoUKUTxrVhWTCpMUBUaOhLFjjW/oad1x0sUFXF2Ne000bWqZjEIIYWaenp5ERUUl+7wUA+mQoChcf/6c6MRE3DUaCru74yo70NmXjRvhnXfg1i3jn1MaPnB2Nu4nUL8+zJ8PxYpZOKAQQphPSsWAvIOlg7NGQ5EsWSiTLRvFsmaVQsAeNWkCZ87Azz+Dt/f/H3d1Nb7xOzsbf/9CvXrGYYGtW6UQEEJkOtIzIISiwJEjxl0KDx+GyEhjMeDlZdxZsFYtKFJE7ZRCCJFuMkwghBBCODgZJhBCCCGESVIMCCGEEA5OigEhhBDCwUkxIIQQQjg4KQaEEEIIByfFgBBCCOHgpBgQQgghHJwUA0IIIYSDk2JACCGEcHBSDAghhBAOTooBIYQQwsFJMSCEEEI4OCkGhBBCCAcnxYAQQgjh4KQYEEIIIRycFANCCCGEg5NiQAghhHBwUgwIIYQQDi5VxYCHh4elcwghhBDCQlJ6H9cASmoaKlSoEFFRUebIJIQQQggr8fDw4MaNGyavSXUxIIQQQojMSeYMCCGEEA5OigEhhBDCwUkxIIQQQjg4KQaEEEIIByfFgBBCCOHgpBgQQgghHJwUA0IIIYSD+x8i6lU5l1rYEgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -474,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": 96, + "execution_count": 110, "id": "2115bb6d", "metadata": {}, "outputs": [ @@ -543,7 +553,7 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 111, "id": "b0a1f778", "metadata": {}, "outputs": [], @@ -573,7 +583,7 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 112, "id": "f9f5ce41", "metadata": {}, "outputs": [ @@ -593,13 +603,13 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 113, "id": "35dea0fb", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -627,13 +637,13 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 114, "id": "22db40be", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -659,7 +669,7 @@ " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", " plt.xlabel(\"Iteration\")\n", - " plt.ylabel(\"Loss\")\n", + " plt.ylabel(\"Cost\")\n", " for index in range(ncircuits):\n", " plt.plot(range(i+1), list_of_loss[index])\n", " legend = ['circuit %d' %leg for leg in range(ncircuits)]\n", @@ -669,7 +679,7 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 115, "id": "d2cf1b57", "metadata": {}, "outputs": [ @@ -678,27 +688,27 @@ "output_type": "stream", "text": [ "Circuit #0\n", - "cost: -17.48183 \n", - "bit strings: ['00010101', '11101010'] \n", + "cost: -15.938664 \n", + "bit strings: ['00110101', '11001010'] \n", "\n", "Circuit #1\n", - "cost: -17.487226 \n", + "cost: -17.461643 \n", "bit strings: ['00010101', '11101010'] \n", "\n", "Circuit #2\n", - "cost: -17.374956 \n", - "bit strings: ['00110101', '11001010'] \n", + "cost: -16.610685 \n", + "bit strings: ['00010101', '11101010'] \n", "\n", "Circuit #3\n", - "cost: -17.486227 \n", + "cost: -16.61402 \n", "bit strings: ['00010101', '11101010'] \n", "\n", "Circuit #4\n", - "cost: -17.480951 \n", + "cost: -14.814039 \n", "bit strings: ['00010101', '11101010'] \n", "\n", "Circuit #5\n", - "cost: -17.452002 \n", + "cost: -14.7950735 \n", "bit strings: ['00010101', '11101010'] \n", "\n" ] @@ -722,7 +732,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 116, "id": "492d215f", "metadata": {}, "outputs": [ From 325762140bbeb68d41c084045823ff1447b1cf51 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 16 May 2023 10:06:40 +0800 Subject: [PATCH 450/725] black tutorial --- docs/source/tutorials/qaoa.ipynb | 77 +++++++++++++++++--------------- 1 file changed, 41 insertions(+), 36 deletions(-) diff --git a/docs/source/tutorials/qaoa.ipynb b/docs/source/tutorials/qaoa.ipynb index 5b9f2d7c..2e1f44ee 100644 --- a/docs/source/tutorials/qaoa.ipynb +++ b/docs/source/tutorials/qaoa.ipynb @@ -176,7 +176,7 @@ "\n", "nlayers = 3 # the number of layers\n", "ncircuits = 6 # six circuits with different initial parameters are going to be optimized at the same time\n", - "nnodes = 8 # the number of nodes" + "nnodes = 8 # the number of nodes" ] }, { @@ -229,13 +229,13 @@ " 7: {4: {\"weight\": 1.0}, 6: {\"weight\": 1.0}, 0: {\"weight\": 1.0}},\n", "}\n", "pos = nx.spring_layout(nx.to_networkx_graph(example_graph_dict))\n", - "colors = ['c' for key in example_graph_dict.items()]\n", + "colors = [\"c\" for key in example_graph_dict.items()]\n", "\n", "# convert to a NetworkX graph\n", - "example_graph = nx.to_networkx_graph(example_graph_dict) \n", + "example_graph = nx.to_networkx_graph(example_graph_dict)\n", "nx.draw_networkx(example_graph, with_labels=True, node_color=colors, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ] }, { @@ -259,7 +259,7 @@ " c = tc.Circuit(n)\n", " for i in range(n):\n", " c.H(i)\n", - " \n", + "\n", " # PQC\n", " for j in range(nlayers):\n", " # U_j\n", @@ -273,7 +273,7 @@ " # V_j\n", " for i in range(n):\n", " c.rx(i, theta=params[2 * j + 1])\n", - " \n", + "\n", " # whether to return the circuit\n", " if return_circuit is True:\n", " return c\n", @@ -314,7 +314,9 @@ "outputs": [], "source": [ "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2))" + "QAOA_vvag = K.jit(\n", + " tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2)\n", + ")" ] }, { @@ -352,8 +354,8 @@ " plt.xlabel(\"Iteration\")\n", " plt.ylabel(\"Cost\")\n", " for index in range(ncircuits):\n", - " plt.plot(range(i+1), list_of_loss[index])\n", - " legend = ['circuit %d' %leg for leg in range(ncircuits)]\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [\"circuit %d\" % leg for leg in range(ncircuits)]\n", " plt.legend(legend)\n", " plt.show()" ] @@ -421,12 +423,12 @@ "\n", " # find the states with max probabilities\n", " probs = K.numpy(c.probability()).round(decimals=4)\n", - " index = np.where(probs==max(probs))[0]\n", + " index = np.where(probs == max(probs))[0]\n", " states = []\n", " for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - " print(\"Circuit #%d\" %num_circuit)\n", - " print('cost:', K.numpy(loss), '\\nbit strings:', states, \"\\n\")" + " states.append(f\"{bin(i)[2:]:0>{c._nqubits}}\")\n", + " print(\"Circuit #%d\" % num_circuit)\n", + " print(\"cost:\", K.numpy(loss), \"\\nbit strings:\", states, \"\\n\")" ] }, { @@ -458,10 +460,10 @@ } ], "source": [ - "colors = [\"r\" if states[0][i] == '0' else \"c\" for i in range(nnodes)]\n", + "colors = [\"r\" if states[0][i] == \"0\" else \"c\" for i in range(nnodes)]\n", "nx.draw_networkx(example_graph, with_labels=True, node_color=colors, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ] }, { @@ -501,12 +503,12 @@ "def classical_solver(graph):\n", " num_nodes = len(graph)\n", " max_cut = [0]\n", - " best_case = [0] # \"01\" series with max cut\n", + " best_case = [0] # \"01\" series with max cut\n", " for i in range(2**num_nodes):\n", - " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + " case = f\"{bin(i)[2:]:0>{num_nodes}}\"\n", " cat1, cat2 = [], []\n", " for j in range(num_nodes):\n", - " if str(case)[j] == '0':\n", + " if str(case)[j] == \"0\":\n", " cat1.append(j)\n", " else:\n", " cat2.append(j)\n", @@ -517,18 +519,19 @@ " for node2 in cat2:\n", " if graph[node1].get(node2):\n", " cost += graph[node1][node2][\"weight\"]\n", - " cost = round(cost, 4) # elimate minor error\n", + " cost = round(cost, 4) # elimate minor error\n", " if max_cut[-1] <= cost:\n", " max_cut.append(cost)\n", " best_case.append(case)\n", - " \n", + "\n", " # optimal cases maybe more than 1, but they are all at the end\n", " index = max_cut.index(max_cut[-1])\n", - " \n", + "\n", " return max_cut[-1], best_case[index:]\n", - " \n", + "\n", + "\n", "max_cut, best_case = classical_solver(example_graph_dict)\n", - "print('bit string:', best_case, '\\nmax cut:', max_cut)" + "print(\"bit string:\", best_case, \"\\nmax cut:\", max_cut)" ] }, { @@ -566,10 +569,10 @@ " 4: {7: {\"weight\": 0.9870}, 6: {\"weight\": 0.0480}, 5: {\"weight\": 4.2509}},\n", " 6: {7: {\"weight\": 4.7528}, 4: {\"weight\": 0.0480}, 5: {\"weight\": 2.2879}},\n", " 5: {6: {\"weight\": 2.2879}, 4: {\"weight\": 4.2509}, 2: {\"weight\": 0.1699}},\n", - " 7: {4: {\"weight\": 0.9870}, 6: {\"weight\": 4.7528}, 0: {\"weight\": 2.5664}}, \n", + " 7: {4: {\"weight\": 0.9870}, 6: {\"weight\": 4.7528}, 0: {\"weight\": 2.5664}},\n", "}\n", "\n", - "weighted_graph = nx.to_networkx_graph(weighted_graph_dict) " + "weighted_graph = nx.to_networkx_graph(weighted_graph_dict)" ] }, { @@ -598,7 +601,7 @@ ], "source": [ "max_cut, best_case = classical_solver(weighted_graph_dict)\n", - "print('bit string:', best_case, '\\nmax cut:', max_cut)" + "print(\"bit string:\", best_case, \"\\nmax cut:\", max_cut)" ] }, { @@ -619,11 +622,11 @@ } ], "source": [ - "colors = [\"r\" if best_case[0][i] == '0' else \"c\" for i in range(nnodes)]\n", - "weighted_graph = nx.to_networkx_graph(weighted_graph_dict) \n", + "colors = [\"r\" if best_case[0][i] == \"0\" else \"c\" for i in range(nnodes)]\n", + "weighted_graph = nx.to_networkx_graph(weighted_graph_dict)\n", "nx.draw_networkx(weighted_graph, with_labels=True, node_color=colors, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ] }, { @@ -653,7 +656,9 @@ } ], "source": [ - "QAOA_vvag = K.jit(tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2))\n", + "QAOA_vvag = K.jit(\n", + " tc.backend.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2)\n", + ")\n", "params = K.implicit_randn(\n", " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", ") # initial parameters\n", @@ -671,8 +676,8 @@ " plt.xlabel(\"Iteration\")\n", " plt.ylabel(\"Cost\")\n", " for index in range(ncircuits):\n", - " plt.plot(range(i+1), list_of_loss[index])\n", - " legend = ['circuit %d' %leg for leg in range(ncircuits)]\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [\"circuit %d\" % leg for leg in range(ncircuits)]\n", " plt.legend(legend)\n", " plt.show()" ] @@ -722,12 +727,12 @@ "\n", " # find the states with max probabilities\n", " probs = K.numpy(c.probability()).round(decimals=4)\n", - " index = np.where(probs==max(probs))[0]\n", + " index = np.where(probs == max(probs))[0]\n", " states = []\n", " for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - " print(\"Circuit #%d\" %num_circuit)\n", - " print('cost:', K.numpy(loss), '\\nbit strings:', states, \"\\n\")" + " states.append(f\"{bin(i)[2:]:0>{c._nqubits}}\")\n", + " print(\"Circuit #%d\" % num_circuit)\n", + " print(\"cost:\", K.numpy(loss), \"\\nbit strings:\", states, \"\\n\")" ] }, { From 6aafef029e96e5fb5f07f7ff6238d540067147a0 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 16 May 2023 02:08:50 +0000 Subject: [PATCH 451/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 0795945e..e397d444 100644 --- a/README.md +++ b/README.md @@ -179,6 +179,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. 隐公观鱼
隐公观鱼
💻 ⚠️ WiuYuan
WiuYuan
💡 + Felix Xu
Felix Xu
✅ From bc8180738d07e3b74b8408bcb922ec38a7b7d759 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 16 May 2023 02:08:51 +0000 Subject: [PATCH 452/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 610c8223..a7ad67f2 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -240,6 +240,15 @@ "contributions": [ "example" ] + }, + { + "login": "FelixXu35", + "name": "Felix Xu", + "avatar_url": "https://avatars.githubusercontent.com/u/61252303?v=4", + "profile": "https://www.linkedin.com/in/felix-xu-16a153196/", + "contributions": [ + "tutorial" + ] } ], "contributorsPerLine": 6, From d6939fd89f35f70bf720b8aba70c9cfd3d9dd73b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 17 May 2023 11:09:06 +0800 Subject: [PATCH 453/725] fix plot_histogram kw passing and measure on multiple qubits --- CHANGELOG.md | 8 ++++++ tensorcircuit/abstractcircuit.py | 43 +++++++++++++++------------- tensorcircuit/interfaces/__init__.py | 3 ++ tensorcircuit/interfaces/torch.py | 2 ++ tensorcircuit/results/counts.py | 4 ++- 5 files changed, 39 insertions(+), 21 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d922b381..54dc97dd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ ## Unreleased +### Added + +- `c.measure_instruction(*qubits)` now supports multiple ints specified at the same time + +### Fixed + +- `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method + ## 0.9.1 ### Added diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index b98c892f..1577fcbd 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -602,39 +602,41 @@ def gate_summary(self) -> Dict[str, int]: summary[d["name"]] = summary.get(d["name"], 0) + 1 return summary - def measure_instruction(self, index: int) -> None: + def measure_instruction(self, *index: int) -> None: """ add a measurement instruction flag, no effect on numerical simulation - :param index: the corresponding qubit + :param index: the corresponding qubits :type index: int """ l = len(self._qir) - d = { - "index": [index], - "name": "measure", - "gatef": "measure", - "instruction": True, - "pos": l, - } - self._extra_qir.append(d) + for ind in index: + d = { + "index": [ind], + "name": "measure", + "gatef": "measure", + "instruction": True, + "pos": l, + } + self._extra_qir.append(d) - def reset_instruction(self, index: int) -> None: + def reset_instruction(self, *index: int) -> None: """ add a reset instruction flag, no effect on numerical simulation - :param index: the corresponding qubit + :param index: the corresponding qubits :type index: int """ l = len(self._qir) - d = { - "index": [index], - "name": "reset", - "gatef": "reset", - "instruction": True, - "pos": l, - } - self._extra_qir.append(d) + for ind in index: + d = { + "index": [ind], + "name": "reset", + "gatef": "reset", + "instruction": True, + "pos": l, + } + self._extra_qir.append(d) def barrier_instruction(self, *index: List[int]) -> None: """ @@ -752,6 +754,7 @@ def draw(self, **kws: Any) -> Any: Visualise the circuit. This method recevies the keywords as same as qiskit.circuit.QuantumCircuit.draw. More details can be found here: https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.draw.html. + Interesting kws options include: ``idle_wires``(bool) :Example: >>> c = tc.Circuit(3) diff --git a/tensorcircuit/interfaces/__init__.py b/tensorcircuit/interfaces/__init__.py index f257d387..1f8cc608 100644 --- a/tensorcircuit/interfaces/__init__.py +++ b/tensorcircuit/interfaces/__init__.py @@ -14,3 +14,6 @@ from .scipy import scipy_interface, scipy_optimize_interface from .torch import torch_interface, pytorch_interface, torch_interface_kws from .tensorflow import tensorflow_interface, tf_interface + + +# TODO(@refraction-ray): jax interface using puer_callback and custom_vjp diff --git a/tensorcircuit/interfaces/torch.py b/tensorcircuit/interfaces/torch.py index e346b757..8fcdb2e2 100644 --- a/tensorcircuit/interfaces/torch.py +++ b/tensorcircuit/interfaces/torch.py @@ -12,6 +12,8 @@ Tensor = Any +# TODO(@refraction-ray): new paradigm compatible with torch functional trasnformation + def torch_interface( fun: Callable[..., Any], jit: bool = False, enable_dlpack: bool = False diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index 78695734..37d5a9d7 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -109,6 +109,8 @@ def plot_histogram(data: Any, **kws: Any) -> Any: See ``qiskit.visualization.plot_histogram``: https://qiskit.org/documentation/stubs/qiskit.visualization.plot_histogram.html + interesting kw options include: ``number_to_keep`` (int) + :param data: _description_ :type data: Any :return: _description_ @@ -116,4 +118,4 @@ def plot_histogram(data: Any, **kws: Any) -> Any: """ from qiskit.visualization import plot_histogram - return plot_histogram(data) + return plot_histogram(data, **kws) From fa8887f9d12a6175af87091a60d7bba6d4232e29 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 17 May 2023 19:35:29 +0800 Subject: [PATCH 454/725] new impl for adjoint --- CHANGELOG.md | 4 +++ tensorcircuit/abstractcircuit.py | 57 ++++++++++++++++++++++++++++---- tensorcircuit/cloud/wrapper.py | 4 +-- tests/test_circuit.py | 19 +++++++++++ 4 files changed, 76 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 54dc97dd..f17b60d6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,10 @@ - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method +- New implementation for `c.inverse()` to partially avoid unrecognized gate name issue + +- Fixed bug for `batch_expectation_ps` for jax backend + ## 0.9.1 ### Added diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 1577fcbd..4ea4a8be 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -406,13 +406,58 @@ def inverse( c = type(self)(**circuit_params) for d in reversed(self._qir): if "parameters" not in d: - self.apply_general_gate_delayed( - d["gatef"].adjoint(), d["name"], mpo=d["mpo"] - )(c, *d["index"], split=d["split"]) + if d["gatef"].n in self.sgates and d["gatef"].n not in [ + "wroot", + "sd", + "td", + ]: + self.apply_general_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], split=d["split"]) + elif d["gatef"].n in ["sd", "td"]: + self.apply_general_gate_delayed( + getattr(gates, d["gatef"].n[:-1]), d["name"], mpo=d["mpo"] + )(c, *d["index"], split=d["split"]) + else: + self.apply_general_gate_delayed( + d["gatef"].adjoint(), d["name"], mpo=d["mpo"] + )(c, *d["index"], split=d["split"]) else: - self.apply_general_variable_gate_delayed( - d["gatef"].adjoint(), d["name"], mpo=d["mpo"] - )(c, *d["index"], **d["parameters"], split=d["split"]) + if d["gatef"].n in ["r", "cr"]: + params = {k: v for k, v in d["parameters"].items()} + if "theta" in params: + params["theta"] = -params.get("theta", 0.0) + self.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], **params, split=d["split"]) + elif d["gatef"].n in ["u", "cu"]: + params = {k: v for k, v in d["parameters"].items()} + # deepcopy fail with tf+jit + params["lbd"] = -d["parameters"].get("phi", 0) + np.pi + params["phi"] = -d["parameters"].get("lbd", 0) + np.pi + self.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], **params, split=d["split"]) + elif d["gatef"].n in self.vgates and d["gatef"].n not in [ + "any", + "exp", + "exp1", + ]: + params = {k: v for k, v in d["parameters"].items()} + df = 0.0 + if d["gatef"].n == "iswap": + df = 1.0 + params["theta"] = -params.get("theta", df) + self.apply_general_variable_gate_delayed( + d["gatef"], d["name"], mpo=d["mpo"] + )(c, *d["index"], **params, split=d["split"]) + + # TODO(@refraction-ray): multi control gate? + + else: + self.apply_general_variable_gate_delayed( + d["gatef"].adjoint(), d["name"], mpo=d["mpo"] + )(c, *d["index"], **d["parameters"], split=d["split"]) return c diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 85d35e9a..7d8d5c53 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -302,6 +302,6 @@ def batch_expectation_ps( counts.expectation(raw_counts[i], exps[i]) for i in range(len(raw_counts)) ] if ws is not None: - sumr = backend.sum([w * r for w, r in zip(ws, results)]) - return sumr + sumr = sum([w * r for w, r in zip(ws, results)]) + return backend.convert_to_tensor(sumr) return backend.stack(results) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 14c7784f..7acba289 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1303,6 +1303,25 @@ def test_circuit_inverse(backend): np.testing.assert_allclose(c.state(), inputs, atol=1e-5) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_circuit_inverse_2(backend): + inputs = np.random.uniform(size=[8]) + inputs /= np.linalg.norm(inputs) + c = tc.Circuit(3, inputs=inputs) + c.iswap(0, 1) + c.iswap(1, 0, theta=0.6) + c.rxx(1, 2, theta=-0.2) + c.cu(0, 1, lbd=2.0, theta=-0.7) + c.r(2, alpha=0.3) + c.sd(2) + c.cx(1, 2) + c.unitary(0, unitary=tc.gates._x_matrix) + c1 = c.inverse() + c.append(c1) + print(c.draw()) + np.testing.assert_allclose(c.state(), inputs, atol=1e-5) + + @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_jittable_amplitude(backend): # @tc.backend.jit From 4f5730459eb0ecb696dcd01473f8c5cbfa4db2a7 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 18 May 2023 13:59:26 +0800 Subject: [PATCH 455/725] add ps for expectation_ps --- CHANGELOG.md | 2 ++ tensorcircuit/abstractcircuit.py | 13 +++++++++++++ tests/test_backends.py | 8 ++++++++ tests/test_circuit.py | 4 ++++ 4 files changed, 27 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index f17b60d6..12892c8c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - `c.measure_instruction(*qubits)` now supports multiple ints specified at the same time +- `c.expectation_ps()` now also supports `ps` argument directly (pauli structures) + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 4ea4a8be..27d9a1cd 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -1160,6 +1160,7 @@ def expectation_ps( x: Optional[Sequence[int]] = None, y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, + ps: Optional[Sequence[int]] = None, reuse: bool = True, noise_conf: Optional[Any] = None, nmc: int = 1000, @@ -1198,6 +1199,10 @@ def expectation_ps( :type y: Optional[Sequence[int]], optional :param z: sites to apply Z gate, defaults to None :type z: Optional[Sequence[int]], optional + :param ps: or one can apply a ps structures instead of ``x``, ``y``, ``z``, + e.g. [0, 1, 3, 0, 2, 2] for X_1Z_2Y_4Y_5 + defaults to None, ``ps`` can overwrite ``x``, ``y`` and ``z`` + :type ps: Optional[Sequence[int]], optional :param reuse: whether to cache and reuse the wavefunction, defaults to True :type reuse: bool, optional :param noise_conf: Noise Configuration, defaults to None @@ -1211,6 +1216,14 @@ def expectation_ps( :rtype: Tensor """ obs = [] + if ps is not None: + from .quantum import ps2xyz + + d = ps2xyz(ps) # type: ignore + x = d.get("x", None) + y = d.get("y", None) + z = d.get("z", None) + if x is not None: for i in x: obs.append([gates.x(), [i]]) # type: ignore diff --git a/tests/test_backends.py b/tests/test_backends.py index f63de48d..6e387eb2 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -302,6 +302,14 @@ def test_backend_methods_2(backend): ) +# @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("torchb")]) +# def test_backend_array(backend): +# a = tc.backend.array([[0, 1], [1, 0]]) +# assert tc.interfaces.which_backend(a).name == tc.backend.name +# a = tc.backend.array([[0, 1], [1, 0]], dtype=tc.rdtypestr) +# assert tc.dtype(a) == "float32" + + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("torchb")]) def test_device_cpu_only(backend): a = tc.backend.ones([]) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 7acba289..e91eeca6 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -422,6 +422,10 @@ def test_expectation_ps(backend): c.H(0) r = c.expectation_ps(z=[1], x=[0]) np.testing.assert_allclose(tc.backend.numpy(r), 1, atol=1e-5) + r1 = c.expectation_ps(ps=[1, 3]) + np.testing.assert_allclose(tc.backend.numpy(r1), 1, atol=1e-5) + r1 = c.expectation_ps(z=[1, 2], ps=[1, 3]) + np.testing.assert_allclose(tc.backend.numpy(r1), 1, atol=1e-5) def test_probability(): From 303b2386aadffcabe1f122fae4a6ac3adc5b4867 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 19 May 2023 19:35:59 +0800 Subject: [PATCH 456/725] tf backend svd stability with mps circuit --- CHANGELOG.md | 2 + tensorcircuit/backends/tensorflow_backend.py | 116 +++++++++++++++++++ tensorcircuit/mps_base.py | 2 +- tensorcircuit/mpscircuit.py | 4 + 4 files changed, 123 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 12892c8c..ffab0545 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,8 @@ - Fixed bug for `batch_expectation_ps` for jax backend +- Partially fix the SVD numerical stability bug on tf backend when using `MPSCircuit` + ## 0.9.1 ### Added diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index a77ea1d7..fbef6638 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -3,6 +3,7 @@ """ # pylint: disable=invalid-name +import os from functools import reduce, partial from operator import mul from typing import Any, Callable, Optional, Sequence, Tuple, Union @@ -225,6 +226,120 @@ def _rq_tf( return r, q +def _svd_tf( + self: Any, + tensor: Tensor, + pivot_axis: int, + max_singular_values: Optional[int] = None, + max_truncation_error: Optional[float] = None, + relative: Optional[bool] = False, +) -> Tuple[Tensor, Tensor, Tensor, Tensor]: + """Computes the singular value decomposition (SVD) of a tensor. + + The SVD is performed by treating the tensor as a matrix, with an effective + left (row) index resulting from combining the axes `tensor.shape[:pivot_axis]` + and an effective right (column) index resulting from combining the axes + `tensor.shape[pivot_axis:]`. + + For example, if `tensor` had a shape (2, 3, 4, 5) and `pivot_axis` was 2, then + `u` would have shape (2, 3, 6), `s` would have shape (6), and `vh` would + have shape (6, 4, 5). + + If `max_singular_values` is set to an integer, the SVD is truncated to keep + at most this many singular values. + + If `max_truncation_error > 0`, as many singular values will be truncated as + possible, so that the truncation error (the norm of discarded singular + values) is at most `max_truncation_error`. + If `relative` is set `True` then `max_truncation_err` is understood + relative to the largest singular value. + + If both `max_singular_values` snd `max_truncation_error` are specified, the + number of retained singular values will be + `min(max_singular_values, nsv_auto_trunc)`, where `nsv_auto_trunc` is the + number of singular values that must be kept to maintain a truncation error + smaller than `max_truncation_error`. + + The output consists of three tensors `u, s, vh` such that: + ```python + u[i1,...,iN, j] * s[j] * vh[j, k1,...,kM] == tensor[i1,...,iN, k1,...,kM] + ``` + Note that the output ordering matches numpy.linalg.svd rather than tf.svd. + + Args: + tf: The tensorflow module. + tensor: A tensor to be decomposed. + pivot_axis: Where to split the tensor's axes before flattening into a + matrix. + max_singular_values: The number of singular values to keep, or `None` to + keep them all. + max_truncation_error: The maximum allowed truncation error or `None` to not + do any truncation. + relative: Multiply `max_truncation_err` with the largest singular value. + + Returns: + u: Left tensor factor. + s: Vector of ordered singular values from largest to smallest. + vh: Right tensor factor. + s_rest: Vector of discarded singular values (length zero if no + truncation). + """ + left_dims = tf.shape(tensor)[:pivot_axis] + right_dims = tf.shape(tensor)[pivot_axis:] + + tensor = tf.reshape(tensor, [tf.reduce_prod(left_dims), tf.reduce_prod(right_dims)]) + + eps = os.environ.get("TC_BACKENDS_TENSORFLOW_BACKEND__SVD_TF_EPS") + if eps is not None: + eps = 10 ** (-int(eps)) + tensor += eps * tf.ones(tensor.shape, dtype=tensor.dtype) + # for numerical stability at least in tf+cpu + s, u, v = tf.linalg.svd(tensor) + + if max_singular_values is None: + max_singular_values = tf.size(s, out_type=tf.int64) + else: + max_singular_values = tf.constant(max_singular_values, dtype=tf.int64) + + if max_truncation_error is not None: + # Cumulative norms of singular values in ascending order. + trunc_errs = tf.sqrt(tf.cumsum(tf.square(s), reverse=True)) + # If relative is true, rescale max_truncation error with the largest + # singular value to yield the absolute maximal truncation error. + if relative: + abs_max_truncation_error = max_truncation_error * s[0] + else: + abs_max_truncation_error = max_truncation_error + # We must keep at least this many singular values to ensure the + # truncation error is <= abs_max_truncation_error. + num_sing_vals_err = tf.math.count_nonzero( + tf.cast(trunc_errs > abs_max_truncation_error, dtype=tf.int32) + ) + else: + num_sing_vals_err = max_singular_values + + num_sing_vals_keep = tf.minimum(max_singular_values, num_sing_vals_err) + + # tf.svd() always returns the singular values as a vector of float{32,64}. + # since tf.math_ops.real is automatically applied to s. This causes + # s to possibly not be the same dtype as the original tensor, which can cause + # issues for later contractions. To fix it, we recast to the original dtype. + s = tf.cast(s, tensor.dtype) + + s_rest = s[num_sing_vals_keep:] + s = s[:num_sing_vals_keep] + u = u[:, :num_sing_vals_keep] + v = v[:, :num_sing_vals_keep] + + vh = tf.linalg.adjoint(v) + + dim_s = tf.shape(s)[0] # must use tf.shape (not s.shape) to compile + u = tf.reshape(u, tf.concat([left_dims, [dim_s]], axis=-1)) + vh = tf.reshape(vh, tf.concat([[dim_s], right_dims], axis=-1)) + + return u, s, vh, s_rest + + # temporary hot replace until new version of tensorflow is released, # see issue: https://github.com/google/TensorNetwork/issues/940 # avoid buggy tensordot2 in tensornetwork @@ -240,6 +355,7 @@ def _rq_tf( ) tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.qr = _qr_tf tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.rq = _rq_tf +tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd = _svd_tf class TensorFlowBackend(tensorflow_backend.TensorFlowBackend, ExtendedBackend): # type: ignore diff --git a/tensorcircuit/mps_base.py b/tensorcircuit/mps_base.py index 1b09b5a8..22bf1cca 100644 --- a/tensorcircuit/mps_base.py +++ b/tensorcircuit/mps_base.py @@ -127,7 +127,6 @@ def set_center_position(site: int) -> None: if center_position is None: center_position = site1 - if use_svd: U, S, V, tw = self.backend.svd( tensor, @@ -136,6 +135,7 @@ def set_center_position(site: int) -> None: max_truncation_error=max_truncation_err, relative=relative, ) + # Note: fix the center position bug here if center_position == site2: left_tensor = U diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index 8a37b3ed..8749d9ef 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -52,6 +52,10 @@ def split_tensor( return backend.qr(tensor) # type: ignore +# TODO(@refraction-ray): AD + MPS can lead to numerical stability issue +# E ./tensorflow/core/kernels/linalg/svd_op_impl.h:110] Eigen::BDCSVD failed with error code 3 + + class MPSCircuit(AbstractCircuit): """ ``MPSCircuit`` class. From b8a41608c8d73ff33326afe5d8081ef1faa05efd Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 20 May 2023 10:00:19 +0800 Subject: [PATCH 457/725] add default pivot axis for tf svd --- tensorcircuit/backends/tensorflow_backend.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index fbef6638..9c19ceca 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -229,7 +229,7 @@ def _rq_tf( def _svd_tf( self: Any, tensor: Tensor, - pivot_axis: int, + pivot_axis: int = -1, max_singular_values: Optional[int] = None, max_truncation_error: Optional[float] = None, relative: Optional[bool] = False, From 0361d48dc291107510d7ddb5252633ae00d56d0d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 20 May 2023 17:33:56 +0800 Subject: [PATCH 458/725] update about.py --- CHANGELOG.md | 2 ++ tensorcircuit/about.py | 11 +++++++++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ffab0545..bcfaf9f2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ - `c.expectation_ps()` now also supports `ps` argument directly (pauli structures) +- Add tc version print in `tc.about()` method + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/tensorcircuit/about.py b/tensorcircuit/about.py index 40f77c8f..d071c1dd 100644 --- a/tensorcircuit/about.py +++ b/tensorcircuit/about.py @@ -39,9 +39,12 @@ def about() -> None: print(f"TensorNetwork is not installed") try: - import cotengra as _ + import cotengra - print(f"Cotengra: installed") + try: + print(f"Cotengra version: {cotengra.__version__}") + except AttributeError: + print(f"Cotengra: installed") except ModuleNotFoundError: print(f"Cotengra is not installed") @@ -107,6 +110,10 @@ def about() -> None: except ModuleNotFoundError: print(f"Cirq is not installed") + from tensorcircuit import __version__ + + print(f"TensorCircuit version {__version__}") + if __name__ == "__main__": about() From 7638cf8b5c55217de67c71254a535b91a5c0d293 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 22 May 2023 16:32:14 +0800 Subject: [PATCH 459/725] add sdk demo jupyter --- docs/source/statics/tianxuan_s1.png | Bin 0 -> 37047 bytes .../{tc_qcloud_sdk.ipynb => qcloud_sdk.ipynb} | 0 docs/source/tutorials/qcloud_sdk_demo.ipynb | 1707 +++++++++++++++++ tensorcircuit/cloud/tencent.py | 2 +- 4 files changed, 1708 insertions(+), 1 deletion(-) create mode 100644 docs/source/statics/tianxuan_s1.png rename docs/source/tutorials/{tc_qcloud_sdk.ipynb => qcloud_sdk.ipynb} (100%) create mode 100644 docs/source/tutorials/qcloud_sdk_demo.ipynb diff --git a/docs/source/statics/tianxuan_s1.png b/docs/source/statics/tianxuan_s1.png new file mode 100644 index 0000000000000000000000000000000000000000..983ac18730a07bb6244ee03d7f459cd2baf15a63 GIT binary patch literal 37047 zcmeFZcR1DWA3u(iEhA)htdOmcJt~EaD4UZ_4o3(Xhs`RL3jF2_M!yjU2Up4V$`wuJD_3BePDm?Tge49R_fzw`cd3;5xSLH)@7`^0=j9=G za?^VJI85uVPe)A)tg)uyRc%dDyphq^S&Fd}w`+0U-1<~vM;Zp(Ef8qVYP-l~`HXxt z($V{(kI9xCE6>dhZeL!`qRaF*4spMK{NeYS>eQ*mGcd!l%C|W6i#P?>p7=)K6-@gM z%u;NgqL3o0mBrJcruso@fx#&_`RpRqBP*e5oPr0>qUw8|4rqER_%=24HeF|}X&&ji z6y@uzOu(5z!wDObK))*Bz9{qN>L<#xDjCGd4?lZI5-XijY9u9nB^3Pr!0QB4Y?v7n zVLqPlsZ*+Sr%p{Z5ax5-Ep;F$hd-lceOHk9=#iY?BU8gG3TC(1MsUM0dQW=7!eNNT z1ya(io`b_frjDALoX<7OTf2vc=#s<3LpS;^tRX2WK{YN;d!NbTt=;k$0N5v%ddgO6 zYB(3bXF?o&Tn3zz;1e!*WN{h)d{)Bc#yN5HdpsPRU|SsgUt`q4Pv~D1c%V7|{5

bQ<%Fw!ogY6 zU54#wge3S3{aTO>b~MDrPKHfSO%rwn>0}8L6A%&*Vv{9?!C=x(7FLp4SCxKE2mg~{ zvvF~8loS+nb8{1LyC{HkvKADUkdP1*5)l*;;Rhr5ogX^5n7Z>jIJ5t=$nSNoS~{CM z**dz|A{}7Rx~68x2QD&fY!IP8|Ni0A(%tr7N)FDywgomQ2>nG+SU^bd&)Q(BH1u0Z zOJpo z;`%lD_#b~wloo_`ehi6!U_SaSz*&}9TJVp|WQp}`E$;&{GTC0$xD9>+C4>IqLh8l+ z&rj&HA{+5J*B%@kc^u`d3b);H=aanijC&uZ#NCYI$0a@|LiFqtIUT8kbUepBsgo`V zSXNtuik`@?pKZD&U+{38UHyXXc}M-l^~t-7wp{j-)U6zvp3g4dnd9gw&F;C;a^2I? z=H+|xfg*pq`m*zd?u8CbpsE7kge#;rQghhQ3|mV|B{4ha^U(Qo(|bC{9b@i z-WS%&^zU{lxS!!D6yLDFMD{Ol@==!L|B@s;qwEVad@J@c=wIFd90dP^;}7cpgX8~4 z+R=Aom|8=cMWA#{@y)&He2(Ssp@Lb_b-A1mDh#%Z%#+?wp`0~KGDF}}eG(T!;C@+@ zJJehe!KwmfU*9uW@)12Y-0_F2{&X!`wri5S&WW9R<)BNAcFl6WO@+qSXJ5rjcx8@1 zTuMrkChR!jv@Lqd!H68)SQFkl-ha0AzQl@Zl&GIT9#Mf(UU+MsCc_DFfnd1#SmWff z9qC9Z6Ds@>V;nWK&Y3qzE#v9Y!90_`t&sk6vX z(bCb?JvtG5yRlXD20w|V0BUsZdw)gh{rzz_Cb=cu{_k=7CEo9VQ6QukHwy78f?#`N z`P$>V!%N!ZYs)evL5w919L*oPETV4X-y0;0C)FP`sVx%pz+e`p9S+S_rJ3gr2RX|L z7=;${d(e;+&hK%s;SQz!teW%9V);}S3DTEWm0!h%cX55g8jp*k{iB(`LPKO#>jf2x zlfrlPAE`yzn{hUaJ#_r>T%MmXRik{Tq85oF;E{UY0ET$SKK?BQ0A#(&|A71-kpI(2 zVA=)>u1lj8b>nraKV=$E85tN5C(srL&LPo)n|`7F7)2#N21lo(G=mzPcow|MYXKDDUL~o}#5N*Xj_J(f9jLPb~x%P_^}roI+*Z z8uVb_wr|jCSGGqF`82@EW+KF&nH_RAy9UT@+OG;xS~O{WEt75V=SZ^M=`B-L`oi|A zit^q@!(~bQ<;=P-bKFC~^G)1LAMgP`5?!ia!iMSZtct&Lk9uqChj4nJPi%t>(0A~A ztxYuMcH!j(ldere#VF$v#A2AXC(kB`exA-hBrG_$tr{1+Rkhdc{P^#MNJePx*ITEMX~-Skn=tC| zKXdxo$Y}+!^j?>uBJo<6B#~7LylrO1>_oed5S2ZYBP(L?qbwGCj)^3<()Ij^M^8zh zxKC?BEdgrdu;eC85Ofs&r-T3Ri}Y%d@~+-&QrE+*xJQ{fzl$J<@|)m5M%27z35Pi8YI5vxS-wM z##sv=tES;vH>1tiW%I)o%B^C;f<+oNWZovMV&MZxT`=k{tJjanYN~@4DFI?#BudqN zW*~HYnw*(LLwak~MTp)+c?I^_p2Ff{^Cj+#DoTcrH$zzPmxoX2JVN$v&Ivak3@@Q2 zrFV+r>ORSN3Sev8kmR~1*s0}ojY^8eov$guJ-OA3Ee22aE>sZBlCxJ#Hm9bcA5e$ljAq@^NwHW;a+`LXcpKT)+AweIY6HZ8ceZimy zd$5_A)paojR2BV~h3mt)O-s$FAHg}sL$3e~G9__+l?zzzmQvJ)nO@21 zg>cOhDJ4c#9JD#nZnX)Z1>1A>Sz}h%96NVVG?hEFTOV0%H`#A`Fo)r4-c3#mbkPM$ zM=)EFTPcJMhwpm1&xW6lgO_0M`@{EZq;zE+557#E!&_SohRroxrS}GwZaK1nbqT?g z8~>w!jynXEsPDNBL_Yg$Hqt~`uI?M@ez z@F9rh4olGN*eU$%A)eBQ=ahWAqJa>OM3GbbiZ=Kjw)hntiZ z-`>w)ZY(J1JjNz%8PP84Rk9haPp$c3quxs2_BD4^h*PY<&D`a@v*`DWZAOmZ7g=HD^SsBgLL77K+-Q1kHm|iDme4vnfeTVDbT=H0~ zoA_x39ru>g?)E!6u z$ffsMkXI+Uj~i~Q%iyR`;B=4Cs3XN#NsK7;C*kDWn3etcm!y?HmHZ5f#j% z>+S&Vi3;kx*UPn7&Sx(TEPV5HyX@tjq3azko-13~k3pq0I`XE(JXQ8?d%e=F zWiCYA8RSrMqpa&U{~#`hq{3~dE;D!68bq&;)**OECK=v( z4f^AtJZmm2XK(Xs8brpbE;EwkOSvr?93-@!4kCzLp&wM<0NIC>GUu0kC_x#|IiR0c&&J7~_DR{STM%jxCqIM$wNh6^I zMv~rQvX`nZYZ^>Se8Y;rEEQlN(LYwgq{Ah1Q#O3K*a*&o8<(kurFaTnCPI*tDjd&A z`veqpa+X=Fs`#SS%9(5_YjSCoQzpjx)9JEvq_>$F%>qw?%ungB%x_4vx#doBT~;sv zE|y&lZ@c&HERqkq>->7~mIIoBRmYtIY$x!q?RfiT8O@5eO_^{f+?MD*?+dqoUENrh zD|l|`+mH238nZwmK*s8CGUClGy)1Qz4nQXQ%^CdV1iud{!Ygx4*Pf_5?evo7*9HQp zrT&7NnaaWvA89JquQ>Sj^Q{Yb+iKVPno74f##!&sNnq~<>zQ5wsImTq8aY{khzcTg zAm7}&bn2yD!bxi8Nj+}rZ^U)QAao*$exg2J!uEo{#B4#lSbSlmjF*qksHb~&UK{9z z>|ZNI5EY1MAwK017xn>Bvt7?18WR^Cubh|=7d-sh%fH{a`8JhR=PV^a=gD8_nEPji z(HdUntIe8J9OP(zdJ-3FpxL2&0=+X}c)NI&aX7RwKyUmiV4eRjg7@(C>4l4Z-;x*V z0D>&nb?}$%u1RVzW2eR)?)26o5vLh|1Ze=YjekM=fyTn}>ww}jkv0P$cPA!&s+wF* z`#n&Mw06)JF2W3qzM(V=qyzK%{+>r~Vfkag@7aa6cR-L|FBbqo+I=tHShi~&E;mp? z=gVB@ttY++YAJ1h)l%+AHMh*<2XbDES1Z#L3%MT+bo1YeXBya`-K8s8j_jbm!SYvq zLmOW|gTnCc$2!CZpar3CjDQw|R;n3eha5ZZa0X%qSl%$31u_FhPyHzoLAL$!LbFQD zfZ`i^D{ZhrEv8A}*Amxz`WulRjS{>zd*KWGJc?P%5J9%T37*o=IAiGeu{LWHs8Iba z2fXcedzig9_T6NHr;8fcA?KaPG(n&U^n&Af5ytLrct(sLp*`-rI`cHIwDc@F)8)4!qaPK_ zNV*1uGK)0T=Tg=l0zHB>XeHsLLasrZ%H(2kjetyZPFWHgI*k9umAd(Xz=9j`&R;K~=3>L)Sao)a;fq;{^B)f` zpYxLjVeOk2u%qg-b#w^-%`3HhjN_zZG?f7uVvdf|lh_Vl?N6##fbtV7W<`Ex1*jE3Sm0$G3_ml?+93fM?^A|V2l z(&r;A%}8|mg@)Zy=LcAj&Wbo_^{X8BPM||-B}?`z;} zzVq}08LeTBnQ8HyVn(0Pi5I}CcpTQuwneWy803WlWtD#{dZ#Zl9@ze-q8PRv6eOh* z;XirJNd~iohAmTXev_L>XZOXpAY{VA;HPQ3Hz?K^4flxhXGd(p_yBMW98zJd0BUA= zOD|P~LISOoIf-SX;p>lhxY!HwF4FiY=GI#__OY0Oml}`nP(-;C0_9dCefYo~)b@SCz+PVRV#S8&fFtk`NTX~6bJi-bm$sLQn|(SW49+Xz#Rw(|ig zwl;q1=a-c%SM2bIN^c^v&(|}MDBq5NB@iNp^E9Ma+)Ky&NQO!CZrYalSy+sk#k&{0Sgw~vIcj#{a|*4!(bERV9}Nvx1YRv4q55S+|~MK zF*7@1R#%R@>2cH+WDOJ+WTuR9yKUAiq+1xD!>=C#1~Y7)xIcQO9q{gx+IKf0NpZSH z#VoJHu^>hVmmb0J8A@35&-}26t5M->7dFYhZ??iwi9&{1p9aIJU98r4_U~Y0?ekP0 z$DEu0zEv8x@X%mu6}wtz(lf)ILN_3NqeU|bl62z%(bejUb652`#dP*pv77k1&BH5( zkKf0NnX~H1syoi6#pM`%UK_^C^V431JjzvK1PcfIK%-@!LqL9DjF27Q_0$mqG;y79 zz(u_62j}0KOXU~2Zd}aYULgF~RRSD+)>COzMpjO#Vf=Xk`sNDkt!lf>5=?PY z?7nboMahrUhUU6gvPc6lrY!n9{3?dr$z)QT{#W9e;HG$vD8ifQarr^CY z?slq+*yN~n`1DuDuPrN3qh0hn>GHY>lLelln~Ntj7c0uX{Ln%SABQ1H41!QrT) z3J?wH+ken*qy}Vo9Es&*T!1nR1n8fmHh&L4_pRqz7!JxjVBRD$JH-1+mP-U&%I8-n z_~CE$X#*gX0uV$DTf$d{MVQhPL9l+BHNVL5#^V^Ny4=&~jB>~c-*(|@gxXC++%ZfM z#sGxUJMq7xf)6o&q5@l)0X=lzzEaf52Q)KP_H76;764n?s8>p8ix>r2*Mt7728+BPK*% zl2{^4HR!EWM+o_E+wB(3#4+p>e*IqZ5lri|4bXc*RJ6Syo;f}J4U*Xp!(TG{VghjS z`T$aAC7U$;;oLizud_;kaZVX@zNk8HeGBRP24u;gw9nF!l`Q?TlABL}m2{;O7INAL z#6Hp9E}Bmpq5-*L+aNt*cqnGD&>aP*fr@>Hzo&fw)5h$A2erf$&8rXreKp~8 zX&$I>BzyES!2Qw!1uy8?*~z4+WN<-;Q}I!BRDAzMG}zsEKWQN+BB1e}ZcEyF!UXF5 zAP4AHE_EUi{Hl~@4KDnsgu>W2ckrO-MTLFE2Z~;Vf84A~2U}$H)rsGzrnKsARf;F6 zy!GvCXYLpK(t`*Df=m^pT;BYs?5SI}502uimq+oHn1Fe{W}_HhxDeDryiAK4=5_A# zljlcOK_ca~d>pf*9SRS%POWEv0JTv61!%qjpjJB|H1~l0Qr|;$310N{nW+FGpjsYY zAgs{&Nx@6~o)&%n^p!`~AaXYnf0HW% zpV5Hq4t_QE2{a-5ZoK+Eu?kFloNC%P3?|;cCt-)yW*iUXz`wULH@g#_eM^T`=lo56 z)bpDM#HWs=@!Qqii~!QOMM_kd45Sfwv2}7;s*u&>HYY$;5TI&bK$)uMHFtGHA>`sUFtaQf1YplE*0)>*N}j7Ma~%mvL;CFFzqBO?tvO!(RPtL5X+Mi3f^~iE5nIJOxaYBXT8G^atIwSA*|L6qiX@hzuH>y+wd(8lnG59WA|76SnyINXI4Nd)3K+<8(48^SyjLs*s5p8=n zN@(27&=uf@KH(6e+6VLq*#dYDawp4wT}F$xd&dXQVTGbqJKwihEnsNcR2|~3pfrYH ze*M0IQ zc=utG$t-Qw0INAtKt1Vq~8WQ>BN77s-U}V4fum0JKE1MA$=0_ z@&FPZzxm0zWD>WL``39Js1&m<0b%M8B^p5|_De#jsR*5^#D&Tel5zoGd7$T^VIui23IE@A5XnXPtmpvudg5jK2YZ3 zM;zZC0i}F5k>G5x5a{%)ulpG}yFS~~8j1~ZJlL75n`%$cz2{&s@NSoR@cH$~fQE*K zA6p{&clS0M@~k_JpQjTr+wC!b#i!$Bf3?v6b0-PE0Hpa^(&$w_nYFfyL>eZN~PFPq>{+OgD5YuRR3H_C(&Aj1wq%Az{oO17oV78zP|E z%Y7+mx<8IJ84j1Nbh{EIdg&_2Pwb8Ev542Mjec|pT(!$h5q`%k*rasUx?ZYU`R-^k z1}R;}y6x$N9uJt_N^pLj`yE_Oy{~j{3D*1})kVCk(msH(AI;+hT3ci(*pZNBJ0I*v zsdI>c#pqH88k^H|IzMstxoxQR_1MaBTxJ6Fw+IXjXa*f?43n0Bx5qg(VW;8jHmVG z)k(VACb|9I<=8dMnS%p(r8J_--FsmFi(tS+dUeie*RjX=gOA3h)Ii zYk8E!-G;Pcfhpe}Sh~;l_SYE-O3Pup_kGl(M3e2Jd$@#7cP<@umkySOm=1=5<>-=q zW{YSZleCU+%3+%yjKlXwsmDuLymZdZ*H97_ocPo}Yl*LaWd%F~jcHS+>}TFWt!3$b zZ07j1&!OISePk7{*AE{VX4y?Hua7nE<+s#d)JRLCG0we#fI%Yx&3n}?-4-y5P(6{LO5Q(1!lsN}9Kh9x)R1g&$ zyklb~g9!Kd7@DPnq{J+#d6hWRR`GK0P7mLs(#PGx`gGLSGkfxfI3sGail* z5*0K)4|DoV*fz1YXHS=OPPQETVo*@pTN1mDlzADp5cPihs1hvu9F0PP`5fji&yx) zW`H#_{A6ops1*}vP_iMF)`|!h!h0OYi0_VKyj*Z@8Ed7hdHV#Ar|~~B1%5?URn@eo zR%}9w=#Q7m_{&TE@{f*VHL0?3YTmiUn2bPoRuWu$bcO2zp)_a*u42ip#UpiF)+!d) zXX85CCfW@#g*DYbo~dTHYIXYhZYq_!Eqxnb9_RG$NZ`~F$AFtPxjVHr>^mJ#5Go}j z1v1im^MyxF6?N*!sh+)Tw$)mUgp+!1j`Z&P(Jy`7lzMYU&=R;j;EiRxcU>;u|9zLPi%I^K40RHai5R=spNjF zOPC->Q)S-N;n*(PpPW6n9||Jg>BLMl)jrFw_MpB6bQ;YMmk3I)zg=AOoahU`=TmsU zSbsuLW!*09{frY7Nxy}fd(a`60m^`se>#QEVbN!->{dJ@@YS;@xZ9U39vk<%gA+2) zJQs0$|J*IV`3uGeb1}Y96_#D}{dZ+no9RNy3PE-!LNK)=GrA8_dJ>ZUfap%-=e61j%(Fp{8K_qo ze)FgZ3{pkFK!$j&RviE${9LG6%froK(R$+fuboI?MJ|SodAHYh$O$N*U=4RH$OtN9 zUTNMzzl#m*He=@#23zhwd>);CB^R|9pvP*xf}Ik+l=DFsJ+b&CQ!U7`!CMt=izs7hf$S1yR~+GeN4-Iqp$vL4Q2o-(m!+$rOc5|BxMRoJEV~V4zemA4 zT?KfIWi(ZWaG8|8Rh)Fx9V8ZRo$l}JD!n&~ji_MEN#=m2J-2Vqm zd$3wsYFFov$!FDhHRXZ&MwDdJ?2ieFy?pzK#p98L0l3=R5#Hqt5i8Ts8|rZ0>m|%r z}jxI#?LR7miwmC#@Ez`@_3J zl$>^xYy#`>p}0*9cc7RRq+7+|H+QD*>2rfj3v>?oQLR4R-6IMD=$EWI&F=1~p0f<% z_XN-r0|O?59gmP39>@l8H&H;w-pu3(0J5edY704mo;=RR`wr5LHN$WCIJv zgwS5Td8F9XcqURGL6n%osnyvJcuW?n9Z*95@&Ye!zBa(Vthtc)81&IbM$4Ra_4G>L zi7RV#BA2G9P3|s;k7oHQh*r z`f0L!#lGRSxrX92xZswwhWAnZ`Tp;y8>r`m(%Io{e#pR&^jd!>ynRxbRp+j!7fR+P z9xs|@@d1k`&})76wciecpCqk6T!kiJIeWH;BA!i2#IJXC#0p* zPRdS7z>=Q7YL~SE`o;r@!fc=&TKQ-uiba8TXawj0D;Tz{*~yS;Z5LG&{8ZyQ((j%3 z)sVq|xbcltr&UqETj?wb@k@xN1ItR89|lYdFAJaBw>{CH^TOhN6EF$rClyyz&a_J!IZ#$^|qBx=ie3PX#3tDi8+%* zy1|%W7cg+9csEkwEAmjq=&8Rilzu+_o#N}AQLfRF6OUuI;z#el~k})W-`$g2GtC_+ZjrfLKIrK~B4M4;&Ku=9-qUqKE~YIfOowg5Q(TE@ish%&X>6Mctf0McYC8>hPmOtJQ!be zM?jV>7p-)8fIc<{*I+!(c)xLqinVY0$IQ=u>n#_WBM&RAqLK^MG^uV{*X3z~y89P( zKHvIUJ`|U)j_W`J5nX%GPLZJx{)B>fY8^F@=VT{U=e zGN#Cs7EKu+h?bre7ZWGUw=;Iv6kLVM59ojiUgVu5rft!>S+qq@QYen`axPtM$=oJ&k*faQ*|N4b zU=AlfExlax)swYe{o2IA$v*3?CrY9>qL>47F`zPns#Nh1C$Us69`Xzi987R1=c$~Q z!SteptwYZ*zvz@cyNEtK$k>v9ob=?~V>-Q*(5_3R%6{{AUG@bznm4U=T4?y9)8b!# zv*v5dL0P$Oa#tEqJ&Jc$L@0|5ds=!sOl!63gQQjYpQM#9y0L~jHuNN8Ekbd-@k)~s zwOM!|$AzZdM5q}D5(l(w^) zA#*gjm`F)O1vcfr;rvB8;jSY!URLM%_(B>=G`0_q9Se?^F8Y={O)KBzQVYHr3M*=o z8<)M>_*unRv7}cDWvzW3^qzt2CLxmcER#)z7 zi;b%2({&Q6NA`@duwkXN2xq?N2kwZ9P`zc=w&GiB4+W;4QOxxW59H{jG*PX4gG{mO z^gp=`WTK6evU`KUwdt}O85wto3bntKK4b;a?gYO0h~t|CloVh|4)kte!a)3)cHNw?H>1nq|_Abu-q`fe7h29E0_zlZlUA*Xf&nhS*pFuLh+I zj`0!}_lO7&Yi{h>?Kk>Snu_7|EKkN~_IB3iY}gI3q=kW|9ihuR zk?(PEv?YEDXwXVtp{H#j?IKfE-wi*>QJa;T$dhIkp>rk6NOsn(B`Q%M8t3TRo;~n% z3xsy_!-NIkUT;-$V0SKKc*hX7(T~bh#~+&~Z067xq?ge(<)&wuvw8zuRLP#%fNryR zNLz!JYEnr044poAXdj(D>Lo_+E?b+@mk(&xDGQN$l@mSK58_R}zh5wb4*CG-oxwk> zb*wUys0Zjv-4dp=XVocBnC#E-ypYD`i@9y#9mWf2CpB9&ef?j+ zZmuwr=mhA?+!yXM2Fv#}<(h1TSzN%3k23ia^VH~-ah2fcz^j9v{}TSOe4`G{z} z3YYhO1X!MrXsrKPu{S@&&38~4`j`7)z&(HMyyGL`VsEg#aQ)KqVp;b~98`A5aNp6L zi>c$wJH5x~jj^?D#+@}E60cVwxU#>wl+5b{E~SzGbQOiVA&{lC6BJ;_$10 z`N6!HjMn_}rFxa@eAMvnWa2rz?TrbxYg_=a1V2P;JpLdpcTA#LYSz^s(ZgNfZl@Wo zscU}@v#G5u55izTY*KwMN%o(&UPuYZnSQ#NcDgkUgcId=KMBGlm(&lF0gNbIgR~$K z;3pqfpnE&vCkwus>iEt3H>pD}(P#vY)@_X>Q?-eK?*{k|eHQ?O!$`TXZB)20Bcs{L zfLJ)qd(zkHIOv}@jLEnm4O2P3$+zz?dP1t8Lr78}tOM>QzI*x(UT3SE5dkiVQr=EQ z9>MDXHGu5K_#)ZkB%)c`~cTK7;1&3U{E{=etEjkFEw>=iy_a51~3ML5@!| zf9Z5Z@tNWLA8{5ET3Pv=!$0@WCx1@NbY7I*8buzWkxP3iMK#VHWo|y0o&C+hy_7G# zHlNnlNzzZCpHW}-Sbvd+7+n4FKo3V_Y|uI~s3%>cN03G4E!)u2!T#yMZxvjOOZNM_ zWTx#e?HF>!jR#8adzWsFh2*)eb-asPe{gUhg(UCKHK97swY9z>`|$oei#TH7Y-3~J zy38UBDZj`3_IkCoBi_2yKEkT&jvw%zGh*6 zKEjU*^a9bRx*l<6?>FMz9Tu{q2O4vi#>|pIfA6IF>fI6yxW z#yIy4(y!Gqy30w|bI$C?W*cEen*EqAHv7plMuTnQFza=PV)S5Pf%>6f^q?d(`a9j_ zwCf+B(T4v$`Z+N3c^a!P3Sxbk!O%9J!^b|dywF-VEWWqW3L|l9gOT9bYX*^|;kw*a zMxxAd^Lg6X{1I8#1tF&(j;_g&p-P)6L9~C5Q=t73uRx1G^oo>D<-|Jx z_^Ck&CR?;=lv-=QlZ!xfEV%aC@d?RyLnXdyqmO@l)Ss(%s9oyLt8YHj?c=+>sSLB9Z; zLd<^Xt4*Ef!SV`A#Mx4AH$ z(LG;J=COiWON zl6Bqq*No?;g9VnRE8iPFFR9&g_~wzI!fcPepmv`^6mLB!IKK0Hd%XwVIr3)&RN4=Q1W)PHNsfr8?qkc*(I)=$nSy#}s}EDECB5oil2{XJ z$gHO=tNJ_?O7!@wn+3d(9L|fl9u(?g(=DSt(gOK3@C=M;8F7EA`80X-#wB{QBR_9> z{^Yps;jU(>&5Fc$x|k8mqW64R-i8JXF7=XeghH|SIg@OvE)**B&06zIh!OA{XN1Ln zUL5Xu%l&ZJgu2>!dVf6M8XnJzjqNu+i<+|64O}XnTN@8C=lb+Dp;fq9tZ+Q$B9V<8 z+FECfUKJ0pwEG`ykro`HCTPaVGGhalcE(OPyL8G-XDzRs+kd%Ca=3SQyKXO{Eve)n zNTF{?-ejXF1yi|Ljdh^6coYGiyiaMRntqS`Tfr+{XD!^kw)8F!?(og;p$_E(7n_PJ zS+S#XOyr0A&oy*93|WMl4Z1sXi#OL2&OIuS0zP{epjLY-?z@a<6ln6+2}(t_CawM-z=sq3%iAr^pr{s$X!%Q<$n z?46Yq2R$iw{O7M@3dKhHcSzuJg?piQf3^cjCk!sPyukmMg1N}M9L9-zN+0G89)u&0 zK=j?QF{h(@3GH+5^LAjbiQx=j?ddS|0{L!q}Wy4It_N7Kh;n;s%G)e~5dxh%WFD+t(jZ zvbc?KpQ;bN7=UzNI5{4NUi-P6gTeZYe@ajPe;4;^Prux5YJYGilcez4!vT^G87VBb z1TE&Z7(#72+=TU#)%gkzv2(s{t+sOL7Zcn$0GwA^{|S)3LiuKIsMH~M?H$vNz|dL} z!D=Sioxq84>n$%~FWX&Cp_NepwddM+?*;GzUx}n-WEPQ7GaeauO#M~wr{bR=i0j#$ z6K(D=tNP&=I6kl@7&xs_CGFYL>qBp0JnM)F+gzJF2)dr70O&jZO}~mjUud)%DEMYL z;w|PCu<%PagT*^xB+<2hS-7D8ydxgHMev09y`?@B>Uwy})*etg2D85u54=kD_3Ldt z$zpOZE>yreU<;&6_s^K7W?kugqR48bUFWtoRY( z?uvdQ=e>ZUyQzV8WYD=EKqA~6%bP-CS>`a=@$rwJmH0S2JL|YU^Ci!5{B@pL!xP7? zZ=Tk*YtSKfuT?{d^Y*AqkNah(A2%*P_-Ub6jL_GsbkA?ut~y13E``vrWVCONGdtII z&)zs*Fo5C}oY1O}4RW~wDaT!|#IE;DDgk(_uwt6q*kkrXo_SM*BYe8w&i2%xc(wtP z12{aFw~Zfs^`nHRo;YV=xFk4T9sZWVLQsDhF;HNsnjLObi%>_|DXdv&;H`u27}}(R zVze9V#}6!UB!hQyz=7==NRTX%&0vvhTn$4Eea!fxL~bfZhYpW=n97B_yAZ;)7kYFO zJ^c$7s51v%yL3f4?T$JwDSYc}HbHwRmrg`1#B@%$X0EVUIWG^lM>j1Hbs;@87?I|d?R=BUApK5MATK(IT^?PxvUcDAMJEN|So$}x z1Hl)FrXJH6W%y@(eZ28QxXojOS9(WO8h4jDIdz&6I?$Ubj^iT(N(7CI6uhMr3OYaQ zJ=SQgWOivHu-&ZkXi2832sS8&aXou1hM8?g@^SYC>U|0%F3{rbdy_6S*PgpP5yyhN z+iO01p95k_r0zIV8b{G)J+XjARE$TyNmYQp1}cyd?LyR*E1-dVb0l$^;}Z7(b%>xU z#jG(!0{sm7xxp*(8{c)^S5#AQ_J3a7xbzx|+v!b@$L$2@eEG8^`F^cz%_`sYmikQl z{NdyExtH)~#L098-y8))WXDMu?1i8FB*v=asDDyFgSmpBRmg5ZcYB$a8FyE$sjsdX zQUwdYPNGPR2cm zieWL^vY@oe#uA@KrE$rlXXy=fj*^uVeC zUvV3-i)6p7b?OS;+ws?SWA>)#VsZA(9=-wJ!398ia2%-DAS?bR1b})-QqZkEpG;{= zJE^-E2X_ZNSx00Y#klpyW84t1370x(6T;0Z@O)1VW-Ch6r0kC666;Hn;hFt$ z67PVfJAvAS<3qB7Zo@Ez7NLZp+>vwWdBUz-X3wjZK%+uo-!eWO(sTNV6+0&rB4FrGki^!!=Mv0X30)C&My){aMk*8yDN|?Zq7I zOa|lZ@7{meH9FL z^_nlZ#nQE?1T^5Dw*A>ig<{;Bxann@w6Odpej89TDvV~;aS$wl@yayC+Xm?Kqq_ys zSfB+y>X)RbKq~t3s%KaOZ1{xwR9va1m4Hxpbr8reRhi8uX*rwK)zkvh%;(tLMiy7| z_xEb+>#xQqj`S>&ov6Oh=m6fs8+WTQoEXNzpP|DU%nN|bkLd0(^ZSv9GFKp_G&|W} zY+n*w<(Yo_b9kgiK(--Lo4L>-?`)lE?R*}%w=^jshd;)PCWKlOciYz`rr99(^n*)yKw!cpm3v0 zl#tYW%t6Jp6d%x;lMjs4ATRX2{kX;`fW_&q%#Y!jBlgG&{kNGbJ*%nJd{JNO^EV*3 z_*mk&Tin}VBrzb(uWJnzUgT=qoO9b=l)!t2v(IKbVRvLCZpSrv6O%$V|pt=FC*axFJ)>aLw-J z-QTNU!}C7xU+=%qTCCM-Ip4F-Is5Fh_x|hw!w@lT4f|ra+xyQ?7lJIjh{~DptLd(* zv}MOml#JDvR{!79nK* z-JgV*!6gdjW#$(eO%`lgnh%+bkJM#I{OPNPnOnjqzShnB1u*JSBT%jpu8_`N6OKlP)Qz4~5 zXtYGVwa&sZDi+NIv;30pAP6*3IY!@haPyB|$HYu8$-7>v_{c}Lws>7Fiysz{UY9p^ z3Y81?vDYJ-tDS4f&8^GqG^bEG=i{ctH z_*VZ2!c>3MHlT7suQ!S1@5~d{e}j6Zoj}(ZB`Q1l#Q!5hj2C7?mh(#EBQOva{xlNq z<21P3j(%}!RSb<}vtVzJK?nKwu-lg%Hn~+3iOL;K?Ktvo@fh;tNY-!H`cqw9UwAb` zo3K*Nzb{>~S|<6H6ECxs{oBC+hkj@KJ0Hc_+xgxt8iu9RJz}-Irw6}3%_DNaTX(C9 z=+uU%ScqLymXfz*tLSGVd(+zDCs0(yla9*oazN#lkAL$DrMWt=@vJ0_k~^ULkRztG zE>5y(%~|&PHIsxL2czrO;hXVX9#icO18!sF!nsVr@0?n_+)|l{$w9BO@Z&GS76@mj zLbE*INP6*SBx>=D>M2<{j6`O&i#5(Ypmy+**-kGcj9E3NIiCGnsK#dl*d?SiBG5m0@tLGQZNoW<@(95IMS*LD4ZG0ruzN-!|x;h!DzW z?D7fsy*|di(bjpYYP2Va=q?>#Xro&7d2CGq3h2#%rTB-!{>DU%*}}eLBGqAaM1PiL zRM=@*GEM=T<2~zR-Wig)vHo@Ki*jDv06aDMHNT7jlN=L~>V~?VdKm`qy(=$1DlSU0 zf*^Ngl_pSqOiD3U#QB7O?COMz^bgl>4~5^KHj2Jb*P-f%p_w}u(kZ@7NZ$dK)-3ibU%a(_?mYXx4l^^A>J_^ zH6Mkz9Z+%i|CUvO0&Fxwc-4%EBpmPMYqOnlfGt-_#NO-HH_E`rYA;V6Q9lmPMy-IL z>9z1n+b0}Y#Q`OJvy%bAJeN)?O0%)Da94(q9w zm~^qopPMZ5xWoM4#+cm@WIk?zOoPT^q~&ZTWo4pSt)y+o!`eZ-UVRt@v1V+R3@_!S ze@nE1WJ?j(d;p39Fvjm%Rt^#&Mno{c(0fl3H+G}sng$YPpdzDwdP2@OgYi^gl|#}3 z|3T)Xy#WTrQfrH2`gt!faG=ap8L7_)>%Mo*%Sah+G z!Ua+z{2luW`>F=YFTD1vtK+Zi%q&WKXeitL(}6!J)*Q!vq`D#Y47f9|Rg0r0yUxTk zudZqxqYPY(&6Rzqs6Ym?SYDw{k58h$urgvK1QIA@Z<=tYrlwYQSkev@k?@gnmOCITxYZ_f4>`#3Xg+7^; z(XNcp)Tdl@4{opg?n04)iw!59_NfO^L%zYSC!ipM>d{P=ho=~~Xo)@zu z>R%7tmNpQixk|^*3qJjm!ZlgxfwkwQ(g?{_wsfso{!14zqCfnlTOsm>&9e2|<8LTm zTgD7AD$%P+3l$6qVstrW#d$9KsO|m~v}MfV2Eiyzd!p-myuorh!b(&6ZU=}DRb&Ls zKE6K#aYXihNFtb?AV!Ouv99LAx|+XXYim}@#wU#EOlSc%R|%{MtL-FV@>G{uGmAY5 za@-~^2BUp7_(C32V}m3n7gr17DX6iX%SRg)5%c;w)s~SX2qe8_Fap@?T*`{H>ycc6 z`}47KO_1=Wcy?O^ntoX>SP@ZY!rivC0@$blnG^KjvA-aQq2&q{(cDi=Mdb~|qs8YR zVamVY1r~W>(JHlDd>sMNcD>Z)u;O2zUy2oKa(Bll-q%=Pygl=xEd;r2Pq*-!3k{^` zMJ9`@a*;z_U)$@GU;5*i%sU(LlUgPIXnU0A4-Le8LT#B(2=Unr?vOnDTyxH5_PXWy zj)tr|F^jVVccz;oU3?*o9wgl%Z%cOo_Rf?&5%ve|Mr)r@d7Z6U`aMyYa!J87aYVb4 zY#?b@aKAbn`4;y5K}!KTQ^IDI;LdC}-6a*v=)MP0OrHGyxXg*xKR)h0n+~>OJbLD_ z;>u!+z}N;N^Xqwj9aBhX8=wupj>(Kb$8IGWkK>^5n2RM(=kQ=czV7tv>+S63bbo$* zUjA&1nljd~egq#Il6r65GMtmubkp84d^*8UY-To}fvyTw%rMGm;eSmK6Zn+d8)DdlkAizVC_sb~5{(kJzp3xANrMWkc2I^Sx~tUD$>(LPhQv@#t| z;?MBieHG7D3PsZhX8H{$?sro=!5Of_{lq=-pXg4GlxEB{V;v_<2qu( ze%o?YorR0@JyfC&;H@+!ELE5~^FhV+Y5t~E3??t!@Z-yCSn28ciwPu=n$Sk&bpb$>>G*#*i)qRRls8+7@B zv*&)CXKS?%=O7s62qwKD@u(%~K>!|oy1(A6)KjH9|Hg$EduJe-OuWYag&zYp9MHa) z{sJ3)*RM}MqH;~~$5^nYcKGarB%#LGnJs=LoHHsBw;WB1MvoS8m9g!~P0=%hgGIiP zNfF=FV4o#X>b1T!`)MMC)v|Q-NCHlb$Db1vQGfUaog|VpHl5`;b#r+3fRJ#)eOrphomZ(0MIUd}!p(sI{j5^k z4^7&Z+}?z?xVLeT(PkQqI|gAWCwMfl{pNQ*zi#v)oLs6T<+2^86tDo*vwQ)27V($cbT+dluUeH(c@YT;EHtO~43yTD(Sd$qB0 zs3znIF80%xl0}(Fxn9hrXG1*J6#2yDc-)`PQOA*nr_xZ{QvUGaq}r0{9?<6QglFcSuySUa0Z`Z4D1Q zU&M^_O}~mSxA+!Dsyt*pF&g|NVAv!%Ttj`YU(!`$~=4xet;SQPTj5IU#t z8`_|Ll*a2bIOR1eHhZ%z2MtlVc{(dN+no<8@ulN&l!Nq`*~P&Per-Rnw_jE5ZET@c zR>%?h;`P;_dnre}#IcTtl$Qoe3f@|lx;bB*nvl1MTb)a&|J5@sJN2_X_xetWux`j2 zZ+|gMxVcsmQsq%6PHVru*y=B?g*`I-9o_GGVhQ2~X-}LLGnt!dlt97R5 znkY3(0#-ud*3`GSxP)E@Hv{Za^0{zgMtT^_?CSFi)%HfaFGEQB>B)nrT%!ZTP^n$) zNjg|Uvf5zLfS27$j`GpnQ3)>RR*LP*gH<|lw=Ffi7?E9OZk%sPNd0o8@Cc#QzCyus zVN-zt0-aqutIi#@i>GnzrR)KY3zJ!L&@;&~+ zNXKqg|1lS(Vk`#7UX?DFV6W`3vN{`2ugsbX(8gx&>M|IZyK=38m;VX*wF5I7y^$(P z*NP^5>6>glQMq4F*Ft6*9F{yy7JjF%Lo;AVHqlri&l%<710p{tdX4WWvOZK88Ht$KPw8kMWb!%25xP2JUStcZ!wLT|#Zv?8nRudV3lS^KWb)D6=uSs_$5 zvrO+-7w?sX_eK+^o)_%j+GF$@zRz;F_go?gg~QxgzB1_TwRY-beW}T)dZ>At8^O7C#4GgDn!12D!F8fTZSOeR z`!nTW9nR74?Fb*ezv^@BPOp{5S3+H)^q{c72kuO?X0fh5Eh<0cIlXr*(4H9D>i zGoo)-{szCN2lpLhS4(LEHTOy^e}B+0eo|eHITVa}=`GtXv{Jo0G$P^A^r6aO6Xae9 zZ&u;;D*#a|-E=rg7{w{Ey_q8TQpegGN#jcsWxc-Mb67dHLEmmNHuKLiIHlsqwv5;p z*$j91u7>~o4#du8+M94;7TCpT#u7a47__aPLDMTKatk&l&^>m z14#~j`p4Gqat3+yu=-Jnl1HAy0*csc&WuyvTV{MW=4r(JU+@zMsXnWF!dhoM_YsuT z?}9~hY7Q)#{b#SKhIXirqrB|ozfjxc%vzF@DPd_ZKRAb9mEN9k!w_(@qg%MyO~1>K zFZYF-@2+d{iMy@#l!2>c31}xuLuqg(ecCdUBQ5yio;}-jrmpke%z@vsb@>m-KK#o1 zvj6@2_a%-Mze*^QuF&hVzrt%K!J9bkGF-cOuXX0D&?H*^q$!aBH_P)Ww%^zEM8H90J;!PgiE7HTncZ+$^6YWRr&x$k2|fAB?}#w%gn0?9nJ~3Kk%}^QI0G$mN&!DsrgIJ zvc2Zqp2<;#Gc5w+*je{;re|+4fF^n z0e-A$CO(_;o-UHe{;%E;WdWtVn6L$mu9Ap~-ga`!oBO2kL=X7X3x9%T%{+b5fsS*1 zpJnKc8A&8~OwUuAe@xX1J>Uf4ek*nn5<@JAZhD<@%O?0>p7h`+UN%2(w%FP|CzVUJ z=kdYy{oz&kzR>_(3PU%{%-bs-Blv~>a#woz#`I{*a2ALl$`*<(cAKHO8oOIwrtr|q zUg`o2EwjO-$*~#C*uD{2at0t`t407FjO4uT81@cIFnI5$Vchcc)*@92?tbIXVYC<# z9#OxZsFn#zp|$L>O7h4d*+nR&aHcGvN0;z$maiAz3C4`A_DOdZHp@i=clHlZWv9<| z6iOsMbLU$a&9qZCBNk34WKC)%GGT+DFhQy-3L#f9L}U3iqSUQ!S^2}apmxJi@T6q( z%A6oqRE=I3cNvcz+U7)|ITzv%breF1ki#n8*=R3B(o88&mylES+_ufsSSo}X9?wd4 z3!~1nClzF2COz`LX0U3S9RopmZE4?R4FV98TOjK8y-t^Bf}E8Yd3pu1xH;pk#OFJE9}4 zb6Om;!#dtR7|u4U1~$h@!4Eb^oqs;40`VC6eB087=dyv!2!o)#w#@8F_uf>Tai8sT z`RJ)?17sE;D-3f+$ei4%XdzCrJSMidF@vR{TfO5@^)8w8(6-}-Xb6{E`YeL}A`84| zgeHS3pssP zAC?Vug!>2ZTd-&1$NlLL z>srNe%g{6sfqE1#aJz-OA#<5(E%~4*K|OYe<`XpxYlLC3ZOB!z-cyl%4`KCFLR*`; z0PG@wKyQ$Ce?2k#+Ua~;eDiFw94roO)GIbj$l~<9hFByM5pMagWdit`K+TQnMBo;; zUTWGSGEpbj>}-8l9s_4*6~WQzB_T9EQQY>FUId|$af`-8D7{iE0TqR8!GtD{EI4=` zV-te6bc7RFT!9)oA}5g(nBT$s5mB+3|8*!@z>ZKOP~7M(z9VgJ>Zkp1Qo-{S4~`4| zENFuqocPqe`iyXd#?x0wX37(H7)AkjT((<3HEo2RX6ll$U@iGkWMxRb7J~+0X!MHj zqthy+?S~ftu#H0_up!&>LHyv$fGeL1Kkb+?VZdBbhf^CsN`gcQ!G?5Ak=-&gK$z>m z7Dj%$0Ln*UAZWO|%-)a6`kH3yyp6MRhVen2U>pZjYIzp5A7K(X8@D585TPD$Uw}}dyTI~76^sjy+SI9_Ii zY=`I8U28Xh%1rK1E~wk`-v>2KN1@Og9TO8n{p5+q#oD}mC#$k9&1A6i!w#9i#`enE zB1C&03L6zB`3V%ajB<0hMkgLp=lIzD>+7TV|5N zWYaaqK9fxDSdve=Ndi_urr~cuZrc;VQEM*)vNW_Ki+&aAZna6A!733_zn=j5QAyrF^}}of z49FkR9^5h4C&8pG4*`%BFRMFi!52VWn@{f#g#-MY+A9HZ*5onU&n+W0%B%wn&`*-l z*ou;CvWFpBku)=;SO2zMy^Cmd|lyfkS;9q$%9eJ)bpo+hNaSpjScJwyj-4J$Q#YsX z@)k0LPSWIIqD75=lxWMy0&j6Xhz)cp_zmKL|B?0M%soh@yfGYv$_>4qi{+v3;0sgW z_)$C-U+ZBWWOs6SW4rG|4>eWkQ&`nODQ_o{rUBRC(7|BgHx9+L%(`b>)p2m{DaKhI@4b8y-_Dbij@*XX$Eo4{u zW^gr*14?=Rq+tb5;a$mUtF(fSBfjS-HE!)#Fb?SGHd0uB+9UZR%H{BxyDE30D87Qf zZd?6V#vK1Ayv!m8&L5+Ce)95j)ETJMDv-}${DjSFFONJsM573N%cQFnRXjkpWEU~{{;NzDsa*lSZ=FY(uSLv_!TYRX{8ZWut9KCC;g^H!BEs7aB0i zt;l|FM`Q|m_jQM--A2t}YvR3#X%0UWukDpf#{= z?lvEtZJVuP>{Q#AZNM*pL3{&yB7#MOWbY{LSx=QUO-Pgs%s=!l@d{FJcnzYr-50vE zG@v|{%n=hW2+3VpT)auuQ{hnTeoLepw0Nz-`NpiT;$QAu)yiU{;#7>{(nv;!=`FZ3 z0-l#0V6GP?>wW-K%3Fw9S)-e?TbP^QAjg7obLUC5(SZPqwmGYlMciwjM<(p@4PnTM zIP=cf;yXk@G=^W!3sD*FebA=T>(`x=BW->s=^J*0_A|M#I#%M-A^-6%3i*t2Pf%f= zn=_}XWrnYeWZ`tHdOUcjdImhpOhZLo@tYQ11pkgcuk3`uoozF-D8;bj*!XD_&bSCf zc8i3(g3~u@M9`iDhX#dF64V}z<+eyMSw4~0wms0{B*=mfr`mQA58eHKy&fPv>3H+b zNAFGv!w{M6rza(SGnhZ*4_7n4h0v}3PofbwO23Vtf{>h-p;>BJ*U|c5EqKlpt3*0F zz81i%F!hzN=FabHi++37jKjG5J9zAR^L3tmp$K`sClT%Z@(tBXw7%S@*ohG+aVFLD zdQyj52Smy1E1BHkDuwYO(Rn$PnNTchvz%E|e7R1E3PNUl^BM=AFU0z$y!UtjF9;Ep z=bNWdb^(U%KjmVL7zFfCt~h*gSB|b&p$=UeBW@@NuKMFgiF?VEkzZ*wR`ARW#<*5C21*y_zQ+ZSw3D|^|kX|;Ceo-l@z&3DZ^ zJ1m^+Koa#eX)NwSTvw6rEok&(A&MTl1rE(Tdj4ML%jOH*P=wyiAdK+QVEOSndt2?x zF^jT_q(?I3omCsz`S~YG$7Ofw$@|KFdUfKRKd3HkIZ~Oh)tcp>Y6d*y&P`#8xe)M<1ZgO;gRd+h!ne>8@k=0f;0)$boFl zy{GrJ&)aZX9jqTM+&sk4EBy~_&9o2F0z#@@Zz7d0Hwa3LzAVtuo0zSqf#?v6{aV}$ zu>tAP=cS280ftmPYi!7iK1pglhswQ_A?Pb2RNcUNLoDLb35EINcQJ|vr@F|AsaGb= zE$y&+=20qz7${6m)#Fa;f9Gqv*XA`(2r9=>0~E$cMhHJ{%PP2+zc?W)ik@tT(wEeE zsN6-V)4=SVq_%Zzmgxpit^GFCBGt^%(K|g?55Yo49opzv%txuhjPM3=xhD8qD7W6o zW88|grLzjpwD?Sy%M3je1U{cIOsU}$20mBgx)6;y9GCg}pG=8*QyxP;76 ztfO~-uHFac(5d_Uk`(NhMog{*0Zg1iF4H2ZJs(w%kX|N_4V%TtLtXKROV$b};I<#R zWvjSWGq0|%x}xTX?A24gzxHaMN+)2GoV?5pLdUpxceaT?mZ@MS4n5@)P9~(%AvEP7 zacIBS9Y~wYbt2;ngLP6y$1p?iHe&LrzE4SL_8l$x>U3WH1x}!Pv^7( z{(!!N@WzvxGXi7fEU{ZE0=&pw}w=8ShG>}h^j zw!$exB5c=RgoRS}aKNEFiiRQ48b&ZAX@fC!iD>N2BXamrmp0P5u>W-~1%maXOu$`bq7j!G6!t+BDcza2<@JfKq6G6& z{J2XvY0RF#$B5OBLO%LK1-OhI3i|?JjB4wq#{@J4F_&BTUW6l!L2{3NpMQaT{U|Fk z4~*$m*azuZbedve%kB1D@l?|tc{mJ-^HGQ!;TPw3uBymD>l2r6Zb=!8W9>W?<1V|c zSIYu1_*>GaUXdU``0FLa4fLDOWa@vyeum{oXRdDnf6Zl56%~sWI%~<1XxW9>gglH~ zDh_jfWVx4vP`ER%XrSca7mwMK2BmJVg8h1kE{=|24X%2=q*y*LCqrZs{>(BvTz`iRiJe4V z*Il+C5TI+#PYBRy@x+(_+{4hZe4Ti*XZ*<^frAAmS=#K8z`C)~BEhBs=dKoq*>8+g zJz~QM6VqtERz+5nBCN7h(iqhQj`F!W`exH6q>yB>XoOSZsuqZ`zFijz#glQip9`!N z{x3kV=r(X&pBB>jrgK+rUtvGj(vRnwpKjo@FI>1_KG7}rc~i~RcC$i4Nr{1uTZ!Y` zbGaV#d=U||vbV)MQ-pP$z`c7>z42Dk#o{>zHa|=wvle!tkDlz)hP&XhOwVKUYWSsgM(&eR^$l5rF|?6$4JBD`zkYW%Ukqp#^5y#Cb?qqT zazcXv5w(BNkjpF+oB1I$n|p1wJPLz%>eQ}-Niqp$>C@5cGY(EXH5(8D6ZfQZCMxjs zB!6x%R{PDO7SlWcJjmN7QO`UiwP**;tkTv;R)`Q)x#2ppWNnB2;vE=E27UfOqm9eQ z$oksaT>OBJ8B%$iTCfqQ>9|d#4SH6EW@im~-g4Z&5X+Hs15ia&Zq>xuoJ~kd8+*A} zsv%e(U%=xRtzD!}?rjde*=~Yq@P<)W$Ai!BNb~+ohz_;6Xjq}shh(sP{7opAKTqlC zkiNe+UMsz-D??5^&V6;nq4nPIV6-wug2U}cO=sM0@w3on4u{I6_E_21%g(z&XOP1J z=@DxDn>M7}rp*;m{Q%iJ7;>HdE`F?o0-*!Vl~HQxD2D6@jjo}4c=^{ac~vuIW4*K0 z(5bd-2D9Jf?aGwHNvJ880VT2 zarkMtAna3~CE|p&RO!JLNF?%J4@6VPD@{aO0K-hjlihy^Eq}W*mBb0^WA9fV;pBHK zE!NMm1dHKUQhyJ%38_jV~$=SVf7|a!1bKrXqAW+?40aq?;(R#r0y!cl7KXd%g#= zxdY9O8JkInUyVtSEk#((FnpxLH{){I3c-J{3b$O+GIpi)Y0}#4qp_+|@5%SGl_BE3 z0!6}4;L{DL-079EC86n1iK2D!a`c*LUv?pSMrCQeV&idkF<$kh{W_p!ui}VD^sJCZ zhAPYpC}?b)RqT3e#eSwtPGJ^+%~_lxXO!qM{<2AKGzar-r3`!()`LeuzB!EfZtA{9 zfjw{tk$uAssvx&`$>h9CNmIN~cCb78Y4uE(^2UxGCeO^nozqfGFTg2tdo*4h>>GHy zzkbX-L3uGU;hk9l;md6Mat7^80>NTscys-%yv|+y6gXwOjg!ngt%-h1>en4;M4%5B zI4v%`J7|ZE_nn#)H)T{>feb(GjrOX+VS3DmlyW!$01$MccMS3P*q~c39=qLpK8*X# z?ns{X;uibED-+7z`Hlng$l)$m@z~suHnoGzF@441wi}YvsS7*@UQBm6g?r&-&6pw4 zPybfAbKO{F$hpl+$;j!7jJt^_)^8As(0lb%`*2JD+Bb3 zySXrVMTAQeNyveV0oFa#1s{Wn%7J^vRHWOF@n_ zTh*fKp~&SxL6=Usw+9O)!nP4xe9wO^>IGFdF!lgx+W!>5Y?e>br39gmB4QWI0Bfor zQ8Q^<0x|z3A9`l~l)lgpa4X^Ojk8xKi`l;!e}i;CDx^4+v$d~gV5pA$_Smku84ueO zur&OUpxhyjDmcw+hh?-Z-lTgYNqR`$hE)s*(m(0co+{i5iTMou09jg<${+;t6YI^< zE{CRb){$fo#qH_2-?rb~n0w|rCJmZ2ncUa^H|JrkCa3V9m&o%p%UrOGyfDx6_o+aW zL7u+Xmwi}nY(5HJ;y!%f?TDVLwRl8k@VuJD_5~VMJKZ2s-gMMZ^twGU;xA2I4-^J^ zF6gk`03Ej9cFTt+rVQy@*diNLrFHTj)IwB%rqzT3rFyvMQ8*5 zr?~){jDjn)*cL=uY%iI%XO%-Q?g->#7-+HmhY2POqH#x;Dv zbwVHTKkX{z$2g$xas@T8fTuOVA7-+3*;(MFMEAkt$w}aasP1B1~zxwj~^6zsHQfhnU^=FOF#% z*y5Od8QK677>msa)rc?S*4X%eiG<=EhRy>1D1(L*hCy_TeSf+_lSpn+5}?Q%E3K1Mcq-sICI24Q6`X?zL>^8|eNGn!Fst*A%AyBztoCQinZ2c2tiwJcIIDIJJ zQ$-JwiWX>Kk%9pWG*G`_>z^P3nJG-c#pQF^x6y%=w+6Rkyj56pgXLdOegU{8I2YqSt@ z#qRuljOahZ)*a#x3)B$!%|<0&`t)6jQ~&-19D2tif8+$+@$CnG{ajYLtJ3KsXY+X5 z&hUSKP+9;tUH9YocO3G8cRqkuQ95@XAY" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "\n", + "Image(filename=\"../statics/tianxuan_s1.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0461fc24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'id': 'tianxuan_s1',\n", + " 'type': 'CHIP',\n", + " 'qubits': 9,\n", + " 'T1': 30.593555450439453,\n", + " 'T2': 12.94344425201416,\n", + " 'Err': {'SQ': 0.0007411111111111112,\n", + " 'CZ': 0.013063749999999999,\n", + " 'Readout': {'F0': 0.017955555555555554, 'F1': 0.06848888888888889}},\n", + " 'report': {'at': 1683908208,\n", + " 'consumed': 181292436838,\n", + " 'done': 32164,\n", + " 'total': 32175,\n", + " 'waiting': 5039},\n", + " 'at': 1684543057,\n", + " 'state': 'on',\n", + " 'links': {(0, 1): {'A': 0, 'B': 1, 'CZErrRate': 0.0132, 'GateLenInNs': 75.88},\n", + " (0, 2): {'A': 0, 'B': 2, 'CZErrRate': 0.01678, 'GateLenInNs': 77.15},\n", + " (0, 3): {'A': 0, 'B': 3, 'CZErrRate': 0.01603, 'GateLenInNs': 79.2},\n", + " (0, 4): {'A': 0, 'B': 4, 'CZErrRate': 0.0183, 'GateLenInNs': 78.45},\n", + " (1, 5): {'A': 1, 'B': 5, 'CZErrRate': 0.007, 'GateLenInNs': 73.28},\n", + " (2, 6): {'A': 2, 'B': 6, 'CZErrRate': 0.02188, 'GateLenInNs': 78.1},\n", + " (3, 7): {'A': 3, 'B': 7, 'CZErrRate': 0.00326, 'GateLenInNs': 63.79},\n", + " (4, 8): {'A': 4, 'B': 8, 'CZErrRate': 0.00806, 'GateLenInNs': 79.64}},\n", + " 'bits': {0: {'Freqency': 3957.7,\n", + " 'Qubit': 0,\n", + " 'ReadoutF0Err': 0.0236,\n", + " 'ReadoutF1Err': 0.0976,\n", + " 'SingleQubitErrRate': 0.00094,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 34.524,\n", + " 'T2': 9.62},\n", + " 1: {'Freqency': 4156.38,\n", + " 'Qubit': 1,\n", + " 'ReadoutF0Err': 0.0218,\n", + " 'ReadoutF1Err': 0.0598,\n", + " 'SingleQubitErrRate': 0.00069,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 34.459,\n", + " 'T2': 8.321},\n", + " 2: {'Freqency': 4106.1,\n", + " 'Qubit': 2,\n", + " 'ReadoutF0Err': 0.0225,\n", + " 'ReadoutF1Err': 0.0568,\n", + " 'SingleQubitErrRate': 0.00066,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 18.917,\n", + " 'T2': 5.222},\n", + " 3: {'Freqency': 4657.26,\n", + " 'Qubit': 3,\n", + " 'ReadoutF0Err': 0.0075,\n", + " 'ReadoutF1Err': 0.0515,\n", + " 'SingleQubitErrRate': 0.00058,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 31.079,\n", + " 'T2': 42.79},\n", + " 4: {'Freqency': 4399.36,\n", + " 'Qubit': 4,\n", + " 'ReadoutF0Err': 0.012,\n", + " 'ReadoutF1Err': 0.0544,\n", + " 'SingleQubitErrRate': 0.00079,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 32.353,\n", + " 'T2': 9.3},\n", + " 5: {'Freqency': 4371.74,\n", + " 'Qubit': 5,\n", + " 'ReadoutF0Err': 0.0124,\n", + " 'ReadoutF1Err': 0.0664,\n", + " 'SingleQubitErrRate': 0.00049,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 30.132,\n", + " 'T2': 6.954},\n", + " 6: {'Freqency': 4307.04,\n", + " 'Qubit': 6,\n", + " 'ReadoutF0Err': 0.0374,\n", + " 'ReadoutF1Err': 0.0886,\n", + " 'SingleQubitErrRate': 0.00092,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 34.827,\n", + " 'T2': 4.462},\n", + " 7: {'Freqency': 4462.32,\n", + " 'Qubit': 7,\n", + " 'ReadoutF0Err': 0.0093,\n", + " 'ReadoutF1Err': 0.0685,\n", + " 'SingleQubitErrRate': 0.00057,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 28.269,\n", + " 'T2': 13.429},\n", + " 8: {'Freqency': 4335.36,\n", + " 'Qubit': 8,\n", + " 'ReadoutF0Err': 0.0151,\n", + " 'ReadoutF1Err': 0.0728,\n", + " 'SingleQubitErrRate': 0.00103,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 30.782,\n", + " 'T2': 16.393}},\n", + " 'langs': ['tQASM', 'eQASM'],\n", + " 'memo': 'tQLab 9Gmon',\n", + " 'usage': '9gmon?o=0 \\nthe o(ptimized) to specify optimization level bits: both = 3 (bits 11) = gate decomposition = 2 (bit 10) | qubit mapping = 1 (bit 01)',\n", + " 'native_gates': ['h', 'rz', 'x', 'y', 'z', 'cz', 'cx']}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d.list_properties()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b44f1844", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Freqency': 4335.36,\n", + " 'Qubit': 8,\n", + " 'ReadoutF0Err': 0.0151,\n", + " 'ReadoutF1Err': 0.0728,\n", + " 'SingleQubitErrRate': 0.00103,\n", + " 'SingleQubitGateLenInNs': 40,\n", + " 'T1': 30.782,\n", + " 'T2': 16.393}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d.list_properties()[\"bits\"][8]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ae4798dc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(['h', 'rz', 'x', 'y', 'z', 'cz', 'cx'], 'tianxuan_s1', tencent)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# some meta data for the device\n", + "\n", + "d.native_gates(), d.name, d.provider" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ade0fb23", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[0, 1],\n", + " [6, 2],\n", + " [4, 0],\n", + " [0, 4],\n", + " [8, 4],\n", + " [1, 5],\n", + " [3, 7],\n", + " [0, 3],\n", + " [2, 0],\n", + " [5, 1],\n", + " [3, 0],\n", + " [7, 3],\n", + " [0, 2],\n", + " [2, 6],\n", + " [4, 8],\n", + " [1, 0]]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# bidirectional coupling maps\n", + "\n", + "d.topology()" + ] + }, + { + "cell_type": "markdown", + "id": "dcea5cfe", + "metadata": {}, + "source": [ + "## Tasks" + ] + }, + { + "cell_type": "markdown", + "id": "3ad38549", + "metadata": {}, + "source": [ + "Submit a simple two-qubit task.\n", + "\n", + "Note that there is no need to explicitly add any measurement operations to the circuit. By default, t.results will return the number of (Z-basis) measurement outcomes for all (in this case 2) qubits in the specified circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "01a0fb92", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'00': 501, '11': 419, '10': 56, '01': 48}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = tc.Circuit(2)\n", + "c.H(0)\n", + "c.cx(0, 1)\n", + "\n", + "t = tc.cloud.apis.submit_task(device=d, circuit=c, shots=1024)\n", + "\n", + "t.results() # this will wait until the result is return" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "33b9eb5a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.draw(output=\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "88cfc4ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tc.results.counts.plot_histogram(t.results())" + ] + }, + { + "cell_type": "markdown", + "id": "0596e9f1", + "metadata": {}, + "source": [ + "Check with the analytical exact result, using tensorcircuit's sota tensornetwork based simulation engine" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "dd798dd7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.49999997 0. 0. 0.49999997]\n", + "{'00': 0.4999999701976776, '11': 0.4999999701976776}\n" + ] + } + ], + "source": [ + "p = c.probability()\n", + "print(p)\n", + "exact_result = tc.results.counts.vec2count(p, prune=True)\n", + "print(exact_result)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "0d5ca58d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tc.results.counts.plot_histogram([t.results(), exact_result])" + ] + }, + { + "cell_type": "markdown", + "id": "d48cb1c1", + "metadata": {}, + "source": [ + "Let us further investigate the Task object ``t`` returned by ``submit_task``" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "598448da", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'id': 'b29e6517-d1da-48fa-99d2-2ef7cd67e376',\n", + " 'queue': 'txq.low',\n", + " 'device': 'tianxuan_s1?o=3',\n", + " 'qubits': 2,\n", + " 'depth': 3,\n", + " 'state': 'completed',\n", + " 'shots': 1024,\n", + " 'prior': 1,\n", + " 'at': datetime.datetime(2023, 5, 22, 16, 28, 25, 529635),\n", + " 'ts': {'completed': datetime.datetime(2023, 5, 22, 16, 28, 25, 529635),\n", + " 'pending': datetime.datetime(2023, 5, 22, 16, 28, 23, 704629),\n", + " 'scheduled': datetime.datetime(2023, 5, 22, 16, 28, 23, 699405)},\n", + " 'md5': '9cb407b41938a256ec15dfec163dca1d',\n", + " 'runAt': 1684744128022598,\n", + " 'runDur': 1073553,\n", + " 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[2];\\nh q[0];\\ncx q[0],q[1];',\n", + " 'version': '1',\n", + " 'lang': 'OPENQASM',\n", + " 'result': {'00': 501, '01': 48, '10': 56, '11': 419},\n", + " 'optimization': {'progs': [{'code': 'Tencent Quantum Program\\nversion 1.0\\nqubit involved: q0,q1,q2,q3,q4,q5,q6,q7,q8\\n# section: eqasm\\n# section lines 3\\neqasm program\\nbs 1 H q0\\nbs 1 CX (q0, q1)\\nMEASZ q0,q1\\n# section: end\\n',\n", + " 'lang': 'QEXE'},\n", + " {'code': 'Tencent Quantum Program\\nversion 1.0\\nqubit involved: q0,q1,q2,q3,q4,q5,q6,q7,q8\\n# section: eqasm\\n# section lines 3\\neqasm program\\nbs 1 H q0\\nbs 1 CX (q0, q1)\\nMEASZ q0,q1\\n# section: end\\n',\n", + " 'lang': 'QEXE_COMPACT'}],\n", + " 'pairs': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8}},\n", + " 'results': {'00': 501, '01': 48, '10': 56, '11': 419},\n", + " 'frontend': ,\n", + " 'backend': }" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.details(prettify=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c6a539ab", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'completed'" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.status()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b3fcd4ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'b29e6517-d1da-48fa-99d2-2ef7cd67e376'" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.id_" + ] + }, + { + "cell_type": "markdown", + "id": "f951f18c", + "metadata": {}, + "source": [ + "The task can be retrieved from cloud with the id without task object `t`" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "00e6c83d", + "metadata": {}, + "outputs": [], + "source": [ + "t1 = tc.cloud.apis.get_task(t.id_)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "19a5e66b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
     ┌───┐     \n",
+       "q_0: ┤ H ├──■──\n",
+       "     └───┘┌─┴─┐\n",
+       "q_1: ─────┤ X ├\n",
+       "          └───┘
" + ], + "text/plain": [ + " ┌───┐ \n", + "q_0: ┤ H ├──■──\n", + " └───┘┌─┴─┐\n", + "q_1: ─────┤ X ├\n", + " └───┘" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t1.details(prettify=True)[\"frontend\"].draw()\n", + "# exactly the task we submitted" + ] + }, + { + "cell_type": "markdown", + "id": "ce9f8313", + "metadata": {}, + "source": [ + "## Cloud simulator\n", + "\n", + "We can also submit tasks to run on tc simulators on the cloud, the only thing you need to change is the device name" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "adadefd1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'00': 520, '11': 504}" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = tc.Circuit(2)\n", + "c.H(0)\n", + "c.cx(0, 1)\n", + "\n", + "t = tc.cloud.apis.submit_task(device=\"simulator:tc\", circuit=c, shots=1024)\n", + "\n", + "t.results() # this will wait until the result is return\n", + "# instead, using wait=False for t.results(wait=False), the task objects can be returned in async mode" + ] + }, + { + "cell_type": "markdown", + "id": "c00c7dde", + "metadata": {}, + "source": [ + "**Batch submission:** Tasks can also submitted in batch, either on real devices or on simulators, a list of task object is returned by ``submit_task``, if the circuit submitted is in a list" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7f57f4e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'10': 528, '00': 475, '11': 12, '01': 9}\n", + "{'00': 524, '01': 479, '10': 14, '11': 7}\n" + ] + } + ], + "source": [ + "c1 = tc.Circuit(2)\n", + "c1.h(0)\n", + "\n", + "c2 = tc.Circuit(2)\n", + "c2.h(1)\n", + "\n", + "ts = tc.cloud.apis.submit_task(device=d, circuit=[c1, c2], shots=1024)\n", + "for t in ts:\n", + " print(t.results())" + ] + }, + { + "cell_type": "markdown", + "id": "1e72f1ab", + "metadata": {}, + "source": [ + "## Compling: gate decomposition and qubit mapping" + ] + }, + { + "cell_type": "markdown", + "id": "7bea5aba", + "metadata": {}, + "source": [ + "Say we want to simulate the following logic circuit, however, the gate set and the coupling for two-qubit gates are both incompatible with our real device" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "2fc080c9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
     ┌──────────┐          ┌─┐                      \n",
+       "q_0: ┤ Rx(1.57) ├──■───────┤M├──────────────────────\n",
+       "     └──────────┘┌─┴─┐     └╥┘     ┌─┐              \n",
+       "q_1: ────────────┤ X ├──■───╫──────┤M├──────────────\n",
+       "                 └───┘┌─┴─┐ ║      └╥┘     ┌─┐      \n",
+       "q_2: ─────────────────┤ X ├─╫───■───╫──────┤M├──────\n",
+       "                      └───┘ ║ ┌─┴─┐ ║      └╥┘┌─┐   \n",
+       "q_3: ───────────────────────╫─┤ X ├─╫───■───╫─┤M├───\n",
+       "                            ║ └───┘ ║ ┌─┴─┐ ║ └╥┘┌─┐\n",
+       "q_4: ───────────────────────╫───────╫─┤ X ├─╫──╫─┤M├\n",
+       "                            ║       ║ └───┘ ║  ║ └╥┘\n",
+       "c: 5/═══════════════════════╩═══════╩═══════╩══╩══╩═\n",
+       "                            0       1       2  3  4
" + ], + "text/plain": [ + " ┌──────────┐ ┌─┐ \n", + "q_0: ┤ Rx(1.57) ├──■───────┤M├──────────────────────\n", + " └──────────┘┌─┴─┐ └╥┘ ┌─┐ \n", + "q_1: ────────────┤ X ├──■───╫──────┤M├──────────────\n", + " └───┘┌─┴─┐ ║ └╥┘ ┌─┐ \n", + "q_2: ─────────────────┤ X ├─╫───■───╫──────┤M├──────\n", + " └───┘ ║ ┌─┴─┐ ║ └╥┘┌─┐ \n", + "q_3: ───────────────────────╫─┤ X ├─╫───■───╫─┤M├───\n", + " ║ └───┘ ║ ┌─┴─┐ ║ └╥┘┌─┐\n", + "q_4: ───────────────────────╫───────╫─┤ X ├─╫──╫─┤M├\n", + " ║ ║ └───┘ ║ ║ └╥┘\n", + "c: 5/═══════════════════════╩═══════╩═══════╩══╩══╩═\n", + " 0 1 2 3 4 " + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = tc.Circuit(5)\n", + "c.rx(0, theta=1.57)\n", + "for i in range(4):\n", + " c.cx(i, i + 1)\n", + "c.measure_instruction(*range(5))\n", + "# note for tasks involving qubit mapping, we recommend you add the measure instruction explicitly\n", + "c.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "ea2b3692", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'00000': 541, '11111': 483}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the ideal answer\n", + "c.sample(allow_state=True, batch=1024, format=\"count_dict_bin\")" + ] + }, + { + "cell_type": "markdown", + "id": "79349e8e", + "metadata": {}, + "source": [ + "By default the backend compiler options are both enabled which we write expicitly below" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "f381a9f7", + "metadata": {}, + "outputs": [], + "source": [ + "t = tc.cloud.apis.submit_task(\n", + " circuit=c,\n", + " shots=1024,\n", + " device=d,\n", + " enable_qos_gate_decomposition=True,\n", + " enable_qos_qubit_mapping=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "0704b37f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'00000': 460,\n", + " '11111': 246,\n", + " '01111': 43,\n", + " '10000': 31,\n", + " '11101': 29,\n", + " '00011': 22,\n", + " '11100': 21,\n", + " '11011': 18,\n", + " '00100': 17,\n", + " '10111': 17,\n", + " '11110': 17,\n", + " '11000': 12,\n", + " '00001': 11,\n", + " '00010': 11,\n", + " '10100': 10,\n", + " '00111': 9,\n", + " '01000': 8,\n", + " '01011': 7,\n", + " '10011': 7,\n", + " '10101': 4,\n", + " '00110': 3,\n", + " '01110': 3,\n", + " '10001': 3,\n", + " '10110': 3,\n", + " '11010': 3,\n", + " '01010': 2,\n", + " '01100': 2,\n", + " '01101': 2,\n", + " '00101': 1,\n", + " '10010': 1,\n", + " '11001': 1}" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.results()" + ] + }, + { + "cell_type": "markdown", + "id": "9847ccaa", + "metadata": {}, + "source": [ + "We can inspect the circuit compiled after the backend server compiling:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "24748fe7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
     ┌────────────┐┌───┐┌───┐┌────────────┐┌────────────┐┌─────────────┐»\n",
+       "q_0: ┤ Rz(1.5708) ├┤ S ├┤ H ├┤ Rz(0.7854) ├┤ Rz(0.3927) ├┤ Rz(0.19635) ├»\n",
+       "     └────────────┘└───┘└───┘└────────────┘└────────────┘└─────────────┘»\n",
+       "q_1: ───────────────────────────────────────────────────────────────────»\n",
+       "                                                                        »\n",
+       "q_2: ───────────────────────────────────────────────────────────────────»\n",
+       "                                                                        »\n",
+       "q_3: ───────────────────────────────────────────────────────────────────»\n",
+       "                                                                        »\n",
+       "q_4: ───────────────────────────────────────────────────────────────────»\n",
+       "                                                                        »\n",
+       "«     ┌──────────────┐┌──────────────┐┌──────────────┐┌──────────────┐»\n",
+       "«q_0: ┤ Rz(0.098175) ├┤ Rz(0.049087) ├┤ Rz(0.024544) ├┤ Rz(0.012272) ├»\n",
+       "«     └──────────────┘└──────────────┘└──────────────┘└──────────────┘»\n",
+       "«q_1: ────────────────────────────────────────────────────────────────»\n",
+       "«                                                                     »\n",
+       "«q_2: ────────────────────────────────────────────────────────────────»\n",
+       "«                                                                     »\n",
+       "«q_3: ────────────────────────────────────────────────────────────────»\n",
+       "«                                                                     »\n",
+       "«q_4: ────────────────────────────────────────────────────────────────»\n",
+       "«                                                                     »\n",
+       "«     ┌───────────────┐┌──────────────┐┌──────────────┐┌───────────────┐»\n",
+       "«q_0: ┤ Rz(0.0061359) ├┤ Rz(0.003068) ├┤ Rz(0.001534) ├┤ Rz(0.0003835) ├»\n",
+       "«     └───────────────┘└──────────────┘└──────────────┘└───────────────┘»\n",
+       "«q_1: ──────────────────────────────────────────────────────────────────»\n",
+       "«                                                                       »\n",
+       "«q_2: ──────────────────────────────────────────────────────────────────»\n",
+       "«                                                                       »\n",
+       "«q_3: ──────────────────────────────────────────────────────────────────»\n",
+       "«                                                                       »\n",
+       "«q_4: ──────────────────────────────────────────────────────────────────»\n",
+       "«                                                                       »\n",
+       "«     ┌────────────────┐┌────────────────┐┌───┐┌─────┐┌────────────┐»\n",
+       "«q_0: ┤ Rz(0.00019175) ├┤ Rz(9.5874e-05) ├┤ H ├┤ Sdg ├┤ Rz(3.1416) ├»\n",
+       "«     └────────────────┘└────────────────┘└───┘└─────┘└────────────┘»\n",
+       "«q_1: ──────────────────────────────────────────────────────────────»\n",
+       "«                                                                   »\n",
+       "«q_2: ──────────────────────────────────────────────────────────────»\n",
+       "«                                                                   »\n",
+       "«q_3: ──────────────────────────────────────────────────────────────»\n",
+       "«                                                                   »\n",
+       "«q_4: ──────────────────────────────────────────────────────────────»\n",
+       "«                                                                   »\n",
+       "«     ┌────────────┐          ┌───┐          ┌───┐     ┌───┐┌───┐     \n",
+       "«q_0: ┤ Rz(1.5708) ├──■────■──┤ X ├──■────■──┤ X ├──■──┤ X ├┤ X ├──■──\n",
+       "«     └────────────┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐  │  └─┬─┘  │  └─┬─┘└─┬─┘  │  \n",
+       "«q_1: ──────────────┤ X ├┤ X ├──■──┤ X ├──┼────┼────┼────┼────┼────┼──\n",
+       "«                   └───┘└───┘     └───┘┌─┴─┐  │    │    │    │    │  \n",
+       "«q_2: ──────────────────────────────────┤ X ├──┼────┼────┼────■────┼──\n",
+       "«                                       └───┘  │  ┌─┴─┐  │         │  \n",
+       "«q_3: ─────────────────────────────────────────■──┤ X ├──■─────────┼──\n",
+       "«                                                 └───┘          ┌─┴─┐\n",
+       "«q_4: ───────────────────────────────────────────────────────────┤ X ├\n",
+       "«                                                                └───┘
" + ], + "text/plain": [ + " ┌────────────┐┌───┐┌───┐┌────────────┐┌────────────┐┌─────────────┐»\n", + "q_0: ┤ Rz(1.5708) ├┤ S ├┤ H ├┤ Rz(0.7854) ├┤ Rz(0.3927) ├┤ Rz(0.19635) ├»\n", + " └────────────┘└───┘└───┘└────────────┘└────────────┘└─────────────┘»\n", + "q_1: ───────────────────────────────────────────────────────────────────»\n", + " »\n", + "q_2: ───────────────────────────────────────────────────────────────────»\n", + " »\n", + "q_3: ───────────────────────────────────────────────────────────────────»\n", + " »\n", + "q_4: ───────────────────────────────────────────────────────────────────»\n", + " »\n", + "« ┌──────────────┐┌──────────────┐┌──────────────┐┌──────────────┐»\n", + "«q_0: ┤ Rz(0.098175) ├┤ Rz(0.049087) ├┤ Rz(0.024544) ├┤ Rz(0.012272) ├»\n", + "« └──────────────┘└──────────────┘└──────────────┘└──────────────┘»\n", + "«q_1: ────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_2: ────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_3: ────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_4: ────────────────────────────────────────────────────────────────»\n", + "« »\n", + "« ┌───────────────┐┌──────────────┐┌──────────────┐┌───────────────┐»\n", + "«q_0: ┤ Rz(0.0061359) ├┤ Rz(0.003068) ├┤ Rz(0.001534) ├┤ Rz(0.0003835) ├»\n", + "« └───────────────┘└──────────────┘└──────────────┘└───────────────┘»\n", + "«q_1: ──────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_2: ──────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_3: ──────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_4: ──────────────────────────────────────────────────────────────────»\n", + "« »\n", + "« ┌────────────────┐┌────────────────┐┌───┐┌─────┐┌────────────┐»\n", + "«q_0: ┤ Rz(0.00019175) ├┤ Rz(9.5874e-05) ├┤ H ├┤ Sdg ├┤ Rz(3.1416) ├»\n", + "« └────────────────┘└────────────────┘└───┘└─────┘└────────────┘»\n", + "«q_1: ──────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_2: ──────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_3: ──────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_4: ──────────────────────────────────────────────────────────────»\n", + "« »\n", + "« ┌────────────┐ ┌───┐ ┌───┐ ┌───┐┌───┐ \n", + "«q_0: ┤ Rz(1.5708) ├──■────■──┤ X ├──■────■──┤ X ├──■──┤ X ├┤ X ├──■──\n", + "« └────────────┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐ │ └─┬─┘ │ └─┬─┘└─┬─┘ │ \n", + "«q_1: ──────────────┤ X ├┤ X ├──■──┤ X ├──┼────┼────┼────┼────┼────┼──\n", + "« └───┘└───┘ └───┘┌─┴─┐ │ │ │ │ │ \n", + "«q_2: ──────────────────────────────────┤ X ├──┼────┼────┼────■────┼──\n", + "« └───┘ │ ┌─┴─┐ │ │ \n", + "«q_3: ─────────────────────────────────────────■──┤ X ├──■─────────┼──\n", + "« └───┘ ┌─┴─┐\n", + "«q_4: ───────────────────────────────────────────────────────────┤ X ├\n", + "« └───┘" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.details(prettify=True)[\"backend\"].draw(idle_wires=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5f0ad718", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 1, 1: 3, 2: 2, 3: 0, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8}" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.get_logical_physical_mapping() # the logical qubit - physical qubit mapping is also returned by the server" + ] + }, + { + "cell_type": "markdown", + "id": "98b2b053", + "metadata": {}, + "source": [ + "To better customize and use the advanced compiling system, we strongly recommend the users to compile the circuit before task submission" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "4debc9ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'logical_physical_mapping': {0: 6, 1: 2, 2: 0, 3: 3, 4: 7}, 'positional_logical_mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}}\n" + ] + }, + { + "data": { + "text/html": [ + "
                                ┌───┐             ┌─┐      \n",
+       "q_0: ───────────────────────────┤ X ├──■──────────┤M├──────\n",
+       "                           ┌───┐└─┬─┘  │  ┌─┐     └╥┘      \n",
+       "q_2: ──────────────────────┤ X ├──■────┼──┤M├──────╫───────\n",
+       "                           └─┬─┘     ┌─┴─┐└╥┘      ║ ┌─┐   \n",
+       "q_3: ────────────────────────┼───────┤ X ├─╫───■───╫─┤M├───\n",
+       "     ┌───┐┌──────────┐┌───┐  │   ┌─┐ └───┘ ║   │   ║ └╥┘   \n",
+       "q_6: ┤ H ├┤ Rz(1.57) ├┤ H ├──■───┤M├───────╫───┼───╫──╫────\n",
+       "     └───┘└──────────┘└───┘      └╥┘       ║ ┌─┴─┐ ║  ║ ┌─┐\n",
+       "q_7: ─────────────────────────────╫────────╫─┤ X ├─╫──╫─┤M├\n",
+       "                                  ║        ║ └───┘ ║  ║ └╥┘\n",
+       "c: 9/═════════════════════════════╩════════╩═══════╩══╩══╩═\n",
+       "                                  6        2       0  3  7
" + ], + "text/plain": [ + " ┌───┐ ┌─┐ \n", + "q_0: ───────────────────────────┤ X ├──■──────────┤M├──────\n", + " ┌───┐└─┬─┘ │ ┌─┐ └╥┘ \n", + "q_2: ──────────────────────┤ X ├──■────┼──┤M├──────╫───────\n", + " └─┬─┘ ┌─┴─┐└╥┘ ║ ┌─┐ \n", + "q_3: ────────────────────────┼───────┤ X ├─╫───■───╫─┤M├───\n", + " ┌───┐┌──────────┐┌───┐ │ ┌─┐ └───┘ ║ │ ║ └╥┘ \n", + "q_6: ┤ H ├┤ Rz(1.57) ├┤ H ├──■───┤M├───────╫───┼───╫──╫────\n", + " └───┘└──────────┘└───┘ └╥┘ ║ ┌─┴─┐ ║ ║ ┌─┐\n", + "q_7: ─────────────────────────────╫────────╫─┤ X ├─╫──╫─┤M├\n", + " ║ ║ └───┘ ║ ║ └╥┘\n", + "c: 9/═════════════════════════════╩════════╩═══════╩══╩══╩═\n", + " 6 2 0 3 7 " + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c1, info = tc.compiler.default_compile(\n", + " c, compiled_options={\"coupling_map\": d.topology()}\n", + ")\n", + "print(info)\n", + "c1.draw(idle_wires=False)" + ] + }, + { + "cell_type": "markdown", + "id": "258236df", + "metadata": {}, + "source": [ + "We now submit the compiled circuit ``c1`` for the qcloud, with now the ``logical_physical_mapping`` in ``info``, the result is improved with tc built in compiler" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "3a165a8c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'00000': 442,\n", + " '11111': 295,\n", + " '01111': 66,\n", + " '11011': 34,\n", + " '11110': 29,\n", + " '10000': 26,\n", + " '10111': 22,\n", + " '11101': 16,\n", + " '11000': 15,\n", + " '01000': 14,\n", + " '00111': 11,\n", + " '11100': 10,\n", + " '00011': 9,\n", + " '00100': 5,\n", + " '01011': 5,\n", + " '10011': 5,\n", + " '01101': 4,\n", + " '11001': 4,\n", + " '01100': 3,\n", + " '01110': 3,\n", + " '00001': 2,\n", + " '00010': 1,\n", + " '00110': 1,\n", + " '10110': 1,\n", + " '11010': 1}" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = tc.cloud.apis.submit_task(\n", + " circuit=c1,\n", + " shots=1024,\n", + " device=d,\n", + " enable_qos_gate_decomposition=False,\n", + " enable_qos_qubit_mapping=False,\n", + ")\n", + "t.results()" + ] + }, + { + "cell_type": "markdown", + "id": "60ba2314", + "metadata": {}, + "source": [ + "## Readout Error Mitigation" + ] + }, + { + "cell_type": "markdown", + "id": "acc9f9ab", + "metadata": {}, + "source": [ + "The results can be further improved via readout error mitigation" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "da287ca9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'00000': 496.04758924971736,\n", + " '11111': 425.0199159717411,\n", + " '01111': 47.435856968160266,\n", + " '11000': 13.069671146547593,\n", + " '11110': 11.714948398147767,\n", + " '11100': 9.142744304288023,\n", + " '00111': 7.038018388943233,\n", + " '00011': 6.1005198202968645,\n", + " '10111': 5.016879874015307,\n", + " '10000': 2.2494050992135244,\n", + " '11101': 1.164450778928778}" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mit = tc.results.rem.ReadoutMit(d.name + \"?o=0\")\n", + "mit.cals_from_system(9)\n", + "mr = mit.apply_correction(t.results(), qubits=5, **info)\n", + "mr" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "1cbf19de", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tc.results.counts.plot_histogram([t.results(), mr], number_to_keep=2)" + ] + }, + { + "cell_type": "markdown", + "id": "73a6c287", + "metadata": {}, + "source": [ + "We can also collect the readout calibriation from the API, but the results can be wrose since it is not up to date" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "43ea80ec", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mit1 = tc.results.rem.ReadoutMit(d.name + \"?o=0\")\n", + "mit1.cals_from_api(9)\n", + "mr1 = mit1.apply_correction(t.results(), qubits=5, **info)\n", + "tc.results.counts.plot_histogram([mr, mr1], number_to_keep=2)" + ] + }, + { + "cell_type": "markdown", + "id": "8ec8d9c8", + "metadata": {}, + "source": [ + "Readout error mitigation in tc supports many other options for subset measurement, scalable mitigation for hundereds of qubits, customized calibriation in local and global mode and native error mitigated expectations, please refer to the API documentation for more interesting usages. For example, we can directly compute the expectation $$ (ideal value should be 1) as" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "77e7d8e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array(1.+0.j, dtype=complex64), 0.9555765968884041)" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.expectation_ps(z=[0, 1]), mit.expectation(t.results(), [0, 1])" + ] + }, + { + "cell_type": "markdown", + "id": "7b156c6f", + "metadata": {}, + "source": [ + "## High level API\n", + "\n", + "Ultimately, for near term quantum computing tasks, the users only want to evaluate some given observable expectation for a circuit without worrying too much details above: compilation, error mitigation, subset measruement, positional/logical/physical mapping etc. Therefore, for most of the applications, `batch_expectation_ps` method is all you need." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "2100ff5d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.90996515])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tc.cloud.wrapper.batch_expectation_ps(c, pss=[[3, 3, 0, 0, 0]], device=d)\n", + "# compute Z0Z1" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "c405123f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(1.70569329)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tc.cloud.wrapper.batch_expectation_ps(\n", + " c, pss=[[3, 3, 0, 0, 0], [0, 3, 3, 0, 0]], device=d, ws=[1, 0.5]\n", + ")\n", + "# compute Z0Z1 + 0.5*Z1Z2" + ] + }, + { + "cell_type": "markdown", + "id": "0965380b", + "metadata": {}, + "source": [ + "The interface is also unifying the numerical simulation (exact) interface with QPU experiments, by spcifying the device as ``None``, we can obtain the expected result from tc simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "5744293b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.5" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tc.cloud.wrapper.batch_expectation_ps(\n", + " c, pss=[[3, 3, 0, 0, 0], [0, 3, 3, 0, 0]], device=None, ws=[1, 0.5]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "300cff3a", + "metadata": {}, + "source": [ + "The results with readout error mitigation disabled can become worse. Note how we cache the readout error calibriation within tc, so that REM is effcient to use" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "0e49467d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(1.25073242)" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tc.cloud.wrapper.batch_expectation_ps(\n", + " c, pss=[[3, 3, 0, 0, 0], [0, 3, 3, 0, 0]], device=d, ws=[1, 0.5], with_rem=False\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "da002ef1", + "metadata": {}, + "source": [ + "**QPU support for tf/torch ML:** Above this API, we also have corresponding keras and torch layers for hybrid deployment" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "718d7215", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "the contraction path is given as [(0, 1), (0, 1), (0, 1), (0, 1)]\n", + "----- WRITE: 7.20945336562895 --------\n", + "\n", + "the contraction path is given as [(0, 2), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1), (0, 1), (0, 1)]\n", + "----- WRITE: 7.20945336562895 --------\n", + "\n", + "the contraction path is given as [(0, 2), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n", + "the contraction path is given as [(0, 1), (0, 1)]\n", + "----- WRITE: 6.189824558880018 --------\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Z_i: [[3, 0, 0, 0, 0], [0, 3, 0, 0, 0], [0, 0, 3, 0, 0], [0, 0, 0, 3, 0], [0, 0, 0, 0, 3]]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import tensorflow as tf\n", + "from functools import partial\n", + "import logging\n", + "\n", + "tc.set_backend(\"tensorflow\")\n", + "logger = logging.getLogger(\"tensorcircuit\")\n", + "logger.setLevel(logging.INFO)\n", + "ch = logging.StreamHandler()\n", + "ch.setLevel(logging.DEBUG)\n", + "logger.addHandler(ch)\n", + "\n", + "pss = []\n", + "for i in range(5):\n", + " ps = [0 for _ in range(5)]\n", + " ps[i] = 3 # Z_i\n", + " pss.append(ps)\n", + "print(\"Z_i:\", pss)\n", + "\n", + "\n", + "def quantum_func(inputs, weights, device=None):\n", + " c = tc.Circuit(5)\n", + " for i in range(5):\n", + " c.rx(i, theta=inputs[i])\n", + " for i in range(5):\n", + " c.rz(i, theta=weights[0, i])\n", + " for i in range(5):\n", + " c.rx(i, theta=weights[1, i])\n", + " return tc.cloud.wrapper.batch_expectation_ps(c, pss=pss, device=device)\n", + "\n", + "\n", + "qlayer = tc.KerasHardwareLayer(quantum_func, [2, 5])\n", + "model = tf.keras.Sequential([qlayer, tf.keras.layers.Dense(1)])\n", + "inputs = tf.stack([0.1 * tf.ones([5]), 0.2 * tf.ones([5])])\n", + "model(inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "0ec02dac", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "submit task on tencent::tianxuan_s1 for 1 circuits\n", + "finished collecting count results of 1 tasks in 5.1344 seconds\n", + "submit task on tencent::tianxuan_s1 for 1 circuits\n", + "finished collecting count results of 1 tasks in 5.0256 seconds\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qlayer1 = tc.KerasHardwareLayer(partial(quantum_func, device=d), [2, 5])\n", + "model1 = tf.keras.Sequential([qlayer1, tf.keras.layers.Dense(1)])\n", + "model1(inputs)" + ] + }, + { + "cell_type": "markdown", + "id": "3b5423ca", + "metadata": {}, + "source": [ + "we align the weights between the two models" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "ab5ca8a5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "submit task on tencent::tianxuan_s1 for 1 circuits\n", + "finished collecting count results of 1 tasks in 4.121 seconds\n", + "submit task on tencent::tianxuan_s1 for 1 circuits\n", + "finished collecting count results of 1 tasks in 4.0726 seconds\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model1.set_weights(model.get_weights())\n", + "model1(inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "16cb1252", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_1\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " hardware_layer_1 (HardwareL multiple 10 \n", + " ayer) \n", + " \n", + " dense_1 (Dense) multiple 6 \n", + " \n", + "=================================================================\n", + "Total params: 16\n", + "Trainable params: 16\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model1.summary()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index dc99ed80..05735fb0 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -65,7 +65,7 @@ def list_properties(device: Device, token: Optional[str] = None) -> Dict[str, An for bit in r["bits"]: bits_dict[bit["Qubit"]] = bit r["bits"] = bits_dict - r["native_gates"] = ["h", "rz", "x", "y", "z", "cz"] # handcoded + r["native_gates"] = ["h", "rz", "x", "y", "z", "cz", "cx"] # handcoded return r # type: ignore else: raise ValueError("No device with the name: %s" % device) From b6ef803e5a69fc0b4adfa8b70b7d69bae37e8447 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 23 May 2023 17:23:52 +0800 Subject: [PATCH 460/725] add batch index --- CHANGELOG.md | 2 ++ tensorcircuit/abstractcircuit.py | 32 ++++++++++++++++++++++++++++++-- tests/test_circuit.py | 14 ++++++++++++++ 3 files changed, 46 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bcfaf9f2..0b32ad38 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,8 @@ - Add tc version print in `tc.about()` method +- tc now supports fancy batch indexing for gates, e.g. `c.rxx([0, 1, 2], [1, 2, 3], theta=K.ones([3]))` + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 27d9a1cd..cf02f920 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -17,6 +17,7 @@ from .cons import backend, dtypestr from .vis import qir2tex from .quantum import QuOperator +from .utils import is_sequence logger = logging.getLogger(__name__) @@ -128,7 +129,25 @@ def apply(self: "AbstractCircuit", *index: int, **vars: Any) -> None: ir_dict=gate_dict, ) - return apply + def apply_list(self: "AbstractCircuit", *index: int, **vars: Any) -> None: + if isinstance(index[0], int): + apply(self, *index, **vars) + elif is_sequence(index[0]): + for i, ind in enumerate(zip(*index)): + nvars = {} + for k, v in vars.items(): + try: + nvars[k] = v[i] + except Exception: # pylint: disable=W0703 + # (TypeError, IndexError) is not enough, + # tensorflow.python.framework.errors_impl.InvalidArgumentError + # not ideally captured here + nvars[k] = v + apply(self, *ind, **nvars) + else: + raise ValueError("Illegal index specification") + + return apply_list @staticmethod def apply_general_gate_delayed( @@ -167,7 +186,16 @@ def apply( ir_dict=gate_dict, ) - return apply + def apply_list(self: "AbstractCircuit", *index: int, **kws: Any) -> None: + if isinstance(index[0], int): + apply(self, *index, **kws) + elif is_sequence(index[0]): + for ind in zip(*index): + apply(self, *ind, **kws) + else: + raise ValueError("Illegal index specification") + + return apply_list @classmethod def _meta_apply(cls) -> None: diff --git a/tests/test_circuit.py b/tests/test_circuit.py index e91eeca6..c758e2aa 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1559,3 +1559,17 @@ def simple_ansatz(param): vs, gs = v_ansatz(K.ones([2, 3], dtype="float32")) assert K.shape_tuple(gs) == (2, 3) np.testing.assert_allclose(K.numpy(vs), -1.0 * K.ones([2]), atol=1e-5) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("npb")]) +def test_fancy_circuit_indexing(backend): + c = tc.Circuit(4) + c.cx([0, 1], [-1, -2]) + c.h(list(range(c._nqubits))) + c.rz([0], theta=0.2) + c.rx([1, 2], theta=[0.3, 0.5]) + c.rzz([2, 3], [0, 1], theta=tc.backend.ones([2])) + c.rxx([2, 0, 1], [0, 1, 2], theta=tc.backend.ones([1])) + assert c.gate_count("h") == 4 + assert c.gate_count("rzz") == 2 + assert c.gate_count("rxx") == 3 From a5640d6c8a51731b41f5445962ff275ba9a69159 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 24 May 2023 20:12:27 +0800 Subject: [PATCH 461/725] update readme: add ra training project --- README.md | 12 +++++++++--- README_cn.md | 12 +++++++++--- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index e397d444..cd6d0d35 100644 --- a/README.md +++ b/README.md @@ -222,14 +222,20 @@ For the numerical demosntration of discrete time crystal enabled by Stark many-b Reference paper: https://arxiv.org/abs/2208.02866 (published in PRL). -### EMQAOA-DARBO +### RA-Training -For the numerical simulation and hardware experiments with error mitigation on QAOA, see the [project repo](https://github.com/sherrylixuecheng/EMQAOA-DARBO). +For the numerical simulation of variational quantum algorithm training using random gate activation strategy by us, see the [project repo](https://github.com/ls-iastu/RAtraining). -Reference paper: https://arxiv.org/abs/2303.14877. +Reference paper: https://arxiv.org/abs/2303.08154. ### TenCirChem [TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) is an efficient and versatile quantum computation package for molecular properties. TenCirChem is based on TensorCircuit and is optimized for chemistry applications. Reference paper: https://arxiv.org/abs/2303.10825. + +### EMQAOA-DARBO + +For the numerical simulation and hardware experiments with error mitigation on QAOA, see the [project repo](https://github.com/sherrylixuecheng/EMQAOA-DARBO). + +Reference paper: https://arxiv.org/abs/2303.14877. diff --git a/README_cn.md b/README_cn.md index bc49327d..71e9f7d6 100644 --- a/README_cn.md +++ b/README_cn.md @@ -167,14 +167,20 @@ VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mb 参考论文: https://arxiv.org/abs/2208.02866 (PRL)。 -### EMQAOA-DARBO +### RA-Training -数值模拟和带错误消除的真实量子硬件实验验证 QAOA 优化的代码请参考 [项目](https://github.com/sherrylixuecheng/EMQAOA-DARBO)。 +利用我们提出的随机量子门激活策略训练优化变分量子算法的实现请参考 [项目](https://github.com/ls-iastu/RAtraining). -参考论文: https://arxiv.org/abs/2303.14877。 +参考论文: https://arxiv.org/abs/2303.08154. ### TenCirChem [TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) 是高效的，专注于处理和计算分子性质的量子计算软件。其基于 TensorCircuit 并为量子化学任务进行了专门的优化。 参考论文: https://arxiv.org/abs/2303.10825。 + +### EMQAOA-DARBO + +数值模拟和带错误消除的真实量子硬件实验验证 QAOA 优化的代码请参考 [项目](https://github.com/sherrylixuecheng/EMQAOA-DARBO)。 + +参考论文: https://arxiv.org/abs/2303.14877。 From b407dd9be1e13850e666569356472a4666c20c08 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 25 May 2023 10:32:42 +0800 Subject: [PATCH 462/725] update readme --- README.md | 4 ++-- README_cn.md | 10 +++++----- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index cd6d0d35..b6114b29 100644 --- a/README.md +++ b/README.md @@ -31,7 +31,7 @@ TensorCircuit is the next generation of quantum software framework with support for automatic differentiation, just-in-time compiling, hardware acceleration, and vectorized parallelism. -TensorCircuit is built on top of modern machine learning frameworks and is machine learning backend agnostic. It is specifically suitable for highly efficient simulations of quantum-classical hybrid paradigm and variational quantum algorithms. It also supports real quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions since v0.9. +TensorCircuit is built on top of modern machine learning frameworks: Jax, TensorFlow, and PyTorch. It is specifically suitable for highly efficient simulations of quantum-classical hybrid paradigm and variational quantum algorithms in ideal, noisy and approximation cases. It also supports real quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions since v0.9. ## Getting Started @@ -117,7 +117,7 @@ We also have [Docker support](/docker). - Elegance - - Flexibility: customized contraction, multiple ML backend/interface choices, multiple dtype precisions + - Flexibility: customized contraction, multiple ML backend/interface choices, multiple dtype precisions, multiple QPU providers - API design: quantum for humans, less code, more power diff --git a/README_cn.md b/README_cn.md index 71e9f7d6..88f8b385 100644 --- a/README_cn.md +++ b/README_cn.md @@ -25,11 +25,11 @@

English | 简体中文

-TensorCircuit 是下一代量子软件框架，支持自动微分、即时编译、硬件加速和向量并行化。 +TensorCircuit 是下一代量子软件框架，完美支持自动微分、即时编译、硬件加速和向量并行化。 -TensorCircuit 建立在现代机器学习框架之上，并且与机器学习后端无关。 它特别适用于量子经典混合范式和变分量子算法的高效模拟。 +TensorCircuit 建立在现代机器学习框架 Jax, TensorFlow, PyTorch 之上，支持机器学习后端无关的统一界面。 其特别适用于理想情况、含噪声情况及可控近似情况下，大规模量子经典混合范式和变分量子算法的高效模拟。 -TensorCircuit 现在支持真实量子硬件连接和实验，并提供优雅的 CPU/GPU/QPU 混合部署方案（v0.9+）。 +TensorCircuit 现在支持真实量子硬件连接和实验，并提供优雅的 CPU/GPU/QPU 混合部署训练方案（v0.9+）。 ## 入门 @@ -52,7 +52,7 @@ print(c.expectation_ps(z=[0, 1])) print(c.sample(allow_state=True, batch=1024, format="count_dict_bin")) ``` -- 运行时特性定制: +- 运行时特性设置: ```python tc.set_backend("tensorflow") @@ -115,7 +115,7 @@ pip install tensorcircuit-nightly - 优雅 - - 灵活性：自定义张量收缩、多种 ML 后端/接口选择、多种数值精度 + - 灵活性：自定义张量收缩、多种 ML 后端/接口选择、多种数值精度、多种量子硬件 - API 设计：人类可理解的量子，更少的代码，更多的可能 From 61f01d79c6bc0c2ffefa6aa4a410c27e32fab65f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 26 May 2023 14:39:34 +0800 Subject: [PATCH 463/725] add batch submit support for quafu backend --- tensorcircuit/cloud/quafu_provider.py | 31 ++++++++++++++++++--------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/tensorcircuit/cloud/quafu_provider.py b/tensorcircuit/cloud/quafu_provider.py index a852b905..f1d1f9bf 100644 --- a/tensorcircuit/cloud/quafu_provider.py +++ b/tensorcircuit/cloud/quafu_provider.py @@ -10,6 +10,7 @@ from .abstraction import Device, sep, Task from ..abstractcircuit import AbstractCircuit +from ..utils import is_sequence logger = logging.getLogger(__name__) @@ -43,18 +44,28 @@ def c2qasm(c: Any) -> str: s = c.to_openqasm() return s # type: ignore - source = c2qasm(circuit) + if not is_sequence(circuit): + source = c2qasm(circuit) + else: + source = [c2qasm(c) for c in circuit] # type: ignore user = User() user.save_apitoken(token) - nq = int(source.split("\n")[2].split("[")[1].split("]")[0]) # type: ignore - qc = QuantumCircuit(nq) - qc.from_openqasm(source) - task = Task_() - device_name = device.name.split(sep)[-1] - task.config(backend=device_name, shots=shots, compile=compile) - res = task.send(qc, wait=False) - wrapper = Task(res.taskid, device=device) - return wrapper + + def c2task(source: str) -> Task: + nq = int(source.split("\n")[2].split("[")[1].split("]")[0]) # type: ignore + qc = QuantumCircuit(nq) + qc.from_openqasm(source) + task = Task_() + device_name = device.name.split(sep)[-1] + task.config(backend=device_name, shots=shots, compile=compile) + res = task.send(qc, wait=False) + wrapper = Task(res.taskid, device=device) + return wrapper + + if not is_sequence(source): + return c2task(source) # type: ignore + else: + return [c2task(s) for s in source] # type: ignore def resubmit_task(task: Task, token: str) -> Task: From 38bbeb1e7eaab95424fc481a9f6f0d1a75f4465f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 26 May 2023 16:01:39 +0800 Subject: [PATCH 464/725] further fix jax sum bug in batch_expectation_ps --- tensorcircuit/cloud/wrapper.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 7d8d5c53..783921c1 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -196,7 +196,8 @@ def batch_expectation_ps( if ws is None: return backend.real(backend.stack(results)) else: - return backend.real(backend.sum([w * r for w, r in zip(ws, results)])) + sumr = sum([w * r for w, r in zip(ws, results)]) + return backend.convert_to_tensor(sumr) cs = [] infos = [] exps = [] From 5d35e256ae7e0afdd27fca3b88c56b7ad8af2958 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 26 May 2023 20:25:38 +0800 Subject: [PATCH 465/725] add group management --- CHANGELOG.md | 2 ++ tensorcircuit/cloud/tencent.py | 3 +++ 2 files changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0b32ad38..a6fa4f21 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,8 @@ - tc now supports fancy batch indexing for gates, e.g. `c.rxx([0, 1, 2], [1, 2, 3], theta=K.ones([3]))` +- Task management via group tag (when `submit_task` and `list_tasks`) + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/tensorcircuit/cloud/tencent.py b/tensorcircuit/cloud/tencent.py index 05735fb0..fc37460a 100644 --- a/tensorcircuit/cloud/tencent.py +++ b/tensorcircuit/cloud/tencent.py @@ -124,6 +124,7 @@ def submit_task( circuit: Optional[Union[AbstractCircuit, Sequence[AbstractCircuit]]] = None, source: Optional[Union[str, Sequence[str]]] = None, remarks: Optional[str] = None, + group: Optional[str] = None, compiling: bool = False, compiled_options: Optional[Dict[str, Any]] = None, enable_qiskit_initial_mapping: bool = False, @@ -261,6 +262,7 @@ def c2qasm(c: Any, compiling: bool) -> str: "lang": lang, "prior": prior, "remarks": remarks, + "group": group, } ) @@ -273,6 +275,7 @@ def c2qasm(c: Any, compiling: bool) -> str: "lang": lang, "prior": prior, "remarks": remarks, + "group": group, } r = rpost_json( tencent_base_url + "task/submit", json=json, headers=tencent_headers(token) From 851e7d337729d020f4b448aef0e103aef47e8cca Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 27 May 2023 19:09:19 +0800 Subject: [PATCH 466/725] update index page with cards and grids --- docs/source/cnconf.py | 2 + docs/source/conf.py | 1 + docs/source/index.rst | 152 ++++++++++++- docs/source/locale/zh/LC_MESSAGES/index.po | 235 +++++++++++++++----- docs/source/locale/zh/LC_MESSAGES/infras.po | 58 ++++- requirements/requirements-dev.txt | 3 +- requirements/requirements-rtd.txt | 3 +- 7 files changed, 383 insertions(+), 71 deletions(-) diff --git a/docs/source/cnconf.py b/docs/source/cnconf.py index 8b01d026..ceecf794 100644 --- a/docs/source/cnconf.py +++ b/docs/source/cnconf.py @@ -48,7 +48,9 @@ "sphinx_copybutton", "nbsphinx", "toctree_filter", + "sphinx.ext.napoleon", "myst_parser", + "sphinx_design", ] autosectionlabel_prefix_document = True diff --git a/docs/source/conf.py b/docs/source/conf.py index 181dda0e..9d8147d9 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -50,6 +50,7 @@ "toctree_filter", "sphinx.ext.napoleon", "myst_parser", + "sphinx_design", ] nbsphinx_allow_errors = True diff --git a/docs/source/index.rst b/docs/source/index.rst index 6732f8fc..7a069e5e 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -7,6 +7,9 @@ TensorCircuit Documentation **Welcome and congratulations! You have found TensorCircuit.** 👏 +Introduction +--------------- + TensorCircuit is an open-source high-performance quantum computing software framework in Python. * It is built for humans. 👽 @@ -25,6 +28,7 @@ With the help of TensorCircuit, now get ready to efficiently and elegantly solve + Relevant Links -------------------- @@ -36,23 +40,153 @@ We also thank `contributions `_ and this version is released by `Tencent Quantum Lab `_ 创建和维" "护；此版本由 `腾讯量子实验室 `_ 发布。" -#: ../../source/index.rst:33 +#: ../../source/index.rst:37 msgid "" "The current core authors of TensorCircuit are `Shi-Xin Zhang `_ and `Yu-Qin Chen `_. We also " @@ -98,7 +102,7 @@ msgstr "" "区的 `贡献 `_。" -#: ../../source/index.rst:36 +#: ../../source/index.rst:40 msgid "" "If you have any further questions or collaboration ideas, please use the issue " "tracker or forum below, or send email to shixinzhang#tencent.com." @@ -106,93 +110,165 @@ msgstr "" "如果关于 TensorCircuit 有任何问题咨询或合作意向，请在 issue 或 discussion 提问，" "或发送邮件到 shixinzhang#tencent.com。" -#: ../../source/index.rst:39 -msgid "Source code: https://github.com/tencent-quantum-lab/tensorcircuit" -msgstr "源代码: https://github.com/tencent-quantum-lab/tensorcircuit" +#: ../../source/index.rst:45 +msgid "Source code" +msgstr "源代码" -#: ../../source/index.rst:41 -msgid "Documentation: https://tensorcircuit.readthedocs.io" -msgstr "文档: https://tensorcircuit.readthedocs.io" +#: ../../source/index.rst:51 +msgid "Documentation" +msgstr "参考文档" -#: ../../source/index.rst:43 -msgid "" -"Software Whitepaper (published in Quantum): https://quantum-journal.org/papers/" -"q-2023-02-02-912/" -msgstr "" -"软件白皮书 (发表于 Quantum): https://quantum-journal.org/papers/" -"q-2023-02-02-912/" +#: ../../source/index.rst:57 +msgid "Whitepaper" +msgstr "白皮书" -#: ../../source/index.rst:45 -msgid "Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues" -msgstr "问题跟踪: https://github.com/tencent-quantum-lab/tensorcircuit/issues" +#: ../../source/index.rst:62 +msgid "published in Quantum journal" +msgstr "Quantum 期刊发表" + +#: ../../source/index.rst:65 +msgid "Issue Tracker" +msgstr "问题跟踪" + +#: ../../source/index.rst:71 +msgid "Forum" +msgstr "论坛" -#: ../../source/index.rst:47 -msgid "Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" +#: ../../source/index.rst:77 +msgid "PyPI" msgstr "" -"论坛社区: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" -#: ../../source/index.rst:49 -msgid "PyPI page: https://pypi.org/project/tensorcircuit" -msgstr "PyPI 页面: https://pypi.org/project/tensorcircuit" +#: ../../source/index.rst:83 +msgid "DockerHub" +msgstr "" -#: ../../source/index.rst:51 +#: ../../source/index.rst:89 +msgid "Applications" +msgstr "应用" + +#: ../../source/index.rst:94 +msgid "Research based on TC" +msgstr "基于 TC 的研究项目" + +#: ../../source/index.rst:97 +msgid "Cloud" +msgstr "量子云" + +#: ../../source/index.rst:101 +msgid "Tencent Quantum Cloud Service" +msgstr "腾讯量子云平台" + +#: ../../source/index.rst:128 +msgid "Unified Quantum Programming" +msgstr "统一量子编程" + +#: ../../source/index.rst:130 msgid "" -"DockerHub page: https://hub.docker.com/repository/docker/tensorcircuit/" -"tensorcircuit" +"TensorCircuit is unifying infrastructures and interfaces for quantum computing." +msgstr "TensorCircuit 尝试统一量子计算的基础设施和编程界面。" + +#: ../../source/index.rst:137 +msgid "Unified Backends" +msgstr "统一后端" + +#: ../../source/index.rst:141 +msgid "Jax/TensorFlow/PyTorch/Numpy/Cupy" msgstr "" -"DockerHub 页面: https://hub.docker.com/repository/docker/tensorcircuit/" -"tensorcircuit" -#: ../../source/index.rst:53 -msgid "" -"Research and projects based on TensorCircuit: https://github.com/tencent-" -"quantum-lab/tensorcircuit#research-and-applications" +#: ../../source/index.rst:143 +msgid "Unified Devices" +msgstr "统一设备" + +#: ../../source/index.rst:147 +msgid "CPU/GPU/TPU" msgstr "" -"基于 TensorCircuit 的研究和项目: https://github.com/tencent-quantum-lab/" -"tensorcircuit#research-and-applications" -#: ../../source/index.rst:55 -msgid "Tencent Quantum Cloud Service: https://quantum.tencent.com/cloud/" -msgstr "腾讯量子云服务: https://quantum.tencent.com/cloud/" +#: ../../source/index.rst:149 +msgid "Unified Providers" +msgstr "统一平台" + +#: ../../source/index.rst:153 +msgid "QPUs from different vendors" +msgstr "不同供应商的 QPU" + +#: ../../source/index.rst:155 +msgid "Unified Resources" +msgstr "统一资源" + +#: ../../source/index.rst:159 +msgid "local/cloud/HPC" +msgstr "本地/云/集群" + +#: ../../source/index.rst:167 +msgid "Unified Interfaces" +msgstr "统一接口" -#: ../../source/index.rst:61 +#: ../../source/index.rst:171 +msgid "numerical sim/hardware exp" +msgstr "数值模拟/硬件实验" + +#: ../../source/index.rst:173 +msgid "Unified Engines" +msgstr "统一引擎" + +#: ../../source/index.rst:177 +msgid "ideal/noisy/approximate simulation" +msgstr "理想/含噪/近似模拟" + +#: ../../source/index.rst:179 +msgid "Unified Representations" +msgstr "统一表示" + +#: ../../source/index.rst:183 +msgid "from/to_IR/qiskit/openqasm/json" +msgstr "" + +#: ../../source/index.rst:185 +msgid "Unified Pipelines" +msgstr "统一流程" + +#: ../../source/index.rst:189 +msgid "stateless functional programming/stateful ML models" +msgstr "函数式编程/面向对象模型" + +#: ../../source/index.rst:195 msgid "Reference Documentation" msgstr "参考文档" -#: ../../source/index.rst:63 +#: ../../source/index.rst:197 msgid "" "The following documentation sections briefly introduce TensorCircuit to the " "users and developpers." msgstr "以下文档向用户和开发者简要介绍了 TensorCircuit 软件。" -#: ../../source/index.rst:76 +#: ../../source/index.rst:210 msgid "Tutorials" msgstr "教程" -#: ../../source/index.rst:78 +#: ../../source/index.rst:212 msgid "" "The following documentation sections include integrated examples in the form of " "Jupyter Notebook." msgstr "" "以下 Jupyter Notebook 格式的文档包括了一系列使用 TensorCircuit 的集成案例。" -#: ../../source/index.rst:92 +#: ../../source/index.rst:226 msgid "API References" msgstr "API 参考" -#: ../../source/index.rst:101 +#: ../../source/index.rst:235 msgid "Indices and Tables" msgstr "索引和表格" -#: ../../source/index.rst:103 +#: ../../source/index.rst:237 msgid ":ref:`genindex`" msgstr ":ref:`genindex`" -#: ../../source/index.rst:104 +#: ../../source/index.rst:238 msgid ":ref:`modindex`" msgstr ":ref:`modindex`" -#: ../../source/index.rst:105 +#: ../../source/index.rst:239 msgid ":ref:`search`" msgstr ":ref:`search`" @@ -213,3 +289,44 @@ msgstr ":ref:`search`" #~ msgid "Links" #~ msgstr "重要链接" + +#~ msgid "Source code: https://github.com/tencent-quantum-lab/tensorcircuit" +#~ msgstr "源代码: https://github.com/tencent-quantum-lab/tensorcircuit" + +#~ msgid "Documentation: https://tensorcircuit.readthedocs.io" +#~ msgstr "文档: https://tensorcircuit.readthedocs.io" + +#~ msgid "" +#~ "Software Whitepaper (published in Quantum): https://quantum-journal.org/" +#~ "papers/q-2023-02-02-912/" +#~ msgstr "" +#~ "软件白皮书 (发表于 Quantum): https://quantum-journal.org/papers/" +#~ "q-2023-02-02-912/" + +#~ msgid "" +#~ "Issue Tracker: https://github.com/tencent-quantum-lab/tensorcircuit/issues" +#~ msgstr "问题跟踪: https://github.com/tencent-quantum-lab/tensorcircuit/issues" + +#~ msgid "Forum: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" +#~ msgstr "" +#~ "论坛社区: https://github.com/tencent-quantum-lab/tensorcircuit/discussions" + +#~ msgid "PyPI page: https://pypi.org/project/tensorcircuit" +#~ msgstr "PyPI 页面: https://pypi.org/project/tensorcircuit" + +#~ msgid "" +#~ "DockerHub page: https://hub.docker.com/repository/docker/tensorcircuit/" +#~ "tensorcircuit" +#~ msgstr "" +#~ "DockerHub 页面: https://hub.docker.com/repository/docker/tensorcircuit/" +#~ "tensorcircuit" + +#~ msgid "" +#~ "Research and projects based on TensorCircuit: https://github.com/tencent-" +#~ "quantum-lab/tensorcircuit#research-and-applications" +#~ msgstr "" +#~ "基于 TensorCircuit 的研究和项目: https://github.com/tencent-quantum-lab/" +#~ "tensorcircuit#research-and-applications" + +#~ msgid "Tencent Quantum Cloud Service: https://quantum.tencent.com/cloud/" +#~ msgstr "腾讯量子云服务: https://quantum.tencent.com/cloud/" diff --git a/docs/source/locale/zh/LC_MESSAGES/infras.po b/docs/source/locale/zh/LC_MESSAGES/infras.po index a24e7660..b285ed77 100644 --- a/docs/source/locale/zh/LC_MESSAGES/infras.po +++ b/docs/source/locale/zh/LC_MESSAGES/infras.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-05-07 10:47+0800\n" +"POT-Creation-Date: 2023-05-27 18:52+0800\n" "PO-Revision-Date: 2022-04-18 20:44+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -403,6 +403,62 @@ msgstr "" "(``*``)、张量乘积（``|``）和偏迹（``.partial_trace(subsystems_to_trace_out)``）。要提取这些对象的矩阵信息，我们可以使用" " ``.eval()`` 或 ``.eval_matrix() ``，前者保留了张量网络的形状信息，而后者给出了形状秩为2的矩阵表示。" +#: ../../source/infras.rst:162 +msgid "Quantum Cloud SDK: Layerwise API design" +msgstr "" + +#: ../../source/infras.rst:164 +msgid "From lower level to higher level, a view of API layers invoking QPU calls" +msgstr "" + +#: ../../source/infras.rst:166 +msgid "" +"Vendor specific implementation of functional API in, e.g., " +":py:mod:`tensorcircuit.cloud.tencent`" +msgstr "" + +#: ../../source/infras.rst:168 +msgid "" +"Provider agnostic functional lower level API for task/device management " +"in :py:mod:`tensorcircuit.cloud.apis`" +msgstr "" + +#: ../../source/infras.rst:170 +msgid "" +"Object oriented abstraction for Provider/Device/Task in " +":py:mod:`tensorcircuit.cloud.abstraction`" +msgstr "" + +#: ../../source/infras.rst:172 +msgid "" +"Unified batch submission interface as standarized in " +":py:meth:`tensorcircuit.cloud.wrapper.batch_submit_template`" +msgstr "" + +#: ../../source/infras.rst:174 +msgid "" +"Numerical and experimental unified all-in-one interface as " +":py:meth:`tensorcircuit.cloud.wrapper.batch_expectation_ps`" +msgstr "" + +#: ../../source/infras.rst:176 +msgid "" +"Application level code with QPU calls built directly on " +"``batch_expectation_ps`` or more fancy algorithms can be built on " +"``batch_submit_func`` so that these algorithms can be reused as long as " +"one function ``batch_submit_func`` is defined for a given vendor (cheaper" +" than defining a new provider from lower level)." +msgstr "" + +#: ../../source/infras.rst:181 +msgid "" +"For compiler, error mitigation and results post-processing parts, they " +"can be carefully designed to decouple with the QPU calls, so they are " +"separately implemented in :py:mod:`tensorcircuit.compiler` and " +":py:mod:`tensorcircuit.results`, and they can be independently useful " +"even without tc's cloud access." +msgstr "" + #~ msgid "" #~ ":py:mod:`tensorcircuit.densitymatrix2`: Highly efficient" #~ " implementation of " diff --git a/requirements/requirements-dev.txt b/requirements/requirements-dev.txt index f4d974b8..6401ab30 100644 --- a/requirements/requirements-dev.txt +++ b/requirements/requirements-dev.txt @@ -11,4 +11,5 @@ numpy==1.21.5 furo sphinx-copybutton nbsphinx -myst-parser \ No newline at end of file +myst-parser +sphinx-design \ No newline at end of file diff --git a/requirements/requirements-rtd.txt b/requirements/requirements-rtd.txt index 4c2d71c9..8e93c419 100644 --- a/requirements/requirements-rtd.txt +++ b/requirements/requirements-rtd.txt @@ -14,4 +14,5 @@ furo==2022.4.7 sphinx-copybutton nbsphinx myst-parser -urllib3==1.26.15 \ No newline at end of file +urllib3==1.26.15 +sphinx-design \ No newline at end of file From f6173051b4443e9905b42312b051a4afa173f290 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 28 May 2023 00:09:45 +0800 Subject: [PATCH 467/725] update link cards --- docs/source/index.rst | 19 +++++-------------- 1 file changed, 5 insertions(+), 14 deletions(-) diff --git a/docs/source/index.rst b/docs/source/index.rst index 7a069e5e..7ccf7ad2 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -40,65 +40,56 @@ We also thank `contributions Date: Sun, 28 May 2023 14:39:40 +0800 Subject: [PATCH 468/725] update readme and doc index --- README.md | 7 +- README_cn.md | 4 +- docs/source/index.rst | 14 ++- docs/source/locale/zh/LC_MESSAGES/index.po | 117 +++++++++++++-------- 4 files changed, 91 insertions(+), 51 deletions(-) diff --git a/README.md b/README.md index b6114b29..974b7198 100644 --- a/README.md +++ b/README.md @@ -31,13 +31,13 @@ TensorCircuit is the next generation of quantum software framework with support for automatic differentiation, just-in-time compiling, hardware acceleration, and vectorized parallelism. -TensorCircuit is built on top of modern machine learning frameworks: Jax, TensorFlow, and PyTorch. It is specifically suitable for highly efficient simulations of quantum-classical hybrid paradigm and variational quantum algorithms in ideal, noisy and approximation cases. It also supports real quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions since v0.9. +TensorCircuit is built on top of modern machine learning frameworks: Jax, TensorFlow, and PyTorch. It is specifically suitable for highly efficient simulations of quantum-classical hybrid paradigm and variational quantum algorithms in ideal, noisy and approximate cases. It also supports real quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions since v0.9. ## Getting Started -Please begin with [Quick Start](/docs/source/quickstart.rst). +Please begin with [Quick Start](/docs/source/quickstart.rst) in the [full documentation](https://tensorcircuit.readthedocs.io/). -For more information and introductions, please refer to helpful [example scripts](/examples) and [full documentation](https://tensorcircuit.readthedocs.io/). API docstrings and test cases in [tests](/tests) are also informative. +For more information on software usage, sota algorithm implementation and engineer paradigm demonstration, please refer to 60+ [example scripts](/examples) and 30+ [tutorial notebooks](https://tensorcircuit.readthedocs.io/en/latest/#tutorials). API docstrings and test cases in [tests](/tests) are also informative. The following are some minimal demos. @@ -121,6 +121,7 @@ We also have [Docker support](/docker). - API design: quantum for humans, less code, more power + ## Contributing ### Status diff --git a/README_cn.md b/README_cn.md index 88f8b385..1d9ff504 100644 --- a/README_cn.md +++ b/README_cn.md @@ -33,9 +33,9 @@ TensorCircuit 现在支持真实量子硬件连接和实验，并提供优雅的 ## 入门 -请从 [快速上手](/docs/source/quickstart.rst) 和 [Jupyter 教程](/docs/source/tutorials) 开始。 +请从 [完整文档](https://tensorcircuit.readthedocs.io/zh/latest/) 中的 [快速上手](/docs/source/quickstart.rst) 开始。 -有关更多信息和介绍，请参阅有用的 [示例脚本](/examples) 和 [完整文档](https://tensorcircuit.readthedocs.io/zh/latest/)。 [测试](/tests)用例和 API docstring 也提供了丰富的使用信息。 +有关软件用法，算法实现和工程范式演示的更多信息和介绍，请参阅 60+ [示例脚本](/examples) 和 30+ [案例教程](https://tensorcircuit.readthedocs.io/zh/latest/#tutorials)。 [测试](/tests) 用例和 API docstring 也提供了丰富的使用信息。 以下是一些最简易的演示。 diff --git a/docs/source/index.rst b/docs/source/index.rst index 7ccf7ad2..9d27204d 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -46,38 +46,50 @@ If you have any further questions or collaboration ideas, please use the issue t :link: https://github.com/tencent-quantum-lab/tensorcircuit :shadow: md + GitHub + .. card:: Documentation :link: https://tensorcircuit.readthedocs.io :shadow: md + Readthedocs + .. card:: Whitepaper :link: https://quantum-journal.org/papers/q-2023-02-02-912/ :shadow: md - published in *Quantum* + *Quantum* journal .. card:: Issue Tracker :link: https://github.com/tencent-quantum-lab/tensorcircuit/issues :shadow: md + GitHub Issues + .. card:: Forum :link: https://github.com/tencent-quantum-lab/tensorcircuit/discussions :shadow: md + GitHub Discussions + .. card:: PyPI :link: https://pypi.org/project/tensorcircuit :shadow: md + ``pip install`` + .. card:: DockerHub :link: https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit :shadow: md + ``docker pull`` + .. card:: Application :link: https://github.com/tencent-quantum-lab/tensorcircuit#research-and-applications diff --git a/docs/source/locale/zh/LC_MESSAGES/index.po b/docs/source/locale/zh/LC_MESSAGES/index.po index bf10bf95..20ed436d 100644 --- a/docs/source/locale/zh/LC_MESSAGES/index.po +++ b/docs/source/locale/zh/LC_MESSAGES/index.po @@ -8,8 +8,8 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-05-27 18:52+0800\n" -"PO-Revision-Date: 2023-05-27 19:00+0800\n" +"POT-Creation-Date: 2023-05-28 14:36+0800\n" +"PO-Revision-Date: 2023-05-28 14:39+0800\n" "Last-Translator: Xinghan Yang\n" "Language-Team: \n" "Language: cn\n" @@ -114,161 +114,185 @@ msgstr "" msgid "Source code" msgstr "源代码" -#: ../../source/index.rst:51 +#: ../../source/index.rst:49 +msgid "GitHub" +msgstr "" + +#: ../../source/index.rst:52 msgid "Documentation" msgstr "参考文档" -#: ../../source/index.rst:57 +#: ../../source/index.rst:56 +msgid "Readthedocs" +msgstr "" + +#: ../../source/index.rst:59 msgid "Whitepaper" msgstr "白皮书" -#: ../../source/index.rst:62 -msgid "published in Quantum journal" -msgstr "Quantum 期刊发表" +#: ../../source/index.rst:63 +msgid "*Quantum* journal" +msgstr "Quantum 期刊" -#: ../../source/index.rst:65 +#: ../../source/index.rst:66 msgid "Issue Tracker" msgstr "问题跟踪" -#: ../../source/index.rst:71 +#: ../../source/index.rst:70 +msgid "GitHub Issues" +msgstr "" + +#: ../../source/index.rst:73 msgid "Forum" msgstr "论坛" #: ../../source/index.rst:77 +msgid "GitHub Discussions" +msgstr "" + +#: ../../source/index.rst:80 msgid "PyPI" msgstr "" -#: ../../source/index.rst:83 +#: ../../source/index.rst:84 +msgid "``pip install``" +msgstr "" + +#: ../../source/index.rst:87 msgid "DockerHub" msgstr "" -#: ../../source/index.rst:89 -msgid "Applications" -msgstr "应用" +#: ../../source/index.rst:91 +msgid "``docker pull``" +msgstr "" #: ../../source/index.rst:94 -msgid "Research based on TC" -msgstr "基于 TC 的研究项目" +msgid "Application" +msgstr "应用" -#: ../../source/index.rst:97 +#: ../../source/index.rst:98 +msgid "Research using TC" +msgstr "研究项目" + +#: ../../source/index.rst:101 msgid "Cloud" msgstr "量子云" -#: ../../source/index.rst:101 -msgid "Tencent Quantum Cloud Service" +#: ../../source/index.rst:104 +msgid "Tencent Quantum Cloud" msgstr "腾讯量子云平台" -#: ../../source/index.rst:128 +#: ../../source/index.rst:131 msgid "Unified Quantum Programming" msgstr "统一量子编程" -#: ../../source/index.rst:130 +#: ../../source/index.rst:133 msgid "" "TensorCircuit is unifying infrastructures and interfaces for quantum computing." msgstr "TensorCircuit 尝试统一量子计算的基础设施和编程界面。" -#: ../../source/index.rst:137 +#: ../../source/index.rst:140 msgid "Unified Backends" msgstr "统一后端" -#: ../../source/index.rst:141 +#: ../../source/index.rst:144 msgid "Jax/TensorFlow/PyTorch/Numpy/Cupy" msgstr "" -#: ../../source/index.rst:143 +#: ../../source/index.rst:146 msgid "Unified Devices" msgstr "统一设备" -#: ../../source/index.rst:147 +#: ../../source/index.rst:150 msgid "CPU/GPU/TPU" msgstr "" -#: ../../source/index.rst:149 +#: ../../source/index.rst:152 msgid "Unified Providers" msgstr "统一平台" -#: ../../source/index.rst:153 +#: ../../source/index.rst:156 msgid "QPUs from different vendors" msgstr "不同供应商的 QPU" -#: ../../source/index.rst:155 +#: ../../source/index.rst:158 msgid "Unified Resources" msgstr "统一资源" -#: ../../source/index.rst:159 +#: ../../source/index.rst:162 msgid "local/cloud/HPC" msgstr "本地/云/集群" -#: ../../source/index.rst:167 +#: ../../source/index.rst:170 msgid "Unified Interfaces" msgstr "统一接口" -#: ../../source/index.rst:171 +#: ../../source/index.rst:174 msgid "numerical sim/hardware exp" msgstr "数值模拟/硬件实验" -#: ../../source/index.rst:173 +#: ../../source/index.rst:176 msgid "Unified Engines" msgstr "统一引擎" -#: ../../source/index.rst:177 +#: ../../source/index.rst:180 msgid "ideal/noisy/approximate simulation" msgstr "理想/含噪/近似模拟" -#: ../../source/index.rst:179 +#: ../../source/index.rst:182 msgid "Unified Representations" msgstr "统一表示" -#: ../../source/index.rst:183 +#: ../../source/index.rst:186 msgid "from/to_IR/qiskit/openqasm/json" msgstr "" -#: ../../source/index.rst:185 +#: ../../source/index.rst:188 msgid "Unified Pipelines" msgstr "统一流程" -#: ../../source/index.rst:189 +#: ../../source/index.rst:192 msgid "stateless functional programming/stateful ML models" msgstr "函数式编程/面向对象模型" -#: ../../source/index.rst:195 +#: ../../source/index.rst:198 msgid "Reference Documentation" msgstr "参考文档" -#: ../../source/index.rst:197 +#: ../../source/index.rst:200 msgid "" "The following documentation sections briefly introduce TensorCircuit to the " "users and developpers." msgstr "以下文档向用户和开发者简要介绍了 TensorCircuit 软件。" -#: ../../source/index.rst:210 +#: ../../source/index.rst:213 msgid "Tutorials" msgstr "教程" -#: ../../source/index.rst:212 +#: ../../source/index.rst:215 msgid "" "The following documentation sections include integrated examples in the form of " "Jupyter Notebook." msgstr "" "以下 Jupyter Notebook 格式的文档包括了一系列使用 TensorCircuit 的集成案例。" -#: ../../source/index.rst:226 +#: ../../source/index.rst:229 msgid "API References" msgstr "API 参考" -#: ../../source/index.rst:235 +#: ../../source/index.rst:238 msgid "Indices and Tables" msgstr "索引和表格" -#: ../../source/index.rst:237 +#: ../../source/index.rst:240 msgid ":ref:`genindex`" msgstr ":ref:`genindex`" -#: ../../source/index.rst:238 +#: ../../source/index.rst:241 msgid ":ref:`modindex`" msgstr ":ref:`modindex`" -#: ../../source/index.rst:239 +#: ../../source/index.rst:242 msgid ":ref:`search`" msgstr ":ref:`search`" @@ -330,3 +354,6 @@ msgstr ":ref:`search`" #~ msgid "Tencent Quantum Cloud Service: https://quantum.tencent.com/cloud/" #~ msgstr "腾讯量子云服务: https://quantum.tencent.com/cloud/" + +#~ msgid "Research based on TC" +#~ msgstr "基于 TC 的研究项目" From 91ca3c0b130d522eb473a17a7abe27881a0383a1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 28 May 2023 15:05:40 +0800 Subject: [PATCH 469/725] support local provider for batch_exp_ps --- CHANGELOG.md | 2 ++ tensorcircuit/cloud/__init__.py | 1 + tensorcircuit/cloud/local.py | 2 +- tensorcircuit/cloud/wrapper.py | 22 ++++++++++++++-------- tests/test_cloud.py | 5 +++++ 5 files changed, 23 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a6fa4f21..6e0a3f50 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,8 @@ - Task management via group tag (when `submit_task` and `list_tasks`) +- `batch_expectation_ps` now supports local device without topology and thus unify the interface for numerical exact simulation, numerical simulation with measurement shots and QPU experiments + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/tensorcircuit/cloud/__init__.py b/tensorcircuit/cloud/__init__.py index acd5bb51..c98259d2 100644 --- a/tensorcircuit/cloud/__init__.py +++ b/tensorcircuit/cloud/__init__.py @@ -1,3 +1,4 @@ from . import apis from . import abstraction from . import wrapper +from .wrapper import batch_expectation_ps diff --git a/tensorcircuit/cloud/local.py b/tensorcircuit/cloud/local.py index aa11681a..6d48f8e6 100644 --- a/tensorcircuit/cloud/local.py +++ b/tensorcircuit/cloud/local.py @@ -39,7 +39,7 @@ def submit_task( **kws: Any ) -> List[Task]: def _circuit2result(c: AbstractCircuit) -> Dict[str, Any]: - if device.name == "testing": + if device.name in ["testing", "default"]: count = c.sample(batch=shots, allow_state=True, format="count_dict_bin") # type: ignore else: raise ValueError("Unsupported device from local provider: %s" % device.name) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 783921c1..fdf30c5a 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -1,7 +1,7 @@ """ higher level wrapper shortcut for submit_task """ -from typing import Any, Callable, Dict, List, Optional, Sequence, Union +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union import logging import time @@ -150,6 +150,7 @@ def batch_expectation_ps( ws: Optional[List[float]] = None, shots: int = 8192, with_rem: bool = True, + compile_func: Optional[Callable[[Circuit], Tuple[Circuit, Dict[str, Any]]]] = None, batch_limit: int = 64, batch_submit_func: Optional[Callable[..., List[counts.ct]]] = None, ) -> Union[Any, List[Any]]: @@ -204,11 +205,17 @@ def batch_expectation_ps( if isinstance(device, str): device = get_device(device) - dc = DefaultCompiler( - { - "coupling_map": device.topology(), - } - ) + if compile_func is None: + try: + coupling_map = device.topology() + compile_func = DefaultCompiler( + { + "coupling_map": coupling_map, + } + ) + except (AttributeError, ValueError): + compile_func = DefaultCompiler() + for ps in pss: # TODO(@refraction-ray): Pauli string grouping # https://docs.pennylane.ai/en/stable/_modules/pennylane/pauli/grouping/group_observables.html @@ -225,8 +232,7 @@ def batch_expectation_ps( exp.append(j) for i in range(c1._nqubits): c1.measure_instruction(i) - c1, info = dc(c1) - # bug for measure instruction! + c1, info = compile_func(c1) # type: ignore # TODO(@refraction-ray): two steps compiling with pre compilation cs.append(c1) infos.append(info) diff --git a/tests/test_cloud.py b/tests/test_cloud.py index f71e8e4d..fb24d318 100644 --- a/tests/test_cloud.py +++ b/tests/test_cloud.py @@ -161,6 +161,11 @@ def test_batch_exp_ps(): [1, -1], atol=1e-1, ) + np.testing.assert_allclose( + wrapper.batch_expectation_ps(c, pss, device="local::default", with_rem=False), + [1, -1], + atol=1e-1, + ) def test_batch_submit_template(): From 79fff4c95b3774558fec3999d72ab942bbd02532 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 28 May 2023 15:27:19 +0800 Subject: [PATCH 470/725] list syntax now supports range --- CHANGELOG.md | 2 ++ tensorcircuit/abstractcircuit.py | 4 ++-- tests/test_circuit.py | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6e0a3f50..11a527b4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,8 @@ - Partially fix the SVD numerical stability bug on tf backend when using `MPSCircuit` +- List syntax for gate now supports range + ## 0.9.1 ### Added diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index cf02f920..c7c47aff 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -132,7 +132,7 @@ def apply(self: "AbstractCircuit", *index: int, **vars: Any) -> None: def apply_list(self: "AbstractCircuit", *index: int, **vars: Any) -> None: if isinstance(index[0], int): apply(self, *index, **vars) - elif is_sequence(index[0]): + elif is_sequence(index[0]) or isinstance(index[0], range): for i, ind in enumerate(zip(*index)): nvars = {} for k, v in vars.items(): @@ -189,7 +189,7 @@ def apply( def apply_list(self: "AbstractCircuit", *index: int, **kws: Any) -> None: if isinstance(index[0], int): apply(self, *index, **kws) - elif is_sequence(index[0]): + elif is_sequence(index[0]) or isinstance(index[0], range): for ind in zip(*index): apply(self, *ind, **kws) else: diff --git a/tests/test_circuit.py b/tests/test_circuit.py index c758e2aa..ddfe30eb 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1565,7 +1565,7 @@ def simple_ansatz(param): def test_fancy_circuit_indexing(backend): c = tc.Circuit(4) c.cx([0, 1], [-1, -2]) - c.h(list(range(c._nqubits))) + c.h(range(c._nqubits)) c.rz([0], theta=0.2) c.rx([1, 2], theta=[0.3, 0.5]) c.rzz([2, 3], [0, 1], theta=tc.backend.ones([2])) From f9f9e61ac470aa20c5edf5e0940be33462b431a1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 29 May 2023 10:47:31 +0800 Subject: [PATCH 471/725] introducing two layers compiling for batch_exp_ps --- tensorcircuit/cloud/wrapper.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index fdf30c5a..8e3307b0 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -14,6 +14,7 @@ from ..cons import backend from ..quantum import ps2xyz from ..compiler import DefaultCompiler +from ..compiler.simple_compiler import simple_compile from .apis import submit_task, get_device from .abstraction import Device @@ -215,26 +216,31 @@ def batch_expectation_ps( ) except (AttributeError, ValueError): compile_func = DefaultCompiler() - + c1, info = compile_func(c) # type: ignore + if not info.get("logical_physical_mapping", None): + info["logical_physical_mapping"] = {i: i for i in range(c._nqubits)} for ps in pss: # TODO(@refraction-ray): Pauli string grouping # https://docs.pennylane.ai/en/stable/_modules/pennylane/pauli/grouping/group_observables.html - c1 = Circuit.from_qir(c.to_qir()) + c2 = Circuit.from_qir(c1.to_qir()) exp = [] for j, i in enumerate(ps): if i == 1: - c1.H(j) # type: ignore + c2.H(info["logical_physical_mapping"][j]) # type: ignore + c2, _ = simple_compile(c2) exp.append(j) + elif i == 2: - c1.rx(j, theta=np.pi / 2) # type: ignore + c2.rx(info["logical_physical_mapping"][j], theta=np.pi / 2) # type: ignore + c2, _ = simple_compile(c2) exp.append(j) elif i == 3: exp.append(j) - for i in range(c1._nqubits): - c1.measure_instruction(i) - c1, info = compile_func(c1) # type: ignore + for i in range(c._nqubits): + c2.measure_instruction(info["logical_physical_mapping"][i]) + # c1, info = compile_func(c1) # type: ignore # TODO(@refraction-ray): two steps compiling with pre compilation - cs.append(c1) + cs.append(c2) infos.append(info) exps.append(exp) From 6b084661c9d82512af8684f3f574ffef8fee2445 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 29 May 2023 11:04:01 +0800 Subject: [PATCH 472/725] fix todo and changelog --- CHANGELOG.md | 2 ++ tensorcircuit/cloud/__init__.py | 1 + tensorcircuit/cloud/wrapper.py | 3 +-- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 11a527b4..6a983e67 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,8 @@ - `batch_expectation_ps` now supports local device without topology and thus unify the interface for numerical exact simulation, numerical simulation with measurement shots and QPU experiments +- introduce two stage compiling for `batch_expectation_ps` to save some compiling overhead + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/tensorcircuit/cloud/__init__.py b/tensorcircuit/cloud/__init__.py index c98259d2..56d5a724 100644 --- a/tensorcircuit/cloud/__init__.py +++ b/tensorcircuit/cloud/__init__.py @@ -2,3 +2,4 @@ from . import abstraction from . import wrapper from .wrapper import batch_expectation_ps +from .apis import submit_task diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 8e3307b0..569e4409 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -26,7 +26,6 @@ def batch_submit_template( device: str, batch_limit: int = 64, **kws: Any ) -> Callable[..., List[counts.ct]]: - # TODO(@refraction-ray): adpative batch def run( cs: Union[Circuit, Sequence[Circuit]], shots: int = 8192, **nkws: Any ) -> List[counts.ct]: @@ -239,7 +238,7 @@ def batch_expectation_ps( for i in range(c._nqubits): c2.measure_instruction(info["logical_physical_mapping"][i]) # c1, info = compile_func(c1) # type: ignore - # TODO(@refraction-ray): two steps compiling with pre compilation + # TODO(@refraction-ray): two steps compiling with pre compilation: basically done, require some fine tuning for performance cs.append(c2) infos.append(info) exps.append(exp) From 6ed15c6a8af268704d7f400e8caf9179ecca6652 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 29 May 2023 21:32:06 +0800 Subject: [PATCH 473/725] fix black --- tensorcircuit/cloud/wrapper.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 569e4409..2ae2da20 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -238,7 +238,8 @@ def batch_expectation_ps( for i in range(c._nqubits): c2.measure_instruction(info["logical_physical_mapping"][i]) # c1, info = compile_func(c1) # type: ignore - # TODO(@refraction-ray): two steps compiling with pre compilation: basically done, require some fine tuning for performance + # TODO(@refraction-ray): two steps compiling with pre compilation: + # basically done, require some fine tuning for performance cs.append(c2) infos.append(info) exps.append(exp) From 5f1b7ed0bcdaba260cd467fec6f4de4801f50859 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 31 May 2023 15:44:16 +0800 Subject: [PATCH 474/725] update sdk demo --- docs/source/tutorials/qcloud_sdk_demo.ipynb | 1071 +++++++++---------- 1 file changed, 506 insertions(+), 565 deletions(-) diff --git a/docs/source/tutorials/qcloud_sdk_demo.ipynb b/docs/source/tutorials/qcloud_sdk_demo.ipynb index 00a2d934..8f0a97a5 100644 --- a/docs/source/tutorials/qcloud_sdk_demo.ipynb +++ b/docs/source/tutorials/qcloud_sdk_demo.ipynb @@ -7,14 +7,14 @@ "source": [ "# Demo on TensorCircuit SDK for Tencent Quantum Cloud\n", "\n", - "This notebook is not served as a full user manual for TC SDK for qcloud. Instead it only highlighted a limited subset of features that TC enabled, mainly for live demo and tutorials.\n", + "This notebook is not served as a full user manual for TC SDK for QCLOUD. Instead，it only highlighted a limited subset of features that TC enabled, mainly for live demo and tutorials.\n", "\n", "## Import and Setup" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "id": "ff5cc3c8", "metadata": {}, "outputs": [], @@ -38,7 +38,7 @@ "metadata": {}, "outputs": [], "source": [ - "# tc.cloud.apis.set_token(\"foobar\")\n", + "# tc.cloud.apis.set_token(\"123456isnotgoodpassword\")\n", "# tc.cloud.apis.set_provider(\"tencent\")" ] }, @@ -55,12 +55,12 @@ "id": "735c2d63", "metadata": {}, "source": [ - "We also support some third party and local providers, and the list will be expanding...\n" + "**Provider agnostic**: The SDK architecture is designed to be provider agnostic so that we have the potential to support multiple QPU providers in the future. And from the user's pespective, no code will change to deploy the quantum program on different QPU providers. We also support some third party and local providers now internally, and the list will be expanding...\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "id": "72106e97", "metadata": {}, "outputs": [ @@ -70,7 +70,7 @@ "[tencent, local]" ] }, - "execution_count": 3, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -81,21 +81,21 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "id": "e35e1518", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[tencent::simulator:aer,\n", + "[tencent::simulator:tc,\n", + " tencent::simulator:aer,\n", " tencent::simulator:tcn1,\n", - " tencent::simulator:tc,\n", " tencent::tianshu_s1,\n", " tencent::tianxuan_s1]" ] }, - "execution_count": 4, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -109,25 +109,25 @@ "id": "4f5ce14e", "metadata": {}, "source": [ - "list on devices online that are currently available with `state` argument" + "list only devices online that are currently available with `state` argument" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "id": "b8456acc", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[tencent::simulator:aer,\n", - " tencent::simulator:tc,\n", + "[tencent::simulator:tc,\n", + " tencent::simulator:aer,\n", " tencent::tianshu_s1,\n", " tencent::tianxuan_s1]" ] }, - "execution_count": 5, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -138,21 +138,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "id": "7ced9cc6", "metadata": {}, "outputs": [], "source": [ - "device_name = \"tianxuan_s1\"" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "44e25b1c", - "metadata": {}, - "outputs": [], - "source": [ + "device_name = \"tianxuan_s1\" # 9 qubits chip\n", + "\n", "# get the device object\n", "\n", "d = tc.cloud.apis.get_device(device_name)" @@ -160,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 46, "id": "0e0633c5", "metadata": { "scrolled": false @@ -173,7 +165,7 @@ "" ] }, - "execution_count": 8, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } @@ -186,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "0461fc24", "metadata": {}, "outputs": [ @@ -198,93 +190,93 @@ " 'qubits': 9,\n", " 'T1': 30.593555450439453,\n", " 'T2': 12.94344425201416,\n", - " 'Err': {'SQ': 0.0007411111111111112,\n", - " 'CZ': 0.013063749999999999,\n", - " 'Readout': {'F0': 0.017955555555555554, 'F1': 0.06848888888888889}},\n", + " 'Err': {'SQ': 0.0008366666666666665,\n", + " 'CZ': 0.01615125,\n", + " 'Readout': {'F0': 0.0209, 'F1': 0.0849111111111111}},\n", " 'report': {'at': 1683908208,\n", " 'consumed': 181292436838,\n", " 'done': 32164,\n", " 'total': 32175,\n", " 'waiting': 5039},\n", - " 'at': 1684543057,\n", + " 'at': 1685496713,\n", " 'state': 'on',\n", - " 'links': {(0, 1): {'A': 0, 'B': 1, 'CZErrRate': 0.0132, 'GateLenInNs': 75.88},\n", - " (0, 2): {'A': 0, 'B': 2, 'CZErrRate': 0.01678, 'GateLenInNs': 77.15},\n", - " (0, 3): {'A': 0, 'B': 3, 'CZErrRate': 0.01603, 'GateLenInNs': 79.2},\n", - " (0, 4): {'A': 0, 'B': 4, 'CZErrRate': 0.0183, 'GateLenInNs': 78.45},\n", - " (1, 5): {'A': 1, 'B': 5, 'CZErrRate': 0.007, 'GateLenInNs': 73.28},\n", - " (2, 6): {'A': 2, 'B': 6, 'CZErrRate': 0.02188, 'GateLenInNs': 78.1},\n", - " (3, 7): {'A': 3, 'B': 7, 'CZErrRate': 0.00326, 'GateLenInNs': 63.79},\n", - " (4, 8): {'A': 4, 'B': 8, 'CZErrRate': 0.00806, 'GateLenInNs': 79.64}},\n", - " 'bits': {0: {'Freqency': 3957.7,\n", + " 'links': {(0, 1): {'A': 0, 'B': 1, 'CZErrRate': 0.0135, 'GateLenInNs': 75.56},\n", + " (0, 2): {'A': 0, 'B': 2, 'CZErrRate': 0.02358, 'GateLenInNs': 78.74},\n", + " (0, 3): {'A': 0, 'B': 3, 'CZErrRate': 0.01899, 'GateLenInNs': 79.94},\n", + " (0, 4): {'A': 0, 'B': 4, 'CZErrRate': 0.03357, 'GateLenInNs': 79.93},\n", + " (1, 5): {'A': 1, 'B': 5, 'CZErrRate': 0.00552, 'GateLenInNs': 74.94},\n", + " (2, 6): {'A': 2, 'B': 6, 'CZErrRate': 0.01951, 'GateLenInNs': 79.71},\n", + " (3, 7): {'A': 3, 'B': 7, 'CZErrRate': 0.00422, 'GateLenInNs': 65.04},\n", + " (4, 8): {'A': 4, 'B': 8, 'CZErrRate': 0.01032, 'GateLenInNs': 76.07}},\n", + " 'bits': {0: {'Freqency': 3974.78,\n", " 'Qubit': 0,\n", - " 'ReadoutF0Err': 0.0236,\n", - " 'ReadoutF1Err': 0.0976,\n", - " 'SingleQubitErrRate': 0.00094,\n", + " 'ReadoutF0Err': 0.035,\n", + " 'ReadoutF1Err': 0.0876,\n", + " 'SingleQubitErrRate': 0.00079,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 34.524,\n", " 'T2': 9.62},\n", - " 1: {'Freqency': 4156.38,\n", + " 1: {'Freqency': 4180.96,\n", " 'Qubit': 1,\n", - " 'ReadoutF0Err': 0.0218,\n", - " 'ReadoutF1Err': 0.0598,\n", - " 'SingleQubitErrRate': 0.00069,\n", + " 'ReadoutF0Err': 0.0308,\n", + " 'ReadoutF1Err': 0.0732,\n", + " 'SingleQubitErrRate': 0.00064,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 34.459,\n", " 'T2': 8.321},\n", - " 2: {'Freqency': 4106.1,\n", + " 2: {'Freqency': 4106.44,\n", " 'Qubit': 2,\n", - " 'ReadoutF0Err': 0.0225,\n", - " 'ReadoutF1Err': 0.0568,\n", - " 'SingleQubitErrRate': 0.00066,\n", + " 'ReadoutF0Err': 0.0192,\n", + " 'ReadoutF1Err': 0.0728,\n", + " 'SingleQubitErrRate': 0.00085,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 18.917,\n", " 'T2': 5.222},\n", - " 3: {'Freqency': 4657.26,\n", + " 3: {'Freqency': 4657.5,\n", " 'Qubit': 3,\n", - " 'ReadoutF0Err': 0.0075,\n", - " 'ReadoutF1Err': 0.0515,\n", - " 'SingleQubitErrRate': 0.00058,\n", + " 'ReadoutF0Err': 0.0073,\n", + " 'ReadoutF1Err': 0.1156,\n", + " 'SingleQubitErrRate': 0.00124,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 31.079,\n", " 'T2': 42.79},\n", - " 4: {'Freqency': 4399.36,\n", + " 4: {'Freqency': 4405.96,\n", " 'Qubit': 4,\n", - " 'ReadoutF0Err': 0.012,\n", - " 'ReadoutF1Err': 0.0544,\n", - " 'SingleQubitErrRate': 0.00079,\n", + " 'ReadoutF0Err': 0.0117,\n", + " 'ReadoutF1Err': 0.0483,\n", + " 'SingleQubitErrRate': 0.0006,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 32.353,\n", " 'T2': 9.3},\n", " 5: {'Freqency': 4371.74,\n", " 'Qubit': 5,\n", - " 'ReadoutF0Err': 0.0124,\n", - " 'ReadoutF1Err': 0.0664,\n", - " 'SingleQubitErrRate': 0.00049,\n", + " 'ReadoutF0Err': 0.0125,\n", + " 'ReadoutF1Err': 0.0604,\n", + " 'SingleQubitErrRate': 0.00058,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 30.132,\n", " 'T2': 6.954},\n", - " 6: {'Freqency': 4307.04,\n", + " 6: {'Freqency': 4247.08,\n", " 'Qubit': 6,\n", - " 'ReadoutF0Err': 0.0374,\n", - " 'ReadoutF1Err': 0.0886,\n", - " 'SingleQubitErrRate': 0.00092,\n", + " 'ReadoutF0Err': 0.0465,\n", + " 'ReadoutF1Err': 0.1351,\n", + " 'SingleQubitErrRate': 0.00102,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 34.827,\n", " 'T2': 4.462},\n", - " 7: {'Freqency': 4462.32,\n", + " 7: {'Freqency': 4462.26,\n", " 'Qubit': 7,\n", - " 'ReadoutF0Err': 0.0093,\n", - " 'ReadoutF1Err': 0.0685,\n", - " 'SingleQubitErrRate': 0.00057,\n", + " 'ReadoutF0Err': 0.0096,\n", + " 'ReadoutF1Err': 0.0525,\n", + " 'SingleQubitErrRate': 0.0006,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 28.269,\n", " 'T2': 13.429},\n", - " 8: {'Freqency': 4335.36,\n", + " 8: {'Freqency': 4335.34,\n", " 'Qubit': 8,\n", - " 'ReadoutF0Err': 0.0151,\n", - " 'ReadoutF1Err': 0.0728,\n", - " 'SingleQubitErrRate': 0.00103,\n", + " 'ReadoutF0Err': 0.0155,\n", + " 'ReadoutF1Err': 0.1187,\n", + " 'SingleQubitErrRate': 0.00121,\n", " 'SingleQubitGateLenInNs': 40,\n", " 'T1': 30.782,\n", " 'T2': 16.393}},\n", @@ -294,7 +286,7 @@ " 'native_gates': ['h', 'rz', 'x', 'y', 'z', 'cz', 'cx']}" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -305,45 +297,63 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "b44f1844", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'Freqency': 4335.36,\n", - " 'Qubit': 8,\n", - " 'ReadoutF0Err': 0.0151,\n", + "{'Freqency': 4106.44,\n", + " 'Qubit': 2,\n", + " 'ReadoutF0Err': 0.0192,\n", " 'ReadoutF1Err': 0.0728,\n", - " 'SingleQubitErrRate': 0.00103,\n", + " 'SingleQubitErrRate': 0.00085,\n", " 'SingleQubitGateLenInNs': 40,\n", - " 'T1': 30.782,\n", - " 'T2': 16.393}" + " 'T1': 18.917,\n", + " 'T2': 5.222}" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "d.list_properties()[\"bits\"][8]" + "d.list_properties()[\"bits\"][2]" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "ae4798dc", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(['h', 'rz', 'x', 'y', 'z', 'cz', 'cx'], 'tianxuan_s1', tencent)" + "(['h', 'rz', 'x', 'y', 'z', 'cz', 'cx'],\n", + " 'tianxuan_s1',\n", + " tencent,\n", + " [[0, 1],\n", + " [6, 2],\n", + " [4, 0],\n", + " [0, 4],\n", + " [8, 4],\n", + " [1, 5],\n", + " [3, 7],\n", + " [0, 3],\n", + " [2, 0],\n", + " [5, 1],\n", + " [3, 0],\n", + " [7, 3],\n", + " [0, 2],\n", + " [2, 6],\n", + " [4, 8],\n", + " [1, 0]])" ] }, - "execution_count": 11, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -351,45 +361,15 @@ "source": [ "# some meta data for the device\n", "\n", - "d.native_gates(), d.name, d.provider" + "d.native_gates(), d.name, d.provider, d.topology()" ] }, { - "cell_type": "code", - "execution_count": 12, - "id": "ade0fb23", + "cell_type": "markdown", + "id": "ccd597ae", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[[0, 1],\n", - " [6, 2],\n", - " [4, 0],\n", - " [0, 4],\n", - " [8, 4],\n", - " [1, 5],\n", - " [3, 7],\n", - " [0, 3],\n", - " [2, 0],\n", - " [5, 1],\n", - " [3, 0],\n", - " [7, 3],\n", - " [0, 2],\n", - " [2, 6],\n", - " [4, 8],\n", - " [1, 0]]" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "# bidirectional coupling maps\n", - "\n", - "d.topology()" + "The native gate set and the coupling map information is essential for TC to transpile the circuits so that they conform the standard of the corresponding devices." ] }, { @@ -412,17 +392,17 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "01a0fb92", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'00': 501, '11': 419, '10': 56, '01': 48}" + "{'00': 494, '11': 391, '10': 80, '01': 59}" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -439,40 +419,50 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "33b9eb5a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "text/html": [ + "
     ┌───┐     \n",
+       "q_0: ┤ H ├──■──\n",
+       "     └───┘┌─┴─┐\n",
+       "q_1: ─────┤ X ├\n",
+       "          └───┘
" + ], "text/plain": [ - "
" + " ┌───┐ \n", + "q_0: ┤ H ├──■──\n", + " └───┘┌─┴─┐\n", + "q_1: ─────┤ X ├\n", + " └───┘" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "c.draw(output=\"mpl\")" + "c.draw()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "88cfc4ad", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -486,12 +476,12 @@ "id": "0596e9f1", "metadata": {}, "source": [ - "Check with the analytical exact result, using tensorcircuit's sota tensornetwork based simulation engine" + "Check with the analytical exact result is easy, just use tensorcircuit's sota tensornetwork based simulation engine. The answer is a quantum state as $\\vert 00\\rangle + \\vert 11\\rangle$" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "dd798dd7", "metadata": {}, "outputs": [ @@ -513,24 +503,25 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "0d5ca58d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "tc.results.counts.plot_histogram([t.results(), exact_result])" + "tc.results.counts.plot_histogram([t.results(), exact_result])\n", + "# experiment vs exact" ] }, { @@ -538,19 +529,19 @@ "id": "d48cb1c1", "metadata": {}, "source": [ - "Let us further investigate the Task object ``t`` returned by ``submit_task``" + "Let us further investigate the Task object ``t`` returned by ``submit_task``, it contains enriched information on manager, compiling, etc." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "598448da", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'id': 'b29e6517-d1da-48fa-99d2-2ef7cd67e376',\n", + "{'id': '3a8840fa-1831-48c3-85fd-67a66523ed8f',\n", " 'queue': 'txq.low',\n", " 'device': 'tianxuan_s1?o=3',\n", " 'qubits': 2,\n", @@ -558,28 +549,28 @@ " 'state': 'completed',\n", " 'shots': 1024,\n", " 'prior': 1,\n", - " 'at': datetime.datetime(2023, 5, 22, 16, 28, 25, 529635),\n", - " 'ts': {'completed': datetime.datetime(2023, 5, 22, 16, 28, 25, 529635),\n", - " 'pending': datetime.datetime(2023, 5, 22, 16, 28, 23, 704629),\n", - " 'scheduled': datetime.datetime(2023, 5, 22, 16, 28, 23, 699405)},\n", + " 'at': datetime.datetime(2023, 5, 31, 11, 45, 7, 695261),\n", + " 'ts': {'completed': datetime.datetime(2023, 5, 31, 11, 45, 7, 695261),\n", + " 'pending': datetime.datetime(2023, 5, 31, 11, 45, 6, 364959),\n", + " 'scheduled': datetime.datetime(2023, 5, 31, 11, 45, 6, 359719)},\n", " 'md5': '9cb407b41938a256ec15dfec163dca1d',\n", - " 'runAt': 1684744128022598,\n", - " 'runDur': 1073553,\n", + " 'runAt': 1685504730279662,\n", + " 'runDur': 1016276,\n", " 'source': 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[2];\\nh q[0];\\ncx q[0],q[1];',\n", " 'version': '1',\n", " 'lang': 'OPENQASM',\n", - " 'result': {'00': 501, '01': 48, '10': 56, '11': 419},\n", + " 'result': {'00': 494, '01': 59, '10': 80, '11': 391},\n", " 'optimization': {'progs': [{'code': 'Tencent Quantum Program\\nversion 1.0\\nqubit involved: q0,q1,q2,q3,q4,q5,q6,q7,q8\\n# section: eqasm\\n# section lines 3\\neqasm program\\nbs 1 H q0\\nbs 1 CX (q0, q1)\\nMEASZ q0,q1\\n# section: end\\n',\n", " 'lang': 'QEXE'},\n", " {'code': 'Tencent Quantum Program\\nversion 1.0\\nqubit involved: q0,q1,q2,q3,q4,q5,q6,q7,q8\\n# section: eqasm\\n# section lines 3\\neqasm program\\nbs 1 H q0\\nbs 1 CX (q0, q1)\\nMEASZ q0,q1\\n# section: end\\n',\n", " 'lang': 'QEXE_COMPACT'}],\n", " 'pairs': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8}},\n", - " 'results': {'00': 501, '01': 48, '10': 56, '11': 419},\n", - " 'frontend': ,\n", - " 'backend': }" + " 'results': {'00': 494, '01': 59, '10': 80, '11': 391},\n", + " 'frontend': ,\n", + " 'backend': }" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -590,7 +581,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "c6a539ab", "metadata": {}, "outputs": [ @@ -600,7 +591,7 @@ "'completed'" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -611,17 +602,17 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "b3fcd4ec", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'b29e6517-d1da-48fa-99d2-2ef7cd67e376'" + "'3a8840fa-1831-48c3-85fd-67a66523ed8f'" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -640,7 +631,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "00e6c83d", "metadata": {}, "outputs": [], @@ -650,7 +641,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "19a5e66b", "metadata": {}, "outputs": [ @@ -671,7 +662,7 @@ " └───┘" ] }, - "execution_count": 22, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -681,6 +672,35 @@ "# exactly the task we submitted" ] }, + { + "cell_type": "code", + "execution_count": 24, + "id": "1e7520af", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'00': 494, '11': 391, '10': 80, '01': 59}" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t1.results()" + ] + }, + { + "cell_type": "markdown", + "id": "303cf6c3", + "metadata": {}, + "source": [ + "Task group management is also possible but not shown here. Try using ``group`` argument when ``submit_task`` and ``list_task`` when retrieving." + ] + }, { "cell_type": "markdown", "id": "ce9f8313", @@ -688,22 +708,22 @@ "source": [ "## Cloud simulator\n", "\n", - "We can also submit tasks to run on tc simulators on the cloud, the only thing you need to change is the device name" + "We can also submit tasks to run on tc simulators on the cloud, the only thing you need to change is the device name, and now the result becomes exact." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 25, "id": "adadefd1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'00': 520, '11': 504}" + "{'11': 546, '00': 478}" ] }, - "execution_count": 23, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -724,12 +744,12 @@ "id": "c00c7dde", "metadata": {}, "source": [ - "**Batch submission:** Tasks can also submitted in batch, either on real devices or on simulators, a list of task object is returned by ``submit_task``, if the circuit submitted is in a list" + "**Batch submission:** Tasks can also submitted in batch, either on real devices or on simulators, a list of task object is returned by ``submit_task``, if the circuit submitted is in a list. In this way, the joint tasks are executed on the QPU at the same time so that the noise profile remains consistent." ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 26, "id": "7f57f4e2", "metadata": {}, "outputs": [ @@ -737,8 +757,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'10': 528, '00': 475, '11': 12, '01': 9}\n", - "{'00': 524, '01': 479, '10': 14, '11': 7}\n" + "{'10': 524, '00': 500}\n", + "{'00': 519, '01': 505}\n" ] } ], @@ -749,7 +769,7 @@ "c2 = tc.Circuit(2)\n", "c2.h(1)\n", "\n", - "ts = tc.cloud.apis.submit_task(device=d, circuit=[c1, c2], shots=1024)\n", + "ts = tc.cloud.apis.submit_task(device=\"simulator:tc\", circuit=[c1, c2], shots=1024)\n", "for t in ts:\n", " print(t.results())" ] @@ -772,78 +792,52 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 27, "id": "2fc080c9", "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
     ┌──────────┐          ┌─┐                      \n",
-       "q_0: ┤ Rx(1.57) ├──■───────┤M├──────────────────────\n",
-       "     └──────────┘┌─┴─┐     └╥┘     ┌─┐              \n",
-       "q_1: ────────────┤ X ├──■───╫──────┤M├──────────────\n",
-       "                 └───┘┌─┴─┐ ║      └╥┘     ┌─┐      \n",
-       "q_2: ─────────────────┤ X ├─╫───■───╫──────┤M├──────\n",
-       "                      └───┘ ║ ┌─┴─┐ ║      └╥┘┌─┐   \n",
-       "q_3: ───────────────────────╫─┤ X ├─╫───■───╫─┤M├───\n",
-       "                            ║ └───┘ ║ ┌─┴─┐ ║ └╥┘┌─┐\n",
-       "q_4: ───────────────────────╫───────╫─┤ X ├─╫──╫─┤M├\n",
-       "                            ║       ║ └───┘ ║  ║ └╥┘\n",
-       "c: 5/═══════════════════════╩═══════╩═══════╩══╩══╩═\n",
-       "                            0       1       2  3  4
" - ], + "image/png": "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\n", "text/plain": [ - " ┌──────────┐ ┌─┐ \n", - "q_0: ┤ Rx(1.57) ├──■───────┤M├──────────────────────\n", - " └──────────┘┌─┴─┐ └╥┘ ┌─┐ \n", - "q_1: ────────────┤ X ├──■───╫──────┤M├──────────────\n", - " └───┘┌─┴─┐ ║ └╥┘ ┌─┐ \n", - "q_2: ─────────────────┤ X ├─╫───■───╫──────┤M├──────\n", - " └───┘ ║ ┌─┴─┐ ║ └╥┘┌─┐ \n", - "q_3: ───────────────────────╫─┤ X ├─╫───■───╫─┤M├───\n", - " ║ └───┘ ║ ┌─┴─┐ ║ └╥┘┌─┐\n", - "q_4: ───────────────────────╫───────╫─┤ X ├─╫──╫─┤M├\n", - " ║ ║ └───┘ ║ ║ └╥┘\n", - "c: 5/═══════════════════════╩═══════╩═══════╩══╩══╩═\n", - " 0 1 2 3 4 " + "
" ] }, - "execution_count": 25, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c = tc.Circuit(5)\n", - "c.rx(0, theta=1.57)\n", + "c.rx(0, theta=1.5708)\n", "for i in range(4):\n", " c.cx(i, i + 1)\n", "c.measure_instruction(*range(5))\n", "# note for tasks involving qubit mapping, we recommend you add the measure instruction explicitly\n", - "c.draw()" + "c.draw(output=\"mpl\")" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 28, "id": "ea2b3692", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'00000': 541, '11111': 483}" + "{'00000': 4014, '11111': 4178}" ] }, - "execution_count": 26, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# the ideal answer\n", - "c.sample(allow_state=True, batch=1024, format=\"count_dict_bin\")" + "# the ideal answer with shot noise\n", + "c.sample(allow_state=True, batch=8192, format=\"count_dict_bin\")" ] }, { @@ -851,19 +845,22 @@ "id": "79349e8e", "metadata": {}, "source": [ - "By default the backend compiler options are both enabled which we write expicitly below" + "The target state we prepare is the so called GHZ state (here is GHZ-5), which is also famuous as Schordinger cat state, as it is a superposition of two very different (macroscopic) quantum states: $\\vert 00000\\rangle + \\vert 11111\\rangle$. GHZ state is also a great measure to determine the quality of the quantum hardware.\n", + "\n", + "\n", + "By default the **backend compiler** options are both enabled which we write expicitly below" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 29, "id": "f381a9f7", "metadata": {}, "outputs": [], "source": [ "t = tc.cloud.apis.submit_task(\n", " circuit=c,\n", - " shots=1024,\n", + " shots=8192,\n", " device=d,\n", " enable_qos_gate_decomposition=True,\n", " enable_qos_qubit_mapping=True,\n", @@ -872,53 +869,55 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 30, "id": "0704b37f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'00000': 460,\n", - " '11111': 246,\n", - " '01111': 43,\n", - " '10000': 31,\n", - " '11101': 29,\n", - " '00011': 22,\n", - " '11100': 21,\n", - " '11011': 18,\n", - " '00100': 17,\n", - " '10111': 17,\n", - " '11110': 17,\n", - " '11000': 12,\n", - " '00001': 11,\n", - " '00010': 11,\n", - " '10100': 10,\n", - " '00111': 9,\n", - " '01000': 8,\n", - " '01011': 7,\n", - " '10011': 7,\n", - " '10101': 4,\n", - " '00110': 3,\n", - " '01110': 3,\n", - " '10001': 3,\n", - " '10110': 3,\n", - " '11010': 3,\n", - " '01010': 2,\n", - " '01100': 2,\n", - " '01101': 2,\n", - " '00101': 1,\n", - " '10010': 1,\n", - " '11001': 1}" + "{'00000': 3794,\n", + " '11111': 862,\n", + " '00010': 584,\n", + " '10000': 311,\n", + " '00011': 258,\n", + " '01111': 254,\n", + " '00110': 221,\n", + " '10111': 188,\n", + " '00111': 176,\n", + " '11101': 169,\n", + " '11000': 128,\n", + " '00100': 113,\n", + " '11100': 104,\n", + " '10010': 102,\n", + " '01010': 89,\n", + " '00001': 87,\n", + " '10100': 84,\n", + " '11110': 79,\n", + " '11011': 78,\n", + " '01011': 71,\n", + " '01000': 66,\n", + " '01101': 63,\n", + " '01110': 63,\n", + " '10110': 49,\n", + " '01100': 43,\n", + " '10011': 42,\n", + " '00101': 26,\n", + " '10101': 25,\n", + " '10001': 18,\n", + " '01001': 15,\n", + " '11001': 15,\n", + " '11010': 15}" ] }, - "execution_count": 28, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "t.results()" + "rb = t.results()\n", + "rb" ] }, { @@ -931,139 +930,29 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 31, "id": "24748fe7", "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
     ┌────────────┐┌───┐┌───┐┌────────────┐┌────────────┐┌─────────────┐»\n",
-       "q_0: ┤ Rz(1.5708) ├┤ S ├┤ H ├┤ Rz(0.7854) ├┤ Rz(0.3927) ├┤ Rz(0.19635) ├»\n",
-       "     └────────────┘└───┘└───┘└────────────┘└────────────┘└─────────────┘»\n",
-       "q_1: ───────────────────────────────────────────────────────────────────»\n",
-       "                                                                        »\n",
-       "q_2: ───────────────────────────────────────────────────────────────────»\n",
-       "                                                                        »\n",
-       "q_3: ───────────────────────────────────────────────────────────────────»\n",
-       "                                                                        »\n",
-       "q_4: ───────────────────────────────────────────────────────────────────»\n",
-       "                                                                        »\n",
-       "«     ┌──────────────┐┌──────────────┐┌──────────────┐┌──────────────┐»\n",
-       "«q_0: ┤ Rz(0.098175) ├┤ Rz(0.049087) ├┤ Rz(0.024544) ├┤ Rz(0.012272) ├»\n",
-       "«     └──────────────┘└──────────────┘└──────────────┘└──────────────┘»\n",
-       "«q_1: ────────────────────────────────────────────────────────────────»\n",
-       "«                                                                     »\n",
-       "«q_2: ────────────────────────────────────────────────────────────────»\n",
-       "«                                                                     »\n",
-       "«q_3: ────────────────────────────────────────────────────────────────»\n",
-       "«                                                                     »\n",
-       "«q_4: ────────────────────────────────────────────────────────────────»\n",
-       "«                                                                     »\n",
-       "«     ┌───────────────┐┌──────────────┐┌──────────────┐┌───────────────┐»\n",
-       "«q_0: ┤ Rz(0.0061359) ├┤ Rz(0.003068) ├┤ Rz(0.001534) ├┤ Rz(0.0003835) ├»\n",
-       "«     └───────────────┘└──────────────┘└──────────────┘└───────────────┘»\n",
-       "«q_1: ──────────────────────────────────────────────────────────────────»\n",
-       "«                                                                       »\n",
-       "«q_2: ──────────────────────────────────────────────────────────────────»\n",
-       "«                                                                       »\n",
-       "«q_3: ──────────────────────────────────────────────────────────────────»\n",
-       "«                                                                       »\n",
-       "«q_4: ──────────────────────────────────────────────────────────────────»\n",
-       "«                                                                       »\n",
-       "«     ┌────────────────┐┌────────────────┐┌───┐┌─────┐┌────────────┐»\n",
-       "«q_0: ┤ Rz(0.00019175) ├┤ Rz(9.5874e-05) ├┤ H ├┤ Sdg ├┤ Rz(3.1416) ├»\n",
-       "«     └────────────────┘└────────────────┘└───┘└─────┘└────────────┘»\n",
-       "«q_1: ──────────────────────────────────────────────────────────────»\n",
-       "«                                                                   »\n",
-       "«q_2: ──────────────────────────────────────────────────────────────»\n",
-       "«                                                                   »\n",
-       "«q_3: ──────────────────────────────────────────────────────────────»\n",
-       "«                                                                   »\n",
-       "«q_4: ──────────────────────────────────────────────────────────────»\n",
-       "«                                                                   »\n",
-       "«     ┌────────────┐          ┌───┐          ┌───┐     ┌───┐┌───┐     \n",
-       "«q_0: ┤ Rz(1.5708) ├──■────■──┤ X ├──■────■──┤ X ├──■──┤ X ├┤ X ├──■──\n",
-       "«     └────────────┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐  │  └─┬─┘  │  └─┬─┘└─┬─┘  │  \n",
-       "«q_1: ──────────────┤ X ├┤ X ├──■──┤ X ├──┼────┼────┼────┼────┼────┼──\n",
-       "«                   └───┘└───┘     └───┘┌─┴─┐  │    │    │    │    │  \n",
-       "«q_2: ──────────────────────────────────┤ X ├──┼────┼────┼────■────┼──\n",
-       "«                                       └───┘  │  ┌─┴─┐  │         │  \n",
-       "«q_3: ─────────────────────────────────────────■──┤ X ├──■─────────┼──\n",
-       "«                                                 └───┘          ┌─┴─┐\n",
-       "«q_4: ───────────────────────────────────────────────────────────┤ X ├\n",
-       "«                                                                └───┘
" - ], + "image/png": "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\n", "text/plain": [ - " ┌────────────┐┌───┐┌───┐┌────────────┐┌────────────┐┌─────────────┐»\n", - "q_0: ┤ Rz(1.5708) ├┤ S ├┤ H ├┤ Rz(0.7854) ├┤ Rz(0.3927) ├┤ Rz(0.19635) ├»\n", - " └────────────┘└───┘└───┘└────────────┘└────────────┘└─────────────┘»\n", - "q_1: ───────────────────────────────────────────────────────────────────»\n", - " »\n", - "q_2: ───────────────────────────────────────────────────────────────────»\n", - " »\n", - "q_3: ───────────────────────────────────────────────────────────────────»\n", - " »\n", - "q_4: ───────────────────────────────────────────────────────────────────»\n", - " »\n", - "« ┌──────────────┐┌──────────────┐┌──────────────┐┌──────────────┐»\n", - "«q_0: ┤ Rz(0.098175) ├┤ Rz(0.049087) ├┤ Rz(0.024544) ├┤ Rz(0.012272) ├»\n", - "« └──────────────┘└──────────────┘└──────────────┘└──────────────┘»\n", - "«q_1: ────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_2: ────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_3: ────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_4: ────────────────────────────────────────────────────────────────»\n", - "« »\n", - "« ┌───────────────┐┌──────────────┐┌──────────────┐┌───────────────┐»\n", - "«q_0: ┤ Rz(0.0061359) ├┤ Rz(0.003068) ├┤ Rz(0.001534) ├┤ Rz(0.0003835) ├»\n", - "« └───────────────┘└──────────────┘└──────────────┘└───────────────┘»\n", - "«q_1: ──────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_2: ──────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_3: ──────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_4: ──────────────────────────────────────────────────────────────────»\n", - "« »\n", - "« ┌────────────────┐┌────────────────┐┌───┐┌─────┐┌────────────┐»\n", - "«q_0: ┤ Rz(0.00019175) ├┤ Rz(9.5874e-05) ├┤ H ├┤ Sdg ├┤ Rz(3.1416) ├»\n", - "« └────────────────┘└────────────────┘└───┘└─────┘└────────────┘»\n", - "«q_1: ──────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_2: ──────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_3: ──────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_4: ──────────────────────────────────────────────────────────────»\n", - "« »\n", - "« ┌────────────┐ ┌───┐ ┌───┐ ┌───┐┌───┐ \n", - "«q_0: ┤ Rz(1.5708) ├──■────■──┤ X ├──■────■──┤ X ├──■──┤ X ├┤ X ├──■──\n", - "« └────────────┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐ │ └─┬─┘ │ └─┬─┘└─┬─┘ │ \n", - "«q_1: ──────────────┤ X ├┤ X ├──■──┤ X ├──┼────┼────┼────┼────┼────┼──\n", - "« └───┘└───┘ └───┘┌─┴─┐ │ │ │ │ │ \n", - "«q_2: ──────────────────────────────────┤ X ├──┼────┼────┼────■────┼──\n", - "« └───┘ │ ┌─┴─┐ │ │ \n", - "«q_3: ─────────────────────────────────────────■──┤ X ├──■─────────┼──\n", - "« └───┘ ┌─┴─┐\n", - "«q_4: ───────────────────────────────────────────────────────────┤ X ├\n", - "« └───┘" + "
" ] }, - "execution_count": 29, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "t.details(prettify=True)[\"backend\"].draw(idle_wires=False)" + "t.details(prettify=True)[\"backend\"].draw(idle_wires=False, output=\"mpl\")" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "id": "5f0ad718", "metadata": {}, "outputs": [ @@ -1073,7 +962,7 @@ "{0: 1, 1: 3, 2: 2, 3: 0, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8}" ] }, - "execution_count": 30, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1087,12 +976,12 @@ "id": "98b2b053", "metadata": {}, "source": [ - "To better customize and use the advanced compiling system, we strongly recommend the users to compile the circuit before task submission" + "To better customize and use the advanced compiling system, we strongly recommend the users to compile the circuit before task submission as **frontend compiling**" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "id": "4debc9ad", "metadata": {}, "outputs": [ @@ -1100,43 +989,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'logical_physical_mapping': {0: 6, 1: 2, 2: 0, 3: 3, 4: 7}, 'positional_logical_mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}}\n" + "{'logical_physical_mapping': {0: 6, 1: 2, 2: 0, 3: 4, 4: 8}, 'positional_logical_mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}}\n" ] }, { "data": { - "text/html": [ - "
                                ┌───┐             ┌─┐      \n",
-       "q_0: ───────────────────────────┤ X ├──■──────────┤M├──────\n",
-       "                           ┌───┐└─┬─┘  │  ┌─┐     └╥┘      \n",
-       "q_2: ──────────────────────┤ X ├──■────┼──┤M├──────╫───────\n",
-       "                           └─┬─┘     ┌─┴─┐└╥┘      ║ ┌─┐   \n",
-       "q_3: ────────────────────────┼───────┤ X ├─╫───■───╫─┤M├───\n",
-       "     ┌───┐┌──────────┐┌───┐  │   ┌─┐ └───┘ ║   │   ║ └╥┘   \n",
-       "q_6: ┤ H ├┤ Rz(1.57) ├┤ H ├──■───┤M├───────╫───┼───╫──╫────\n",
-       "     └───┘└──────────┘└───┘      └╥┘       ║ ┌─┴─┐ ║  ║ ┌─┐\n",
-       "q_7: ─────────────────────────────╫────────╫─┤ X ├─╫──╫─┤M├\n",
-       "                                  ║        ║ └───┘ ║  ║ └╥┘\n",
-       "c: 9/═════════════════════════════╩════════╩═══════╩══╩══╩═\n",
-       "                                  6        2       0  3  7
" - ], + "image/png": "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\n", "text/plain": [ - " ┌───┐ ┌─┐ \n", - "q_0: ───────────────────────────┤ X ├──■──────────┤M├──────\n", - " ┌───┐└─┬─┘ │ ┌─┐ └╥┘ \n", - "q_2: ──────────────────────┤ X ├──■────┼──┤M├──────╫───────\n", - " └─┬─┘ ┌─┴─┐└╥┘ ║ ┌─┐ \n", - "q_3: ────────────────────────┼───────┤ X ├─╫───■───╫─┤M├───\n", - " ┌───┐┌──────────┐┌───┐ │ ┌─┐ └───┘ ║ │ ║ └╥┘ \n", - "q_6: ┤ H ├┤ Rz(1.57) ├┤ H ├──■───┤M├───────╫───┼───╫──╫────\n", - " └───┘└──────────┘└───┘ └╥┘ ║ ┌─┴─┐ ║ ║ ┌─┐\n", - "q_7: ─────────────────────────────╫────────╫─┤ X ├─╫──╫─┤M├\n", - " ║ ║ └───┘ ║ ║ └╥┘\n", - "c: 9/═════════════════════════════╩════════╩═══════╩══╩══╩═\n", - " 6 2 0 3 7 " + "
" ] }, - "execution_count": 31, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -1146,7 +1009,7 @@ " c, compiled_options={\"coupling_map\": d.topology()}\n", ")\n", "print(info)\n", - "c1.draw(idle_wires=False)" + "c1.draw(idle_wires=False, output=\"mpl\")" ] }, { @@ -1159,41 +1022,48 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 33, "id": "3a165a8c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'00000': 442,\n", - " '11111': 295,\n", - " '01111': 66,\n", - " '11011': 34,\n", - " '11110': 29,\n", - " '10000': 26,\n", - " '10111': 22,\n", - " '11101': 16,\n", - " '11000': 15,\n", - " '01000': 14,\n", - " '00111': 11,\n", - " '11100': 10,\n", - " '00011': 9,\n", - " '00100': 5,\n", - " '01011': 5,\n", - " '10011': 5,\n", - " '01101': 4,\n", - " '11001': 4,\n", - " '01100': 3,\n", - " '01110': 3,\n", - " '00001': 2,\n", - " '00010': 1,\n", - " '00110': 1,\n", - " '10110': 1,\n", - " '11010': 1}" + "{'00000': 3506,\n", + " '11111': 1962,\n", + " '01111': 523,\n", + " '11011': 279,\n", + " '10000': 262,\n", + " '11110': 257,\n", + " '10111': 174,\n", + " '11000': 167,\n", + " '00111': 148,\n", + " '11101': 109,\n", + " '01000': 92,\n", + " '01011': 90,\n", + " '00001': 87,\n", + " '01110': 85,\n", + " '00011': 80,\n", + " '11100': 72,\n", + " '11010': 45,\n", + " '00100': 42,\n", + " '10011': 31,\n", + " '00110': 24,\n", + " '01101': 24,\n", + " '00010': 22,\n", + " '10110': 18,\n", + " '11001': 17,\n", + " '01100': 16,\n", + " '01010': 15,\n", + " '10100': 11,\n", + " '00101': 10,\n", + " '10001': 10,\n", + " '10101': 8,\n", + " '01001': 4,\n", + " '10010': 2}" ] }, - "execution_count": 32, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1201,12 +1071,36 @@ "source": [ "t = tc.cloud.apis.submit_task(\n", " circuit=c1,\n", - " shots=1024,\n", + " shots=8192,\n", " device=d,\n", " enable_qos_gate_decomposition=False,\n", " enable_qos_qubit_mapping=False,\n", ")\n", - "t.results()" + "rf = t.results()\n", + "rf" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "22d46c41", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tc.results.counts.plot_histogram([rb, rf], number_to_keep=2)\n", + "# backend compiling vs frontend compiling" ] }, { @@ -1222,32 +1116,31 @@ "id": "acc9f9ab", "metadata": {}, "source": [ - "The results can be further improved via readout error mitigation" + "The above results can be further improved via readout error mitigation (a classical algorithmic postprocessing on the measurement results)" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 35, "id": "da287ca9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'00000': 496.04758924971736,\n", - " '11111': 425.0199159717411,\n", - " '01111': 47.435856968160266,\n", - " '11000': 13.069671146547593,\n", - " '11110': 11.714948398147767,\n", - " '11100': 9.142744304288023,\n", - " '00111': 7.038018388943233,\n", - " '00011': 6.1005198202968645,\n", - " '10111': 5.016879874015307,\n", - " '10000': 2.2494050992135244,\n", - " '11101': 1.164450778928778}" + "{'00000': 3931.5654653719635,\n", + " '11111': 3736.9302177814375,\n", + " '11000': 156.2388037789295,\n", + " '00111': 139.79207327296174,\n", + " '10000': 82.70413218088015,\n", + " '10111': 62.54914892519676,\n", + " '11100': 40.2309011836783,\n", + " '00011': 34.01063384376864,\n", + " '01111': 5.923071025515406,\n", + " '00001': 2.0555526356691276}" ] }, - "execution_count": 33, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -1261,24 +1154,25 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 36, "id": "1cbf19de", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 34, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "tc.results.counts.plot_histogram([t.results(), mr], number_to_keep=2)" + "tc.results.counts.plot_histogram([t.results(), mr], number_to_keep=2)\n", + "# raw vs mitigated" ] }, { @@ -1291,18 +1185,18 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 37, "id": "43ea80ec", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAFTCAYAAABbKVcuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxdElEQVR4nO3de3xU1b3//9eHhBAQREC5RTQBJBUUlAYRG0PagwcOnmJtvbbKUSoeqtVSrdX+VASVqt9ar6it2srleAQvp0ptRaxHiFQEA4oCiojBI6AgEAUqJCR8fn/snTSEEPbAZGaSvJ+PxzycWWvtnU+YMZ/Za6+LuTsiIiJyYC2SHYCIiEhjoaQpIiISkZKmiIhIREqaIiIiESlpioiIRKSkKSIiElF6sgNIpiOPPNKzs7OTHYaIiKSQJUuWbHb3o+qqa9ZJMzs7m+Li4mSHISIiKcTMPtlfnbpnRUREIlLSTKDbb7+djIwMWrZsyYgRI/bb7rrrrsPMmD59OgBff/01vXr1IjMzk1atWjF8+PC92peXl9OmTRu6dOnSoPGLiDR3SpoJUl5ezqRJk5g7dy6lpaXMnz+f2bNn79Nuw4YNPProoxx22GHVZddddx27d+9m165drF+/nldffZUFCxZU15977rl07tw5Ib+HiEhzpqSZIFOnTqV9+/YUFhbStm1bCgoKeOihh/Zpd+aZZ/Lzn/+c9PR/3m5u0aIFZWVl7Nq1i9LSUlq0aEG3bt0AeOutt3j99de56qqrEva7iIg0V0qaCbJq1So6depU/TonJ4fPPvtsrzZPPvkkmzZtYuLEiXuV33XXXbRq1Yo2bdrQp08fzjvvPHr16gXA2WefzQMPPEBaWlqD/w4iIs2dkmaKqKio4Morr2TWrFn71E2bNo0WLVqwY8cOli9fztNPP828efOYMGECRxxxBBdddFESIhYRaX6UNBMkNzeXLVu2VL8uKSmp7mKF4F7mtm3bKCwsJD09na+++opLL72U6dOn8/DDDzNixAjatGlDv379yM7O5oUXXuCVV17h/fffJz09nWuvvZZNmzaRk5MTt5jnzJlDbm4uvXv35s4779xvu+eeew4zq56+8+STT3LSSSdVP1q0aME777wDQGFhIbm5udV1mzZtilu8IiINzt2b7eOb3/ymJ8rOnTs9PT3d58+f79u3b/fMzEx//vnn99u+ffv2Pm3aNHd3HzFihPfu3dvd3Tdu3OgZGRn+zDPP7NX+3nvv9c6dO8ct3oqKCu/Zs6evWbPGy8rKvH///r5ixYp92m3bts1PP/10Hzx4sL/11lv71L/77rves2fP6tdDhw6ts52ISKoAin0/eUNXmgmSmZnJTTfdxLBhw+jQoQP5+fmcddZZFBQUcOONN9Z77BNPPMHOnTvJzMykR48eDBs2jHPOOadB4128eDG9e/emZ8+eZGRkcMEFF/DCCy/s0+7mm2/m+uuvJzMzs87zPPXUU1xwwQUNGquISKIoaSbQLbfcQnl5Obt37+aVV14BoKioiMmTJ+/T9ssvv2T06NEAdO3alXXr1rFr1y7Kysr4y1/+sk/78ePHs3HjxrjFun79enr06FH9+uijj2b9+vV7tVm6dCmffvopZ5555n7PM2vWLC688MK9yi699FJOOukkbrvtNoIvdSIijYOSphyUPXv2cM011/Db3/52v20WLVpEmzZtOOGEE6rLnnzySd577z1ef/11Xn/9dWbMmJGIcEVE4kJJU+qUlZXFp59+Wv163bp1ZGVlVb/evn07y5cvp7CwkOzsbN58801GjRq111q+M2fO3Ocqs+oc7dq144c//CGLFy9u4N9ERCR+lDSlToMGDWL16tWUlJRQXl7OzJkzGTVqVHV9+/bt2bx5M2vXrmXt2rWceuqpzJ49m7y8PCC4En366af3up9ZUVHB5s2bAdi9ezcvvvjiXlehIiKprlnvciL7l56ezpQpUxg+fDiVlZWMGTOGfv36MWHCBPLy8vZKoHUpKiqiR48e9OzZs7qsrKyM4cOHs3v3biorKxk2bBhjx45t6F9FRCRurDkPxMjLy3NtDSYiIjWZ2RJ3z6urTt2zIiIiESlpioiIRKSkKSIiEpGSpoiISERKmiIiIhEpaYqIiESkpCkiIhKRFjeIg7H3JTuC2Dw2PtkRiIg0TrrSFBERiUhJU0REJCIlTRERkYiUNEVERCLSQKBmaE3uxGSHELNeqyYmOwQREV1pioiIRKWkKSIiEpGSpoiISERKmiIiIhEpaYqIiESkpCkiIhKRkqaIiEhESpoiIiIRJTxpmtkVZlZiZrvMbImZnR7xuHwzqzCz5bXKLzEzr+OR2TC/gYiINFcJTZpmdj5wP/Br4GTgDeAlMzvmAMd1AKYDr+6nyddAt5oPd98Vr7hFJDBnzhxyc3Pp3bs3d955537bPffcc5gZxcXFAGzZsoVvf/vbtG3blp/+9Kd7tS0vL+fyyy+nT58+fOMb3+C5555r0N9B5FAk+krzGmCquz/m7u+7+1XAZ8BPDnDcH4BpwML91Lu7f17zEceYRRrM7bffTkZGBi1btmTEiBH7bXfddddhZkyfPh2A1atX06FDB8yM/v3779X2iCOOICMjg9atW9O6dWtWrFgRl1grKyu58soreemll1i5ciVPPfUUK1eu3Kfd9u3buf/++xk8eHB1WWZmJrfddht33333Pu0nT55M586d+fDDD1m5ciVDhw6NS7wiDSFhSdPMMoBvAnNrVc0FTqvnuCuALsDt9Zy+tZl9YmbrzOxFMzv5kAMWaWDl5eVMmjSJuXPnUlpayvz585k9e/Y+7TZs2MCjjz7KYYcdVl3Wvn17Jk+ezIUXXljnuR9//HF27tzJzp076devX1ziXbx4Mb1796Znz55kZGRwwQUX8MILL+zT7uabb+b6668nM/Ofd0gOO+ww8vPz9yqr8sc//pFf/epXALRo0YIjjzwyLvGKNIRELth+JJAGbKxVvhEYVtcBZnYicAtwqrtXmlldzVYBY4BlQDvgZ8DfzWyAu6+u45yXA5cDdO/enXnz5gHQs2dP2rVrx7JlywDo1KkT/fr1o6ioCID09HTy8/NZunQp27ZtAyAvL4+NGzcCvaL+G8hBisf79OmnnwJw3HHH0apVK5YvD26Pd+7cmT59+rBgwQIAWrVqxZAhQyguLmbHjh0ADB48mHXr1rF+/XoAcnNzSUtLq77S6tq1Kzk5OSxcGHSGtG7dmsGDB7No0SJ27twJwJAhQygpKeHzz4OOkOLiYtq1a1f9PC8vjwceeIDDDz8cgLZt25KXl0dhYSHf+973eO6556isrGTlypVs2rSJvn378sYbb1BeXl7979OjRw/cnQ8++IB58+Zx+OGHM3DgQBYsWEBFRQUABQUFrFixgi1btgAwYMAAtm/fzscffwxAdnY2HTt2ZOnSpQB06NCBAQMGMHfuXNLT05k/fz5Dhw5lz549FBcXM2/ePAYOHMjWrVuZO3cuS5cu5ZprrqGiooIlS5awY8eO6vfpgw8+YP369SxYsID8/Hzmz59PWVkZl1xyCatXr6Zbt26MHTuWjh07psz71LdvXyorK1m1ahUAWVlZHH300SxatGiv92nhwoWUlZUBkJ+fz4cffsimTZsAOOGEEygrK2P16tXV71OXLl2qu6/j+T7Nnz8fd8fMGDp0KMuWLaO0tBSg+n1au3Ztk/v/KZ7vU33M3ettEC9m1h1YDwx196Ia5ROAH7l7bq32rYC3gTvcfUZYNhE4x91PqOfnpAHvAK+5+9X1xZSXl+dVH9pDMfa+Qz5FQt3wyMRkhxCzprjLybXXXsuLL75Y/T/5uHHjeOONN3j33Xer2zz55JP88pe/ZP369RxxxBE88MADjB49urr+sssuY/HixXsdc8QRR7Br1y7MjNNOO41XXnmFFi0OvVPp2WefZc6cOTz++OMAzJgxg0WLFjFlyhQA9uzZw3e+8x2mTp1KdnY2hYWF3H333eTl5VWfY+rUqRQXF1cfs3nzZo466iieeeYZzjnnHO655x7efvttZsyYccjxihwsM1vi7nl11SXynuZmoJKgq7WmLkBd9yC7AccDT4SjZiuACUC/8PW/1vVD3L0SKAaOi1vkIklQUVHBlVdeyaxZs2I67m9/+xu7du1izZo1vPPOO4wbNy4u8WRlZVVfXQCsW7eOrKys6tfbt29n+fLlFBYWkp2dzZtvvsmoUaOo74tpp06daNOmDd///vcBOPfcc6uvnERSUcKSpruXA0uAM2pVnUEwira29cCJwEk1Hr8DPgqf13UMFvTh9icYYCSSsnJzc6u73gBKSkro1q1b9esNGzawbds2CgsLSU9P56uvvuLSSy+tHgy0P1VXdt27d+fss8/mzTffjEu8gwYNYvXq1ZSUlFBeXs7MmTMZNWpUdX379u3ZvHkza9euZe3atZx66qnMnj17ryvN2syM7373u9Xdy6+++ip9+/aNS7wiDSHRm1DfA8wws8XA34FxQHeCZIiZTQdw99HuvhuoPSdzE1Dm7strlN0CvAmsBg4HriZImgcakSuSVKNHj+bKK6+kqKiIgQMHUlRUxMyZM6vrjznmGPbs2VP9uq7u2dp27drFJ598Qm5uLl9//TVz5syhoKAgLvGmp6czZcoUhg8fTmVlJWPGjKFfv35MmDCBvLy8vRJoXbKzs9m2bRvl5eU8//zzzJ07l759+3LXXXdx8cUXM378eI466iieeOKJuMQr0hASmjTdfZaZdQJuIuh+XQ6MdPdPwib1ztfcjyOAR4GuwFcE90EL3H3xoUcs0nAyMzO56aabGDZsGO5OYWEhZ511FgUFBZx++ulMnjy53uPT09PZs2cP7k5aWhp/+tOfOPXUUzn55JNxd9ydb3zjG0ydOjVuMY8cOZKRI0fuVXbrrbfW2bbq6rFK1eCT2o499tjqgSciqS5hA4FSkQYCNR5NcSCQiKSmVBkIJCIi0qgpaYqIiESkpCkiIhKRkqaIiEhESpoiIiIRKWmKiIhEpKQpIiISkZKmiIhIREqaIiIiESlpioiIRJToBdtFJEWtyZ2Y7BBioqUVJRmUNEUaQGNbjxjghmQHINIIqHtWREQkIiVNERGRiJQ0RUREIlLSFBERiUhJU0REJCIlTRERkYiUNEVERCJS0hQREYlISVNERCQiJU0REZGIlDRFREQiUtIUERGJSElTREQkIiVNERGRiJQ0RUREIlLSFBERiUhJU0REJKLISdPMvmdmaQ0ZjIiISCqL5UrzSWC9md1lZn0aKiAREZFUFUvS7ArcAgwF3jezBWZ2qZkd1jChiYiIpJbISdPdt7v77939VKA/sAi4A/jMzB4zs1MbKkgREZFUcFADgdx9BXAv8CiQAZwPvG5mi8ysfxzjExERSRkxJU0za2lm55nZHKAE+A4wDugCHAu8D8yKe5QiIiIpID1qQzN7ELgQcGAGcI27r6zRZKeZ3QBsiG+IIiIiqSFy0gT6Aj8F/sfdy/fTZjPw7UOOSkREJAXF0j07CXi2dsI0s3QzKwBw9wp3nx/PAEVERFJFLEnzNaBjHeXtwzoREZEmLZakaQT3M2vrBPwjPuGIiIikrgPe0zSz2eFTB/7LzMpqVKcBJwBvNEBsIiIiKSXKQKAt4X8NKAV21qgrBxYAj8U5LhERkZRzwKTp7pcCmNla4G53V1esiIg0S5GnnLj7pIYMREREJNXVmzTN7F1gqLuXmtl71D0QCAB31/J5IiLSpB3oSvM5oGrgz7MNHIuIiEhKqzdp1uySVfesiIg0dwe1y4mIiEhzdKB7mvXex6xJ9zRFRKSpO9A9Td3HFBERCUW+pykiItLc6Z6miIhIRJqnKSIiEpHmaYqIiESkeZoiIiIRRV57toqZ9QKOD1++7+5r4huSiIhIaoqcNM2sE/AHYBSw55/F9iIwxt237PdgERGRJiCW0bOPA72B04HM8FEA5KD9NEVEpBmIpXt2OPAv7r6wRtnfzew/gb/FNywREZHUE8uV5hdAXRtQfw2oa1ZERJq8WJLmrcB9ZpZVVRA+/21YJyIi0qTFumB7DrDWzNaHr7OAXUBngnueIiIiTZYWbBcREYlIC7aLiIhEpAXbRUREIoqcNM0sw8wmmdmHZrbLzCprPmI4zxVmVhKeY4mZnV5P26Fm9oaZbTGznWb2gZn9oo52PzCzlWZWFv737KjxiIiIRBXLleZtwH8QjJbdA1wHPEQw3eSKKCcws/OB+4FfAycDbwAvmdkx+zlkB/AAwSIKfYHbgUlmVv3zzGwIMAt4Ejgp/O8zZjY4ht9NRETkgGJJmucB49z990Al8IK7Xw3cApwR8RzXAFPd/TF3f9/drwI+A35SV2N3X+LuM919hbuXuPt/AS8TrEpUZTzwmrtPDs85GZgXlouIiMRNLEmzC7AyfL4DOCJ8Pgf41wMdbGYZwDeBubWq5gKnRQnAzE4O286vUTykjnO+HPWcIiIiUcWyjN7/Ad3D/35EsKzeEoKktTPC8UcCacDGWuUbgWH1HWhm64CjwngnufvvalR33c85u+7nXJcDlwN0796defPmAdCzZ0/atWvHsmXLAOjUqRP9+vWjqKgIgPT0dPLz81m6dCnbtm0DIC8vj40bNwK96gtf4iAe79Onn34KwHHHHUerVq1Yvnw5AJ07d6ZPnz4sWLAAgFatWjFkyBCKi4vZsWMHAIMHD2bdunWsXx9MUc7NzSUtLY2VK4PvkV27diUnJ4eFC6tWmSxs0H8PgYULFx7y+9S6dWsGDx7MokWL2Lkz+DM2ZMgQSkpK+PzzzwHo27cvlZWVrFq1CoCsrCyOPvpoFi1aBEDbtm3Jy8tj4cKFlJUF2w/n5+fz4YcfsmnTJgBOOOEEysrKWL16NQA9evSgS5cuFBcXA3D44YczcOBAFixYQEVFBQAFBQWsWLGCLVuCBdcGDBjA9u3b+fjjjwHIzs6mY8eOLF26FIAOHTowYMAA5s+fj7tjZgwdOpRly5ZRWloKwMCBA9m6dStr164FGs//T4l+n+pj7l5vg+qGZncAO9x9spmdAzwFrCNY4OA37n7jAY7vDqwHhrp7UY3yCcCP3D23nmNzgLbAqcBdwM/cfUZYVw5c5u7Ta7QfDTzm7q3qiykvL8+rPrSHYux9h3yKhLrhkYnJDiFmvVZNTHYIMWlsnwlofJ+LxvaZkMbDzJa4e15ddZGvNN39VzWePxte/Z0GfOjuL0Y4xWaCe6FdapV3AT4/wM8uCZ++Z2ZdgInAjLDs84M5p4iISKwOep6mu7/p7vdETJi4ezlBd27tQUNnEIyijaoFUPMKcmEczikiInJAsdzTxMwGEoxK7RsWvQ/c6+5LI57iHmCGmS0G/g6MI7hP+rvw/NMB3H10+PoqoARYFR5fAPwCeLjGOe8HiszsBuB54Gzg20B+LL+biIjIgUROmmb2I2A68L/AX8PiU4HFZnZJOB2kXu4+y8w6ATcB3YDlwEh3/yRsUnu+ZhrBPcxsoAJYA9xAmGTDc75hZhcQzOG8NWxzvrsvivq7iYiIRBHLleZk4GZ3/3XNQjP7FUHCOmDSBHD3h9n7SrFmXWGt1/cB90U457NocXkREWlgsdzTPAp4uo7yZwi2BhMREWnSYkmar1H35LNC9l5sQEREpEk60CbU36/x8iXgDjPLA94My04Fvk8wBURERKRJO5hNqKtX1KnhQfZzn1JERKSpONAm1NpvU0REJKSkKCIiElFMSdPMzjSzIjPbbGZfmNl8MxvZUMGJiIikkshJ08wuA/5EsHjA9QSLDJQAfzKzMQ0TnoiISOqIZXGD64Fr3H1KjbI/mNkSggT6x7hGJiIikmJi6Z49hmDD6dpeAo6NTzgiIiKpK5ak+X/su5sIwL8Cn9RRLiIi0qTE0j17N/BguNNJ1bZb3wIuBq6Kd2AiIiKpJpZNqH9vZpuAawlWAYJga7Dz3P2FhghOREQklURKmmbWkmCXk4fcXftUiohIsxTpnqa77wauAKxhwxEREUldsQwEehn4TkMFIiIikupiGQj0KvBrM+sPLAH+UbPS3f8nnoGJiIikmliSZtWiBlfXUedA2qGHIyIikrpiGT2rxd1FRKRZUyIUERGJKNZdTr5XY5eTzWb2upmd3VDBiYiIpJJYdjm5FpgFrAJ+GT4+AP7bzH7RMOGJiIikjlgGAv0C+Km7P1aj7I9mthi4lWCZPRERkSYrlu7ZtsBrdZS/FtaJiIg0abEkzeeBc+oo/wEwOy7RiIiIpLBYumc/Am4ws28DC8OyU8PHPWZ2TVVDd78nfiGKiIikhliS5iVAKdAnfFQpBS6t8doBJU0REWlyYlncIKchAxEREUl1B7W4gZl9y8xaxTsYERGRVHawKwK9BGTFMxAREZFUd7BJU/tqiohIs6O1Z0VERCI62KT5n8DGeAYiIiKS6mKZclLN3f873oGIiIikunqTppnNBi5y923h8/1y91FxjUxERCTFHOhKcwvBYgVVz0VERJqtepOmu19a13MREZHm6KBHz5pZazMbZmbHxjMgERGRVBXLJtRTzeyK8HkGsBiYC6wys39roPhERERSRixXmsOBN8Pno4B2QFdgYvgQERFp0mJJmh2ATeHzEcBz7r4JmAn0jXdgIiIiqSaWpPk5cIKZpRFcdf4tLG8L7I53YCIiIqkmlsUN/gjMAjYAlcCrYflg4IM4xyUiIpJyYtlP81YzWwEcAzzj7uVhVQVwV0MEJyIikkpiWkbP3Z+ro2xa/MIRERFJXTElTTNLB04huNrMqFnn7tPjGJeIiEjKiZw0zewbwJ+BHIL9NCvD43cDZYCSpoiINGmxjJ69D1gCtAe+Bo4H8oB3gB/EOzAREZFUE0v37CBgqLv/w8z2AOnuvtTMfgk8CPRvkAhFRERSRCxXmkZwhQnwBZAVPl8H9I5nUCIiIqkolivN5cAA4GOCdWevN7NKYCzwUQPEJiIiklJiSZqTgcPC5zcBfwFeAzYD58U5LhERkZQTy+IGL9d4/jFwvJl1BErd3fd/pIiISNMQ0zzN2tx9a7wCERERSXWxzNOcXV+9u4869HBERERSVyxXmltqvW5JMDCoB/A/cYtIREQkRcVyT/PSusrN7LfAtrhFJCIikqJimae5P78HrozDeURERFJaPJJmbhzOISIikvJiGQj0QO0ioBvwbwQbVIuIiDRpsQwEOrHW6z0Ey+n9HCVNERFpBmIZCPRtM2sPHAeUAyXuvr3BIhMREUkxke5pmtkxZvZngmkni4C3gc1m9pSZda7RrlXDhCkiIpJ8B7zSNLMs4E2C7tgJwMqwqh9wBfCmmZ0MnB6W3dUwoYqIiCRXlO7ZW4ASYJi776xR/ryZ3QvMBWYDpwAXxz9EERGR1BAlaY4EflQrYQLg7l+b2U3A/wJXufuz8Q5QREQkVUS5p3kUsKae+o+ASnd/KMoPNLMrzKzEzHaZ2RIzO72ett3M7L/N7AMzqzSzqXW0ucTMvI5HZpR4REREooqSNDcBveupPw74PMoPM7PzgfuBXwMnA28AL5nZMfs5pBXBfp13EgxA2p+vCeaMVj/cfVeUmERERKKKkjRfAm6va2RseDV3G/DXiD/vGmCquz/m7u+7+1XAZ8BP6mrs7mvd/Wp3nwrUtw2Zu/vnNR8R4xEREYksyj3NiUAx8JGZTQE+CMv7EoyeTQPOO9BJzCwD+CZwd62qucBpEePdn9Zm9kkYyzvAze7+9iGeU0REZC8HTJruvsHMTgMeJuhWtaoqYA5wpbtviPCzjiRIahtrlW8EhkWOeF+rgDHAMqAd8DPg72Y2wN1X125sZpcDlwN0796defPmAdCzZ0/atWvHsmXLAOjUqRP9+vWjqKgIgPT0dPLz81m6dCnbtgWbuuTl5bFx40ag1yGEL1HE43369NNPATjuuONo1aoVy5cvB6Bz58706dOHBQsWANCqVSuGDBlCcXExO3bsAGDw4MGsW7eO9evXA5Cbm0taWhorVwYzsLp27UpOTg4LFy4MIy5s0H8PgYULFx7y+9S6dWsGDx7MokWL2LkzGOs4ZMgQSkpK+PzzoMOqb9++VFZWsmrVKgCysrI4+uijWbQouGPUtm1b8vLyWLhwIWVlZQDk5+fz4YcfsmnTJgBOOOEEysrKWL06+JPUo0cPunTpQnFxMQCHH344AwcOZMGCBVRUVABQUFDAihUr2LIl2JVxwIABbN++nY8//hiA7OxsOnbsyNKlSwHo0KEDAwYMYP78+bg7ZsbQoUNZtmwZpaWlAAwcOJCtW7eydu1aoPH8/5To96k+5u71NtirsVkHgnuYAKvdvTSGY7sD64Gh7l5Uo3wCwejcehd+N7MXgc3ufskB2lVdbb7m7lfX1zYvL8+rPrSHYux9h3yKhLrhkYnJDiFmvVZNTHYIMWlsnwlofJ+LxvaZkMbDzJa4e15ddbGsPUuYJBcfZBybgUqgS63yLkQcSBSFu1eaWTH/TO4iIiJxEY+twSJx93JgCXBGraozCEbRxoWZGdCfYICRiIhI3MR0pRkH9wAzzGwx8HdgHNAd+B2AmU0HcPfRVQeY2Unh08OBPeHrcndfGdbfQrDM3+qwzdUESbPOEbkiIiIHK6FJ091nmVkn4CaC+ZTLgZHu/knYpK75mrVHwX4X+ATIDl8fATwKdAW+CtsXuPvBdiOLiIjUKdFXmrj7wwQjceuqK6yjzOpoWrP+5wR7eoqIiDSohN3TFBERaeyUNEVERCJS0hQRkYM2Z84ccnNz6d27N3feeec+9UVFRQwcOJD09HSefXbvjbCmTZvGcccdx3HHHce0adOqy5966ilOPPFE+vfvz4gRI9i8eXOD/x5RKWmKiMhBqays5Morr+Sll15i5cqVPPXUU9Wr+lQ55phjmDp1Kj/84Q/3Kt+6dSuTJk1i0aJFLF68mEmTJlFaWkpFRQU/+9nPeO2113j33Xfp378/U6ZMSeSvVS8lTREROSiLFy+md+/e9OzZk4yMDC644AJeeOGFvdpkZ2fTv39/WrTYO928/PLLnHHGGXTs2JEOHTpwxhlnMGfOHNwdd+cf//gH7s62bdvo3r17In+teilpiojIQVm/fj09evSofn300UdXryd7sMe2bNmSRx55hBNPPJHu3buzcuVKfvzjH8c99oOlpCkikkJuv/12MjIyaNmyJSNGjNin/sEHH6RNmzaYGddee+1edWPHjiUjI4OMjAzGjh1bXf6tb32L9PR0ggXTUtvu3bt55JFHePvtt9mwYQP9+/fnjjvuSHZY1ZQ0RURSRHl5OZMmTWLu3LmUlpYyf/58Zs+evVebk08+menTp9OzZ8+9ytesWcPUqVN5//33WbVqFVOnTqWkpASASy+9lHhsTlFbVlZW9W4nAOvWrSMrK+uQjn3nnXcA6NWrF2bGeeedxxtvxG2l1UOmpCkikiKmTp1K+/btKSwspG3bthQUFPDQQw/t1SY/P59zzjlnn6vG++67j969e9OrVy9ycnLo3bs399xzDwCXXXYZJ510UtzjHTRoEKtXr6akpITy8nJmzpzJqFGjIh07fPjw6i8HpaWlzJ07l+HDh5OVlcXKlSv54osvAHjllVc4/vjj4x77wUr4ikAiIlK3VatW0alTp+rXOTk5ka+ySkpK9rrK6969e/WVZkNJT09nypQpDB8+nMrKSsaMGUO/fv2YMGECeXl5jBo1irfeeouzzz6b0tJS/vznP3PLLbewYsUKOnbsyM0338ygQYMAmDBhAh07dgTglltuoaCggJYtW3LssccyderUBv09YqGkKSIiB23kyJGMHDlyr7Jbb721+vmgQYNYt25dnceOGTOGMWPG7FM+btw4xo0bF99A40TdsyIiKSI3N5ctW7ZUvy4pKaFbt26Rjs3Jydlr5OqGDRvIycmJe4zNnZKmiEiKGD16NF999RVFRUXs2LGDoqIirrjiikjHjh8/no8++oiSkhJKSkr46KOPGD9+fMMG3AwpaYqIpIjMzExuuukmhg0bRocOHcjPz+ess86ioKCAG2+8EQiWnktLS2PNmjXce++9ZGZmAsFo04suuog+ffrQp08fLr74Ynr16gXAKaecQlpaGgBpaWkUFhYm5fdrCszdkx1D0uTl5Xk8hmGPve/QY0mkGx6ZmOwQYtZr1cRkhxCTxvaZgMb3uWhsn4nGaE3uxGSHEJN4fSbMbIm759VVpytNERGRiJQ0RUREIlLSFBERiUjzNEVEEqBR3udOdgApSFeaIiIiESlpioiIRKSkKSIiEpGSpoiISERKmiIiIhEpaYqIiESkpCkiIhKRkqaIiEhESpoiIiIRKWmKiIhEpKQpIiISkZKmiIhIREqaIiIiESlpioiIRKSkKSIiEpGSpoiISERKmiIiIhEpaYqIiESkpCkiIhKRkqaIiEhESpoiIiIRKWmKiIhEpKQpIiISkZKmiIhIREqaIiIiESlpioiIRKSkKSIiEpGSpoiISERKmiIiIhEpaYqIiESkpCkiIhKRkqaIiEhESpoiIiIRKWmKiIhEpKQpIiISkZKmiIhIREqaIiIiESlpioiIRKSkKSIiEpGSpoiISERKmiIiIhEpaYqIiESkpCkiIhKRkqaIiEhESpoiIiIRKWmKiIhElPCkaWZXmFmJme0ysyVmdvoB2g8N2+0ys4/NbNyhnlNERORgJDRpmtn5wP3Ar4GTgTeAl8zsmP20zwH+GrY7GbgDeNDMfnCw5xQRETlYib7SvAaY6u6Pufv77n4V8Bnwk/20HwdscPerwvaPAdOAXxzCOUVERA5KwpKmmWUA3wTm1qqaC5y2n8OG1NH+ZSDPzFoe5DlFREQOSnoCf9aRQBqwsVb5RmDYfo7pCvytjvbp4fks1nOa2eXA5eHLHWa2KkrwTcnjwb/d5mTHEROblOwImrxG97nQZ6LBNePPxLH7q0hk0kwJ7v4o8Giy40gmMyt297xkxyGpRZ8LqU2fiX0lMmluBiqBLrXKuwCf7+eYz/fTviI8nx3EOUVERA5Kwu5puns5sAQ4o1bVGQQjXuuycD/ti91990GeU0RE5KAkunv2HmCGmS0G/k4wOrY78DsAM5sO4O6jw/a/A35qZvcBvwe+BVwCXBj1nFKnZt09Lfulz4XUps9ELebuif2BZlcAvwS6AcuBn7t7UVg3D8DdC2u0HwrcC/QDNgB3ufvvop5TREQkXhKeNEVERBorrT0rIiISkZKmiIhIREqaIiIiESlpNmNmZjWet6j5WkRE9qWk2by1MLOeAO6+x8NRYUqeIgJgZqckO4ZUo9GzzZCZnUiwU8wg4CuCFZYWAf/l7u8kMTRJEjOzGl+a0oDqL1HSPJnZ94GfuHvtxWOaNV1pNk//A3QAZhDsV7oMyAdmmtn9ZtY5mcFJ4rm7m9nx4fPK8LWFCVSaETM7L3z6c6A4LEurdTsnMxmxpYJmt2B7c2dmPyT4snSRu28Ly9oBucAI4FKgtZn9NFymUJoBMzsXmGVmbwCzgafc/VOCtZ0xsxZAGyDH3d9LXqTSkMIvzNPNbFpY9CQEX6TC+rTw+S1m9nd3fzFJoSaNrjSbn2OAD4DtVQXuvt3di939doJNvc8CTkpOeJIk5wOLgfeBi4CFZvZXMxttZm3cfQ9QALydzCClwW0FOgN/BloB95jZVjN7zMxOcfdKM8sGrgdWJDHOpNE9zWbGzE4FXgMmAg+7+/Za9QYUAS+5+68TH6Ekmpm1Bv4SPqYDvQjudxcAJxPsWTsf6At84u7nJilUSRAzG0LQs/ARcC7Bl6qTgC+BT4GN7v5vyYovmZQ0myEzuxEYC7wETCW4uihz9zIzO5bgHudId9dOMc1A2D1/ObA93G+2qjyLIFEOBv4FGAoMcvclSQlUGlTVYLDwfmV3YIu7fxV+kW4DHA98J2z+nLuvSVasyaSk2YyYWQt332NmLQn+SF5D0F27nGCHmB5AH2CNu/978iKVZKjxR7PqvlV1OXALcLm7d09ehNKQzCzd3SvMbDzQH7jH3ZeH7/+R7v5FciNMDbqn2YyECTMz3Iv0IXfvRXAF8QZBd9yXwBTgsiSGKQkWjpKtnnJSY9CHha8dOA2YlbwopaG5e0X4dDywlKAHCmAy8JyZzTWzfsmILZVo9GwzYWZdgXOAgeHUgsXArHALtaqt2TLdfVcSw5TkSKvxB7NajXmbLYHngecSHJckSI1ehkHAYe4+JSy/mmAP4z8SDBD8N5rpAKAqutJsPv4AXAV0JBgBWQgUmdmHZjY27JrZFU4tkGakKmGGc/H2mZcZ9kw87O4bEx+dJEKNhSz6ACVm1tXMzgG+C9zi7jcRJM4RyYoxVegPZDNgZt8BTgH+xd2/R3AvsyB8zAd+BVwNQRduksKUBDOzb5nZMjO7zMwywkUNqrpm06vWIzazI7XIQbPxCpABzCS4VfMm/+yW/yawIUlxpQwlzeahAHjP3dcBuPsud/8qHB17LcFV6K1mNjCZQUrCXQ6cANwGfG1mc8zs3yG4+gy/QJ0G/Beg9YibuLCLdhPBF+iPgNuBie6+zcxOIhg9/VASQ0wJGj3bDJhZPvAn4GJ3n1NHfTrBcnovufu9iY5PksPM5gNzgBcJeiLOJfjDuBt4BniAYFDYUHfvn6w4peHVHAhWR92xwP0EvbhnJzay1KOBQM3DEoI5mVPM7HGCLpgP3P0fYX1bgvl4v0tSfJJgZtYdWA1sdff3zGwlwZrEvQlGVP+AYLBYS4IBINK0Wbigwc0EKwL9HbjT3Te4+ydm9p9A66RGmCJ0pdlMmFkPgnuXw4BS4C3gc4K1RYcAue6em7wIJdHMrBPQJlxjtmZ5OsGC/lcBV7v7EUkITxKgak5uuCb1/0fQ89AVOBPIAbYBvdx9dRLDTClKms2MmfUnWFv0NIKehg4E8zTv0ULcUpOZPQ9UuvsPkh2LNIwaC568C0xz99+a2f8DjnH3C8zsG8B9wOPu/mxSg00R6p5twsysFcHKHt8nWKD9XaDY3X8Z1ucCa4Fy7Z0oNZlZW4IeifuTHYs0nDBhdgW6EKw9DPBj4Ifh87XA4YD+PoSUNJu23xAkzM8I5mdmA5+b2QvAXe6+KomxSQpz9x1mNs7dy5IdizS4rcDrQJaZtSf4gj0vrOsNDCAYEyFoykmTZWZ9CVbyGAOMCJfM6wo8SLCqxwdm9p81N5aVps/MupjZxWbW8QDtMsMF/PX5aPquC/97BzANKArf+2zgJmCeu3+drOBSjZJm0/U94B13n+vuW8IVf75w9zvdPQe4l2Bn9m5JjVIS7SaCP4wfmdkzZjYy7MavZmbHAD81s1bqtm+aqr4MhVsF/oxg16M3gMOAPuF0pMUEI2YnJCvOVKSk2XS9D3Qzs94QTFYPV3nJDOsfA74mWI9Wmo884C6CRS06EMzfLTGzB2ssbjEWUNds83A0wfzsUoI9dq8hGFm/GLgT+JG2gtub7mk2XUVABfCimU0AXgj/CFYAuHtJuDSa/jA2E+HczHVAibs/YWYzCO5ZnQVcCFwRztfsSTD9QJqoGj0IfYHjzWyAuy8jWNTimaptwpIXYerSlJMmLPwjeS9wIsEfy8XA/4bPryQYIZddY5EDacLM7DCCTYQ3ufuiWnVtCJbU+wXB4LF27r4z8VFKopjZiQQjZjsDa4AnCNaifsfddycztlSmpNnEhRPY/x04g+AKIpegW24+8Ht3n5nE8CSJ6lo6zcymEkxmPz05UUkimdnhBIub/JRgE/qtwHsEOyG95u6fJDG8lKSk2QSZ2dEE3W4A/wBWAjsJkmZbgnuZm919a3IilGQIt33zetYYbQ28ADzi7n9KaHCSdGbWjWAA4bkEW4Rd4+5PJzWoFKSk2cSY2U8IppkMIEiOHxN0x74GPFt7yTSRKuFm03nuvjDZsUjyhF+ucoF17r492fGkGiXNJiTsiv0I+C3wCHAUwVqzhQQ3/DcQrCW6sr5dDaRpCZNhDvCJRsSKHBolzSbEzK4CLnL3wXXU5RNMXs4CTnH3zYmOT5LDzMYDk4GnCXYyeQv4omrD6bDN4cDpwCvuXp6MOEUaA83TbFrKgXZmdgIEa8+aWQaAuy8AfgTsAv41eSFKEpxPMHK6N/A8sBD4jZnlh8umQTCS+mYlTJH6KWk2Lc8Ce4DxZtbO3cvcvTy8R4G7/x/wJcGEZmkGzOwogk2lHwtHxB4L/IFgRHUR8L9mdj0wHli0v/OISEDds01EjTVCzyLYmaIjQXfcwwTDx48GCgjudZ7o7muTEKYkWDgi8gJgpbu/XKvuZOCysL4D0MPd1yc+SpHGQ0mziTGzI4BjCPbLPBv4Vlj1OWDADHefmJTgJCnCqSTu7rtqLsBeNRDMzCYDI9395GTFKNJYaBm9JsDMOgMXE6wnuplgTuaXwALgbqAlwf2sOe7+YZLClCRx951VybKOxQzaAD8gWA1GRA5AV5pNQLiKSz/gzwQrenQkWDqvD7AJuKn2smnS9IUjYrfXN7UoXMD/fOApDQISOTAlzUYuvILYTtC9VlSj7BhgMME9q57Aee6+NGmBSsKZ2e8JRs0uJpijua2ONke4+5eJjk2ksdLo2cavL1BCMN0ECNdJc/8kXALruwRdtecmJzxJBjO7kGCLr98SLI33GzM728x6hfc4q+51TquaoiQiB6YrzUYu/MP3ItAGGA2scfc9tdpcBfzY3U9KfISSDGb2GFAJ/D+CXUv+A+gFrAL+CrxKsFTa/e6ekaw4RRobXWk2cuH2TTcS7LA+HRhtZj3MrC1UD/QYCixPXpSSSGaWTtD78KW7f+zud7v7icAggt1t/oNgOtKDwIzkRSrS+OhKs4kIu9huBkYR7GyyEPiCYO3Zz4DL3P295EUoiWRmHYAu7v5BuCrU7poDgszsfOApYKC7v5OkMEUaHSXNJiacfnImwRY/uwiuMJ9x9w+SGZckX7gylLl7pZmNJeiabZPsuEQaEyXNJszMWtS+vykCYGbXAGnu/ptkxyLSmChpijRD4XZhlfpSJRIbJU0REZGINHpWREQkIiVNERGRiJQ0RUREIlLSFBERiUhJU0REJCIlTRERkYj+f6JMzW5bnie6AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 35, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -1311,7 +1205,9 @@ "mit1 = tc.results.rem.ReadoutMit(d.name + \"?o=0\")\n", "mit1.cals_from_api(9)\n", "mr1 = mit1.apply_correction(t.results(), qubits=5, **info)\n", - "tc.results.counts.plot_histogram([mr, mr1], number_to_keep=2)" + "tc.results.counts.plot_histogram([mr, mr1], number_to_keep=2)\n", + "\n", + "# mitigated via real time calibriation vs. mitigated via api calibriation data" ] }, { @@ -1324,17 +1220,17 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 38, "id": "77e7d8e1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(array(1.+0.j, dtype=complex64), 0.9555765968884041)" + "(array(1.+0.j, dtype=complex64), 0.9584156264735034)" ] }, - "execution_count": 36, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -1355,17 +1251,53 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 39, + "id": "f07070b5", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "\n", + "logger = logging.getLogger(\"tensorcircuit.cloud\")\n", + "logger.setLevel(logging.INFO)\n", + "# ch = logging.StreamHandler()\n", + "# ch.setLevel(logging.INFO)\n", + "# logger.addHandler(ch)\n", + "\n", + "# we enable log for the high level API to see what happen behind the scene" + ] + }, + { + "cell_type": "markdown", + "id": "4f50a8f1", + "metadata": {}, + "source": [ + "$\\langle Z_0Z_1\\rangle$" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "id": "2100ff5d", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:tensorcircuit.cloud.wrapper:submit task on tencent::tianxuan_s1 for 1 circuits\n", + "INFO:tensorcircuit.cloud.wrapper:finished collecting count results of 1 tasks in 4.873 seconds\n", + "INFO:tensorcircuit.cloud.wrapper:submit task on tencent::tianxuan_s1 for 2 circuits\n", + "INFO:tensorcircuit.cloud.wrapper:finished collecting count results of 2 tasks in 7.6044 seconds\n" + ] + }, { "data": { "text/plain": [ - "array([0.90996515])" + "array([0.82589585])" ] }, - "execution_count": 37, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -1375,19 +1307,35 @@ "# compute Z0Z1" ] }, + { + "cell_type": "markdown", + "id": "630b8791", + "metadata": {}, + "source": [ + "$\\langle Z_0Z_1\\rangle+0.5\\langle Z_1Z_2\\rangle$" + ] + }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 41, "id": "c405123f", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:tensorcircuit.cloud.wrapper:submit task on tencent::tianxuan_s1 for 1 circuits\n", + "INFO:tensorcircuit.cloud.wrapper:finished collecting count results of 1 tasks in 4.9699 seconds\n" + ] + }, { "data": { "text/plain": [ - "array(1.70569329)" + "array(1.54442738)" ] }, - "execution_count": 38, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -1409,17 +1357,17 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 42, "id": "5744293b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "1.5" + "array(1.5+0.j)" ] }, - "execution_count": 39, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -1435,29 +1383,42 @@ "id": "300cff3a", "metadata": {}, "source": [ - "The results with readout error mitigation disabled can become worse. Note how we cache the readout error calibriation within tc, so that REM is effcient to use" + "The results with readout error mitigation disabled can become worse. Note how we cache the readout error calibriation within tc, so that REM is effcient to use." ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 8, "id": "0e49467d", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:tensorcircuit.cloud.wrapper:submit task on tencent::tianxuan_s1 for 1 circuits\n", + "INFO:tensorcircuit.cloud.wrapper:finished collecting count results of 1 tasks in 3.6587 seconds\n" + ] + }, { "data": { "text/plain": [ - "array(1.25073242)" + "array(0.8828125)" ] }, - "execution_count": 40, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tc.cloud.wrapper.batch_expectation_ps(\n", - " c, pss=[[3, 3, 0, 0, 0], [0, 3, 3, 0, 0]], device=d, ws=[1, 0.5], with_rem=False\n", + " c,\n", + " pss=[[3, 3, 0, 0, 0], [0, 3, 3, 0, 0]],\n", + " device=d,\n", + " ws=[1, 0.5],\n", + " with_rem=False,\n", + " shots=1024,\n", ")" ] }, @@ -1471,52 +1432,10 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 9, "id": "718d7215", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "the contraction path is given as [(0, 1), (0, 1), (0, 1), (0, 1)]\n", - "----- WRITE: 7.20945336562895 --------\n", - "\n", - "the contraction path is given as [(0, 2), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1), (0, 1), (0, 1)]\n", - "----- WRITE: 7.20945336562895 --------\n", - "\n", - "the contraction path is given as [(0, 2), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n", - "the contraction path is given as [(0, 1), (0, 1)]\n", - "----- WRITE: 6.189824558880018 --------\n", - "\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -1528,11 +1447,11 @@ "data": { "text/plain": [ "" + "array([[-0.19370872],\n", + " [-0.11048019]], dtype=float32)>" ] }, - "execution_count": 41, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -1540,14 +1459,8 @@ "source": [ "import tensorflow as tf\n", "from functools import partial\n", - "import logging\n", "\n", "tc.set_backend(\"tensorflow\")\n", - "logger = logging.getLogger(\"tensorcircuit\")\n", - "logger.setLevel(logging.INFO)\n", - "ch = logging.StreamHandler()\n", - "ch.setLevel(logging.DEBUG)\n", - "logger.addHandler(ch)\n", "\n", "pss = []\n", "for i in range(5):\n", @@ -1568,37 +1481,47 @@ " return tc.cloud.wrapper.batch_expectation_ps(c, pss=pss, device=device)\n", "\n", "\n", - "qlayer = tc.KerasHardwareLayer(quantum_func, [2, 5])\n", + "qlayer = tc.KerasLayer(quantum_func, [2, 5])\n", "model = tf.keras.Sequential([qlayer, tf.keras.layers.Dense(1)])\n", "inputs = tf.stack([0.1 * tf.ones([5]), 0.2 * tf.ones([5])])\n", "model(inputs)" ] }, + { + "cell_type": "markdown", + "id": "f2b675fa", + "metadata": {}, + "source": [ + "``model`` is a model with quantum layer simulated using CPU/GPU and a classical layer on CPU/GPU while ``model1`` shares exactly the same architecture but is with quantum layer on real QPU while classical layer still live on CPU/GPU, namely, TC is powerful enough to handle these quantum-classical hybrid tasks with an interface familiar to any ML engineers." + ] + }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 10, "id": "0ec02dac", - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "submit task on tencent::tianxuan_s1 for 1 circuits\n", - "finished collecting count results of 1 tasks in 5.1344 seconds\n", - "submit task on tencent::tianxuan_s1 for 1 circuits\n", - "finished collecting count results of 1 tasks in 5.0256 seconds\n" + "INFO:tensorcircuit.cloud.wrapper:submit task on tencent::tianxuan_s1 for 1 circuits\n", + "INFO:tensorcircuit.cloud.wrapper:finished collecting count results of 1 tasks in 5.2411 seconds\n", + "INFO:tensorcircuit.cloud.wrapper:submit task on tencent::tianxuan_s1 for 1 circuits\n", + "INFO:tensorcircuit.cloud.wrapper:finished collecting count results of 1 tasks in 5.3121 seconds\n" ] }, { "data": { "text/plain": [ "" + "array([[-1.470755 ],\n", + " [-1.3294612]], dtype=float32)>" ] }, - "execution_count": 42, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -1609,17 +1532,66 @@ "model1(inputs)" ] }, + { + "cell_type": "code", + "execution_count": 11, + "id": "51620507", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " quantum_layer (QuantumLayer (2, 5) 10 \n", + " ) \n", + " \n", + " dense (Dense) (2, 1) 6 \n", + " \n", + "=================================================================\n", + "Total params: 16\n", + "Trainable params: 16\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "\n", + "\n", + "Model: \"sequential_1\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " hardware_layer (HardwareLay multiple 10 \n", + " er) \n", + " \n", + " dense_1 (Dense) multiple 6 \n", + " \n", + "=================================================================\n", + "Total params: 16\n", + "Trainable params: 16\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model.summary()\n", + "print(\"\\n\")\n", + "model1.summary()" + ] + }, { "cell_type": "markdown", "id": "3b5423ca", "metadata": {}, "source": [ - "we align the weights between the two models" + "we align the weights between the two models (numerical one vs hybrid one)" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 12, "id": "ab5ca8a5", "metadata": {}, "outputs": [ @@ -1627,21 +1599,21 @@ "name": "stderr", "output_type": "stream", "text": [ - "submit task on tencent::tianxuan_s1 for 1 circuits\n", - "finished collecting count results of 1 tasks in 4.121 seconds\n", - "submit task on tencent::tianxuan_s1 for 1 circuits\n", - "finished collecting count results of 1 tasks in 4.0726 seconds\n" + "INFO:tensorcircuit.cloud.wrapper:submit task on tencent::tianxuan_s1 for 1 circuits\n", + "INFO:tensorcircuit.cloud.wrapper:finished collecting count results of 1 tasks in 5.5113 seconds\n", + "INFO:tensorcircuit.cloud.wrapper:submit task on tencent::tianxuan_s1 for 1 circuits\n", + "INFO:tensorcircuit.cloud.wrapper:finished collecting count results of 1 tasks in 5.2209 seconds\n" ] }, { "data": { "text/plain": [ "" + "array([[-0.21918973],\n", + " [-0.1476661 ]], dtype=float32)>" ] }, - "execution_count": 43, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -1650,37 +1622,6 @@ "model1.set_weights(model.get_weights())\n", "model1(inputs)" ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "16cb1252", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"sequential_1\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " hardware_layer_1 (HardwareL multiple 10 \n", - " ayer) \n", - " \n", - " dense_1 (Dense) multiple 6 \n", - " \n", - "=================================================================\n", - "Total params: 16\n", - "Trainable params: 16\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" - ] - } - ], - "source": [ - "model1.summary()" - ] } ], "metadata": { From 15c494289d3fa8b4281b55cc535a733155d9f756 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 2 Jun 2023 14:47:55 +0800 Subject: [PATCH 475/725] add pulse control example --- examples/analog_evolution_jax.py | 42 ++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 examples/analog_evolution_jax.py diff --git a/examples/analog_evolution_jax.py b/examples/analog_evolution_jax.py new file mode 100644 index 00000000..f5e92ca0 --- /dev/null +++ b/examples/analog_evolution_jax.py @@ -0,0 +1,42 @@ +""" +Parameterized Hamiltonian (Pulse control/Analog simulation) with AD/JIT support using jax ode solver +""" + +import optax +from jax.experimental.ode import odeint +import tensorcircuit as tc + +K = tc.set_backend("jax") +tc.set_dtype("complex128") + +hx = tc.quantum.PauliStringSum2COO([[1]]) +hz = tc.quantum.PauliStringSum2COO([[3]]) + + +# psi = -i H psi +# we want to optimize the final z expectation over parameters params +# a single qubit example below + + +def final_z(b): + def f(y, t, b): + h = b[3] * K.sin(b[0] * t + b[1]) * hx + K.cos(b[2]) * hz + return -1.0j * K.sparse_dense_matmul(h, y) + + y0 = tc.array_to_tensor([1, 0]) + y0 = K.reshape(y0, [-1, 1]) + t = tc.array_to_tensor([0.0, 10.0], dtype=tc.rdtypestr) + yf = odeint(f, y0, t, b) + c = tc.Circuit(1, inputs=K.reshape(yf[-1], [-1])) + return K.real(c.expectation_ps(z=[0])) + + +vgf = K.jit(K.value_and_grad(final_z)) + + +opt = K.optimizer(optax.adam(0.1)) +b = K.implicit_randn([4]) +for _ in range(50): + v, gs = vgf(b) + b = opt.update(gs, b) + print(v, b) From fa6ff1b76eaeebec2bf9a2ccf9136741f2848981 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 2 Jun 2023 17:21:26 +0800 Subject: [PATCH 476/725] add pulse programming experimental support --- CHANGELOG.md | 2 + examples/analog_evolution_interface.py | 40 ++++++++++++ tensorcircuit/experimental.py | 87 +++++++++++++++++++++++++- tests/test_miscs.py | 30 +++++++++ 4 files changed, 158 insertions(+), 1 deletion(-) create mode 100644 examples/analog_evolution_interface.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 6a983e67..0318eb7a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,8 @@ - introduce two stage compiling for `batch_expectation_ps` to save some compiling overhead +- Add experimental support for ODE backend pulse level control simulation/analog quantum computing + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/examples/analog_evolution_interface.py b/examples/analog_evolution_interface.py new file mode 100644 index 00000000..9cc00a9b --- /dev/null +++ b/examples/analog_evolution_interface.py @@ -0,0 +1,40 @@ +""" +jax backend is required, experimental built-in interface for parameterized hamiltonian evolution +""" + +import optax +import tensorcircuit as tc +from tensorcircuit.experimental import evol_global, evol_local + +K = tc.set_backend("jax") + + +def h_fun(t, b): + return b * tc.gates.x().tensor + + +hy = tc.quantum.PauliStringSum2COO([[2, 0]]) + + +def h_fun2(t, b): + return b[2] * K.cos(b[0] * t + b[1]) * hy + + +@K.jit +@K.value_and_grad +def hybrid_evol(params): + c = tc.Circuit(2) + c.x([0, 1]) + c = evol_local(c, [1], h_fun, 1.0, params[0]) + c.cx(1, 0) + c.h(0) + c = evol_global(c, h_fun2, 1.0, params[1:]) + return K.real(c.expectation_ps(z=[0, 1])) + + +opt = K.optimizer(optax.adam(0.1)) +b = K.implicit_randn([4]) +for _ in range(50): + v, gs = hybrid_evol(b) + b = opt.update(gs, b) + print(v, b) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index b2de6451..263d8e14 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -7,9 +7,11 @@ import numpy as np -from .cons import backend, dtypestr +from .cons import backend, dtypestr, contractor, rdtypestr +from .gates import Gate, array_to_tensor Tensor = Any +Circuit = Any def adaptive_vmap( @@ -433,3 +435,86 @@ def _evol(t: Tensor) -> Tensor: return callback(psi_exact) return backend.stack([_evol(t) for t in tlist]) + + +def evol_local( + c: Circuit, + index: Sequence[int], + h_fun: Callable[..., Tensor], + t: float, + *args: Any, + **solver_kws: Any +) -> Circuit: + """ + ode evolution of time dependent Hamiltonian on circuit of given indices + [only jax backend support for now] + + :param c: _description_ + :type c: Circuit + :param index: _description_ + :type index: Sequence[int] + :param h_fun: h_fun should return a dense Hamiltonian matrix + with input arguments time and *args + :type h_fun: Callable[..., Tensor] + :param t: evolution time + :type t: float + :return: _description_ + :rtype: Circuit + """ + from jax.experimental.ode import odeint + + s = c.state() + n = c._nqubits + l = len(index) + + def f(y: Tensor, t: Tensor, *args: Any) -> Tensor: + y = backend.reshape2(y) + y = Gate(y) + h = -1.0j * h_fun(t, *args) + h = backend.reshape2(h) + h = Gate(h) + edges = [] + for i in range(n): + if i not in index: + edges.append(y[i]) + else: + j = index.index(i) + edges.append(h[j]) + h[j + l] ^ y[i] + y = contractor([y, h], output_edge_order=edges) + return backend.reshape(y.tensor, [-1]) + + t = array_to_tensor([0, t], dtype=rdtypestr) + s1 = odeint(f, s, t, *args, **solver_kws) + return type(c)(n, inputs=s1[-1]) + + +def evol_global( + c: Circuit, h_fun: Callable[..., Tensor], t: float, *args: Any, **solver_kws: Any +) -> Circuit: + """ + ode evolution of time dependent Hamiltonian on circuit of all qubits + [only jax backend support for now] + + :param c: _description_ + :type c: Circuit + :param h_fun: h_fun should return a **SPARSE** Hamiltonian matrix + with input arguments time and *args + :type h_fun: Callable[..., Tensor] + :param t: _description_ + :type t: float + :return: _description_ + :rtype: Circuit + """ + from jax.experimental.ode import odeint + + s = c.state() + n = c._nqubits + + def f(y: Tensor, t: Tensor, *args: Any) -> Tensor: + h = -1.0j * h_fun(t, *args) + return backend.sparse_dense_matmul(h, y) + + t = array_to_tensor([0, t], dtype=rdtypestr) + s1 = odeint(f, s, t, *args, **solver_kws) + return type(c)(n, inputs=s1[-1]) diff --git a/tests/test_miscs.py b/tests/test_miscs.py index 5a40d94e..b3e9eb8a 100644 --- a/tests/test_miscs.py +++ b/tests/test_miscs.py @@ -218,3 +218,33 @@ def fsum1(param1, param2): np.testing.assert_allclose(g1, g3, atol=1e-5) np.testing.assert_allclose(g2, g4, atol=1e-5) + + +def test_evol(jaxb): + def h_square(t, b): + return (tc.backend.sign(t - 1.0) + 1) / 2 * b * tc.gates.x().tensor + + c = tc.Circuit(3) + c.x(0) + c.cx(0, 1) + c.h(2) + c = experimental.evol_local( + c, [1], h_square, 2.0, tc.backend.convert_to_tensor(0.2) + ) + c.rx(1, theta=np.pi - 0.4) + np.testing.assert_allclose(c.expectation_ps(z=[1]), 1.0, atol=1e-5) + + ixi = tc.quantum.PauliStringSum2COO([[0, 1, 0]]) + + def h_square_sparse(t, b): + return (tc.backend.sign(t - 1.0) + 1) / 2 * b * ixi + + c = tc.Circuit(3) + c.x(0) + c.cx(0, 1) + c.h(2) + c = experimental.evol_global( + c, h_square_sparse, 2.0, tc.backend.convert_to_tensor(0.2) + ) + c.rx(1, theta=np.pi - 0.4) + np.testing.assert_allclose(c.expectation_ps(z=[1]), 1.0, atol=1e-5) From 03661220b1c6928e573159916b4f5588e3c4f031 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 5 Jun 2023 10:13:54 +0800 Subject: [PATCH 477/725] add pulse level diff t support --- CHANGELOG.md | 2 ++ examples/analog_evolution_mint.py | 36 +++++++++++++++++++++++++++++++ tensorcircuit/experimental.py | 12 ++++++----- 3 files changed, 45 insertions(+), 5 deletions(-) create mode 100644 examples/analog_evolution_mint.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 0318eb7a..8b43e428 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,8 @@ - Add experimental support for ODE backend pulse level control simulation/analog quantum computing +- make the pulse level control support differentiating the end time + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/examples/analog_evolution_mint.py b/examples/analog_evolution_mint.py new file mode 100644 index 00000000..0af4fc04 --- /dev/null +++ b/examples/analog_evolution_mint.py @@ -0,0 +1,36 @@ +""" +jax backend analog evolution targeting at minimizing evolution time +""" + +import optax +import tensorcircuit as tc +from tensorcircuit.experimental import evol_global + +K = tc.set_backend("jax") + +hx = tc.quantum.PauliStringSum2COO([[1]]) + + +def h_fun(t, b): + return K.sin(b) * hx + + +def fast_evol(t, b): + lbd = 0.08 + c = tc.Circuit(1) + c = evol_global(c, h_fun, t, b) + loss = K.real(c.expectation_ps(z=[0])) + return loss + lbd * t**2, loss + # l2 regularization to minimize t while target z=-1 + + +vgf = K.jit(K.value_and_grad(fast_evol, argnums=(0, 1), has_aux=True)) + +opt = K.optimizer(optax.adam(0.05)) +b, t = tc.array_to_tensor(0.5, 1.0, dtype=tc.rdtypestr) + +for i in range(500): + (v, loss), gs = vgf(b, t) + b, t = opt.update(gs, (b, t)) + if i % 20 == 0: + print(v, loss, b, t) diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 263d8e14..bd395fb0 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -8,7 +8,7 @@ import numpy as np from .cons import backend, dtypestr, contractor, rdtypestr -from .gates import Gate, array_to_tensor +from .gates import Gate Tensor = Any Circuit = Any @@ -484,8 +484,9 @@ def f(y: Tensor, t: Tensor, *args: Any) -> Tensor: y = contractor([y, h], output_edge_order=edges) return backend.reshape(y.tensor, [-1]) - t = array_to_tensor([0, t], dtype=rdtypestr) - s1 = odeint(f, s, t, *args, **solver_kws) + ts = backend.stack([0.0, t]) + ts = backend.cast(ts, dtype=rdtypestr) + s1 = odeint(f, s, ts, *args, **solver_kws) return type(c)(n, inputs=s1[-1]) @@ -515,6 +516,7 @@ def f(y: Tensor, t: Tensor, *args: Any) -> Tensor: h = -1.0j * h_fun(t, *args) return backend.sparse_dense_matmul(h, y) - t = array_to_tensor([0, t], dtype=rdtypestr) - s1 = odeint(f, s, t, *args, **solver_kws) + ts = backend.stack([0.0, t]) + ts = backend.cast(ts, dtype=rdtypestr) + s1 = odeint(f, s, ts, *args, **solver_kws) return type(c)(n, inputs=s1[-1]) From e8ca8cef7b7c2fa47eab73d760e7a39b095cfc89 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 6 Jun 2023 12:09:44 +0800 Subject: [PATCH 478/725] large scale rem test --- examples/rem_super_large_scale.py | 52 +++++++++++++++++++++++++++++++ tensorcircuit/mps_base.py | 10 +++++- 2 files changed, 61 insertions(+), 1 deletion(-) create mode 100644 examples/rem_super_large_scale.py diff --git a/examples/rem_super_large_scale.py b/examples/rem_super_large_scale.py new file mode 100644 index 00000000..5fb4a239 --- /dev/null +++ b/examples/rem_super_large_scale.py @@ -0,0 +1,52 @@ +""" +Demonstrate the failure of rem when qubit number is much larger than 1/p +""" + +from functools import partial +import numpy as np +import tensorcircuit as tc + + +def simulate_engine(p, ans): + fans = "" + for a in ans: + if p > np.random.uniform(): + if a == "0": + fans += "1" + else: + fans += "0" + else: + fans += a + return fans + + +def run(cs, shots, p=0.1): + # we assume only all 0 and all 1 results for simplicity + rds = [] + for c in cs: + if len(c.to_qir()) < 10: + ans = "0" * c._nqubits + else: + ans = "1" * c._nqubits + rd = {} + for _ in range(shots): + r = simulate_engine(p, ans) + rd[r] = rd.get(r, 0) + 1 + rds.append(rd) + return rds + + +if __name__ == "__main__": + for p in [0.1, 0.05, 0.02]: + print(p) + n = int(3 / p) + c = tc.Circuit(n) + c.x(range(n)) + runp = partial(run, p=p) + r = runp([c], 8192)[0] + mit = tc.results.rem.ReadoutMit(runp) + mit.cals_from_system(n) + rs = [] + for i in range(n): + rs.append([i, np.abs(mit.expectation(r, list(range(i))))]) + print(rs[i]) diff --git a/tensorcircuit/mps_base.py b/tensorcircuit/mps_base.py index 22bf1cca..ae05c7ad 100644 --- a/tensorcircuit/mps_base.py +++ b/tensorcircuit/mps_base.py @@ -6,7 +6,15 @@ from typing import Any, Optional, List, Sequence import numpy as np -from tensornetwork.linalg.node_linalg import conj + +try: + from tensornetwork.linalg.node_linalg import conj + + # google tn +except ModuleNotFoundError: + # tc tn + from tensornetwork.matrixproductstates.utils import conj + import tensornetwork as tn import tensornetwork.ncon_interface as ncon from tensornetwork.network_components import Node From 3149292238df4385d43497e0aa84fd39f5aec2fa Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Wed, 7 Jun 2023 10:32:42 +0800 Subject: [PATCH 479/725] qem code --- .../source/tutorials/benchmark_circuits.ipynb | 206 +++++++ docs/source/tutorials/error_mitigation.ipynb | 553 ++++++++++++++++++ tensorcircuit/results/qem/__init__.py | 18 + .../results/qem/benchmark_circuits.py | 93 +++ tensorcircuit/results/qem/qem_methods.py | 345 +++++++++++ tests/test_qem.py | 152 +++++ 6 files changed, 1367 insertions(+) create mode 100644 docs/source/tutorials/benchmark_circuits.ipynb create mode 100644 docs/source/tutorials/error_mitigation.ipynb create mode 100644 tensorcircuit/results/qem/__init__.py create mode 100644 tensorcircuit/results/qem/benchmark_circuits.py create mode 100644 tensorcircuit/results/qem/qem_methods.py create mode 100644 tests/test_qem.py diff --git a/docs/source/tutorials/benchmark_circuits.ipynb b/docs/source/tutorials/benchmark_circuits.ipynb new file mode 100644 index 00000000..7755ae3f --- /dev/null +++ b/docs/source/tutorials/benchmark_circuits.ipynb @@ -0,0 +1,206 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Benchmark Chips" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Benchmark Chips using mirror circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "from tensorcircuit.results import qem\n", + "from tensorcircuit.results.qem import benchmark_circuits\n", + "import random\n", + "import numpy as np\n", + "\n", + "from tensorcircuit.cloud import apis\n", + "from tensorcircuit.results import counts\n", + "from tensorcircuit.compiler.qiskit_compiler import qiskit_compile\n", + "from matplotlib import cm\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0, 1], [6, 2], [4, 0], [0, 4], [8, 4], [1, 5], [3, 7], [0, 3], [2, 0], [5, 1], [3, 0], [7, 3], [0, 2], [2, 6], [4, 8], [1, 0]]\n" + ] + } + ], + "source": [ + "d = apis.get_device(\"tianxuan_s1\")\n", + "lis = d.topology()\n", + "print(lis)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nq: [0, 1] depth: 1 success 4.1484000000000005\n", + "nq: [0, 1] depth: 2 success 3.7722999999999995\n", + "nq: [0, 1, 2] depth: 1 success 3.2711\n", + "nq: [0, 1, 2] depth: 2 success 3.2814\n", + "nq: [0, 1, 2, 3] depth: 1 success 3.1682000000000006\n", + "nq: [0, 1, 2, 3] depth: 2 success 2.5158\n", + "nq: [0, 1, 2, 3, 4] depth: 1 success 2.1039999999999996\n", + "nq: [0, 1, 2, 3, 4] depth: 2 success 1.4552999999999998\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_list = []\n", + "\n", + "\n", + "for nq in range(2,6):\n", + " qlis = list(range(nq))\n", + " graph = []\n", + " for i in range(len(lis)):\n", + " if lis[i][0] in qlis and lis[i][1] in qlis:\n", + " graph.append(lis[i])\n", + "\n", + "\n", + " G=nx.Graph()\n", + " G.add_edges_from(graph)\n", + " nx.draw(G,with_labels=True)\n", + "\n", + "\n", + " for depth in range(1,3):\n", + "\n", + " \n", + "\n", + " A = 0\n", + " for numc in range(5):\n", + "\n", + " c, ideal = benchmark_circuits.mirror_circuit(depth=depth, two_qubit_gate_prob=1, connectivity_graph=G,seed = random.randint(0,100)) # includes np.sqrt(X)^{\\dagger} gate,identity gate\n", + "\n", + " c1, info = qiskit_compile( \n", + " c,\n", + " compiled_options={\n", + " \"basis_gates\": ['h', 'rz', 'x', 'y', 'z', 'cz'],\n", + " \"optimization_level\": 2,\n", + " # \"coupling_map\": d.topology(), \n", + " },\n", + " )\n", + "\n", + "\n", + " t = apis.submit_task(circuit=c1,shots=10000,device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + " raw_count = t.results(blocked=True) # position_counts=logical_counts\n", + " # print(\"raw\",raw_count[list(ideal.keys())[0]]/10000)\n", + "\n", + " A+=raw_count[list(ideal.keys())[0]]/10000\n", + " print(\"nq:\",qlis, \"depth:\",depth, \"success\",A)\n", + " result_list.append(A)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "result_list1 = [i/5 for i in result_list]\n", + "result_list2 = np.reshape(result_list1,[4,2])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Depth')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax=plt.subplots()\n", + "Z=np.transpose(result_list2)\n", + "X=list(range(2,6))\n", + "Y=list(range(1,3))\n", + "p=ax.pcolor(X,Y, Z,vmin=Z.min(),vmax=Z.max(), cmap='rainbow')\n", + "cb=fig.colorbar(p, ax=ax)\n", + "plt.xlabel(\"Nqubit\")\n", + "plt.ylabel(\"Depth\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('tf')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "4d2770c334f3778740193ba4b3686745ae5c2e3ee10c8c0d673798cf1c2fcefe" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/tutorials/error_mitigation.ipynb b/docs/source/tutorials/error_mitigation.ipynb new file mode 100644 index 00000000..9f6b0d78 --- /dev/null +++ b/docs/source/tutorials/error_mitigation.ipynb @@ -0,0 +1,553 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## QEM APPLICATIONS" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "from tensorcircuit.results import qem\n", + "from tensorcircuit.results.qem import qem_methods, benchmark_circuits\n", + "from tensorcircuit.results.qem import zne_option,apply_zne,dd_option,apply_dd,apply_rc\n", + "\n", + "from tensorcircuit.cloud import apis\n", + "from tensorcircuit.results import counts\n", + "from tensorcircuit.results.readout_mitigation import ReadoutMit\n", + "from tensorcircuit.compiler.qiskit_compiler import qiskit_compile\n", + "\n", + "from functools import partial\n", + "import numpy as np\n", + "import networkx as nx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ZNE" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0, 1], [6, 2], [4, 0], [0, 4], [8, 4], [1, 5], [3, 7], [0, 3], [2, 0], [5, 1], [3, 0], [7, 3], [0, 2], [2, 6], [4, 8], [1, 0]]\n" + ] + } + ], + "source": [ + "d = apis.get_device(\"tianxuan_s1\")\n", + "lis = d.topology()\n", + "print(lis)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "mit = tc.results.rem.ReadoutMit(\"tianxuan_s1\")\n", + "mit.cals_from_system(qubits=9, shots=4096)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph = [(2,0),(3,7),(0,3),(1,5),(2,6)]\n", + "weight = [1]*len(graph)\n", + "params = np.array([[1,1],[1,1]])\n", + "optimization_level=2\n", + "\n", + "\n", + "c = benchmark_circuits.QAOA_circuit(graph, weight, params)\n", + "c.to_qiskit().draw(\"mpl\") " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "c1, info = qiskit_compile(\n", + " c,\n", + " compiled_options={\n", + " \"basis_gates\": ['h', 'rz', 'x', 'y', 'z', 'cz'],\n", + " \"optimization_level\": optimization_level,\n", + " # \"coupling_map\": d.topology(),\n", + " },\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ideal 0.9400000000000001\n", + "raw 0.37379999999999997\n", + "read 0.4909275773352902\n" + ] + } + ], + "source": [ + "t = apis.submit_task(circuit=c, shots=10000, device=\"simulator:aer\")\n", + "raw_count = t.results(blocked=True)\n", + "ideal = sum([-counts.expectation(raw_count, z=[graph[e][0], graph[e][1]])*weight[e] for e in range(len(graph))])\n", + "print(\"ideal\",ideal)\n", + "\n", + "t = apis.submit_task(circuit=c1,shots=10000,device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + "raw_count = t.results(blocked=True)\n", + "raw = sum([-counts.expectation(raw_count, z=[graph[e][0], graph[e][1]])*weight[e] for e in range(len(graph))])\n", + "print(\"raw\",raw)\n", + "read = sum([-mit.expectation(raw_count, z=[graph[e][0], graph[e][1]],**info)*weight[e] for e in range(len(graph))])\n", + "print(\"read\",read)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zne 0.6603988839789069\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "def execute(circuit):\n", + " t = apis.submit_task(circuit=circuit, shots=10000, device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + " count =t.results(blocked=True)\n", + " a = sum([-mit.expectation(count, z=[graph[e][0], graph[e][1]],**info)*weight[e] for e in range(len(graph))])\n", + " # a = sum([-counts.expectation(raw_count, z=[graph[e][0], graph[e][1]])*w[e] for e in range(len(graph))])\n", + " return a\n", + "\n", + "random_state = np.random.RandomState(0)\n", + "noise_scaling_function = partial(\n", + " zne_option.scaling.fold_gates_at_random,\n", + " fidelities = {\"single\": 1.0}, \n", + " random_state=random_state, \n", + ")\n", + "factory = zne_option.inference.PolyFactory (scale_factors=[1,3,5],order = 1)\n", + "# factory = zne_option.inference.ExpFactory(scale_factors=[1,1.5,2],asymptote=0.)\n", + "# factory = zne_option.inference.RichardsonFactory(scale_factors=[1,1.5,2])\n", + "# factory = zne_option.inference.AdaExpFactory(steps=5, asymptote=0.)\n", + "\n", + "result = apply_zne(\n", + " circuit=c1, executor = execute, factory=factory, scale_noise = noise_scaling_function,num_to_average=1\n", + ")\n", + "_ = factory.plot_fit()\n", + "print(\"zne\",result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DD" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[18, 17], [7, 17], [3, 4], [14, 4], [4, 3], [5, 4], [16, 17], [12, 13], [14, 13], [3, 13], [8, 9], [10, 0], [9, 8], [19, 9], [1, 0], [19, 18], [17, 18], [8, 18], [13, 14], [15, 5], [6, 5], [15, 14], [18, 19], [4, 5], [5, 6], [18, 8], [4, 14], [14, 15], [0, 1], [11, 1], [5, 15], [1, 2], [10, 11], [2, 1], [11, 10], [0, 10], [1, 11], [9, 19], [16, 6], [6, 7], [15, 16], [7, 6], [16, 15], [12, 2], [6, 16], [3, 2], [12, 11], [17, 7], [8, 7], [17, 16], [2, 3], [11, 12], [13, 3], [2, 12], [13, 12], [7, 8]]\n" + ] + } + ], + "source": [ + "d = apis.get_device(\"tianshu_s1\")\n", + "lis = d.topology()\n", + "print(lis)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c, ideal = benchmark_circuits.ghz_circuit(8)\n", + "c.to_qiskit().draw(\"mpl\") # logical circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'logical_physical_mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7}, 'positional_logical_mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7}}\n" + ] + } + ], + "source": [ + "\n", + "c1, info = qiskit_compile( \n", + " c,\n", + " compiled_options={\n", + " \"basis_gates\": ['h', 'rz', 'x', 'y', 'z', 'cz'],\n", + " \"optimization_level\": 2,\n", + " # \"coupling_map\": d.topology(), \n", + " },\n", + ")\n", + "\n", + "print(info)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ideal 1.0\n", + "raw 0.156\n" + ] + } + ], + "source": [ + "zpauli = [0,6] # logical\n", + "\n", + "t = apis.submit_task(circuit=c, shots=10000, device=\"simulator:aer\")\n", + "raw_count = t.results(blocked=True)\n", + "ideal = counts.expectation(raw_count, z=zpauli)\n", + "print(\"ideal\",ideal)\n", + "\n", + "\n", + "t = apis.submit_task(circuit=c1,shots=10000,device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + "raw_count = t.results(blocked=True) # position_counts=logical_counts\n", + "raw = counts.expectation(raw_count, z=zpauli)\n", + "print(\"raw\",raw)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mit 0.1734\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def execute(circuit):\n", + " t = apis.submit_task(circuit=circuit, shots=10000, device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + " count =t.results(blocked=True) # physical_counts\n", + "\n", + " n = len(info['logical_physical_mapping'])\n", + " physical_qubits = [info['logical_physical_mapping'][i] for i in range(n)]\n", + " count = counts.marginal_count(count,physical_qubits)\n", + " \n", + " # a = mit.expectation(count, z=zpauli,**info)\n", + " a = counts.expectation(count, z=zpauli)\n", + " return a\n", + "\n", + "\n", + "mitigated_result = apply_dd(\n", + " circuit=c1, \n", + " executor=execute, \n", + " rule = dd_option.rules.yy,\n", + " rule_args = {\"spacing\": -1},\n", + " full_output = True,\n", + " ignore_idle_qubit =True,\n", + " fulldd = False\n", + " )\n", + "\n", + "print(\"mit\",mitigated_result[0])\n", + "mitigated_result[1].to_qiskit().draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### RC" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = tc.Circuit(5)\n", + "c.x(0)\n", + "c.h(2)\n", + "c.cz(0,1)\n", + "c.cz(2,3)\n", + "c.y(1)\n", + "c.h(2)\n", + "c.cz(0,1)\n", + "c.cz(2,3)\n", + "c.h(4)\n", + "c.cz(3,4)\n", + "\n", + "c.to_qiskit().draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circuit = qem.rc_circuit(c)\n", + "circuit = qem.washcircuit(circuit,qlist=list(range(circuit.circuit_param[\"nqubits\"])))\n", + "circuit.to_qiskit().draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'logical_physical_mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}, 'positional_logical_mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c1, info = qiskit_compile( \n", + " c,\n", + " compiled_options={\n", + " \"basis_gates\": ['h', 'rz', 'x', 'y', 'z','cz'],\n", + " \"optimization_level\": 2,\n", + " # \"coupling_map\": d.topology(), \n", + " },\n", + ")\n", + "\n", + "print(info)\n", + "c1.to_qiskit().draw(\"mpl\") " + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ideal -1.0\n", + "raw -0.3894\n" + ] + } + ], + "source": [ + "zpauli = [1,2] # logical\n", + "\n", + "t = apis.submit_task(circuit=c, shots=10000, device=\"simulator:aer\")\n", + "raw_count = t.results(blocked=True)\n", + "ideal = counts.expectation(raw_count, z=zpauli)\n", + "print(\"ideal\",ideal)\n", + "\n", + "\n", + "t = apis.submit_task(circuit=c1,shots=10000,device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + "raw_count = t.results(blocked=True) # position_counts=logical_counts\n", + "raw = counts.expectation(raw_count, z=zpauli)\n", + "print(\"raw\",raw)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mit -0.39233333333333337\n", + "mit -0.4132\n" + ] + } + ], + "source": [ + "\n", + "def execute(circuit):\n", + " t = apis.submit_task(circuit=circuit, shots=10000, device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + " count =t.results(blocked=True) # physical_counts\n", + "\n", + " n = len(info['logical_physical_mapping'])\n", + " physical_qubits = [info['logical_physical_mapping'][i] for i in range(n)]\n", + " count = counts.marginal_count(count,physical_qubits)\n", + " \n", + " # a = mit.expectation(count, z=zpauli,**info)\n", + " a = counts.expectation(count, z=zpauli)\n", + " return a\n", + "\n", + "\n", + "mitigated_result = apply_rc(\n", + " circuit=c1, \n", + " executor=execute, \n", + " num_to_average=6,\n", + " simplify=True\n", + " )\n", + "\n", + "print(\"mit\",mitigated_result[0])\n", + "\n", + "\n", + "mitigated_result = apply_rc(\n", + " circuit=c1, \n", + " executor=execute, \n", + " num_to_average=6,\n", + " simplify=False\n", + " )\n", + "\n", + "print(\"mit\",mitigated_result[0])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('tf')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "4d2770c334f3778740193ba4b3686745ae5c2e3ee10c8c0d673798cf1c2fcefe" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tensorcircuit/results/qem/__init__.py b/tensorcircuit/results/qem/__init__.py new file mode 100644 index 00000000..83b4f592 --- /dev/null +++ b/tensorcircuit/results/qem/__init__.py @@ -0,0 +1,18 @@ +from . import qem_methods + +zne_option = qem_methods.zne_option +apply_zne = qem_methods.apply_zne + + +apply_dd = qem_methods.apply_dd +dd_option = qem_methods.dd_option + +apply_rc = qem_methods.apply_rc + +apply_gate = qem_methods.apply_gate +rc_circuit = qem_methods.rc_circuit +rc_candidates = qem_methods.rc_candidates + +use_qubits = qem_methods.use_qubits +washcircuit = qem_methods.washcircuit +add_dd = qem_methods.add_dd diff --git a/tensorcircuit/results/qem/benchmark_circuits.py b/tensorcircuit/results/qem/benchmark_circuits.py new file mode 100644 index 00000000..945b182b --- /dev/null +++ b/tensorcircuit/results/qem/benchmark_circuits.py @@ -0,0 +1,93 @@ +from mitiq.benchmarks import ( + generate_ghz_circuit, + generate_mirror_circuit, + generate_quantum_volume_circuit, + generate_rb_circuits, + generate_w_circuit, +) + +from mitiq.interface import ( + CircuitConversionError, + convert_to_mitiq, + convert_from_mitiq, +) + + +from ... import Circuit + + +def ghz_circuit(num_qubits): # type: ignore + cirq = generate_ghz_circuit(num_qubits) + ideal = {"0" * num_qubits: 0.5, "1" * num_qubits: 0.5} + qisc = convert_from_mitiq(cirq, "qiskit") + circuit = Circuit.from_qiskit(qisc, qisc.num_qubits) + return circuit, ideal + + +def w_circuit(num_qubits): # type: ignore + # Efficient quantum algorithms for GHZ and W states https://arxiv.org/abs/1807.05572 + # Werner-state with linear complexity {'1000': 0.25, '0100': 0.25, '0010': 0.25, '0001': 0.25} + cirq = generate_w_circuit(num_qubits) + + ideal = {} + for i in range(num_qubits): + bitstring = "0" * i + "1" + "0" * (num_qubits - i - 1) + ideal[bitstring] = 1 / num_qubits + + qisc = convert_from_mitiq(cirq, "qiskit") + circuit = Circuit.from_qiskit(qisc, qisc.num_qubits) + return circuit, ideal + + +def rb_circuit(num_qubits, depth): # type: ignore + # num_qubits limited to 1 or 2 + cirq = generate_rb_circuits(num_qubits, depth)[0] + ideal = {"0" * num_qubits: 1.0} + qisc = convert_from_mitiq(cirq, "qiskit") + circuit = Circuit.from_qiskit(qisc, qisc.num_qubits) + return circuit, ideal + + +def mirror_circuit( # type: ignore + depth, two_qubit_gate_prob, connectivity_graph, seed, two_qubit_gate_name="CNOT" +): + # Measuring the Capabilities of Quantum Computers https://arxiv.org/pdf/2008.11294.pdf + cirq, bitstring_list = generate_mirror_circuit( + nlayers=depth, + two_qubit_gate_prob=two_qubit_gate_prob, + connectivity_graph=connectivity_graph, + two_qubit_gate_name=two_qubit_gate_name, + seed=seed, + ) + ideal_bitstring = "".join(map(str, bitstring_list)) + ideal = {ideal_bitstring: 1.0} + qisc = convert_from_mitiq(cirq, "qiskit") + circuit = Circuit.from_qiskit(qisc, qisc.num_qubits) + return circuit, ideal + + +def QAOA_circuit(graph, weight, params): # type: ignore + nlayers = len(params) + + qlist = [] + for i in range(len(graph)): + for j in range(2): + qlist.append(graph[i][j]) + qlist = list(set(qlist)) + + nqubit = max(qlist) + 1 + + c = Circuit(nqubit) + for i in qlist: + c.h(i) # type: ignore + + for i in range(nlayers): + for e in range(len(graph)): + c.cnot(graph[e][0], graph[e][1]) # type: ignore + c.rz(graph[e][1], theta=params[i, 0] * weight[e]) # type: ignore + c.cnot(graph[e][0], graph[e][1]) # type: ignore + + for k in qlist: + c.rx(k, theta=params[i, 1] * 2) # type: ignore + + return c diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py new file mode 100644 index 00000000..98059cd9 --- /dev/null +++ b/tensorcircuit/results/qem/qem_methods.py @@ -0,0 +1,345 @@ +from mitiq import zne, ddd +from mitiq.zne.inference import Factory +from mitiq.zne.scaling import fold_gates_at_random +from typing import Any, Sequence, Union, Optional, Dict, Tuple, Callable +import numpy as np +from random import choice +from itertools import product +import cirq +from functools import partial +import collections +import functools +import operator + + +from ... import Circuit +from ... import backend, gates +from ...compiler import simple_compiler + + +zne_option = zne + + +def apply_zne( + circuit: Any, + executor: Callable[[Any], float], + factory: Optional[Factory], + scale_noise: Callable[[Any, float], Any] = fold_gates_at_random, + num_to_average: int = 1, + **kws: Any, +) -> float: + """Apply zero-noise extrapolation (ZNE) and return the mitigated results. + + :param circuit: The aim circuit. + :type circuit: Any + :param executor: A executor that executes a circuit and return results. + :type executor: Callable[[Any], float] + :param factory: Determines the extropolation method. + :type factory: Optional[Factory] + :param scale_noise: The scaling function for the aim circuit, defaults to fold_gates_at_random + :type scale_noise: Callable[[Any, float], Any], optional + :param num_to_average: Number of times expectation values are computed by + the executor, average each point, defaults to 1. + :type num_to_average: int, optional + :return: Mitigated average value by ZNE. + :rtype: float + """ + + def executortc(c): # type: ignore + c = Circuit.from_qiskit(c, c.num_qubits) + return executor(c) + + circuit = circuit.to_qiskit() + result = zne.execute_with_zne( + circuit=circuit, + executor=executortc, + factory=factory, + scale_noise=scale_noise, + num_to_average=num_to_average, + **kws, + ) + return result # type:ignore + + +def washcircuit(c: Any, qlist: list) -> Any: # type:ignore + """Discard DD sequence on idle qubits and Discard identity gate (no identity/idle gate on device now) filled in DD sequence. + + :param c: circuit + :type c: Any + :param qlist: qubit list to apply DD sequence + :type qlist: list + :return: new circuit + :rtype: Any + """ + qir = c.to_qir() + cnew = Circuit(c.circuit_param["nqubits"]) + for d in qir: + if d["index"][0] in qlist: + if_iden = np.sum(abs(np.array([[1, 0], [0, 1]]) - d["gate"].get_tensor())) + if if_iden > 1e-4: + if "parameters" not in d: + cnew.apply_general_gate_delayed(d["gatef"], d["name"])( + cnew, *d["index"] + ) + else: + cnew.apply_general_variable_gate_delayed(d["gatef"], d["name"])( + cnew, *d["index"], **d["parameters"] + ) + return cnew + + +def use_qubits(c: Any) -> list: # type:ignore + """Create a qubit list that includes all qubits having gate manipulation. + + :param c: a circuit + :type c: Any + :return: qubit list + :rtype: list + """ + qir = c.to_qir() + qlist = [] + for d in qir: + for i in range(len(d["index"])): + if d["index"][i] not in qlist: + qlist.append(d["index"][i]) + return qlist + + +def add_dd(c: Any, rule: Callable[[int], Any]) -> Any: + """Add DD sequence to A circuit + + :param c: circuit + :type c: Any + :param rule: The rule to conduct the DD sequence + :type rule: Callable[[int], Any] + :return: new circuit + :rtype: Any + """ + nqubit = c.circuit_param["nqubits"] + input_circuit = c.to_qiskit() + circuit_dd = dd_option.insert_ddd_sequences(input_circuit, rule=rule) + circuit_dd = Circuit.from_qiskit(circuit_dd, nqubit) + return circuit_dd + + +dd_option = ddd + + +def apply_dd( + circuit: Any, + executor: Callable[[Any], float], + rule: Union[Callable[[int], Any], list], # type:ignore + rule_args: Dict[str, Any] = {}, + num_trials: int = 1, + full_output: bool = False, + ignore_idle_qubit: bool = True, + fulldd: bool = False, + iscount: bool = False, +) -> Union[float, Tuple[float, Dict[str, Any]]]: + """Apply dynamic decoupling (DD) and return the mitigated results. + + + :param circuit: The aim circuit. + :type circuit: Any + :param executor: A executor that executes a circuit and return results. + :type executor: Callable[[Any], float] + :param rule: The rule to construct DD sequence, can use default rule "dd_option.rules.xx" + or custom rule "['X','X']" + :type rule: Union[Callable[[int], Any], list] + :param rule_args:An optional dictionary of keyword arguments for ``rule``, defaults to {}. Can set {"spacing": -1},{"spacing": 3} + :type rule_args: Dict[str, Any], optional + :param num_trials: The number of independent experiments to average over, defaults to 1 + :type num_trials: int, optional + :param full_output: If ``False`` only the mitigated expectation value is + returned. If ``True`` a dictionary containing all DD data is + returned too, defaults to False + :type full_output: bool, optional + :param ig_idle_qubit: ignore the DD sequences that added to unused qubits, defaults to True + :type ig_idle_qubit: bool, optional + :param fulldd: dd sequence full fill the idle circuits, defaults to False + :type fulldd: bool, optional + :param iscount: whether the output is bit string, defaults to False + :type iscount: bool, optional + :return: mitigated expectation value or mitigated expectation value and DD circuit information + :rtype: Union[float, Tuple[float, Dict[str, Any]]] + """ + + def dd_rule(slack_length: int, spacing: int = -1): # type:ignore + """Set DD rule. + + :param slack_length: Length of idle window to fill. Automatically calculated for a circuit. + :type slack_length: int + :param spacing: How many identity spacing gates to apply between dynamical + decoupling gates, defaults to -1 + :type spacing: int, optional + """ + dd_sequence = dd_option.rules.general_rule( + slack_length=slack_length, + spacing=spacing, + gates=gates, + ) + return dd_sequence + + if isinstance(rule, list): + gates = [] + for i in rule: + gates.append(getattr(cirq, i)) + rule = dd_rule + + if ignore_idle_qubit is True: + qlist = use_qubits(circuit) + else: + qlist = list(range(circuit.circuit_param["nqubits"])) + + rule_partial = partial( + rule, **rule_args + ) # rule_args influence the finall DD sequence + c2 = circuit + c3 = add_dd(c2, rule_partial) + c3 = washcircuit(c3, qlist) + if fulldd is True: + while c2.to_openqasm() != c3.to_openqasm(): + c2 = c3 + c3 = add_dd(c2, rule_partial) + c3 = washcircuit(c3, qlist) + + exp = [] + for i in range(num_trials): + exp.append(executor(c3)) + + if iscount is True: + sumcount = dict( + functools.reduce(operator.add, map(collections.Counter, exp)) # type:ignore + ) # type:ignore + result = {k: sumcount[k] / num_trials for k in sumcount.keys()} + else: + result = np.mean(exp) # type:ignore + + if full_output is True: + result = [result, c3] # type:ignore + + # def executortc(c): + # c = Circuit.from_qiskit(c, c.num_qubits) + # c = washcircuit(c,qlist) + # return executor(c) + # circuit = circuit.to_qiskit() + # result = ddd.execute_with_ddd( + # circuit=circuit, + # executor=executortc, + # rule=rule, + # rule_args=rule_args, + # num_trials=num_trials, + # full_output=full_output, + # ) + + return result # type:ignore + + +def rc_candidates(gate): # type:ignore + pauli = [m.tensor for m in gates.pauli_gates] + if isinstance(gate, gates.Gate): + gate = gate.tensor + gatem = backend.reshapem(gate) + r = [] + for combo in product(*[range(4) for _ in range(4)]): + i = ( + np.kron(pauli[combo[0]], pauli[combo[1]]) + @ gatem + @ np.kron(pauli[combo[2]], pauli[combo[3]]) + ) + if np.allclose(i, gatem, atol=1e-4): + r.append(combo) + elif np.allclose(i, -gatem, atol=1e-4): + r.append(combo) + return r + + +def apply_gate(c, i, j): # type:ignore + if i == 0: + c.i(j) + elif i == 1: + c.x(j) + elif i == 2: + c.y(j) + elif i == 3: + c.z(j) + return c + + +def rc_circuit(c): # type:ignore + qir = c.to_qir() + cnew = Circuit(c.circuit_param["nqubits"]) + for d in qir: + if len(d["index"]) == 2: + rc_list = choice(rc_candidates(d["gate"])) + + cnew = apply_gate(cnew, rc_list[0], d["index"][0]) + cnew = apply_gate(cnew, rc_list[1], d["index"][1]) + if "parameters" not in d: + cnew.apply_general_gate_delayed(d["gatef"], d["name"])( + cnew, *d["index"] + ) + else: + cnew.apply_general_variable_gate_delayed(d["gatef"], d["name"])( + cnew, *d["index"], **d["parameters"] + ) + cnew = apply_gate(cnew, rc_list[2], d["index"][0]) + cnew = apply_gate(cnew, rc_list[3], d["index"][1]) + else: + if "parameters" not in d: + cnew.apply_general_gate_delayed(d["gatef"], d["name"])( + cnew, *d["index"] + ) + else: + cnew.apply_general_variable_gate_delayed(d["gatef"], d["name"])( + cnew, *d["index"], **d["parameters"] + ) + return cnew + + +def apply_rc( + circuit: Any, + executor: Callable[[Any], float], + num_to_average: int = 1, + simplify: bool = True, + iscount: bool = False, + **kws: Any, +) -> float: + """Apply Randomized Compiling or Pauli twirling on two-qubit gates. + + :param circuit: Input circuit + :type circuit: Any + :param executor: A executor that executes a circuit and return results. + :type executor: Callable[[Any], float] + :param num_to_average: Number of circuits for RC, defaults to 1 + :type num_to_average: int, optional + :param simplify: Whether simplify the circuits by merging single qubit gates, defaults to True + :type simplify: bool, optional + :param iscount: whether the output is bit string, defaults to False + :type iscount: bool, optional + :return: Mitigated results by RC + :rtype: float + """ + exp = [] + circuit_list = [] + for _ in range(num_to_average): + circuit1 = rc_circuit(circuit) + + if simplify is True: + circuit1 = washcircuit( + circuit1, qlist=list(range(circuit1.circuit_param["nqubits"])) + ) + circuit1 = simple_compiler.merge(circuit1) + + exp.append(executor(circuit1)) + circuit_list.append(circuit1) + + if iscount is True: + sumcount = dict( + functools.reduce(operator.add, map(collections.Counter, exp)) # type:ignore + ) # type:ignore + result = {k: sumcount[k] / num_to_average for k in sumcount.keys()} + else: + result = np.mean(exp) # type:ignore + + return result, circuit_list # type:ignore diff --git a/tests/test_qem.py b/tests/test_qem.py new file mode 100644 index 00000000..c0d5a846 --- /dev/null +++ b/tests/test_qem.py @@ -0,0 +1,152 @@ +import pytest +from pytest_lazyfixture import lazy_fixture as lf +import numpy as np +from functools import partial +import networkx as nx + +import tensorcircuit as tc +from tensorcircuit.noisemodel import NoiseConf +from tensorcircuit.results import qem +from tensorcircuit.results.qem import ( + zne_option, + apply_zne, + dd_option, + apply_dd, + apply_rc, +) +from tensorcircuit.results.qem import benchmark_circuits + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_benchmark_circuits(backend): + # QAOA + graph = [(2, 0), (0, 3), (1, 2)] + weight = [1] * len(graph) + params = np.array([[1, 1]]) + + _ = benchmark_circuits.QAOA_circuit(graph, weight, params) + + # mirror circuit + # return circuit and ideal counts {"01000":1} + _, _ = benchmark_circuits.mirror_circuit( + depth=5, two_qubit_gate_prob=1, connectivity_graph=nx.complete_graph(3), seed=20 + ) + + # GHZ circuit + _ = benchmark_circuits.generate_ghz_circuit(10) + + # Werner-state with linear complexity + # {'1000': 0.25, '0100': 0.25, '0010': 0.25, '0001': 0.25} + _ = benchmark_circuits.generate_w_circuit(5) + + # RB cirucit + _ = benchmark_circuits.generate_rb_circuits(2, 7)[0] + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_zne(backend): + c = tc.Circuit(2) + for _ in range(3): + c.rx(range(2), theta=0.4) + + error1 = tc.channels.generaldepolarizingchannel(0.01, 1) + noise_conf = NoiseConf() + noise_conf.add_noise("rx", error1) + + def execute(circuit): + value = circuit.expectation_ps(z=[0], noise_conf=noise_conf, nmc=10000) + return value + + random_state = np.random.RandomState(0) + noise_scaling_function = partial( + zne_option.scaling.fold_gates_at_random, + # fidelities = {"single": 1.0}, + random_state=random_state, + ) + factory = zne_option.inference.PolyFactory(scale_factors=[1, 3, 5], order=1) + # factory = zne_option.inference.ExpFactory(scale_factors=[1,1.5,2],asymptote=0.) + # factory = zne_option.inference.RichardsonFactory(scale_factors=[1,1.5,2]) + # factory = zne_option.inference.AdaExpFactory(steps=5, asymptote=0.) + + result = apply_zne( + circuit=c, + executor=execute, + factory=factory, + scale_noise=noise_scaling_function, + num_to_average=1, + ) + + ideal_value = c.expectation_ps(z=[0]) + mit_value = result + + np.testing.assert_allclose(ideal_value, mit_value, atol=4e-2) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_dd(backend): + c = tc.Circuit(2) + for _ in range(3): + c.rx(range(2), theta=0.4) + + def execute(circuit): + value = circuit.expectation_ps(z=[0]) + return value + + def execute2(circuit): + key = tc.backend.get_random_state(42) + count = circuit.sample( + batch=1000, allow_state=True, format_="count_dict_bin", random_generator=key + ) + return count + + _ = apply_dd( + circuit=c, + executor=execute, + rule=["X", "X"], + rule_args={"spacing": -1}, + full_output=True, + ignore_idle_qubit=True, + fulldd=False, + ) + + _ = apply_dd( + circuit=c, + executor=execute2, + rule=dd_option.rules.xyxy, + rule_args={"spacing": -1}, + full_output=True, + ignore_idle_qubit=True, + fulldd=True, + iscount=True, + ) + + # washcircuit based on use_qubits and washout iden gates + _ = qem.washcircuit(c, qlist=list(range(c.circuit_param["nqubits"]))) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_rc(backend): + c = tc.Circuit(2) + for _ in range(3): + c.rx(range(2), theta=0.4) + c.cnot(0, 1) + + def execute(circuit): + value = circuit.expectation_ps(z=[0]) + return value + + def execute2(circuit): + key = tc.backend.get_random_state(42) + count = circuit.sample( + batch=1000, allow_state=True, format_="count_dict_bin", random_generator=key + ) + return count + + _ = apply_rc(circuit=c, executor=execute, num_to_average=6, simplify=False) + + _ = apply_rc( + circuit=c, executor=execute2, num_to_average=6, simplify=True, iscount=True + ) + + # generate a circuit with rc + _ = qem.rc_circuit(c) From b19f996b001ab7ecb3fa307533c7a842df6f2d76 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 7 Jun 2023 15:26:41 +0800 Subject: [PATCH 480/725] add qpu tutorial on docs --- docs/source/tutorial.rst | 6 +++++- examples/rem_super_large_scale.py | 4 +++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index 2596f072..e1ba6e21 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -20,4 +20,8 @@ Jupyter Tutorials tutorials/vqex_mbl.ipynb tutorials/dqas.ipynb tutorials/barren_plateaus.ipynb - tutorials/qaoa_portfolio_optimization.ipynb \ No newline at end of file + tutorials/qaoa_portfolio_optimization.ipynb + + Tutorials demosntrating QPU access: + + tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file diff --git a/examples/rem_super_large_scale.py b/examples/rem_super_large_scale.py index 5fb4a239..8ee75f31 100644 --- a/examples/rem_super_large_scale.py +++ b/examples/rem_super_large_scale.py @@ -24,7 +24,7 @@ def run(cs, shots, p=0.1): # we assume only all 0 and all 1 results for simplicity rds = [] for c in cs: - if len(c.to_qir()) < 10: + if len(c.to_qir()) < 2: ans = "0" * c._nqubits else: ans = "1" * c._nqubits @@ -46,6 +46,8 @@ def run(cs, shots, p=0.1): r = runp([c], 8192)[0] mit = tc.results.rem.ReadoutMit(runp) mit.cals_from_system(n) + for i in range(n): + print(i, "\n" ,mit.single_qubit_cals[i]) rs = [] for i in range(n): rs.append([i, np.abs(mit.expectation(r, list(range(i))))]) From 2335eeadb99f74f657d015d7ccb2b50b46f3e689 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 7 Jun 2023 15:49:51 +0800 Subject: [PATCH 481/725] update doc toc --- docs/source/tutorial.rst | 3 --- examples/rem_super_large_scale.py | 2 +- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index e1ba6e21..c7bae543 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -21,7 +21,4 @@ Jupyter Tutorials tutorials/dqas.ipynb tutorials/barren_plateaus.ipynb tutorials/qaoa_portfolio_optimization.ipynb - - Tutorials demosntrating QPU access: - tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file diff --git a/examples/rem_super_large_scale.py b/examples/rem_super_large_scale.py index 8ee75f31..a10e7290 100644 --- a/examples/rem_super_large_scale.py +++ b/examples/rem_super_large_scale.py @@ -47,7 +47,7 @@ def run(cs, shots, p=0.1): mit = tc.results.rem.ReadoutMit(runp) mit.cals_from_system(n) for i in range(n): - print(i, "\n" ,mit.single_qubit_cals[i]) + print(i, "\n", mit.single_qubit_cals[i]) rs = [] for i in range(n): rs.append([i, np.abs(mit.expectation(r, list(range(i))))]) From 89c44186b61f7a488d7ee6e9cc7d433242dd8a67 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Wed, 7 Jun 2023 17:17:15 +0800 Subject: [PATCH 482/725] revise qem code --- .../source/tutorials/benchmark_circuits.ipynb | 12 +-- docs/source/tutorials/error_mitigation.ipynb | 22 ++--- tensorcircuit/results/qem/__init__.py | 12 +-- .../results/qem/benchmark_circuits.py | 31 ++++--- tensorcircuit/results/qem/qem_methods.py | 93 +++++++++++-------- tests/test_qem.py | 6 +- 6 files changed, 97 insertions(+), 79 deletions(-) diff --git a/docs/source/tutorials/benchmark_circuits.ipynb b/docs/source/tutorials/benchmark_circuits.ipynb index 7755ae3f..e07bf9ca 100644 --- a/docs/source/tutorials/benchmark_circuits.ipynb +++ b/docs/source/tutorials/benchmark_circuits.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Benchmark Chips using mirror circuit" + "### Benchmark chips using mirror circuit" ] }, { @@ -49,8 +49,8 @@ ], "source": [ "d = apis.get_device(\"tianxuan_s1\")\n", - "lis = d.topology()\n", - "print(lis)" + "couple_list = d.topology()\n", + "print(couple_list)" ] }, { @@ -90,9 +90,9 @@ "for nq in range(2,6):\n", " qlis = list(range(nq))\n", " graph = []\n", - " for i in range(len(lis)):\n", - " if lis[i][0] in qlis and lis[i][1] in qlis:\n", - " graph.append(lis[i])\n", + " for i in range(len(couple_list)):\n", + " if couple_list[i][0] in qlis and couple_list[i][1] in qlis:\n", + " graph.append(couple_list[i])\n", "\n", "\n", " G=nx.Graph()\n", diff --git a/docs/source/tutorials/error_mitigation.ipynb b/docs/source/tutorials/error_mitigation.ipynb index 9f6b0d78..a241032d 100644 --- a/docs/source/tutorials/error_mitigation.ipynb +++ b/docs/source/tutorials/error_mitigation.ipynb @@ -4,12 +4,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## QEM APPLICATIONS" + "## QEM Applications" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -50,23 +50,23 @@ ], "source": [ "d = apis.get_device(\"tianxuan_s1\")\n", - "lis = d.topology()\n", - "print(lis)" + "couple_list = d.topology()\n", + "print(couple_list)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "mit = tc.results.rem.ReadoutMit(\"tianxuan_s1\")\n", + "mit = tc.results.rem.ReadoutMit(\"tianxuan_s1?o=0\") # set ?o=0 for readout mitigation initialization \n", "mit.cals_from_system(qubits=9, shots=4096)" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -76,7 +76,7 @@ "
" ] }, - "execution_count": 30, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -209,8 +209,8 @@ ], "source": [ "d = apis.get_device(\"tianshu_s1\")\n", - "lis = d.topology()\n", - "print(lis)" + "couple_list = d.topology()\n", + "print(couple_list)" ] }, { diff --git a/tensorcircuit/results/qem/__init__.py b/tensorcircuit/results/qem/__init__.py index 83b4f592..541f9c8d 100644 --- a/tensorcircuit/results/qem/__init__.py +++ b/tensorcircuit/results/qem/__init__.py @@ -1,18 +1,14 @@ from . import qem_methods -zne_option = qem_methods.zne_option apply_zne = qem_methods.apply_zne - +zne_option = qem_methods.zne_option apply_dd = qem_methods.apply_dd dd_option = qem_methods.dd_option +used_qubits = qem_methods.used_qubits +prune_ddcircuit = qem_methods.prune_ddcircuit +add_dd = qem_methods.add_dd apply_rc = qem_methods.apply_rc - -apply_gate = qem_methods.apply_gate rc_circuit = qem_methods.rc_circuit rc_candidates = qem_methods.rc_candidates - -use_qubits = qem_methods.use_qubits -washcircuit = qem_methods.washcircuit -add_dd = qem_methods.add_dd diff --git a/tensorcircuit/results/qem/benchmark_circuits.py b/tensorcircuit/results/qem/benchmark_circuits.py index 945b182b..2ed1dc08 100644 --- a/tensorcircuit/results/qem/benchmark_circuits.py +++ b/tensorcircuit/results/qem/benchmark_circuits.py @@ -1,22 +1,25 @@ +""" +circuits for quantum chip benchmark +""" + +from typing import Any, List, Dict, Tuple + from mitiq.benchmarks import ( generate_ghz_circuit, generate_mirror_circuit, - generate_quantum_volume_circuit, generate_rb_circuits, generate_w_circuit, ) - from mitiq.interface import ( - CircuitConversionError, - convert_to_mitiq, convert_from_mitiq, ) +import networkx as nx from ... import Circuit -def ghz_circuit(num_qubits): # type: ignore +def ghz_circuit(num_qubits: int) -> Tuple[Any, Dict[str, float]]: cirq = generate_ghz_circuit(num_qubits) ideal = {"0" * num_qubits: 0.5, "1" * num_qubits: 0.5} qisc = convert_from_mitiq(cirq, "qiskit") @@ -24,7 +27,7 @@ def ghz_circuit(num_qubits): # type: ignore return circuit, ideal -def w_circuit(num_qubits): # type: ignore +def w_circuit(num_qubits: int) -> Tuple[Any, Dict[str, float]]: # Efficient quantum algorithms for GHZ and W states https://arxiv.org/abs/1807.05572 # Werner-state with linear complexity {'1000': 0.25, '0100': 0.25, '0010': 0.25, '0001': 0.25} cirq = generate_w_circuit(num_qubits) @@ -39,7 +42,7 @@ def w_circuit(num_qubits): # type: ignore return circuit, ideal -def rb_circuit(num_qubits, depth): # type: ignore +def rb_circuit(num_qubits: int, depth: int) -> Tuple[Any, Dict[str, float]]: # num_qubits limited to 1 or 2 cirq = generate_rb_circuits(num_qubits, depth)[0] ideal = {"0" * num_qubits: 1.0} @@ -48,9 +51,13 @@ def rb_circuit(num_qubits, depth): # type: ignore return circuit, ideal -def mirror_circuit( # type: ignore - depth, two_qubit_gate_prob, connectivity_graph, seed, two_qubit_gate_name="CNOT" -): +def mirror_circuit( + depth: int, + two_qubit_gate_prob: float, + connectivity_graph: nx.Graph, + seed: int, + two_qubit_gate_name: str = "CNOT", +) -> Tuple[Any, Dict[str, float]]: # Measuring the Capabilities of Quantum Computers https://arxiv.org/pdf/2008.11294.pdf cirq, bitstring_list = generate_mirror_circuit( nlayers=depth, @@ -66,7 +73,9 @@ def mirror_circuit( # type: ignore return circuit, ideal -def QAOA_circuit(graph, weight, params): # type: ignore +def QAOA_circuit( + graph: List[Tuple[int]], weight: List[float], params: List[float] +) -> Any: nlayers = len(params) qlist = [] diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py index 98059cd9..1d9a7a8d 100644 --- a/tensorcircuit/results/qem/qem_methods.py +++ b/tensorcircuit/results/qem/qem_methods.py @@ -1,39 +1,44 @@ -from mitiq import zne, ddd -from mitiq.zne.inference import Factory -from mitiq.zne.scaling import fold_gates_at_random -from typing import Any, Sequence, Union, Optional, Dict, Tuple, Callable -import numpy as np -from random import choice +""" +quantum error mitigation functionalities +""" + +from typing import Any, List, Union, Optional, Dict, Tuple, Callable, Sequence from itertools import product -import cirq +import functools from functools import partial import collections -import functools import operator +from random import choice +import numpy as np +from mitiq import zne, ddd +from mitiq.zne.inference import Factory +from mitiq.zne.scaling import fold_gates_at_random +import cirq from ... import Circuit from ... import backend, gates from ...compiler import simple_compiler +Gate = gates.Gate zne_option = zne def apply_zne( circuit: Any, - executor: Callable[[Any], float], + executor: Callable[[Union[Any, Sequence[Any]]], Any], factory: Optional[Factory], scale_noise: Callable[[Any, float], Any] = fold_gates_at_random, num_to_average: int = 1, **kws: Any, -) -> float: +) -> Any: """Apply zero-noise extrapolation (ZNE) and return the mitigated results. :param circuit: The aim circuit. :type circuit: Any - :param executor: A executor that executes a circuit and return results. - :type executor: Callable[[Any], float] + :param executor: A executor that executes a single circuit or a batch of circuits and return results. + :type executor: Callable[[Union[Any, Sequence[Any]]], Any] :param factory: Determines the extropolation method. :type factory: Optional[Factory] :param scale_noise: The scaling function for the aim circuit, defaults to fold_gates_at_random @@ -58,11 +63,12 @@ def executortc(c): # type: ignore num_to_average=num_to_average, **kws, ) - return result # type:ignore + return result -def washcircuit(c: Any, qlist: list) -> Any: # type:ignore - """Discard DD sequence on idle qubits and Discard identity gate (no identity/idle gate on device now) filled in DD sequence. +def prune_ddcircuit(c: Any, qlist: List[int]) -> Any: + """Discard DD sequence on idle qubits and Discard identity gate + (no identity/idle gate on device now) filled in DD sequence. :param c: circuit :type c: Any @@ -88,13 +94,13 @@ def washcircuit(c: Any, qlist: list) -> Any: # type:ignore return cnew -def use_qubits(c: Any) -> list: # type:ignore +def used_qubits(c: Any) -> List[int]: """Create a qubit list that includes all qubits having gate manipulation. :param c: a circuit :type c: Any :return: qubit list - :rtype: list + :rtype: List """ qir = c.to_qir() qlist = [] @@ -124,29 +130,33 @@ def add_dd(c: Any, rule: Callable[[int], Any]) -> Any: dd_option = ddd +# pylint: disable=dangerous-default-value + def apply_dd( circuit: Any, - executor: Callable[[Any], float], - rule: Union[Callable[[int], Any], list], # type:ignore + executor: Callable[[Any], Any], + rule: Union[Callable[[int], Any], List[str]], rule_args: Dict[str, Any] = {}, num_trials: int = 1, full_output: bool = False, ignore_idle_qubit: bool = True, fulldd: bool = False, iscount: bool = False, -) -> Union[float, Tuple[float, Dict[str, Any]]]: +) -> Union[ + float, Tuple[float, List[Any]], Dict[str, float], Tuple[Dict[str, float], List[Any]] +]: """Apply dynamic decoupling (DD) and return the mitigated results. :param circuit: The aim circuit. :type circuit: Any :param executor: A executor that executes a circuit and return results. - :type executor: Callable[[Any], float] + :type executor: Callable[[Any], Any] :param rule: The rule to construct DD sequence, can use default rule "dd_option.rules.xx" or custom rule "['X','X']" - :type rule: Union[Callable[[int], Any], list] - :param rule_args:An optional dictionary of keyword arguments for ``rule``, defaults to {}. Can set {"spacing": -1},{"spacing": 3} + :type rule: Union[Callable[[int], Any], List[str]] + :param rule_args:An optional dictionary of keyword arguments for ``rule``, defaults to {}. :type rule_args: Dict[str, Any], optional :param num_trials: The number of independent experiments to average over, defaults to 1 :type num_trials: int, optional @@ -164,7 +174,7 @@ def apply_dd( :rtype: Union[float, Tuple[float, Dict[str, Any]]] """ - def dd_rule(slack_length: int, spacing: int = -1): # type:ignore + def dd_rule(slack_length: int, spacing: int = -1) -> Any: """Set DD rule. :param slack_length: Length of idle window to fill. Automatically calculated for a circuit. @@ -187,7 +197,7 @@ def dd_rule(slack_length: int, spacing: int = -1): # type:ignore rule = dd_rule if ignore_idle_qubit is True: - qlist = use_qubits(circuit) + qlist = used_qubits(circuit) else: qlist = list(range(circuit.circuit_param["nqubits"])) @@ -196,15 +206,15 @@ def dd_rule(slack_length: int, spacing: int = -1): # type:ignore ) # rule_args influence the finall DD sequence c2 = circuit c3 = add_dd(c2, rule_partial) - c3 = washcircuit(c3, qlist) + c3 = prune_ddcircuit(c3, qlist) if fulldd is True: while c2.to_openqasm() != c3.to_openqasm(): c2 = c3 c3 = add_dd(c2, rule_partial) - c3 = washcircuit(c3, qlist) + c3 = prune_ddcircuit(c3, qlist) exp = [] - for i in range(num_trials): + for i in range(num_trials): # type: ignore exp.append(executor(c3)) if iscount is True: @@ -220,7 +230,7 @@ def dd_rule(slack_length: int, spacing: int = -1): # type:ignore # def executortc(c): # c = Circuit.from_qiskit(c, c.num_qubits) - # c = washcircuit(c,qlist) + # c = prune_ddcircuit(c,qlist) # return executor(c) # circuit = circuit.to_qiskit() # result = ddd.execute_with_ddd( @@ -235,7 +245,7 @@ def dd_rule(slack_length: int, spacing: int = -1): # type:ignore return result # type:ignore -def rc_candidates(gate): # type:ignore +def rc_candidates(gate: Gate) -> List[Any]: pauli = [m.tensor for m in gates.pauli_gates] if isinstance(gate, gates.Gate): gate = gate.tensor @@ -254,7 +264,7 @@ def rc_candidates(gate): # type:ignore return r -def apply_gate(c, i, j): # type:ignore +def _apply_gate(c: Any, i: int, j: int) -> Any: if i == 0: c.i(j) elif i == 1: @@ -266,15 +276,15 @@ def apply_gate(c, i, j): # type:ignore return c -def rc_circuit(c): # type:ignore +def rc_circuit(c: Any) -> Any: qir = c.to_qir() cnew = Circuit(c.circuit_param["nqubits"]) for d in qir: if len(d["index"]) == 2: rc_list = choice(rc_candidates(d["gate"])) - cnew = apply_gate(cnew, rc_list[0], d["index"][0]) - cnew = apply_gate(cnew, rc_list[1], d["index"][1]) + cnew = _apply_gate(cnew, rc_list[0], d["index"][0]) + cnew = _apply_gate(cnew, rc_list[1], d["index"][1]) if "parameters" not in d: cnew.apply_general_gate_delayed(d["gatef"], d["name"])( cnew, *d["index"] @@ -283,8 +293,8 @@ def rc_circuit(c): # type:ignore cnew.apply_general_variable_gate_delayed(d["gatef"], d["name"])( cnew, *d["index"], **d["parameters"] ) - cnew = apply_gate(cnew, rc_list[2], d["index"][0]) - cnew = apply_gate(cnew, rc_list[3], d["index"][1]) + cnew = _apply_gate(cnew, rc_list[2], d["index"][0]) + cnew = _apply_gate(cnew, rc_list[3], d["index"][1]) else: if "parameters" not in d: cnew.apply_general_gate_delayed(d["gatef"], d["name"])( @@ -299,18 +309,18 @@ def rc_circuit(c): # type:ignore def apply_rc( circuit: Any, - executor: Callable[[Any], float], + executor: Callable[[Any], Any], num_to_average: int = 1, simplify: bool = True, iscount: bool = False, **kws: Any, -) -> float: +) -> Tuple[float, List[Any]]: """Apply Randomized Compiling or Pauli twirling on two-qubit gates. :param circuit: Input circuit :type circuit: Any :param executor: A executor that executes a circuit and return results. - :type executor: Callable[[Any], float] + :type executor: Callable[[Any], Any] :param num_to_average: Number of circuits for RC, defaults to 1 :type num_to_average: int, optional :param simplify: Whether simplify the circuits by merging single qubit gates, defaults to True @@ -326,7 +336,7 @@ def apply_rc( circuit1 = rc_circuit(circuit) if simplify is True: - circuit1 = washcircuit( + circuit1 = prune_ddcircuit( circuit1, qlist=list(range(circuit1.circuit_param["nqubits"])) ) circuit1 = simple_compiler.merge(circuit1) @@ -343,3 +353,6 @@ def apply_rc( result = np.mean(exp) # type:ignore return result, circuit_list # type:ignore + + +# TODO(yuqinchen) add executor with batch ability diff --git a/tests/test_qem.py b/tests/test_qem.py index c0d5a846..6ef01cec 100644 --- a/tests/test_qem.py +++ b/tests/test_qem.py @@ -1,7 +1,7 @@ +from functools import partial import pytest from pytest_lazyfixture import lazy_fixture as lf import numpy as np -from functools import partial import networkx as nx import tensorcircuit as tc @@ -120,8 +120,8 @@ def execute2(circuit): iscount=True, ) - # washcircuit based on use_qubits and washout iden gates - _ = qem.washcircuit(c, qlist=list(range(c.circuit_param["nqubits"]))) + # wash circuit based on use_qubits and washout iden gates + _ = qem.prune_ddcircuit(c, qlist=list(range(c.circuit_param["nqubits"]))) @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) From fe342ace4d4f2d07b4ceda2fc89684359153c197 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Thu, 8 Jun 2023 11:00:49 +0800 Subject: [PATCH 483/725] revise quantum error mitigation code --- .../results/qem/benchmark_circuits.py | 2 +- tensorcircuit/results/qem/qem_methods.py | 33 ++++++++++++++----- 2 files changed, 26 insertions(+), 9 deletions(-) diff --git a/tensorcircuit/results/qem/benchmark_circuits.py b/tensorcircuit/results/qem/benchmark_circuits.py index 2ed1dc08..8097c784 100644 --- a/tensorcircuit/results/qem/benchmark_circuits.py +++ b/tensorcircuit/results/qem/benchmark_circuits.py @@ -75,7 +75,7 @@ def mirror_circuit( def QAOA_circuit( graph: List[Tuple[int]], weight: List[float], params: List[float] -) -> Any: +) -> Any: # internal API don't use nlayers = len(params) qlist = [] diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py index 1d9a7a8d..c6f9885f 100644 --- a/tensorcircuit/results/qem/qem_methods.py +++ b/tensorcircuit/results/qem/qem_methods.py @@ -33,7 +33,8 @@ def apply_zne( num_to_average: int = 1, **kws: Any, ) -> Any: - """Apply zero-noise extrapolation (ZNE) and return the mitigated results. + """ + Apply zero-noise extrapolation (ZNE) and return the mitigated results. :param circuit: The aim circuit. :type circuit: Any @@ -67,7 +68,8 @@ def executortc(c): # type: ignore def prune_ddcircuit(c: Any, qlist: List[int]) -> Any: - """Discard DD sequence on idle qubits and Discard identity gate + """ + Discard DD sequence on idle qubits and Discard identity gate (no identity/idle gate on device now) filled in DD sequence. :param c: circuit @@ -95,7 +97,8 @@ def prune_ddcircuit(c: Any, qlist: List[int]) -> Any: def used_qubits(c: Any) -> List[int]: - """Create a qubit list that includes all qubits having gate manipulation. + """ + Create a qubit list that includes all qubits having gate manipulation. :param c: a circuit :type c: Any @@ -112,7 +115,8 @@ def used_qubits(c: Any) -> List[int]: def add_dd(c: Any, rule: Callable[[int], Any]) -> Any: - """Add DD sequence to A circuit + """ + Add DD sequence to A circuit :param c: circuit :type c: Any @@ -146,7 +150,8 @@ def apply_dd( ) -> Union[ float, Tuple[float, List[Any]], Dict[str, float], Tuple[Dict[str, float], List[Any]] ]: - """Apply dynamic decoupling (DD) and return the mitigated results. + """ + Apply dynamic decoupling (DD) and return the mitigated results. :param circuit: The aim circuit. @@ -175,7 +180,8 @@ def apply_dd( """ def dd_rule(slack_length: int, spacing: int = -1) -> Any: - """Set DD rule. + """ + Set DD rule. :param slack_length: Length of idle window to fill. Automatically calculated for a circuit. :type slack_length: int @@ -276,12 +282,22 @@ def _apply_gate(c: Any, i: int, j: int) -> Any: return c +global candidate_list +candidate_list = {} # type: ignore + + def rc_circuit(c: Any) -> Any: qir = c.to_qir() cnew = Circuit(c.circuit_param["nqubits"]) for d in qir: if len(d["index"]) == 2: - rc_list = choice(rc_candidates(d["gate"])) + if d["gate"].name in list(candidate_list.keys()): + rc_cand = candidate_list[d["gate"].name] + rc_list = choice(rc_cand) + else: + rc_cand = rc_candidates(d["gate"]) + rc_list = choice(rc_cand) + candidate_list[d["gate"].name] = rc_cand cnew = _apply_gate(cnew, rc_list[0], d["index"][0]) cnew = _apply_gate(cnew, rc_list[1], d["index"][1]) @@ -315,7 +331,8 @@ def apply_rc( iscount: bool = False, **kws: Any, ) -> Tuple[float, List[Any]]: - """Apply Randomized Compiling or Pauli twirling on two-qubit gates. + """ + Apply Randomized Compiling or Pauli twirling on two-qubit gates. :param circuit: Input circuit :type circuit: Any From efe8aa7cdb555ad327e12dbf0a2a43576a603025 Mon Sep 17 00:00:00 2001 From: yutuer21 <510465359@qq.com> Date: Thu, 8 Jun 2023 11:17:07 +0800 Subject: [PATCH 484/725] revise2 quantum error mitigation --- docs/source/tutorials/benchmark_circuits.ipynb | 4 ++-- docs/source/tutorials/error_mitigation.ipynb | 8 ++++---- tensorcircuit/results/qem/qem_methods.py | 10 +++++----- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/docs/source/tutorials/benchmark_circuits.ipynb b/docs/source/tutorials/benchmark_circuits.ipynb index e07bf9ca..eceef94d 100644 --- a/docs/source/tutorials/benchmark_circuits.ipynb +++ b/docs/source/tutorials/benchmark_circuits.ipynb @@ -4,14 +4,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Benchmark Chips" + "# Benchmark Chips" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Benchmark chips using mirror circuit" + "## Benchmark chips using mirror circuit" ] }, { diff --git a/docs/source/tutorials/error_mitigation.ipynb b/docs/source/tutorials/error_mitigation.ipynb index a241032d..a64b0d08 100644 --- a/docs/source/tutorials/error_mitigation.ipynb +++ b/docs/source/tutorials/error_mitigation.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## QEM Applications" + "# QEM Applications" ] }, { @@ -32,7 +32,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### ZNE" + "## ZNE" ] }, { @@ -191,7 +191,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### DD" + "## DD" ] }, { @@ -347,7 +347,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### RC" + "## RC" ] }, { diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py index c6f9885f..eae34fba 100644 --- a/tensorcircuit/results/qem/qem_methods.py +++ b/tensorcircuit/results/qem/qem_methods.py @@ -282,8 +282,8 @@ def _apply_gate(c: Any, i: int, j: int) -> Any: return c -global candidate_list -candidate_list = {} # type: ignore + +candidate_dict = {} # type: ignore def rc_circuit(c: Any) -> Any: @@ -291,13 +291,13 @@ def rc_circuit(c: Any) -> Any: cnew = Circuit(c.circuit_param["nqubits"]) for d in qir: if len(d["index"]) == 2: - if d["gate"].name in list(candidate_list.keys()): - rc_cand = candidate_list[d["gate"].name] + if d["gate"].name in candidate_dict: + rc_cand = candidate_dict[d["gate"].name] rc_list = choice(rc_cand) else: rc_cand = rc_candidates(d["gate"]) rc_list = choice(rc_cand) - candidate_list[d["gate"].name] = rc_cand + candidate_dict[d["gate"].name] = rc_cand cnew = _apply_gate(cnew, rc_list[0], d["index"][0]) cnew = _apply_gate(cnew, rc_list[1], d["index"][1]) From 90dc0f1ff36dc7d0c19d8d107e130cd6a5d209c3 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Jun 2023 11:26:44 +0800 Subject: [PATCH 485/725] black --- .../source/tutorials/benchmark_circuits.ipynb | 59 ++--- docs/source/tutorials/error_mitigation.ipynb | 224 +++++++++++------- tensorcircuit/results/__init__.py | 1 + tensorcircuit/results/qem/qem_methods.py | 1 - 4 files changed, 175 insertions(+), 110 deletions(-) diff --git a/docs/source/tutorials/benchmark_circuits.ipynb b/docs/source/tutorials/benchmark_circuits.ipynb index eceef94d..e2e5eb1d 100644 --- a/docs/source/tutorials/benchmark_circuits.ipynb +++ b/docs/source/tutorials/benchmark_circuits.ipynb @@ -30,6 +30,7 @@ "from tensorcircuit.results import counts\n", "from tensorcircuit.compiler.qiskit_compiler import qiskit_compile\n", "from matplotlib import cm\n", + "\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt" ] @@ -87,45 +88,49 @@ "result_list = []\n", "\n", "\n", - "for nq in range(2,6):\n", + "for nq in range(2, 6):\n", " qlis = list(range(nq))\n", " graph = []\n", " for i in range(len(couple_list)):\n", " if couple_list[i][0] in qlis and couple_list[i][1] in qlis:\n", " graph.append(couple_list[i])\n", "\n", - "\n", - " G=nx.Graph()\n", + " G = nx.Graph()\n", " G.add_edges_from(graph)\n", - " nx.draw(G,with_labels=True)\n", - "\n", - "\n", - " for depth in range(1,3):\n", - "\n", - " \n", + " nx.draw(G, with_labels=True)\n", "\n", + " for depth in range(1, 3):\n", " A = 0\n", " for numc in range(5):\n", + " c, ideal = benchmark_circuits.mirror_circuit(\n", + " depth=depth,\n", + " two_qubit_gate_prob=1,\n", + " connectivity_graph=G,\n", + " seed=random.randint(0, 100),\n", + " ) # includes np.sqrt(X)^{\\dagger} gate,identity gate\n", "\n", - " c, ideal = benchmark_circuits.mirror_circuit(depth=depth, two_qubit_gate_prob=1, connectivity_graph=G,seed = random.randint(0,100)) # includes np.sqrt(X)^{\\dagger} gate,identity gate\n", - "\n", - " c1, info = qiskit_compile( \n", + " c1, info = qiskit_compile(\n", " c,\n", " compiled_options={\n", - " \"basis_gates\": ['h', 'rz', 'x', 'y', 'z', 'cz'],\n", + " \"basis_gates\": [\"h\", \"rz\", \"x\", \"y\", \"z\", \"cz\"],\n", " \"optimization_level\": 2,\n", - " # \"coupling_map\": d.topology(), \n", + " # \"coupling_map\": d.topology(),\n", " },\n", " )\n", "\n", - "\n", - " t = apis.submit_task(circuit=c1,shots=10000,device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + " t = apis.submit_task(\n", + " circuit=c1,\n", + " shots=10000,\n", + " device=d,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + " )\n", " raw_count = t.results(blocked=True) # position_counts=logical_counts\n", " # print(\"raw\",raw_count[list(ideal.keys())[0]]/10000)\n", "\n", - " A+=raw_count[list(ideal.keys())[0]]/10000\n", - " print(\"nq:\",qlis, \"depth:\",depth, \"success\",A)\n", - " result_list.append(A)\n" + " A += raw_count[list(ideal.keys())[0]] / 10000\n", + " print(\"nq:\", qlis, \"depth:\", depth, \"success\", A)\n", + " result_list.append(A)" ] }, { @@ -134,8 +139,8 @@ "metadata": {}, "outputs": [], "source": [ - "result_list1 = [i/5 for i in result_list]\n", - "result_list2 = np.reshape(result_list1,[4,2])" + "result_list1 = [i / 5 for i in result_list]\n", + "result_list2 = np.reshape(result_list1, [4, 2])" ] }, { @@ -165,12 +170,12 @@ } ], "source": [ - "fig, ax=plt.subplots()\n", - "Z=np.transpose(result_list2)\n", - "X=list(range(2,6))\n", - "Y=list(range(1,3))\n", - "p=ax.pcolor(X,Y, Z,vmin=Z.min(),vmax=Z.max(), cmap='rainbow')\n", - "cb=fig.colorbar(p, ax=ax)\n", + "fig, ax = plt.subplots()\n", + "Z = np.transpose(result_list2)\n", + "X = list(range(2, 6))\n", + "Y = list(range(1, 3))\n", + "p = ax.pcolor(X, Y, Z, vmin=Z.min(), vmax=Z.max(), cmap=\"rainbow\")\n", + "cb = fig.colorbar(p, ax=ax)\n", "plt.xlabel(\"Nqubit\")\n", "plt.ylabel(\"Depth\")" ] diff --git a/docs/source/tutorials/error_mitigation.ipynb b/docs/source/tutorials/error_mitigation.ipynb index a64b0d08..abb35992 100644 --- a/docs/source/tutorials/error_mitigation.ipynb +++ b/docs/source/tutorials/error_mitigation.ipynb @@ -16,7 +16,13 @@ "import tensorcircuit as tc\n", "from tensorcircuit.results import qem\n", "from tensorcircuit.results.qem import qem_methods, benchmark_circuits\n", - "from tensorcircuit.results.qem import zne_option,apply_zne,dd_option,apply_dd,apply_rc\n", + "from tensorcircuit.results.qem import (\n", + " zne_option,\n", + " apply_zne,\n", + " dd_option,\n", + " apply_dd,\n", + " apply_rc,\n", + ")\n", "\n", "from tensorcircuit.cloud import apis\n", "from tensorcircuit.results import counts\n", @@ -60,7 +66,9 @@ "metadata": {}, "outputs": [], "source": [ - "mit = tc.results.rem.ReadoutMit(\"tianxuan_s1?o=0\") # set ?o=0 for readout mitigation initialization \n", + "mit = tc.results.rem.ReadoutMit(\n", + " \"tianxuan_s1?o=0\"\n", + ") # set ?o=0 for readout mitigation initialization\n", "mit.cals_from_system(qubits=9, shots=4096)" ] }, @@ -82,14 +90,14 @@ } ], "source": [ - "graph = [(2,0),(3,7),(0,3),(1,5),(2,6)]\n", - "weight = [1]*len(graph)\n", - "params = np.array([[1,1],[1,1]])\n", - "optimization_level=2\n", + "graph = [(2, 0), (3, 7), (0, 3), (1, 5), (2, 6)]\n", + "weight = [1] * len(graph)\n", + "params = np.array([[1, 1], [1, 1]])\n", + "optimization_level = 2\n", "\n", "\n", "c = benchmark_circuits.QAOA_circuit(graph, weight, params)\n", - "c.to_qiskit().draw(\"mpl\") " + "c.to_qiskit().draw(\"mpl\")" ] }, { @@ -101,7 +109,7 @@ "c1, info = qiskit_compile(\n", " c,\n", " compiled_options={\n", - " \"basis_gates\": ['h', 'rz', 'x', 'y', 'z', 'cz'],\n", + " \"basis_gates\": [\"h\", \"rz\", \"x\", \"y\", \"z\", \"cz\"],\n", " \"optimization_level\": optimization_level,\n", " # \"coupling_map\": d.topology(),\n", " },\n", @@ -126,15 +134,36 @@ "source": [ "t = apis.submit_task(circuit=c, shots=10000, device=\"simulator:aer\")\n", "raw_count = t.results(blocked=True)\n", - "ideal = sum([-counts.expectation(raw_count, z=[graph[e][0], graph[e][1]])*weight[e] for e in range(len(graph))])\n", - "print(\"ideal\",ideal)\n", + "ideal = sum(\n", + " [\n", + " -counts.expectation(raw_count, z=[graph[e][0], graph[e][1]]) * weight[e]\n", + " for e in range(len(graph))\n", + " ]\n", + ")\n", + "print(\"ideal\", ideal)\n", "\n", - "t = apis.submit_task(circuit=c1,shots=10000,device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + "t = apis.submit_task(\n", + " circuit=c1,\n", + " shots=10000,\n", + " device=d,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + ")\n", "raw_count = t.results(blocked=True)\n", - "raw = sum([-counts.expectation(raw_count, z=[graph[e][0], graph[e][1]])*weight[e] for e in range(len(graph))])\n", - "print(\"raw\",raw)\n", - "read = sum([-mit.expectation(raw_count, z=[graph[e][0], graph[e][1]],**info)*weight[e] for e in range(len(graph))])\n", - "print(\"read\",read)" + "raw = sum(\n", + " [\n", + " -counts.expectation(raw_count, z=[graph[e][0], graph[e][1]]) * weight[e]\n", + " for e in range(len(graph))\n", + " ]\n", + ")\n", + "print(\"raw\", raw)\n", + "read = sum(\n", + " [\n", + " -mit.expectation(raw_count, z=[graph[e][0], graph[e][1]], **info) * weight[e]\n", + " for e in range(len(graph))\n", + " ]\n", + ")\n", + "print(\"read\", read)" ] }, { @@ -161,30 +190,45 @@ } ], "source": [ - "\n", "def execute(circuit):\n", - " t = apis.submit_task(circuit=circuit, shots=10000, device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", - " count =t.results(blocked=True)\n", - " a = sum([-mit.expectation(count, z=[graph[e][0], graph[e][1]],**info)*weight[e] for e in range(len(graph))])\n", + " t = apis.submit_task(\n", + " circuit=circuit,\n", + " shots=10000,\n", + " device=d,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + " )\n", + " count = t.results(blocked=True)\n", + " a = sum(\n", + " [\n", + " -mit.expectation(count, z=[graph[e][0], graph[e][1]], **info) * weight[e]\n", + " for e in range(len(graph))\n", + " ]\n", + " )\n", " # a = sum([-counts.expectation(raw_count, z=[graph[e][0], graph[e][1]])*w[e] for e in range(len(graph))])\n", " return a\n", "\n", + "\n", "random_state = np.random.RandomState(0)\n", "noise_scaling_function = partial(\n", " zne_option.scaling.fold_gates_at_random,\n", - " fidelities = {\"single\": 1.0}, \n", - " random_state=random_state, \n", + " fidelities={\"single\": 1.0},\n", + " random_state=random_state,\n", ")\n", - "factory = zne_option.inference.PolyFactory (scale_factors=[1,3,5],order = 1)\n", + "factory = zne_option.inference.PolyFactory(scale_factors=[1, 3, 5], order=1)\n", "# factory = zne_option.inference.ExpFactory(scale_factors=[1,1.5,2],asymptote=0.)\n", "# factory = zne_option.inference.RichardsonFactory(scale_factors=[1,1.5,2])\n", "# factory = zne_option.inference.AdaExpFactory(steps=5, asymptote=0.)\n", "\n", "result = apply_zne(\n", - " circuit=c1, executor = execute, factory=factory, scale_noise = noise_scaling_function,num_to_average=1\n", + " circuit=c1,\n", + " executor=execute,\n", + " factory=factory,\n", + " scale_noise=noise_scaling_function,\n", + " num_to_average=1,\n", ")\n", "_ = factory.plot_fit()\n", - "print(\"zne\",result)" + "print(\"zne\", result)" ] }, { @@ -232,7 +276,7 @@ ], "source": [ "c, ideal = benchmark_circuits.ghz_circuit(8)\n", - "c.to_qiskit().draw(\"mpl\") # logical circuit" + "c.to_qiskit().draw(\"mpl\") # logical circuit" ] }, { @@ -249,17 +293,16 @@ } ], "source": [ - "\n", - "c1, info = qiskit_compile( \n", + "c1, info = qiskit_compile(\n", " c,\n", " compiled_options={\n", - " \"basis_gates\": ['h', 'rz', 'x', 'y', 'z', 'cz'],\n", + " \"basis_gates\": [\"h\", \"rz\", \"x\", \"y\", \"z\", \"cz\"],\n", " \"optimization_level\": 2,\n", - " # \"coupling_map\": d.topology(), \n", + " # \"coupling_map\": d.topology(),\n", " },\n", ")\n", "\n", - "print(info)\n" + "print(info)" ] }, { @@ -277,18 +320,24 @@ } ], "source": [ - "zpauli = [0,6] # logical\n", + "zpauli = [0, 6] # logical\n", "\n", "t = apis.submit_task(circuit=c, shots=10000, device=\"simulator:aer\")\n", "raw_count = t.results(blocked=True)\n", "ideal = counts.expectation(raw_count, z=zpauli)\n", - "print(\"ideal\",ideal)\n", + "print(\"ideal\", ideal)\n", "\n", "\n", - "t = apis.submit_task(circuit=c1,shots=10000,device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + "t = apis.submit_task(\n", + " circuit=c1,\n", + " shots=10000,\n", + " device=d,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + ")\n", "raw_count = t.results(blocked=True) # position_counts=logical_counts\n", "raw = counts.expectation(raw_count, z=zpauli)\n", - "print(\"raw\",raw)" + "print(\"raw\", raw)" ] }, { @@ -317,29 +366,35 @@ ], "source": [ "def execute(circuit):\n", - " t = apis.submit_task(circuit=circuit, shots=10000, device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", - " count =t.results(blocked=True) # physical_counts\n", + " t = apis.submit_task(\n", + " circuit=circuit,\n", + " shots=10000,\n", + " device=d,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + " )\n", + " count = t.results(blocked=True) # physical_counts\n", + "\n", + " n = len(info[\"logical_physical_mapping\"])\n", + " physical_qubits = [info[\"logical_physical_mapping\"][i] for i in range(n)]\n", + " count = counts.marginal_count(count, physical_qubits)\n", "\n", - " n = len(info['logical_physical_mapping'])\n", - " physical_qubits = [info['logical_physical_mapping'][i] for i in range(n)]\n", - " count = counts.marginal_count(count,physical_qubits)\n", - " \n", " # a = mit.expectation(count, z=zpauli,**info)\n", " a = counts.expectation(count, z=zpauli)\n", " return a\n", "\n", "\n", "mitigated_result = apply_dd(\n", - " circuit=c1, \n", - " executor=execute, \n", - " rule = dd_option.rules.yy,\n", - " rule_args = {\"spacing\": -1},\n", - " full_output = True,\n", - " ignore_idle_qubit =True,\n", - " fulldd = False\n", - " )\n", + " circuit=c1,\n", + " executor=execute,\n", + " rule=dd_option.rules.yy,\n", + " rule_args={\"spacing\": -1},\n", + " full_output=True,\n", + " ignore_idle_qubit=True,\n", + " fulldd=False,\n", + ")\n", "\n", - "print(\"mit\",mitigated_result[0])\n", + "print(\"mit\", mitigated_result[0])\n", "mitigated_result[1].to_qiskit().draw(\"mpl\")" ] }, @@ -371,14 +426,14 @@ "c = tc.Circuit(5)\n", "c.x(0)\n", "c.h(2)\n", - "c.cz(0,1)\n", - "c.cz(2,3)\n", + "c.cz(0, 1)\n", + "c.cz(2, 3)\n", "c.y(1)\n", "c.h(2)\n", - "c.cz(0,1)\n", - "c.cz(2,3)\n", + "c.cz(0, 1)\n", + "c.cz(2, 3)\n", "c.h(4)\n", - "c.cz(3,4)\n", + "c.cz(3, 4)\n", "\n", "c.to_qiskit().draw(\"mpl\")" ] @@ -402,7 +457,7 @@ ], "source": [ "circuit = qem.rc_circuit(c)\n", - "circuit = qem.washcircuit(circuit,qlist=list(range(circuit.circuit_param[\"nqubits\"])))\n", + "circuit = qem.washcircuit(circuit, qlist=list(range(circuit.circuit_param[\"nqubits\"])))\n", "circuit.to_qiskit().draw(\"mpl\")" ] }, @@ -431,17 +486,17 @@ } ], "source": [ - "c1, info = qiskit_compile( \n", + "c1, info = qiskit_compile(\n", " c,\n", " compiled_options={\n", - " \"basis_gates\": ['h', 'rz', 'x', 'y', 'z','cz'],\n", + " \"basis_gates\": [\"h\", \"rz\", \"x\", \"y\", \"z\", \"cz\"],\n", " \"optimization_level\": 2,\n", - " # \"coupling_map\": d.topology(), \n", + " # \"coupling_map\": d.topology(),\n", " },\n", ")\n", "\n", "print(info)\n", - "c1.to_qiskit().draw(\"mpl\") " + "c1.to_qiskit().draw(\"mpl\")" ] }, { @@ -459,18 +514,24 @@ } ], "source": [ - "zpauli = [1,2] # logical\n", + "zpauli = [1, 2] # logical\n", "\n", "t = apis.submit_task(circuit=c, shots=10000, device=\"simulator:aer\")\n", "raw_count = t.results(blocked=True)\n", "ideal = counts.expectation(raw_count, z=zpauli)\n", - "print(\"ideal\",ideal)\n", + "print(\"ideal\", ideal)\n", "\n", "\n", - "t = apis.submit_task(circuit=c1,shots=10000,device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", + "t = apis.submit_task(\n", + " circuit=c1,\n", + " shots=10000,\n", + " device=d,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + ")\n", "raw_count = t.results(blocked=True) # position_counts=logical_counts\n", "raw = counts.expectation(raw_count, z=zpauli)\n", - "print(\"raw\",raw)\n" + "print(\"raw\", raw)" ] }, { @@ -488,38 +549,37 @@ } ], "source": [ - "\n", "def execute(circuit):\n", - " t = apis.submit_task(circuit=circuit, shots=10000, device=d,enable_qos_qubit_mapping=False,enable_qos_gate_decomposition=False)\n", - " count =t.results(blocked=True) # physical_counts\n", + " t = apis.submit_task(\n", + " circuit=circuit,\n", + " shots=10000,\n", + " device=d,\n", + " enable_qos_qubit_mapping=False,\n", + " enable_qos_gate_decomposition=False,\n", + " )\n", + " count = t.results(blocked=True) # physical_counts\n", + "\n", + " n = len(info[\"logical_physical_mapping\"])\n", + " physical_qubits = [info[\"logical_physical_mapping\"][i] for i in range(n)]\n", + " count = counts.marginal_count(count, physical_qubits)\n", "\n", - " n = len(info['logical_physical_mapping'])\n", - " physical_qubits = [info['logical_physical_mapping'][i] for i in range(n)]\n", - " count = counts.marginal_count(count,physical_qubits)\n", - " \n", " # a = mit.expectation(count, z=zpauli,**info)\n", " a = counts.expectation(count, z=zpauli)\n", " return a\n", "\n", "\n", "mitigated_result = apply_rc(\n", - " circuit=c1, \n", - " executor=execute, \n", - " num_to_average=6,\n", - " simplify=True\n", - " )\n", + " circuit=c1, executor=execute, num_to_average=6, simplify=True\n", + ")\n", "\n", - "print(\"mit\",mitigated_result[0])\n", + "print(\"mit\", mitigated_result[0])\n", "\n", "\n", "mitigated_result = apply_rc(\n", - " circuit=c1, \n", - " executor=execute, \n", - " num_to_average=6,\n", - " simplify=False\n", - " )\n", + " circuit=c1, executor=execute, num_to_average=6, simplify=False\n", + ")\n", "\n", - "print(\"mit\",mitigated_result[0])" + "print(\"mit\", mitigated_result[0])" ] } ], diff --git a/tensorcircuit/results/__init__.py b/tensorcircuit/results/__init__.py index 7a953ae9..c7cf260f 100644 --- a/tensorcircuit/results/__init__.py +++ b/tensorcircuit/results/__init__.py @@ -1,4 +1,5 @@ from . import counts +from . import qem from . import readout_mitigation rem = readout_mitigation # alias diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py index eae34fba..7dda7dfe 100644 --- a/tensorcircuit/results/qem/qem_methods.py +++ b/tensorcircuit/results/qem/qem_methods.py @@ -282,7 +282,6 @@ def _apply_gate(c: Any, i: int, j: int) -> Any: return c - candidate_dict = {} # type: ignore From b76bc0f4b193f9c004f6ec6ae73b8d0988ffafa2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Jun 2023 12:06:33 +0800 Subject: [PATCH 486/725] fix mypy --- tensorcircuit/results/qem/__init__.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/results/qem/__init__.py b/tensorcircuit/results/qem/__init__.py index 541f9c8d..c895d370 100644 --- a/tensorcircuit/results/qem/__init__.py +++ b/tensorcircuit/results/qem/__init__.py @@ -1,10 +1,10 @@ from . import qem_methods apply_zne = qem_methods.apply_zne -zne_option = qem_methods.zne_option +zne_option = qem_methods.zne_option # type: ignore apply_dd = qem_methods.apply_dd -dd_option = qem_methods.dd_option +dd_option = qem_methods.dd_option # type: ignore used_qubits = qem_methods.used_qubits prune_ddcircuit = qem_methods.prune_ddcircuit add_dd = qem_methods.add_dd From e70d71d598329179cf16526d7880ca95bbbc7bb1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Jun 2023 14:53:39 +0800 Subject: [PATCH 487/725] update the doc script to general module with arbitrary dir depth --- CHANGELOG.md | 2 + docs/source/api/about.rst | 2 +- docs/source/api/abstractcircuit.rst | 2 +- docs/source/api/applications.rst | 4 +- docs/source/api/applications/dqas.rst | 2 +- docs/source/api/applications/graphdata.rst | 2 +- docs/source/api/applications/layers.rst | 2 +- docs/source/api/applications/utils.rst | 2 +- docs/source/api/applications/vags.rst | 2 +- docs/source/api/applications/van.rst | 2 +- docs/source/api/applications/vqes.rst | 2 +- docs/source/api/backends.rst | 4 +- docs/source/api/backends/backend_factory.rst | 2 +- docs/source/api/backends/cupy_backend.rst | 2 +- docs/source/api/backends/jax_backend.rst | 2 +- docs/source/api/backends/numpy_backend.rst | 2 +- docs/source/api/backends/pytorch_backend.rst | 2 +- .../api/backends/tensorflow_backend.rst | 2 +- docs/source/api/basecircuit.rst | 2 +- docs/source/api/channels.rst | 2 +- docs/source/api/circuit.rst | 2 +- docs/source/api/cloud.rst | 4 +- docs/source/api/cloud/abstraction.rst | 2 +- docs/source/api/cloud/apis.rst | 2 +- docs/source/api/cloud/config.rst | 2 +- docs/source/api/cloud/local.rst | 2 +- docs/source/api/cloud/quafu_provider.rst | 2 +- docs/source/api/cloud/tencent.rst | 2 +- docs/source/api/cloud/utils.rst | 2 +- docs/source/api/cloud/wrapper.rst | 2 +- docs/source/api/compiler.rst | 4 +- .../source/api/compiler/composed_compiler.rst | 2 +- docs/source/api/compiler/qiskit_compiler.rst | 2 +- docs/source/api/compiler/simple_compiler.rst | 2 +- docs/source/api/cons.rst | 2 +- docs/source/api/densitymatrix.rst | 2 +- docs/source/api/experimental.rst | 2 +- docs/source/api/gates.rst | 2 +- docs/source/api/interfaces.rst | 4 +- docs/source/api/interfaces/numpy.rst | 2 +- docs/source/api/interfaces/scipy.rst | 2 +- docs/source/api/interfaces/tensorflow.rst | 2 +- docs/source/api/interfaces/tensortrans.rst | 2 +- docs/source/api/interfaces/torch.rst | 2 +- docs/source/api/keras.rst | 2 +- docs/source/api/mps_base.rst | 2 +- docs/source/api/mpscircuit.rst | 2 +- docs/source/api/noisemodel.rst | 2 +- docs/source/api/quantum.rst | 2 +- docs/source/api/results.rst | 5 +- docs/source/api/results/counts.rst | 2 +- docs/source/api/results/qem.rst | 5 + .../api/results/qem/benchmark_circuits.rst | 7 + docs/source/api/results/qem/qem_methods.rst | 7 + .../source/api/results/readout_mitigation.rst | 2 +- docs/source/api/simplify.rst | 2 +- docs/source/api/templates.rst | 4 +- docs/source/api/templates/blocks.rst | 2 +- docs/source/api/templates/chems.rst | 2 +- docs/source/api/templates/dataset.rst | 2 +- docs/source/api/templates/ensemble.rst | 2 +- docs/source/api/templates/graphs.rst | 2 +- docs/source/api/templates/measurements.rst | 2 +- docs/source/api/torchnn.rst | 2 +- docs/source/api/translation.rst | 2 +- docs/source/api/utils.rst | 2 +- docs/source/api/vis.rst | 2 +- docs/source/generate_rst.py | 85 +++---- docs/source/modules.rst | 2 +- docs/source/modules.rst.backup | 227 +++--------------- requirements/requirements-extra.txt | 1 + 71 files changed, 165 insertions(+), 312 deletions(-) create mode 100644 docs/source/api/results/qem.rst create mode 100644 docs/source/api/results/qem/benchmark_circuits.rst create mode 100644 docs/source/api/results/qem/qem_methods.rst diff --git a/CHANGELOG.md b/CHANGELOG.md index 8b43e428..0a1f99b9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,8 @@ - make the pulse level control support differentiating the end time +- Add new qem module with qem methods: zne, dd and rc + ### Fixed - `tc.results.counts.plot_histogram` now can dispatch kws to corresponding qiskit method diff --git a/docs/source/api/about.rst b/docs/source/api/about.rst index 8f7bbf76..e065f1eb 100644 --- a/docs/source/api/about.rst +++ b/docs/source/api/about.rst @@ -1,5 +1,5 @@ tensorcircuit.about -================================================== +================================================================================ .. automodule:: tensorcircuit.about :members: :undoc-members: diff --git a/docs/source/api/abstractcircuit.rst b/docs/source/api/abstractcircuit.rst index 2caf0af1..3d67a499 100644 --- a/docs/source/api/abstractcircuit.rst +++ b/docs/source/api/abstractcircuit.rst @@ -1,5 +1,5 @@ tensorcircuit.abstractcircuit -================================================== +================================================================================ .. automodule:: tensorcircuit.abstractcircuit :members: :undoc-members: diff --git a/docs/source/api/applications.rst b/docs/source/api/applications.rst index ad329ccf..8682f5b4 100644 --- a/docs/source/api/applications.rst +++ b/docs/source/api/applications.rst @@ -1,5 +1,5 @@ -tensorcircuit.applications -================================================== +tensorcircuit.applications.rst +================================================================================ .. toctree:: applications/dqas.rst applications/graphdata.rst diff --git a/docs/source/api/applications/dqas.rst b/docs/source/api/applications/dqas.rst index 32457e1f..73cacd43 100644 --- a/docs/source/api/applications/dqas.rst +++ b/docs/source/api/applications/dqas.rst @@ -1,5 +1,5 @@ tensorcircuit.applications.dqas -================================================== +================================================================================ .. automodule:: tensorcircuit.applications.dqas :members: :undoc-members: diff --git a/docs/source/api/applications/graphdata.rst b/docs/source/api/applications/graphdata.rst index 22e1af13..44851513 100644 --- a/docs/source/api/applications/graphdata.rst +++ b/docs/source/api/applications/graphdata.rst @@ -1,5 +1,5 @@ tensorcircuit.applications.graphdata -================================================== +================================================================================ .. automodule:: tensorcircuit.applications.graphdata :members: :undoc-members: diff --git a/docs/source/api/applications/layers.rst b/docs/source/api/applications/layers.rst index 69303e98..d4f49e81 100644 --- a/docs/source/api/applications/layers.rst +++ b/docs/source/api/applications/layers.rst @@ -1,5 +1,5 @@ tensorcircuit.applications.layers -================================================== +================================================================================ .. automodule:: tensorcircuit.applications.layers :members: :undoc-members: diff --git a/docs/source/api/applications/utils.rst b/docs/source/api/applications/utils.rst index d4549700..4114e7d8 100644 --- a/docs/source/api/applications/utils.rst +++ b/docs/source/api/applications/utils.rst @@ -1,5 +1,5 @@ tensorcircuit.applications.utils -================================================== +================================================================================ .. automodule:: tensorcircuit.applications.utils :members: :undoc-members: diff --git a/docs/source/api/applications/vags.rst b/docs/source/api/applications/vags.rst index 5b951bd3..af0f451f 100644 --- a/docs/source/api/applications/vags.rst +++ b/docs/source/api/applications/vags.rst @@ -1,5 +1,5 @@ tensorcircuit.applications.vags -================================================== +================================================================================ .. automodule:: tensorcircuit.applications.vags :members: :undoc-members: diff --git a/docs/source/api/applications/van.rst b/docs/source/api/applications/van.rst index 463e44d2..5c90f2e5 100644 --- a/docs/source/api/applications/van.rst +++ b/docs/source/api/applications/van.rst @@ -1,5 +1,5 @@ tensorcircuit.applications.van -================================================== +================================================================================ .. automodule:: tensorcircuit.applications.van :members: :undoc-members: diff --git a/docs/source/api/applications/vqes.rst b/docs/source/api/applications/vqes.rst index e3c775e5..d868c634 100644 --- a/docs/source/api/applications/vqes.rst +++ b/docs/source/api/applications/vqes.rst @@ -1,5 +1,5 @@ tensorcircuit.applications.vqes -================================================== +================================================================================ .. automodule:: tensorcircuit.applications.vqes :members: :undoc-members: diff --git a/docs/source/api/backends.rst b/docs/source/api/backends.rst index 4504e569..777a69ab 100644 --- a/docs/source/api/backends.rst +++ b/docs/source/api/backends.rst @@ -1,5 +1,5 @@ -tensorcircuit.backends -================================================== +tensorcircuit.backends.rst +================================================================================ .. toctree:: backends/backend_factory.rst backends/cupy_backend.rst diff --git a/docs/source/api/backends/backend_factory.rst b/docs/source/api/backends/backend_factory.rst index 8864abfe..6df6374e 100644 --- a/docs/source/api/backends/backend_factory.rst +++ b/docs/source/api/backends/backend_factory.rst @@ -1,5 +1,5 @@ tensorcircuit.backends.backend_factory -================================================== +================================================================================ .. automodule:: tensorcircuit.backends.backend_factory :members: :undoc-members: diff --git a/docs/source/api/backends/cupy_backend.rst b/docs/source/api/backends/cupy_backend.rst index 743fe8f3..1e2421eb 100644 --- a/docs/source/api/backends/cupy_backend.rst +++ b/docs/source/api/backends/cupy_backend.rst @@ -1,5 +1,5 @@ tensorcircuit.backends.cupy_backend -================================================== +================================================================================ .. automodule:: tensorcircuit.backends.cupy_backend :members: :undoc-members: diff --git a/docs/source/api/backends/jax_backend.rst b/docs/source/api/backends/jax_backend.rst index e0dfe7c3..209409bc 100644 --- a/docs/source/api/backends/jax_backend.rst +++ b/docs/source/api/backends/jax_backend.rst @@ -1,5 +1,5 @@ tensorcircuit.backends.jax_backend -================================================== +================================================================================ .. automodule:: tensorcircuit.backends.jax_backend :members: :undoc-members: diff --git a/docs/source/api/backends/numpy_backend.rst b/docs/source/api/backends/numpy_backend.rst index af19d26b..735f969f 100644 --- a/docs/source/api/backends/numpy_backend.rst +++ b/docs/source/api/backends/numpy_backend.rst @@ -1,5 +1,5 @@ tensorcircuit.backends.numpy_backend -================================================== +================================================================================ .. automodule:: tensorcircuit.backends.numpy_backend :members: :undoc-members: diff --git a/docs/source/api/backends/pytorch_backend.rst b/docs/source/api/backends/pytorch_backend.rst index df2712c6..0d10f664 100644 --- a/docs/source/api/backends/pytorch_backend.rst +++ b/docs/source/api/backends/pytorch_backend.rst @@ -1,5 +1,5 @@ tensorcircuit.backends.pytorch_backend -================================================== +================================================================================ .. automodule:: tensorcircuit.backends.pytorch_backend :members: :undoc-members: diff --git a/docs/source/api/backends/tensorflow_backend.rst b/docs/source/api/backends/tensorflow_backend.rst index 52663b1a..a595418e 100644 --- a/docs/source/api/backends/tensorflow_backend.rst +++ b/docs/source/api/backends/tensorflow_backend.rst @@ -1,5 +1,5 @@ tensorcircuit.backends.tensorflow_backend -================================================== +================================================================================ .. automodule:: tensorcircuit.backends.tensorflow_backend :members: :undoc-members: diff --git a/docs/source/api/basecircuit.rst b/docs/source/api/basecircuit.rst index 6b014bb1..79c2636e 100644 --- a/docs/source/api/basecircuit.rst +++ b/docs/source/api/basecircuit.rst @@ -1,5 +1,5 @@ tensorcircuit.basecircuit -================================================== +================================================================================ .. automodule:: tensorcircuit.basecircuit :members: :undoc-members: diff --git a/docs/source/api/channels.rst b/docs/source/api/channels.rst index 3a7cf3af..d9d6fd00 100644 --- a/docs/source/api/channels.rst +++ b/docs/source/api/channels.rst @@ -1,5 +1,5 @@ tensorcircuit.channels -================================================== +================================================================================ .. automodule:: tensorcircuit.channels :members: :undoc-members: diff --git a/docs/source/api/circuit.rst b/docs/source/api/circuit.rst index 910c5ef6..59c76ddd 100644 --- a/docs/source/api/circuit.rst +++ b/docs/source/api/circuit.rst @@ -1,5 +1,5 @@ tensorcircuit.circuit -================================================== +================================================================================ .. automodule:: tensorcircuit.circuit :members: :undoc-members: diff --git a/docs/source/api/cloud.rst b/docs/source/api/cloud.rst index 65b9c714..d94d1412 100644 --- a/docs/source/api/cloud.rst +++ b/docs/source/api/cloud.rst @@ -1,5 +1,5 @@ -tensorcircuit.cloud -================================================== +tensorcircuit.cloud.rst +================================================================================ .. toctree:: cloud/abstraction.rst cloud/apis.rst diff --git a/docs/source/api/cloud/abstraction.rst b/docs/source/api/cloud/abstraction.rst index b0a50812..3f00247c 100644 --- a/docs/source/api/cloud/abstraction.rst +++ b/docs/source/api/cloud/abstraction.rst @@ -1,5 +1,5 @@ tensorcircuit.cloud.abstraction -================================================== +================================================================================ .. automodule:: tensorcircuit.cloud.abstraction :members: :undoc-members: diff --git a/docs/source/api/cloud/apis.rst b/docs/source/api/cloud/apis.rst index 648baa66..fe623eec 100644 --- a/docs/source/api/cloud/apis.rst +++ b/docs/source/api/cloud/apis.rst @@ -1,5 +1,5 @@ tensorcircuit.cloud.apis -================================================== +================================================================================ .. automodule:: tensorcircuit.cloud.apis :members: :undoc-members: diff --git a/docs/source/api/cloud/config.rst b/docs/source/api/cloud/config.rst index a4338784..8f6282a0 100644 --- a/docs/source/api/cloud/config.rst +++ b/docs/source/api/cloud/config.rst @@ -1,5 +1,5 @@ tensorcircuit.cloud.config -================================================== +================================================================================ .. automodule:: tensorcircuit.cloud.config :members: :undoc-members: diff --git a/docs/source/api/cloud/local.rst b/docs/source/api/cloud/local.rst index c3ae767d..649f66d6 100644 --- a/docs/source/api/cloud/local.rst +++ b/docs/source/api/cloud/local.rst @@ -1,5 +1,5 @@ tensorcircuit.cloud.local -================================================== +================================================================================ .. automodule:: tensorcircuit.cloud.local :members: :undoc-members: diff --git a/docs/source/api/cloud/quafu_provider.rst b/docs/source/api/cloud/quafu_provider.rst index eae158af..06d15eee 100644 --- a/docs/source/api/cloud/quafu_provider.rst +++ b/docs/source/api/cloud/quafu_provider.rst @@ -1,5 +1,5 @@ tensorcircuit.cloud.quafu_provider -================================================== +================================================================================ .. automodule:: tensorcircuit.cloud.quafu_provider :members: :undoc-members: diff --git a/docs/source/api/cloud/tencent.rst b/docs/source/api/cloud/tencent.rst index b38a7183..431c3294 100644 --- a/docs/source/api/cloud/tencent.rst +++ b/docs/source/api/cloud/tencent.rst @@ -1,5 +1,5 @@ tensorcircuit.cloud.tencent -================================================== +================================================================================ .. automodule:: tensorcircuit.cloud.tencent :members: :undoc-members: diff --git a/docs/source/api/cloud/utils.rst b/docs/source/api/cloud/utils.rst index 190ea5a4..a7e33fe4 100644 --- a/docs/source/api/cloud/utils.rst +++ b/docs/source/api/cloud/utils.rst @@ -1,5 +1,5 @@ tensorcircuit.cloud.utils -================================================== +================================================================================ .. automodule:: tensorcircuit.cloud.utils :members: :undoc-members: diff --git a/docs/source/api/cloud/wrapper.rst b/docs/source/api/cloud/wrapper.rst index bac6a502..d65d3c07 100644 --- a/docs/source/api/cloud/wrapper.rst +++ b/docs/source/api/cloud/wrapper.rst @@ -1,5 +1,5 @@ tensorcircuit.cloud.wrapper -================================================== +================================================================================ .. automodule:: tensorcircuit.cloud.wrapper :members: :undoc-members: diff --git a/docs/source/api/compiler.rst b/docs/source/api/compiler.rst index c83bc2bd..745e4f29 100644 --- a/docs/source/api/compiler.rst +++ b/docs/source/api/compiler.rst @@ -1,5 +1,5 @@ -tensorcircuit.compiler -================================================== +tensorcircuit.compiler.rst +================================================================================ .. toctree:: compiler/composed_compiler.rst compiler/qiskit_compiler.rst diff --git a/docs/source/api/compiler/composed_compiler.rst b/docs/source/api/compiler/composed_compiler.rst index c856636d..07f7f23e 100644 --- a/docs/source/api/compiler/composed_compiler.rst +++ b/docs/source/api/compiler/composed_compiler.rst @@ -1,5 +1,5 @@ tensorcircuit.compiler.composed_compiler -================================================== +================================================================================ .. automodule:: tensorcircuit.compiler.composed_compiler :members: :undoc-members: diff --git a/docs/source/api/compiler/qiskit_compiler.rst b/docs/source/api/compiler/qiskit_compiler.rst index 369b4740..b46ae8dc 100644 --- a/docs/source/api/compiler/qiskit_compiler.rst +++ b/docs/source/api/compiler/qiskit_compiler.rst @@ -1,5 +1,5 @@ tensorcircuit.compiler.qiskit_compiler -================================================== +================================================================================ .. automodule:: tensorcircuit.compiler.qiskit_compiler :members: :undoc-members: diff --git a/docs/source/api/compiler/simple_compiler.rst b/docs/source/api/compiler/simple_compiler.rst index 0578d8e5..941efba5 100644 --- a/docs/source/api/compiler/simple_compiler.rst +++ b/docs/source/api/compiler/simple_compiler.rst @@ -1,5 +1,5 @@ tensorcircuit.compiler.simple_compiler -================================================== +================================================================================ .. automodule:: tensorcircuit.compiler.simple_compiler :members: :undoc-members: diff --git a/docs/source/api/cons.rst b/docs/source/api/cons.rst index 6e077058..d4f48ab6 100644 --- a/docs/source/api/cons.rst +++ b/docs/source/api/cons.rst @@ -1,5 +1,5 @@ tensorcircuit.cons -================================================== +================================================================================ .. automodule:: tensorcircuit.cons :members: :undoc-members: diff --git a/docs/source/api/densitymatrix.rst b/docs/source/api/densitymatrix.rst index 571647d2..274dc323 100644 --- a/docs/source/api/densitymatrix.rst +++ b/docs/source/api/densitymatrix.rst @@ -1,5 +1,5 @@ tensorcircuit.densitymatrix -================================================== +================================================================================ .. automodule:: tensorcircuit.densitymatrix :members: :undoc-members: diff --git a/docs/source/api/experimental.rst b/docs/source/api/experimental.rst index 16761d4c..dbdfa068 100644 --- a/docs/source/api/experimental.rst +++ b/docs/source/api/experimental.rst @@ -1,5 +1,5 @@ tensorcircuit.experimental -================================================== +================================================================================ .. automodule:: tensorcircuit.experimental :members: :undoc-members: diff --git a/docs/source/api/gates.rst b/docs/source/api/gates.rst index 8f72fbcc..71428553 100644 --- a/docs/source/api/gates.rst +++ b/docs/source/api/gates.rst @@ -1,5 +1,5 @@ tensorcircuit.gates -================================================== +================================================================================ .. automodule:: tensorcircuit.gates :members: :undoc-members: diff --git a/docs/source/api/interfaces.rst b/docs/source/api/interfaces.rst index 6371d824..1b468a27 100644 --- a/docs/source/api/interfaces.rst +++ b/docs/source/api/interfaces.rst @@ -1,5 +1,5 @@ -tensorcircuit.interfaces -================================================== +tensorcircuit.interfaces.rst +================================================================================ .. toctree:: interfaces/numpy.rst interfaces/scipy.rst diff --git a/docs/source/api/interfaces/numpy.rst b/docs/source/api/interfaces/numpy.rst index 5df8b0bb..5271b873 100644 --- a/docs/source/api/interfaces/numpy.rst +++ b/docs/source/api/interfaces/numpy.rst @@ -1,5 +1,5 @@ tensorcircuit.interfaces.numpy -================================================== +================================================================================ .. automodule:: tensorcircuit.interfaces.numpy :members: :undoc-members: diff --git a/docs/source/api/interfaces/scipy.rst b/docs/source/api/interfaces/scipy.rst index c263bd93..284dcbe9 100644 --- a/docs/source/api/interfaces/scipy.rst +++ b/docs/source/api/interfaces/scipy.rst @@ -1,5 +1,5 @@ tensorcircuit.interfaces.scipy -================================================== +================================================================================ .. automodule:: tensorcircuit.interfaces.scipy :members: :undoc-members: diff --git a/docs/source/api/interfaces/tensorflow.rst b/docs/source/api/interfaces/tensorflow.rst index e02981b9..8ac1a344 100644 --- a/docs/source/api/interfaces/tensorflow.rst +++ b/docs/source/api/interfaces/tensorflow.rst @@ -1,5 +1,5 @@ tensorcircuit.interfaces.tensorflow -================================================== +================================================================================ .. automodule:: tensorcircuit.interfaces.tensorflow :members: :undoc-members: diff --git a/docs/source/api/interfaces/tensortrans.rst b/docs/source/api/interfaces/tensortrans.rst index b666e177..a92b166d 100644 --- a/docs/source/api/interfaces/tensortrans.rst +++ b/docs/source/api/interfaces/tensortrans.rst @@ -1,5 +1,5 @@ tensorcircuit.interfaces.tensortrans -================================================== +================================================================================ .. automodule:: tensorcircuit.interfaces.tensortrans :members: :undoc-members: diff --git a/docs/source/api/interfaces/torch.rst b/docs/source/api/interfaces/torch.rst index 28090f54..5f7e3dea 100644 --- a/docs/source/api/interfaces/torch.rst +++ b/docs/source/api/interfaces/torch.rst @@ -1,5 +1,5 @@ tensorcircuit.interfaces.torch -================================================== +================================================================================ .. automodule:: tensorcircuit.interfaces.torch :members: :undoc-members: diff --git a/docs/source/api/keras.rst b/docs/source/api/keras.rst index 5ed313b2..9f2e4860 100644 --- a/docs/source/api/keras.rst +++ b/docs/source/api/keras.rst @@ -1,5 +1,5 @@ tensorcircuit.keras -================================================== +================================================================================ .. automodule:: tensorcircuit.keras :members: :undoc-members: diff --git a/docs/source/api/mps_base.rst b/docs/source/api/mps_base.rst index caf11b36..039da259 100644 --- a/docs/source/api/mps_base.rst +++ b/docs/source/api/mps_base.rst @@ -1,5 +1,5 @@ tensorcircuit.mps_base -================================================== +================================================================================ .. automodule:: tensorcircuit.mps_base :members: :undoc-members: diff --git a/docs/source/api/mpscircuit.rst b/docs/source/api/mpscircuit.rst index a4de8119..58a68f56 100644 --- a/docs/source/api/mpscircuit.rst +++ b/docs/source/api/mpscircuit.rst @@ -1,5 +1,5 @@ tensorcircuit.mpscircuit -================================================== +================================================================================ .. automodule:: tensorcircuit.mpscircuit :members: :undoc-members: diff --git a/docs/source/api/noisemodel.rst b/docs/source/api/noisemodel.rst index ab152857..4930d8f0 100644 --- a/docs/source/api/noisemodel.rst +++ b/docs/source/api/noisemodel.rst @@ -1,5 +1,5 @@ tensorcircuit.noisemodel -================================================== +================================================================================ .. automodule:: tensorcircuit.noisemodel :members: :undoc-members: diff --git a/docs/source/api/quantum.rst b/docs/source/api/quantum.rst index c9d13b6b..f25c8a5d 100644 --- a/docs/source/api/quantum.rst +++ b/docs/source/api/quantum.rst @@ -1,5 +1,5 @@ tensorcircuit.quantum -================================================== +================================================================================ .. automodule:: tensorcircuit.quantum :members: :undoc-members: diff --git a/docs/source/api/results.rst b/docs/source/api/results.rst index 0bea95e7..e5363756 100644 --- a/docs/source/api/results.rst +++ b/docs/source/api/results.rst @@ -1,5 +1,6 @@ -tensorcircuit.results -================================================== +tensorcircuit.results.rst +================================================================================ .. toctree:: results/counts.rst + results/qem.rst results/readout_mitigation.rst \ No newline at end of file diff --git a/docs/source/api/results/counts.rst b/docs/source/api/results/counts.rst index 7542d722..7f145206 100644 --- a/docs/source/api/results/counts.rst +++ b/docs/source/api/results/counts.rst @@ -1,5 +1,5 @@ tensorcircuit.results.counts -================================================== +================================================================================ .. automodule:: tensorcircuit.results.counts :members: :undoc-members: diff --git a/docs/source/api/results/qem.rst b/docs/source/api/results/qem.rst new file mode 100644 index 00000000..9b5abe3a --- /dev/null +++ b/docs/source/api/results/qem.rst @@ -0,0 +1,5 @@ +tensorcircuit.results.qem.rst +================================================================================ +.. toctree:: + qem/benchmark_circuits.rst + qem/qem_methods.rst \ No newline at end of file diff --git a/docs/source/api/results/qem/benchmark_circuits.rst b/docs/source/api/results/qem/benchmark_circuits.rst new file mode 100644 index 00000000..3c339884 --- /dev/null +++ b/docs/source/api/results/qem/benchmark_circuits.rst @@ -0,0 +1,7 @@ +tensorcircuit.results.qem.benchmark_circuits +================================================================================ +.. automodule:: tensorcircuit.results.qem.benchmark_circuits + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/results/qem/qem_methods.rst b/docs/source/api/results/qem/qem_methods.rst new file mode 100644 index 00000000..a95bdf95 --- /dev/null +++ b/docs/source/api/results/qem/qem_methods.rst @@ -0,0 +1,7 @@ +tensorcircuit.results.qem.qem_methods +================================================================================ +.. automodule:: tensorcircuit.results.qem.qem_methods + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/results/readout_mitigation.rst b/docs/source/api/results/readout_mitigation.rst index 0d9baa3d..325fe21a 100644 --- a/docs/source/api/results/readout_mitigation.rst +++ b/docs/source/api/results/readout_mitigation.rst @@ -1,5 +1,5 @@ tensorcircuit.results.readout_mitigation -================================================== +================================================================================ .. automodule:: tensorcircuit.results.readout_mitigation :members: :undoc-members: diff --git a/docs/source/api/simplify.rst b/docs/source/api/simplify.rst index c1816c31..22833f9f 100644 --- a/docs/source/api/simplify.rst +++ b/docs/source/api/simplify.rst @@ -1,5 +1,5 @@ tensorcircuit.simplify -================================================== +================================================================================ .. automodule:: tensorcircuit.simplify :members: :undoc-members: diff --git a/docs/source/api/templates.rst b/docs/source/api/templates.rst index 330fa6db..a79b769d 100644 --- a/docs/source/api/templates.rst +++ b/docs/source/api/templates.rst @@ -1,5 +1,5 @@ -tensorcircuit.templates -================================================== +tensorcircuit.templates.rst +================================================================================ .. toctree:: templates/blocks.rst templates/chems.rst diff --git a/docs/source/api/templates/blocks.rst b/docs/source/api/templates/blocks.rst index 0c88f3d9..b7a0945a 100644 --- a/docs/source/api/templates/blocks.rst +++ b/docs/source/api/templates/blocks.rst @@ -1,5 +1,5 @@ tensorcircuit.templates.blocks -================================================== +================================================================================ .. automodule:: tensorcircuit.templates.blocks :members: :undoc-members: diff --git a/docs/source/api/templates/chems.rst b/docs/source/api/templates/chems.rst index 8a31f9d3..d06d9e39 100644 --- a/docs/source/api/templates/chems.rst +++ b/docs/source/api/templates/chems.rst @@ -1,5 +1,5 @@ tensorcircuit.templates.chems -================================================== +================================================================================ .. automodule:: tensorcircuit.templates.chems :members: :undoc-members: diff --git a/docs/source/api/templates/dataset.rst b/docs/source/api/templates/dataset.rst index 36b9e510..aa6cdfa7 100644 --- a/docs/source/api/templates/dataset.rst +++ b/docs/source/api/templates/dataset.rst @@ -1,5 +1,5 @@ tensorcircuit.templates.dataset -================================================== +================================================================================ .. automodule:: tensorcircuit.templates.dataset :members: :undoc-members: diff --git a/docs/source/api/templates/ensemble.rst b/docs/source/api/templates/ensemble.rst index c7dd6f85..fc086a35 100644 --- a/docs/source/api/templates/ensemble.rst +++ b/docs/source/api/templates/ensemble.rst @@ -1,5 +1,5 @@ tensorcircuit.templates.ensemble -================================================== +================================================================================ .. automodule:: tensorcircuit.templates.ensemble :members: :undoc-members: diff --git a/docs/source/api/templates/graphs.rst b/docs/source/api/templates/graphs.rst index 0a2141f0..b86ab51e 100644 --- a/docs/source/api/templates/graphs.rst +++ b/docs/source/api/templates/graphs.rst @@ -1,5 +1,5 @@ tensorcircuit.templates.graphs -================================================== +================================================================================ .. automodule:: tensorcircuit.templates.graphs :members: :undoc-members: diff --git a/docs/source/api/templates/measurements.rst b/docs/source/api/templates/measurements.rst index 2113f03b..7e05673c 100644 --- a/docs/source/api/templates/measurements.rst +++ b/docs/source/api/templates/measurements.rst @@ -1,5 +1,5 @@ tensorcircuit.templates.measurements -================================================== +================================================================================ .. automodule:: tensorcircuit.templates.measurements :members: :undoc-members: diff --git a/docs/source/api/torchnn.rst b/docs/source/api/torchnn.rst index 5a5b2775..9f9c6598 100644 --- a/docs/source/api/torchnn.rst +++ b/docs/source/api/torchnn.rst @@ -1,5 +1,5 @@ tensorcircuit.torchnn -================================================== +================================================================================ .. automodule:: tensorcircuit.torchnn :members: :undoc-members: diff --git a/docs/source/api/translation.rst b/docs/source/api/translation.rst index a33667f7..f320c909 100644 --- a/docs/source/api/translation.rst +++ b/docs/source/api/translation.rst @@ -1,5 +1,5 @@ tensorcircuit.translation -================================================== +================================================================================ .. automodule:: tensorcircuit.translation :members: :undoc-members: diff --git a/docs/source/api/utils.rst b/docs/source/api/utils.rst index 3fa45319..93ee9496 100644 --- a/docs/source/api/utils.rst +++ b/docs/source/api/utils.rst @@ -1,5 +1,5 @@ tensorcircuit.utils -================================================== +================================================================================ .. automodule:: tensorcircuit.utils :members: :undoc-members: diff --git a/docs/source/api/vis.rst b/docs/source/api/vis.rst index f27680f1..2cdc89e2 100644 --- a/docs/source/api/vis.rst +++ b/docs/source/api/vis.rst @@ -1,5 +1,5 @@ tensorcircuit.vis -================================================== +================================================================================ .. automodule:: tensorcircuit.vis :members: :undoc-members: diff --git a/docs/source/generate_rst.py b/docs/source/generate_rst.py index 60fcf0de..7bcb5d99 100644 --- a/docs/source/generate_rst.py +++ b/docs/source/generate_rst.py @@ -5,7 +5,7 @@ class RSTGenerator: - title_line = "=" * 50 + title_line = "=" * 80 toctree = ".. toctree::\n {}" automodule = ".. automodule:: {}\n :members:\n :undoc-members:\n :show-inheritance:\n :inherited-members:" @@ -21,11 +21,14 @@ def __init__( def cleanup(self): if os.path.exists("modules.rst"): os.remove("modules.rst") - shutil.rmtree(self.dfolder) + try: + shutil.rmtree(self.dfolder) + except FileNotFoundError: + pass os.makedirs(self.dfolder) def write(self, path, content): - if type(content) == type([]): + if isinstance(content, list): content = "\n".join(content) with open(path, "w") as f: @@ -33,70 +36,68 @@ def write(self, path, content): print(f"Finish writing {path}") - def single_file_module(self): - """Process the module in the self.pfolder/*.py""" - - for module_name in glob.glob(pj(self.pfolder, "*.py")): + def _file_generate(self, package_parents): + file_list = [] + for module_name in glob.glob(pj(self.pfolder, *package_parents, "*.py")): module_name = os.path.basename(module_name)[:-3] if module_name in self.ingnored_modules: continue - rst_file = pj(self.dfolder, f"{module_name}.rst") + rst_file = pj(self.dfolder, *package_parents, f"{module_name}.rst") + name = f"{self.name}" + for n in package_parents: + name += f".{n}" + name += f".{module_name}" content = [ - f"{self.name}.{module_name}", + name, self.title_line, - self.automodule.format(f"{self.name}.{module_name}"), + self.automodule.format(name), ] - self.write(rst_file, content) - self.tree[rst_file] = [] - - def subdir_files_module(self): - """Write the rst files for modules with subdir or files""" - for subdir in glob.glob(pj(self.pfolder, "*/")): + if not package_parents: + upper = self.dfolder + else: + upper = package_parents[-1] + file_list.append(upper + f"/{module_name}.rst") + for subdir in glob.glob(pj(self.pfolder, *package_parents, "*/")): if "_" in subdir: continue - subdir = os.path.basename(os.path.normpath(subdir)) - os.makedirs(pj(self.dfolder, subdir), exist_ok=True) - rst_file = pj(self.dfolder, f"{subdir}.rst") - self.tree[rst_file] = [] - - for module_name in glob.glob(pj(self.pfolder, subdir, f"*.py")): - module_name = os.path.basename(module_name)[:-3] - if module_name in self.ingnored_modules: - continue - - content = [ - f"{self.name}.{subdir}.{module_name}", - self.title_line, - self.automodule.format(f"{self.name}.{subdir}.{module_name}"), - ] - - self.write(pj(self.dfolder, subdir, f"{module_name}.rst"), content) - self.tree[rst_file].append(f"{subdir}/{module_name}.rst") - + os.makedirs(pj(self.dfolder, *package_parents, subdir), exist_ok=True) + rst_file = pj(self.dfolder, *package_parents, f"{subdir}.rst") + subdir_filelist = self._file_generate(package_parents + [subdir]) + + name = f"{self.name}" + for n in package_parents: + name += f".{n}" + name += f".{subdir}.rst" content = [ - f"{self.name}.{subdir}", + name, self.title_line, - self.toctree.format("\n ".join(sorted(self.tree[rst_file]))), + self.toctree.format("\n ".join(sorted(subdir_filelist))), ] self.write(rst_file, content) - def modules_file(self): + if not package_parents: + upper = self.dfolder + else: + upper = package_parents[-1] + file_list.append(upper + f"/{subdir}.rst") + return file_list + + def modules_file(self, file_list): """Write the modules.rst""" content = [ self.name, self.title_line, - self.toctree.format("\n ".join(sorted(self.tree.keys()))), + self.toctree.format("\n ".join(sorted(file_list))), ] self.write("modules.rst", content) def start(self): self.cleanup() - self.single_file_module() - self.subdir_files_module() - self.modules_file() + file_list = self._file_generate([]) + self.modules_file(file_list) if __name__ == "__main__": diff --git a/docs/source/modules.rst b/docs/source/modules.rst index 280c7584..67e7425e 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -1,5 +1,5 @@ tensorcircuit -================================================== +================================================================================ .. toctree:: ./api/about.rst ./api/abstractcircuit.rst diff --git a/docs/source/modules.rst.backup b/docs/source/modules.rst.backup index 28261e24..280c7584 100644 --- a/docs/source/modules.rst.backup +++ b/docs/source/modules.rst.backup @@ -1,200 +1,29 @@ -tensorcircuit API -===================== - +tensorcircuit +================================================== .. toctree:: - :maxdepth: 4 - - -tensorcircuit.backends module ------------------------------------- - -.. automodule:: tensorcircuit.backends - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.backends.backend_factory module -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. automodule:: tensorcircuit.backends.backend_factory - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.backends.jax_backend module -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. automodule:: tensorcircuit.backends.jax_backend - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.backends.numpy_backend module -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. automodule:: tensorcircuit.backends.numpy_backend - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.backends.pytorch_backend module -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. automodule:: tensorcircuit.backends.pytorch_backend - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.backends.tensorflow_backend module -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. automodule:: tensorcircuit.backends.tensorflow_backend - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.channels module -------------------------------------- - -.. automodule:: tensorcircuit.channels - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.circuit module -------------------------------------- - -.. automodule:: tensorcircuit.circuit - :members: - :undoc-members: - :show-inheritance: - - -tensorcircuit.cons module -------------------------------------- - -.. automodule:: tensorcircuit.cons - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.densitymatrix module -------------------------------------- - -.. automodule:: tensorcircuit.densitymatrix - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.densitymatrix2 module -------------------------------------- - -.. automodule:: tensorcircuit.densitymatrix2 - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.experimental module -------------------------------------- - -.. automodule:: tensorcircuit.experimental - :members: - :undoc-members: - :show-inheritance: - - -tensorcircuit.gates module ---------------------------------- - -.. automodule:: tensorcircuit.gates - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.interfaces module ---------------------------------- - -.. automodule:: tensorcircuit.interfaces - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.keras module ---------------------------------- - -.. automodule:: tensorcircuit.keras - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.mpscircuit module ---------------------------------- - -.. automodule:: tensorcircuit.mpscircuit - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.quantum module ---------------------------------- - -.. automodule:: tensorcircuit.quantum - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.simplify module ---------------------------------- - -.. automodule:: tensorcircuit.simplify - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.templates module ------------------------------------- - -.. automodule:: tensorcircuit.templates - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.templates.blocks module -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. automodule:: tensorcircuit.templates.blocks - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.templates.graphs module -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. automodule:: tensorcircuit.templates.graphs - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.templates.measurements module -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. automodule:: tensorcircuit.templates.measurements - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.utils module ---------------------------------- - -.. automodule:: tensorcircuit.utils - :members: - :undoc-members: - :show-inheritance: - -tensorcircuit.vis module ---------------------------------- - -.. automodule:: tensorcircuit.vis - :members: - :undoc-members: - :show-inheritance: \ No newline at end of file + ./api/about.rst + ./api/abstractcircuit.rst + ./api/applications.rst + ./api/backends.rst + ./api/basecircuit.rst + ./api/channels.rst + ./api/circuit.rst + ./api/cloud.rst + ./api/compiler.rst + ./api/cons.rst + ./api/densitymatrix.rst + ./api/experimental.rst + ./api/gates.rst + ./api/interfaces.rst + ./api/keras.rst + ./api/mps_base.rst + ./api/mpscircuit.rst + ./api/noisemodel.rst + ./api/quantum.rst + ./api/results.rst + ./api/simplify.rst + ./api/templates.rst + ./api/torchnn.rst + ./api/translation.rst + ./api/utils.rst + ./api/vis.rst \ No newline at end of file diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 09cacbba..12363bef 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -4,3 +4,4 @@ qiskit-nature torch jupyter mthree==1.1.0 +mitiq From c0b4e1c59598dd4a6473aa141759f0acdbc63304 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Jun 2023 15:09:49 +0800 Subject: [PATCH 488/725] lazy load qem to avoid mitiq installation --- setup.py | 2 +- tensorcircuit/results/__init__.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 6495eed6..6e372719 100644 --- a/setup.py +++ b/setup.py @@ -11,7 +11,7 @@ version=__version__, author=__author__, author_email="shixinzhang@tencent.com", - description="Quantum circuits on top of tensor network", + description="High performance unified quantum computing framework for the NISQ era", long_description=long_description, long_description_content_type="text/markdown", url="https://github.com/tencent-quantum-lab/tensorcircuit", diff --git a/tensorcircuit/results/__init__.py b/tensorcircuit/results/__init__.py index c7cf260f..7a953ae9 100644 --- a/tensorcircuit/results/__init__.py +++ b/tensorcircuit/results/__init__.py @@ -1,5 +1,4 @@ from . import counts -from . import qem from . import readout_mitigation rem = readout_mitigation # alias From d375d2840e1b05b525ad368cd4f8bceb0b558dac Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Jun 2023 15:18:32 +0800 Subject: [PATCH 489/725] reshape reqs --- requirements/requirements-extra.txt | 1 + requirements/requirements-rtd.txt | 1 + requirements/requirements.txt | 1 - 3 files changed, 2 insertions(+), 1 deletion(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 12363bef..bc98045e 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,6 +1,7 @@ # extra dependencies for ci qiskit qiskit-nature +cirq torch jupyter mthree==1.1.0 diff --git a/requirements/requirements-rtd.txt b/requirements/requirements-rtd.txt index 8e93c419..7d5b80d1 100644 --- a/requirements/requirements-rtd.txt +++ b/requirements/requirements-rtd.txt @@ -3,6 +3,7 @@ scipy cirq tensorflow tensornetwork +mitiq graphviz networkx jax diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 69ddfea0..9532163a 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,6 +1,5 @@ numpy scipy -cirq==0.13.1 tensorflow==2.7 tensornetwork graphviz From bccaa5bbcfd977d7de15498c05df900cc84408c6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Jun 2023 16:11:36 +0800 Subject: [PATCH 490/725] update readme --- README.md | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/README.md b/README.md index 974b7198..ade11d2d 100644 --- a/README.md +++ b/README.md @@ -121,6 +121,56 @@ We also have [Docker support](/docker). - API design: quantum for humans, less code, more power +- Batteries included + +
+ Tons of amazing features and built in tools for research (click for details) + + - Support **super large circuit simulation** using tensor network engine. + + - Support **noisy simulation** with both Monte Carlo and density matrix (tensor network powered) modes. + + - Support **approximate simulation** with MPS-TEBD modes. + + - Support **analog/digital hybrid simulation** (time dependent Hamiltonian evolution, **pulse** level simulation) with neural ode modes. + + - Support **qudits simulation**. + + - Highly customizable **noise model** with gate error and scalable readout error. + + - Support for **non-unitary** gate and post-selection simulation. + + - Support **real quantum devices access** from different providers. + + - **Scalable readout error mitigation** native to both bitstring and expectation level with automatic qubit mapping consideration. + + - **Advanced quantum error mitigation methods** and pipelines such as ZNE, DD, RC, etc. + + - Support **MPS/MPO** as representations for input states, quantum gates and observables to be measured. + + - Support **vectorized parallelism** on circuit inputs, circuit parameters, circuit structures, circuit measurements and these vectorization can be nested. + + - Gradients can be obtained with both **automatic differenation** and parameter shift (vmap accelerated) modes. + + - **Machine learning interface/layer/model** abstraction in both TensorFlow and PyTorch for both numerical simulation and real QPU experiments. + + - Circuit sampling supports both final state sampling and perfect sampling from tensor networks. + + - Light cone reduction support for local expectation calculation. + + - Highly customizable tensor network contraction path finder with opteinsum interface. + + - Observables are supported in measurement, sparse matrix, dense matrix and MPO format. + + - Super fast weighted sum Pauli string Hamiltonian matrix generation. + + - Reusable common circuit/measurement/problem templates and patterns. + + - SOTA quantum algorithm and model implementations. + + - Support hybrid workflows and pipelines with CPU/GPU/QPU hardware from local/cloud/hpc resources using tf/torch/jax/cupy/numpy frameoworks all at the same time. + +
## Contributing From afc36a163bf0a22ac572e589d2e56c5131d74d17 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 8 Jun 2023 16:23:59 +0800 Subject: [PATCH 491/725] update docs --- docs/source/api/applications.rst | 2 +- docs/source/api/backends.rst | 2 +- docs/source/api/cloud.rst | 2 +- docs/source/api/compiler.rst | 2 +- docs/source/api/interfaces.rst | 2 +- docs/source/api/results.rst | 2 +- docs/source/api/results/qem.rst | 2 +- docs/source/api/templates.rst | 2 +- docs/source/generate_rst.py | 2 +- tensorcircuit/results/qem/qem_methods.py | 4 ++-- 10 files changed, 11 insertions(+), 11 deletions(-) diff --git a/docs/source/api/applications.rst b/docs/source/api/applications.rst index 8682f5b4..2ecae939 100644 --- a/docs/source/api/applications.rst +++ b/docs/source/api/applications.rst @@ -1,4 +1,4 @@ -tensorcircuit.applications.rst +tensorcircuit.applications ================================================================================ .. toctree:: applications/dqas.rst diff --git a/docs/source/api/backends.rst b/docs/source/api/backends.rst index 777a69ab..cfc63bec 100644 --- a/docs/source/api/backends.rst +++ b/docs/source/api/backends.rst @@ -1,4 +1,4 @@ -tensorcircuit.backends.rst +tensorcircuit.backends ================================================================================ .. toctree:: backends/backend_factory.rst diff --git a/docs/source/api/cloud.rst b/docs/source/api/cloud.rst index d94d1412..be2faf7d 100644 --- a/docs/source/api/cloud.rst +++ b/docs/source/api/cloud.rst @@ -1,4 +1,4 @@ -tensorcircuit.cloud.rst +tensorcircuit.cloud ================================================================================ .. toctree:: cloud/abstraction.rst diff --git a/docs/source/api/compiler.rst b/docs/source/api/compiler.rst index 745e4f29..cb47419f 100644 --- a/docs/source/api/compiler.rst +++ b/docs/source/api/compiler.rst @@ -1,4 +1,4 @@ -tensorcircuit.compiler.rst +tensorcircuit.compiler ================================================================================ .. toctree:: compiler/composed_compiler.rst diff --git a/docs/source/api/interfaces.rst b/docs/source/api/interfaces.rst index 1b468a27..5b234d0f 100644 --- a/docs/source/api/interfaces.rst +++ b/docs/source/api/interfaces.rst @@ -1,4 +1,4 @@ -tensorcircuit.interfaces.rst +tensorcircuit.interfaces ================================================================================ .. toctree:: interfaces/numpy.rst diff --git a/docs/source/api/results.rst b/docs/source/api/results.rst index e5363756..2e60327c 100644 --- a/docs/source/api/results.rst +++ b/docs/source/api/results.rst @@ -1,4 +1,4 @@ -tensorcircuit.results.rst +tensorcircuit.results ================================================================================ .. toctree:: results/counts.rst diff --git a/docs/source/api/results/qem.rst b/docs/source/api/results/qem.rst index 9b5abe3a..160098f7 100644 --- a/docs/source/api/results/qem.rst +++ b/docs/source/api/results/qem.rst @@ -1,4 +1,4 @@ -tensorcircuit.results.qem.rst +tensorcircuit.results.qem ================================================================================ .. toctree:: qem/benchmark_circuits.rst diff --git a/docs/source/api/templates.rst b/docs/source/api/templates.rst index a79b769d..897ff36c 100644 --- a/docs/source/api/templates.rst +++ b/docs/source/api/templates.rst @@ -1,4 +1,4 @@ -tensorcircuit.templates.rst +tensorcircuit.templates ================================================================================ .. toctree:: templates/blocks.rst diff --git a/docs/source/generate_rst.py b/docs/source/generate_rst.py index 7bcb5d99..9b112c46 100644 --- a/docs/source/generate_rst.py +++ b/docs/source/generate_rst.py @@ -70,7 +70,7 @@ def _file_generate(self, package_parents): name = f"{self.name}" for n in package_parents: name += f".{n}" - name += f".{subdir}.rst" + name += f".{subdir}" content = [ name, self.title_line, diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py index 7dda7dfe..167b9b7f 100644 --- a/tensorcircuit/results/qem/qem_methods.py +++ b/tensorcircuit/results/qem/qem_methods.py @@ -166,8 +166,8 @@ def apply_dd( :param num_trials: The number of independent experiments to average over, defaults to 1 :type num_trials: int, optional :param full_output: If ``False`` only the mitigated expectation value is - returned. If ``True`` a dictionary containing all DD data is - returned too, defaults to False + returned. If ``True`` a dictionary containing all DD data is + returned too, defaults to False :type full_output: bool, optional :param ig_idle_qubit: ignore the DD sequences that added to unused qubits, defaults to True :type ig_idle_qubit: bool, optional From e7e8ecc216c70a2d2ceee8bc83678c05d825c154 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 9 Jun 2023 10:42:54 +0800 Subject: [PATCH 492/725] further fix rtd issue --- .readthedocs.yaml | 24 +++++++++++++++++ requirements/requirements-rtd.txt | 1 - tensorcircuit/results/qem/qem_methods.py | 34 +++++++++++++++--------- 3 files changed, 45 insertions(+), 14 deletions(-) create mode 100644 .readthedocs.yaml diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 00000000..65fcea8e --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,24 @@ +# .readthedocs.yaml +# Read the Docs configuration file +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +formats: + - pdf + +# Set the version of Python and other tools you might need +build: + os: ubuntu-20.04 + tools: + python: "3.8" + +# Build documentation in the docs/ directory with Sphinx +sphinx: + configuration: docs/conf.py +# We recommend specifying your dependencies to enable reproducible builds: +# https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html +python: + install: + - requirements: requirements/requirements-rtd.txt diff --git a/requirements/requirements-rtd.txt b/requirements/requirements-rtd.txt index 7d5b80d1..8e93c419 100644 --- a/requirements/requirements-rtd.txt +++ b/requirements/requirements-rtd.txt @@ -3,7 +3,6 @@ scipy cirq tensorflow tensornetwork -mitiq graphviz networkx jax diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py index 167b9b7f..0dafdf15 100644 --- a/tensorcircuit/results/qem/qem_methods.py +++ b/tensorcircuit/results/qem/qem_methods.py @@ -9,27 +9,36 @@ import collections import operator from random import choice +import logging + +logger = logging.getLogger(__name__) import numpy as np -from mitiq import zne, ddd -from mitiq.zne.inference import Factory -from mitiq.zne.scaling import fold_gates_at_random import cirq +try: + from mitiq import zne, ddd + from mitiq.zne.scaling import fold_gates_at_random + + zne_option = zne + dd_option = ddd +except ModuleNotFoundError: + logger.warning("mitiq is not installed, please ``pip install mitiq`` first") + zne_option = None + dd_option = None + from ... import Circuit from ... import backend, gates from ...compiler import simple_compiler Gate = gates.Gate -zne_option = zne - def apply_zne( circuit: Any, executor: Callable[[Union[Any, Sequence[Any]]], Any], - factory: Optional[Factory], - scale_noise: Callable[[Any, float], Any] = fold_gates_at_random, + factory: Optional[Any], + scale_noise: Optional[Callable[[Any, float], Any]] = None, num_to_average: int = 1, **kws: Any, ) -> Any: @@ -50,6 +59,8 @@ def apply_zne( :return: Mitigated average value by ZNE. :rtype: float """ + if scale_noise is None: + scale_noise = fold_gates_at_random def executortc(c): # type: ignore c = Circuit.from_qiskit(c, c.num_qubits) @@ -132,16 +143,11 @@ def add_dd(c: Any, rule: Callable[[int], Any]) -> Any: return circuit_dd -dd_option = ddd - -# pylint: disable=dangerous-default-value - - def apply_dd( circuit: Any, executor: Callable[[Any], Any], rule: Union[Callable[[int], Any], List[str]], - rule_args: Dict[str, Any] = {}, + rule_args: Optional[Dict[str, Any]] = None, num_trials: int = 1, full_output: bool = False, ignore_idle_qubit: bool = True, @@ -178,6 +184,8 @@ def apply_dd( :return: mitigated expectation value or mitigated expectation value and DD circuit information :rtype: Union[float, Tuple[float, Dict[str, Any]]] """ + if rule_args is None: + rule_args = {} def dd_rule(slack_length: int, spacing: int = -1) -> Any: """ From 2fc8808bff0fb89c4050390ff21c7d04ed76a548 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 9 Jun 2023 11:10:38 +0800 Subject: [PATCH 493/725] rtd fix --- .readthedocs.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 65fcea8e..2acb1049 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -16,7 +16,7 @@ build: # Build documentation in the docs/ directory with Sphinx sphinx: - configuration: docs/conf.py + configuration: docs/source/conf.py # We recommend specifying your dependencies to enable reproducible builds: # https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html python: From 74c7a96048f86df4ea78fe865461d97a041e0d3c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 9 Jun 2023 11:29:00 +0800 Subject: [PATCH 494/725] mitiq req out for benchmarkcircuit file --- .../results/qem/benchmark_circuits.py | 25 ++++++++++++------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/tensorcircuit/results/qem/benchmark_circuits.py b/tensorcircuit/results/qem/benchmark_circuits.py index 8097c784..9c6023c9 100644 --- a/tensorcircuit/results/qem/benchmark_circuits.py +++ b/tensorcircuit/results/qem/benchmark_circuits.py @@ -3,18 +3,25 @@ """ from typing import Any, List, Dict, Tuple +import logging + +logger = logging.getLogger(__name__) -from mitiq.benchmarks import ( - generate_ghz_circuit, - generate_mirror_circuit, - generate_rb_circuits, - generate_w_circuit, -) -from mitiq.interface import ( - convert_from_mitiq, -) import networkx as nx +try: + from mitiq.benchmarks import ( + generate_ghz_circuit, + generate_mirror_circuit, + generate_rb_circuits, + generate_w_circuit, + ) + from mitiq.interface import ( + convert_from_mitiq, + ) +except ModuleNotFoundError: + logger.warning("mitiq is not installed, please ``pip install mitiq`` first") + from ... import Circuit From cac74977f628e6e623bd34af95454fe55af399c2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 9 Jun 2023 13:48:25 +0800 Subject: [PATCH 495/725] version0.10.0 --- CHANGELOG.md | 2 ++ tensorcircuit/__init__.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0a1f99b9..f3c89ff5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.10.0 + ### Added - `c.measure_instruction(*qubits)` now supports multiple ints specified at the same time diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 558439de..e0020972 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.9.1" +__version__ = "0.10.0" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From 29c06c381789b6ab2ec1b6909a6da6088e222c17 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 10 Jun 2023 11:53:05 +0800 Subject: [PATCH 496/725] new dockerfile --- docker/Dockerfile_v2 | 37 +++++++++++++++++++ docker/README.md | 17 ++++----- requirements/requirements-docker-v2.txt | 47 +++++++++++++++++++++++++ 3 files changed, 93 insertions(+), 8 deletions(-) create mode 100644 docker/Dockerfile_v2 create mode 100644 requirements/requirements-docker-v2.txt diff --git a/docker/Dockerfile_v2 b/docker/Dockerfile_v2 new file mode 100644 index 00000000..9f2f4523 --- /dev/null +++ b/docker/Dockerfile_v2 @@ -0,0 +1,37 @@ +FROM nvidia/cuda:11.7.1-cudnn8-devel-ubuntu20.04 +# nvidia/cuda:11.6.0-cudnn8-devel-ubuntu20.04 + +RUN apt update && DEBIAN_FRONTEND=noninteractive apt install -y \ + wget \ + git \ + vim \ + pandoc + +RUN wget -q -P /tmp \ + https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \ + && bash /tmp/Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda \ + && rm /tmp/Miniconda3-latest-Linux-x86_64.sh + +ENV PATH="/opt/conda/bin:$PATH" + +RUN conda install -y \ + pip \ + python=3.10 + +COPY requirements/requirements-docker-v2.txt /requirements-docker-v2.txt + +# RUN pip install -r /requirements-docker-v2.txt -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html +RUN pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -r /requirements-docker-v2.txt -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html + +# RUN pip install nvidia-cudnn-cu11==8.6.0.163 ray +RUN pip install -i https://pypi.tuna.tsinghua.edu.cn/simple nvidia-cudnn-cu11==8.6.0.163 ray + +RUN pip install tensorcircuit + +# requirements conflict for ray +# jax must have cudnn>8.6 otherwise fail when init array on gpu, +# while torch insists cudnn 8.5 in setup but 8.6 can also work for torch + +RUN echo export TF_CPP_MIN_LOG_LEVEL=3 >> ~/.bashrc + +CMD ["/bin/bash"] \ No newline at end of file diff --git a/docker/README.md b/docker/README.md index c9940635..1c5aea0d 100644 --- a/docker/README.md +++ b/docker/README.md @@ -4,6 +4,12 @@ Run the following command to build the docker for tensorcircuit at parent path: sudo docker build . -f docker/Dockerfile -t tensorcircuit ``` +Since v0.10 we introduce new docker env based on ubuntu20.04+cuda11.7+py3.10 (+ pip installed tensorcircuit package), build the new docker use + +```bash +sudo docker build . -f docker/Dockerfile_v2 -t tensorcircuit +``` + One can also pull the [official image](https://hub.docker.com/repository/docker/tensorcircuit/tensorcircuit) from DockerHub as ```bash @@ -15,14 +21,9 @@ Run the docker container by the following command: ```bash sudo docker run -it --network host --gpus all tensorcircuit -# if one also wants to mount local source code, also add args `-v "$(pwd)":/app` - -# using tensorcircuit/tensorcircuit to run the prebuild docker image from dockerhub +# if one also wants to mount local source code, also add args `-v "$(pwd)":/root` -# for old dockerfile with no runtime env setting -# sudo docker run -it --network host -e LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-11.0/targets/x86_64-linux/lib -e PYTHONPATH=/app -v "$(pwd)":/app --gpus all tensorcircuit +# using tensorcircuit/tensorcircuit:latest to run the prebuild docker image from dockerhub ``` -`export TF_CPP_MIN_LOG_LEVEL=3` maybe necessary since jax suprisingly frequently complain about ptxas version problem. And `export CUDA_VISIBLE_DEVICES=-1` if you want to test only on CPU. - -The built docker has no tensorcircuit pip package installed but left with a tensorcircuit source code dir. So one can `python setup.py develop` to install tensorcircuit locally (one can also mount the tensorcircuit codebase on host) or `pip install tensorcircuit` within the running docker. +`export CUDA_VISIBLE_DEVICES=-1` if you want to test only on CPU. diff --git a/requirements/requirements-docker-v2.txt b/requirements/requirements-docker-v2.txt new file mode 100644 index 00000000..5a99a02d --- /dev/null +++ b/requirements/requirements-docker-v2.txt @@ -0,0 +1,47 @@ +torch>2.0 # 2.0.1 +jax[cuda11_pip]==0.4.7 +tensorflow==2.11 +# tf 2.12 can make torch 2 hangs with runtime error +# check with hybrid_gpu_pipeline.py example +cupy-cuda11x==12.0.0 +tensornetwork==0.4.6 +graphviz +numpy==1.23.5 +scipy==1.10.1 +sympy==1.12 +cirq==1.1.0 +qiskit +matplotlib +jupyter +cotengra +networkx +optax==0.1.5 +kahypar +optuna +baytune +nevergrad +scikit-learn==1.2.2 +scikit-optimize +openfermion +quimb +openfermionpyscf +pennylane==0.30.0 +mthree==1.1.0 +mitiq==0.26.0 +# below is for development +mypy==1.3.0 +pytest +pytest-cov +pytest-benchmark +pytest-xdist +pytest-lazy-fixture +black==23.3.0 +sphinx>=4.0 +sphinx-intl +sphinx-copybutton +nbsphinx +furo +myst-parser +pylint +sphinx-design +# made in 202306 From a1e1705be342e7a4ea5c03d54203b00340da36de Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 12 Jun 2023 11:21:01 +0800 Subject: [PATCH 497/725] add pmap example --- CHANGELOG.md | 4 +++ README.md | 2 ++ examples/vqe_parallel_pmap.py | 68 +++++++++++++++++++++++++++++++++++ tensorcircuit/cloud/apis.py | 1 + 4 files changed, 75 insertions(+) create mode 100644 examples/vqe_parallel_pmap.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f3c89ff5..3084e947 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Added + +- Add multiple GPU VQE examples using jax pmap + ## 0.10.0 ### Added diff --git a/README.md b/README.md index ade11d2d..a3335f0a 100644 --- a/README.md +++ b/README.md @@ -136,6 +136,8 @@ We also have [Docker support](/docker). - Support **qudits simulation**. + - Support **parallel** quantum circuit evaluation across **multiple GPUs**. + - Highly customizable **noise model** with gate error and scalable readout error. - Support for **non-unitary** gate and post-selection simulation. diff --git a/examples/vqe_parallel_pmap.py b/examples/vqe_parallel_pmap.py new file mode 100644 index 00000000..54ea6922 --- /dev/null +++ b/examples/vqe_parallel_pmap.py @@ -0,0 +1,68 @@ +""" +jax pmap paradigm for vqe on multiple gpus +""" + +import os + +os.environ["XLA_FLAGS"] = "--xla_force_host_platform_device_count=8" +from functools import partial +import jax +import optax +import tensorcircuit as tc + +K = tc.set_backend("jax") +tc.set_contractor("cotengra") + + +def vqef(param, measure, n, nlayers): + c = tc.Circuit(n) + c.h(range(n)) + for i in range(nlayers): + c.rzz(range(n - 1), range(1, n), theta=param[i, 0]) + c.rx(range(n), theta=param[i, 1]) + return K.real( + tc.templates.measurements.parameterized_measurements(c, measure, onehot=True) + ) + + +def get_tfim_ps(n): + tfim_ps = [] + for i in range(n): + tfim_ps.append(tc.quantum.xyz2ps({"x": [i]}, n=n)) + for i in range(n): + tfim_ps.append(tc.quantum.xyz2ps({"z": [i, (i + 1) % n]}, n=n)) + return K.convert_to_tensor(tfim_ps) + + +vqg_vgf = jax.vmap(K.value_and_grad(vqef), in_axes=(None, 0, None, None)) + + +@partial( + jax.pmap, + axis_name="pmap", + in_axes=(0, 0, None, None), + static_broadcasted_argnums=(2, 3), +) +def update(param, measure, n, nlayers): + # Compute the gradients on the given minibatch (individually on each device). + loss, grads = vqg_vgf(param, measure, n, nlayers) + grads = K.sum(grads, axis=0) + grads = jax.lax.psum(grads, axis_name="pmap") + loss = K.sum(loss, axis=0) + loss = jax.lax.psum(loss, axis_name="pmap") + param = opt.update(grads, param) + return param, loss + + +if __name__ == "__main__": + n = 8 + nlayers = 4 + ndevices = 8 + m = get_tfim_ps(n) + m = K.reshape(m, [ndevices, m.shape[0] // ndevices] + list(m.shape[1:])) + param = K.stateful_randn(jax.random.PRNGKey(43), shape=[nlayers, 2, n], stddev=0.1) + param = K.stack([param] * ndevices) + opt = K.optimizer(optax.adam(1e-2)) + for _ in range(100): + param, loss = update(param, m, n, nlayers) + print(loss[0]) diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index 8449ec74..edddb0af 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -212,6 +212,7 @@ def set_token( # file_token = backend.tree_map(b64decode_s, file_token) except json.JSONDecodeError: logger.warning("token file loading failure, set empty token instead") + # TODO(@refraction-ray): better conflict solve with multiprocessing file_token = {} else: file_token = {} From 067635820b03cc2ea876c64df27cd06f2c3ae016 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 14 Jun 2023 10:39:11 +0800 Subject: [PATCH 498/725] refactor the codebase structure --- tensorcircuit/applications/__init__.py | 2 +- tensorcircuit/applications/ai/__init__.py | 0 .../applications/finance/__init__.py | 0 .../applications/physics/__init__.py | 0 .../applications/physics/baseline.py | 57 +++++++++++++++++++ tensorcircuit/applications/utils.py | 2 + tensorcircuit/templates/__init__.py | 3 + tensorcircuit/templates/ansatz.py | 3 + tensorcircuit/templates/chems.py | 35 +----------- tensorcircuit/templates/conversions.py | 38 +++++++++++++ tests/test_miscs.py | 6 ++ 11 files changed, 112 insertions(+), 34 deletions(-) create mode 100644 tensorcircuit/applications/ai/__init__.py create mode 100644 tensorcircuit/applications/finance/__init__.py create mode 100644 tensorcircuit/applications/physics/__init__.py create mode 100644 tensorcircuit/applications/physics/baseline.py create mode 100644 tensorcircuit/templates/ansatz.py create mode 100644 tensorcircuit/templates/conversions.py diff --git a/tensorcircuit/applications/__init__.py b/tensorcircuit/applications/__init__.py index 99d7c732..70d128b0 100644 --- a/tensorcircuit/applications/__init__.py +++ b/tensorcircuit/applications/__init__.py @@ -1,5 +1,5 @@ """ The application codebase is related to research and previous version of tensorcircuit, the code inside is subject to change, be caution to use. -Most of the useful code is refactored and copied to other parts of tensorcircuit. +Most of the useful code is and will be refactored and copied to other parts of tensorcircuit. """ diff --git a/tensorcircuit/applications/ai/__init__.py b/tensorcircuit/applications/ai/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tensorcircuit/applications/finance/__init__.py b/tensorcircuit/applications/finance/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tensorcircuit/applications/physics/__init__.py b/tensorcircuit/applications/physics/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tensorcircuit/applications/physics/baseline.py b/tensorcircuit/applications/physics/baseline.py new file mode 100644 index 00000000..9105abaf --- /dev/null +++ b/tensorcircuit/applications/physics/baseline.py @@ -0,0 +1,57 @@ +""" +baseline calculators for physical systems +""" + +import numpy as np + + +def TFIM1Denergy( + L: int, Jzz: float = 1.0, Jx: float = 1.0, Pauli: bool = True +) -> float: + # PBC + # nice tutorial: https://arxiv.org/pdf/2009.09208.pdf + # further investigation on 1 TFIM solution structure is required + # will fail on AFM phase Jzz>Jx and Jzz>0 and odd sites (frustration in boundary) + e = 0 + if Pauli: + Jx *= 2 + Jzz *= 4 + for i in range(L): + q = np.pi * (2 * i - (1 + (-1) ** L) / 2) / L + e -= np.abs(Jx) / 2 * np.sqrt(1 + Jzz**2 / 4 / Jx**2 - Jzz / Jx * np.cos(q)) + return e + + +def Heisenberg1Denergy(L: int, Pauli: bool = True, maxiters: int = 1000) -> float: + # PBC + error = 1e-15 + eps = 1e-20 # avoid zero division + phi = np.zeros([L // 2, L // 2]) + phi2 = np.zeros([L // 2, L // 2]) + lamb = np.array([2 * i + 1 for i in range(L // 2)]) + for _ in range(maxiters): + k = 1 / L * (2 * np.pi * lamb + np.sum(phi, axis=-1) - np.diag(phi)) + for i in range(L // 2): + for j in range(L // 2): + phi2[i, j] = ( + np.arctan( + 2 + / ( + 1 / (np.tan(k[i] / 2) + eps) + - 1 / (np.tan(k[j] / 2) + eps) + + eps + ) + ) + * 2 + ) + if np.allclose(phi, phi2, rtol=error): # converged + break + phi = phi2.copy() + else: + raise ValueError( + "the maxiters %s is too small for bethe ansatz to converge" % maxiters + ) + e = -np.sum(1 - np.cos(k)) + L / 4 + if Pauli is True: + e *= 4 + return e # type: ignore diff --git a/tensorcircuit/applications/utils.py b/tensorcircuit/applications/utils.py index a2db4fee..8390afce 100644 --- a/tensorcircuit/applications/utils.py +++ b/tensorcircuit/applications/utils.py @@ -388,6 +388,8 @@ def repr2array(inputs: str) -> Array: return np.array(outputs) +# duplicated, will remove later +# use the version in applications.physics.baseline.py def TFIM1Denergy( L: int, Jzz: float = 1.0, Jx: float = 1.0, Pauli: bool = True ) -> float: diff --git a/tensorcircuit/templates/__init__.py b/tensorcircuit/templates/__init__.py index e40637e3..85f350ea 100644 --- a/tensorcircuit/templates/__init__.py +++ b/tensorcircuit/templates/__init__.py @@ -1,5 +1,8 @@ +from . import ansatz from . import blocks from . import chems from . import dataset from . import graphs from . import measurements + +costfunctions = measurements diff --git a/tensorcircuit/templates/ansatz.py b/tensorcircuit/templates/ansatz.py new file mode 100644 index 00000000..6af93245 --- /dev/null +++ b/tensorcircuit/templates/ansatz.py @@ -0,0 +1,3 @@ +""" +Shortcuts for reusable circuit ansatz +""" diff --git a/tensorcircuit/templates/chems.py b/tensorcircuit/templates/chems.py index 0ac3a0da..bc0a2184 100644 --- a/tensorcircuit/templates/chems.py +++ b/tensorcircuit/templates/chems.py @@ -2,37 +2,6 @@ Useful utilities for quantum chemistry related task """ -from typing import Any, Tuple +from .conversions import get_ps # pylint:disable=unused-import -import numpy as np - -Tensor = Any - - -def get_ps(qo: Any, n: int) -> Tuple[Tensor, Tensor]: - """ - Get Pauli string array and weights array for a qubit Hamiltonian - as a sum of Pauli strings defined in openfermion ``QubitOperator``. - - :param qo: ``openfermion.ops.operators.qubit_operator.QubitOperator`` - :type qo: ``openfermion.ops.operators.qubit_operator.QubitOperator`` - :param n: The number of qubits - :type n: int - :return: Pauli String array and weights array - :rtype: Tuple[Tensor, Tensor] - """ - value = {"X": 1, "Y": 2, "Z": 3} - terms = qo.terms - res = [] - wts = [] - for key in terms: - bit = np.zeros(n, dtype=int) - for i in range(len(key)): - bit[key[i][0]] = value[key[i][1]] - w = terms[key] - res_t = tuple() # type: ignore - for i in range(n): - res_t = res_t + (bit[i],) - res.append(res_t) - wts.append(w) - return np.array(res), np.array(wts) +# backward compatibility for the entry point diff --git a/tensorcircuit/templates/conversions.py b/tensorcircuit/templates/conversions.py new file mode 100644 index 00000000..2fc92463 --- /dev/null +++ b/tensorcircuit/templates/conversions.py @@ -0,0 +1,38 @@ +""" +helper functions for conversions +""" + +from typing import Any, Tuple + +import numpy as np + +Tensor = Any + + +def get_ps(qo: Any, n: int) -> Tuple[Tensor, Tensor]: + """ + Get Pauli string array and weights array for a qubit Hamiltonian + as a sum of Pauli strings defined in openfermion ``QubitOperator``. + + :param qo: ``openfermion.ops.operators.qubit_operator.QubitOperator`` + :type qo: ``openfermion.ops.operators.qubit_operator.QubitOperator`` + :param n: The number of qubits + :type n: int + :return: Pauli String array and weights array + :rtype: Tuple[Tensor, Tensor] + """ + value = {"X": 1, "Y": 2, "Z": 3} + terms = qo.terms + res = [] + wts = [] + for key in terms: + bit = np.zeros(n, dtype=int) + for i in range(len(key)): + bit[key[i][0]] = value[key[i][1]] + w = terms[key] + res_t = tuple() # type: ignore + for i in range(n): + res_t = res_t + (bit[i],) + res.append(res_t) + wts.append(w) + return np.array(res), np.array(wts) diff --git a/tests/test_miscs.py b/tests/test_miscs.py index b3e9eb8a..b7a201cb 100644 --- a/tests/test_miscs.py +++ b/tests/test_miscs.py @@ -16,6 +16,7 @@ from tensorcircuit import experimental from tensorcircuit.quantum import PauliString2COO, PauliStringSum2COO from tensorcircuit.applications.vqes import construct_matrix_v2 +from tensorcircuit.applications.physics.baseline import TFIM1Denergy, Heisenberg1Denergy i, x, y, z = [t.tensor for t in tc.gates.pauli_gates] @@ -248,3 +249,8 @@ def h_square_sparse(t, b): ) c.rx(1, theta=np.pi - 0.4) np.testing.assert_allclose(c.expectation_ps(z=[1]), 1.0, atol=1e-5) + + +def test_energy_baseline(): + print(TFIM1Denergy(10)) + print(Heisenberg1Denergy(10)) From a96a559e57d6e497d2f60f1ebde4bf39a38b63b7 Mon Sep 17 00:00:00 2001 From: Hong-Ye Hu <50563225+hongyehu@users.noreply.github.com> Date: Fri, 16 Jun 2023 11:16:45 -0400 Subject: [PATCH 499/725] Create development_MacM2.md A description of how to install compatible Jax and TensorFlow in one environment. --- docs/source/contribs/development_MacM2.md | 50 +++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 docs/source/contribs/development_MacM2.md diff --git a/docs/source/contribs/development_MacM2.md b/docs/source/contribs/development_MacM2.md new file mode 100644 index 00000000..8b082f7d --- /dev/null +++ b/docs/source/contribs/development_MacM2.md @@ -0,0 +1,50 @@ +# Tensorcircuit Installation Guide on MacOS + +Contributed by [Hong-Ye Hu](https://github.com/hongyehu) + +The key issue addressed in this document is **how to install both TensorFlow and Jax on a M2 chip MacOS without conflict**. + +## Starting From Scratch + +### Install Xcode Command Line Tools + +Need graphical access to the machine. + +Run `xcode-select --install` to install if on optimal internet. + +Or Download from [Apple](https://developer.apple.com/download/more/) Command Line Tools installation image then install if internet connection is weak. + +## Install Miniconda + +Due to the limitation of MacOS and packages, the lastest version of python does not always function as desired, thus miniconda installation is advised to solve the issues. And use anaconda virtual environment is always a good habit. + +``` +curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh +bash ~/miniconda.sh -b -p $HOME/miniconda +source ~/miniconda/bin/activate +``` + +## Install Packages +First, create a virtual environment, and make sure the python version is 3.8.5 by +``` +conda create --name NewEnv python==3.8.5 +conda activate NewEnv +``` +Then, install the TensorFlow from `.whl` file (file is attached in *contribs* folder). This will install TensorFlow version 2.4.1 +``` +pip install ~/Downloads/tensorflow-2.4.1-py3-none-any.whl +``` +Next, one need to install **Jax** and **Optax** by +``` +conda install jax==0.3.0 +conda install optax==0.1.4 +``` +Now, hopefully, you should be able to use both Jax and TensorFlow in this environment. But sometimes, it may give you an error "ERROR: package Chardet not found.". +If that is the case, you can install it by `conda install chardet`. +Lastly, install tensorcircuit +``` +pip install tensorcircuit +``` +This is the solution that seems to work for M2-chip MacOS. Please let me know if there is a better solution! + + From d6fd9e296509c6ff6a7d8ce931e8eef3368e19c4 Mon Sep 17 00:00:00 2001 From: Hong-Ye Hu <50563225+hongyehu@users.noreply.github.com> Date: Sat, 17 Jun 2023 13:05:26 -0400 Subject: [PATCH 500/725] Update development_MacM2.md Add download link for TensorFlow --- docs/source/contribs/development_MacM2.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/contribs/development_MacM2.md b/docs/source/contribs/development_MacM2.md index 8b082f7d..28c77bc3 100644 --- a/docs/source/contribs/development_MacM2.md +++ b/docs/source/contribs/development_MacM2.md @@ -30,7 +30,7 @@ First, create a virtual environment, and make sure the python version is 3.8.5 b conda create --name NewEnv python==3.8.5 conda activate NewEnv ``` -Then, install the TensorFlow from `.whl` file (file is attached in *contribs* folder). This will install TensorFlow version 2.4.1 +Then, install the TensorFlow from `.whl` file (file can be downloaded from this [URL](https://drive.google.com/drive/folders/1oSipZLnoeQB0Awz8U68KYeCPsULy_dQ7)). This will install TensorFlow version 2.4.1 ``` pip install ~/Downloads/tensorflow-2.4.1-py3-none-any.whl ``` From 50753a4db4f2576303c2780555992f9714f0eb17 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Sun, 18 Jun 2023 03:13:59 +0000 Subject: [PATCH 501/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index a3335f0a..f06476f1 100644 --- a/README.md +++ b/README.md @@ -233,6 +233,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. 隐公观鱼
隐公观鱼
💻 ⚠️ WiuYuan
WiuYuan
💡 Felix Xu
Felix Xu
✅ + Hong-Ye Hu
Hong-Ye Hu
📖 From d8045385645bf939160d60f500afc14f10ab0ffc Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Sun, 18 Jun 2023 03:14:00 +0000 Subject: [PATCH 502/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index a7ad67f2..3270e04e 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -249,6 +249,15 @@ "contributions": [ "tutorial" ] + }, + { + "login": "hongyehu", + "name": "Hong-Ye Hu", + "avatar_url": "https://avatars.githubusercontent.com/u/50563225?v=4", + "profile": "https://scholar.harvard.edu/hongyehu/home", + "contributions": [ + "doc" + ] } ], "contributorsPerLine": 6, @@ -256,5 +265,6 @@ "repoType": "github", "repoHost": "https://github.com", "projectName": "tensorcircuit", - "projectOwner": "tencent-quantum-lab" + "projectOwner": "tencent-quantum-lab", + "commitType": "docs" } From 41a7fac73b91c52c31fa8d16c919a975673c177e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 27 Jun 2023 12:08:27 +0800 Subject: [PATCH 503/725] update readme: adding journal ref --- README.md | 2 +- README_cn.md | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index f06476f1..fde62c3e 100644 --- a/README.md +++ b/README.md @@ -286,7 +286,7 @@ Reference paper: https://arxiv.org/abs/2303.08154. [TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) is an efficient and versatile quantum computation package for molecular properties. TenCirChem is based on TensorCircuit and is optimized for chemistry applications. -Reference paper: https://arxiv.org/abs/2303.10825. +Reference paper: https://arxiv.org/abs/2303.10825 (published in JCTC). ### EMQAOA-DARBO diff --git a/README_cn.md b/README_cn.md index 1d9ff504..c9f74ac1 100644 --- a/README_cn.md +++ b/README_cn.md @@ -171,13 +171,13 @@ VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mb 利用我们提出的随机量子门激活策略训练优化变分量子算法的实现请参考 [项目](https://github.com/ls-iastu/RAtraining). -参考论文: https://arxiv.org/abs/2303.08154. +参考论文: https://arxiv.org/abs/2303.08154。 ### TenCirChem [TenCirChem](https://github.com/tencent-quantum-lab/TenCirChem) 是高效的，专注于处理和计算分子性质的量子计算软件。其基于 TensorCircuit 并为量子化学任务进行了专门的优化。 -参考论文: https://arxiv.org/abs/2303.10825。 +参考论文: https://arxiv.org/abs/2303.10825 (JCTC)。 ### EMQAOA-DARBO From bbdb82b6abd025aab92dc0d709ccd8ebe3bd5a71 Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Wed, 28 Jun 2023 20:03:16 +0800 Subject: [PATCH 504/725] Resolve keras.engine no found error tf/keras>=2.13 --- tensorcircuit/templates/ensemble.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index f8b97aee..54d1f46b 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -9,18 +9,19 @@ NDArray = Any kwargus = Any +model_type = Any class bagging: # A.K.A. voting def __init__(self) -> None: - self.models: List[keras.engine.functional.Functional] = [] + self.models: List[model_type] = [] self.model_trained: List[bool] = [] self.count = 0 self.need_confidence = True # Help in reducing numbers of get_confidence runs self.permit_train = False def append( - self, model: keras.engine.functional.Functional, model_trained: bool + self, model: model_type, model_trained: bool ) -> None: """ Add model to the voting method From ab45a9f619b968c525f955b399363f75610d464e Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Wed, 28 Jun 2023 20:11:54 +0800 Subject: [PATCH 505/725] updated for black --- tensorcircuit/templates/ensemble.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index 54d1f46b..c6e81cd6 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -20,9 +20,7 @@ def __init__(self) -> None: self.need_confidence = True # Help in reducing numbers of get_confidence runs self.permit_train = False - def append( - self, model: model_type, model_trained: bool - ) -> None: + def append(self, model: model_type, model_trained: bool) -> None: """ Add model to the voting method """ From c599c0ef8b66452127d1960bb5476bbf843bf482 Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Thu, 29 Jun 2023 14:12:02 +0800 Subject: [PATCH 506/725] Update kwargs in ensemble and latest Mac dev guide --- docs/source/contribs/development_MacARM.md | 45 ++++++++++++++++++---- tensorcircuit/templates/ensemble.py | 4 +- 2 files changed, 39 insertions(+), 10 deletions(-) diff --git a/docs/source/contribs/development_MacARM.md b/docs/source/contribs/development_MacARM.md index ffddf582..1ead5993 100644 --- a/docs/source/contribs/development_MacARM.md +++ b/docs/source/contribs/development_MacARM.md @@ -43,13 +43,7 @@ pip install [Package Name] ### Install Tensorflow (Optional) -#### Install Tensorflow (Recommended Approach) - -❗️ Tensorflow with MacOS optimization would not function correctly in version 2.11.0 and before. Do not use this version of tensorflow if you intented to train any machine learning model. - -FYI: Error can occur when machine learning training or gpu related code is involved. - -⚠️ Tensorflow without macos optimization does not support Metal API and utilizing GPU (both intel chips and M-series chips) until at least tensorflow 2.11. Tensorflow-macos would fail when running `tc.backend.to_dense()` +#### Install Tensorflow without MacOS optimization ``` conda config --add channels conda-forge @@ -75,13 +69,45 @@ model.compile(optimizer="adam", loss=loss_fn, metrics=["accuracy"]) model.fit(x_train, y_train, epochs=5, batch_size=64) ``` +#### Install Tensorflow with MacOS optimization (Recommended) + +For tensorflow version 2.13 or later: +``` +pip install tensorflow +pip install tensorflow-metal +``` + +For tensorflow version 2.12 or earlier: +``` +pip install tensorflow-macos +pip install tensorflow-metal +``` + +#### Verify Tensorflow Installation + +``` +import tensorflow as tf + +cifar = tf.keras.datasets.cifar100 +(x_train, y_train), (x_test, y_test) = cifar.load_data() +model = tf.keras.applications.ResNet50( + include_top=True, + weights=None, + input_shape=(32, 32, 3), + classes=100,) + +loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) +model.compile(optimizer="adam", loss=loss_fn, metrics=["accuracy"]) +model.fit(x_train, y_train, epochs=5, batch_size=64) +``` + ## Install Tensorcircuit ``` pip install tensorcircuit ``` -Testing Platform (Tested Feb 2023) +Testing Platform (Tested Jun 2023) - Platform 1: - MacOS Ventura 13.1 (Build version 22C65) @@ -89,3 +115,6 @@ Testing Platform (Tested Feb 2023) - Platform 2: - MacOS Ventura 13.2 (Build version 22D49) - M1 Ultra (Virtual) +- Platform 4: + - MacOS Sonoma 14.0 Beta 2 (Build version 23A5276g) + - M2 Max \ No newline at end of file diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/templates/ensemble.py index c6e81cd6..0c4a0fc3 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/templates/ensemble.py @@ -4,7 +4,6 @@ from typing import Any, List, Optional import tensorflow as tf -import keras import numpy as np NDArray = Any @@ -56,7 +55,8 @@ def compile(self, **kwargs: kwargus) -> None: self.permit_train = True for i in range(self.count): if not self.model_trained[i]: - self.models[i].compile(**kwargs) + dic_kwargs = kwargs.copy() + self.models[i].compile(**dic_kwargs) def __get_confidence(self, model_index: int, input: NDArray) -> NDArray: """ From b1e2d9d74df8523dc5ca406ea09ea1167320cfd5 Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Thu, 29 Jun 2023 14:13:02 +0800 Subject: [PATCH 507/725] suggest to add test.qasm to .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index c1649c55..c21b5efb 100644 --- a/.gitignore +++ b/.gitignore @@ -28,3 +28,4 @@ examples/Unified AD model.ipynb docs/source/locale/zh/LC_MESSAGES/textbook.po docs/source/locale/zh/LC_MESSAGES/whitepapertoc_cn.po docs/source/locale/zh/LC_MESSAGES/textbooktoc.po +test.qasm From 40492881ff5155e3a6f0e68bbfc81ea9da3aa92e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 29 Jun 2023 20:03:01 +0800 Subject: [PATCH 508/725] update readme with more ref sec --- README.md | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index fde62c3e..01bf52c1 100644 --- a/README.md +++ b/README.md @@ -170,7 +170,7 @@ We also have [Docker support](/docker). - SOTA quantum algorithm and model implementations. - - Support hybrid workflows and pipelines with CPU/GPU/QPU hardware from local/cloud/hpc resources using tf/torch/jax/cupy/numpy frameoworks all at the same time. + - Support hybrid workflows and pipelines with CPU/GPU/QPU hardware from local/cloud/hpc resources using tf/torch/jax/cupy/numpy frameworks all at the same time. @@ -293,3 +293,28 @@ Reference paper: https://arxiv.org/abs/2303.10825 (published in JCTC). For the numerical simulation and hardware experiments with error mitigation on QAOA, see the [project repo](https://github.com/sherrylixuecheng/EMQAOA-DARBO). Reference paper: https://arxiv.org/abs/2303.14877. + +### More works + +
+ More research works and code projects using TensorCircuit (click for details) + +- Neural Predictor based Quantum Architecture Search: https://arxiv.org/abs/2103.06524 (published in Machine Learning: Science and Technology). + +- Quantum imaginary-time control for accelerating the ground-state preparation: https://arxiv.org/abs/2112.11782 (published in PRR). + +- Efficient Quantum Simulation of Electron-Phonon Systems by Variational Basis State Encoder: https://arxiv.org/abs/2301.01442 (published in PRR). + +- Understanding quantum machine learning also requires rethinking generalization: https://arxiv.org/abs/2306.13461. + +- Decentralized Quantum Federated Learning for Metaverse: Analysis, Design and Implementation: https://arxiv.org/abs/2306.11297. Code: https://github.com/s222416822/BQFL. + +- Non-IID quantum federated learning with one-shot communication complexity: https://arxiv.org/abs/2209.00768 (published in Quantum Machine Intelligence). Code: https://github.com/JasonZHM/quantum-fed-infer. + +- Quantum generative adversarial imitation learning: https://doi.org/10.1088/1367-2630/acc605 (published in New Journal of Physics). + +- GSQAS: Graph Self-supervised Quantum Architecture Search: https://arxiv.org/abs/2303.12381. + +
+ +If you want to highlight your research work here, feel free to add by opening PR. From e4729dde24cfef13be5ef8654c28974de4088801 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 29 Jun 2023 20:04:41 +0800 Subject: [PATCH 509/725] update refs --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 01bf52c1..a5391f0a 100644 --- a/README.md +++ b/README.md @@ -305,6 +305,8 @@ Reference paper: https://arxiv.org/abs/2303.14877. - Efficient Quantum Simulation of Electron-Phonon Systems by Variational Basis State Encoder: https://arxiv.org/abs/2301.01442 (published in PRR). +- Variational Quantum Simulations of Finite-Temperature Dynamical Properties via Thermofield Dynamics: https://arxiv.org/abs/2206.05571. + - Understanding quantum machine learning also requires rethinking generalization: https://arxiv.org/abs/2306.13461. - Decentralized Quantum Federated Learning for Metaverse: Analysis, Design and Implementation: https://arxiv.org/abs/2306.11297. Code: https://github.com/s222416822/BQFL. From ef9e03b3297440d795c6001250ed60a70d5d2ed0 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sun, 2 Jul 2023 15:12:08 +0800 Subject: [PATCH 510/725] update --- docs/source/tutorials/qaoa_nae3sat.ipynb | 1070 ++++++++++++++++++++++ 1 file changed, 1070 insertions(+) create mode 100644 docs/source/tutorials/qaoa_nae3sat.ipynb diff --git a/docs/source/tutorials/qaoa_nae3sat.ipynb b/docs/source/tutorials/qaoa_nae3sat.ipynb new file mode 100644 index 00000000..21d979bb --- /dev/null +++ b/docs/source/tutorials/qaoa_nae3sat.ipynb @@ -0,0 +1,1070 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dc0db886", + "metadata": {}, + "source": [ + "# Quantum Approximation Optimization Algorithm (QAOA) for Not-all-equal 3-satisfiability (NAE3SAT)" + ] + }, + { + "cell_type": "markdown", + "id": "aecf6615", + "metadata": {}, + "source": [ + "## Overview" + ] + }, + { + "cell_type": "markdown", + "id": "b533d43e", + "metadata": {}, + "source": [ + "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In QAOA, the parameterized quantum circuit is regarded as an oracle, we sample the circuit to obtain the gradient of the parameters, and update them through the classical optimizer. Before this tutorial, there was already a tutorial of [QAOA for Max-Cut](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html). In this tutorial, we will focus on another combinatorial optimization problem - Not-all-equal 3-satisfiability (NAE3SAT), and discuss the performance of QAOA in different hardness cases.\n" + ] + }, + { + "cell_type": "markdown", + "id": "16ad937f", + "metadata": {}, + "source": [ + "## Not-all-equal 3-satisfiability (NAE3SAT)" + ] + }, + { + "cell_type": "markdown", + "id": "c2321b00", + "metadata": {}, + "source": [ + "[Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) is a variant of 3-satisfiability (3-SAT) and 3-SAT is a subset of [Boolean satisfiability problem (SAT)](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem). SAT is, given a Boolean expression, to check whether it is satisfiable, where the Boolean expression is a disjunction of clauses (or a single clause) and each clause is a disjunction of literals (or a single literal). Here is an example of Boolean expression of SAT,\n", + "$$\n", + "\\begin{equation}\n", + " (x_1\\lor x_2\\lor\\cdots\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor\\cdots\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor\\cdots\\lor \\lnot x_n),\n", + "\\end{equation}\n", + "$$\n", + "where $(x_i\\lor x_j\\lor\\cdots\\lor x_k)$ is a clause and $x_i$ is a literal. SAT with $k$ literals in each clause is called $k$-SAT, thus in 3-SAT, there are only three literals in each clause, for example\n", + "$$\n", + "\\begin{equation}\n", + " (x_1\\lor x_2\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor \\lnot x_n).\n", + "\\end{equation}\n", + "$$\n", + "When $k$ is not less than 3, SAT is NP-complete. On the other hand, NAE3SAT requires the three literals in each clause are not all equal to each other, in other words, at least one is true, and at least one is false. It is different from 3-SAT, which requires at least one literal is true in each clause. However, NAE3SAT is still NP-complete, [which can be proven by a reduction from 3-SAT](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability).\n" + ] + }, + { + "cell_type": "markdown", + "id": "4d28f719", + "metadata": {}, + "source": [ + "Now we use the spin model to represent a NAE3SAT. Let the set of clauses in the NAE3SAT be $\\mathcal{C}$. In each clause, there are three literals and each literal is represented by a spin. Spins up ($s=1$, $\\text{bit}=0$) and down ($s=-1$, $\\text{bit}=1$) represent false and true respectively. For the clause $(s_i,\\ s_j,\\ s_k)\\in\\mathcal{C}$, $s_i,\\ s_j,\\ s_k$ cannot be 1 or -1 at the same time. The Hamiltonian of the NAE3SAT is as follows\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " H_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $H_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT." + ] + }, + { + "cell_type": "markdown", + "id": "871bff2e", + "metadata": {}, + "source": [ + "## QAOA for NAE3SAT" + ] + }, + { + "cell_type": "markdown", + "id": "598dc69e", + "metadata": {}, + "source": [ + "QAOA utilizes a parameterized quantum circuit ([PQC](https://tensorcircuit.readthedocs.io/en/latest/textbook/chap5.html?highlight=变分)) to generate a quantum state that represents a potential solution. The initial state, denoted as $|s\\rangle$, is a uniform superposition over computational basis states.\n", + "$$\n", + "\\begin{equation}\n", + " |s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle\n", + "\\end{equation}\n", + "$$\n", + "This state is then evolved by a unitary operator that consists of $p$ layers, denoted as\n", + "$$\n", + "\\begin{equation}\n", + " U(\\boldsymbol{\\beta}, \\boldsymbol{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", + "\\end{equation}\n", + "$$\n", + "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ is the driving layer and $V_{j}= e^{-i \\beta_{j} H_m}$ is the mixing layer. $H_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $H_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." + ] + }, + { + "cell_type": "markdown", + "id": "949be36e", + "metadata": {}, + "source": [ + "Begin with a set of initial $\\boldsymbol{\\gamma}$ and $\\boldsymbol{\\beta}$, the quantum state is obtained from the PQC and then the expectation value of $H_C$ is calculated. A classical optimizer is then used to vary the parameters until a lower expectation value is found. This process is iterated a certain number of times until the expectation value of $H_C$ is approximated to 0. Then we perform projective measurement on the quantum state output by PQC, and obtain a bit string, which is very likely to be the solution of NAE3SAT. Since NAE3SAT is an NP-complete problem, we can verify whether the solution is correct in polynomial time on classical computer. Even if this bit string is not the correct solution, we can repeat the projective measurement and verify the obtained solution until we get the correct solution.\n", + "\n", + "For other details of QAOA, such as the selection of $p$ and the overall algorithm loop, please refer to [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028) or the tutorial of [QAOA for Max-Cut](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html)." + ] + }, + { + "cell_type": "markdown", + "id": "940fa22b", + "metadata": {}, + "source": [ + "### The code" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b0def04d", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:02:33.234006600Z", + "start_time": "2023-06-30T02:02:33.229847200Z" + } + }, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import optax\n", + "import tensorflow as tf\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from IPython.display import clear_output\n", + "import random\n", + "\n", + "K = tc.set_backend('jax')\n", + "\n", + "nlayers = 30 # the number of layers\n", + "ncircuits = 6 # six circuits with different initial parameters are going to be optimized at the same time" + ] + }, + { + "cell_type": "markdown", + "id": "6e407437", + "metadata": {}, + "source": [ + "#### Define the Graph" + ] + }, + { + "cell_type": "markdown", + "id": "c82972a4", + "metadata": {}, + "source": [ + "The graph of NAE3SAT is constructed by the set $\\mathcal{C}$ of clauses. When a clause is violated, the energy will increase by 4, so the upper bound of $H_C$ will not exceed $4|\\mathcal{C}|$. In practice, we multiply $H_C$ by a normalization factor $1/(4|\\mathcal{C}|)$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f1532831", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:02:33.397944100Z", + "start_time": "2023-06-30T02:02:33.231412200Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# a easy graph instance\n", + "easy_clauses = [[4, 7, 6], [0, 5, 9], [2, 6, 9], [2, 6, 7], [3, 1, 9], [5, 9, 11], [4, 8, 9], [5, 1, 9], [3, 8, 6], [2, 8, 10], [5, 6, 8], [2, 9, 6], [2, 6, 8], [5, 3, 9], [4, 11, 7], [3, 11, 10], [5, 10, 7], [3, 9, 8], [3, 6, 9], [2, 4, 7], [4, 0, 6], [3, 4, 6], [3, 11, 6], [4, 5, 6], [4, 0, 10], [5, 4, 10], [3, 7, 9], [0, 11, 6], [5, 11, 9], [3, 5, 9], [3, 4, 7], [3, 4, 7], [3, 0, 7], [1, 7, 8], [0, 3, 10], [0, 8, 9], [5, 7, 8], [2, 9, 6], [0, 8, 6], [4, 6, 8], [3, 2, 9], [4, 3, 8], [0, 2, 8], [4, 5, 10], [2, 4, 8], [5, 8, 9], [4, 8, 9], [3, 5, 11], [5, 4, 10], [2, 7, 9], [3, 0, 7], [2, 8, 6], [5, 3, 6], [0, 6, 10], [3, 2, 8], [4, 6, 9], [3, 2, 6], [1, 5, 6], [2, 8, 11], [2, 10, 8], [2, 0, 6], [2, 6, 9], [0, 8, 7], [0, 10, 8], [3, 5, 7], [2, 10, 8], [5, 7, 9], [0, 1, 6], [0, 3, 8], [0, 6, 9], [0, 5, 11], [1, 2, 10]]\n", + "factor = 1 / len(easy_clauses) / 4\n", + "\n", + "# convert to a NetworkX graph\n", + "easy_graph = nx.Graph()\n", + "for i, j, k in easy_clauses:\n", + " easy_graph.add_edge(i, j, weight=0)\n", + " easy_graph.add_edge(j, k, weight=0)\n", + " easy_graph.add_edge(k, i, weight=0)\n", + "for i, j, k in easy_clauses:\n", + " easy_graph[i][j]['weight'] += 1\n", + " easy_graph[j][k]['weight'] += 1\n", + " easy_graph[k][i]['weight'] += 1\n", + "pos_easy = nx.spring_layout(easy_graph)\n", + "nx.draw_networkx(easy_graph, with_labels=True, pos=pos_easy)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "c944f6dd", + "metadata": {}, + "source": [ + "#### Parameterized Quantum Circuit (PQC)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "055d1257", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:02:33.427591300Z", + "start_time": "2023-06-30T02:02:33.396852700Z" + } + }, + "outputs": [], + "source": [ + "def QAOAansatz(params, g, each=1, return_circuit=False):\n", + " n = g.number_of_nodes() # the number of nodes\n", + "\n", + " # PQC loop\n", + " def pqc_loop(s_, params_):\n", + " c_ = tc.Circuit(n, inputs=s_)\n", + " for j in range(each):\n", + " # driving layer\n", + " for a, b in g.edges:\n", + " c_.RZZ(a, b, theta=g[a][b]['weight'] * params_[2 * j] * factor)\n", + " # mixing layer\n", + " for i in range(n):\n", + " c_.RX(i, theta=params_[2 * j + 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(n)\n", + " for i in range(n):\n", + " c0.H(i)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, K.reshape(params, [nlayers // each, 2 * each]), s0)\n", + " c = tc.Circuit(n, inputs=s)\n", + "\n", + " # whether to return the circuit\n", + " if return_circuit is True:\n", + " return c\n", + "\n", + " # calculate the loss function\n", + " loss = 0.25\n", + " for a, b in g.edges:\n", + " loss += c.expectation_ps(z=[a, b]) * g[a][b]['weight'] * factor\n", + "\n", + " return K.real(loss)" + ] + }, + { + "cell_type": "markdown", + "id": "5b159920", + "metadata": {}, + "source": [ + "#### Optimization" + ] + }, + { + "cell_type": "markdown", + "id": "6d07ee61", + "metadata": {}, + "source": [ + "Here, several circuits with different initial parameters are optimized/trained at the same time.\n", + "\n", + "Optimizers are used to find the minimum value." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "690b8b67", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "backend = type(K).__name__\n", + "# use vvag to get the losses and gradients with different random circuit instances\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "\n", + "params_easy = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", + "if backend == 'JaxBackend':\n", + " opt = K.optimizer(optax.adam(1e-2))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(2000):\n", + " loss, grads = QAOA_vvag(params_easy, easy_graph)\n", + " params_easy = opt.update(grads, params_easy) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "98a6b152", + "metadata": {}, + "source": [ + "#### Results" + ] + }, + { + "cell_type": "markdown", + "id": "fc1c257d", + "metadata": {}, + "source": [ + "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we can also use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8c5df93e", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:09.636366200Z", + "start_time": "2023-06-30T02:28:26.850918300Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #0\n", + "measurement prob: 0.244925856590271\n", + "output: 111111000000\n", + "cost: 0.021371711045503616\n", + "max prob: 0.24492625892162323\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #1\n", + "measurement prob: 0.2965589463710785\n", + "output: 000000111111\n", + "cost: 0.013323463499546051\n", + "max prob: 0.2965589165687561\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #2\n", + "measurement prob: 0.05372887849807739\n", + "output: 111111000001\n", + "cost: 0.018687034025788307\n", + "max prob: 0.26440468430519104\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #3\n", + "measurement prob: 0.2904357314109802\n", + "output: 000000111111\n", + "cost: 0.014396688900887966\n", + "max prob: 0.2904358506202698\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #4\n", + "measurement prob: 0.2968122959136963\n", + "output: 000000111111\n", + "cost: 0.01325833611190319\n", + "max prob: 0.29681235551834106\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #5\n", + "measurement prob: 0.28433939814567566\n", + "output: 000000111111\n", + "cost: 0.015517047606408596\n", + "max prob: 0.2843400239944458\n", + "bit strings: ['111111000000']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print QAOA results\n", + "for num_circuit in range(ncircuits):\n", + " print(f'Circuit #{num_circuit}')\n", + " c = QAOAansatz(params=params_easy[num_circuit], g=easy_graph, return_circuit=True)\n", + " loss = QAOAansatz(params=params_easy[num_circuit], g=easy_graph)\n", + "\n", + " # measurement output\n", + " m_out, m_prob = c.sample()\n", + " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", + " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", + "\n", + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + "\n", + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if m_out[i] == '0' else 'c' for i in easy_graph.nodes]\n", + "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "4ae99ab9", + "metadata": {}, + "source": [ + "## Classical Method" + ] + }, + { + "cell_type": "markdown", + "id": "720dd1a4", + "metadata": {}, + "source": [ + "Here we use two classical methods. The first is the brutal force method (BF), which is to check all bit string one-by-one and need exponential time, thus the obtained solution is guaranteed to be correct." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2115bb6d", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:09.636366200Z", + "start_time": "2023-06-30T02:29:09.635854Z" + } + }, + "outputs": [], + "source": [ + "def b2s(bit):\n", + " return 1 - 2 * int(bit)\n", + "\n", + "def energy(cfg, graph, normalize=True):\n", + " E = 0.25\n", + " for a, b in graph.edges:\n", + " E += cfg[a] * cfg[b] * graph[a][b]['weight'] * factor\n", + " return E if normalize else E / factor\n", + "\n", + "def brutal_force(graph):\n", + " num_nodes = graph.number_of_nodes()\n", + " min_cost, best_case = 1., []\n", + " for i in range(2 ** num_nodes):\n", + " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + "\n", + " cost = energy(list(map(b2s, case)), graph)\n", + "\n", + " gap = min_cost - cost\n", + " if gap > 1e-6:\n", + " min_cost = cost\n", + " best_case = [case]\n", + " elif abs(gap) < 1e-6:\n", + " best_case.append(case)\n", + "\n", + " return best_case, min_cost" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b0cdc04f", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:09.976150600Z", + "start_time": "2023-06-30T02:29:09.635854Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost: 0.000\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print BF results\n", + "bf_best_cases, bf_best = brutal_force(easy_graph)\n", + "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in easy_graph.nodes]\n", + "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "20324164", + "metadata": {}, + "source": [ + "Another method is the simulated annealing method (SA), which is an approximation method that can be done in polynomial time, so the obtained solution has only a certain probability of being correct." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e1551fb4", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:09.976664900Z", + "start_time": "2023-06-30T02:29:09.976150600Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "def sim_annealing(graph, t_max: int, T: float):\n", + " num_nodes = graph.number_of_nodes()\n", + " state = np.random.randint(0, 2, num_nodes)\n", + " next_state = state.copy()\n", + " E = energy(1 - 2 * state, graph, normalize=False)\n", + " t = 0\n", + " while t < t_max:\n", + " temper = (1 - t / t_max) * T\n", + " flip_idx = np.random.randint(num_nodes)\n", + " next_state[flip_idx] = 1 - next_state[flip_idx]\n", + " next_E = energy(1 - 2 * next_state, graph, normalize=False)\n", + " if next_E <= E or np.exp(-(next_E - E) / temper) > np.random.rand():\n", + " state[flip_idx] = 1 - state[flip_idx]\n", + " E = next_E\n", + " else:\n", + " next_state[flip_idx] = 1 - next_state[flip_idx]\n", + " t += 1\n", + " return ''.join(map(str, state.tolist())), E" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "04596ec1", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:53:56.645392800Z", + "start_time": "2023-06-30T02:53:52.616150200Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "output: 111111000000\n", + "cost: 0.000\n", + "prob: 0.880\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print SA results\n", + "sa_best_cases, sa_best, n_exp = [], float('inf'), 100\n", + "for _ in range(n_exp):\n", + " sa_case, sa_cost = sim_annealing(easy_graph, 200, 1)\n", + " gap = sa_best - sa_cost\n", + " if gap > 1e-6:\n", + " sa_best = sa_cost\n", + " sa_best_cases = [sa_case]\n", + " elif abs(gap) < 1e-6:\n", + " sa_best_cases.append(sa_case)\n", + "sa_prob = len(sa_best_cases) / n_exp\n", + "sa_best_cases = list(set(sa_best_cases))\n", + "print(f'output: {sa_case}\\ncost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if sa_case[i] == '0' else 'c' for i in easy_graph.nodes]\n", + "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "e9b8619b", + "metadata": {}, + "source": [ + "## Hard Problem" + ] + }, + { + "cell_type": "markdown", + "id": "9f8cb1da", + "metadata": {}, + "source": [ + "We call the above problem a easy problem, because the classical simulated annealing method has a high probability to obtain the correct solution. Now let's define another relatively hard problem." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b0a1f778", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:14.201998500Z", + "start_time": "2023-06-30T02:29:14.058753400Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# a hard graph instance\n", + "hard_clauses = [[4, 1, 7], [5, 11, 8], [4, 1, 8], [4, 11, 8], [4, 1, 10], [5, 11, 8], [4, 1, 8], [1, 11, 8], [4, 1, 7], [0, 11, 8], [4, 1, 10], [4, 11, 8], [5, 0, 10], [0, 6, 7], [5, 0, 11], [0, 6, 7], [5, 0, 9], [3, 6, 7], [5, 0, 8], [5, 6, 7], [5, 0, 10], [3, 6, 7], [5, 0, 10], [1, 6, 7], [2, 4, 6], [1, 8, 11], [2, 4, 6], [2, 8, 11], [2, 4, 9], [5, 8, 11], [2, 4, 10], [2, 8, 11], [2, 4, 10], [4, 8, 11], [2, 4, 8], [4, 8, 11], [3, 0, 9], [5, 11, 7], [3, 0, 10], [2, 11, 7], [3, 0, 9], [0, 11, 7], [3, 0, 9], [5, 11, 7], [3, 0, 10], [3, 11, 7], [3, 0, 7], [4, 11, 7], [5, 0, 10], [4, 0, 10], [2, 5, 6], [2, 11, 10], [2, 6, 10], [2, 4, 9], [0, 9, 10], [3, 0, 7], [2, 5, 6], [1, 10, 9], [1, 4, 11], [5, 10, 11], [0, 4, 8], [0, 9, 8], [2, 11, 10], [2, 8, 6], [3, 6, 7], [0, 8, 10], [4, 0, 9], [3, 5, 8], [5, 11, 10], [2, 11, 10], [4, 11, 8], [1, 3, 11]]\n", + "factor = 1 / len(hard_clauses) / 4\n", + "\n", + "# convert to a NetworkX graph\n", + "hard_graph = nx.Graph()\n", + "for i, j, k in hard_clauses:\n", + " hard_graph.add_edge(i, j, weight=0)\n", + " hard_graph.add_edge(j, k, weight=0)\n", + " hard_graph.add_edge(k, i, weight=0)\n", + "for i, j, k in hard_clauses:\n", + " hard_graph[i][j]['weight'] += 1\n", + " hard_graph[j][k]['weight'] += 1\n", + " hard_graph[k][i]['weight'] += 1\n", + "pos_hard = nx.spring_layout(hard_graph)\n", + "nx.draw_networkx(hard_graph, with_labels=True, pos=pos_hard)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "d37be898", + "metadata": {}, + "source": [ + "We first solve this problem by two classical methods." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f22b5956", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:14.525210200Z", + "start_time": "2023-06-30T02:29:14.223057500Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost: 0.000\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print BF results\n", + "bf_best_cases, bf_best = brutal_force(hard_graph)\n", + "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "9df75fbc", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:53:22.166071800Z", + "start_time": "2023-06-30T02:53:18.629941Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "output: 111000010001\n", + "cost: 0.000\n", + "prob: 0.090\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVyT6/vHP9sYXdJIWCgqBqDYimK3mOjX7u7u7s5jezzGwWN3HTGP3YmYYKCYICixfX5/4PYTqY1thD7v12sv8Xnu2hjPdd33VSKShICAgICAgMBvizirFyAgICAgICCQtQjKgICAgICAwG+OoAwICAgICAj85gjKgICAgICAwG+OoAwICAgICAj85gjKgICAgICAwG+OoAwICAgICAj85uip0kgul+PVq1cwMzODSCTS9ZoEBAQEBAQEtABJREVFIXfu3BCLU9//q6QMvHr1Ci4uLlpbnICAgICAgEDmERYWBmdn51Tvq6QMmJmZKQczNzfXzsoEBAQEBAQEdEpkZCRcXFyUcjw1VFIGFKYBc3NzQRkQEBAQEBDIYaRn4hccCAUEBAQEBH5zBGVAQEBAQEDgN0dQBgQEBAQEBH5zBGVAQEBAQEDgN0dQBgQEBAQEBH5zBGVAQEBAQEDgN0dQBgQEBAQEBH5zBGVAQEBAQEDgN0dQBgQEBAQEBH5zBGVAQEBAQEDgN0dQBgQEBAQEBH5zBGVAQEBAQEDgN0dQBgQEBAQEBH5zBGVAQEBAQEDgN0dQBgQEBAQEBH5zBGVAQEBAQEDgN0cvqxcgICAgICCgNUjg+XPg5UtAJgMsLIDChQEDg6xeWbZGUAYEBAQEBHI2CQnAvn3AmjXA2bNAZGTS+3p6QNGiQKtWQJcugL191qwzGyOYCQQEBAQEci67dwOurkDTpsCRI8kVASBRWbh1Cxg3DnB2BgYMAKKjM32p2RlBGRAQEBAQyHlERwNt2gD+/kB4eOI1mSztPnJ5omKwdCng4QFcuqT7deYQBDOBgIBAlpEgl+PAhw84+uEDLkZGIjgmBrEk9EUiFDQyQllzc1TPlQuNbWygLxb2LgLfiYoCatYErlxJ/D+pXn+5HHjxAvD1BQ4fTvz3N0dEpv8pRkZGwsLCAp8/f4a5uXlmrEtAQOAXJl4ux6IXLzDvxQuEx8VBTyRCQgqPIsV1G6kUA52dMdTFBQaCUvB7QwJ16gD//pv+SUB6iMWJjoXXriU6Gf6CqCq/hb8qAQGBTOXOly/wuXoVw588QXhcHACkqAj8eP1dfDzGPX0KzytXcC0qKtPWKpANWbkSOHo0VUXgKoA6AMwBmAGoBeBGamPJ5UB8PNC+veaKRQ5HUAYEBAQyjZMfP6LMtWu4GxMDNQ92QQAhMTEof+0aDr5/r4vlCWR33rwBBg9O9fY1AJUAPAEwAcB4ACEAfAEEp9YpIQG4fBlYsUK7a81hCMqAgIBApnA5MhJ1b99GrFye6klAesgAxJNocucOTn/6pNX1CeQA1qwBYmNTvT0OgBGA8wCGABgG4D8AcgCj0xt77tzEk4LfFMGBUEBAQOfEyGRode8e4uVyJHvcPniQGBJ2/Xrizs/cHChSJDEe3MUl2VgEICPR6t49PChTBhZ6wmPst0AuB5YtS1Ngn0GiicD6h2uOSDwZ2A/gCwDT1Do/f57oh1CzpnbWm8MQTgYEBAR0zvinT/H82zekaJXduhU4fRrw9gb69gUaNEiMCe/eHXj6NMXx5AAi4uIw7PFjXS5bIDsREgK8fp1mk1gkngz8jDGAOAB30uqspwccP57h5eV0BGVAQEBAp3yMj8eSly+TnwgoaNEC+PtvoH9/oH59oF07YPHiRIeuLVtSHVcGYN3r13iVxrGxwC/E1avpNnEHcAFIonTGAbj4/eeXaXVOSPit8w4IyoCAgIBOWR8ejvi0fASKFQOk0qTXnJ2BvHkTj27TYXU6u0WBX4SQkMTdexr0BvAQQBcA95B4EtAegOIb8jW9OR480GyNORjB2CYgIKBTtkdEqB05ABL4+DFRIUgDGYBtb99iQjrtBFJHLpcjPj4e8fHxiIuLQ1xcXJKf0/u/Lu6l1HZkZCT6JSRAP4330hNAGIA5AP78fq00gOEApiENfwEFv/Epk6AMCAgI6AwZietfvqjf8fhx4N07oFOndJsGx8Tgm0wGQ4kkAyvULiSRkJCgFeGnLSGa3r2EhAStvHexWAx9fX3lSyqVpvhzSvckEgn09PSUL/H3xFLx8fFISEhATEwMPsfFQaTCOqYBGArgLgALAMXx/5EEhdLrbGiYsTf/CyAoAwICAjrj2bdv+KZuuFZoKLBoUWLu+Nq1020uA7D53Dnk/Wl3m1UCVlsYGBikK0R/vmdkZAQLC4s0+6krqFW5pxDoCuLi4vDmzRuEh4fj9evXCA8PT/Lz69ev8eTJE4SHhyP2p924qakpHBwc4ODgAA8PDzg4OMDR0RElHzyAdONGlT67XEjMN6DgOABnAGnmGBSJEr9zvymCMiAgIKAzotTddX74AIwaBZiYABMnAiru9rv27Qvcvp3q/YwKPxMTE50K0dT+L5FIIBKpsg/OPEji8+fPSkGempAPDw/H+5+SQonFYtjZ2SkFe9GiReHn5wdHR0flNYUCYGqaeJj/5s0bnDp1CidPnsRff/2Ftffvo14G1h0I4DKAuUjHSU4iAXx8MjDDr4GgDAgICOgMPXUE2pcvwIgRif8uWgTY2KjcdcumTShrapqigNXT08t2gjU7ERcXh7dv3yYT6CkJ+Z938SYmJkkEepEiRZIId8W/tra2SU4OUuL169fYv3+/UgF48N2Zz93dHb6+vqg6dizihw6F3uvXqZoLTgOYjMQUxNZIjCxYj8TcAwPS+yASEoBatdJr9csiKAMCAgJa59OnT7hx4wb+u3ULKFEi/Q5xccCYMYmV5ObOTddx8GcqFyoE59/Y3vszP+7ifxbsPwv5tHbxDg4OKFKkCKpVq5aikFfs4jPCq1evcOrUKaXwDw5OTBhcuHBhVK1aFRMmTICvry8cHR3x6tUrLFmyBPc/fsQEAKmpFU7f780BEAUgH4CpAAYjHWEnEgFubr919UJBGRAQENCIN2/e4Pr167h27Zry3ydPngAAjIyMoL95M+Jy5Up9AJkMmDQJuHsXmDpVbbutlZ4enAwMNHkLOYb4+Hi8efMmzd274vXt27ckfX/cxSuE/M9H9I6OjrCxsYGeDrI6vnz5Uin4T506hYcPHwIAihQpAj8/P0yaNAm+vr5wcHBQ9rlz5w5Gjx6NzZs3w9DQEIO6dIFowwYwOjrF04ECAI5kZHEkMHx4olLwmyIoAwICAipBEqGhoUmE/vXr1/Hq1SsAgIWFBby8vNC4cWN4e3vDy8sL7u7u6BISgi1v36Zej2DFCuC//4AKFRLr1B87lvR+GulhJQAqWVjkaDOAYhef3hF9eHg43r17l6SvSCSCnZ2dUqAXLlw42S5e8bMmu/iM8OLFiyTCPyQkBABQtGhR1KhRA1OnTkWVKlVgb2+fpB9JBAUFYe7cuTh06BCcnJwwffp0dOvWDfr6+th47x46BgVpb6F6ekD58kDnztobMwciKAMCAgLJkMlkCAkJSbbj//jxIwDAzs4O3t7e6NixI7y8vODt7Y18+fKlKJS7Ojpi45s3qU/26FHiv//9l/j6mTSUARmAHrlzq/PWMg3FLl4VIf/zLt7Y2BiOjo5JhHxKzna2trY62cVnhLCwMKXwP3nyJB5/TxXt4eGBWrVqYfr06ahSpQrs7OxS7B8fH49//vkHc+fOxfXr11GiRAn89ddfaNmyJfT19XH37l20atUKjx89QhVPT+S7dQsiTQsLSSSAsTGwYQMg/r1z8GWPb5GAgECWERcXh3v37iUR+jdv3kR0dDQAIE+ePPD29sagQYOUO35HR0eVd+OVLCzgYWyMBzExKdcmWLgwQ+sWA3AxMEAdK6sM9c8IJBEZGamSs11qu3iFQFfYxlMS8mZmZpn2njJKaGhoEuGvMA0VK1YMdevWRdWqVVGlShXY2tqmOU5UVBTWrFmDhQsXIjQ0FLVq1cLRo0dRo0YNiEQikMTKlSsxcOBAFChQAJevXEH+AgWAhg3BoKCMKwQKReDYMSB//oyN8QshKAMCAr8R0dHRuHXrVpId/507dxAXFweRSAR3d3d4eXnB398fXl5e8PLygpWGwlYkEmGluzsqX7+upXeRiBzASnd3iLVgIvhxF5/a7l3xc2q7eIVAd3d3T9WjPrvs4jPC8+fPkwj/p9+LSBUvXhz169dXCn8bFaNAXr58iSVLluCPP/5AdHQ0WrdujSFDhqBkyZLKNh8/fkS3bt2wY8cO9OjRA/Pnz4exsXHizQMH8Kh+fRT891/IRSKI1SmLLRIBhQoB27YlpsMWEJQBAYFflY8fP+LGjRtJdvzBwcGQy+WQSqXw8PCAt7c3OnXqBG9vb5QoUUJnduWKFhZoZ2iIjTEx2jmOlcvhfOsWynt7p9rk5118WkI+rV28g4ODMrztZzu8wqM+J/sspMazZ8+U9v6TJ0/i2bNnAICSJUuiYcOGqFq1KipXrqyy8Fdw+/ZtzJs3D1u2bIGRkRF69OiB/v37w9nZOUm7c+fOoU2bNoiMjMT27dvRrFmzJPfffPqE8jduoH+VKhgYHAzzN29AiQQiWYrnT//vHGhgAAwbBowdC+inldz490JEpq9ORUZGwsLCAp8/f4a5uXlmrEtAQH1I4ORJICgIuHwZCA5ODFkzNgaKFwdKlwbq1gU8PbN6pVonPDw8mWOfYudmZGQET09PpW3fy8sLHh4eMMhED/wzZ86gQePGwKRJiCpeXP1aBT8gBlA0NhZPAwJgbW6OXr16IT4+PkUhn9YuPqXdu+LnnL6LVxeSyYT/8+fPIRKJULJkycQ4/+/C39raOkPjnzhxAnPnzsXhw4fh7OyMgQMHomvXrrCwsEjSViaTYebMmZgwYQLKlSuHzZs3I0+ePMnGa9asGc6ePYs7d+6gfr16qAZgdqFCwJkziSGqP2Jiklgiu1WrxKqYv5EcU1V+C8qAQM5HJgNWrgTmzQOePEn0DpbJEpUDBYqEJzJZYpaxUaMAf/+sWa8GKB7aPzv2hYeHAwAsLS2TCH1vb28UKlQo3YQvumT37t0ICAhAhQoV8M+uXRj6+jU2hIcDcrl6pwSK9idPAtOnAz+k/s2VKxdcXV3TFfK/6i5eXUji6dOnSYR/aGgoRCIRPD09UbVqVfj6+qJy5coamYl+dgosWbIkhg0bhpYtW0L6c6VKJJoO2rVrh5MnT2LMmDGYMGFCikrZ1q1b0aZNG/zzzz/InTs3KlasiP3796N+/fqJDT58AF69wrrVq7F4wwbc+Pjxt3UQFJQBgd+D+/eB9u2BK1cSjwFVsRuKxYmCxd8f+OMPIBXv5qxGJpPh4cOHyXb8nz59AgA4ODgkEfpeXl7ImzdvthJ2f/zxB/r06YNq1aqhT58+eP/+PR49eoT5ly5BNmgQ5Kamib+ztB7U33+n+vHxaPz0KWrp6SH3dyEvlUrRq1cvXLlyBevXr0fr1q0z6Z3lLEjiyZMnSnv/qVOnEBYWBpFIBC8vryTCP1daOSFUJDIyUukUGBYWhtq1a2Po0KGoXr16qt/P/fv3o2PHjjAwMMCmTZtQrVq1FNuFh4fDw8MDNWrUQGBgIFq1aoXr16/jwYMHygJHCtauXYuuXbsiLi4uReXjd0BV+f37nIMJ/HqcOAE0aPD/O0RVHYgU3sd79wIXLiTuNAulW89Mp8TFxeHu3bvJPPpjYmIAAPny5YOXlxeGDh2qdOxzdHTMkrUqbPFp2eFfvXqFJ0+eKNf/77//4t9//4VIJIKBgQHk8fGoqKeHBF9fhJQogXffvedFJMQiEWQ/nBq4Gxujn7Mz2tnbwzyFXeK///6Lbt26oU2bNnj48CHGjx+frRSirIAkHj9+nET4v3jxAmKxGF5eXmjZsqVS+FtaWmpt3pcvX2LRokVYuXIlYmJi0KZNGwwZMgQl0shCGRsbi+HDh2Px4sVo0KAB1q9fn6ofAkn06tULEokES5cuRVhYGHbs2IEFCxYkUwQAKMf58OFDsnwGAkkRlAGBnMm5c0C9eomKQEZDi2QyICICqFIFuHgR+MkuqSuio6Nx8+bNZB798fHxEIvFcHd3h7e3N5o1awZvb294enpqZbeWHgkJCSp71H/9+jVJXyMjoyRH8iKRCDExMWjSpAm6dOmC3Llzw8HBAffv30eNGjXwxx9/oEePHsr++Tw98drMDLO2bsU3uRx/rVsHw3fvcGD+fNin4+RlYGCAP//8E+7u7hg7diyCg4Oxbt06GP5G6YlJ4tGjR0rhf/LkSbx69QpisRje3t4ICAhA1apVUalSpWQ2em1w69YtpVOgsbExevbsiX79+iVzCvyZ4OBgBAQE4N69e1i0aBH69euXpiK3detW7N69G9u3b4etrS1GjhwJExMTdOzYMcX2irDGiIgIQRlIB8FMIJDz+PwZKFwYePtWJUVgGoCxADwA3EmpgZ4eULYscPq01u2KHz9+TGbfDw4OBklIpVIUL148yTF/iRIlYGJiorX5SSIqKkplj/ofHwcikQi2trbp2uEVcfEikQixsbFo27Ytdu7ciT/++APdunVTjhcbG6tUbM6ePZtkJ2dkZIQ8efIoi9P069cPQUFBuHMnxd9Yqvzzzz9o3749PD09sXv37l9WAJBESEhIEuH/+vVriMVilCpVClWrVkXVqlVRsWJFnQh/xRr+/fdfzJ07F0eOHIGLi4vSKTA9OUESf/75J/r27QsnJyf8/fff8PLySrOPwjxQs2ZN/P3334iJiYGzszM6dOiABQsWpNjn4cOHcHd3R1BQEKpWrZrRt5qjEcwEAr8uQ4cm7uhVUAReAJgOIE3xmpCQeNKwfDnQt2+Gl/X69etk9n1FOJaJiQlKliyJGjVqYNiwYfD29kbRokWhn8HQpoSEhCSV5tIS8unt4itXrpyqR706dtbIyEg0adIE58+fx44dO9CkSZMk9+fMmYNHjx7h2rVrSRSBT58+4du3b/D8IcrD1dUVz58/B0m1jvxbtGiBPHnyoFGjRihbtiz279+PYr9AHDlJBAcHJ4nzDw8Ph0QiQenSpdGuXTul8Nf1hi0+Ph6BgYGYO3cubt68CU9PT2zevBktWrRQ6fsSGRmJnj17YuvWrejUqRMWL16cbkgrSfTs2RN6enpYunQpAGDTpk349OkT+vXrl2q/H08GBNJGUAYEchbPnwNr16rsHzAUQDkkpq19l05bTJoEdO+ebuyxwhP75x3/m+8pd3PlygUvLy80b95cuesvWLBguh79il18ekf0qe3ibWxslALdzc0tVSGv2MVrk/DwcNStWxdPnz7F0aNHUbly5ST3Q0JCMHXqVAwZMgTFixdPcm///v0AAD8/P+U1V1dXfPnyBZ8/f1bbpl2mTBlcunQJDRs2RIUKFRAYGIi6detm7I1lESTx4MGDJN7+b968gUQigY+PDzp06KAU/pmVrTAyMhKrV6/GwoUL8eLFC9SpUwfz5s2Dn5+fyt+ny5cvIyAgABEREdiyZYvKDp9btmzBnj17sGPHDtjY2IAkFi9ejEaNGiF/GtkDLSwsIJFIkuWREEiOoAwI5CxWrUo8yk8tscgPnAawHcB1AKnvHX7g3Ttg926gZUvlJZlMhuDg4CRC/8aNG0qPfkdHR3h7e6Nbt27Ko/48efIkeTj+aItPS8iHh4crHe4UGBoaJslRrxDwPx/bq7uL1yaPHj1CrVq1EBsbizNnziQT9iTRu3dvODo6Yvz48cn6H/temOjHkwRXV1cAiSlvM+Lg5urqirNnz6JNmzZo0KABFi5cmOYOMqshifv37ycR/m/fvoWenh58fHzQuXNn+Pr6okKFCpmeqvjFixdYtGgRVq1aha9fvyqdAn/+PaeFXC7HvHnzMHr0aHh5eeHo0aMoUKCASn1fv36Nfv36ISAgAE2bNgWQ6DR69+5dLFmyJM2+YrEYNjY2gjKgAoIyIJCz2LxZJUVAhkQFoCsAVR9ZlEjw6Y8/sCMyUin8b968qTxmz58/P7y8vDBs2DB4enqiYMGCIKkU6KGhobh48WIyIR8REYGfXXMUtnhHR8cku/ifhbwudvHa5OrVq6hbty6srKwQFBSULDkMkLirO378OA4ePPj/qWR/4Nq1a9DX109SwMbFxQVAYvGbtDzR08LMzAy7d+/GsGHD0L9/fwQHB2PhwoXZIpkQSdy7dy+Jt39ERAT09PRQpkwZdO3aVSn8M7vaoIKbN29i3rx52Lp1K0xMTNCrVy/069cPTk5Oao3z5s0bdOjQAUeOHMHw4cMxZcoUlc1jCvOAVCpNIvgXLlyIEiVKqOQHYGNjI5gJVCDr/yoEBFTl06dEM4EK/AHgOYDjagwvkskQExSE7idPIm/evMibNy8aNmyoFMgfP35EeHg41q5dm+YuXiHIK1WqlKKznZ2d3S8R83z8+HH4+/ujaNGiOHDgQIrhYB8+fMDgwYPRsmXLVI/qnz17lixM0tHRERKJBKGhoRqtUSKRYP78+XB3d0efPn3w6NEjBAYG6sypLjXkcnkS4X/69GlERERAKpWiTJky6N69u1L4a9OBVF1I4vjx45g7dy6OHj0KFxcXzJ49G127ds3QicTRo0fRrl07AMCRI0dQq1Yttfpv3rwZe/fuxc6dO5Xfr5CQEBw4cABr1qxRSVG2tbUVTgZUgSrw+fNnAuDnz59VaS4goBtOnSITvQXSfL0DaAVw7g/XfAF6qNCXAC0B4oeXra0tixcvzpo1a7J9+/YcPnw4FyxYwK1btzIoKIgPHjzgp0+fKJfLs/oTyjS2bt1KqVTKOnXq8MuXL6m269atG83Nzfnq1asU73/79o0AWL9+/WT38uTJw5EjR2ptzceOHaOFhQWLFi3KJ0+eaG3clJDJZLx16xYXL17Mpk2b0tramgAolUpZqVIljh07lsePH2d0dLRO16EqcXFx3LhxI0uUKEEA9PLy4pYtWxgXF5eh8WJjYzls2DACYK1atRgeHq72GK9evWKuXLnYunXrJNf79etHGxsbxsTEqDRO8+bNWaNGDbXn/1VQVX4LyoBAzmHvXpWEeU+AbgBjM6gMHF+7lpcvX+aLFy8y/DD8lVm0aBEBsF27dml+PmfPniUALlu2LNU2Bw4cIADOnDkz2b3KlSuzTZs2Wlmzgvv37zN//vy0tbXluXPntDauTCbjzZs3uWjRIvr7+9PKyooAqK+vz8qVK3PcuHH8999/s43wV/Dp0yfOmTOHzs7OBMC6devy33//1UixffToEX18fKinp8fZs2dTJpOpPYZcLmfDhg1pb2/Pd+/eJVmvqakpx4wZo/JYvXr1oqenp9pr+FUQlAGBX4/9+9MV5A8BigEuBvj0h1dZgIW+//w+PYUgLCyr32m2RC6Xc9SoUQTAoUOHpvmQj42NpYeHB8uUKcOEhIRU2/Xt25cA+ODBg2T3/ve//7FSpUpaWfuPREREsFKlSjQwMODmzZszNIZMJuP169e5cOFCNmnSJInwr1KlCsePH88TJ06ovHvNbEJDQzl06FCamZlRKpWyY8eOvH37tsbjbt68mWZmZsyfPz8vXbqU4XE2btxIANy1a1eS6wsWLKCenh5fvnyp8ljjxo2jk5NThteS0xGUAYFfj6tX01UGgn464k/pNSCtMcRiMps+wLOS+Ph4du7cmQA4d+7cdNvPmDGDEomE169fT7Odj48PJRJJijvRUaNGMU+ePBlccdp8+/aN7du3JwCOHz8+3Z1wQkICr127xgULFrBx48bMlSsXAdDAwIBVq1blhAkTGBQUlG2Fv4IbN26wbdu21NPTo4WFBUeOHKmWYE2NqKgoduzYkQDYpk0bjWTFy5cvaWlpmexUKCEhgfnz509mNkiPRYsW0cDA4Lcy4/2IoAwI/HrExpJ6emkqAxEAd6Xw8gDo+v3nW2kpA0WKZPW7zHZER0ezYcOG1NPT419//ZVu+8ePH9PQ0JBDhgxJt62VlRXt7e1TvLd8+XJKJJI0TxY0QS6Xc/r06QTAgICAJII8ISGBV69e5bx589ioUSNaWloqhX+1atU4ceJEnjx5kl+/ftXJ2rSJXC7nkSNHWLNmTQKgq6srFyxYwMjISK2Mf/36dbq7u9PExIQbNmzQSOjK5XI2aNAgmXmAJHfv3k0AvHDhglpjbtmyhQC09n5zGoIyIPBr4uOTuHtX0f6vjs+AXCIhe/TI6neYrXj//j0rVKhAY2NjHjp0KN32crmctWvXpqurK6OiotJsK5PJKBKJ6Ovrm+L9/fv3EwDDdGy2+eeff2hoaMjixYtzwoQJbNCgAS0sLAiAhoaG9PPz4+TJk3nq1KkcIfwVxMbG8s8//2Tx4sUJgN7e3ty6dSvj4+O1Mr5cLueiRYuor69PLy+vFE096vLnn38SAHfv3p3sXrVq1Vi2bFm1xzx69CgB6NxpNLsiKAMCvyarVlGupiKgqjJAgH18fLhnzx6d7UZzEmFhYSxatCitra1V3o39/fffBMC9e/em2/b8+fMEwFGjRqV4/9atWwSgVUc/BfHx8bx8+TLnzJnD+vXr08TEhAAoEolYtmxZTpkyhadPn+a3b9+0Preu+fTpE2fPnk0nJycCYL169XjixAmtHpNHRESwQYMGiWa3AQO08jkpzAP/+9//kt27efMmAXDr1q1qj3v9+nUC0MiHIScjKAMCvxxxcXFcMXcuIwHKMqAQpHcq8N7VlWXLlCEA5suXj3PnzuWHDx+y+m1nCffu3aOLiwtdXV1V3vF9/PiRDg4ObNq0qUrtx4wZQwD877//Urz/6dOnDAuAn4mPj+elS5c4e/Zs1qtXj+bm5gRAIyMj1qhRg1OnTuWOHTtYokQJmpmZ8cCBAxrPmdmEhoZyyJAhSqfATp068c6dO1qf58SJE8ydOzetra25b98+rYypMA84ODjw/fv3ye536dKFTk5OGYruCQsLI4Ac+TvVBoIyIPDLIJfLuX37dhYsWJAikYgbypfXqiJAgBSJyLNnSZIXL15k27ZtKZVKaWxszJ49e/Lu3btZ/ClkHv/99x+trKxYrFgxvnjxQuV+vXr1oqmpqcrH+lWrVqVIJErzFMbc3JyzZs1SeQ0K4uPjefHiRc6aNYt169almZkZAdDY2Jg1a9bktGnTeO7cOcbGxibpFxUVxQYNGlAsFnPRokU5wuns2rVr/N///kc9PT1aWlpy1KhRqeZ10IT4+HiOHTuWIpGIVatWVeu7kR4K88CePXuS3YuIiKChoSGnTZuWobG/fv1KAPzzzz81XWaORFAGBH4Jzp49y3LlylERA33z5k1SLierVSMlEq0oAgkAQ5s3Tzb369evOWnSJDo4OBAAq1ev/subEPbv308jIyNWrlyZHz9+VLnf+fPnKRKJuGjRIpX7ODg4MFeuXGm28fDwYN++fdMdKy4ujufPn+fMmTNZp04dmpqaEgBNTExYq1YtTp8+nf/9918y4Z8SCQkJHDx4MAGwd+/eWrOxaxO5XM7Dhw+zevXqBMA8efJw4cKFOnOSe/bsGStUqECJRMKpU6dq9W9AYR5o27ZtivenTZtGQ0NDRkREZHgOU1NTlaJgfkUEZUAgR/PgwQP6+/tTkQ3t+PHjSRtERJCFCmmsEMgAXrSyorGeHjdt2pTiWmJjY7l582alUvKrmhDWr19PiUTCJk2aqBUiFxcXxxIlSrBUqVIqCwm5XE6JRMLSpUun2a5u3bps1KhRinP+999/nDFjBmvXrq20+ZuYmLB27dqcMWMGz58/r1HSqJUrV1JPT4+1atXip0+fMjyONomNjeWGDRuUToGlSpXi33//rVOFZfv27bS0tKSrq6vW/Tfkcjnr16+fqnkgLi6OuXPnZpcuXTSaJ1++fFrNZpmTEJQBgRxJeHg4e/XqRYlEQldXV27atCn15DZv3pDe3olH/Or6CHz/d4dYzHYtWypjpKdNm5bm0fClS5fYrl07pQmhR48eOrHLZiZyuZwzZ84kAHbv3l1twTJnzhyKxWJeuXJF5T7BwcHKnXda9OjRg56enoyNjeW5c+c4bdo01qpVSyn8TU1NWbduXc6cOZMXLlzQesbI48eP09LSkkWLFuXjx4+1OrY6fPz4kbNmzWLu3LmpSN8cFBSkUzNGTEwMe/ToQQBs1qyZTpTfDRs2pOlwqggLvHXrlkbz+Pj4aKxQ5FQEZUAgR/HlyxdOnjyZpqamtLS05Jw5c1QL44qLIydPTsw/oOIpgQxglEjE+HXrGPjd+33cuHGcMGGCygLxZxOCn58fd+/eneNMCDKZjAMHDlR+BuoKl2fPntHY2JgDBgxQq9/s2bMJIFUHtNjYWJ49e5Y1atRQKl4AaGZmxnr16nHWrFm8ePFiphzh379/nwUKFKCNjQ3PfvcrySyeP3/OQYMG0dTUlPr6+uzcuXOm+K/cvn2bHh4eNDQ05MqVK3WidLx48YIWFhZs165dqm3Kli1LPz8/jeeqV68eGzdurPE4ORFBGRDIEcTHx3P16tV0dHSkvr4+Bw8enOJxYbo8fkwOHcqo7wqBHGCcSERKpYkvhTLg5MTwgQNpJxJx8eLFJBOz5SkcjNatW0c9PT3Wq1cv3Th5MlFobdmyRWlCyJs3L+fMmZMjTAixsbFs3bo1RSJRmvUDUkNxxOvk5KS2rVoRlqbI1f/t2zeeOXOGU6ZMYY0aNWhkZERFnD8ATp06lZcuXcoy+31ERAQrV65MfX39VM1J2uTatWts06YNJRIJc+XKxdGjR+vEKfBn5HI5V6xYQUNDQxYrVkxnp15yuZz16tWjo6Njqn8rFy5cSNWpUF3at2/PChUqaDxOTkRQBgSyNXK5nPv27WPRokWpSGGqaVKQz58/00giYeDw4Zzq4sLDJUqQAwaQI0eSf/5J3r1Lfjc5dOrUiba2toyMjKRcLmfXrl0plUoZFBTEI0eO0NTUlKVKleLr169Vnv9nE0L37t21ku9dF0RGRrJmzZrU19fnP//8k6Extm/fTgDcuXOn2n1dXV1paGjIyZMn08/PTyn8zc3N2aBBA86dO5eXL1/miRMnCID37t3L0Bq1ybdv39ihQwflKUpGCvCkhVwu56FDh+jn56dULBctWqSSUqoNPnz4wGbNmhEAe/bsqdPUyuvXr0/zZIgkW7duzfz582vltG3w4MEsVKiQxuPkRARlQCDbcunSJfr6+hIAq1WrppatOS3++ecfAuDTp09pY2PDqVOnpto2NDSUBgYGnDhxIslER6WaNWvS0tKS9+7d4/Xr15k7d27myZNHbUEUHh7OyZMn09HRUWlC2LVrV7YxIbx584alS5emmZkZT5w4kaExPn/+zNy5c7NRo0YqHSF//fqVp06d4qRJk1itWjUq6kRYWFiwYcOGnDdvHq9evZrsM3ry5AkB8MiRIxlap7aRy+XKk6SWLVtqRWDGxsZy/fr1LFasGAGwdOnSDAwMzNRTkDNnztDFxYWWlpbcvn27TudSmAfat2+fZhs9PT0uWLBAK3POmDEj3ciVXxVBGRDIdjx+/JgBAQEEQA8PDx44cECrtsiOHTvSw8ODX758IQBu3LgxzfZDhgyhqakp37x5QzIxyY2Hhwfz5cvHN2/eMDQ0lMWKFWOuXLl46tQptdcTGxvLrVu3snz58sqd3uzZszNmBtEST548oZubG+3t7Xnt2rUMj9OvXz+amJjw+fPnKd7/+vUrg4KCOHHiRFatWpUGBgYEQEtLS9aqVYuKzHjpKUixsbEUiURcvXp1hteqC7Zv304jIyOWLVtWrdOjH/n48SNnzpypdAps0KABT548mam5DRISEjh58mSKxWJWrFgx1d+ntpDL5axbty5z586dpilt9OjRNDU11VoUx+rVqwkgW4aJ6hpBGRDINrx7944DBw6kVCpl7ty5uXbtWq3vkmUyGe3s7Dh8+HDev3+fANIV4O/evaO5uXkS57dnz57RwcGB5cqVY0xMDD9+/Eg/Pz/q6+trlAnv8uXLbN++PfX19WlkZMRu3bpp7CGtLjdu3KCDgwMLFCigkWf8pUuXKBKJOG/ePOW1mJgYnjhxghMmTKCvr69S+OfKlYuNGzfmggULeP36dSYkJCgfzKomgcmdOzfHjRuX4fXqisuXL9PR0ZGurq6J+S9U5NmzZxw4cKDSKbBLly5ZYgZ58eKFMvHTuHHjMkVQrlu3jgC4f//+VNvExMTQ2tqa/fv319q8iiJHCsX/d0JQBgSynJiYGM6aNYsWFhY0MzPj1KlT+eXLF53MdenSJaUCcPjwYaW5ID2mTZtGfX39JG0vX75MIyMjNm/enDKZjLGxsWzXrh0BcPbs2Rrt3N68ecMpU6YoTQjVqlXjzp07dW5CCAoKorm5Ob29vRkeHp7hceLj4+nl5cUSJUrw6NGjHDduHKtUqUJ9fX0CoJWVFf39/blw4ULeuHEjRbu64nRI1SQy5cqVY4cOHTK8Zl0SFhZGT09Pmpqappvu9urVq2zdurXSKXDMmDEZPlXQlL1799La2ppOTk4MCgrKlDnDwsJobm6e7u9yzZo1FIlEDAkJ0drcZ8+eJYAcHwacEQRlQCDLkMlk3LhxI11cXKinp8e+ffvqXCMfP348LS0tGR8fz5UrV1IsFqsUc/7lyxc6ODgkC2/avXs3RSIRhw8fTjLxeHPs2LHK2HhNhXdcXBz//vtvVqhQQZlBTlcmhO3bt1NfX581atTIcIa66OhoHj9+XFkGV09PjwBobW3Npk2bctGiRbx586ZKTnXu7u40MDBQee6WLVuyWrVqGVp3ZhAVFcVGjRqlmMJYLpfz4MGDSqfAfPnycfHixTpTitPj69ev7N+/PwGwYcOGGmX1Uwe5XM46deowd+7caWa2lMvlLF68OBs0aKDV+RV5LU6ePKnVcXMCgjIgkCUcPXqUnp6eykQlDx8+zJR5S5UqxYCAAJKJBXBcXFxU7rt8+XKKRKJkR70LFiwgAK5cuVJ5bdWqVZRIJGzYsKHWHuhXrlxhhw4ddGJCWLFiBUUiEQMCAlRKxavgy5cvPHbsGMeMGcNKlSpRKpUqnf7y58/PJUuW8NatWxnyqDc2Nma+fPlUbj906FC6ubmpPU9mkpCQwKFDhxIAe/XqxaioKK5bt44eHh4EQB8fH27bti1LbdYPHjygp6cn9fX1uXjx4kz1TVi7di1VKRakiB45duyYVud///49AWQ4ciYnIygDApnKjRs3lI5hFSpUSLUSnS549eoVAfCvv/4iSbZt25YVK1ZUuX9cXBzd3NxYv379JNflcjn79OlDiUTCw4cPK68fOHCAJiYm9PHx0ejI/WfevHnDqVOnKh3Kqlatyp07d2ZIgMjlcmUSpf79+6crtL98+cKjR49y9OjRrFChglL429jYsHnz5ly6dCn9/Pzo6OiokVOXohKhOglgFi1aRAMDA62H8umChQsXUiwWK80mDRs25KlTp7K04JFcLue6detobGxMd3d3Xr9+PVPnDw0Npbm5OTt27Jhu20aNGtHDw0Prn5dMJqNEIuGKFSu0Om5OQFAGBDKF0NBQdujQgSKRiIUKFeLOnTsz/cG3du1aikQi5ZFnlSpV2KZNG7XG+Pt7JsLTp08nuR4fH8/69evTzMwsyW796tWrdHBwYL58+VQu8asqChNCxYoVCYCurq6cNWuWyiaEhIQEZRrZGTNmpPj7iIqK4pEjRzhq1CiWL19eeexva2vLFi1acNmyZbx7966yr8IBa9u2bRq9N0VuAnVCxnbt2kUAWlW8tM3Tp085YMAAmpiYUE9Pj/r6+ho7amqDT58+sXXr1gTAzp07Z7p5Qi6Xs3bt2nRyckq38NWjR48oEom4atUqnazFzs6OkydP1snY2RlBGRDQKZ8+feKIESNoaGhIOzs7Ll++XOt54VWladOmLF++vPL/efLkUbsoiUwmo7e3NytUqJBMeEZFRdHT05MuLi58+fKl8vrTp09ZpEgRWllZ6SxN7c8mhK5du6bpuf7161c2bdqUEomE69atU16PjIzkoUOHOHLkSJYrV04p/O3s7NiyZUsuX76c9+7dS1FxiIyMpLOzM+vVq6exotetWzcCUMs57OrVqwTAS5cuaTS3Lrhy5QoDAgIokUhoZWXFsWPH8vXr13zw4AHd3NxoY2PDM2fOZMnaLl68yHz58tHMzIxbtmzJkjWsWbOGAHjw4MF02w4cOJBWVlbKrJTapmjRolqNUMgpCMqAgE6IjY3lwoULaW1tTWNjY44bN05nZVNV4du3bzQ1NVUmGEpISMjwceDRo0dTTX/64sULOjk50dvbO8nu6sOHD8pQOl3aI382Ifj6+nLHjh1JTAgfP35klSpVaGhoyMDAQB48eJAjRoxg2bJlKZFICIAODg5s1aoVV6xYwfv376sk3AcNGkQjIyOVojPSw9PTkxKJRC2lIiIiggB0ngxHVWQyGQ8cOMCqVasqnQKXLFmSbNf97t07ZaSFwoSVWeubNWsW9fT0WKZMmSw7nVCYBzp16pRu28jISJqbm+u0sqCvry9bt26ts/GzK4IyIKBV5HI5AwMDmT9/forFYnbr1i3JLjmrOHbsGAHwxo0bJBMfQKo4KqWEXC6nn58fPTw8UowWuHHjBk1NTdmwYcMk9799+8aAgACKRCLOnz8/429GBeLi4hgYGJjEhKCo2Jc3b14aGhqySJEiSuHv6OjIgIAA/vHHH3zw4IHaO/tr165RLBZz1qxZWlm/ubk5HR0d1eojl8tpZGSk8882Pb59+8a1a9cqU2iXKVOG//zzT5qRJbGxscqKmGPHjtW538Pr16+VER8jRozIstM6dcwDJLl48WJKJBKGhobqbE3NmjVjzZo1dTZ+dkVQBgS0xqlTp+jj46PMkpadYnUHDhxIZ2dnpZDTNJ5Yka9g/fr1Kd4/ePAgJRJJsip9MpmMI0aMIAAOGDBA53kDPn36xIULFyq91RWvXLlysU2bNly5ciWDg4M1OtZPSEhg6dKlWbx4ca0Ila9fvxIAq1evrnZfd3d3Dho0SOM1ZIQPHz5w+vTpygqVjRo14unTp1X+bH8sEa2tFMYpcfjwYdrZ2dHe3p5Hjx7VyRyqokgspYp5QCaT0c3NjS1bttTpmnr27ElPT0+dzpEdEZQBAY25d+8eGzZsqMyXnlnJSdShYMGC7N69u/L/mzdvJgCNTBfNmzeni4tLqiWUly9fTgDKqoc/3xOLxfT399fqQ//jx4/ct28fhwwZwtKlS1MsFisd/vT19WlmZkYbGxulCWH79u0ah7EtWbKEALQWGaIIG5swYYLafWvUqMFmzZppZR2q8qNToIGBAbt378779+9neLwdO3bQyMiIZcqU0WqyodjYWGVYY+3atbPc0fL58+c0MzNj586dVWq/b98+rX7PUmPs2LF0dnbW6RzZEUEZEMgwr169Yvfu3SkWi5kvXz5u3bo1W4Z1KRKJ/Gjj10ZBkuDgYEokkjSPpYcMGUKxWMy9e/cmu7dv3z4aGxuzXLlyfPv2bYbW8PHjR+7du5eDBw+mt7e3Uvg7Ozuzbdu2XLNmDdetW0cTExOWL1+e79+/Z1xcHLdt28ZKlSoRAF1cXDhjxowMJZZ58eIFzczM2KNHjwytPyUUAisjjoCdO3emj4+P1taSFpcvX2arVq0oFotpZWXFcePGaU3AXrlyhY6OjnRxcVErhXFqPHr0iD4+PpRKpZw7d26W/53K5XLWrFmTzs7OKoeg1qhRgz4+PjqPQlq0aBENDQ2zNMwzKxCUAQG1iYqK4oQJE2hiYkIrKysuWLCA3759y+plpcr8+fNpYGCQxHGrZ8+eLFmypMZjd+/endbW1qk+0GQyGZs2bUpjY+MUqy5eunSJdnZ2dHNzU8lz/sOHD9yzZw8HDRpELy8vikQipUBv164d165dy8ePHysfZJs2baKenh7r16+fovf1tWvX2KlTJxoYGNDQ0JBdunRR+lWoQvPmzWlvb59mMRl1qVixIkUiUYZOLCZOnEh7e3utreVnZDIZ9+/fr6ymmT9/fi5dulQnoXhhYWH08vKiqalpmjn602PTpk00MzNjgQIFePnyZS2uMOOsWrWKAJLk5UiLO3fuEAA3bdqk45X9/6lhZpWEzi4IyoCAysTHx3PFihW0t7engYEBhw8frpLTT1ZTvXp11qlTJ8m1unXrslGjRhqP/fLlSxoaGnLs2LGptomOjmaZMmXo6OiYouPTkydP6O7uThsbG54/fz7Jvffv33P37t0cOHAgPT09lcLf1dWV7du357p16/jkyZMUdzHz588nAHbs2DFdW/7bt285ffp0Ojs7EwCrVKmSrglh//79BKD1cDQbGxtaWVllqK+iwE1qppuM8u3bN65Zs4ZFihQhAJYtW5bbt2/Xuc9HVFQUGzduTLFYzAULFqi1W42KimKHDh0IgP/73/+yzXNZYR7o0qWLyn26d+9OR0dHtbJjZhRFtJA2omJyEoIyIJAucrmcu3fvpru7O0UiEdu3b6/zEqbaIjIyklKplEuWLEly3cPDg/369dPKHCNGjKCxsXGa9t3w8HDmyZOHxYsXT/Hv4927d6xYsaJSyRowYABLliypFP558uRhhw4duH79+nQfUnK5nMOHDycAjhw5Ui0BEh8fz3/++YeVK1dO04Tw5csX5smTh7Vq1dLqcWp8fDxFIhHLli2bof7Hjx9XOz9BWrx//57Tpk2jvb09RSIRGzduzDNnzmTqEbJMJuOwYcMIgD179lTJSfPatWssVKgQTUxMuGHDhmxz5J0R88C7d+9oZGSUaYmArl27lm3zVegSQRkQSJPz588rbcs1atTQqLZ9VrBjxw4C4JMnT5TX5HI5TU1NOWfOHK3M8eHDB1paWrJ3795ptrt79y4tLCxYu3Zt5QM9IiKCO3bsYP/+/Vm8eHGlt7+1tTU7duzIDRs2qLVDiYuLY/v27dXO3pcS169fZ+fOnZUmhM6dOytT1A4bNoyGhoZ89OiRRnP8jOJB/HMUhqoo/ENOnDih0TqePHnCfv360djYWOkUqO0MkuqyZs0a6unpsWbNmqmeyMnlci5YsID6+vr08vJicHBw5i4yHVauXKmWeYBM9O/R19fPtLLCYWFhKkc4/EoIyoBAioSEhLB58+YEwBIlSvDIkSNZvaQM0alTJxYtWjTJtQ8fPmglZe6PKJK3pLcj3b59O8ViMT08PJII//z587NTp05cv369Mvve4MGD1XL0+vLlC+vVq0epVKrVo/uIiIgkJgSFo+KUKVO0NoeCKVOmEECGv28xMTEEwA0bNmSo/6VLl9iyZUuKxWJaW1tz/Pjx2aq2/YkTJ5grVy4WLlw4mSL29u1b1q9fnwA4cODAbOfH8+zZM5qamrJr164q94mLi6Ozs7NKCYm0heI79Oeff2banNkBQRkQSMLbt2/Zr18/6unp0dnZmRs2bNC5XVRXyGQy2tvbc9iwYUmuX79+nQB44cIFrc0VExNDJyenZJnL3rx5w3/++Yd9+vRhsWLFksT6+/j4cOPGjSmaXBYvXkyRSMQWLVqoZP9+9+4dy5YtSxMTE50pbvHx8QwMDKSZmRkB0MnJidOnT9dqeVtFIhxNHPJsbW3VOlKWyWTct28fq1SpQgAsUKAAly1bprN0t5oSHBxMNzc3WltbK1MYnzhxgo6OjrSxsdHI2VBXyOVy1qhRgy4uLmrJh8DAwCTJwjILExMTzps3L1PnzGoEZUCAZKKT2/Tp02lubk5zc3POnDlTZ0lPMovLly8TSF6bfM+ePQSg1Rhu8v8TqMyaNYu9e/dWZqADQDc3N3bt2pV//fUXQ0NDOWbMGAJpl0rdtWsXDQ0NWbFiRb579y7Vds+fP2fhwoVpa2urc2/xFStWEADXrl3Lzp0709DQkAYGBuzUqZNWTEhOTk40NTXVaIxSpUqptPv8+vUrV69ezcKFCxMAy5Urxx07duQI5ffdu3f09fWlvr4+GzZsSJFIRD8/v2yR7TMl/vjjjwyd+FSoUIG+vr66WVQa5M2bV6cpj7MjgjLwm5OQkMB169bRycmJUqmUAwYM0OpOLyuZOHEiLSwskjlcLV68mPr6+lqJtQ4PD2dgYCB79eql9DQHwIIFC7Jbt27cvHkzX7x4kayfTCZjQEAADQ0Nk0UQ/Mj58+dpY2NDd3f3FHPH3759m05OTsybNy8fPnyo8ftJi9evX9PCwiKJF3hERARnzJihNCFUqlSJ27Zty1AmQrlcTolEwuLFi2u0Tn9/f9aqVSvV++/evePUqVOVToFNmjTRWQEpXRIcHExbW1sCiWWssyqlcHo8ffqUpqam7Natm1r9FMr8zp07dbSy1CldurRa5oxfAUEZ+E2Ry+U8dOiQ0m7dsmVLrTuDZTWlS5dOMXXp0KFD6ebmlqExX79+zb///ps9e/ZU7igBsFChQuzevTsHDhyosgPb169fWbFiRdra2iZxcPyZkJAQurm50c7OLomH85kzZ2hpacmSJUvy1atXGXo/6hAQEEBbW9sUSyTHx8dz+/btyqN2Z2dnTps2Ta1kSo8ePVKGQmrCgAEDWKRIkWTXHz9+zL59+9LY2JiGhobs0aNHtnOwU5V//vmHFhYWdHV1Ze/evZUmpexm2pDL5axevTpdXV3Vlgtt27Zl3rx5s+Skpm7dumzSpEmmz5uVCMrAb8jVq1dZvXp1AmDlypW1ajvPLrx+/ZoAuHHjxmT3WrRoQT8/P5XGefXqFbdu3coePXrQ3d1dKfzd3d3Zo0cPbt26NYkglsvlLFOmDMuUKaNSOFdERATd3NxYuHDhNBP3REREsHz58jQ2NubevXu5Z88eGhoasmrVqiqHaGnC4cOHU/08f+bGjRvs0qWL0oTQsWNHlUwIirTGW7du1Witc+fOpYmJifLzv3jxIlu0aKF0CpwwYUK2cgpUh+joaHbv3p0A2Lx5c2VUwc6dO2lsbEwfH59MUQxVRWFWUrcGwqtXryiVSrPMbt+uXTtWrFgxS+bOKgRl4Dfi2bNnbNu2LQGwSJEi3Lt3b7aJP9Y269ato0gkSnFnWqZMmVS9k1++fMnNmzeze/fuLFSokFL4FylShD179uTff/+drq+BIre+qqV0Hz58SCsrK1arVi3NpCoxMTH09/enSCSiSCRis2bNtJ5cJyWio6OZL18++vn5qfV9effuHWfOnEkXFxelCSEwMDDV42x/f38C0FhQb9u2jQC4efNmZb4ENzc3rlixItvtnNXh1q1bLFq0KI2MjLhq1apkv4urV68yd+7cdHFxyXSHu5RQmAd+rAmiKuPGjaOJiUmWJTUbPHgw3d3ds2TurEJQBn4DPnz4wKFDh1JfX58ODg5cuXKlxsVpsjvNmjVjuXLlUrzn4ODAiRMnkkzMrb9p0yZ269aNBQsWVAr/okWLslevXgwMDMxQvvnatWvT3d1d5c/59OnT1NfXZ4cOHVIVuHK5nJMnT1aucejQoZmSY37UqFHU19fP8JF6fHw8d+zYoUzh6+TklKIJIX/+/DQwMNBorV+/fuXIkSOVn1H58uW5c+fOHOEUmBpyuZzLly+noaEhixUrxrt376ba9sWLF8oUxvv27cvEVSZFJpPRz88vQ+aBr1+/0tbWln369NHR6tJn+vTpGc6CmVMRlIFfmG/fvnHevHnMlSsXTUxMOGnSpN8i33ZsbCzNzMxSjIN/+PCh0jzi5uamFBoeHh7s06cPt23bppViM4rkOatXr1a5jyInekphcTKZjH379iUATpo0ifPnz6dIJGJAQIBO48nv3LlDPT09Tpo0SSvj3bx5k127dk1iQrh69SpJ0sDAIMO+HO/eveOUKVNoZ2enzNo4c+ZMraw5K3n//r3yxKR3794qRfh8+fKFTZo0oUgk4vz587Pk9E9RsfPYsWNq912/fj0BZGmSp9WrV2e4PkZORVAGfkFkMhm3bNnCvHnzUiKRsGfPnloPo8vOKFLSXr9+naGhody4cSM7d+7M/PnzK4V/vnz52LdvX/7zzz86sx8HBATQyclJrRBNRdKdHwuyfPv2TZkI548//lBe3759Ow0MDFilShWtFgpSIJPJWLFiRbq7u2td4VCYEFxdXZU5FwCo7bT16NEj9unTh0ZGRjQ0NGSvXr344MGDFFNQ5zTOnDlDFxcX5sqVS22PeplMpkxJ3b1790yNNHjy5AlNTEwyVMlSLpfT09OTdevW1cHKVGfXrl1aMVnlJARl4BfjxIkTLFWqFAGwcePGGtVVz4k8e/aMtWvXprGxMfPly6cU/sWLF2e/fv04fvx4reauT4uQkBDq6elx1qxZKveRy+Xs2LEj9fX1efr0aX7+/Jl+fn40MDBIUSCcPXuWVlZWLFKkiNYLqyjyJgQFBWl13B9RmBAUkRkWFhacOnVqulEIFy5cYPPmzSkWi2ljY8OJEycm6ZM/f34OHz5cZ+vWJQkJCZw0aRLFYjErVaqkUR2QtWvXUk9PjzVq1MgU+7tMJmO1atWYJ08eRkZGqt3/5MmTaqcr1gVnzpwhgDRNMr8agjLwi3D79m3Wq1ePQGJFtdOnT2f1kjKFp0+fcsOGDezYsSPz5s2rFP5WVlbs378/d+7cmSRvgqKqXWalau3duzctLS3V2rnHxsayWrVqtLS0ZNGiRWlhYcFTp06l2j44OJj58+eng4OD8shdU968ecNcuXJpHOanKop6Ci1atKChoaHSf+LHss8ymYx79uxR1sooWLAgV6xYkeLJi6+vLwMCAjJl7dokLCyMvr6+FIvFnDBhglaOqYOCglJNYaxtli1bRgA8fvx4hvr7+/uzSJEiWe7Y/ODBgxQTlv3KCMpADufFixfs0qULxWIxCxQowH/++SfL/5B0hVwu55MnT7h+/Xp26NCBefLkIQCKRCKWLFmSAwYMUD6Mdu/eneIYEyZMoIODQ6at+fXr1zQ2NlY7m9nVq1cplUopkUhUeiC9efOGPj4+NDEx0UqBlbZt29La2jrTElB5eHhQIpFQJpPx3bt3nDVrltKEULZsWXbt2lXp4FmxYkXu2rUrTafAdu3asUKFCpmydm2xZ88eWllZ0cnJSetC6OHDhyxYsCCtra11tlFQmAd69uyZof5Pnz6lWCzmihUrtLwy9Xn37p1aEUG/AoIykEP5/Pkzx4wZQyMjI9rY2HDx4sWZUus7M5HL5Xz8+DHXrVvH9u3bK4WDSCSip6cnBw4cyN27dydJgqOo2Jaao2SnTp0yXB43o4wdO5ZGRkYqp4q9evUq7ezsmC9fPlpZWbFixYoqhRB++fKFjRo1okQi4apVqzK83mPHjhEA169fn+Ex1MXExIROTk5Jrr1+/ZoBAQGUSqUEQENDQ3br1k0lO+6YMWPo7Oysq+Vqla9fvyqdQxs1apRm6mlNeP/+PatWrUqpVKr1IjwymYxVq1bNsHmAJIcMGUJLS0uN6lJoC5lMlm0Uk8xCUAZyGHFxcVy6dCltbW1paGjI0aNHZ0rSmcxALpfz0aNHXLNmDdu1a6eMTxeJRPT29uagQYO4Z8+eNI/ca9Sowdq1a6d638/Pjy1atNDF8lPl06dPtLa2Vine+vjx4zQ1NaWPjw/fvn3LCxcu0NDQkAEBASqFESYkJLBPnz4EwDFjxqh9SvT161e6ubnR19c3006YFFUkFSmEQ0JC2Lt3bxoZGdHIyIi9e/fm/v372a1bNxoZGVFfX5/t27dPYkL4mZUrV1IsFmd7b/D79++zZMmSNDAw4JIlS3T+mcfGxrJz584EwNGjR2stNHXp0qUEwH///TdD/aOiomhhYZGsqFhWYmtrq5PKnNkVQRnIIcjlcu7YsYMFCxakSCRip06dGBYWltXL0gi5XM6QkBCuXr2abdu2Vea3F4vFLFWqFIcMGcK9e/eq7PgUGRlJqVTKxYsXp9rGzc2NQ4cO1dI7UJ158+ZRIpGkGS4VGBhIqVTK2rVrJznZ2L59u1K4q4JcLuecOXMIgG3btlXrxGjcuHGUSqWZ6ni6f/9+AmCPHj3YrFkzikQi2tractKkScnMFO/fv+fs2bOVJqIKFSpw69atybzlDx06RAAaOd/pErlczjVr1tDY2JiFCxfO1CRBiu+HSCRi8+bNNU7E9PjxYxobG7NXr14ZHmPZsmUUi8V89uyZRmvRJkWLFuWAAQOyehmZhqAM5ADOnj3L8uXLEwDr1q3LmzdvZvWSMoRcLufDhw+5atUqtmnThk5OTkrhX7p0aQ4dOpT79u3LsNfzzp07CSDFgj5k4tGfvr5+msqCrvj69StdXFzYvHnzFO8vWbKEIpGI//vf/1IU3rNnz1ZWC1SVv//+m/r6+qxWrZpKn+n9+/cplUo5btw4lefQFJlMxrp16yap8bBy5cp0wzETEhK4a9cuVqtWjQCYO3duTpkyRWlCuHv3LgEoS/xmJz59+sRWrVoRALt06ZJlx+K7du2isbExS5cuneEUxjKZjL6+vsybN2+Gc5jIZDIWKlQo1b+NrKJKlSps06ZNVi8j0xCUgWzMgwcPlAlHvLy8Muyhm1XI5XIGBwdz5cqVbN26NR0dHZXC38fHh8OGDeP+/fu1Zubo3LkzCxcunOr9V69eEQD37NmjlfnURZFM5cdiQ3K5XFnOePDgwake28rlcvbo0YN6enpqfQ9Onz7NXLly0cPDg6Ghoam2k8vl9PX1pZubW6akOI6JieEff/yRJOvjP//8k6Fj61u3brF79+5JTAiKELXNmzfrYPUZ58KFC8yXLx/Nzc35999/Z/VyeO3aNTo5OdHZ2ZnXr19Xu7+inoQqhblS4+DBg9lScWvWrFma1S9/NQRlIBsSHh7O3r17UyKR0NXVlZs2bcqUtLOaIpfL+eDBA/7xxx8MCAigg4MDAVAikbBMmTIcPnw4Dx48qJPvh0wmo4ODQ5omgAsXLhBAluVtT0hIoIeHB6tXr04yMca+S5cuBMA5c+ak2z8+Pp516tShhYWFWvHP9+7dY968eZk7d+5UH/gKRSUjGePUISIigpMmTaKtra2yvoKpqSltbGw0Hvv9+/ecM2eO0oQgkUgYEBCQLUr7ymQyzpw5k3p6eixbtmyaVSozmxcvXtDb25smJibcu3evyv0ePXpEY2Nj9u7dW6P5a9euTW9v72wXBdWjRw96eXll9TIyDUEZyEZ8+fKFkydPpqmpKS0tLTlnzpxM2aVlFLlcznv37nHFihVs1aoV7e3tlQ/hsmXLcsSIETx06FCGvYvV4cqVK+kmyAkMDCQAnWTrU5U9e/YQAPft26f0/FfHs/vz588sXrw48+TJo1ba5NevX7NUqVI0NTVNltAlIiKC1tbWbNu2rcrjqcvDhw/Zq1cvpVNgnz59GBISwujoaKXtX1soTAimpqYEQEdHR06ePFkraaYzwuvXr1mjRg2KRCKOHDkyWygnP/Plyxc2bdqUIpGI8+bNS1cwy2QyVqlShfny5dMoxfn9+/cJQOvRDdpg7NixdHFxyeplZBqCMpANiI+P5+rVq+no6Eh9fX0OHjw4xZrxWY1cLufdu3e5fPlytmzZknZ2dgRAPT09litXjiNHjuThw4czRfj/zKRJk2hhYZHmg3bOnDk0MzPL0h2IosSxiYkJjY2NeeDAAbXHCA0NpaOjI318fNRy/oqKimK9evUokUiS+B507NiRuXLl0knq1f/++08pZGxtbTl58uQkToFnz55VFl3SNg0aNGCVKlWSmBDatWuXxEyjaw4dOkRbW1s6ODioXcY3s5HJZBwxYoRKKYwXL16sleyUvXr1or29faYlAVOHhQsX0tDQMNudWOgKQRnIQuRyOffv308PDw8CYJs2bbLV8aFcLuedO3e4dOlStmjRIonwr1ChAkeNGsUjR45ki+JHZcqUSTdksG/fvvTw8MikFaVMWFiYMk2yJmFLV69epYmJCf39/dWqyBcfH8/u3bsTAMePH68st6xOQaX0UOzMK1SokK5T4OjRo3VmnujduzdLlChB8v9NCIosleXKleOWLVt0lpsjNjaWQ4YMIQDWqVMnR+W4X7duHaVSKatXr57iKZrCPKBpVcEPHz7Q2NiYEyZM0GgcXbFp0yYCyBZ5DzIDQRnIIi5fvsyqVasSAKtVq5ZmzHRmIZPJePv2bS5ZsoTNmzenra0tAVAqlbJixYocPXo0jx49mu3+OMLDwwmAGzZsSLNdo0aNWK9evUxaVXLu3btHFxcXuri4KJ31NDky3rdvH8ViMYcMGaJWP7lczunTpxMAzc3NWaFCBa34pMTExHDFihVKp8DKlStzz549aY6tKGusi2fGjBkzaGlpmeRaQkICd+/ezerVqxMAHRwcOGnSJK2aEEJCQliqVClKpVLOmzcvR/j7/MzJkydpZWVFd3f3JHU8tGUeIBMjZPT19bNtEbUjR44QgNZrfmRXBGUgk3ny5AkDAgIIJJbNPXDgQJYdQ8lkMt66dYuLFy9m06ZNaWNjoxT+lSpV4pgxY3js2LFsJ/x/Zv369RSJROnuvkqWLJnhVKmacv78eVpZWdHDw4NhYWG8desWRSIRly9frtG4iuPajIzTrFkzAmD58uU1+pt9+/YtJ06cSBsbG4rFYjZv3pwXLlxQqa+dnR3NzMwyPHdaKEpCp/bebt++zR49etDY2JhSqZRt27bV2ITw119/0dTUlG5ubrx8+bJGY2U1Dx8+ZKFChWhlZaWsjbFo0SKtmAfi4+Pp6urK9u3ba2GluuHq1asEkON/j6oiKAOZxLt37zho0CBKpVLmzp2ba9euVet4VxvIZDLevHmTixYtor+/P62trZXCv3Llyhw3bhyPHz+ucRKSzKZ58+YqpRjOlSsXZ8yYkQkrSsqBAwdoZGTEihUrJjl2bdeuHR0cHDRWtgYMGECxWKyW/0FwcDANDAzYpk0bWlhYsESJEnzx4oVa8z58+JA9e/akoaEhjYyM2LdvX7UK4cTFxSnrSugCReW5O3fupNnuw4cPnDt3rtJ8U7ZsWW7evFktE0JUVJSy2FLbtm2zxG9GF7x//57VqlWjVCrlrFmzlL9nTVEk0tJWYS1dEBoaSgA8dOhQVi8lUxCUAR3z9etXzp49mxYWFjQzM+PUqVMzbactk8l448YNLly4kE2aNKGVlRUBUF9fn1WqVOH48eP577//5jjh/yOxsbE0Nzfn5MmT02wXGRmZJXHnf/75JyUSCRs1apTMZv706VPq6+tz2rRpGs2RkJDARo0a0dTUVKWwSblcTj8/P+bPn5/R0dG8c+cOXVxc6OzszFu3bqXb/9y5c/T396dIJKKdnR2nTJmSoXz6N27cIAB269ZN7b6q8Pz5cwJQuXBTQkIC9+zZk8SEMHHixHSPsa9evcqCBQvSxMSEGzdu1MbSsxVxcXHKEFhLS0utKDqVK1dmpUqVtLA63RETE0MAv+TvNCUEZUBHyGQybty4ka6urtTT02OfPn107kSUkJDAa9euccGCBWzcuDFz5cpFADQwMKCvry8nTJjAoKCgdLO75ST+/fdflXYYt2/fJgCePXs2U9Yll8uVWQO7du2aao78AQMG0NzcXOPiNF++fKG3tzednJzS3eH/9ddfBJLWjH/58iU9PT1pbm6eYlKjhIQE7ty5U5kJ093dnatXr9Yo9HXWrFnKZEO6ID4+nmKxmH/88Yfafe/cucOePXsmMSFcvHgxSRu5XM4FCxZQKpXS29ubDx8+1NbSsx0LFixQ1glp2rSpRhsIxfG7rn7v2sTExITz58/P6mVkCoIyoAOOHTtGT09PAmCzZs0YHBysk3kSEhJ49epVzp8/n40aNaKlpaVS+FetWpUTJ07kyZMns3WuAk0ZPHgwc+fOna7fxYEDBwggU+o5yGQyDh48mAA4duzYNNf25s0bmpqaqu0EmBKvXr2ii4sLPT09U929vX//nra2tgwICEh2LzIykrVr16aenp4y7js6OprLly+nm5sbAbBKlSrcu3evVpzi6tWrRwAZToWrCi4uLirXdEiJDx8+cN68eUlMCJs2beKLFy+U6x80aFC2DI3TFg8fPqSRkRH79evH3bt309jYmKVKlVK5CufPKCqQZvciUiSZJ08ejho1KquXkSn8NsrAx7g4rnn1it0fPKDX5cvMfe4cHc+dY7FLl9j5/n2uePGCbzUMM7px4wZr166tTKLy33//aWn1iSQkJPDKlSucO3cuGzZsSAsLCwKJpV39/Pw4adIknjp16pcW/j/j7u7Orl27pttu+fLl1NPT07mfRmxsLP/3v/9RJBJxyZIlKvWZOHEiDQwMtFJU59atWzQzM2O9evVSfNh27dqVFhYWqR59/3gkXK1aNaVTYIsWLVR2ClQVFxcXGhgYaHXMn6lQoQLbtWun8TgJCQncu3cva9SooUypbWxszE2bNmlhldkXmUzGSpUqsUCBAkrzpiYpjMPDw6mvr8/Zs2frYLXap3Tp0jozY2U3fnllIPTrV3Z98IAGJ09SFBREvZMniaCgJC+9H+797+5dPlTzCCw0NJQdOnSgSCRioUKFuHPnTq1ECMTHx/Py5cucM2cOGzRoQHNzc6Xwr169OidPnszTp0//0ruStHj06BEBcNeuXem2HTlyJPPmzavT9URFRbFWrVrU19dnYGCgyv0iIyNpa2vLTp06aWUdR44coUQiYZ8+fZJ8D0+fPk0AadZoDw4OZvfu3amnp0cALFq0aJqVFjOKTCajRCJhwYIFtT72jwQEBNDX11crY8XFxXHUqFEUiUR0cnKioaEhpVIp//e//2ldUcouKMwDimgCBS9fvmSpUqVoYmKiVq2PiRMn0tjYOEuzgKpDnTp12KRJk6xeRqbwyyoDcrmca1+9osmpUykqAKm99IKCaHDyJBeEhlKWjkD/9OkTR44cSUNDQ9rZ2XH58uUaxY3Hx8fz0qVLnD17NuvVq6cU/kZGRqxRowanTJnCM2fO/LbC/2cWLVpEfX19leKdW7duzSpVquhsLW/fvqWPjw/NzMwyVNN98eLFFIvFatUcSItVq1YRABcsWEAy8cSiaNGiLFeuXLIjfrlczrNnz7JJkyYUiUS0t7fn1KlTuWzZMurp6bFOnTpa945/+PAhAbBVq1ZaHfdnhg8fznz58mk8ztOnT1muXDlKJBJOnz6dCQkJ/PjxI+fNm8f8+fMTAMuUKcNNmzbpLJFRZqMwD/Tv3z/F+9HR0crsknPnzk13A/Tt2zfa29tnWXhvRmjXrl22d3TUFr+kMiCTy9njwQOVFYDUXi3u3GFsCrbR2NhYLlq0iNbW1jQ2Nua4ceMy9LCMj4/nxYsXOWvWLNatW5dmZmYEQGNjY9asWZPTpk3j2bNnf5mHi7apWbOmylXFKlasqJXj4pR4+vQpCxYsSDs7uwyHSsXGxjJv3rxa3YWMGDGCIpGIu3bt4rRp0yiRSJKUv05ISOD27dtZrlw5AmDhwoW5Zs2aJGam48eP09zcnJ6enhm2EaeEQllZtWqV1sZMiaVLl1IqlWrk47Bt2zZaWFgwT548KZr+FCaEmjVrEgDt7e05YcIEnfpC6JqEhARWrFgxiXkgJWQyGUeNGqWMCklrM7Rx40YC4L1793SxZJ0waNAguru7Z/UyMoVfUhno+/ChxooAgoIoCgpiwJ07So1XLpczMDCQ+fPnp1gsZrdu3dR6QMbFxfHChQucOXMm69SpoyykYmxszFq1anH69Ok8d+6cIPxVICoqivr6+ly0aJFK7Z2dnTVyJEuNmzdv0tHRkfnz51crxj4lFF7+2vI1kclkbNGiBQ0MDGhgYMBhw4aRTNzRLVu2jAUKFCAA+vr6ct++fakKzFu3btHJyYmurq7pxuyrSqtWrQhAZ861Cvbu3ZthJ8Xo6Gh269aNANiyZUt+/Pgx3T53795lr169aGJiQqlUyjZt2uRIE8L8+fMpEol4+vRpldqvX7+eUqmUfn5+KZoA5HI5vb29c1xJ4GnTptHa2jqrl5Ep/HLKwM63b9MW8gcPEu3bEz4+xPedOEaMSLPPqpcveerUKZYpU4YA2KBBA5UeinFxcTx//jxnzJjB2rVr08TEhABoYmLC2rVrc8aMGTx//ny2rGKW3dm1axcBqCSA4+LiKBaLtb4LPXnyJM3Nzenl5aWVdLYymYwlSpRglSpVtJaVMjo6mhYWFhSLxTxz5gzHjRtHa2trisVitmzZUuWMe2FhYSxevDgtLCw0zj5HkgULFqREItF5ql5FLgN1BfKtW7dYpEgRGhkZcfXq1Wr/Pj5+/Mj58+crTQg+Pj7866+/coSJLzg4mIaGhhwwYIBa/U6dOkUrKysWKlQoSQpj8v8TQKma8yG7sGrVKopEokxPEJcV/FLKwPu4OFqdOUNRWsrA1q2JCoC9PfE9/C89ZUBy9ChhZ8fSpUun+SCMjY3luXPnOH36dNaqVUsp/E1NTVmnTh3OnDmTFy5cEIS/FujatavKx3dPnz5NFlevKTt27KCBgQGrV6+u1e+7IgQyI9UMU2Lr9++7kZERRSIRjY2N2b9//wwVxPr06RNr1KhBfX19jZI3yeVyGhgY0NnZOcNjqMr79+8JgNu2bVOpvVwu57Jly2hgYMASJUpofKSdkJDAffv2sVatWgRAOzs7jh8/PtuaEBISElihQgW6ubllKJdASEgI3d3daWVlxZMnTyqvN2/enIUKFcpxdRp27txJAHz79m1WL0Xn/FLKwNRnzyhO7/j/yBFix47En//4QyVlAMePs87+/cm+yLGxsTx79iynTp3KmjVr0tjYmABoZmbGunXrctasWbx48WKOiKfNScjlcjo6OnLw4MEqtT916hQB8P79+1qZ/48//lDurLW905PL5axSpQpLlCih0YNTLpfz4MGDNDAwIADa2NjQ0NCQvr6+GimjsbGx7NChAwFwxowZGTrBCAsLIwDWrVs3w+tQFblcThMTE86dOzfdtu/fv6e/vz8BsE+fPloP0b137x579+5NExMT6unpsXXr1jx//ny2KpE7b948ikQinjlzJsNjfPjwgX5+fpRKpVy3bh2fP39OiUTCpUuXanGlmYPiRCMn+TlklF9GGYiXyeh47px6fgGqKgNBQTQ9fZrvo6N55swZTpkyhTVq1KCRkZFS+NerV4+zZ8/mpUuXBOGvYxQZzE6cOKFSe4XjkqZpoOVyOSdNmkQA7Nu3r852OefPnyeADMWwJyQk8J9//mHZsmWV8fDz5s3jt2/fGBQURKlUyi5dumgkgORyOcePH08A7Nmzp9rf923bthEAZ82aleE1qEORIkVS9YhXcPr0aTo7OzNXrlwqhapqwqdPn7hgwQKlz4aPjw83btyY5SaEBw8e0NDQkAMHDtR4rLi4OKW/RdmyZWlubp4tSp2ry/3791MMrfwVUVV+i5HNuRQVhddxcTob/4tMBscGDVC5cmXMmTMHhoaGmDx5Mi5fvowPHz7gwIEDGDZsGHx8fKCnp6ezdQgABw4cgLm5OSpVqqRS++fPn8PGxgYmJiYZnlMmk6F3796YMGECpk2bhsWLF0Ms1s2fRbly5dCkSROMGzcOcSp+p6Ojo7Fs2TIUKlQILVq0QHx8PABgwYIFGDx4MAwMDFC1alWsWbMGa9euxaxZszK8PpFIhEmTJmHt2rVYvXo1mjRpgi9fvqjc/+jRowAAPz+/DK9BHVxdXREaGpriPZlMhkmTJqFq1arIly8fbt68iSZNmuh0PRYWFhg4cCAePnyI/fv3I1euXGjfvj1cXV0xfvx4vHr1Sqfzp4RMJkOnTp3g7OyMadOmaTyeVCrFypUrMWPGDFy8eBF2dnYQiURaWGnmYmtrCwB49+5dFq8k+5DtlYErUVE6XaRIJkOVbt1w5coVfPjwAfv27cPQoUNRunRpQfhnMgcOHECtWrUglUpVah8aGoo8efJkeL5v376hZcuWWLVqFdasWYPRo0fr/ME2bdo0PH/+HCtXrkyz3Zs3bzB+/Hi4urqif//+8PHxwfnz5xEXF4fSpUujT58+Sdq3b98e48ePx6hRoxAYGKjRGjt37owDBw7g1KlTqFq1KsLDw1Xqd+nSJYhEIhQrVkyj+VXF1dUVYWFhya6/ePECfn5+mDx5MsaPH48TJ07AxcUlU9YEAGKxGPXr18eRI0dw//59tGjRAvPnz0eePHnQpk0bnD9/HiQzZS0LFy7EhQsXsH79ehgbG2tlTJFIBEtLS4hEIrx69Qq+vr5ZouhoQq5cuSAWixEREZHVS8k2ZHtl4OaXLxDr8gEtkcDQwwOlSpWCRCLR3TwCafL27VtcunQJ9evXV7nP8+fP4erqmqH5Pn/+jDp16uDgwYPYtWsXunTpkqFx1KVo0aLo0KEDpkyZgqioqGT3Hzx4gO7duyNPnjyYP38+2rVrh8ePH+Pvv//G6dOnce/ePaxatSrF7+rEiRPRtm1bdOjQAf/9959G66xduzbOnDmDV69eoXz58njw4EG6fR4/fgxra2sYGhpqNLeqpHQysGfPHpQsWRJPnjxBUFAQJkyYkKVKfeHChbF06VK8fPkSc+fOxaVLl1ChQgWUKVMGGzduRGxsrM7mDg4OxtixYzFgwACVT9tUgSQWL16MJk2a4Ny5c3jz5g3KlCmD69eva20OXSMWi2FtbS2cDPxAtlcGPickQKZDLZoAPiYk6Gx8AdU4dOgQAKBu3boq98noycDr16/h6+uLmzdv4tixY2jUqJHaY2jCpEmTEBkZifnz5wNIfLieOXMGjRo1QpEiRbBv3z5MmDABoaGhWLhwIfLmzYunT59i4sSJGDBgALy8vFIcVyQSYc2aNShbtiwaN26Mx48fa7ROT09PXLhwASYmJqhQoQLOnDmTatv3798jOjoaRYoU0WhOdXBxcUFERAS+fv2Kb9++oV+/fmjSpAkqV66MGzduoEqVKpm2lvSwsLDAgAEDlCYEa2trdOjQQWcmBIV5wMXFRSvmgR85duwY7t+/jwEDBsDT0xOXLl2Co6MjKlWqhD179mh1Ll1iY2MjnAz8QLZXBiQiEXRtkQoJDsbUqVOxd+9e3L17F58/f9bxjAI/c+DAAfj4+MDe3l6l9iQzdDIQEhKCChUq4N27dzhz5oxWd0yq4uLigr59+2LOnDlYu3YtypUrhypVquDx48dYt24dnj17hlGjRsHKygpA4nvt27cvbGxsMHny5DTHNjAwwK5du2BlZYV69erhw4cPGq3V1dUVZ8+ehaenJ2rUqJGqCeLKlSsAgIoVK2o0n7prA4CTJ0+ibNmyWL16NZYtW4Zdu3bB2to609ahDgoTwuHDh/HgwQO0bNkSCxYsQJ48edC6dWv8999/WjEhLFiwQOvmAQWLFi1CyZIllcqWo6MjTp06hXr16sHf3x9z587NNDOIJtjY2AgnAz+Q7ZUBR319SHRpJkhIwNu7dzFu3Dg0btwYxYoVg6WlJaRSKWxsbFC0aFHUqVMHffv2xfLly3Hw4EHcunULHz9+zBFf+JxAfHw8jhw5opaJ4P379/j69ataJwNXrlxBxYoVYWhoiP/++y/TbNs/Ex0dDVtbW8TExKBr164wMTHBgQMHcPv2bXTq1AkGBgZJ2m/fvh0HDx7EkiVLYGpqmu74VlZWOHDgAD58+AB/f3+Nj6ItLS1x+PBhtGzZEgEBASk+7BXOgzVr1tRoLnVQ+AE0bdoU8fHxuHTpEnr37p1jHNrc3d2xZMkSvHjxAnPnzlV+P318fDQyITx48ABjx47FwIEDta6cPXz4EAcPHsSAAQOSfM7GxsYIDAzEqFGjMGzYMHTr1k1lJ9mswtbWVjgZ+IFs7yFXyswM8ToUumI9PYxu2RJVq1XDjRs3cPfuXTx69AgvXrxAREQE7t+/j/v37+PIkSPJ+kqlUlhbWyN37tzImzcvChUqBFdXVzg7O8PFxQXOzs6wtrbOMQ+nrOLcuXOIjIxU218AgMonA8eOHYO/vz+KFSuGAwcOZMnO8c2bN1iyZAmWL1+OyMhIFC9eHPfu3cO6deuQN2/eFPt8/vwZAwYMQJMmTdC4cWOV53Jzc8OePXvg5+eHrl27YuPGjRp9D/X19bFx40a4urpi2LBheP78ORYuXKj0XVD4KKRmwtA2nz9/xujRowEAPj4+OHTokEZRJVmJwoTQr18/HD58GEuWLEGHDh0wdOhQ9OjRAz179oSTk5NKYynMA66urpg6darW17pkyRLY2tqidevWye6JxWJMmzYN7u7u6Nq1K548eYLt27crT7iyGzY2Nnj27FlWLyPbkO2VgfLm5qo33rUL+PIFUBz9/PcfoND8/P2BFHZVcgCnV6yAh68vevTokWznFRcXh7CwMDx9+hSPHz/GnTt3EBwcjOfPn+P169cIDw9HeHg4rl27luKSpFIp7Ozs4Orqinz58imVBMW/zs7OsLW11Vk4W05g//79cHBwUEuQKBzHVDkZ2Lp1Kzp06ICaNWti27ZtmS407t+/j/nz5+Ovv/6Cnp4eunXrhgEDBsDW1hZubm4YP348Nm7cmGLfMWPGICoqCosXL1Z73goVKuDPP/9EQEAAChQogIkTJ2r0PkQiEaZNm4Y8efKgd+/eCAsLw5YtW2BsbIzg4GCYmZkhV65cGs2hChcuXEDr1q3x4cMHWFhYoHr16jlWEfgRsViMevXqoV69eggODsbSpUuxcOFCzJw5E82aNUP//v1Rvnz5NJW6+fPn4+LFizhz5ozWzQOfPn3C+vXrMXjw4DSdRNu3b498+fLB398f5cuXx/79+1GwYEGtrkUbCCcDP6HNpAW6osLVq5SokmzI3j4x2VBKr61bk7f/91/qb9vGIkWLKlO7Nm/enP/884/KKTtjYmJ4//59Hjp0iMuXL+eQIUPYoEEDFilSRFmtUPESiUSUSqUUiURJruvp6dHFxYWVKlViQEAAhw4dykWLFnHHjh28ePEiX758+Uvn0C5cuDC7dOmiVp8FCxbQyMgo3SQ7irrtHTp0yNR00XK5nKdOnWKDBg0IgI6OjpwxY0ayYi/Lly+nSCRKUnVQwcWLFykSiZTlijPK9OnTCYB//vmnRuP8yIEDB2hiYsIyZcrwyZMnBEBvb2+tjZ8SMpmMM2bMoEQiYbly5fjkyRP6+Piwc+fOOp03K/n8+TMXLVrEggULKj/jDRs2pJhF8d69ezQwMFA5g6e6zJs3j1KpVOWUy48ePWLhwoWZK1curdS90DaKZ8ivjqryW0SmfwYfGRkJCwsLfP78Gebq7NS1RODbtwi4d0/7A5Ow3rIF79esQfny5VGkSBFcv34d169fh4mJCRo2bIhWrVqhTp06GQ6XioqKwvPnz/H06VM8ffoUz549w5MnT/Do0SM8f/48SVIXiUSitBfHxsZCJpMluZc7d+5kpwo/vhwdHXNcboQnT56gQIEC2LlzJ/z9/VXuN2jQIBw6dCjVkDeSGDVqFGbNmoXhw4dj5syZmWKuSUhIwM6dOzF37lxcvnwZHh4eGDp0KFq3bp3MFwBI9JcoWrQo3N3dsX///iTj+Pj4QCQS4dKlSxr9XkmiW7du2LhxI44ePYqqVatmeKwfuXr1KurXrw+xWIzXr1+jZ8+eWLFihVbG/pnXr1+jXbt2OHHiBEaOHIlJkyZBKpWiefPm+Pz5M44dO6aTebMLcrkcR44cweLFi3H48GHY2tqie/fu6NWrF5ycnCCTyVCxYkV8/PgRN27cgJGRkVbnl8lkcHNzQ8WKFbFp0yaV+338+BEtWrTA6dOnsXLlSnTq1Emr69KEzZs3o23btoiOjtb6KUp2QlX5nSMkRwtbWywxN8fFyEhoLQhQJkOuL1/wcN48/FurFmbPno1169ahRIkSmDNnDmJiYrBjxw74+/vDzMwMjRs3RqtWrVCrVi3o6+urPI2ZmRmKFSuWqrPax48f8ezZM6Wi8KPC8PTpU3z9+vX7cmV4+/Ytvnz5gkePHiEhIQHR0dFJnHTEYjEcHBxSVRacnZ2RO3dutdavaw4cOACpVIoaNWqo1S80NDRVf4H4+Hh0794dGzZswPz58zFo0CBtLDVNvnz5gvXr12PBggV4+vQp/Pz8cPDgQdSpUydNJUQqlWLq1KkICAjAmTNnULlyZQDA4sWLcevWLVy8eFFjBU8kEmHFihV4/vw5/P39cf78eRQuXFijMQGgVKlSuHDhAnx8fABAZ4l9Dh06hA4dOkAikeDYsWOoXr268p6rqysOHDigk3mzE2KxGHXr1kXdunXx8OFDLF26FIsXL8asWbPQtGlTWFtb49KlSzh79qzWFQEA2LdvH549e4Zt27ap1S9Xrlw4dOgQ+vXrh86dO+PBgweYMWNGtjCL2tjYAAAiIiI0Sl72q5AjTgYA4PHXryh2+TJi5XJow51QTEKvXz+4kdiyZQtKlCiBU6dOYfbs2Th06BBcXFwwePBgVKpUCQcOHEBgYCDu378PS0tLNGnSBK1atUL16tVVzpaXEUji3bt3yRSFH08ZflQGTExMYG5urtyBfvv2DZGRkYiJiVG2EYlEsLe3T1VZcHZ2hpOTU6YljqlduzbkcrnaO7vSpUvDy8sLq1evTnI9JiYGLVu2xJEjR7Bhwwb873//0+ZykxEeHo4lS5ZgxYoViIyMRMuWLTFkyBCUKlVK5THkcjl8fHxgaGiIs2fPIiwsDEWKFEGXLl0y5CuQGp8/f0aFChXw9etXXLx4UZmSVVN8fX1x+vRpGBgYYPPmzWjWrJlWxo2Li8OoUaMwf/581KtXDxs2bEi25oULF2LUqFGIiYn57Rx1IyMj8eeff2LevHl4/vw57OzsMGvWLAQEBGj977datWqIjY3NcDIrkli4cCGGDBmCJk2a4K+//spyP49r166hVKlSuHLlilp/rzkNleW3Nm0OuubAu3eUBAWlX8Ewrde//xInTnD5w4e8e/cuS5YsSX19fc6bN09ZoObmzZts164d9fT0aGlpydGjR/P169e8ffs2x44dq7TfWVlZsWvXrjx27FiWFDGSyWR8+fIlz507x02bNnHKlCns0qUL/fz8mD9/furp6SXxTciVKxfz58/P4sWL09PTk8WKFWO+fPlobm6ezMfC1taWXl5ebNiwIXv16sVp06bxzz//5IkTJ/jw4cMMlUH9maioKOrr63PhwoVq97W1teWUKVOSXHv37h3LlStHExMTrZY1Tol79+6xS5cu1NfXp6mpKQcNGsRnz55leLyjR48SAHfv3s2GDRsyd+7cOvl7e/bsGe3t7VmuXDnGxMRoZUwHBwcaGBiwVatWWvFxIMmHDx+yVKlSlEqlnD9/fqrFo3bs2EEAjIiI0HjOnEh8fDzLlClDZ2dnZTllGxsbjh49mmFhYVqZ4/r16wTAwMBAjcfau3cvTUxM6O3tzRcvXmhhdRnn+fPnBMBDhw5l6Tp0zS9TtfBnDr17R5NTp6iXAUVALyiI+kFBtGjShKVKlWJkZCS/ffvGIUOGEABr1qzJly9fKucKDQ3l4MGDaWpqSgMDA3bv3p3BwcGUy+W8fv06R44cyXz58imFZ69evRgUFJRtnP3i4+P5/Plznjx5kuvXr+eECRPYvn17VqlShS4uLskcGe3t7VmsWDFWrFiR1apVY7Vq1Vi+fHkWKVKE1tbWyRQGKysrlihRgvXq1WP37t05efJkrl+/nseOHeP9+/fTrWa2e/duAmBISIha7ys6OjqZQ1xoaCiLFClCGxsbXrp0KUOfV3rI5XKePHkyiVPgzJkz+fHjR62M7efnRxcXFwLg9u3bNV9wKly6dIlGRkZs0aKFxhUav337RpFIRHd3d8pkMo4YMYIAOGDAgAz/HWzcuJGmpqZ0c3PjlStX0mx7+fJlAuDVq1czNFdOZ+bMmRSLxfzvv/9IksHBwezfvz/NzMwokUjYsmVLnjlzRqNqlp06daKzs7PWHHBv3LhBFxcX5s6dO0t/b4rnyF9//ZVla8gMflllgCRDv35lrRs3lAI+PSVAEYlQ7upVPoyO5vXr12lubk4/Pz9ledFjx47R0dGR1tbWyUqdfvjwgdOnT6e9vT1FIhH9/f15/vx5kokP8cuXL3Po0KF0dXVVCol+/frx7NmzOiuHqw1iY2P56NEjHjt2jKtXr+bo0aPZpk0bli9fno6OjskiHvLkycNy5cqxbt26bNasGVu2bMmmTZuyVq1a9Pb2pp2dXTKFwcLCgh4eHqxduza7du3KiRMncs2aNTx8+DCbNWvGAgUKqP2gevDgAQHw5MmTJMk7d+7QycmJefLkYXBwsNY/p/j4eP79998sXbo0AbBYsWLcsGEDY2NjtTpPUFAQAbBkyZIaPbxVYdeuXRSJRBwxYoRG4yjKTrdp00Z5bdmyZRSLxWzatKlapw+RkZFs164dAbBdu3aMjIxMt094eDgB6Lw8cXbk7t271NfX59ChQ5Pd+/z5M5csWcJChQoRAL28vLhu3boUoxDS4u3btzQwMOCMGTO0tWyS5KtXr+jj40NjY+Ms/d0ZGxtz/vz5WTZ/ZvBLKwNkohA++v49G9+6pTQbSIKCKD15ktKTJ5OEIta6cYN7IiIo++EBe/LkSRoYGLB58+bKHUxERASbNGlCAOzevTu/fPmSZM6vX79y9erVyj+wypUrc9++fUqBL5fLef78eQ4cOJBOTk4EQGdnZw4aNIgXLlzQ+QNe2/wcNjl8+HC2aNGCpUuXpo2NTRKhb2BgwEKFCrFGjRps3bo1e/TowX79+rFv377s0qUL/f396ePjQ0dHx2QnEqampixcuDBr1qzJTp06cdy4cVy5ciUPHDjAmzdv8v3790k+uyNHjhAAnzx5wrNnz9LS0pIlSpRIcqqjDaKiorho0SLmzZuXAFi9enUeOnRIZ7/HAQMGUCKRMHfu3Go/tDPC/PnzCYCrVq3K8BgLFy4kAK5duzbJ9b1799LY2Jjly5dX6Qj/ypUrdHNzo6mpKTdu3Kjy/DKZjAYGBly0aJHaa8/JxMfH08fHh+7u7mkqXDKZjIcOHWK9evUyZEKYMmUKjYyM+O7dO20tXUl0dDSbN29OkUjE2bNnZ8nz0dXVlaNHj870eTOTX14Z+JEPcXE8/uEDZz9/zmGPHnHoo0ec8ewZD79/z4g0dm+7d++mWCxmjx49lF9EuVzOVatW0djYmIUKFUrxmFImk3HXrl0sX748AbBo0aJct26d8pRB0ebMmTPs27cv7b/nP8iTJw+HDRvGK1eu5DjFICUiIyN5+/Zt7t27l4sXL+agQYPYpEkTenp60sLCIonANzY2ZtGiRVm/fn326tWLXbp0IQB26dKFkydP5oABA9i8eXOWK1eOzs7OFIvFyfoXKlSIfn5+ys+9e/fu1NfXp7e3N0NCQrT2mb569YqjRo2ipaUlJRIJ27Rpw2vXrmll7NS4cuUKxWIxhw8fTolEkim7Fblczt69e1MikfDIkSMZGqNRo0YEwLt37ya7d+nSJdrZ2bFgwYJ89OhRiv1lMpkyfr1UqVJ8+PCh2mtwc3PjkCFD1O6Xk5kxYwbFYrHyhFIVHj58yAEDBihNCC1atODp06dT/buJjY2lo6Mju3Xrpq1lJ0Mmk3Hs2LEEwM6dO2v9tC09SpUqpdP3lx34rZQBTVi7di0BcOzYsUmuP3jwgKVKlaKenh5nzpyZqv3z7Nmzygdi7ty5OXv2bH769ClJm4SEBJ44cYI9e/ZU7qgLFCjAUaNG8caNG7+EYpASHz9+5LVr17hjxw7OmzePffv2ZYMGDejh4UGpVJpE2Jubm7NkyZJs0qQJBw4cyPnz53PdunX866+/uHHjRi5YsIBDhgxhq1at6OzsnOx0QXE6UaBAAfr6+vJ///sfR4wYwSVLlnDXrl28cuUKw8PD0zTb3L17l507d1Y6BQ4ePJjPnz/X+eeUkJDAUqVKsUSJEoyLi2P37t1pbW2d7HukC+Lj41mvXj2amZnx9u3bavfPkycPJRJJqn8fjx8/ZqFChWhra8sLFy4kuffmzRvWrVuXADh48OAMCwI/Pz+2aNEiQ31zInfu3KG+vj6HDRuWof6RkZFcsmQJ3d3dCYCenp5ct25dshOGzZs3EwDv3LmjjWWnycaNG6mvr8+qVavy/fv3Op9PQe3atenv759p82UFgjKgBrNmzSKAZEeNsbGxHDlyJEUiEatWrcrQ0NBUx7h37x47d+5MqVRKc3NzDhs2LEVv2fj4eB49epRdu3allZUVAdDd3Z3jxo3LlD+67ELZsmXZoEEDXrx4kYGBgZw5cyZ79uzJ2rVr093dnQYGBkkEvbW1NUuXLs1mzZopfRPq1KnDEydO8PTp09y5cycXL17M4cOHs02bNqxSpQrz5ctHfX39JONIpVLmzZtXme1xyJAh7NOnD0uVKkUAdHBw4IwZM7TiFKgqixYtokgkUu7yXrx4QUNDw2QKqq6IjIykp6cnXVxc0s4uJ5eTz5+T586Rp08z4coVGovFdHV1TXP8d+/esUKFCjQyMuLu3btJksePH6eDgwNtbW158OBBjdbfsWNHlitXTqMxcgrx8fEsXbo0CxcurLEpSSaT8fDhw6xfv77yb2zUqFEMDQ2lXC6nj48Pa9SooaWVp8/p06dpbW3NggUL6sT3JyXatm3LypUrZ8pcWYWgDKjJ0KFDCYCbN29Odi8oKIjOzs7MlSsXt23bluY4L1++5IgRI2hubk6pVMpOnTqleIRKknFxcTx48CA7duyoPFb38PDgpEmT+ODBA628r+zI27dvKRKJuG7dulTb/Bw2OXXqVHbu3JnOzs7JTgQUQrxcuXJs3bo1R40axVWrVvHYsWMMDg5mWFgYr169yj179nDZsmUcNWoU//e//7FIkSLJlA4AlEgkdHFxYfny5dmiRQsOGjSI8+fP57Zt2/jff/8xNDRUa6GkYWFhNDU1Za9evZJcHzFiBI2Njfn69WutzJMeL168oJOTE0uVKpXUVyYhgdy/n2zUiMyViwSSvOIBPjU1JSdPJtNQJGJiYti8eXNl1I5IJGKNGjVUTm2bFuPHj2fu3Lk1HicnMH36dIrF4mSnLJqiMCGYm5tTIpGwWrVqBMC9e/dqdZ70+DGF8YkTJ3Q+38CBA1m4cGGdz5OVCMqAmsjlcnbo0IF6enop7lQ+fPjAFi1aEAA7deqUrqfz58+fOWfOHObOnZsA2LBhwzRDfL59+8a9e/eybdu2ypoGJUuW5LRp01K1t+ZU/vzzTwJQS9B9+/ZNGcduZWXFYcOGKcMmN2zYkGbYpEgkorOzMytXrsyAgADWrl1bGSpZqVIl7t+/nxEREbxx4wb379/PP/74g2PGjGGHDh1YvXp1uru709jYOInCIBaLmTt3bpYpU4ZNmzblgAEDOGfOHG7dupVnzpzh06dPVTr2btq0KR0cHJKdRHz48IGWlpbs3bu3uh9vhrlx4wZNTU3ZqFGjxGP/gwdJV9dEwS+RJFMEkrzE4sQ2PXqQqTwnHj16pIxSqVy5stYUqtWrV1MkEmW6vTmzuX37NvX19Tl8+HCdzREZGcmlS5cmeQatXbtWazkpVOHjx4+sWbMm9fT0kjmmaptp06bRxsZGp3NkNYIykAHi4+PZoEEDGhkZKeN2f0Qul3PDhg00NTVlgQIFVNLOY2NjuX79ehb9XgypXLly3LlzZ5ox2DExMdy5cycDAgKUQqhUqVKcNWsWnz59qslbzBa0bNmSPj4+KrePjIxkjRo1qK+vz23btlFPT4/Lly9Ps48ibPL48eNcvXo1+/fvz6JFi1IikSQ7CdDT02O+fPno5+fHzp07c8qUKfzrr7949uxZvnjxgjKZjHK5nB8/fuTt27d56NAhrlq1iuPHj2fnzp1Zq1YtFi1aNMXkTfb29ixdujSbNGnCvn37cubMmdy0aRNPnjzJlStXEkg9mcusWbOop6eXqcrggQMHaCQS8byHx/8L+bSUgJ9fEgmZOzd55kyScQMDA2lubs68efNy0KBBFIlEbNmypVaiJn6MLvlVUZgHihQpovNIk7CwMEokEvbq1Yv169enSCSitbU1R44cmaapVJvExcWxZ8+eBMBhw4bpLER75cqVFIlE2SY3jC4QlIEMEhMTw0qVKjFXrlyp2vBDQkJYtmxZSiQSTpkyRaUvkkwm4/79+1mlShUCYKFChbhq1ap0/7Cjo6O5bds2NmvWjIaGhgTAsmXLct68eZn2h6lN4uLiaGFhwYkTJ6rUPjw8nN7e3jQ3N2dQUBDDwsIIgPv371ep/507d9ipUydKpVKamZlxyJAhDA0NZUxMDB88eJAsbNLHxyfVsMlatWqxR48enDFjBv/++29euHCBb968SXLa8/nzZ967d49Hjhzh2rVrOWnSJHbr1o1169Zl8eLFmStXrmQKg42NTYrZHg8ePEh7e/vMdY6LiWFYoUJMUEcBSOmUQF+fPHKEX758YdeuXQmALVu2VJ6A7Ny5k4aGhqxUqZLGDmP379/nj3knfkWmTZtGsVjMixcv6nyuUaNG0czMTPm8DwkJ4cCBA5UmhGbNmvHUqVM6d3yWy+VcuHAhxWIxmzRpkizUWxvs3LmTwK+dwVJQBjTg48ePLFGiBJ2cnFJNMRsXF8dx48ZRLBazUqVKau3YL1y4wGbNmlEkEtHe3p7Tpk1LVto2JaKiorhlyxY2btxY6RhXsWJFLl68WCu218zg5MmTBMDLly+n2/bx48csUKAAHRwceOPGDZLkuXPnCCBNz3e5XM4TJ04oPdWdnJxSjPJIi5TCJv39/dMNm+zTpw/nzp3L7du38+rVq/zw4UOyh+aXL1/YqVMnGhgYcM6cOZw6dSp79uzJBg0a0NPTM8VsjxYWFsmyPa5bt07lbI8qIZeTTZuqfxqQikIgk0rZOG9eGhkZcc2aNck+h/Pnz9PGxobu7u4a7eq/fPlCAGrlJ8hJ3L59m1KpVOMEUaoQHR1Na2trDhw4MNm9yMhILlu2jIULF1aaENasWaNzE8L+/ftpampKLy8vracwPn36NAHw3r17Wh03OyEoAxry6tUr5suXj4UKFeLbt29TbXfmzBnmyZOH5ubm3LJli1pzPHz4kD169KCBgQFNTEw4aNAglUPZPn36xI0bN7J+/fqUSqUUiUT09fXl8uXL+ebNG7XWkZkMGzaM9vb26R77Xbt2jfb29nRzc0siKLZs2ZLqdzE+Pp5btmyht7c3AbBEiRLcuHGjTmzJirDJnTt3ct68eezXr58ybPJn/wJF2GTjxo05cOBADhs2jGKxmAMGDEjV9yQmJoYhISFKr/uCBQuyT58+bNy4sUrZHrt06cIJEyYosz3euXOHnz59Sns3t2mTUphHARwPsDbAXN/HX5+K4L/3vZ3J97ZtAb5FonNhiIEB731X5FIiJCSEbm5utLOzU0lBTA1ra2tOmzYtw/2zK3FxcSxVqhSLFi2aKYmoVq1aRZFIxMePH6faRi6X8+jRo2zQoIHSh2fEiBE6DcO9efOmMoVxeimq1eHevXsEwNOnT2ttzOyGoAxogZCQEKXNNy2HwU+fPvF///sfAbBt27Zqx4eHh4dzzJgxtLS0pJ6eHtu2bcubN2+q3P/Dhw9ct24da9euTYlEQrFYzOrVq3PVqlU6yRyWJtHR5MaNZLduZIkSpKUlaWpK2tuTtWpxhbU1JzVqlOYQJ06coJmZGUuXLp1MsZk5cyYtLS2TXIuMjOSCBQuU6aBr1qzJI0eOZFn+Brlczrdv3/LSpUsMDAzkrFmzlGGThQoVSpYjwdramqVKlWLz5s05bNgwLlu2jAcPHuS9e/cYExPD7du3E0Ay7+pv377xyZMnPH36NLds2cLZs2ezf//+KmV7rFGjBjt27KjM9ngkMJAJJiaUi0QkwKff27sCrJqGMhAG0AZgAYCLAE77rhCUBBgLJI43c2aan9fbt29Zrlw5Ghsbc9++fRn6zL28vNijR48M9c3OTJ06NdPMA3K5nB4eHmyUzt/njzx69IiDBg2iubk5xWIxmzVrxpMnT+rkb+/169csU6YMjY2NuXPnTq2MGRERQQDcsWOHVsbLjgjKgJZQ1DGoXr16kgyDKbFp0yalk9TZs2fVnisqKooLFy5UCjVFHL06f1gRERFctWoVq1evTrFYTIlEwtq1a3PdunUqmSIyzKdP5NChpJlZoqDQ00smOOQiEeMU//fyIlPISb5t2zbq6+uzZs2aKSpgvXr1YokSJUj+fxinhYWFUom6kcYuNDuwbNkyAuCePXuShE126dKF1atXT7HapIODA01MTGhlZcWRI0dy1apVPHr0KENCQtI99YiLi+Pz58957tw5BgYGct68eRw4cGCybI/9Acp++F19A/j6+8+X01AGegE0Avj8h2vHvrdfqbhmZ0emU+QmOjqa/v7+FIvFXLFihdqfa6NGjVi3bl21+2Vnbt26RalUypEjR2bKfMePHycA/vvvv2r3jYqK4vLly5UmhBIlSnD16tVaqW76IzExMWzZsiUBcObMmRorHQkJCRSJRFy5cqWWVpj9EJQBLZJSHYPUePr0KStWrEixWMzx48dnKHwqLi6OmzZtYokSJaiIJAgMDFR7rDdv3nD58uX09fWlSCSiVCpl/fr1uXHjRu3+Lg8fJh0c0g8/+8mmTIBs2ZL87ryzdOlSikQitm7dOlUhV79+ffr6+rJjx45Kp8ChQ4fmCGfKly9f0tzcnN27d0+zXUJCQrKwydq1a1PhbPhjquYfwybbtWvH8ePHc926dQwKCuKzZ89U+s7Ex8UxPm9e5anAz6+0lAE7gC1SuF4IYPUfr6mwk0tISGD//v0JgCNHjlTLg7xv37708PBQuX12Jy4ujt7e3ixatGi6mxBt0bBhQxYrVkwjAaswITRs2FBnJoQfUxh36tRJYzOgjY0Np06dqqXVZT8EZUDL7Nq1K1kdg9SIj4/n5MmTKZFIWK5cuQyHhsnlch45coTVq1cnAObPn5/Lli3LkLb98uVLLl68mBUrVqTCQ75x48bcsmWLZs5ny5ZlLARN8ZJIKM+bl3P69iUADhw4MEUhIJfL+e+//9LU1JQKp8A5c+ZkSspebdGyZUva2dll+IRGkZ0xOjo6SdjkmDFj0qw2mS9fPlarVo2dO3fm5MmTk4VN8sWLNH9HqSkDL75fn5VCn7YArb7/HCcS8XDBghw6dCgXLlzI7du388KFC3z58mWKyrWigFKbNm1UFoSzZ8+mmZlZhj7X7MiUKVMokUh0Vo77Z0JCQigSibhmzRqtjfno0SMOHjyYFhYWyiqW2jQh/PXXX9TX16evr69G5tDChQun6DD5qyAoAzpAUcdg3LhxKrU/f/488+fPT1NTU27YsEGjP4IrV66wVatWFIvFtLGx4cSJEzMcDhMaGsr58+ezbNmyBEBDQ0M2a9aM27ZtU0/RWLdOc69zgAkiEZ8CXDxuXLLPKC4ujps3b6aXlxcVyX4CAgJyXIKZgwcPEkg5w6WqXLt2jQC4evXqNNv9GDa5YsWKNMMm9fX12cPRMUPKgOL6xhT6DPt+79v3/983M6Obm5syPFbxSinb47x58zho0CBKpVKWLVs2TQdeBX///TcB5CjlMDVu3rxJqVTKUaNGZdqc/fv3p7W1tU4iAxQmhCJFihAAixcvrjUTwtmzZ2ljY0M3N7cMpzCuXLky27Ztq/FasiuCMqAjUqtjkBqRkZHs2LEjFXHWmtrtHz9+zL59+9LIyIhGRkbs27evRmFZT58+5ezZs5W5+U1MTBgQEMCdO3em7b0cHJwYS56KAHkIsBVAJyTalN0BTgIYnUp7mVhMNmmSGN7GxM9t/vz5Sv+JWrVqKWOC//777wy/36wgOjqaefPmZY0aNTTeFQUEBNDJyUmjh3ZUVFSSsMk9lSszIRUTQVrKwOnv1wNT6DPu+72Pimvfd+1yuZzv3r1Lku1x7Nix7NixY6rZHhXJmxTZHvv3758s2+OpU6cIgLdu3dLo881q4uLi6OXlRQ8Pj0wzD3z+/JlmZmY6L+Url8t57NixJCaE4cOHpxq+rSqPHz9mkSJFMpzC2N/fn7Vr19ZoDdkZQRnQEXK5nEOGDFF7lxcYGEhLS0u6uLhoJTlKREQEJ06cSGtra4rFYrZq1UrjkJuQkBBOnz6dJUuWJACamZmxbdu23Lt3b9IHk1xOliuXopMgAYYCtASYB+AMJDqSdfz+UG+UzinB++87WYVTYLt27ZSRFTdu3CAAtcq2ZgdGjBhBAwMDhoSEaDxWSEgI9fT0OGvWrHTbymQyRkZG8sWLF7x37x4vXrzIY8eOcceOHVy/fj0XLVrEqVOn8lAGlQF1TgZkBgYqKzA/ZntcvXo1bWxsaGJiwsaNG6eZ7REA3dzcUsz2+OjRo0wJzdMUhXlRkzBLdVm4cCH19PS0HsOfFo8fP05iQvD392dQUFCGleUfUxind3L2M927d2epUqUyNG9OQFAGdIhMJlPWMTh06JDK/UJDQ5XOfKNGjdLKUXd0dDSXLVvGfPnyEQCrV6+ulbC6Bw8ecPLkyfTw8KAihr1jx448dOgQ448cSVOgT/v+YL7z0/X2369/SO10AOB9gOZmZhw2bBjDwsKSrGnv3r0EkGMSLJGJHuF6enqcMmWKyn2+ffvGiIgIPn78mNevX+epU6e4b98+btmyhX/88QfLly9PAwMDdu/enZ06dWKzZs1Ys2ZNli1blkWKFKGTkxPNzc1TLPP848vQ0JB2dnacbm2dZsZBTX0G+P2EQKFgurm5sUKFCvT392fPnj05YcIELl++nDt27ODZs2cZEhLCyMhI5Xc4PDycPj4+NDExSVI3RJHt8ejRo1y9ejXFYjErVqyYoWyP//77L4ODg7Xu/a4OCvOArnfoP5KQkMACBQowICAg0+b8kaioKK5YsSKJCWHVqlUZ+j3Ex8ezV69eBMChQ4eqnGJ49OjR6VbezMmoKr9FJIl0iIyMhIWFBT5//gxzc/P0mv8WxMfHo2nTpjhx4gSOHz+O8uXLq9RPJpNh7ty5GDt2LDw9PbF582YUKlRI4/UkJCRg586dmD17Nq5evYqSJUti+PDhaNGiBaRSqUZj3717F4GBgQgMDMTDhw+xVypFvYQESFL56owEMAtABACbn67PARAJwCSN+aIPHYJJnTrJri9duhRDhgzB169fIRaLM/p2dIJcLseXL18QGRmJyMhIREVF4dOnT+jfvz+ioqKU61bc//EVFRWV5P9xcXGpziMWi2FmZobIyEhYW1ujYMGCMDc3V77MzMyS/D+162ZmZv//vdi/H2jYMNU5rwDwAbAeQMef7tkBqApg20/X3QE4A/j3+/8/ubtj/9ixePPmTYqvt2/fQiaTJRnDyMgI9vb2sLe3h42NDW7fvo2wsDC0atUK/v7+ynv29vawtLREvnz50Lp1a8yYMUM5RnR0NF6+fImwsDC8ePEixde7d++SzGtlZQVnZ+dUXy4uLjA1NU3188oI8fHxKFu2LOLj43HlyhUYGBhodfzU2LdvHxo1aoTz58+jXLlymTJnSpDEiRMnsHjxYuzbtw+Wlpbo2rUrevfujbx586o1zpIlSzBo0CA0bNgQmzZtSvd3tXDhQowZMwbR0dEavovsiaryW1AGNODr16+oVasW7t69izNnzsDDw0PlvlevXkWbNm3w4sULLFq0CF26dIFIJNJ4TSQRFBSE2bNn48iRI3B1dcXgwYPRpUsXjR9gJHH7yhV4lCsHiVyearvDAOoCaARgEgBrAP8B6A6gM4AFaU2ipwf06QMsXJjs1vDhw7Fz5048evQow+/hR0giNjY2mTBOTUindS0qKirNuYyMjFQS0uldMzY2hkgkwrhx4zBv3jw8evQIuXPn1uyDeP0aSGOMtJSBXgD+BBAMwOX7tX8B1ACwAkBPAJBKgZ49gcWLU51DLpfjw4cPqSoKip8fPHiAL1++JOuvr68PADA1NUW5cuWSKAp2dnZJ/m9tbZ1Emfz69StevnyZqrLw4sULvHnzJsl8FhYWaSoLzs7OMDc3V/lvesqUKZg0aRIuXryIUqVKqdRHG9SoUQNfvnzBhQsXMm3O9Hjy5AmWL1+ONWvWICoqCo0aNUL//v1RtWpVlT/PAwcOICAgAG5ubti3bx+cnZ1Tbbtp0ya0a9cO0dHRMDY21tbbyDYIykAm8enTJ1SpUgUfPnzAuXPnkCdPHpX7RkdHY9CgQVi9ejX8/f2xevVqWFtba21tN2/exNy5c7F161aYm5ujT58+6NevH+zs7DI+6NWrQOnS6TabCmA6gK8/XBvz/Xq6lC8P/PdfssutWrVCREQEjh07lmQXrq7g/vH/8fHxqS5DIpFkWHDHx8ejcePGaNiwITZs2AA9PT1V3rnKfP78GQUKFECzZs2wcuVKzQcsUgQIDk481P/OUgCfALxComBvCsDr+71+ACwAhH2/ZglgAIAvSDz9cQZwGYByf7t3b5qnD6pCEnPmzMGIESOUQkKhRKxcuRLv3r1Dmf9j76zDolj/Nn5v0g3SCIodiAEW2N1x7MTu7sIWu7v12N16VOwWj92KiR2I9M79/sHZfUFqd1nAc377ua69lNmZ53kGdmfu+aaPTxIBERkZmWQMiUQCOzu7JALh15dSQNjZ2UEqlSImJgZv375NUSgorQ7v3r1D4supqalpqkJB+bKyssLt27dRsmRJDB06FJMmqfUN0Qm3b99G0aJFsWnTJrRs2TLL5lWXnz9/YuPGjZg/fz7u3buHwoULo0+fPmjTpo1aN+3bt2+jbt26iIuLw/79+1MVWUeOHEGtWrXw4sULuMXGAlevAjduAF+/AiIRkCMHULw44OMDpCEqflf0YiALCQsLQ7ly5SCTyXDu3DnY2dlpdPzu3bvRuXNnGBoaYt26dahatapO1/fixQvMnTsXK1asQHx8PDp06IBBgwYhT548mg+2Zg0QEJDubhv/eTVBgmXgIBKeLOcD6J3OsTFSKbq2apXsxv3s2TOQRHx8fJrHm5iYaPzEndJ2IyMjra01rVu3xrFjx/DgwQOdCrzEzJ49G0OHDsXdu3eRL1++jA22eDHQu3cSMeAO4EUquz//530AuAtgIIBzAOQA6gCYBcAeCY56kbMz8OIFIJFkbI2J2LJlC9q3bw8/Pz/s3LkTFhYWGDlyJDZt2oTQ0NAk+0ZERKTqnvjVAhEeHp7kWJFIBBsbmzSFg/JlZWWFz58/pyoWXr9+jbdv30JIZFUzNDQESUilUjRo0ADu7u7JBIStra1OrIa/0qVLFxw6dAihoaEZdiVmJkpr5/z587Fv3z5YWlqiU6dO6NWrV7ouhHfv3qFhw4a4desWNm7ciMaNGyfbJ+TiRSwoWxaL8uaF8aNHCRtlsiTfBSivOZUqAX36AA0aAL+ZqzI19GIgi3ny5AnKly8PV1dXnDx5EmZmZhod//btW7Rv3x7Hjx/HoEGDMHnyZJ37Db98+YKlS5di3rx5+PjxIxo3bowhQ4bA19dX/UHmzwcGDADScBNsQYI74BESnhCVdESCb/klEgRCWri7ucHYxAQmJiYwNTWFqakpjh8/jkKFCqFatWqwtLSEtbU1bGxsYG1tDVtbW+TIkQNWVlbZfmE7duwYatSogXXr1qFdu3aZNk90dDTy5s0LX19fbN++PWOD/fgBuLsnPA2lf0lQGwHAqfr14bdjh87/LmfOnEGDBg3g4uKCQ4cO4cCBA+jTpw9iYmIg0VJ4REVFJbEqpPX6+vVrsuMtLS3TFAw2NjaQSCSIiYnBp0+fsHLlShw9ehRVq1ZFZGQkXr9+jTdv3iQRvAYGBnB2dk7RsqB85ciRQ6M4mk+fPsHV1RWjR4/GqFGjtPpdZQfPnz9XuRDCw8PVciFERUWhY8eO2Lp1K6ZOnYphw4b9/75XryKueXNInz8HRCKI0vvsSySAQgGULw+sXQvkzq3bE8wE9GIgG7hx4wYqVqyIUqVK4eDBgxrfzAVBwNy5czFixAgULFgQmzZtQoECBXS+zujoaKxfvx4zZ87E48eP4e/vj6FDh6JWrVrpX1AWLUpQxml8bPwBKACc/2X7biSYmv9Cgk85NRQAclhbIyoqClFRUWnsmRyxWAxDQ0MYGRmpXol/Tuu99H5O7T1DQ0PVxSUqKgpFihSBm5sbTpw4kSlPdIlZu3YtOnbsiCtXrqBUqVIZG2znTqBpU90sDIBCJMJrGxvk+fwZ+QoVwpIlS1C+fHmdjQ8A9+/fR61atRAfH49hw4ahb9++ePXqVZo+Yl0RGxuLDx8+qCUePn36hF8vtSYmJvj58ydcXFxQqlQplWCws7ODoaEhACAmJgY/f/7Ex48fk8U1JA40lclkKsGQ2svBwUElkqZOnYrx48fj1atXGlsyfwd+/vyJP//8E/Pnz8fdu3dVLoTWrVvDxCR5eLIgCBg/fjwmTJiADh06YNmyZZAvWwb06weKxRD9EryaLlJpwmvrVqB+fR2dVeagFwPZxOnTp1GjRg3Uq1cPW7Zs0eoJ5e+//0arVq3w/PlzzJ49G927d8+Um4pCocC+ffsQFBSEy5cvo1ChQhgyZAhatmypCshKxp49QKNGaY6bD4AVgF9DkrYBaA7gMIDkuQL/j+DoCPHbtwD+P8jv/v37KF68ONavX4/ixYsjOjpaJRYS/1/Tn1N779fI9vQwNDSEoaEh4uPjERERoYryz0wRIpFIoFAo4OXlBQcHBxw/flyjNSeGJObMmYMcgwahFYCMGkAFkQhRJNrmy4fOs2djwoQJuHz5Mjp06IDp06fr9Ab07t071KlTBw8ePEBkZCTOnz+PsmXL6mx8XRAfH49Pnz6pxMHbt28xatQoxMbGombNmvj48aPamRXKmAYzMzNVLEpcXBwiIyPx7ds3fPjwQZVBER0drRpDIpHAyckJTk5OuHXrFnLnzo2OHTsmiWdwdHTUeXxLZqJ0ISxYsAD79u2Dubk5OnfunKoL4c8//0RAQABmurigz7NnGZtcJEp47d79WwsCvRjIRvbs2YMmTZqgS5cuWLJkiVY38sjISAwdOhSLFi1C3bp1sWrVqowF/qUBSZw7dw7Tp0/HgQMH4OzsjP79+6Nr167J/96vXwOurikP9A/1ABwDcBtA4qTJRgD2ISHoLLXY9XgA+wEE+frCz88Pfn5+KF++PP7++29UqVIFjx490i7WQUPi4uLUFg7KlzI2o0yZMihZsqTGAiWtlMKUkMlkqriG79+/w9XVFba2thpbQmQyGTZu3IiTJ0+iVdOmWPDmDawuXUrfZJoaEgkgl+PZ4sWoMn48IiMjsWvXLty9exfDhw8HAEybNg2dO3fWWYpoREQEGjdujL/++gvdu3fHkiVLdDJuZjF+/HhMnDgRV65cQfHixZO8p25mhfL16+dGLperAiCtrKxgYmICmUwGkUiEuLg4PH36FLdv34arqys+f/6cJMBSLBbDwcEhzcBHJyen1B8WspFfXQj16tVD3759UalSpSTX4Dvz56Nwv366mVQkAuRy4M4dwNNTN2PqGL0YyGZWr16NTp06YcyYMZgwYYLW4xw4cAABAQEQi8VYu3YtaqaQf69L7t27h5kzZ2Ljxo0wMjJCjx490K9fPzg6OibsQCZE1P7z5J4SZwBURkJcQO9//j2ABItAZwAr0pifYjEuNmyIhQYGOHv2LF6/fg0AcHZ2xps3b7BmzRpUqVIFrukIkqxGEARUrFgR79+/x82bN1VmXk1QKBSIjo7W2LIRGRmJZcuWqWpfpCZgUhvnV6QApiMhO0D452e1fw8APhgbY4GfH945OwMAjh49infv3qFx48YoUqQIDh8+jIsXLyJPnjzo2bMnChUqlKaAMTAwUEtQx8fHw9jYGHFxcQgMDMTYsWMz3U2jDX///TdKlSqFESNGZOjaACQI+e/fv6cbGJlWZoWtrS0sLS1hYmICuVwOkUgEhUKByMhIhIeH4/Pnz8ly8O3t7dPMknB2dtbqO6ALfnUhFCpUSJWFYCIIQIECYFgYRGnEPYUACERCUGw0gFxISI3um9LOUmlCpsHZs79lUKFeDPwGBAUFYfjw4Zg/fz769Omj9Tjv3r1Dx44dceTIEfTt2xdBQUGZ/kV78+YN5s2bh6VLlyImJgZt27bF4MGDkT9/fmDCBGD8+DSDCK8g4ct0A8BnAB4A2gMYirRvLoJYjPgXLyB3cQFJvHjxAmfPnsXcuXNx8+ZNlfk0Z86cKsuBn58f8ufPn60XfqX4O3nyJCpVqpTl8589exb+/v7YsmULmjdvrtYx9+/fR926dfH9+3ds2LABxYoVSyIW5JcvI9f06TB9+RKCWAxxKn9vZXk/hViMA7lzY52HB77HxqrGiYyMxNu3bxEZGQmZTIb4+Phk/vP0UNfacfToUcjlcnz48AFFixZFo0aNYGpqqrE7xtDQUOsgxLSIjY2Fj48PSOLq1atZ/oR96tQpVKpUCdOmTUPevHnTFBG/1s4QiUQwNzeHqakp5HI5xGIxFAoFoqKi8OPHj2RCw9bWNlWxoHxlZl4/SZw6dUqVhWBubo5NhQqh5sWLaQqBY0iwbnojwa1pCuApEoTu9LQm3LYN+OMP3Z2AjtCLgd8AkhgyZAhmzZqV4Vxekli4cCGGDBmCPHnyYNOmTShSpIgOV5sy379/x/LlyzFnzhyEhYWhfv36GBUQAJ+mTf8/3UZHKEQibCExKmdOjBo1Cu3bt1ddLDt16oQ7d+5g//79OHfuHM6ePYuzZ8/ixo0bEAQBtra2KF++PPz9/eHn54dixYplme/z48ePyJ8/P+rWrYt169ZlyZwpUbduXTx8+BD37t1LN3L/6NGjaNasGVxdXbF//354eHikvCOZ8MSzciXCNm+G469/cyMjwNs7IfCwQwfAyiqVYYiZM2di2LBhaNiwIVavXg2FQoH58+djxowZMDU1xcCBA+Hv76+2ayal965fvw6SMDExwdu3byGXy2FoaJghN0xG4jp+/Xnbtm34888/sWHDBnh7eyfbN7MzYVq3bo2LFy/i8ePH6YqdjGZWKONoxGIxBEFQWb0SY25uDldXV+TMmTPVwEdNM7NSIjQ0FEsXLsSA2bORg0Rqjw3hSHBtlgWwAxrEzkgkQNmywJkzGV6rrtGLgd8EQRDQsWNHbNq0Cfv378+wmf/OnTto1aoVHj16hKCgIPTt2zdLnohjYmKwadMmzJgxA/fv38cyV1d0efUq1S+VVpiY4MGePRi3YgW2b98ONzc3lSioXbs2rKyskqXQ/fjxAxcvXlSJg8uXLyM6OhqmpqYoU6aMynLg6+sLIyMjXa5WRfv27XHgwAE8ePAgWyOzb9++DS8vLyxevBjdu3dPcR+lqOzfvz9q1qypKkiVHsobrKOhIZ6eOZMgBM3MEtIRNXiC3rdvH1q3bg1PT0/s27cPrq6uePnyJfr374/du3ejWrVqWLRokdZxId27d8fly5dx48YNBAcHo1GjRnB3d8fBgwfh4OCgEhDaBJVqK1A0QSKR6CS4NKWfIyIiUK9ePQwfPhw9e/ZUvaeuGyYtMppZIZVKIZFIIAhCskJgRkZGcHBwgLOzMzw8PODh4ZHE0uDq6qpetcdjx4AaNdLcZSkSqmreA1AAwE8ARtBAFDx/nvCd+I3Qi4HfiMR9DE6cOJHhGuDR0dEYMWIE5s6di5o1a2LNmjVwcHDQ0WrTRhAEHDp0CLOmTcPs8+dRBJr5lNNk1SpVQaO7d+9i4sSJ2LZtG1xdXREdHY1WrVphzpw0ixkjJiYG169fx9mzZ3HmzBmcP38e379/h0wmQ8mSJVXioFy5crBK5SlWE06ePIkqVapg1apVCFCjGFNm065dO/z111948uRJshSruLg49OvXD0uWLMGAAQMwY8YMtU3hb9++hbOzM8qVK4dz585laI23bt1CvXr1EBsbiz179qjqXBw8eBB9+vTBmzdvMHz4cAwfPlxjATdlyhTMmjULnz9/BpAgnmvXrg2SOHToUJZY0xKjzIb5/v07KlWqBJLYvHkz4uPjdZL1ktrPQhpm8F8RiUSqp/jMECG//iyVSlXpkikFRYaFheHNmzcqi8Ov5yISiZKJCZlMBisrK9jb28PZ2Rnu7u7IkycP8ubNCzc3t4RqjwsWQDRpUpoWzaZISH3eCaAXEmqlmABoi4Qy6uk6Z7dsAdR002UVejHwmxEZGYkaNWrg3r17OHv2LAoWLJjhMY8ePYoOHTogPj4eq1evRj0dlHvVhOv79sGtRQtYRkUhw8bNIUOAoKCE6NxE3L17FxMmTMC2bdtgZWWFadOmoUOHDmr7WhUKBe7cuaOyHJw9exZhYWEQiUQoXLhwkrgD538C3tQlOjoaXl5esLe3x+nTp3+LYLXQ0FDkzZsXgYGBGDlypGr7169f0axZM5w6dQqLFy9Gly5dNBr3wIEDqFevHoYOHYqgoKAMr/P9+/do3Lgxrl+/jjVr1qhcaJGRkZgyZQqmT58ONzc3LFy4UCNrmrLOfEREhEoMvX37FnXq1MGzZ8+we/duVK5cOcPr15Rx48ZhypQpuHr1KooVK5apcymrdCYWCt++fUPFihVRtWpV9OjRI1OsImmV9k4JuVyuluhQ3vyVVoPY2FhER0cnKTH+8+fPdEXQPgC1AaQlf70AKDufdEJCE65TABYAaAFgc1onJJMlFGTTwfdDl6h9/9ZlC0Q9afP161cWKVKEzs7ODA0N1cmYHz58YP369QmAPXr0yPoWrK9fMzpPHgpptMBN9SWRkCIRGRhIptFy+d27dwTA8uXLUyQS0c3NjcuWLdOqBbQgCHzy5AnXrFnDgIAA5smTR9XeNleuXGzfvj1XrlzJhw8fptsGety4cZTJZLx7967G68hM+vbtS3Nzc3769Ikk+ejRI+bNm5fW1tYMDg7WasyBAwcSgEYtu9MjKiqKbdu2JQCOGTOGCoVC9d6DBw9YuXJlAmCTJk2StbNOjdOnTxMA79+/n2R7eHg4a9SoQZlMxvXr1+vsHNQhJCSEUqmU48aNy9J5E7Nq1SqKRCI+evQo0+aIj49nREQEP378yJcvX/LRo0e8efMmL126xODgYB4+fJi7du3in3/+yVWrVnHhwoWcMWMGJ0yYwJEjR3LAgAHs3r0727dvz+bNm7N+/fqsVq0a/fz8WLJkSRYqVIi5cuWik5MTraysaGhomGaL7l9fV9W4JuX6Z9/uv2zv9s/2R2kdL5WS7dtn2u9XW9S9f+vFQBbz9u1benh4MG/evPzw4YNOxhQEgUuWLKGRkRHz58/PkJAQnYyrNjEx5NixFCQSKkSidL9wyn1iXF3J8+fTHf7y5csEwJCQEN69e5ctWrTIsChITFhYGLdv386+ffuyWLFiFIlEBEB7e3s2adKEc+fO5fXr15P0R3/w4AHlcjlHjRqVobkzg/fv39PU1JSDBg3iiRMnaGVlxfz58/Px48daj1mmTBkC4Lt373S40oTP7tSpUykSidi0adMkYlYQBG7atIkODg40NTXlrFmzGBsbm+Z4z58/JwAePXo02XuxsbEMCAggAE6aNCldsacLYmJiWLRoUXp5eWX4c6otgiCwaNGirFOnTrbMn5kIgsCoqCh++fKFb9684ZMnT3jnzh1evXqVZ86c4bFjx7h3715u2bKFn9zc0r02Ffrnpn/6l+2n/9m+Lr2Hm7Zts/tXkgy9GPiNefz4MXPkyMGSJUsyPDxcZ+Peu3ePxYoVo0wm44wZM5I8aWUJz5+Tw4dTsLRUfUFiAcaKRIxL9KWJ9/FhN3Nz9uzUSa1ht2/fTgD8/PmzatuvomDp0qU6u9h++/aNhw4d4ogRI1i+fHnK5XICoJmZGWvUqMGJEyeyWLFi9PDwYGRkpE7m1DWBgYGUSqWUSqWsVq0av379mqHxrKysaGJiopvFpcDu3btpbGzMEiVK8PXr10ne+/btG/v06UOxWMwiRYrw3LlzqY4TGxtLkUjEFStWpPi+IAicMGECAbBLly6Mi4vT6Xn8ypgxYyiVSnnjxo1MnSctgoODCYDHjh3LtjX8FlStmq4YqPbPTf/BL9vv/7N9blrHy2Rknz7ZfZbJ0IuB35yQkBCam5uzSpUqjI6O1tm40dHRHDJkCAGwSpUqyS6sWUJ8PHnvHuPWrGFI06acZ23NgQADXFy4d/VqxsfHc+rUqZTL5Xzz5k26w82cOZMmJiYpPsllpihQEhUVxTNnznDy5MmsWbOmyjwpk8lYvnx5jhgxgocOHeK3b990Oq+2xMXFsUePHgTAAgUKZPiGFx4eTgAsWrSojlaYMjdu3KCLiwsdHR159erVZO9fu3aNpUqVIgAGBATw48ePKY7j5OTEMWPGpDnX2rVrKZVKWatWLf748UMn6/+V69evUyKRMDAwMFPGV5eGDRuyYMGCWWIJ+a0ZOjTBlJ/GDX34Pzf9E79sP/HP9j/TczWsWpXdZ5kMvRj4F3Dq1CkaGBjwjz/+SGKC1gXHjx+nk5MTra2tuWvXLp2OrSnfvn0jABYsWJAAmDt3bs6aNYvm5uYcPHhwusf36dOHBQsWTHOfrBAFJPnp0yfa2NiwZs2anDdvHps0acIcOXIQAMViMYsVK8Y+ffpw27ZtDAsL0/n86fHt2zfWqlWLEomETZs2pVgsznBMw/nz5wmAndS05GSEsLAw+vr60tDQkFu3bk32fnx8PJcsWUJLS0taW1tzxYoVySxgpUuXZns1fLfHjh2jmZkZixcvzrdv3+rqFEgmuAeKFCnCYsWKpevayEyePn1KkUjEZcuWZdsafhu2b0/XMhDyz02/1S/bWwKUAnyTnhi4eTO7zzIZejHwL2H37t0Ui8Xs3r27zpX7p0+f2LhxYwJg586dM+0JKD0EQaCxsTFnz57Nq1evslmzZhSLxTQyMqJcLueTJ0/SPL5BgwasVauWWnPdvXuXLVu2pEgkoqurK5csWaJTy0tAQAAtLS2T+M4FQeDDhw+5cuVKtm/fnrly5aIyaMnT05MdO3bk6tWr+fjx40x9Onv69CkLFixICwsLHjt2jDExMXR3d2fDhg0zNO7UqVMJgJs3b9bRStMmKiqKrVq1IgAGBgam+Dt7//4927VrRwAsU6YM//77b9V7zZo1Y+XKldWa6+bNm3R2dmbOnDl1Ggg6evRoSqXSJOvKDgYMGEBra+usDyz+zfj27RsXBQXxpxoxTQH/fHebAVwE8I9/fh6R1nEiEZk3b5qB0NmFXgz8i1i5ciUBcOzYsTofWxAErlq1iiYmJsyTJw+vXLmi8znUwdPTM4kV4MmTJ+zQoYPK3N6nTx8+f/48xWOLFSvGbt26aTTfvXv3dC4KlJHq6jxlvXnzhlu2bGGvXr1YtGhRVVCio6MjmzVrxgULFvDvv//WmUXo9OnTtLGxYe7cuZNE0m/YsIEAeOHCBa3HrlmzJgFkKABRUwRB4KRJkwiAzZs3TzU249SpUyxYsCAlEgkHDBjA8PBwDh48mJ6enmrP9erVKxYpUoSWlpY8depUhtd+7do1SiQSjh8/PsNjZYTw8HCam5tz2LBh2bqO7OTWrVvs1q0bTUxMKJVKeShPHiokkjTFQCzAQIA5AcoAegKck55FQCQiFy7M7tNNEb0Y+Jcxbdo0AuD8+fMzZfxHjx6xVKlSlEqlnDJlis7dEunh5+fH1q1bJ9veqVMnGhkZ0crKihKJhC1btkyWDWFtbc0pU6ZoNa+uREF0dDTz58/PsmXLahWY+eXLFx44cIDDhg1j2bJlKZPJCIAWFhasXbs2p06dynPnzmm1ttWrV1Mmk7FixYqqdEIlCoWCRYsWpb+/v9ZWCRcXF8pksqwPSCW5Y8cOGhkZsVSpUqnGl8TExDAoKIjGxsZ0cnJihw4dKJfLNVrvt2/fWKVKFcrlcm7atEnr9UZHR7Nw4cL09vbOVvcASS5YsIASiYQvX77M1nVkNbGxsdy2bRv9/f1VAjwwMDDh8/PyJQUjIyrSu7lr8pJISDc3MiIiu089RfRi4F+GIAgcNGgQAWToYpQWsbGxHDlyJEUiEf39/fnixYtMmSclmjVrxkqVKiXbHhoaSqlUyqCgIC5YsIDu7u4EwGrVqvHYsWOq4LWNGzdmaP579+6xVatWWouCiRMnUiqV8tatWxlah5LIyEieOnWKEyZMYLVq1WhqakoANDQ0pL+/P0eNGsUjR46kmW0SHx/PwYMHUxkZn1qMxMGDBwmAhw4d0nidcXFxFIvFzJUrl8bH6orr16/T2dmZzs7OvH79eqr7hYaGskGDBioXzcWLFzWaJyYmRuV6mDZtmlbiadSoUZTJZLyZzb5jhULBPHnysFmzZtm6jqwkLCyM48ePp5OTEwHQz8+PW7duTSLKLly4wKHW1roTAsqXDixKmYVeDPwLUSgUbNeuHaVSqU6Lu/zKqVOn6OrqSgsLC27ZsiXT5klM//79mT9//hTfa9euHV1cXBgTE8O4uDhu3ryZ3t7eBMD8+fMTgNbFcn4lsShwcXHh4sWL0xUFjx8/poGBQaaaW+Pi4nj16lXOnj2bjRo1oq2tLZVBiSVKlGD//v25c+dOvn//nmSCCbh+/foUi8WcM2dOmjcuQRDo7+9PLy8vjZ/u79y5QwBs3Lhxhs4vo7x9+5alSpWikZERt2/fnua+c+bMIQDK5XIGBgYyKipK7XkEQeDYsWOpLOKlSSbG1atXKZFIOGHCBLWPySyUAvC8GnU8/s0IgsBz586xRYsWlMlkNDY2ZteuXZOJMUEQOHPmTEqlUpYpXZoRjRtTUCN+QK3XpEnZdPbqoRcD/1JiY2NZt25dGhsba/xkowlfvnxh8+bNCYDt2rXL9L9tUFAQLSwsUnzv7t27BMBVidJyBEHg8ePHWbx4cQKgi4sL582bxwgdmeLUFQWCILBq1ap0d3fP0iAsQRB4//59Ll++nG3btlVZTJSVEq2trWloaMhVq1ap9QR78eJFrSwsyniWhb+BPzQyMlL1mZ04cWKq5/3x40eVgJHJZPT09EyxCFFarFy5khKJhHXr1lXrMxcdHc1ChQqxePHi2e4eIMlq1aqxZMmS/9l0wp8/f3LFihX08vKiMlB3zpw5KdbT+Pz5M+vVq0cAHDJkCGNjYxn65Am3GhqSgHbVU8XihH/TqZ76O6AXA/9ifv78yfLly9Pa2jpTS90KgsD169fTzMyMuXLlylTxoQxkS+2G2rBhQ+bNmzdZLMPSpUspFovZsmVLSiQSWltbc8yYMaon5Ixy//79NEXBn3/+qbWJXde8evWKgYGBNDIyUsUcAKCzszNbtGjBRYsW8datW6k+/Tds2JAeHh4apVy2bNmSyuqPvwOCIHD8+PEEwJYtW6YYWCgIAo2MjDhnzhzeu3ePlSpVIgA2a9ZMo7obR44coampKUuVKpVu5cWRI0dSJpPpzI2UEZTiesOGDdm9FJ3z+PFjDhw4kJaWlhSJRKxbty6PHDmS6mf+woULdHNzo7W1NQ8cOEAyIT6kUKFC9HB3Z/jMmaSRUbr1B5LFCNjZkfv2ZeWpa41eDPzLSdzHILN9+0+fPmWZMmVUEdCZUZXt+PHjBJBqGqGy5PCvJuARI0bQzc2NZIJPuF+/fjQ2NqahoSF79Oihswj3+/fvs3Xr1hSLxXRxceGiRYsYFhbGHDly/DZ+1w0bNlAul7N8+fL88OEDP336xL1793Lw4MH09fWlVColAFpZWbFevXqcPn06L168qLr53717l2KxWKMg1Xz58lEkEmVbKd3U2LZtG42MjOjr65tiPYd8+fJxwIABJBPEwcaNG2lvb09TU1POnj1b7c94SEgIHR0d6eHhwQcPHqS4j9I9MHHiRO1PSId069aNDg4Ov93fTFsUCgUPHDjAWrVqEQCtra05ZMgQPnv2LNVjkrgFypRRBVHGxcWxRo0atLCw4L179xJ2Dg0le/RgnFyeYCmQyZLc/AWR6P/FgpUVOWIE+eVLVpy6TtCLgf8Ab9++pbu7O/Ply6ezPgapERcXx3HjxlEsFrNs2bJpftG0Qfm0cvbs2VT3qVKlCosXL57EtNmqVSv6+fkl2e/Tp0+cOHEi7ezsKBaL2bRpU52lTCYWBSYmJjQ0NEw15TGrUCgUHDlyJAGwffv2qcY4RERE8MSJEwwMDGSVKlVobGxMADQyMmKlSpU4duxY1qhRg7a2tmqVwRYEgQYGBrS3t9f1KemEq1ev0snJiS4uLsksF1WrVmWTJk2SbPv69St79epFkUhELy8vtdMtX7x4wUKFCtHa2jrZ5/d3cw98/vyZRkZG2Z7WqAs+f/7MmTNnqup2FC9enKtXr063BHhKbgEy4fPcvXt3SqVSnjhxItlxx3bsYEuA4Z07k35+jMqVi7cBfi1ZMkEA7N5N6rBmSVahFwP/ETKrj0FqnD9/nu7u7jQzM9OpmfHr168EkGJVOSVK68GRI0dU28qXL882bdqkuH9kZCSXLl1KT09PAmDFihV56NAhnfhJle4Bpftg0aJFOi1epC4RERFs3LgxRSIRg4KCNDq32NhYXr58mTNnzmT9+vVpbW2dxLUwcOBA7t69O9Wyvq9fvyYAtQv4ZAevX79miRIlaGxsnKTSZkBAAEuVKpXiMVevXmXJkiWpLMb1azpmSnz9+pUVK1akgYEBt23bpto+YsSI38Y9QCbE5sjlcp250bKDkJAQdurUiYaGhpTL5WzTpg0vXryo1mc/JbeAklmzZiWLTUrM1atXCUCVsRIaGsr/Qk8HvRj4D6HsY1C1atUsuSF9+/ZN1Vq2VatWGW5yQyaockNDQ86dOzfNfUqVKsUKFSqotrm6unLkyJFpjh0fH88dO3ao6tYXLlyY69at09pMGhsby8KFC9PHx4d3795lmzZtKBaL6ezsnKWi4NWrVyxevDhNTEy4Z8+eDI+nUCh4584dVq1alVKplM7OzipxUKBAAXbr1o0bN25UuaX27NlDZRXA35mfP3+yadOmBMApU6ZQEAQGBgamadGIj4/n4sWLaWFhQRsbG65atSrdTIvo6GhVZcSZM2fy8uXLFIvFnPSbRJPHxcXR1dWVHTp0yO6laExMTAz//PNPli1bVhUwPHnyZLVFTWpuASW7d++mSCTi8OHDUx1DefNXBpt++vSJALhz507tT+w3QC8G/mMEBwdnWh+D1Ni0aRMtLCyYM2dOnjlzJsPj5cqVi0OHDk1zn127dlFZMU+Z465uXXVBEHjq1CnWqVNHdUGZNWuWxhaVqVOnUiKRJOk09+DBgySiYOHChRqlrGnKlStX6OjoSFdXV52XtP306RPNzc3Zr18/hoaGcsOGDezatSsLFCigEgdubm7MmzcvAXDt2rW/fVS6QqFQpQS2adOGy5YtI4B0hdu7d+/Ypk0bAmC5cuXSfcJXKBQcMWKEynddokSJTO98qC7btm0jgGztkKgpr1694ujRo2lvb6+yQu3cuVOj32lqbgEl165do7GxMZs2bZqm4IuIiEiScRMTE0MAXLdunXYn95ugFwP/QTKzj0FqhIaG0s/Pj2KxmKNHj86QX7RcuXJsm06/b4VCwQIFCrBevXoqpa5NzYXbt2+zffv2lEqltLCw4PDhw9VqRvP06VMaGRlx0KBBKb6fFaJg69atNDQ0TDU4ThdMmjSJcrk8WTzEhw8fuHv3bg4cOFAVcwCANjY2bNCggeqJ+Hfwj6fE5s2baWBgoGqKlV7fCyXBwcEsUKAAJRIJBw0alK6ArFGjhurm9bvU/S9Xrhz9/f2zexnpIggCg4OD2aRJE0okEpqamrJXr15aZU4ldgvs378/2fsvX76ko6MjfXx81Go3bmRklMR6KZPJfou02oygFwP/UTKzj0FqxMfHc9KkSZRIJPTx8dE6gr9p06asWrVquvutXbtW9UQK4P+jfrXg1atXHDx4MM3MzCiXy9m5c+dUo8IFQWDNmjXp5uaWblOnzBAFSvO20j2TmZaHiIgIOjg4pCnOLCwsaG5uzmPHjnHMmDGsWLGiqn2ziYkJq1SpwvHjx/PkyZO/zQ2RTMhMsbOzIwCuWLFC7eNiYmI4depUGhkZ0dnZmTt27EhRdCvdA+3ataOxsTF9fX0zPcA3Pa5du/bbm7R//PjBxYsXs1ChQlQWFFu4cKFW95Vf3QIpZVyFh4ezaNGizJkzZ7qpoUpcXV05atQo1c/W1tacNm2axuv7ndCLgf8wmd3HIDUuX77M3Llz08TEhKtXr9bYOtG3b990WxGTCT57Nzc3lf9QF4WGvn79ymnTptHBwYEikYgNGjRIVp1t69atBJDiE0ZqPHz4kG3btqVYLKaTkxMXLFig1U08MjKSLVq0IABOmjQpSyw/ixcvpkgkStE0riwDXbJkySTbY2JieOHCBQYFBbFu3bq0tLQkkNBsqnTp0hwyZAj37dvHz58/Z/r60+LRo0cEQAMDA+7du1ejY58/f64yO9esWTOJdSEqKooFChRgyZIlVVUj7e3tmTt3bj569EjXp6E2ysJUWd1zRB3u37/PPn360NzcnGKxmI0aNeKJEye0/oyn5xYgE+InatWqRXNzc965c0ftsb29vZM0RXNzc0siDv6N6MXAfxhBEDhw4EBmZh+D1Pjx4wcDAgIIgH/88YdGF/2pU6fSyspKrX0XLFhAkUhES0tLbZeaItHR0Vy5cqWqzHG5cuW4d+9efv78mQ4ODlqX3c2IKNCk1K4uiY2NpaenJ+vWrZvsvbNnzxIAe/XqleYYCoWCt27d4qJFi9iiRQtVXXhlIGePHj24adMmvnr1KrNOI1VsbW1ZsGBBrTIxSHLv3r10c3OjoaEhJ0yYwOjoaA4bNoxyuTzJDebZs2fMnz8/bWxsMtQdUlvCwsIok8k4c+bMLJ87NeLj47lnzx5WrVqVAGhnZ8eRI0dmuGbKxYsX03QLkAnXx169elEikWicCVC9evUk14BChQqxX79+GVlytqMXA/9xEvcxSJyKl1Vs376dVlZWdHFx4cmTJ9U6Zt26dQSglu/u58+fNDQ0pK2tbUaXmiIKhYJ79+5luXLlCICWlpY0NDTk06dPMzSupqIgJCSELi4udHJy4rVr1zI0tzZs2bIlxfoPyip/u3fv1mg8QRD49OlTrl27lp06dVIFIQKgu7s727ZtyxUrVvDBgweZbv0oUaIEO3XqxFGjRqVboyE1IiIiOHz4cEqlUrq6ulIkEqXYQfPz58/08/OjoaFhkhTHrGDs2LE0MTHRSdZPRvnw4QOnTp1KNzc3AqCvry83bNiQ4QwcddwCSubNm0dAvVbjv9KqVaskcRe+vr4MCAjQas2/C3ox8D9AbGws69SpQ2NjY166dCnL53/16hUrVapEkUjEYcOGpZvKd+zYMQJQu6BRnjx5KBaLMy2ITsny5ctVNyxHR0dOmzYtwxfWhw8fsl27dmmKgl27dtHY2JglSpTQqEyuLlEoFCxevDjLli2b5OasfKJLrW2wJrx79447duxgv379WLx4cYrFYgJgjhw52LhxY86ZM4fXrl3TeVR+o0aNWKNGDZLkxo0baWBgwHLlymmVgx8SEkIjIyNVWeOUfi9RUVFs3rw5RSIR582bl+H1q0N0dDRz5MjBnj17Zsl8qXH58mW2a9eOcrmcBgYG7NChA69evaqTsdVxCyjZv38/xWIxBw8erNVc/fr1S+LKrFq16m9TgVRb9GLgf4Ss6mOQGvHx8QwKCqJMJmPx4sVTDc4jEyL8AfU7qeXNm5cymSzddMSMEBsby6JFi7JEiRK8c+cOO3fuTLlcTjMzMw4ePDjD5u1Hjx4lEQXz589nZGQkp0yZQgBs2rRptgffHT16lACS+NYdHR1paGiYKU/v379/55EjRzhq1Cj6+/vTwMCAAGhqasrq1atz4sSJPHXqlFoWpLTo168fCxQooPr54sWLtLe3Z86cOTUuEjR06FDKZDJOnTqVOXLkoJmZGefOnZtMwCgUCg4dOpQAOGDAAI27RGqKMsg2re9dZhEVFcV169ap6nu4u7szKCgo1SJW2qCOW0BJSEgITUxM2KhRI61/78rKpkoaNmzIWrVqaTXW74JeDPwP8eXLFxYpUoQuLi6Z3scgNa5du8Z8+fLRyMiIy5YtS/Em8vnz5xT7D6SEIAg0NjZmpUqVaGZmlmkm0BkzZlAsFquqjpEJPvwRI0bQwsKCUqmU7du35+3btzM0T2JRoHzCHDlyZKbfLNRBEARWrlyZhQoVYnx8PGNjYykWi1NtOa1roqOjefbsWU6ZMkUV9AUktCAuW7Yshw0bxoMHD2r8GZg1axZNTEySfBZfvHhBLy8vmpqaqh0oevHiRYrFYk6dOpVkwvetR48eFIlELFasWIoNvhYuXEixWMwmTZpkWNSkhiAI9Pb2Zs2aNTNl/NQIDQ3l8OHDVW22a9SowX379uk0eFETtwCZUInSycmJJUuWzJC4VjZGU34v27Ztm6wc+r8NvRj4H+PNmzeqPga6VOaaEBERwW7duhEAGzRokGwdylr36mRBKKt/rVixggYGBplS5S00NJTGxsbs379/iu+Hh4dz1qxZdHFxIQDWqVOHp0+f1vpp+f379/T29qZYLKZIJKKjoyPnz5+fqSmE6nLlyhVVOqfSgtOyZctsWUt8fDxv3LjB+fPn848//qCDg4OqNLSXlxd79+7NrVu3pls3QlmE59cg1x8/frBBgwYUiUScOXNmmn/PqKgo5s+fnz4+PsmsAFeuXGGJEiUoEonYtWvXZPPs3buXRkZGLFu2bKZ8J8+cOZOsfHdmIQgCjx07xgYNGlAsFtPCwoL9+/fnw4cPdT6XJm4BMuHv6e3tTVdXV7VqiaTFjh07CEBVorpHjx4sVqxYhsbMbvRi4H8QZR+DUqVKZUkfg9TYs2cPbWxs6OjomCya193dPc2SoEquX79OALxy5Qp79OhBW1tbnZrTBUFg3bp16eLiku7vKiYmhuvWrWPhwoUJgD4+PtyxY4dGT0K3bt1izpw5aW9vz0uXLvHRo0ds3749xWIxHR0dOW/evEx7glSXpk2b0s3NTRWAlVoN96xGEAQ+fvyYq1evZseOHVW9KAAwd+7c7NChA1etWsVHjx4lubFfunQp1Yp8CoWCw4cPJwB27Ngx1XiXIUOGUC6Xp+qCi4+P58KFC2lubk5bW1uuWbMm2Rrs7OyYJ08etQsgqUuTJk2YP3/+TA3E/PbtG+fNm8d8+fIRAIsUKcJly5bpJN03JTRxC5AJv/969erRzMyMN2/ezPD8p0+fTuJ2GTp0KD09PTM8bnaiFwP/o4SEhNDMzCzL+hikxtu3b1m9enUC4MCBA1VrKVOmDNu3b5/u8bt37yYAvn//ns+ePaNEItFpUNbOnTs1jpYXBIGHDh1ixYoVCYCenp5cunRpujfx/fv309TUlF5eXsnMnUpRIJFIsl0UPHz4kBKJhEWLFs02P7S6vH37llu3bmXv3r3p5eVFkUhEAHRwcGDTpk05b948VcDqvjT6zq9fv55yuZx+fn7Jnt6V7gF1is6EhYWp+haUL18+iVvpyZMnzJMnD+3s7Hj58mWNzvNLbCwf//zJJ5GR/JbIMvH8+XOKxWIuXrxYo/HU5fbt2+zevTtNTEwolUrZrFkznjlzJtOEh6ZuASX9+vWjWCzmoUOHdLKOX7urTpgw4bft2qkuejHwP0x29DFICYVCwTlz5lAul7No0aK8c+cOGzduzOrVq6d77Ny5c5MEsLVp04aurq466dH+/ft3Ojk5sX79+lqPcfnyZTZt2pQikYg5cuTgpEmTkpmJlRc4ZZGjtKoaPn78+LcQBV27dqVYLKZEIvktC9ikxtevX3nw4EEOHz6c5cqVo1wuV1kPChYsyClTpvDs2bMpCuTz58/Tzs6OHh4eqvoBkZGRzJcvX4rugbQ4ceIE8+XLR6lUyiFDhqj+5h8/fmTZsmVpZGSUZhGkOIWCez5+ZNM7d+h8/jwRHJzk5XrhAlvcucPGQUG0sLLS6RN6bGwst2/fzgoVKqiE1bhx43SSUZIWmroFlCxcuJAAuGjRIp2t5f3790keEubMmUMTExOdjZ8d6MXA/zjKPgY9evTI9iYzf//9NwsWLEhDQ0P6+/uzcOHC6R4zcOBA5s2bV/XznTt3CIBr1qzJ8Hr69u1LExMTnQRbPn78mD169KChoSFNTExUzX9iYmLYqVMnAuDw4cPVDhR8/PgxO3TokG2i4NWrVwRAc3PzLJszM4iMjOTp06dpZWVFDw8PmpmZqSoS+vn5ceTIkTx8+LDqmhYaGsoiRYrQzMyMhw4d4uDBg2lgYKBVKezo6GhOnjyZhoaGdHV15a5duygIAiMjI9mkSROKxeJk9e4FQeDGd+/o+I8AkPwiAhK/lO+ZHTrEHToogxwWFsYJEyaoCkaVL1+eW7Zs0YnwTg9N3QJKDh48SLFYnGq8j7bExcVRJBJx+fLlJMkVK1YQwG8R6KstejGgR9XHYNy4cdm9FEZGRrJ3796q0rXp1Qpv0qRJsj4G9evXZ/78+TP0xbx69SpFIhFnzZql9Rgp8f79e44ZM4ZWVlYUi8XMkSMHpVIp165dq9V4iUWBg4MD586dmyWiQCkGsqK+Q1ZQoUIFtmjRgnFxcbx27RrnzJnDxo0bq3oXiMVient7s2/fvly/fj2rV6+uqoOQ0Zr0z549U3XQrFOnDp8+fUqFQsEBAwaonoIVCgU/xsSw7q1bRHAwRWmIgF9fyn3/uHOHXzVsHCUIAs+fP8+WLVtSJpPR2NiYXbp00XmHzLTm18YtQJI3b96kqakp69evnynWK2tra1VhKWVRruyMwcooejGgh2RCCWAAXLBgQXYvhSTZv39/VXnSgwcPprpfqVKl2KlTpyTbLl68mKFmLHFxcSxevDiLFSuWaW1nr169ShsbG9UNpXr16jx+/LjW1pmsFgXbt28nABoaGqZbivjfQNu2bVm2bNlk2wVB4IMHD7hixQq2a9eOHh4eKreC8m/n7+/P+/fvZ8iyJggCd+/eTVdXVxoaGnLixImMjo7m3LlzKRKJWL9jR3pevJimJSC9lyQ4mEWuXOEnNQTBz58/uXLlShYrVkwV9zJ79mx++fJF63PUFG3dAmRCrIirqyu9vb3TbSamLfny5eOAAQNIkgcOHCCADGcpZCd6MaCH5P/3MRCJRFnexyAljhw5QgCsVKkSAbB3794p3txy5MjB8ePHJ9tesWJFlixZUqsL9Jw5cygSiTQO4lKXw4cP09zcnIUKFeKjR4+4adMm1UW3ePHi3Lx5s9YiJKtEQdeuXVV/F6lUqvMI+Kxm1KhRdHFxUWvf169fs06dOhSLxbS3t1eJAwcHBzZv3pwLFy7kzZs3tbJMRUREcOjQoZRKpcyXLx+PHz/OTTt3UrR2LXH8uNZCILEgKH71KmNSWduTJ084aNAgWllZUSQSsW7dujx8+HCWm7+1dQuQCb/DEiVK0NnZOVMrdiZuta7MLsiMFMqsQi8G9KhQKBRs27ZttvUxSMzNmzcJgBcuXODChQtpaGjIQoUKJUkLioyMVOW8/4oyQlzTBiQvX76kqakpe/funeFz+BVBEDh//nyKxWLWrl07yfdEmZ+tLO/r7u7OBQsWaB349eTJE3bs2FElCubMmaNTUeDt7U2RSMQvX77Q2dk522oN6Iply5ZRLBarJcLOnz9PkUjE6dOnk0zwS5ubm9PS0pJeXl6USqWqPhZ16tThtGnTeP78eY1863fu3KG/vz8BMN/8+RSdPJn6Tf7oUaJFC8LGhpDLifz5iRkz0nQbjE1U6luhUPDgwYOsXbs2RSIRraysOGTIkAz339CGjLgFyIQUwoYNG9LExCTFVFFdkrjqoDLFOXFRsn8bejGgJwnZ3cdAycePH5OY+u/cucOiRYtSLpdzzpw5VCgUfPjwIQGk2ABJEASWKFGClSpV0mjehg0b0tHRkd++fdPJeSiJjY1ljx49VCmUafkwQ0JC2LJlS0okEtrY2HDcuHH8oGUAWGaJAnNzc9rY2JD8/+CpkJCQDI+bXRw+fJgA0r35REZGMm/evCxdunSSv+GzZ89YqFAhmpubc8+ePTx58iTHjx/PqlWr0sTEROVSqVChAkePHs1jx46la74WBIFjN28m0hICwcFE5cqEREI0b04MHEgUKpTw8/z5aVoIzr95w5kzZzJ37twEQG9vb65atSrbyl5nxC2gZNCgQRSLxRpbE7Shc+fOqtbdylbYp06dyvR5Mwu9GNCTjJ8/f7JcuXLZ1seATLgQymSyJNHUUVFRqqCq6tWrc/PmzQSQ6hOMskqYuqJmz549apdB1oQvX76wSpUqlEqlXLFihdrHPXv2jH369KGxsTENDQ3Zs2dPrc3xuhQFyu+50sceFxfHfPnyqZr9/Bv5NW88NQYOHEgDAwPev38/2Xvfv39n7dq1KRaLOX/+fJWLKjY2lleuXOGsWbPYsGFD2tjYEAAlEglLlizJAQMGcNeuXSkKvmZ37qQdJ7B4cYKbonv3pJYCJ6cEUZCadeDECUqGDaNMJmPr1q154cKFbM0myohbQMnSpUsJIMuaP40YMYLu7u4kE2IUAPDAgQNZMndmoBcDelLkd+hj4ObmxpEjRybbfvToUTo4ONDU1JQAUjW/KhQK5suXjw0aNEh3rvDwcLq4uLB27do6vSg+fPiQefPmpbW1NYODg7Ua49OnT5wwYQJtbW0pFovZrFkzrTu9PXnyhAEBARkSBcHBwQSQpOObUnip26b6dyM8PJwA+Oeff6a6z7lz5ygSiThjxoxU94mPj+fAgQMJgN26dUvx6VYQBN67d49Lly5l69atVW18ATB//vzs0qUL169fzytPnqQfMNi8OSEWEwcOJN3euXPCmFu3pm4dOHGCDzO5NkB6ZNQtoOTIkSOUSCSZ4t5LDWVPCzKh1DEAbt68Ocvm1zV6MaAnVbK7j4Gvry87duyY4nsfP35k3rx5VRfd1Hzrq1evJgBVkZjUGDBgAI2MjPj8+fOMLlvF8ePHaWlpyfz58/Px48cZHu/nz59cvHgxc+XKpQquPHz4sFbi5enTpypRYG9vz9mzZ6ttHh45cmSyeAxBEOjj40MfH59sr1ehLZaWlqomQ7/y8+dP5smTh2XKlFErTW3lypWUSqWsXLlysiJTKfHixQtu3LiR3bp1Y8GCBRNu5JUrpx8UWKIEkTNn8u0zZyaMMXlymsfvz6b+JKRu3AJkQhVEMzMz1q5dO9Oyf1Ji/fr1BMDIyEgqFAoC0Mjy97uh7v1bDD3/czg5OeHYsWP4+vUrateujR8/fmTp/I6OjggLC0vxPVtbW5QuXRq5cuXC+vXrUaJECYSEhCTbr3Xr1nBxcUFQUFCq89y4cQPz5s1DYGAg3N3ddbL2ZcuWoUaNGvDx8cHFixfh6emZ4TGNjY3Ro0cPPHr0CNu3b8ePHz9Qq1YteHl5YePGjYiLi1N7rFy5cmHVqlV49OgR6tSpgyFDhiBXrlyYM2cOIiMj0zz2/PnzAIASJUqotolEIkybNg1XrlzB7t27tTvBbMbNzQ2vXr1K8b3Ro0fj1atXWLNmDSQSSbpjderUCcePH8fNmzfh6+uLhw8fpjt369atsXTpUty9excfP35E/aFDIRaEtCf6/Bmwtk6+3cYm4d9Pn1I9VCoS4XpERHqnkilcunQJ3t7eOH/+PPbv34/p06dDJpNpPM67d+9Qp04d5MqVC1u2bIFUKs2E1aaMra0tAODTp08Qi8UwMTHJ8mtkdqAXA/+j5MmTB0eOHMGDBw/QuHFjxMTEZNncTk5OePv2barvv3z5EqVKlUJISAhMTExQunRpTJ8+HUKiC6hcLsfgwYOxadMmPH/+PNkYCoUCXbt2RaFChTBgwIAMrzk+Ph79+/dH9+7d0aNHDxw8eBCWlpYZHjcxEokETZs2xZUrVxAcHAwXFxe0bdsWuXPnxpw5czS6IGkjCu7fvw9TU1NY/3ITqlSpEmrUqIGRI0ciPj4+Q+eYHbi5ueHly5fJtp87dw5z587FpEmTkC9fPrXHq1ChAi5fvgyZTAZfX1/89ddfah9ra2uLOEdHCOJ0Lr2xsYBcnny7cltsbKqHCiTu//yp9pp0AUnMmjULfn5+cHZ2xo0bN1C3bl2txoqMjET9+vURFxeHAwcOwMzMTMerTZvEYgAAzMzMEJFN4ior0YuB/2G8vb2xb98+nD17Fu3atYNCociSedOyDAAJYiBnzpzInz8/Ll68iIEDB2L48OGoVq0aXr9+rdqvc+fOsLKywsyZM5ONsWTJEly/fh3Lli3T6skkMd+/f0e9evWwcOFCLFq0CAsWLMjUJxWRSISKFSvi0KFDuHXrFipVqoShQ4fCzc0No0aNwrt379QeK7EoqFu3rkoUzJ49O4koiIuLw8ePH+Hh4ZHiOFOnTsXDhw+xdu3ajJ5elpOSGIiMjETHjh1RunRp9O/fX+Mxc+fOjYsXL6JMmTKoVasWFi1apPaxP9X5nsnlKd/wldtSEgr/IACISs/yoEO+fPmCBg0aYPDgwRgwYABOnz4NNzc3rcYSBAHt2rXD3bt3sX//fri4uOh4teljZ2cHAPj48SMAwNTUVG8Z0PPfp2LFiti8eTN27NiBvn37gmSmz+nk5ISPHz8iNoWLnSAIePXqlepiIpfLMW3aNJw4cQIPHz5E0aJFsXPnTgCAiYkJ+vXrh9WrV+P9+/eqMd68eYORI0eiW7duKFOmTIbW+vTpU5QpUwYXL17E4cOH0bNnzwyNpylFihTBunXr8OzZMwQEBGD+/Plwd3dHt27d8OjRI7XHyZUrF1auXKkSBcOGDYOHh4dKFNy/fx8kUbJkyRSP9/b2RosWLRAYGIioqChdnV6WkJIYGDVqFF6/fq22eyAlLCwssH//fvTp0we9e/dGr1691LKcGIhE6Q9uYwN8+ZJ8++fPCf/+8/SaEmIABulZHnSErtwCSkaOHIldu3Zh06ZNSdxVWYneMqDnf5ZGjRph2bJlWLx4McaPH5/p8zk6OgJAkhu4knfv3iEuLg45c+ZMsr1SpUq4desWKleujKZNm6JTp06IiIhAr169IJVKMXfuXNW+/fv3h7GxMaZOnZqhdZ45cwa+vr6Ii4vDpUuXUK1atQyNlxFcXV0xa9YsvHz5EuPGjcPevXuRP39+NG7cGJcuXVJ7HKUoePjwIerVq6cSBWPHjgUAVK1aNdVjJ06ciPfv32PhwoUZPp+sxNXVFd++fUN4eDgA4OzZs5g3b57G7oGUkEqlmDNnDpYtW4bly5ejVq1a+Pr1K4AE0/nbt29x9OhRzJo1Cx07dkTJkiVxcsMGIL04EE9P4NUr4Fdz//37//9+KohFIngaGWXktNJFl24BJStXrkRQUBBmzZqFBg0a6GilmmNiYgJDQ8P/OcuAPptAj4qs6mNw48YNAkixLPCFCxcIIElFwsQIgsDVq1fTxMSEnp6evHz5MocMGUJzc3N++/ZNVUs8o6lAq1evpkwmY6VKldSKGs9qoqKiuGLFClXmhZ+fH/ft26dxedlnz56xc+fOFIlEBMDRo0enmX3Qs2dPWllZ8evXrxk8g6zj7NmzqsyTnz9/0tPTk2XLltVpk5uvX79y3rx5NDY2pqWlJUuVKkVra2tVaqGxsTFLlSrFgIAAtli7Nv2CQ4sWpVxnwNmZKFAg3WwEXXQzTA1dZQsk5vjx45RKpezevftvkbXi4uLC0aNHkyRr167Nhg0bZvOKtEefWqhHYwRB4IABAygSiTI1r/bXnuGJURYcSq9S4OPHj+nj40OJRMJhw4bRwMCAgYGBzJkzJ6tXr671BSU+Pp6DBw8mAHbp0kUnF7rMRKFQcPfu3SxTpgwBsECBAly9ejWjo6M1GsfFxYVisZhSqZQ5cuTgzJkzU0zrDAsLo7GxMYcPH66rU8h0Xrx4QQA8fPgw+/XrR0NDQ61rzUdFRTEkJITr16/nkCFDWKtWLbq4uKhu+hKJhHK5nHK5nB07duSePXtU3QqVPI+MVK87YYUKKVcgnDs33T4F7zKp/bAuigj9yt27d2lhYcEaNWpkaQphWnh7e7N79+4kyWbNmrFKlSrZvCLt0YsBPVqh7GMgk8l49OjRTJtDKpVy8eLFyd4LCgqihYWFWuPExsZy9OjRFIvFdHBwoKGhIQ0NDbWu5hceHs569epRLBZzzpw5v8UTiiacO3eO9evXJwA6OTkxKChIrfLLyqqQHh4eKktBWqJg9OjRNDIy4ptsLmyjLnFxcRSLxRw8eLDa7avj4+P58OFD7tixg4GBgWzSpAnz5cun6miIf/pM1K1blyNGjOCff/7JW7duMTo6ml+/fmX16tUpkUi4dOnSFMev8fff6RceOno0QQhYWxMyWUJvgqCgNI+RBie0NNY1uioi9Cvv37+nu7s7Cxcu/FvdX6pVq8YmTZqQJDt16kRfX99sXpH26MWAHq3Jij4Gic1wienZsyeLFCmi0VhnzpxR9acvXry4VusJDQ1lkSJFaGZmlmZr5X8D9+7dY0BAAGUyGc3MzDhkyJA0u7y9fPmSAJKYQtMSBd++faONjQ27du2a6eeiK5ydnWllZcVy5colcQ8IgsDXr1/z8OHDnDFjBtu1a8fixYvT0NBQddO3s7Nj5cqV2bdvX65YsYIXL15M91oYFxfH3r17EwD79OmT7In3yOfP6VsGtHyd03H/jcxwC5AJ/SBKly5Ne3t7hoaG6mRMXdGqVStWqFCBJNmvXz8WLFgwexeUAfRFh/RojUwmw7Zt2+Dt7Y3atWvjvjJoSYekll6oTCvUhHLlysHd3R0ymQwhISFo06aNKlhMHS5cuAAfHx9ERETg4sWLqF27tkbz/24UKFAAq1atQmhoKHr27Illy5bBw8MDAQEBuHfvXrL9z507ByAhs0SJh4cHVqxYgcePH6NBgwYYPnw4PDw8MHPmTEilUowcORKrVq1Kt+jO74IgCPj+/bvq99GzZ0/4+fnB2toaLi4uqFWrFgIDA/Hw4UN4e3tj2rRpOH78ON6/f48PHz7gxIkTmDdvHjp37ozSpUvD3Nw8zfmkUikWLFiAxYsXY/HixahTpw6+ffumer+GtTWa29lBuzyGlJEA6OLoiHIWFjobU9fZAkoEQUCHDh1w8+ZN7N+/X+PvfGZja2urCiDUZxPo+Z/G2NgY+/fvh7OzM6pXr55i0ZaMkJoYePHihcY5ysuXL8fVq1exYsUKAMDOnTtRrFgxXLhwId1jN27ciEqVKiFv3ry4fPkyChUqpNHcvzNOTk6YNm0aXr16hSlTpuDYsWMoVKgQ6tWrh7Nnz6rSSJVFc6pUqZJsDHd3dyxfvhyPHz9Gw4YNMWLECHh4eCAmJgYODg4YM2ZMlp6TOkRFRSEkJATr1q3DkCFD4Ovri7CwMAiCgNatW6Nfv344e/YsXF1dMWTIEOzduxfPnj1DeHg4Ll26hJUrV6Jfv36oUqUKcuTIkaG19OjRA0eOHMGVK1dQpkwZPHnyRPXewjx5YCWRADqo7yESBDgbGGBm7twZHgvInGyBxIwZMwbbt2/Hxo0bUapUKZ2Nqyvs7OxUqYX6bAItzAx6/nso+xjkz59fp30MunfvzmLFiiXbbmFhwaCgILXHCQsLo4WFBTt37kySrFu3Lj09PVmmTBmKxWKOGzcuxaAkhUKhqsXfvn17jQPu/o3ExMRw7dq1qhr5pUuX5q5du1ikSBGKxWK1greeP3/OLl26UCqV0szMjAB45syZLFh9cuLi4nj//n1u376dY8eOZePGjZk3b95kfn1jY2OamprS1taWt2/fTrUBVmby8OFD5smTJ0ljqxcvXtClXDmK9+9PP34gjZf45Eli5052HjdOJ3EumeUWULJmzRoC4PTp03U6ri5ZsmQJJRIJFQoFFy1aRJlMlt1L0hp9zIAenfHo0SPmyJGDPj4+6fZqV5fx48fT3t4+ybZv375pnBbYokUL2tnZqdL/zp8/TwDcsWMHx48fT4lEwjJlyiRphxwREcHGjRtTJBIxKCjoXxcomFEUCgUPHDhAf39/AqBIJKK5uTmjoqLUHkMpCgBQJpNx+vTpqTaVyiiCIPDly5c8dOgQg4KC2LZtWxYrVowGBgaqm36OHDlYpUoV9uvXjytXruSlS5f448cP9unTh0ZGRhw7dixlMpnGqZe6JHHL62nTptHDw4Pu7u4MfvyYhS5fVi/D4JeXKDiYxa9e5Zh/UhHHjRuXoTVmRrZAYoKDgymTydilS5ff+nu3fft2AuDnz5+5bt26NLuo/u7oxYAenRISEkIzMzNWq1ZNJ0/RK1asoEgkSvI0euvWLQLghQsX1BrjyJEjBMANGzYk2e7v76/qsnfhwgV6eHjQzMyM69at48uXL+nt7U0TExPu2bMnw+fxb+f48eOqG6q9vT0nT57ML1++qH388uXLVSl1dnZ2GRYFnz9/5unTp7lw4UJ2796d5cqVo4WFhWqNpqamLF26NLt06cJ58+bxxIkTfP/+fYpjnTp1igA4Z84c7tu3jwD49u1brdemC2JjY9mmTRsCoLm5uUqkxigUHPfsGeWnTiWIghMn0hQAouBgGp4+zamhoYz7R+Ao64RMmzZN43VlVrZAYh48eEArKytWrVr1t0/ZVX52Hjx4wF27dhEAP336lN3L0gq9GNCjc4KDgymXy9m8efMMF2xRFgdKHOW+f//+ZNtS4+fPn/Tw8GCVKlWSPWEcPnyYAHj8+HGSCZ/f9u3bEwANDQ3p7OzMv//+O0Pr/6/w119/EQB79uzJbt260cDAgCYmJuzfv79aNwRBEFi2bFkWKlRI5T5QRxT8/PmTV69e5Zo1azhw4EBWr16dTk5Oqpu+TCZjkSJF2KpVK06ZMoX79+/n8+fP1X6yj4iIYK5cuVi+fHkqFAr+/fffBJBp2THqEhoaSg8PD9rY2FAikbBWrVpJ0j8/x8ay+sqVFK9Zk6LrQHrqFL2vXuX8V6/4LQW3ztixYwmA8+bNU3tNme0WIBNak+fOnZsFCxb8VxSsunPnDgHw3LlzPHbsGAH8dhkP6qIXA3oyhV27dlEsFrNnz54ZMvNdv36dAHj16lXVNqVvTp0L/ogRI2hgYJBi8RhBEOjt7Z2kUMiWLVsok8kokUjo5OTE06dPa732/xLKAktnz54lSb57946jR4+mlZUVJRIJ27Rpk2o1SCVnzpwhAG7ZsoWhoaHs1q0bZTIZbW1tOW3aNF67do3btm3jmDFj2KhRI3p6eqoqHopEIubOnZsNGjTgqFGjuGXLFt65cyfDN6TevXvTyMiIjx8/JplwwwPAbdu2ZWjcjBAaGkp3d3d6eHjwxYsXPHr0KC0sLFiwYMEkbiwvLy+2atWKUfHxvPr9O498/syjnz/zWng4o9P5bgiCoPqbLl++PN01ZbZbgEwo1FSuXDna2dnx2bNnmTKHrlEWRtuzZw8vXrxIALx9+3Z2L0sr9GJAT6axYsWKDPsnw8LCCIB79+5VbRs6dCg9PDzSPfbOnTuUSqUcP358qvts27ZNVfI4MDCQANiqVSs+fPiQ/v7+FIlEHDly5G9vrsxsypUrRwDJShD/+PGDc+fOpZubGwGwZs2aPHnyZKoCsHbt2syZMyf37NnDadOmsWHDhrSxsVE96Sv9+lWrVuWAAQO4atUqXrlyJVPiDIKDgwmAc+fOVW0TBIEmJiacOXOmzudTh+fPn9Pd3Z25cuVKYnG5f/8+PT09aWNjw9OnT/PZs2cZFi2CILBXr14UiUTJXGiJ98lst4BynlatWtHQ0JAXL17MlDkyg7i4OALgihUrePv2bQL4V60/MXoxoCdTmTJlCgFw4cKFWh0fHx9PsVicpEJb8+bNWbFixTSPUygULFeuHPPly5dm7EJ8fDw9PT3p7OxMAJw0aZLqRhYfH88pU6ZQKpWyVKlSfPTokVbn8F/A1tY2zYqPsbGx3LhxI728vAiAJUqU4MqVK3n8+HEuWLCAXbt2ZdmyZWlqaqq66ZuZmbFMmTLs2rUrAwMDWa9ePZWlICgoSGdBqCnx48cPenh40M/PL5mFqUCBAuzXr1+mzZ0az58/Z86cOZkrVy6+fPky2fufP39mpUqVKJPJ2KJFCxoYGDA8PDxDcyoUCnbq1IlisTiZsMgKt4ASpdsiOy0y2mJtbc2pU6cyNDSUAHjs2LHsXpJW6MWAnkxFF30MnJycOHbsWNXPZcqUYfv27dM8RmmVUKZnpcbbt2/p7u6uCiBLiStXrjBPnjw0MTHhypUrf+vo5swgJiaGIpGIJUqUSPH9iIgIXrlyhatXr2b//v1ZvHhxyuVy1U1fKpWySJEibN26NadNm8ZKlSrRzs4uxZv9r+6DzBIFvXr1SuIeSEyNGjXYqFEjnc+ZFkohkDt37hSFgJLY2Fh27dqVAOjh4aGTJkrx8fFs1aoVpVIp9+3bR/L/3QJWVlaqbZnF+vXrCYBTpkzJ1Hkyi7x583LgwIH89OkTAXDXrl3ZvSSt0IsBPZlORvsYlChRgl26dFH97OTkxDFjxqS6//v372llZcUOHTqkOW5ISAidnZ3p5OREOzu7NAXGjx8/2LlzZwJg48aN/7URw9oQEhKiash09+5dbtmyhaNHj2aDBg2YO3fuJH59T09PNmzYkGPGjOHUqVNZq1YtikQi2traMjAwkB8/fuTz588pk8k4efLkVOd88eIFu3fvniSmQFei4OTJk2kGz3Xp0iVV4ZMZPHv2jG5ubsydOzdfvXqV7v7v37+nSCSiSCRinTp1dHK9jYuLY+PGjSmXy9m1a1dKpVKWLl0609wCSk6fPk2ZTMaAgIB/rcguV64c27Vrx5iYGALgunXrsntJWqEXA3qyBGUfAxMTE40jtevWrcu6deuS/P+n1JUrV6a6f5s2bWhjY5Nm8aOdO3fS2NiYJUuW5Js3bzh79mxKpdJ0I4F37txJa2trOjk5qbIQ/msIgsDQ0FDu37+fU6dOZbFixVRP+MqnfUdHR1avXp0DBw7kmjVrePXq1VT9+s+ePVMF6hkZGbF3795s3749zc3N0xVViUWBjY1NhkXBjx8/6O7uTn9//1QDUCdOnEg7Ozut59CEp0+f0s3NjZ6enmoJATKhbbbS0mZubs7ChQvz+fPnGV5LWFgYc+TIQQBs0aJFpsfJPHr0iNbW1qxUqdK/NjefJBs0aMBatWqRJGUyGRctWpTNK9IOvRjQk2X8/PmT5cqVo7W1Ne/du6f2cV27dlU1Fnr69GmafjllCtyaNWtSfF8QBFUcwx9//KEKiPvx4wetra3Zu3fvdNfz+vVrVqlShSKRiEOGDPlXVyX88OEDT548yXnz5rFLly4sXbq0qmKgMsfdysqKADh16lSeOnVKa6vIx48fGRgYSBsbG1Ub5DZt2qh1rK5EQc+ePWlsbJxmx8q1a9cSACMjIzUeXxOePn1KV1dXenp6qpUmq6RevXosX748yYS2vrly5aKtra0q00MblG4BS0tLenl50dTUNFMD4T59+sQ8efIwf/78GtWr+B3p1KkTS5UqRZK0srLSqn7D74BeDOjJUr58+cLChQvTxcUlTd9oYsaNG0dHR0eS/x8BnlKqYFRUFD09PVmhQoUUTY5RUVGqQi5jx45N9mQ4fvx4GhoaplqcJjEKhYIzZ86kTCajt7c379+/r9a5ZBc/fvzg5cuXuXLlSvbv359VqlShvb296qZvYGDAYsWKsU2bNgwKCuLBgwf58uVLCoJANzc3GhkZ6WwtP3/+5KJFi1Qio1y5cjxy5IhaZuIXL16wR48eWomCEydOEADnz5+f5n5KN0JKnzFd8eTJE7q6ujJPnjwaCYEfP37QwMAgSbbDx48fWaFCBcrlcq5du1ajdSTOFlC6BSIiIli+fHlaWFjw+vXrGo2nDtHR0fT396etra3WbcR/J4YPH053d3eSpJubW4pdVv8N6MWAnixH0z4Gy5Yto1gsZnx8fJpPbWPGjKFMJkvxxvzu3TuWKVOGBgYG3LRpU4rzfP78maamphw5cqTa5xISEsL8+fPTyMiIS5YsyXa/Z2xsLG/fvs3Nmzdz5MiRrF+/PnPlyqW66YtEIubJk4eNGzfm2LFjuX37dt6/fz/VfgOCIFAqlTJfvnw6X+uXL19oZmamSi308vLixo0b1TJP/yoKpk6dmmZkvdI9UKFChXTrUzx58iRJMSpd8+TJE7q4uGgsBMgENxWAZDfRmJgYdurUiQA4dOhQtQIL08oW+P79O318fGhjY6PTvHlBENi2bVvK5XKeO3dOZ+NmJzNnzqSpqSlJsmDBgtmSiaIL9GJAT7agbh8DhSBw6f79RPnyXPjgAf9YvJhWZcsy8peL3f379ymTyVIMLLx58ybd3Nxob2+fbrzCoEGDaGFhodFn+OfPn+zRowcBsF69evzw4YPax2qLQqHgs2fPuG/fPk6ePJktW7Zk4cKFKZPJVDd+Jycn1qhRg4MGDeLatWt57dq1ZHUC0kOZLtW8efNMOY/58+dTJBJx9erVrFmzJgHQzc2Nc+fOVeuJX11R0KNHDxobGycp2pMa0dHRBMDVq1drdU5p8fjxY7q4uDBv3rx88+aNxse3adOGRYoUSfE9QRA4e/ZsisVi1q9fP01xpE62wJcvX1isWDHa29vrzEoyYcIEAkhVkP8bUfYkiIqKoq+vLzt16pTdS9IKvRjQk21cv35d1ccgcQCRIAg8/+0bW929S9MzZ1LuwBYczFLXrnHN27f8GRfHChUq0NPTM1kTnX379tHU1JReXl5quSXevHlDuVyuld9v3759tLW1pYODA48cOaLx8anx/v17njhxgnPnzmXnzp3p6+ubJF/fwsKC5cuXZ48ePbho0SKePn1a1ZApoyg7x6lTpU4boqOj6e7uzoYNG5Ik//77b7Zp04ZSqZRWVlYcNWoU3717l+44L1++TFUUKN0DCxYsUHtdDg4ODAwM1O6kUiGjQiA2NpaWlpZpZtKQCSW8zczMWLRo0WQBsSm5BdLiw4cPLFiwIJ2dnTNcFXDTpk0EwAkTJmRonN+NgwcPEgBfvXrFKlWqsFmzZtm9JK3QiwE92crJkyeT9DF49PMny16/rqqvnmZL1n/+NTl+nKhUicf++ks1rvKiJxKJ2KBBA42Czbp06UJ7e3utAsjCwsJYo0YNAmD//v016vAXHh7OixcvcsWKFezbty8rV66siu5W+vW9vb3Zrl07Tp8+nYcPH+arV68y1TXRunXrFM3SumTDhg0EkjaeevHiBQcMGEATExMaGBiwW7duahV9evnyJXv27Em5XE5ra2uOGzeOrq6urFixokadCH18fBgQEKDV+aTE48eP6ezszLx582rdBEnZLCokJCTdfe/cuUMPDw/myJFD9XvVtojQ27dv6enpSXd3d7XjfH7l3LlzlMvlbNeuXba70nTNlStXCIA3btxgw4YNWbt27exeklboxYCebGfnzp0Ui8WsNGMGDU6dolTTFq3/dG5rcvs2f8bHMyYmhgEBAQTA4cOHa9yO9vHjxxSLxVqnCCkUCs6bN48GBgYsUqRIMp9rTEwMb926xU2bNnHEiBGsV6+eqvARAIrFYubLl49NmjThuHHjuGPHDj548EAnBWY0pWDBgpRKpZl6AVcoFCxatCj9/f2TzfPlyxdOnjyZOXLkoEgkYuPGjdVKTVWKArFYTAAcPHiwRtX6mjRpwqpVq2p8Linx6NEjOjs7M1++fBnqhti7d2+6ubmp/bf48OEDy5cvT7lcznHjxmWoiNCLFy+YM2dO5smTh2FhYRod++TJE9ra2tLf3/9fnXmTGsrS0MeOHWObNm3o5+eX3UvSCnXv3yKSRDqEh4fDwsIC379/h7m5eXq769Gjotn27dhuZ5ehMcQAShobQzZyJK6ePYsVK1agXbt2Wo3VsmVLXLp0CY8fP4ZUKtVqjJs3b6JZs2Z49uwZatSoATMzM9y+fRsPHz5EfHw8AMDFxQWFCxdGkSJFVP/mz58fRkZGWs2pa0xMTGBtbY1Xr15l6jyHDh1CnTp1cOjQIdSqVSvZ+9HR0diwYQNmzJiBx48fw9/fH0OHDkWtWrUgFotTHPPEiROoWrUq/Pz8cPnyZZiammLw4MHo3bs3zMzM0lzPwIEDcfDgQTx8+DBD5/X48WNUrFgR5ubmOHnyJBwdHbUahyTc3NzQuHFjzJs3T+3joqOj4e/vj6tXr8LJyQnnz5+Hu7u7Vmt49uwZ/Pz8YGVlhVOnTsHW1jbdY75+/YoyZcpAEARcvHgRNjY2Ws39OxMREQEzMzNs2rQJZ8+exaVLlxASEpLdy9IYde/fKX/b9OjRAbs+fsywEAAAAcCViAhcrVYNJ06c0FoIAMDw4cMRGhqKLVu2pLsvSbx//x7Hjx/H3Llz0alTJ/j6+qJcuXJ49OgR4uPjcfDgQRw9ehSlSpXC/PnzcfbsWXz58gWvXr3C4cOHMX36dLRr1w7e3t6/jRD49u0bIiMjUahQoUyfq1atWvD398eIESMgCEKy9w0NDdGlSxfcv38fu3btQkxMDOrWrYuiRYti3bp1iI2NTbL/jx8/0KlTJ1SsWBGnTp3C06dP0bJlSwQGBsLd3R1Tp07Fjx8/Ul2Pm5sbXr16BTWegVLl0aNHKiEQHBystRAAgOvXr+P169do2LCh2sd8+fIFzZo1w9WrV1GhQgWEhYVh4MCBiIiI0GoNuXLlwokTJ/Dx40dUq1YNX79+TXP/2NhYNG7cGB8/fsTBgwf/k0IASBDMBgYG+PjxI0xNTdP8XP0n0KWZQY8eJR9iYmh19ixFwcHEoUNEu3ZEqVKEsvDNsGHJ3QKLFxP16xN58hASScJ+v+yzSY2gs/SoXbs2CxUqlMTN8P37d164cIHLly9nnz59WKlSJdra2qpM/IaGhixRogTbt2/PmTNn8siRI3zz5g0PHjxIe3t72tnZ8cCBAxleW1agDIxKq2ywLrlw4QIBcOPGjenuKwgCz5w5o/KBOzs7c8aMGaprT7du3WhiYpIs6O3Vq1fs1auXKqZg8uTJKV6vlCl86qS+psTDhw/p6OjIAgUKaGxWT4lRo0bR2to61RTQX0kpW0AZTFusWDGtff8keevWLVpbW9PX1zdV14sgCOzQoQPlcjnPnDmj9Vz/FlxcXDhmzBhOmDCBDg4O2b0crdDHDOjJVjrev0+J8ia+eXPCTdXenvinBG6KYqB9e0IqJfLmJVxdk4kBUXAwLc+eZUQGfOzR0dGqSPomTZqwTp06zJkzZxK/fv78+dm0aVOOHz+eO3fu5KNHj9L0679//55169YlAPbq1SvTK9xllD59+hAAr127lmVzNmjQgB4eHhqVp7179y47duxImUxGc3NzNm/enADSjPlITxRcvXqVALQquvPgwQOVEFAnE0IdChYsmG5zLjL9bIFbt24xZ86caqXZpsW1a9doYWFBPz+/FNNVlVU+U2uN/F+jWLFi7N69O2fPnk0TE5PsXo5W6MWAnmzjY0wMZYkzBo4eJXbuTPj/0qWpi4GdO4kjRxL+37BhipYBBAdzhRrpWwqFgk+ePOHu3bs5ceJENmvWTBU0p7zxy+Vy1q5dm0OHDuWGDRt448YNjbIEEiMIAhcvXkxDQ0MWKFCAN27c0GqcrMDX15cikSjTa9Qn5u7duxSLxelWCUyJ169fs2/fvqomPh07dky37HVqouD9+/cEwN27d2u0BqUQKFiwoM6EwMOHD9Vai7rZAu/fv2fZsmXTLMClDhcuXKCJiQmrVq2a5PuwdetWVZXP/xWqVq3Kpk2bqrqlahq0/Dug7v1bHzOgR+esf/8eisQ+WbkcsLZO/0Bra8DAIM1dxAAWvXmj+pkkwsLC8Ndff2H27NkICAhAqVKlYGZmBk9PTzRq1Ahz5szB+/fvUalSJSxcuBDnzp3Dtm3bEBsbi8GDByMoKAht2rRBsWLFYGhoqNU5i0Qi9OjRA9evX4dcLoevry9mz56dop88u3n8+DGsra0hk8mybM6CBQuiffv2mDhxosa+V2dnZ0RHR8PY2BjDhg3D0aNHUbBgQTRo0ADnz59P8RgXFxcsXLgQT58+RatWrTB+/Hi4u7tj+fLlkMvlePnypdrzP3jwABUrVoSVlRVOnjwJe3t7jdafGnv37oWRkRGqV6+e6j6XLl2Ct7c3zp07h3379mH69Omp/t1y5MiBkydPonnz5mjVqhXGjBmj1eevTJkyOHDgAM6dO4emTZsiNjYWly5dQrt27dCqVSsEBgZqPOa/FTs7O1XMAAD8/Pkzm1eUiehSWejRQ5L1bt1S1QpI9krLMpD4lYZlACdPsmv//qxQoYKq5C0AGhkZsWTJkuzQoQNnzZrFo0eP8u3btymmbAmCQC8vL1arVk3n5x8dHc1BgwYRAKtWrapVIZrMQtmOtUyZMlk+98uXL2lgYMDx48drdNyxY8cIgIsXLyaZ8PtdvXo1CxQooDqX3bt3p/nU9urVK/bu3ZtyuZxisZjly5dX63p2//59Ojg4sFChQmr1ttCEMmXKqIoy/YqmRYR+PXbatGkUiURs0qRJql0n0+PIkSOUy+WsWbMmbW1tWa5cOa0tZ/9W+vTpw0KFCvHAgQMEkKEU0uxCbxnQk21cDg9Hpj4Pi0Q4+uQJ7O3t0a9fP+zevRuPHz/Gjx8/cPXqVaxZswYDBw5E9erV4ejoCJFIlMIQIowYMQJ//fUXrl+/rtPlGRgYYObMmfjrr79w9+5dFClSBHv27NHpHNpy69YtAEDp0qWzfG5XV1f07t0bM2bMwMePH9U6Jjw8HJ06dULlypXRrVs3AAm/344dO+LOnTvYv38/pFIpGjVqhIIFC2LlypWIjo5ONo6LiwsWLFiAp0+fwsnJCRcuXIC7uzsmT56M8PDwFOe+f/8+KlasCFtbW5w8eRI5cuTQ/uR/ISwsDJcuXUoxi+DLly9o0KABBg8ejP79++PMmTNwc3NTe2yRSIRhw4Zh165dOHLkCPz9/fH69WuN11ijRg2sWbMGR44cQXR0NHbu3Km15ezfip2dHT59+qSyDGibsfFvQC8G9OiUOEHAh7i4TJ9n/IoV2Lp1K8aMGYOGDRvC09MTEolEozGaNm0KT09PTJ06NVPWWLVqVdy+fRv+/v5o1KgRunXrlu1mxkOHDgEAatasmS3zjxgxAmKxGJMnT1Zr/8GDB+Pr169YtWpVsroDYrEYdevWxZkzZ3DhwgUULFgQXbt2VaUYppQi5+LigqpVq6JYsWJo06YNJk6cmKIouHfvHipVqgQ7OzudCwEA2L9/v2r9ifnVLTBjxgyt3TkNGzbE+fPn8fHjR/j4+ODq1asaHR8XF4fVq1fDxMQEkZGRGD169G/p9spMbG1t8enTJ5iYmADAfzq9UC8G9OiUuAzkb2s0jw4uShKJBEOHDsWuXbvw4MEDHawqOTY2Nti1axeWL1+OjRs3onjx4jq3RGjCuXPnACT4hbMDGxsbDB06FEuWLEFoaGia+x47dgwrVqzAjBkz0i2oU6ZMGdXfsUGDBhg/fjzc3NwwaNCgZIWV3Nzc8O7dO8yfPx9Pnz5NIgomTZqEK1euoHLlyiofvJ0OamX8yu7du+Hv76/K0SeJ2bNnw8/PD05OTvj7779Rr169DM/j5eWFK1euIGfOnPD398fWrVvVOo4kevbsiTNnzuDAgQNYs2YNVq1ahf79+2eoRsO/DTs7OygUCtU56y0DevSoiYFYnCUfKmMNrQCp0a5dOzg6OmL69Ok6GS8lRCIRunTpgpCQEJiZmaF06dIICgqCQqHItDlT4969ezA1NU23Ul9m0r9/f1hbW2PcuHGp7vP9+3d07twZVapUUbkH1CFv3rxYtmwZQkND0bdvX6xevRq5cuVCu3btcPv2bQAJ7oqwsDDExsbC2dk5mShQulD27NmTKUIgPDwcJ06cULkIlG6BQYMGaeUWSA8HBwcEBwejSZMmaNGiBQIDA9O9oc+YMQMrV67EihUrULFiRbRr1w5Lly7FggULMHz48P8ZQaCsxhgTEwNAbxnQo0dtJCIRcmVBpb2nJ07gyZMnGb4oGRgYYODAgdiwYYNGEebakC9fPly4cAGDBw/GiBEjULVq1UwvB5wYknj37p3WZWt1hYmJCcaOHYsNGzaobtC/ktg9kFLMR3o4ODhg8uTJePnyJWbMmIFTp06haNGiqF27Nr5+/QqSeJMoK8XZ2RndunWDmZkZrK2t8e3bN5QsWRKTJk3C9+/ftT7XlDh8+DDi4uLQsGFDnboF0sLQ0BAbNmzA5MmTMX78eLRo0QKRkZEp7rtz504MGzYMo0aNQvv27VXbu3btirlz52L69OmYMGGCztf4O6IUg8o4FL1lQI8eDShjbg7dPLenQnw8xrZvjzx58sDR0RFNmjTBnDlzcOXKFcRpEa/QtWtXmJmZYdasWZmw2KTI5XJMnToVJ0+exJMnT1C0aFFs37490+cFgNDQUCgUChQvXjxL5kuLzp07I3fu3Bg5cmSy944ePYqVK1di5syZyJkzZ4bmMTMzQ//+/fH06VNs2LABr1+/xtChQwEA69evV1ln7t69i0qVKsHZ2RkPHjzAs2fP0LZtW0yaNAnu7u6YOHGizkTB7t274e3tjR07dujcLZAWIpEII0eOxM6dO3HgwAFUqFABb9++TbLPlStX0KZNGzRv3jzFG36/fv0wdepUBAYGZqo17XdBaRlQWgT+y5YBfWqhHp2z5f375OmAffsSAQEJ5YYBws8v4eeAAGL//v+vVKjc9k/amOrnESMS2hufPMlaN27w69evPHToEEeOHMkKFSrQ0NBQlV5YsWJFjh49mkeOHOG3b9/UWvO4ceNoZGTEDx8+ZPJv5//58uUL//jjDwJghw4dNOq+pw1LliwhAK5fvz5T51GXLVu2EADPnj2r2vbt2ze6uLiwatWqmdJRURAE7tmzR5WOmjt3bo4ePZp2dnb08vJKVqb4zZs37Nu3Lw0MDGhpackJEyao/ZlKiejoaJqamjJfvnyqrotZWfxJSUhICF1cXOjk5KSqRBkaGkp7e3uWLl063SqaY8aMIQCtikj9m4iLiyMArly5kiYmJpwzZ052L0lj9BUI9WQbMQoFbc6eTSoG7O1VF+Bkr82bE/aZMyf1fby8VGNZVKnCiRMn8vPnz/8/Z0wML168yJkzZ7Jhw4a0s7MjAIpEInp5ebFnz57ctGlTqvnanz59oomJCUePHp1VvyaSCTentWvX0tTUlLly5cpQKdn0aNas2W+VK61QKFi8eHGWLVtWdePv1KkTzczMGBoamqlz29jYsGfPnqxRowYBUCKRcPjw4fz06VOK++tKFMyePZsAaG5urlXLYV3y9u1b+vj40MjIiOvWrWPhwoXp4eGhVj0FQRA4ePBgAuDy5cuzYLXZh5WVFadOnUoHBwdOmDAhu5ejMXoxoCdbCXrxIqFJkQ5fkuBg5jt7lt179KChoSFNTEzYv3//FG/wgiDw4cOHXL16NQMCAlRPYgDo6urKFi1acOHChfz7779VfQcGDBhAS0vLbPmcP3nyhL6+vpRIJJw4cWKavRC0JW/evJTL5TofNyMcPXqUALh3714ePnyYALhs2bJMn9fb25tNmzalra0tCxQowICAABoZGdHY2Jh9+vTh8+fPUzzuzZs37Nevn8aiQBAEzpo1i2KxmAYGBpkudtQlMjJS1fPBwMCAd+/eVftYQRDYq1cvikSi/3Svgjx58nDQoEH09PTk0KFDs3s5GqMXA3qylTiFgt5Xr1KqYzHw948fJBPqsI8ZM4ZWVlaUSCRs06YNb968meaaPnz4wN27d3Pw4MEsXbo0ZTKZ6imtRo0aHDRoECUSCSdNmpQVv6JkxMbGcsyYMaoKeandkLTFyMiIHh4eOh0zowiCwMqVKzN//vx0cXFhtWrVMsU98CsVKlSgTCajt7e3yhrw4cMHjhs3jjY2NpRIJGzZsiVDQkJSPP5XUTB+/PhURUHi3gLGxsbs379/pp2XpgiCwG7dulEsFhMAW7RooVGjLYVCwYCAAIrFYm7fvj0TV5p9lC1blu3atWOxYsXYo0eP7F6OxujFgJ5s515EBE3PnEm9NLGGr5kptGf98eMH586dSzc3NwJgrVq1GBwcrNYNJTIykqdPn+aUKVNYu3ZtWlpaqqwHJUqUYP/+/bljxw6dtKrVhLNnzzJnzpw0Nzfnn3/+qZMxv3z5QgCsX7++TsbTJVeuXFG1idak7K623Lx5k4aGhjQ0NEzialISERHBBQsW0N3dXVVS+tixYyl+ppSiwNDQMEVRkLjl8PTp05PFSGQ3s2bNUvnEt2/fTiMjI/r4+GjkSoqPj2erVq0olUq5f//+TFxt9lC/fn3Wrl2bfn5+bNu2bXYvR2P0YkDPb8GFb99oeubM/7cz1vR18iQRHMweV66keYOPjY3lhg0bWKRIEQJgqVKluGPHDo3M7QqFgvv37ycA+vj4qG4GykCz9u3bc/ny5bx3716mP71++/aNrVu3JgC2bt06Q0FrJLlr1y4C4KxZs3S0Qt2hdA9YW1tneu37v//+mzY2NnR2dqaZmVma+8bFxXHLli0sXrw4AbBYsWLctGkT4+Liku379u3bJKIgMDCQkyZNStJbYOjQocyRI0emuIC0Yffu3RSJRBw2bJhq27Vr1+jk5EQXF5dUrSIpERcXx8aNG1Mul/PYsWOZsdxso1OnTvTx8WGtWrVS7SXxO6MXA3p+G+5ERLDolSsaxxBIg4NpfPo0nQICmCdPHn758iXduQRB4OHDh1mpUiUCoKenJ5cuXarRTeaPP/6gh4cH4+Li+Pr1a27dupV9+/Zl8eLFVeZUa2tr1qtXj9OmTeO5c+cYHR2dkV9RqmzcuJHm5ubMmTNnhp4ou3XrRgDptv7NapTZA+XKlaNYLObs2bMzbS6lEChevDhXrlxJAGr7+48fP87q1asTAHPmzMl58+al2ADo7du37N69u+pzUrZsWX748IGCIDBPnjzs3LlzZpyaxly7do3GxsZs2rRpsgZPb968YcmSJWlsbMydO3eqPWZMTAxr165NIyMjnj59WtdLzjaGDRtGDw8PNmvWjFWrVs3u5WiMXgzo+a2IVSg4JTSUlv9kGaRmKRD98544OJhNbt/my6goPnnyhNbW1qxatWqKT2WpcfnyZTZt2pQikYg5cuTg5MmT1RIUISEhBJCiiT48PJx//fUXAwMDWbVqVZqYmBAA5XI5y5Urx2HDhnHfvn2pRqVrw/Pnz1U3yzFjxmiViqYUMr9bP/aAgACamZnxxYsX7NKlC21sbDJsBUmJGzdu0NramiVKlOCXL1944cIFAuCtW7c0Hqd169aUSCS0trbmmDFjkkTfK90CFhYWrF+/Pg0NDWlhYcFevXoRAA8cOKDrU9OYly9f0tHRkT4+PqnGB/z8+VOVfTJ58mS1LWFRUVGsUqUKTU1NefHiRV0uO9uYOXMmzczMGBAQQF9f3+xejsboxYCe35JohYIbwsLY7M4dul24kEQImJ05w8o3bnDC8+d89cuT/IkTJyiRSNivXz+N53z06BG7detGAwMDmpiYcMCAAXyZQvxBYmrWrMkiRYqkexGMi4vj9evXOW/ePDZr1oxOTk4q10KBAgXYpUsXrl27lk+ePMmQayEuLo4TJ06kRCKhr68vnzx5otHxlpaWtLe313r+zODQoUMEwBUrVpAkX79+TUNDQ52ndyqFQMmSJVVi8PXr1xm6OYeGhrJfv340NjamoaEhu3XrxhEjRiRrOfz2QSfF+gAARVxJREFU7Vv279+fUqmUADh69Gh+/fpVV6emMeHh4SxatChz5szJd+/epbmvIAgcN26cylWlrnUtIiKC5cuXp4WFBa9fv66LZWcra9euJQD26tWLhQoVyu7laIxeDOj5VxAVH89PsbH8HheX7s1y4cKFqmAnbXj37h1HjRpFS0tLSqVStmvXjrdv305x39OnTxOAxgFRgiDw+fPn3LBhA7t3787ChQurxIG9vT2bNGnCOXPm8MqVK1o94V+6dIm5cuWiqakp165dq5bAiImJIQBWqFBB4/kyi69fv9LZ2Zk1atRIcg7Dhg2jsbFxujcqdQkJCUkmBMiEoDepVMrFixdnaPzPnz9z5MiRlMvlBMC8efPywoULyfYrWrQo8+TJo7IUBAYGZrkoiIuLY61atWhubp7q5z4ltmzZQkNDQ5YuXVrtv8v3799ZqlQp2tjYaDTX78jBgwcJgH369KGbm1t2L0dj9GJAz38OZRqUTCbLkP88PDycs2fPpouLCwGwTp06PH36dJKbkiAILFu2LMuUKZPhYMEvX77w4MGDHDFiBP39/VXVEo2NjVmpUiWOGTOGR44cUfv7FR4ezg4dOhAAmzVrlq7rQ2kSHz58eIbOQ5d07NiR5ubmySw0X758oaWlJXv16pXhOUJCQmhlZcWSJUumeOPNmTMnR4wYkaE5EmcL9OzZk56engTAihUr8uDBgxQEgS9fvlS5ncLCwjhgwACVKBg3blyWiYLevXtTIpHw6NGjGh975coVOjo60tXVlX///bdax3z+/JleXl60t7fnw4cPNZ7zd+Hy5csEwL59+9La2jq7l6MxejGg5z9JTEwM/f39aWdnl+HCLbGxsVy/fr3q6d3X15c7d+5URXsrMwtOnTqli6WrUFZLnDFjBhs0aEBbW1sCoFgsppeXF3v16sXNmzen68rYunUrLS0t6eLiwuDg4FT3GzVqFAHwzJkzOj0PbVE+aaVm4QkKCqJUKtXYFZKY69ev08rKiqVKlUr1Zuvn58fWrVtrNb6yiNCvboH4+Hju3LmTPj4+BMDChQuzbdu2lMlkSWIhsloUzJs3jwC4dOlSrcd49eoVvb29aWJiwj179qh1zIcPH1igQAG6uLjw2bNnWs+dnTx9+pQA2Lt3b8pksuxejsboxYCe/ywfP36ku7s7vby8Uozo1hRBEHjw4EFWqFBBZepdvnw5IyMjWaRIEdaoUUMHq057/gcPHnDVqlXs2LEj8+bNq3ItuLm5sWXLlly0aFGSaolKXr58yQoVKlAkEnH48OGMiYlJNn7FihUJINMyHjTh69evdHJyYs2aNVO1uERGRtLJyYktW7bUag6lEPDx8UnzBtu6dWv6+flpPH7iIkKp9RYQBIGnT59mnTp1VNX9Zs6cmewamhWiYP/+/RSLxRw0aFCGx4qIiGCTJk0oEok4bdo0taxmb9++paenJ93d3fnq1asMryGrCQ8PJwB2796dAFL8jv3O6MWAnv80t27doomJCZs0aaLTCPlLly6xcePGFIlEdHBwUJVqzepAqPfv33P37t0cNGhQitUSJ06cyODgYP78+ZPx8fGcNm0apVIpS5QowQcPHiQZy9HRkRYWFlm6/tTo0KEDzc3N070pLF++nAA0ynUnE1LmLC0t6ePjk25WwogRI5gzZ06Nxk/sFlCnt8CXL18okUhUf0MLCwsOHz48WVGfsLAwDhw4kEZGRjQ3N+fYsWPVynxJj5CQEJqYmLBhw4Y6q2+gUCg4evRoAmC7du3UEpkvXrxgzpw5mTdv3iwv4pVRBEGgXC5np06dCECnmUJZgV4M6PnPs3v3bgJgYGCgzsd++PAhu3TpQplMRpFIxLx582brU83Pnz956tQpTp48mbVq1aKFhQUBUCqV0sfHhwMGDOD06dOZK1cuGhsbc/ny5RQEgYIgUCKR0NvbO9vWruTAgQMEwFWrVqW7b1xcHPPly8eaNWuqPf7Vq1dpaWlJX19ftdITlyxZQolEotZNMjW3QHps2LCBAPjmzRu+evWKgwcPppmZGeVyOTt37pxMuOlSFLx+/ZpOTk4sUaKETixov/Lnn3/SwMCA5cqVU6u50ZMnT+jk5MRChQol6w75u+Ps7KwqAva79JVQF70Y0PM/waRJkwiAO3bsyJTxw8LCWLNmTdWNt0OHDrxz506mzKUJCoWCt27d4pIlS9i6desk1RLNzc0JgN7e3ty6dSsBsEuXLtm63i9fvtDJyYm1atVSOyBzx44dBJBmPIQSpRAoXbq02nUKlOIkPZH3+fNn1v+n9bamLYcbN26cLDf969evnDZtGh0dHSkSidigQQOeP38+yT4ZFQU/fvygt7c3XV1dM7VL5aVLl2hvb8+cOXOqVbPh/v37zJEjB729vXVi+cgqvLy82KhRIwL412VH6MWAnv8JBEFg8+bNaWxszBs3bmTKHFFRUbS3t6ePjw+dnZ0JgHXr1uWZM2eypKmOurx69Ypbtmxhnz596OHhoRIHAFiyZEkGBQXx/Pnz2RI70L59e1pYWGhkXREEgT4+PvTx8Unz93zlyhVaWFiwdOnSGl2jbt26RQAppgIq0dQtkJjIyEgaGxtz6tSpKb4fHR3NVatWMX/+/ATAcuXKce/evUncXu/eveOgQYM0EgXx8fGsV68ezczM0m3epQtevHhBLy8vmpqaqvU7unXrFq2trenr68vw8PBMX58uqFq1qqoC5b+tmJJeDOj5n+Hnz58sUaIEXV1ddZaf/ivTp0+nTCbj06dPuXbtWhYsWJAAWKZMGe7evfu3q+xHJrg6lFYCFxcXVbVEAwMDli9fnsOGDeP+/ftTbNajS5RP4KtXr9b42JMnTxJAqmVxL1++TAsLC5YpU0bj69O3b98IgFu2bEn2nrZugcTs27ePAHj//v0091MoFNy7dy/LlStHAMyfPz9XrlyZRLT9KgrGjBmTqijo168fxWIxDx06pPGateXHjx9s2LAhRSIRZ8yYka5IvnbtGs3Nzenn58efP39m0Sq1p0WLFixdujQB8K+//sru5WiEXgzo+Z/i1atXtLe3Z7ly5TLlyTc8PJyWlpaq9rMKhYIHDhygn58fATBfvnxcsWLFbxGxn5hcuXJRJpNRLpezaNGi3LZtG+fNm8c//viDjo6OKstBwYIF2aVLF65bt45Pnz7VmcXjy5cvdHR0ZO3atbUes0aNGsyXL1+yUtSXL1+mubk5y5Ytq/W1ydzcnNOnT0+yLSNugcQEBAQwf/78Gh1z/vx51U3V0dGR06ZNS5JdkJIoSCzmlIW5Fi5cqNWaM4JCoeCIESMIgB07dkz3u3D+/HmamJiwatWqmd6gKqP06dOHBQoUIADu2rUru5ejEXoxoOd/josXL1IulzMgICBTzPejR4+msbFxsuCnCxcusFGjRqoMhGnTpmVKfX1tMDAwYN68eXnjxg0WKFCAhoaGXLRokSq48NmzZ1y/fj27devGQoUKqcSBg4MDmzZtyjlz5vDq1asa9YRITLt27WhhYcHXr19rfQ7KXhHKssVkgq9aKQQyYmouXLgwe/furfo5I26BxMTFxdHW1lbrQk/3799n586dKZfLaWZmxkGDBiVxsaQkCrZu3UqxWKxVyW5dsn79esrlcvr5+fHDhw9p7hscHExDQ0PWqVPnt07ZGz9+PO3t7QmA69evz+7laIReDOj5n0RZR3zu3Lk6H/vjx480Njbm2LFjU3z/wYMHSS7gQ4YMydBNMKN8+vSJANi0aVOSCe4UZcOcOnXqpBgB/vnzZx44cIAjRoygn58fDQwMVNUSK1euzDFjxvDo0aNqXQuUZvI1a9Zk+FxatGhBZ2dnRkZGqoRAuXLlMuxzrlWrFuvXr5/MLZDRiHFlOetLly5laJy3b99yxIgRtLCwoFQqZfv27ZMEsL17946DBw9WVbXMkydPujfgrOD8+fPMkSMH3d3d0w24O3LkCOVyOZs0aaK16MxsFi9eTIlEQqlUykWLFmX3cjRCLwb0/M8yaNAgisVircqupke/fv1oZWWV5k3o7du3HDZsGM3NzSmTydixY8dsaR28adMmAkhWf3///v20s7Njjhw50vUrR0dH88KFC5w+fTobNGhAGxsbVbXEYsWKsXfv3ty8eXOywECle6BOnTo6sdI8fvyYUqmUvXr10pkQIBNaOxcpUkQnboHEDBgwgE5OTjqLJQkPD+esWbNUJbRr167NU6dOURAEvn37lk5OTsyRIweNjIxoZmbG0aNHZ3osSHqEhoaySJEiNDMz48GDB9Pcd+/evZRKpWzdurXO6iHokm3bthEALSwsGBQUlN3L0Qi9GNDzP0t8fDxr1qxJS0tLnddEf/nyJWUyGWfOnJnuvt+/f+eMGTNUnQzr16/Pc+fO6XQ9adGxY8dU86LfvXvHWrVqqRqwqOuzVVZLXLlyJTt27Mg8efIkqZbYqlUrLlq0iHXr1qW5ublOLSONGzcmAJYuXVpnUejdunWjWCzOsFsgMYIg0N3dnT169NDJeImJiYlJUkK7RIkSzJUrF52dnfn69Wu+f/+egwcP/m1EQXh4OOvXr0+xWMzZs2enKQyVbo7OnTv/dgG5ykBWR0dHnXfVzGz0YkDP/zRfv35lvnz5mC9fPp2Xd+3YsSMdHR3VDhaMiYnh6tWrVQFIZcuWTZZClhkULVqUUqk01QuwIAicP38+DQwMWLhwYbXyxFPi3bt33LVrFwcOHEhfX19KJBICoJGREWvWrMlJkyapqiVqy4ULF2hqakqxWMwBAwZoPY4SpVtAuVZdWm7+/vtvAsgUy5QSQRC4f/9+VV8LV1dXLlmyhJGRkSQTKlgOGTKExsbG2S4K4uPjOXToUAJg586d04wNWLdunUqg/k5pu7dv3yYAuru7q4KI/y3oxYCe/3kePXpES0tL1qxZU6emxwcPHlAkEnHZsmUaHadQKLhv374kKWSrVq3KtAwEc3NzOjs7p7vf7du3WaRIERoYGHDu3LkZEimfP3+mvb09S5cuzYkTJ6ZYLXHgwIHcuXOn2mmg58+fp5mZGf38/Dh06FAaGRnxzZs3GVqj0i3QokULtdL/NCEwMJAWFhaZHhCndIfNmjWLf/zxB8ViMe3s7Dhx4kTVjf9XUTBq1KhsEwVr1qyhTCZjhQoV0qxAuHTpUgLg0KFDfxtBEBYWporJ6NSpU3YvRyP0YkCPHpLHjh3TWZOWxDRp0oS5c+fWOuDp3LlzbNCgAQHQycmJ06dP12kGQnR0NAGwatWqau0fFRXF/v37EwBr1KihddW6Nm3a0NLSMsnNOj4+njdv3uTixYvZqlUr5syZU+Va8PT0ZIcOHbhy5Urev38/2cX//PnzNDU1pb+/P3/8+MFv377RxsaGXbt21Wp9v2YLPH/+XOdP8V5eXmzVqpXOxksJ5Q1z3rx5qm2PHz9mjx49aGhoSBMTE/bt25fPnz8nmbIoyI4a+2fPnqWtrS1z5crFu3fvprrfnDlzMq3UuDbExsYSAAsUKMDmzZtn93I0Qi8G9Oj5h7lz5xIA165dq7Mxr127RgDcvHlzhsa5d+8eAwICKJPJaG5uzqFDh+qkfKzSx6npxfTIkSN0cHCgra0t9+7dq9Gxe/fuJQCuW7cu3X2V1RJ79+5Nb29visViAqCtrS3r16/P6dOnc8mSJTQxMVEJASVK874m8SCpZQvExsZSJBIlSVvMCM+ePSMAbtu2TSfjpcSRI0cokUiSpEQm5v379xw7diytra0pkUjYqlUrVXXO30EUPHv2jIULF6a5uTkPHz6c6n5TpkwhgN8mYM/S0pIFCxZk7dq1s3spGqEXA3r0/IMgCOzUqRPlcnmapWc1pXr16vTy8tKJKfPNmzccOnQozc3NVR3SMmK6Hjx4MAHw6tWrGh/74cMHlRm9e/fuavn6P3/+TAcHB9atW1er38f379957Ngxjh07lpUrV1alyolEIpYpU4bDhw/ngQMH+OXLF0ZFRdHV1ZV//PGHWmOnV0TIyckp1XRRTZkzZw4NDAwyrczu7du3aWZmxlq1aqVrlYqIiOD8+fNVlpjq1avz+PHjFASB79+/59ChQ2lsbExTU1OOHDkyS0XB9+/fWadOHYrFYs6bNy/Vz8yYMWMIgPPnz8+ytaVGnjx5WKBAAfr7+2f3UjRCLwb06ElEdHQ0y5UrR3t7e511HwwODiaAdNOmNOHbt28MCgpSNbFp2LChVgKmfPnyFIlEWsdKCILApUuX0sjIiPnz50+3lXDr1q2TuQe05ezZszQ2Nmbx4sUZFBTEpk2b0sHBQeVaKFSoECtUqEAA3L17d5riQ50iQqVLl2aHDh0yvG6S9Pf3Z506dXQy1q+EhYXRzc2NRYsW1UhsxMXFcdOmTfT29lY1sNq8eTPj4uL44cOHbBMF8fHxHDRoEAGwa9euKaZ0CoKg2mf58uVZsq7UKFOmDPPmzftbdADVBL0Y0KPnF96/f09XV1cWL15cJ/XQBUFg6dKlWb58eR2sLinR0dFcuXIl8+XLRwAsX7489+/fr3ZwX44cOWhtbZ3hddy7d4/FihWjTCbjjBkzUpx/z549OqvMdubMGZqYmLBSpUpJ2u4KgsCnT59y/fr17Nq1a5JqiY6Ojvzjjz84d+5cXrt2jXFxcRoVEWrWrBkrV66c4bV/+PCBYrFYZy6HxPz8+ZM+Pj50dHTky5cvtRpDEAT+9ddfrFatmioyfsGCBYyIiMhWUbBq1SrKZDJWqlQpxeBGQRDYs2dPikQibtiwIUvWlBL169dnrly5mCdPnmxbgzboxYAePSlw48YNGhsbs3nz5jox7yv95GfOnNHB6pKjUCi4Z88elilTRtVDYM2aNWlGqguCQLFYTB8fH52sITo6mkOGDCEAVqlSJUntgE+fPtHe3p716tXL8O/z9OnTKiGgjljbsGEDAbB58+YsX768qlqiiYmJKuWuadOm6UbPDx48mJ6enhlaO0muXr2aIpFI582yFAoFmzRpQmNjY167dk0nY4aEhLBly5aUSCS0sbHh2LFj+eHDB3748IHDhg2jiYlJloqC06dP08bGhp6enim6xxQKBQMCAigWi7l9+/ZMX09KBAQE0NnZmQ4ODtkyv7boxYAePamwY8cOAuCkSZMyPJZCoWChQoVYq1YtHawsbc6ePct69eoRAJ2dnTlz5swUv5P37t1T5WrrkuPHj9PJyYnW1taqLoKtWrWilZVVhoMelUKgcuXKalttBEFg2bJlWaJECSoUCkZHR3PZsmW0tLSkTCajmZmZqlqit7c3e/fuzS1btiRzEylrLWS07kO9evUyxUo0bNgwikQi7tmzR+djP3/+nH379qWxsTENDQ3Zs2dPPnnyJJkoGDFiRJrpgLrg6dOnLFiwIC0sLHjs2LFk78fHx7Nly5aUSqXcv39/pq4lJYYOHUobGxuamppm+dwZQS8G9OhJg8DAQJXPOaMon1CVEduZzd27d9mhQwfKZDJaWFhw+PDhDAsLU70fFBSk81gGJZ8+fVJVAqxSpQoBZNh0e/r0aRobG7NKlSoau2/OnDmjakOsdAv4+voyNDSUgiDw/v37XLFiBTt06EBPT0+VayFnzpxs3bo1Fy9erMo2ycgT/Y8fP2hgYKBWZUpNWLFiBQFw1qxZOh33Vz59+sQJEybQ1taWYrGYf/zxB69evZrlouDbt2+sVasWJRJJip0XY2Nj2ahRI8rl8hQFQ2YyY8YMVWDr71YhMS30YkCPnjRQml5NTEy0rrynJC4uju7u7lmef/zq1SsOHjyYZmZmlMvl7NKlCx8+fMg6deoQgKoana4RBIHz5s2jSCSiiYkJL1++rPVYp06d0loIKKlWrRpNTEwIgIMGDUrThfLu3Tvu3LmTAwcOpI+PD6VSqUoglC1blpMmTeKpU6c0XsvOnTsJgE+ePNHqHFLi+PHjlEql7N69e5YV34mMjOSSJUuYO3duAmClSpV4+PBhvn//PstEQXx8vKrmRc+ePZMFFsbExLB27do0MjLi6dOnM2UNKbFmzRrVZyVxquvvjl4M6NGTDhEREfTy8qK7u3uGO70tXryYYrGYjx8/1tHq1Ofr16+cOnUq7e3tKRKJaGRkRCMjo0yds2XLlrSwsKCXlxelUimnTJmiceZCcHAwjY2NWbVqVa2FwMWLF+no6EgAWvUC+PnzpyoA0tvbm+bm5qpqib6+vhw0aBB37dqVYofHxLRt25ZFihTR6hxS4u7du7SwsGCNGjWypZNffHw8t2/fzlKlShEAixQpwvXr1/Pt27ccPnw4TUxMaGJiwuHDh2eaKFi+fDmlUimrVKnCL1++JHkvMjKSlStXpqmpKS9evJgp8//KgQMHVGJAF7VAsgq9GNCjRw1CQ0NpZ2dHf3//DJWPjYqKor29Pbt06aLD1Wm+BqVZGQD9/f154MABnT9V7tq1iwC4ceNGxsbGcuTIkRSJRPT39+eLFy/UGiOxENDGgpE4W8DX15eNGjWig4NDkgwETcYyMjLinDlzVNUSFy1axFatWtHNzU31+8yTJw87duzIlStX8sGDB6rfa2xsLC0tLTlmzBiN506J9+/f093dnYULF872a64gCAwODmbt2rVVPRBmz57N58+fZ4koCA4OprW1NfPmzZusyFRERATLly9PCwsLXr9+Xedz/8qlS5dUn4VHjx5l+ny6Qi8G9OhRk7Nnz1Imk7Fbt24ZunFOmzaNcrlcp536NOX9+/cqIeDr60sALFy4MNetW6eTWvkfP35kjhw52KBBgyS/q9OnT9PV1ZUWFhbcsmVLmmOcPHmSRkZGrFatmlZCIHERIaVb4NmzZ5TJZJw8ebLG45Fkvnz5Um2A9PLlS27evJm9evVisWLFklRLbNCgAbt27UoAvHTpklZzJyYyMpKlS5emvb19mumQ2cGtW7fYrl07SqVSWlpacuTIkbxz506mi4LHjx8zf/78tLS05PHjx5O89/37d5YqVYo2Nja8ffu2Tuf9ladPn6rEQFaID12hFwN69GjAypUrCYCLFi3Seozv37/TwsKCAwcO1OHKNEPp11y9ejUFQeDp06dVMQQuLi6cPXt2hqrjtWjRgtb/1959h0dZbW8Dft6pmWSSmEpJlN4CggRQyidNCNKEECAgBATxoNJUmgo/DiAqiopGPIgVpRelg6GjHAFFBekoCIpACpEEAiHJzPP9Mc4ckkxNJgWz7uuaS5i3Tgyz17v32msHB+dLWLRKT09nfHw8AXDIkCF2vy927NhBg8HAmJiYIgUCzooIjR07lgEBAUWaCte5c2fGxcW5tW9GRgaTkpL4f//3f+zYsaMt78DHx4cPPvggX3jhBVu1RE+YTCb279+fBoOhWHkYJe3333/n+PHjaTQabbkq+/bt4wsvvECj0VgiQcFff/3FmJgYqtVqzp8/P9+2K1eusEmTJqxUqZLXlyy/nbUdBFCquQrFJcGAEB4aN24c1Wo1d+zYUeRzvPjii/Tz8yuTRWBISyVAAIXGuI8cOcKhQ4fme6rzNHvemiS3ZMkSh/uYzWZ+/vnn9Pf3Z82aNfNVT9y+fTsNBgO7dOnicSBQcFjA3lNzcnIyjUYjJ0yY4NG5Scsc8qLUZTCbzYyIiGB8fDznzp3LuLi4QtUSR44cyUWLFvHs2bNOe56mTJlCAFy9erXH91EWCuaqxMbGcsuWLfmCgsmTJxc7H8cqNzeXY8aMIQCOHj06Xy5FSkoKGzRowMjISJ49e9Yr1yvIbDZTp9OV2EydkiLBgBAeys3NZefOnRkcHFzkrPDk5GT6+PiU2WprUVFR1Ol0Drf//vvvfO6552g0GqnX6zly5Ei3xj+twwO9e/d2ayjlzJkzbNWqFdVqNWfMmMGkpCT6+PiwS5cuvHnzpkefyd6wgCPTp0+nXq/3uErf9OnTi1RM5vvvvycA7ty50/ae2Wzmr7/+ys8++4xPPPEEo6KibMFB1apV2a9fP77zzju2aonk/3p0ysuiPJ6w5qrUrVvXVi1z8eLFfP7550skKJg/fz7VajVjYmL4119/2d6/ePEia9euzerVq3ut5HhB1mRVV0Nh5YkEA0IUQXp6OuvUqcOoqKgi/76PGTOGwcHBZTL9yGg0slq1ai73S09P58svv8zw8HAqisK4uDh+9913DvePj493ODzgSG5uLv/9739TURSqVCq2a9fO40DAnbUFbpeZmcmwsDAOHz7co+t88sknBMDs7GyPjpsyZQqDg4NdZvynpaVxw4YNnDx5Mtu0aWN7wvTz82N0dDRVKhW7du16R3/HFqyW2aBBAyYmJnLSpEleDwq2b9/OoKAg1qtXL98MnvPnz7NatWqsW7euR7+r7mrSpAkB8KOPPvL6uUuKBANCFNGJEycYEBDAHj16FGmhn/Pnz1Oj0fCtt94qgbtz7MaNGwTg0RKrN2/e5IIFC2wFedq3b8/Nmzfne/q3VmxcunSpx/e0detW6nQ6GgwGGo1GLlq0yK2eBXeGBRxJTEykSqXisWPH3D5m+/btRaoTEBUVxaFDh3p0DGn5ue/du5cTJkygVqulVqu1VUuMjo7mmDFjuGLFijJNRi2OvXv32npzqlSpwmnTptnyDPz8/Dhp0qRiBwWnTp1i3bp1GRQUlK9n5tdff2XVqlXZsGFDryczPvTQQ1Sr1Zw7d65Xz1uSJBgQohg2b95MlUrF559/vkjHDx06lBERER4/aRbHli1bCICzZ8/2+Ni8vDyuXr0637zyRYsW8c8//2RYWBhjY2M9nmlhHRro1q0bk5OTmZCQQAAcOHBgvu7dgjwZFrAnOzub1atXZ+/evd0+5vTp04W6+105depUsapYpqamslatWoyKiuKVK1d4/Phxfvjhhxw6dGi+aonVq1fnoEGDOH/+fB45cuSOqn53/Phx2/Lh/v7+HD16NMeMGUOj0UhfX99iBwXp6ens1KkTNRoNFyxYYHv/xIkTDA8PZ9OmTT1O5HQmPj6eWq2WL730ktfOWdIkGBCimN544w3bfHpPHT9+nIqilMgKdo6MHTuWAHj8+PEin8NsNnP37t3s2rUrAdBgMNDPz49nzpzx6DxJSUnU6/Xs1q1bvoBo6dKlDAwM5D333GN3cSdPhwUcsZaIdrcgjbVXZeHChW5f4/XXX6fBYChSwaSbN2+yTZs2DAsLc5jwdunSJa5evZrPPvssW7RoYZu1cNddd7Fbt258+eWXuWfPnhKrNOlNf/75JydPnsyAgABqtVoOHDiQ//rXv7wSFOTk5PDpp58mAI4bN842ZHP48GEGBwfzgQceKNYMmtuNHj2aOp2OkyZN8sr5SoMEA0IUk9ls5pAhQ6jX652OpzsSGxvLOnXqFGmooSgeeOABqlQqrxUZsgZDKpWKQUFBnDp1qstKfOT/AoHu3bvb7Rk5d+4cH3zwQapUKk6dOpU5OTnFGhawx2QysXHjxmzXrp3bP4+wsDCPnvhatWrlUe+Dldls5qOPPkq9Xu9R9bzr169z586dfOmll9ilSxdbtUStVsuWLVty/PjxXLNmjdcS9UpCRkYG33jjDUZERBAAY2JimJCQYAsKJk6c6NbvmD3z5s2jWq3mww8/zKtXr5IkDx48yICAALZt29Yry5ZPnz6dGo2GTz/9dLHPVVokGBDCC27evMmWLVuySpUq/PPPPz069rvvviMArlixooTuLr+QkBCGh4d75VwpKSkMCwtjnz59eO7cOT7zzDP08/Ojj48Pn3rqKYdj61999RX1ej179OjhdIgkLy+Ps2bNolqtZnR0tG3Ro6IMCziyadMmAuDmzZvd2r9Zs2ZuV5C8ePEiFUXxqCfBatq0aV75vcjLy+OhQ4c4b948Dhw4kHfffbdtaKFu3bocPnw4P/74Y546darU1jZw161bt7hw4UI2bNiQANisWTPGxcUVOyjYunUrAwMD2aBBA9vv6H//+1/6+fmxc+fOHiewFvTee+9RURQOHjy4WOcpTRIMCOElly5dYmRkJFu0aOFxl+xDDz3E++67r8S/jE0mExVFYZs2bbxyvn79+jEkJCRfLYIrV65w1qxZDAsLy7eyndWWLVvcCgRu99FHH9m6v8eOHevVn5PZbGbbtm3ZpEkTt8bZY2Nj2aVLF7fOvWDBAqrVao/rSXz++ecEUORKia6cP3+eS5cu5ahRo9ikSRMqikIADAsLY+/evTlnzhzu27fPawFXcZlMJm7cuJHt2rUjANasWZNdu3alv79/kYOCEydOsHbt2gwJCeHu3btJWsoa+/j4sEePHsX67CtWrCAAdu/evcjnKG0SDAjhRQcPHqTBYOCgQYM8arB27NhBANyyZUsJ3h35008/EUCRCu4UtHLlSqdzqQuubNexY0fOmjWLer2ePXv2dCsQuH1YoHnz5uzfvz8BsG/fvrxy5UqxP4PVt99+63bex7hx49igQQO3zvvwww+zQ4cOHt3Lnj17qNVq+dhjj5Xak/rVq1f51VdfcerUqezQoQMNBoOtWmLbtm35wgsvcNOmTV5Nsiuq/fv3My4ujoqiMDQ0lO3bty9yT8GVK1fYoUMHarVa2zTAr776ijqdjn379i3y4k87d+60rXB5p5BgQAgvW758ucfZ+mazmffffz/btm1bgndGzpgxgwC4a9euYp0nOTmZoaGhjIuLc9lg5eXlceXKlbbM94CAAC5cuNDlF62j2QKrVq1iUFAQIyIiPMrqd6VXr16sUaOGyyfCN998k35+fi4/d0ZGBrVaLd955x237+H06dMMDg5mhw4dyvSpPCcnh9999x3feustxsXFsVKlSgRARVHYqFEjPvnkk1y0aBF/++23MhtaOH36NEeOHEm9Xk9fX1/ef//9tqBgwoQJbgcFOTk5HDlyJAHwueeeY15eHteuXUuNRsPBgwcXKZfn559/tlWWvFNIMCBECZgyZQoVReGGDRvcPmbNmjUEwL1795bYfXXu3JkACq397qm+ffsWGh5wZtOmTdTpdGzdurXtHqpVq8Z33nnH7gqC+/fvZ7Vq1RgUFMR169YV2v7HH3+wQ4cOVBSFkyZN8krDeezYMapUKr777rtO97P2iLjqmbAGhe4mOaalpbFOnTqsV69euXgCv521WuLChQv5xBNPsEGDBvmqJfbv35+JiYn84YcfSn0p5cuXL3Pq1KkMCgqiSqVio0aN6Ofn51FQYDabbXUnunXrxoyMDC5fvpwqlYojRozwOOC5dOkSAfCee+4p6scqdRIMCFECTCYTe/XqRX9/fx49etTtY6Kiokp0nDEyMpIBAQHFOod1PNTdUqsbN26kTqdjr169bI32oUOHOGjQIKrVagYHB3PatGlMSUnxaLZAXl4eX3vtNWq1WkZHR/PEiRPF+lwkOWzYMIaHhzutCmldovbQoUNOzzVgwABGR0e7dd3s7Gy2bduWoaGhRS5xXdrS0tK4fv16Tpo0KV+1RKPRyE6dOnH69Onctm1bqVXYvHbtGt9++23bctI1a9akr6+vR0HBli1bGBAQwIYNG/Ls2bNcuHAhAXDMmDEeBQQ5OTkEwJCQkOJ8pFIlwYAQJSQzM5ONGjVizZo13U4g++yzzwiAhw8fLpF70mq1bNKkSZGP92R4gCQ3bNhAnU7H3r172316P3fuHMeOHUtfX1/q9XpWr17d49kCBw8eZL169WgwGLhgwYJidVv//vvv1Ov1nDFjhsN9Ll68SABO6xtkZ2fT39+fM2fOdHlNs9nMhIQE6nS6Eu0VKmnWaomzZ89mz549GRwcTAC2mSBjx47lypUrPZ5t46mcnBwuWbLEVhK4SpUqNBgMNBgMHD9+vMverOPHj7NmzZoMDQ3lN998w/fff58AOGnSJI9+t3x8fGgwGIr7cUqNBANClKCzZ88yNDSUHTt2dKtrPicnh9WqVePAgQO9fi8XLlwgAI/r8VuZzWbGxcUxNDTUraesDRs2UKvVMjY21mXDnpSUxLvuuouKolBRFMbHx3u0Fvz169dt4769evUqVnlZazlcR/PwTSYTtVot582b5/Ac1iqPP//8s8vrzZw5s8hlnMszk8nEY8eO8YMPPuCQIUNsiaQAWKNGDQ4ePJjvv/9+iVVLNJvNTEpKsk1Hveuuu2wNtKugIC0tje3ataNWq+Wnn37KuXPnEoBHC4tZZ9PcKSQYEKKE7d69mxqNhqNHj3Zr/3nz5lGlUnm9u3j+/PkEwGXLlhXpeOsYuDvz3tevX28LBJwFQQWHBU6cOMH33nuPNWrUIAB26tSJW7dudfuJbO3atQwJCWHlypWZlJTk9me7XVpaGgMCAjhu3DiH+9SsWdNpdbmRI0eyVq1aLu976dKlBOBWD8I/gbVa4jPPPMMWLVpQrVbnq5b4yiuv8Ouvv/Z6tcQffviBAwYMoKIoNBgM1Ov1LoOCW7duccSIEQTAiRMnctasWe6vGJmdzUciI/kQwJwtW8jDh8li5umUNAkGhCgF1q7G2+uiO3Ljxg2Gh4dz5MiRXr0H67Q8a9U1T1y+fJkhISHs27evy33XrVtHrVbLPn36OA0EnK0tkJuby+XLlzM6OpoA2LRpUy5btsyt5LSLFy8yJiaGAPjss88WqYDMrFmzqNPp+Ntvv9nd3r59ew4YMMDuNpPJxMqVK3P8+PFOr7F3717qdDomJCSUu2I/peX69evcsWMHZ86cyZiYGPr7+9uqJbZq1YoTJkzg2rVrvVYt8ezZsxw9ejR9fHyo0Wio0+no4+PjMCgwm82cO3cuVSoVe/bsyYkTJxIAExMTC588PZ186y3yvvtIjYYE8r+0WrJFC3L+fNJLZY+9SYIBIUrJqFGjqNFobAVOnHnllVeo0+l48eJFr12/Xr169PHx8fg4s9nMPn36uDU8sHbtWmq1WsbFxTkNBFzNFrj92tu3b7c17tWrV+e7775rdwbC7UwmE+fOnUudTsfGjRu7ncRpdf36dVauXJlDhgyxuz0hIcFh4SZrzYJvvvnG4fl//fVXhoaGsm3btqW6SFV5l5eXx59++onz5s3jgAEDGBkZaRtaqFevHocPH85PPvmEp0+fLlYAlZqayhkzZtjyGrRaLfV6PZ977jm7Sxpv2rSJ/v7+bNSoEZ944gkC+N96IrdukdOnk3o9qSiWV8FAwPqybvf1tQQOpVSC3B0SDAhRSnJyctihQweGhIQ4XHTG6urVqwwICPBKcSArX19f1qpVy+Pjli1bRgBcuXKl0/2sgUDfvn0dBgLFWVvgp59+4sCBA6lWqxkSEsJ///vfLnMDDh8+zKioKPr4+PDdd9/1qAH5z3/+Q0VR7I77T5kyhXfffbfd4yZNmsTw8HCH89PT09NZr1491qlTx+PKhBXR+fPnuWTJEj799NNs3LhxvmqJsbGxfOONN7h///4iTS/Nysrie++9x2rVqtmSHfV6PZ999tlCQcHRo0dZo0YNW/ltRVG4ds4csmFD5wGAs1fLlmQ5WX5aggEhSlFaWhpr1arFe++91+UKac8//zyNRqNX5pxnZWURAGNjYz06zjo80K9fP6f7WQOBfv36OQwEirvksNXZs2c5ZswYW4b46NGjnQZXN27c4OjRowmA3bp1c7s2Qk5ODmvXrs0ePXoU2rZgwQKqVKpCwxZms5l16tThiBEj7J7z1q1b7NChA4ODg3n69Gm37kPkd/XqVW7ZsoVTp05l+/bt81VLbNeuHV988UVu3rzZ6fLXBeXm5nLFihW2GQgqlYo6nY7PPPNMvqAgNTWVDz74ILVaLROio5kG0KRSFS0QACzDCZGRZDEX3PIGCQaEKGVHjx6lv78/e/fu7TSL+vLly/Tx8fFKctmXX35JAB5VwzObzYyNjWVYWJjTMds1a9ZQo9E4DQTcHRbwRGpqKqdPn86QkBCqVCoOGDCAP/74o8P9N23axPDwcIaHh3PTpk1uXcOaNFmwy986W+D8+fP53j927BgBcOPGjYXOZTabOWzYMGq1Wu7Zs8et6wvXcnJyeODAAb755pvs06cPw8PDbdUS7733Xj711FNcvHgxz50757JnyGw2c+fOnbYZCIqiUKvVctSoUbag4NatWxw7cCAvA8wtahBQMCCoVYt0MfRV0iQYEKIMbNiwgYqicOrUqU73e/rppxkSEuJyjNyVJ598kgAcJsTZY810X7VqlcN9vvzyS6eBgLeXHLYnKyuL8+bNs9Uo6Ny5M7dt22b3i//y5cvs1q0bAXD06NEus9ZNJhObNm3K1q1b5zuftdEvGCS8/PLLNBqNdpMWX3nlFQLgokWLivhJhTvMZjN/+eUXfvrppxwxYgTr169vyzuIiIhgfHw8ExMT+eOPPzotNXz48GH279/fNiyh0Wg4cuRIXrp0ieZ+/Rz2CBwF2BdgDYAGgCEAHwS43llAoFKRY8aU4k+pMAkGhCgjs2fPpqtKfr/99hvVajXffvvtYl2rWbNm1Gg0bu9/6dIlBgcHs3///g73+eKLL6jRaNi/f3+7Wf7eGhZwV25uLpctW8amTZsSAKOjo7l8+XK7Xfnz5s2jj48Po6KiXFYSTEpKorXIUOqtW5x34QIHHD5MfP45fXfsYODXX7Pat9+y75EjjJgwgd3s1HGwVm2cNm2aVz+zcE9qairXrVvHSZMmsXXr1vmqJXbu3JnTp0/n9u3b7VZLPH/+PJ966ilqtVoCYHcXwwKbAHYBOB3gBwDf/jsYAMAFrnoJvvuuDH46FhIMCFFGzGYzBw0aRIPB4LTATkJCAiMjI4vVmAYFBbFKlSpu31fv3r2dDg+sXr2aGo2G8fHxdgOBkhgWcJfZbObWrVvZqVMnWsvSvvfee8zKysq339GjR9m4cWPqdDq+9dZbDodszGYzW8XGMnD2bGp376ayaxc1u3cTu3ble6l27SK2byd27mS3w4f5w985Ifv27aNer+ejjz5aYacQljc3b97kN998w1dffZU9evRgUFCQLYGwWbNmHDduXKFqienp6Zw6dSp3qlQeDw/kAWwCsJ6r4YJBg8rsZyLBgBBl6MaNG2zRogUjIyPtTmkiLY0WAH788cdFuobJZKKiKG4vpbtkyRIC4OrVq+1uX716NdVqNQcMGGD3qbukhwU8YS02o1KpGBoayhkzZuTL4M/Ozuazzz5rG14oWCrXbDbz/T//pH7XLmLbtkIBgKOX+u/gYNQPPzC0cmW2adOmSPUOROmwVktcsGABhwwZwpo1a9qGFmrUqMGEhAS+//77PL15c5FzA3oArORO/kAZzTCRYECIMnbhwgVWqVKFLVu2dDjnvFevXqxbt26RllO1znufMmWKy32twwPx8fF2t69atYpqtZoDBw4sFAiU9rCAJ86cOcNRo0bRYDDQ19eXY8eOzZc/kZSUxMqVKzMkJIRr1qwhSZrMZj5x8qTbAYDd144d9HnvPf7m5gwGUX5cvHiRq1at4rhx49i8eXOq1Wo+DtDsZuN/HWAqwF8BvgVQDfBRd44t5Z40KwkGhCgHDhw4QL1ez6FDh9rtSraulOcsmc+RF198kQC4f/9+p/uZzWb26tWL4eHhdufvr1y5kmq1mo8++mihQKAshwU8kZKSwmnTpjE4ONj2Waw5A6mpqezVqxcB8F//+hefOnaseIHAbcMHnQ4dYm4J1N8XpefatWv8o2dP5rk5lXDk3z0LAKiCJakw3Z2egTLKK5FgQIhyYvHixQTAN9980+72Dh06MDo62uNx5/bt21NRFJeLwViv/8UXXxTatmLFCruBQHkbFnDX9evXmZiYaCs206VLF+7YsYMmk4kLFiygrn17xw18ly62L3m7r5UrCx2j7NrFV++Qn41womNHt4cFTgDcBvAzgN0BxgK87Oo4tZosgUXK3OFu+62QJFzIzMxEYGAgMjIyEBAQ4Gp3IUQBzz//PObMmYONGzeia9eu+bZt27YNMTExSEpKQkxMjNvnrFq1KrKzs5Genu5wn0uXLqFhw4bo0qULli1blm/bihUrMGjQIAwYMACfffYZ1Go1ACA9PR3Dhg3D+vXrMX78eLzyyivQ6XQefNqyl5eXh5UrV+L111/H4cOH0bx5czw9eTLGh4XhL5MJUKkKH3TsGHDxYv73SGDuXKBSJWDhQrvX0igKfm7eHA38/Lz/QYRHcnNzcf36ddsrKysr39/tva5evYoXN21C1NWrRbpmDICrAA4AUBztpChAnz7A6tVFukZxuNt+SzAgRCkwmUzo3bs3vv76axw4cAD169e3bSOJ+++/H0ajEbt27XL7nBqNBk2bNsX3339vdztJ9O7dG/v378exY8cQGhpq22YNBAYOHIiFCxfaAoEDBw4gPj4emZmZWLhwIR555JEifuLygSS2bduG1157DTvDw4EnnrAfCDhy5Agwdizw+OPA4MF2d9EAGFSpEhY2aOCdm64ASOLmzZuFGmZ3Gm9nr5ycHJfXVqvVUKlUIAmz2Qyz2YytADrBSWPuxAcARgI4CaCe44sCAwYAixcX4QrF4277rSnFexKiwlKr1ViyZAlatWqFRx55BAcOHEBQUBAAQFEUvPDCC4iLi8O+ffvQqlUrl+f77bffYDKZ0Lx5c4f7LFmyBOvXr8eXX36ZLxBYvnw5Bg0ahEGDBuHTTz+FWq0GSbz99tuYNGkSmjVrhj179qBatWrF/+BlTFEUxMTEoFPnzoj4+mtcNps9O8H27Zanuk6dHO6SB2BpSgrerF0bIVpt8W64HMrLy7PbSBe34Xb1HKrRaGA0GmE0GuHn5wdfX19otVpoNBooigKNRgN/f3/4+PjAaDTixo0byMrKQmZmJm7dupXvXGq1GmFhYahcuTIqVaqU71W5cmXUW70a3LgRSl6exz+fm3//N8PVjuU8WJRgQIhSEhAQgPXr16NFixaIj4/H5s2bodFY/gn27t0b9evXx6uvvor169e7PNe6desAAA8//LDd7ZcuXcLYsWMxcOBAxMbG2t63BgKDBw/GJ598ArVa/Y8YFnDl0PXruExaGnZ35eUBu3cDDRsClSs73TWXxOYrV5DgYr+SRBK3bt2y2/AWp+HOzs52eW2DwWBruAu+QkND7b7v5+cHlUqFnJwcZGdn48aNG7h27RoyMzPx119/IS0tDcnJyUhOTsb58+cL3YdGo7E16NWqVSvUyN/e2AcHB0PlrEcoLw9Yu9bpZ0wBEF7gvVwAnwMwAIhydrDJBDRr5vT8ZU2CASFKUa1atbB69WrExMRg4sSJmDt3LgBApVJh8uTJGDZsGI4ePYpGjRo5Pc+ePXsAwG6OAUmMHDkSOp0O7777ru39ZcuWYfDgwfkCgduHBdatW3fHDws4cvDaNc8P+v57IDPTaa+AlVZR8MO1a24HA2az2WEDXZyG22QyOb2uSqWCv78//Pz8CjXOwcHBuOeeexw26o5evr6+tmEmkrh69aqtEU9OTsbly5dtfz5x4kS+bQWf4LVabb6GvGHDhujYsaPdRj4oKMh5A++Jhx6yDB856TkaCSATQFsAEQAuA1gCy/DAmwCMzs7v4wO0bu2dey0hEgwIUco6duyId955B6NHj8a9996L4cOHAwAeffRRTJs2DbNnz8ZiF2OLR44cga+vLwwGQ6FtixcvxoYNG7BmzRqEhIQAAJYuXYqEhAQkJCTg448/hkqlwty5c/9xwwKOHMnKglZRkOs6Rep/tm8HNBqgfXuXu+aazVh77Bj0H33kVqN948YNl+e0dn/ba7gjIyM9brSNRiP0ej0UT3pHYGng09PTbQ34qVOn7Db0ycnJSElJKTRur9fr8zXijRs3tj2xF2zg77rrLo/vzysiI4GePYFNmyy9BHbEA/gYwHwAVwD4A2gG4DUATkNojQZ47DGgnOfbSQKhEGWAJJ566il88skn2LVrF9q0aQMASExMxHPPPYdffvkFNWrUcHi8wWBA9erVceLEiXzvX7x4EQ0bNkS3bt2wZMkSAJbcgSFDhmDIkCH46KOPkJGR8Y8fFihoyIkTWJqcDOfPzbe5edOS/d20KfDKK24dojl/HtVnzSpSI22vC906hFQSzGYz0tPTCzXmBV+XL19GSkoK8go0kD4+PnYb84Ld85UqVUJAQEDZNPCe+u9/gf/3/7x/XrXakohaRjkDkkAoRDmmKAoSExNx4sQJ9OnTB99//z3uuecejBgxAi+99BLmzJmD//znP3aPzczMRHZ2Npo0aZLvfevwgF6vR2JiIgBLL8HQoUMxdOhQfPjhhzh48GCFGBYoyOPO5L17gexst4YIrO5t2BA//vKLp1fyGpPJhCtXrjh8ai/4BF9wSMHX1zdfQ96iRQuHDb2/v/+d0cB7ok0b4MkngQ8+cDpc4BFFAaZOLffJg4AEA0KUGZ1Oh9WrV+P+++9Hr169sHfvXvj5+eGZZ57BSy+9hGlTp6LyqVPAvn3AwYPA778DJhNu5OZiDoD7jEYgIwMIDAQALFq0CBs3bsTatWsREhJSKBBITEz8xw8L3Lx5E6dPn8bJkydx6tQpnDx5EidPnsSRFi1g6tfP0mXrju3bAYPB7XFeFYDqPj5Fv3EHTCYTUlNTHT613/731NRUmAs0YkajMV8j3rJlS4dd9Eaj01HvimHOHMv/+3PnHA4XuE2ttvQsvfiiV26tpMkwgRBl7Oeff0br1q3RtWtXrFixApkpKZhTvTom6PUIysy0fKmQtqcVwpLFrAMsiUlDhiB56FDU794d3bt3x+LFi7Fo0SIMHToUw4YNw2uvvYbHH3/8HzMsQBLJycm2hv72hv/8+fO2KWvh4eGoV68e6tevj9wHHsDCWrXcu8DVq0DfvkDHjm5/kasBzKxRAy+6EWDl5eUhJSXFZfd8cnIy0tLSCk3BCwgIcKt7vlKlSvD19XXvM4v/uXABePBBy3+LGhCo1ZbegN27gb/zdsqKFB0S4g6ydu1axMbG4qMRI/D47t0w//orAPe6t6nRINdsxkt+fnj27Fls3LwZjz32GIYPH47HH38cAwcOvCOLCOXk5ODMmTN2G/2MDMusbrVajdq1a6N+/fq2ht/65+DgYNu5Lt+6har79sGt9ME1a4DEROC114D773f7fldERKD2tWsuu+ivXLlSqIEPDAy025jbe9lLGhVelpwMJCQA27Z5dpyiWAL3fv0sww133VUit+cJCQaEuMNsiI1F97VrAZUKqiKOWf7etCnq/fQTBj3+OKKiojB58mQ0a9YMK1asKLfDAunp6fkafGujf+bMGdu4dmBgIBo0aFCo0a9Zs6bbvRw9fv4ZSenpcPmsN2oUcOkSsGqV5QnPFbMZSEkBHv177bq/BQUFOX1qt77Cw8PhUwJDDKKYSODTT4HnnwdSUy2/C46mblq3RUZaylf37Vu69+qEBANC3EkWLQKGDAFRtJKoViYAhyMjMbNJE6zbtKncDAuYTCacO3euUKN/8uRJpKWlAbAkVVavXt3W0N/e8IeHhxc7YS0pPR0P//yzNz5OPgqJfunpGHJbhn14eHiZ/8yFl+TmAuvWWUoJ799v6TW4XUSEJbdk6FDg4YfdCyBLkQQDQtwpTpwAmjSxfOl4gRnATIMB0cuXl/qwQGZmJk6dOpUvee/kyZP45ZdfbPPP/fz88j3dW1+1a9cuUhf4zZs33cqgv5ycjMyJE4EHHnA/kdAFNYA6vr441Lw59N4qgCPKt9RUID3dMiQQGgrcNhxVHkkwIMSdwGQCWrYEDh2ym6y0G0AHB4fuA9DSwTZqNFAOHwainBZJLRKz2YwLFy4Uytg/efIkLt626l9kZKTdRj8iIsLlU35WVpZbGfTJycm4VqC6oKIoCAsLs9s9r69SBS9GROCmosAbk8fUAPZHR6O5fC+KckrqDAhxJ9iwwTJt0IWxAFoUeK+2k/0VAJg5E1i+vMi3dvs0vdsb/lOnTtkq6On1etStWxf16tXD8OHDbQ1+3bp14e/vbzsXSVy/fh3Jycn49ttvXTb0WVlZ+e5FpVIhPDzc1rjXrFkTrVq1sjsWHxoaaiuPa0/zjAw8dPgwcs1m94sQFWANZT5r0EACAfGPID0DQpSlhx4C9uxxmJi0G5aegVUAPE5J0miAP/5wusiOJ9P0Co7jWzP209LSXFayS05OLlSCV61WIzw83GX2fKVKlRASEuK0gffU/owM9DhyBFfz8jwOCDSKAo2i4LP69dE/vODSNUKUL9IzIER5l5oK7Nzp9u7XYFkdze1/tCYT8MUXwKhRbk/Tq1WrFmrXro1OnTohJCQE/v7+0Gg0uPb3lLlLly7h0KFDtga+4EpyWq023xN8/fr10b59e7sNvMuV5EpQy8BAnH7gAYz55RcsTUmBRlGQ52pJXViWK27p74/PGjRATZniJ/5BpGdAiLLy1VdA165Od9kNS8+AEcB1WMaoHwQwB0BzF6c3qVTYFRGBp/R6nD171ladztfXF2FhYQgMDIROp7MtfZuRkYGUlJRCK8npdDq3CtxYV5K708rUfp+Zif9cvIilycnIIaHA8vQPACYSZljqPXQPCcHoiAh0CgqC6g77jKLikp4BIcq7Q4ecz12GpcpgHIBuAEIBHAfwBiwBwbcAmjo5vdpsRtULF3BWUfKVqb1x4wYuX74Mkm4tNhMYGHjHNfCeaBEQgE8DAjC/Th0cycrCj9evIzknBwQQpNGgqdGI+4xG+JfgwkFClDX57RairKSnW9ZQdxIMtP77ZfUILLkDjQG8AOArF5e429cXia+9VqiRv2NWkitFPmo1WgQEoIX0fooKSIIBIcpKERvj2gB6AfgSliJDztLq/AMDMWrUqCJdRwhRcUiVDCHKSqVKTnsFnLkbQA6ALFc7VqpUpPMLISoWCQaEKCvR0UVeN/0sAB9YEgsd0mgs1faEEMIFCQaEKCvR0S7rmKfaee8wgPUAYuDiH7DJ5NGqe0KIiktyBoQoKwEBQGwssHatw3XT42GpLdAaQDgsswk+AOALYLar8+v1QFyc125XCPHPJT0DQpSlUaMcBgIA0BtAGoC3ADwNYAWAPgAOAmjg7LxqtWUVNcmMF0K4QYoOCVGWSKBnTyApyWlQ4BFFAYxG4ORJoGpV75xTCHFHcrf9lp4BIcqSogAffgj4+lpqDngDCcybJ4GAEMJtEgwIUdaqVLHkDajV3gkIxo4FEhKKfx4hRIUhwYAQ5UGHDsCWLYDBYJkS6ClrEDFxIvD220UuaCSEqJgkGBCivHjoIeD4caB9e8vf3V2yV6UCwsKATZuA11+XQEAI4TEJBoQoT+65B9i6FVi3ztJbYKXVWoIDtdryZ6vq1YE5c4BTp4Bu3Ur9doUQ/wxSZ0CI8kZRgEcesbz++AM4cAD44Qfg0iVLIaGAAOC++4BmzSz/9VbioRCiwpJgQIjy7O67La++fcv6ToQQ/2DySCGEEEJUcBIMCCGEEBWcBANCCCFEBSfBgBBCCFHBSTAghBBCVHASDAghhBAVnAQDQgghRAUnwYAQQghRwUkwIIQQQlRwEgwIIYQQFZwEA0IIIUQFJ8GAEEIIUcFJMCCEEEJUcBIMCCGEEBWcBANCCCFEBSfBgBBCCFHBSTAghBBCVHAad3YiCQDIzMws0ZsRQgghhPdY221rO+6IW8HAtWvXAAB33313MW9LCCGEEKXt2rVrCAwMdLhdoatwAYDZbMbFixfh7+8PRVG8eoNCCCGEKBkkce3aNVStWhUqlePMALeCASGEEEL8c0kCoRBCCFHBSTAghBBCVHASDAghhBAVnAQDQgghRAUnwYAQQghRwUkwIIQQQlRwEgwIIYQQFdz/B3Ld2kq8kxTkAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print SA results\n", + "sa_best_cases, sa_best, n_exp = [], float('inf'), 100\n", + "for _ in range(n_exp):\n", + " sa_case, sa_cost = sim_annealing(hard_graph, 200, 1)\n", + " gap = sa_best - sa_cost\n", + " if gap > 1e-6:\n", + " sa_best = sa_cost\n", + " sa_best_cases = [sa_case]\n", + " elif abs(gap) < 1e-6:\n", + " sa_best_cases.append(sa_case)\n", + "sa_prob = len(sa_best_cases) / n_exp\n", + "sa_best_cases = list(set(sa_best_cases))\n", + "print(f'output: {sa_case}\\ncost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if sa_case[i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "c4f3a812", + "metadata": {}, + "source": [ + "We found that the probability of SA getting the correct solution on the hard problem is much lower than that on the easy problem. This is because the energy landscape is different for the easy and hard problem, as shown in the following figure.\n", + "\n", + "\n", + "\n", + "The global minimum is located in a large and smooth neighborhood for a simpler problem and a narrow region for a harder problem. It is worth noting that when the system size is relatively small, most of the randomly generated problems are easy, and hard problems need to be constructed with special methods, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." + ] + }, + { + "cell_type": "markdown", + "id": "99ee9bf8", + "metadata": {}, + "source": [ + "Now we use QAOA to solve this hard problem." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1f6ba479", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "backend = type(K).__name__\n", + "# use vvag to get the losses and gradients with different random circuit instances\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "\n", + "params_hard = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", + "if backend == 'JaxBackend':\n", + " opt = K.optimizer(optax.adam(1e-2))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(2000):\n", + " loss, grads = QAOA_vvag(params_hard, hard_graph)\n", + " params_hard = opt.update(grads, params_hard) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "a6b7606f", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:52:31.104782900Z", + "start_time": "2023-06-30T02:51:56.848514800Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #0\n", + "measurement prob: 0.011892922222614288\n", + "output: 100111100001\n", + "cost: 0.03514176607131958\n", + "max prob: 0.03562089055776596\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #1\n", + "measurement prob: 0.021911870688199997\n", + "output: 111100100001\n", + "cost: 0.029562288895249367\n", + "max prob: 0.04285888373851776\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #2\n", + "measurement prob: 0.016403989866375923\n", + "output: 111000011000\n", + "cost: 0.03551255911588669\n", + "max prob: 0.034648310393095016\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #3\n", + "measurement prob: 0.006490767467767\n", + "output: 000110011110\n", + "cost: 0.029899753630161285\n", + "max prob: 0.042506810277700424\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #4\n", + "measurement prob: 0.025229839608073235\n", + "output: 100110100001\n", + "cost: 0.03145389258861542\n", + "max prob: 0.04125567898154259\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #5\n", + "measurement prob: 0.02942775934934616\n", + "output: 000111011110\n", + "cost: 0.03618713840842247\n", + "max prob: 0.035310640931129456\n", + "bit strings: ['000000111111']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print QAOA results\n", + "for num_circuit in range(ncircuits):\n", + " print(f'Circuit #{num_circuit}')\n", + " c = QAOAansatz(params=params_hard[num_circuit], g=hard_graph, return_circuit=True)\n", + " loss = QAOAansatz(params=params_hard[num_circuit], g=hard_graph)\n", + "\n", + " # measurement output\n", + " m_out, m_prob = c.sample()\n", + " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", + " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", + "\n", + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "565dd4a7", + "metadata": {}, + "source": [ + "The probability of QAOA getting the correct solution is also very low. A very simple trick can be adopted to improve the performance of QAOA, namely quantum dropout, please refer to following tutorials or [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "89ed16e3", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:52:31.105332Z", + "start_time": "2023-06-30T02:52:31.104219200Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OS info: Linux-5.4.119-1-tlinux4-0010.2-x86_64-with-glibc2.28\n", + "Python version: 3.10.11\n", + "Numpy version: 1.23.5\n", + "Scipy version: 1.11.0\n", + "Pandas version: 2.0.2\n", + "TensorNetwork version: 0.4.6\n", + "Cotengra is not installed\n", + "TensorFlow version: 2.12.0\n", + "TensorFlow GPU: []\n", + "TensorFlow CUDA infos: {'cpu_compiler': '/dt9/usr/bin/gcc', 'cuda_compute_capabilities': ['sm_35', 'sm_50', 'sm_60', 'sm_70', 'sm_75', 'compute_80'], 'cuda_version': '11.8', 'cudnn_version': '8', 'is_cuda_build': True, 'is_rocm_build': False, 'is_tensorrt_build': True}\n", + "Jax version: 0.4.13\n", + "Jax installation doesn't support GPU\n", + "JaxLib version: 0.4.13\n", + "PyTorch version: 2.0.1\n", + "PyTorch GPU support: False\n", + "PyTorch GPUs: []\n", + "Cupy is not installed\n", + "Qiskit version: 0.24.1\n", + "Cirq version: 1.1.0\n", + "TensorCircuit version 0.10.0\n" + ] + } + ], + "source": [ + "tc.about()" + ] + } + ], + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c569e0496ac7faa80ef4e91d1d015733cfa8228a Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sun, 2 Jul 2023 15:14:02 +0800 Subject: [PATCH 511/725] update --- docs/source/api/applications.rst | 3 + docs/source/api/templates.rst | 2 + docs/source/tutorials/figs/landscape.jpg | Bin 0 -> 66616 bytes docs/source/tutorials/figs/qd_alg.jpg | Bin 0 -> 251040 bytes .../tutorials/qaoa_quantum_dropout.ipynb | 1040 +++++++++++++++++ 5 files changed, 1045 insertions(+) create mode 100644 docs/source/tutorials/figs/landscape.jpg create mode 100644 docs/source/tutorials/figs/qd_alg.jpg create mode 100644 docs/source/tutorials/qaoa_quantum_dropout.ipynb diff --git a/docs/source/api/applications.rst b/docs/source/api/applications.rst index 2ecae939..337c8aec 100644 --- a/docs/source/api/applications.rst +++ b/docs/source/api/applications.rst @@ -1,9 +1,12 @@ tensorcircuit.applications ================================================================================ .. toctree:: + applications/ai.rst applications/dqas.rst + applications/finance.rst applications/graphdata.rst applications/layers.rst + applications/physics.rst applications/utils.rst applications/vags.rst applications/van.rst diff --git a/docs/source/api/templates.rst b/docs/source/api/templates.rst index 897ff36c..d76ab744 100644 --- a/docs/source/api/templates.rst +++ b/docs/source/api/templates.rst @@ -1,8 +1,10 @@ tensorcircuit.templates ================================================================================ .. toctree:: + templates/ansatz.rst templates/blocks.rst templates/chems.rst + templates/conversions.rst templates/dataset.rst templates/ensemble.rst templates/graphs.rst diff --git a/docs/source/tutorials/figs/landscape.jpg b/docs/source/tutorials/figs/landscape.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3ffd79028ebaf7bcfe39d2dbc41bc259789ba5a3 GIT binary patch literal 66616 zcmeFZ1yo$iwl2Jy#@*e51b1uPf(H%m1PksGTmlL15Ik6L2(H1M;Fci4g9Uegopb(s z_TJ|nxpKz6;~(!8qq@JYRjaCI=~uI6@%Z&|1;CV-mXiiRFd$$6`UgC&p=!%XN*bxC zDND;emjXZ_06>*}Ze{NPg9!k3_O8xqG7^;9I=YkyqW}zm1i%9v0AOP3;;8sSS{;Bo zIVnj>7igqk_&0Yk3qVr>fGHMP6-vtA!v8}E%hb`?6#zgg(AZpN<}RjC{053`JzO1s zg&#pN?n|3r7zXwic7_%ZiV1&V%Rgi0KgIbo7W;+G?Ci~;aekHA(ag^57w&=LckXWH zPz-(!#i8z2<{nTy4aGFJZgy5sdu3jqKk zs^#zS%im#Fb5CeF0YK8h@wKy+;7;gZee(ZPh;Q#6`uUuUn1=!d; zJUm#f%uQK;Rp?*bKaKF0n13JqE;Xr>1#k-jfe=7wARG`8hyp|lVghl3ARrNt6zDlf4Wt7y23dmaL2e))P%tP0 z6c0)R<$#JoRiGwNCuk5f0s0171?_-NKsPX87*rTs7&4frFl;ao7;zW{7{{&yd!o%XgQo^#p3c||5YQUPpI>GwEM#84S7QxoT_P|cTuEHL{ zKER>Dk-{;-3Bbw0X~S8n}OSeyMTv>$A_nb=YyAp*MYZ&_lA#z z&xEgp?|`3xUxz9IOouFttd4Ar9EkiL zxdOQtc@g;(1qFo)g&#!~#R??=jg5f)6k7`04Eqgs9(FhO zIu00z8b=bx6ek!bAEy^*6Bizr4p$D>8aD#B9CsA=2oD>N8&4C@6E7X_Gu{e582>50 z9KJ1n41P8KEdC7v8G$%~IYAgf1;Hf2B_Ro+7@;{~IAJB>4B-tCC6N@74N)9X1JM#O zEHNXoDzOJ~7I81}PZC@bK@wAvaFS}0c~TfsMp89WZ_+%{FQn&W z@yW%=t;rL~+sJn)a41A5tSAyG+9`G^@hHV9Z7JVV_D~)@A$=nI#O+DWlhG%)RCH7t zR6$ggR7=#z)DUV5>O|@;>LVHo8bul(no^p1S|nNs?JL?8+J4&0r*u!Xp1ytB@N}Dw zkWP-yi>{Pzksgg+l-`LxmwuW7o&myO!;r}^&IrTE!}y9ZopFo_hKZNSiYb$6f*FpP zpV^){mwAo_l|`Jzou!mzl@*`$IcpGW1M2}B4Vx}o99uuz13M49Eqgxu0tYsSJVy{m zGsg)hBc~~6I_ESO8kaPeKUX8yF*g&pId>NKR~{T5MV_}jT|D=^e7w%Q6}&rqG>_Ex;?_Do`zOD99pcBUmE1Ekq||E|f2{E=(nCBAg?< zB0?!*Eb>8QMf8cNiD<6qni#d1nb=3MEpY~MYw*wVM}R9rAd94rjoXlE|or#;gRu{>5zq!RgjI7os%PzGnFfrJCf&<_m%HaKvj65 zkfyNqobkEy^JYaDMR~;p#YH7rC3~d?Wk6X@IYD_zg-*pur9~B9RYf&j^@kdVnvYul z3!E25FG^lqs7t8Fs4r;HYq)82X<}&VYZhx>YCY46*ILnL)ArRK)*;rh(rMI1(ACua zsC%v_rI)0)sn4Sysy}N$XW(ftXh>{mYxvm+!^p&_#u(06%ech&&P3TH*W~=A+{=uY zN2ZddDW-d7VrGeEJLbaX@#b3=!WQus+m^zX36?vrL|-Mp`e`L;m1cEpEo+@^eQBd? zQ)u&Ot7ThhhiGSP*JO`vZ)4x%K3Lflr}McmWfuRJt8YCN$#?LEJ|W_%s?ddo}NtH2x9+tjp(u{1_fe107SW?IyfIm^@Uix>vvHzvMe$hi zUh(S*iV5|Jl!@VqXGum$gUQ^<*(t~=ZYeA8pTBQRrAduVy-RzQHj^%qUYS9f5teb8 zX_h&eC6-l@O_m*zee=QU!`B>{oci3SxygC(dG2{X@-_4O3m^r>ABjIke7rBTFI*{7 zE9xocD=sb}Er}_GDRnE|Dbp_-FMn3vSiw?}Q;A<0@d^0k_G!1uxN5dqp}MOEQd3b& zTbogbQx{$js()R7)bOfdrBSDGqDj7~t68wQu7$Owu=Po6`e(e)F>T0gZ`vN)z1q(^ z96Nq?T6V5?8FejmYj;ogsP>HZD)bKYN%wX4i}$w=2oJOl3Jf+4L53QJd57!2@O-Ho z;TfqLZ?@l# z=iTRT7XlXH7Q>e?my*Aee$QQISgu^*UHQEFZ1v09i?xMy)AhX#myNs4H$TvRByUk{ z6>oEHx9&*qjPL60Ztgkm-Tn;S$J)<0pg*WR6g&KKqv4y0_x_&YzWG7nVe!%K@$vBhKo>W2cxetm={1x; zJT3r|04gFP8X_7NIyx2s9zGrxE)mob5aSb&lamrtl8}+nk&#eR(fx8%%xqA{%qJ)) z_{;x)?pGopG!ztc6m%>M3~WLyEG%pS5<*;D0&)UENi$+D zF#qjDIshz0m~Pm3FhB)>us|?aFpoU|1yoQtC?|osUqb(KAQ&(#96SOd5;6)jLLDXm z0|J9#V8L*3uuzf&@`XMJV6ot^pKyr7(Qv(V4nji4 zCmC;viSLsJXN-b~HREi7MIS-ZHpxqEoN_6mLz z68iRCSa^IwVp4L-`_#1Dy!?WXg+;|B)it$s^$m?p&0XC+y?y-ygF};3(=)SkU%$<- zuB~ru{@B{y**!ivJv+a+yt=;mB^L+)|5>cRNcLB9VL|1BfrSObBK(pI1mp2ba4cB3 zCmitD;;INHPB>JYfrz*gaXD3;NYq?vM|dxtCy?=JxL0Y9e~I=d$^K)41^t&K`-@<| z$u$q4f}u@-1%m~M0_VE)xdF)k&;QHn08$x2d^XP-A7RIr!hDI?q{Tol1@|qs7@B zFyn*Lh97^$*eZNcN;B~SDtvv~Gipa>$*Ls%N)@D+d2?17<5P(DY)_Bn;A=bA!H5NZ|si|I`~_O@0|EFi=WRMvc`|rsC$3LmH~M!+Zme zV9$>LWEf|R!=K{~-*KfL2nk!!MCzng{3)A7Svi^$IblV&UwOC~GEJxn3q0(SL^KvC zy#Ar7FdPeJOl8L$P+{m}CkUJ(H3k>tHYta+pRjy=1Qz-q66FjGev|U|692DY{jDAr zRqk^5^99&J6p0dThNnge(M^m+&}V8hCEksj{u_YPxoxo(}snzmexZyA`gAjVTXhB z5%;$hlN8ln23a_4>SKh!cJpwD-?RSb4M`3$LXJ{>tK!=t8RT^-H@qc~R zhDrI${?*<1Tg7iW|AK{?f?;Y2|vvYoca19(PK z$7b`Bsc`> zri7>qO5corv-GKgOsn*`rI zsSmK)>L(yb=CaoH%d)5s#oXLX|9P;1I)udwF~M9-cZ3ZhaOd~vWxK{dY~Npg1mvmn z9?ZsW1E6E005A}tNmrSooaT;@e7(hYQ=i0=Dz-=%e@&!mkdOXZoT{3eB21xjAptJo z^F+Lc!mCX!K{Xx+o(;zcVtnH!;Tw2~uBjBgVt527bsmAe2jzP_JTJJ{k3gsLH4Jn* zF*@Ufr;A!%i7Z2Ea%GX;Sk3axH`<+Eo zWvHeHvFrTj_Bd|db{h<9+Hl#EG6QGS62iNZ)G_5^exPdY5g^)a!>QBRoLZrhel;_> zlds{MU$OCunuZjo^QSm<_(JhuMlF*W||!Fwp4$olEQZ zd^Wg9+{U*M(Iji5pRC*9<7D8>^8yL75AdjxSm&hzApA@K=ouG!f!@G8TS>C8 zBpxI1{ka1vMyf2tb+E%^E;xYD;(MV>(ZXigzDWk+V7GoPCqB`&*ondGb=XfEr-36* zSqyABp6zmNk!TIpESVbNT$u|fBJhOt@tj;4Kf#e;!?$9j{%_l!NR?P6>}sjL7Pr59 zmlK(49@pA9)Ypo3@TDIB^&5h?M_krWzY}`96z%+g6k1*U%%shHW(Mf8=Ws40uE;wg zZBZkjtkg&0)}LBqll@G=AeDE1_N*^d#?Yy$Q-hAEYaK$PRiLjc=}|KpMPU{}Wv{Ye z;I|hU97?nj{R(vYJb8Okwo^mBh6}RS6jyM$fEi~=JULbUp@$yx$RtFc*7i3~Lb)64z{ z(G8Sh|GAL4hj8mHKNd-DUGvZP%`v>A7evqAOAPQ6ku(S0a`KN65#rTV7=A2V9d0S= zMBz>14krNxc%uB7504`V9-SI#`-nQ&SfMN}_LF{@kk*hm$TCRZh%I6L={jgj)+zg= zPOEQfXR;^ld)5UKcOZ58X!IJ{S32~asLZNZmq7@!qSR5=ER#R_LNhCBwbFsJlD6zb z@ZkEU6secj)B|Hzyr=VisyO{PXFQ0}XG1?mGL)LSiYh>0e(>1xF3^qb=BW7*m{3$c z>KSv&|0+j~Z&6)uVL|&o0Xtq!C|>!+^FKrrBQiqq-_Wai1R7%Q>EoN5H%0Itfq@3o zN5FyNMwQl;xbE`8AZg_L(t~1a_5SG60%ko|aO8RgJ(v?pUPjr_vkUb|ir39fJ56C# z@&Yu{G&NykJ3>@?0=~cJFuJO`6Vj-QFo9(qDiz{Pf8U+t{&je>pAw>kC{21IW#Yp< z!}62c{I%a4O#=bW2$OH}t{bbK#k07cjtxq>A9VbKKY4t#iso%}6*oULw77eFd~G-R ztUr+F>T@l5)v@ce*9*9My=lPI8@Lz`E6^C~Gdl^!x)Z$k1RI@7IHra`oicvs=CNku zAgDamkQgmV|N5?IrW-RhKa~3OH$T%34OsJP8_5o;eOD%$&oXjqyb={zdLc4qk$9B; zfZ^hKN%rrnCxGe7V~ymh7|+&LE`#g!Fiinv7;vrqh5DsJ7M_IVlbQfdHy@U@{A0?- zs2p~E-7ltD*j-|UF2J*Jz}P)2vvWV_^>R@530(F=`v$a?R8^1GA0!QFAA!o_MC zc(t~#gcdfFEa21g4kS>H9ikssjdBfD^lU@u5(X+&{xrk>nq~jXzG;lq=8~MKuKshF zf^Egh1BkQ<36LYPKW7{M@6mSjL)0U10RxS zKVS(HJOtKfU!f5^0ytV_wR;8}sP3O+kdv7;xwWU`fl*vg251D(hOXpu(3Mbv;*XW{8VI# zI&S9Rj#6$pZ{_3rPJf=X7!6X1vn3xmA*1b)Y-9k7fqREyWJWz?7A#zHS*Q+a2Yd}d zPZFqWgH7fEntimaj11HuDdm+Y*ee&=`Z_llgM!Tt6_2JxaYosfc}OinA!Lo^C@dJt zQ>247RZ}dksIpv_f}Og?E9L(9w7;dZw=N)xgvHd0W!Q#_EQo z1tO0iK9>Msm^0oHo{{3}*_qJ|{Jj4Px6z#-a+WJ2lt1)aV4D^2qO7-#wTdQSOG&B1`N zSxiFX8Xqme0$}V2sR#-XdIZ*u?gEXW!d*QAXXq)r!miPH(~mC>06To`RnLI&m&%>PZO8 zglUvSNs)#INF87YzyZKEW5L1O!d)er=Gq_&WL)kznn-|Vof)Z5ZY==vhk01*gQoHw zl^5GR*iQ6_nC;yYQ*r0F4+XcVr{ub|GbC5DA!{5gw`6 zl^DOpYEAH2ORev~BBrOS$qb=ODA7Y6WsoZqh4xWsTqX8gvQrB_Y$H5B5=yOw>`)cp z6y!8Du7bdGOh_00wD#z}m_>BnH0@;xk;yx129FKEaV2C_nT(Is%Lu0{`3CRKsYt^> zU{gaKP6ZZfJ>v+F!M)P4nr(hbxNjVd$E;oUs;Za`qI5rM5~8<(bt<=Eg*_ z)UcSIl+n2X5U743Eu`gD{j8xePEU1BkDm@qYv?oILfBH~a7lFjJ;kdW--`&m3A>ch z=Fjo$aSYd8)M2P^BjJWj;}KqDFjSP>%2m(s-dD^M)mu8G6U#L~M)|;zD;5!CPlpwj zE)-swEJuA;w<7;(Ni+}dln@SZr&IiFVX{$NxJ&oUU5aX{r_^7kBkF%Xqm1uAK%fTg zl_-_>xHIKC37)2MjqdRZD4G^8zl=EGaL{bT%WuScr2+j{dXE6rQp|m;|IV|d$))*T zU)1DN){SI786s-Nj#AVh!~x+_(LYYdy3?R8AA#l+@lzqeqWa-?`5pn7u+9?8yrw>A z%e+7Mw-D}=QD*mud)vb7Eiy>=k&U<&*! zZjQ>npjVO*I27wio}?uMZO{*~v+hoL@HG7Jav-MKH8~V^Sf>D|x#@AZ1%*_#A^ytx zXKPF3eqvFCl$<_2adk?s2iHGCC*j}oie|l1S%=(L_SAB!Rf%rsZ(*^LjKw>NN~*5B zpNBF$QDAbDbH9E^8A-j*Z!koFfDo6J2^Ihb$ze6;cei$tqjodj8GiM!Aw@~!daEPkeEcmg0Z}pPU=>iXWxZu7N z(UnH_*u*7G_^je8>@*!NLhd7^jQXLq6;w&&Ny^!UxT$`|EQ8v;4H-1XpgrabwHIPx zX(eD5`o@xMp*kQjx>w`wD2p;kYPMpA`ri0x^L#dIK9PgyiCliv5X_elEHmZ~bON-? zW>nJk$n$pMM__{o;oegQ%Gt~-Du2IdsDq%2J5(O!pP&5}Tz<+mKvj9H`wRU8pOJ`S z>8Ot(BfcO*sbh@Q_3Z;UUrIbF2Ts}bp;{W!>*8pM;6d=gIR)F&xxwF2xR1ky|F_RQ z%1qXH2#&OcTdM}?Ev~H0&m-_{&ix|FhTf`BUF&5KXF+{3oPt?oaBYC&>t1{HVg}yiJr~_X zMzu&$X~y-R`xg<`qkjFCbAw7c}S9}8Grs?5vTv0D{9lNJ=JhwH*eE$a_(iM0Ia zls2EApFeNF$6YL4K;QL3^TnUi-o{l`9ix^AN#>1>^eIv2*s8x!JskWfp=IT9m_v&f z?7fy}>SAYm;X_`AVyQ#{9+IMtA|HO5RsR0O zr~g=S{~M(BpH{^m(?&koxj0>vbUqGE#*3BikIz+XIsS@`i+bKCBjNHgoF3dO!UNsH zS!3KB#XJJi!v;pb*A|r~{vx4IibVIiMDIyh-2CC7TVK(8|G`HfHy5gUF1aA~ZA(E6 zn&%)j$#`RkOW?d8_|-fbSaBuQ2&V^f|Dius4)Z_3j(GTt1I<`YXSVof-iXa!eZPf4 z(8G8|(dn&VZ<~#a-KMLT0p7})7T;WZ(<6}J-yz(7uJw@Xf06>#_j~t3AE}-n9{6u8 zAA#>RpsMfey8`I>1^Ka*r!cOs_igqy-yQG>X!!5aJpv5=7yYfOh8R*5h7Vg0ijM#w zI%9Mb_6Q6a-B%srY6VZo{97&<|Itjml>(tWeL?i*Ecg+SDz}rw+E3T7uRe4c9pUu< z`BlPiZr)|E)Y*A{=>D5uIDPpT4O9Gd`-aUY=rSh#2#i}+)Hk+c()MK0*63NP$IfGt zg|2+KUPvb!AfhDaiagfQnvl73x*L;Z(w|{sD)3=3_o%)kFWaXtqqvfA9Tc&76Yn8x zmTZL@wG&^K7ud1>q2xPaOCri=5iL&NXnz*cBl*olRzc9G^@KSxI1%^!Jem}qeM{e# z?Z_AdXf%`LUJPvhNNjkwzCmsm!#!aL{IXISmaP3ko9Z^uXXsPeE{&BX_t z0tAY;Af^6Ckvo1yNf!{O8hdxNt3HuO;QLsc%QAoAmjx@9=FcMgh!@2iYJ-%n~zxVI}TJ1;M>M~ZZYspaeE;7mOP^C?>*xjb&$D?b7YpC_5mneTHEH)xR$ z%;7q=0+wW6M3U1-Uax;i8N7alceID5Gg-`nm(8tl7O$qu+bpt~6sP}56SlY;a2D@? zh`fcR=*u+pU9n@do}zZq04sf zn|)7&=2q8r_4YZjMPWX(Gyl8Aj|1N#-d(iHOVnU5$o3B@6GHaF_t{uAhmb5C<@-sR zz!kXIP8lw}QhbLq4vJbEuIrR-m4Q)wqZy1k^JBU(3Le{vQZ8P+8EuqNJY-VOBY#Mu zs$nek5?LU_tRT=BAD9d*M5h+DN`bGeupa>>a$V-qi+AcFQ8VEc5*a1giL4qfquv?< zQ8HQI4{rDDFF3WKwkoZ4U^^-y6nD@a z6^S*>uuLcEyiCFiFdzB^F{jn`#h_};G@%?9lCi#+UH=jMZVHiD2K!lF24j%>#sh?| zSgnvsX-=`g`w|}mzDliFIkhj}YE)jRWTew@q`v%;>>MxjftcV()*(Z|iN+b|!4Ice zL6sqbfE@X6`-$k%Qo4yXMq?}}o6<+@HX`xOH99oJ^fCahaku^^Yc)GMlBW&rKP&~f zO_kK5?5+CboSkbkZ+e$CcH=6ga5XYkrL@|r-l~O^9}qb6a&l@xp1frg-(?Crs!yff zB~Gg4B(z&^0(EgAX;TkSi(L;@8uar+0CKsqEj}VC-MjC;O06RJc-yl@yUqd(yczZx zdI~b$%Le7A`^&2O`~5+-)KT+;#7JFyDO4l$j9=F?M>@AXw-vRIqHAw9gNE5|dfcN% z0oVXUO7J39R>l?>cY2wRIVoLB(?i!MwlFj}e@`_%;|VPhL#Kq?(1p8Nd`-=+tsGTP z*+HjTI01bQCo%_RNQY3--c-X2z2y4xHA>b> z5GMNzw6?><3dyqgeTaoE4DP17SG=``^p90LH3QeVw$S*_7t!Qd)bk>8Lss7zfr$dEI@*H(bvlY7+ z=K}If40jwKYYo-(^3C8-Xsq$gnWD;Q`t~~_Hxjb0OR~tO3l-9%7!Sm0>R06lxKgPp zG4-eqSvSXow%U-`GCw9JRn{ooT+o`Vt7UA-D=B4FN9GM(v!-y?c=J}M9jDyAsWrN} z6}{mk-m{53K9x`LdLfpRkJBV2jA9@0N+=rX60eRgWZw-=($DaR6lsg#hrvGCC_={I zzzzyEWu6SZizM5ML$amh;px3{WCx@`x2Nmm@+A{7LhWHJwu>5V79)7WR&&^|bjL1K z-94X1dY;_aQ@6{->Q}SG7YqK!1 zCG9%fHPWm0^9%noGoIPGKmMG4@j$Dr{UE#D`v^1}x9=?(-SboCRtqVYw#8T&(pV&G zVLiizk!%!HLgep*5b{IFPNgbCZP%A*zu35Ntqd}kkXDh0JL96R!2JZa@azpQ8MSP@ zTkKu>g4C0AzR#a&F|*Pf&6dOExbu22)YDq9Z4ST`spz@H zb#x4=F)7x%pk3)){$YR06}ef zPkaau*P-sr`i6TZGrb{oYC@ka>df1Yyzje>8OUv(~+ro?Ul`b_kCkLFzpqs`HBIbaEz<%8Z-9p!Fmmnv{#N5jWtAzn5 zi8TxPN5}sE1JB4Ajw>G|Rs84P_}}pA?mi&<58(UXKzR_9Ye?xA_O)N5i9Z5{SdYN= zHygUH`OKxH(tHB!zK<3(G?BrA>XtyXXW8zwdfu0rbAcm52Gc!8j`#>C`$LVKGc>%l z<%OG+y9a&$nVq^ zRKLjcd8T1IzbDqSw+*$E#ny{JaEz~k1C3JMe^>RC+K7SPDi7Y!?79XxUUFX6F`r0<-Vp?2P^_PFJ$$?s^ z;JvNzl$bKgw9MSp)b0WzKNw?s7jLC4=6+O-oXM|FoN$EtCaEL9Hy1r=aXGtAXNj(f`iAd7e?EQsG*4=Dsre5y(Eh9aVV1`yF6kpB7U6WGE-6Hh6pQ z#rF^_>{d7OeS7}RO^-l4Gl@x5?32_^V~>EIchMMQQ(2id0>yPCO!H3uG^2}cPH#$G zeXfFTsh?J4&O702U=D^{E5xR*Q+rA{@^>zb zeJB&f*luXn*xWdIC%>f7x*s=8$Jzmyf|_jI$lInrrf2fm;do3ne>$3sbo|=bM9a{J z%#>=-I3l;O@s4Ln^W;`lky<%nNRUsNUQHgRsb2{~8HAw*ua!0%(Vff`%Xyk~31b#Bas&i;A^gnkMj&`WAj!!~PoBr`8yiLsn!m?WBk z`^DQ`Xy@56rEn_v*|?-#b^>vZ53{>6NxJZ@O8KT*e8axzI}yHB%UI`ubnok}7UC}a zXwW;Xc*}n@^&npT2+S=&=at62@(RmtU6F#-1!NVpH7!o zTAV1hOP}1S_+c5@zCoJ{73v!_h1l8b$QAD>@*NekH=4T$h`T>up8;t({;S?g@&}VA zI;+?{s~K;6!wGDt7!R%k9DCx2{2YuCq~o}HHy3eZV>>^ks|Jpd=wwGaIxAV@>SyYG zOuV=)vs3#lz|qmDsGdyLK$EaM&+oqQn6(!tq+4pmzQTWmzYCu2Mk9qDbk4$5e` zo3w1T@!tK~I0GZ4m(*<8H6OZSzcD`{1QYFPl%GK>ADu|ES99&_-5?mMOyy-cg>zR! zzU-tv9kju4@GsAmaU))k@OWL7|4~jK97trYfm~Q>94|v^Hl?t%X?3bQJG;~{->GKQ z=2krYvDjP5T=2z3#6Fw*;^MH){M_F3bWOb;JyjqQ6X~mftVR`Jlw%C8`8F_HxdHaxA zJfkZ`Tbp}kfWy_H$e@|Aks^#d(VCy&lHocv^7%r*n(=e#V%uS@46$q9pziaVEmy0U z*)q-I#nnW8gUmKXp34tVl>w#}?aJ~sl8w>%h3J_X)Pfmhb-}xEhDWE|43yW}ExqwB zUo&2@BNhpjBgq(@pO7-Gue5e&$Jc1X3qn}DT2(wKeYUfE(O#>0JG$F=_%>|Ix9wO} z^=TtW#UFiXtl}(!;r3C(9lLyBoQZ zpGmL<9n$q)o!qw<>w#t|GcBstmsP`Ch@2c*)wz&yR8C2N!Fi#gq2_CYzQ^0~&NX3q z{?Kb=0oQUzR17B?@DJSn@JijE3kr3-H z#=kbJ+f3TutRiHb2r8F%NYcz-AE}5}lrx-PP~b9b+#VlW`-VzwnPQK+%;k4PIE^mg zr~}zK*($f=`B8Cj%#z6TM$p_Qej*_-CQ+JnU1$USZC29L2tfOr= z%83gH8vqDl>;&MZ)H=xtN^9Ab+U*)3F_SV4IY%VvvSLM=6&%;OU+c*a=gnSB)wBI! zXwK4ACYG{sT<+vDXm`k(*0M8m#SJ{xUvI_ z_NG`l7j{s1R8{V(pA^vsTHX(#SOm$8-O))#9PCm)LeyT|(@||Etp2J(MMyDUA$NL1 z%2`<7bcl}X8w$<>Y4#uA_zfCt78F_xZZaDFN*Mjon!H`z&m&2F!>+g7Eyr5}3vFh$ zmV<=1ZTB|L^9l_w>B4FB9n~yix2E7})|W*?=&kr$1m#L!-B2C#CX=Ax(Ko4uNYNDF zPr2B+&B=`aX!ZQaa5kL$GOpiQa)4dlEDr{RK!>O-IhD38T4M=iD7P`UKcKTmq4_MoP*H9dN?af2 zm-{|hKeuF6&B){1MjS;CVNBGYDRHJ*r~8tYcsB9XD&F6sQERO)f!nBMGD^he-RdF8{1=1NslV>1C?WZv*t0heryjFCh*$Z~&HHaRF+Kv({u^k}qY~TpGi!A}rU?fhaXY-$m$=>e zk-9PvG?l9&SRWB6?EvYmbFVr1_3-=9}#xHo_5KdAl&&IpY0Qd4Yh7WG16 z5r8fdspZJAkYs|rIODuuHm5%=kh6TSgh~WCd#*JYeSK`;KRAa zRELA`#FmCCkouMU>fGzzc74X$(z2QqEY*uQD-t-)4j!@}k;e_-;~ z&;7cZ#=9zV-HE7A+J>{cUx2mPli9AKCjs9PPfa5K1M^qk7R0W2M2K(^*y}&34u<(J z#>c?@gCbb*XsZbDt)A05dhsAu z1FfvP>>EbL)Gi)8DD(dGHLX!TYcjIQ(xTGr%ukV1`ATE?>=t@HC3q*@9tlf; zC9od9n#X_EfzjXQk9?-fL>H3(Fw$mw814UFYH3F8#4)NJHio77%DYr=|7+E7#+F%t zDdFA^+r9m?{+0>0GRfMD$=sZ74(YG_{mXrmNZT%B))ys=v_Zk&>aH@?8?$jpyyYF! zPFjt2+rgc?Ha3Gl-?w77+Daoy(>u)(!8-MNlU)Rx6x;LRPgL2O*N4Qe6JF1uEs%LR zO*Tbot(K|5%yK5$CR9r{@lylrBmrPyNz0gW6J|158-kIYJYfM+sW&~|Nx3^le&!<> zpZ(*KKKjVC)eSUDH6lQSo~;}&X%X(-@o!aHLyfj^zuI_eo6SE0rz1zz9^0Ifj$9`R zfpd79H*JC5xxB0|pST39|A=Z{M-|M#2@Z~)$&`nr)n*n{CN|s-RmQJ49bF_6fBZgG zU`dhTep?1ri~k_Th_OGLs{UEmuBC*t>hd0py#^_xo;|O`X*(7WgICh!&j@T6_f~jAzMKldDVfaPajXl@r zl0F~LelCK%=0WO2MmSjPXdD!EXZeujwaz`l)u}sM8SG%nfkxKZl_g!>vd?9qf`7+=HG4Jlm&UFx5v$fF z#0mR4z;5B8h9rzSNN(^@jM(*m=+cPiU#Ub&|7Z{GoK5_Xj$@%mg1_DD!5gyq4%AJ{ zC6B+O>A04Np;;mI$s>_lr}2B1w!2-N37OW6Z)zhU&_fXM;&Sx0t1+~(@T@4!TY5G5 zzQUAg5c#Vh1>vS% zjH7M{gqrdk0d^%?>UDouD+X^uv$w%y2M)6w{Ifo;SdO@5N=L4&R3W@ilLdzo`)r>n zv{Eb+od#8VXp!SJ=T=gZTST9_krN!3=?o` zss?XI{Lzo%8k#Y|11or6McJ$BLcAly+1`CV|CtGE`j?CA0oc zH>5vOPaU(^n;3DWOik0kh`6YP@mvL=Xc-DlJk^)z#O?FK+f1{B5W6GsiD8`u8Yx?X{m!kQ^aD*+&U8X zgyh{zDlk9c_JT`XaP%v1RCyFd7jauFSm)cou6pbS;yNYoR2U6oesCXX%t+F(H^+y0 z!qrVWnXOK~H6=ZfreYG-$i+bo3{Ner1m}(m+DsGe#07W@JmnajlUD%fe^W@MMj7K`1YL=#&B$Pgls`6}A}lUqvvR)PP*@Bfr~@~_4s z;Psa#{auMjMI(feBSW{8Vo*5^X$Mic;#J(KZ}Wl#P>*~bKCd;l6J2rbdmq{+TxO(F zgAZ@2V-CGypqB%@51n2*&Rwp2R=dY27_6yJ>s~8xeL#-)el2(L^ARYJ?9Af2eLBoE zcfSn7k93JA1=+i?Gk!9>Lg8 zbr1i8ypfDJK(G?~s$1!(Oz&W0IJ3n>v78G=b`dk~scrJLtlcC~5Nx*Tsc#w?nPs?pV6&rZ6GpCOYrYiG)B%{khnhGtX>}W7O#5iC z4$B?|yYFN>cjW`_DZt%gG(eZJPDBaDZ+--j?l`A?p66O&d^29hpyKd=^MHT0?tHcp z%fFI=Wtg%m8mj9Ns;&6sR{hRoLkjT?@5(^NzI{f#GAUL()29#U{@qz{lRg}8>)*QO ziMFL+upOhL1BQgbwW!fe6+!>b(%^@W!n%zw!KI2_n!|fck_`z?k(Yv7SDqsIPN^B| ziiS!93mBoL5kV6}t7Pn&%lP}nZ1uWLzf7Ta^6t(ydVw=V+$)?O_%(KL@w%sB zk3Rw7hG_+YoFVncUCtdXj>RtNGkzi>1j-=9Gs?KT(yy+*nk*Kxg74p52P}Tr$TR&R z*|Fivzc)VnRrg_1sM_!3PIb#N)o6OxTUWJ?IL5rzd|~3CZEYVq0O`VizhwVUVZ4Mj z3Y@Q=hFCm5TRiN)2H?jHMaGthf)WCdh^To2*OkNSv!FynrVh!)(IW`_a6rY`&ab~2 zjM2#Ml##S9LR(}_KwRFF!pBKO8(00sE8#8x9Do2gLO!4^<9pt!9_!)8wZ7+vA^aAE z)#AuDHrfr22i7T3)3%<39FUntDR8lCXuv^-9srJ)+h)@17Qt&fHt!a<$lKI!jh62V z&M*s5(vAc`bd_SV7f{PxPvZVA#6HqNu9CN@9ZLc58e+F4vZMUMoJ#NjWEs(i;ej7X}m=4X-FNfN?j63iH1GM6uq)rI~D^8;f^70G~)vQSjvl&*MhA*sWe|+&L@ho;7NE=-mnvcy-+7J0pLx^e8x4u(W)g)TrM<9XrNuW$9j$wD zd3*`i>EH_pEYhqhwvP==Eq;S1Pf{h_@w~D5zdS z|6P}A7$7$$CcsA>{kjA1tLI#Io=zRtv%Il4*yu=>Do7m1(^;jRThW|~uMJ)&Jz?f~ zwqCzCRdq=yB*nZ3N3Wrk)MU*%xkG!M_np2%uS54}x*RU=5h!brBGdYz6fQ<6O5c?w zjP7hxTq%vCL6u)`*|+v-s!KDI=uXAG-EE>$9XbQ32K-GG%Rjwl{~x)E|JQLO-8|4D z6?uBXuvs||Ix)=xIKPMy(cyx4UW-OQFo|3J6=uM#<@}8?P7kVE@}yh!9ec;SxO^BilehQ= z4|^~pWFApat4-UPqZZRy00X#V4x`drvS1lq&=qtaKm@^Z2S--*FA9OWVU!4_>0#Qk z3m0}Yj~Dc$sl$1?inb9>X|m*m5(a;i{chj$`$-gU!;pC{`m?8j|BOsxr1>XlzXx=7 zy=_Q`Fqc6}%=vnuZiMW+Q#w?V94aA`#xb~>0H?k2@KeUsK8=?KdtQ(0#aA|k4^_*Mow23;1HVYdT}ZeN@-uY`0Yp%w8A2FD0g>)jTIp^90qKwi zDM3000g)jTkWT6DZV-?hN*W32@VE9k_nf`mXYYH@IrseTAATko*P8jR_xrxj`#jIf zZZv2AFKn&;_oU- zv|6x%{2L5xYz}|d)PQ|=tc%8UcYffhqe5R9+l~hMi7t9H2YXD4IMB9B5b<$0bE;!I zN!wJJ0~uZ2bf5_&_Xzlk7_m=acy4hrw6Me!KYNCkpTPlMpBVPyRM)-AxgOYV!$Q^L zLQ9L8ngaa6))|4aLDsGhNCG*)tg`#YU2*Gj9WK$j_pIxX{QQHju*RQZe|43e)HGLJ zwFmE`tO-%!cyx_>jH=;F_G|o2>js(HQ&-V7vu`RoDT8}%U9j@2B4PNQ=zModi{z)8 z3-i=G$QAfe?Ch~VwaMw+%V!r+j6;X+T!LlQ;kMJ!y$JMs8(B1OH~k^a?Vk7R)}1Nj z$$M&;?=_R-ao`gOGq;*Xd@z$%$b`kr{r@cLnt067cnfW$!bnCzm}?@OdR zzhFJ4BWh#6yLs#APrVeY+~*&1$3NQNe*4_u zg!8l_zK-zh^tL1l(pyU%oDN=QhkQUZ#6)TA{`Wk0R$J4X?G!6-zoVZb6ajo$l#>C@ zQYvi5tzikBeOjusCrl`Iw9m_4E2>!;1z8eFV&L0p|}tJ zZ$gmn#rn!7QGDawLfgVn`4_H0Z!FBxt;H7DdHOjRgfYV7Yf*OSx+fCzjD(;-vOfU^ zndp7IPejum#aK-BD+co0Sn!woU*KAC$&*aka4`3Pfw>2!K=p%Qor%c;Or*{0)Ne-n z^i&=+DZ9%`d%cmTU zq+W%R-zoR{CDcDR3_*IupX;4B__*-V9%9x;vUyB^kzv7x=A5vFPs?ljp!@0^5;GR{ z2B@=lNI7hN9Z;b9PA6mM(t}1HxoDDL6h~pOl|?PXFmlgxaA)-MyYI@99@1_9S9RL| zsvXFY$HLjvspc0CuO_=6544hfkv_ zu7yjoDiE1oAYi50Q?pvDxVltUYq)=E%5yLnLLnN<<+{d~fWvscA)?y7lMchX-te*7 zhEdu3&JJ_Na>r>WETENDhOY~54$~~&m~ylnM@%)MJ?d~rMXDEL4`4&dzt*Y9Ox-bc zX6lil4Zk6cal_-LfeRD$zz5`uuM=ORO1m87$zR1&XVtBb%U`5$>6LQ4_%s zzM@b31{EGe4uz(~F*x}ANlbBxo0YT7AWAUoJGFKp(PEL5<2ZjHJ@-KE3I#Ix2aNuL zBPVio+eW~{iPhyf*>Te#pfVbOs_I>&-gv=XBM%A`OY4R@@(4fWaByVPiSgXvHNBWI zimX$DO8-6MGM#tJlOHWyEPc0vvEP+l5?;GwQ~MADYUYY(+hL{it2+}@WKO~4T1dnG zBA>V>y(iE|^sJ&tgPuMRV_(>^FkrD?ux*fIQpWT~zGRXK-B*bd37{!_%F*;I_w&ML-&8i|Q74j+0s@I+F1_%Kh{V@B`GV}|e&JzsGQXG|?L z0sv)6ADwdN>U?QgStXH#j}7WEGe55=$2Fr637(T@)-U zD|<39gK&GK{CV;qko+nD?hCq*w7k4kwi}mLSxK2({OnD*P`Kc6OZY|J^bA6FK@?}o zO>RhcI$~gwqeqHbit2np>ZSVjjx3|?ufN|PDQ@-#Z*8P&kKIX@y%$}wjNr*`qP@XJ z8Q;Oz??Dh*E}r$gREm;7bZ5*f19f>2Fl{R(hKe~Xx>pFZd7?)8#Bj}95f8OZ@ixcq zful&6wrE4|@<39Pj_6U`Nn&TWUHM?`>amGGfs$_3612c0&iF)BUO*v<$hKDhfIcdT z-_|#1O~MzuQ~6~4^NXkJ=K@x>pDzaK`8$NnSZzcdQ>*dEbsLk$z;b5tK;owb^s|rz z?O%TFpoqlFuwqoJIg?4RYG7U06_LTi1~kXgQj4R%$E+sq1HW&EB?5|z{QbAIn|T7KPWz!`qDW<`CxgdbqJ zU~;gEDLxAmyUQ>7;F}I-$|d`tPD|Md)m1?uH^B}$A>YfSIQ`TObfV)<%g>;a@gB%k z81!sBKPCMEP^975yyUQOCCn9=d4%uyjp7X%#y-8Pt%rTqeu0%?2sKq*oU#0O%uoL7 zaM>otgcx;ch1KZ-W1p5c!#=C^^OqN(Q4C8zGR2iyiap#R zs&fc^c-wZNA;hdQhCyn8icA1Th)*sH#W4O@L@0`Xp}HVV>cT=5r&Ut%W(Oi;lL@O9GZR<75- z%X8O-F!9*0H4mYp?R#YS=!v=iekJ}d+abi=UUIwHd#rBi)QYxx=v-h^cSMUAl3aPtMBj%p4=)8 zMq$X=4TAR;e}bnm_lw-NXf&=RjVUDbsrPG&c3uN0Ukl4JIuyz0M-i=o98(uUiS$*& z6w%``7=D^pQ{1W_@+iNA=rWV1ra&`i?HSo%j`0G|Hjd|~?VhuXl&pj`idu_=620(k zC_Z%W_CgQ`hi5p_6!*wu*W*wTvXP}cs=-U|1?}D7ECZBK5ReJuvCSxKm4vC%-+cJ_ zWmb9Hq=JQNTe}sF%gd+*AI8&U1|oHDsY9+_?VSvae70_S%x2@8@;5ld2B5GBhyBb@ zX2fnovTKp{$Mifs1=A{}bt2Ag8zN;wZGdE-b+IX+y4%`_T6}SCS4A zTyfeDzY9m9IdnMqiqrY>tQGn^-ff$cu~FDx^bBf_Nv}?sqP52wi-bl3L-h0oXJtGiv8(YLeKhEV7lYjfCl+}0u5bT^k0I8hChf!C9`uYy3 zx4x-9E+4f8zaxS6{BTmtV9A(Za$0lrNGrvwn|Tork0*{N(99|)RmPv+FG#ohMwc_A zYti+avp7x^(0&D4#Nfp(=qio1ihV=VyN?iMUn1exQcI>~c+ zpdn1g?zB8!gzyaW0bYim2_Xl^`<{T*`mScGCV^09!p)YoJ+_LP+8||rgm>XrqkL@I zx1iK$BAl2$CZ z!5?4=`~hY((=<~rKpl1TM2OGkh0oe_DDeHSrj#F_+(;xRizb&5)Q%~Z;(JCLuqKY- zk_H_%u-h%gIo#%1)a}ig@h-pG8tJ6x3%XtXQ5wJLE<}?SUv_qX+ozSL;v`7{p)YZ^ zs1~`9{)n(n0b6Nh%A%*|2jBydH}arKuz-H}?EO%&^0UoyMRm9=QCN`bP}EnjTI7eu z^gE^EvwkxxuBvQ^?T;V1TAb{zo=tj+Cu`0xRD$l;1XFJ$UeB%|J6^_1UukiGW< zD-Wg$*}g0~TEWH-z-l)>CrjQ&xUHfx!OD(HRdJP$6DYCf_!jM`Jq<+yGGuA^<0ThQ z7IbMybn{6=UuyKoykZG<8^FPM>e~$FkB2}+=z(IGj^%R?Asf6(n!4HunDA_0S8vHY z=ChcDZ+C?Sm7pJ{blOeuTy_h`Lb)E1GvcN(g(GB}s5UH_{ZG2NDrz1-AS#v8S$;GP zf1x2AD$&!Efd#eLAnNeHRZKA?hUi4CK1{m)NmC}lHL&`3vPnKJgCJ-5?No++*%)M<%+Ozw{akk z)D2m^y@;iPlG}pN8$lT(X7I}(UxxnjbG3Caa8G~jPaD*Fx|IwFjjQg55 z)0})#B8G!hwV5z*Wg6Rrj&Orb_`9uk@=`yjYU**US10$i|Rc_jO5*0kh z1A6l1Zb@4Y+<&?NK?xotx}a`G+o$bAg-GbCBSaOeKHJh)RD^f4LFMSb?ZB&cZbsc(Hqi(E%TTw*-MSF=$qJBJ4T+hW{8+{d>~?XDY$xJRg!g;rarO z1$?9aby;x4fq9DCfjUKG#_)SVT53bph$h4;1|IApYr=wmUA>MbGeTD-lvlqiF{ZOO z{DIg*XUt;k&W9)C3?4qMvn-R7U_e<%jF4QFBLw9-Yt53;`^8C=3hoXev5?sdcTNkPbw$RZ9+Nq(XgTE zjgH}2nI02~^I+2lK{k!7LqurvJdVgH`47JQgV#=OJ>D&)mn1{jr@z?YSVsA)5lWzu zg+H)HQ`A{o`;B35_Z~qIi;yyQ(9!*AS8IE@uD~E14I01ZE;wF5==cX;q1a2&h3h|n zy_x3;gr2rg8eeTS0wa_Q{qkYWuj%XW$ZJ2VmrW>)hx}m_yW^3whxaFuWZQGOc zNuSN6SifHOQyFFic#(dGZ2kbQ*MXuE9O_t_x93@vZ7Rzvk95*92bR4))=V-M8A0<(Z;2g?>kvCF_0X*O(**~Oach;QP{?Gls8!yhBS;{# zO~YJ6M*}*=Pd+!kK1-N%W(bKSd2!cqTGReCdg(nsrS$oX2X)k<0ume;P^~2E|Cm|~ zV%o$AMYv+3Q)lfS1TR}8>XYT&!?j#$0ByMDabRG^@QG>saD6TwwOF49uy9& zP}-Rvx~@IP^|`V5yH#xw!<}g|LskV7JN8#TY&(rSGCO=-16Csn8=Gccj~5ph$(iNu zf2es#3ZJ1<%=$7_SmJpUDE6iqywyz4Qf0lp_eu(pBx>LSk zwro}q+0rYyQEYm3mGxTOj8Eawq(CIu4tLbY3wA3?iI@#nmyw2JW*bh1+^$)+h=bB1 zbe8kC`02%@I=hdjJZ3CK?JBEkX+0fNliBLY%}ik=?_Lj{j2$w0x4D%$26tpl^XHzjH>q+@ z;)mH-(35qz4=$|Dx=NJoQKe7me_XZ|hY7H)ZMe7M{Qw?D%g|B~H@h9tdl#L!V9Puw zTv;)ldGF8Mwi3+vk>1(^}|L1@X=uw=l11lC&52O6EKKf8$(NoYWxabfKNARE>mi1n)mF2 z=G%sKBtDTn(k$s4cohOXa@eQtk0)cyGH?jsQrRr=FTzA-aC$8+TA*L=e7@gDxXsrg zbp+-T#=7!$j1fB+w6^*%oZ?!AAAkT4IUi+Y3-X`?Y7N~Kx!pMC{QmuO6*$BFi|Mcc zvbe>y9ui)rEPf@${^N6E?z}WN&vOCoqMaUjPp1H`+*)NZfJHf=OA^3K(IvNSGT$&D zsSnVhm`i})p5qE#B(HoG166@TdMbzkh(m{hI|kYoHD0k=gzY=e!TVw8u0jd8vUnWE zX8R$KV5m8bfn~yPy*~>KPmuav;T1)9=O?JSH- zX+@s-s@ckcGresDhe4VUGg77}kcKO1ALgruM^i6GrSA@A0a2&d-4d=EJFg@OZ}g1n-x>kPW!FK~N#tWvvQ06(|sOsd@G_&As%)$y`# zy5R?)hyMmLHLNsMHb|KC>d{Nb?5~et$ft=nQbfPdjQ?Utc`x=4&0PUh!%wP0>7N`R z9yS?Jj9t(_6VB+hyR#0DBR7kF)!K^?e8}sL~AV23;~}$^Q+d0`Ev%#lTTM-H3^qsLuu_}F7@@{Lt)ZwE3f;5 zQ>DbpwHtx-Xr(>-WTt4B5q8hqAC5V%&8<_kQO;ppj*Kl zc@|>e1-MJl9z}PpkW4<>1ks!}cX?;=T9D2BaZ%MiIBGy0))f#N&PjKx^PC=x7)yp=#9%9p9PKH4{j8<8cAKLcNngl*^z7$ zIs{jJ@ruA^6=uLyBUq>mtBe=@);Kr2&Uv9gvHi@sKKFi|LM63z;yWqva&4k}H~ha` zN66@zzz*}M*+#hS2-gjthTJ!PuI1kTG48VjpELF&F@y{`9M2Kp?*hz!`C5HvX z7mArrOk9I0)XCZT6V>uwOI(9L3sN&Ras`g_&&lf4&5bLzSm24o#Afb=GPfndYfc}1 zg29R%y4O2t$cADUdby^g(F`Kpda(}x|ocj6Ad1hL8Twn{Tdlb1; z;RXzj`z*g4Y20j41gTTyUXq}Ck@0oo4#N)s)ZANMQHEH+y(R+b>sO(D0$WE@A^v&o}0w<4R1NhgtYi|0D}sOd;pc?-#Bk> zjqNm4A1js=ilg7sn|!T_Db>U12Mbe zf{_yb?9md-hpVm%adR^Y@g;SoFeZ9V*e&05ILc|HPE)nPMq$G$e!w&)3A6GB&Vr-o z-6k5jl@7HP|Ij%@gzy|?i>LLYJXr%Sjnt+1upLdRjP=1h{dP+vISu)eFTYtcJs*HH ze|Hq-MmWwD${zSgT^V6dWQ3REp$Xj`l_wOM7^wadyd-*$oSxNT>;@ZWCq|^F2PT<- zSMk@)2i?${i?h~pX{oi6R#*I%S1Zqs!LE?L^s9g9a{Wm+{9k#Wn`T=h;p|C(a#cB) z^qG~$BpB%dJuQrJyNY|sxe9F9WEjZa-Sjr6=e#3LEB$%8{VbEca03;)gJR++$w`Os zWoKI4H6g5u*psBT8~r55?ySCDeJ?equ;a*On`h*lp}rojqbEr=S!*IRRgrV!d{4&4 z_pZLe!wHMN`cFGFVNY&$A9F!kPf{0Ca`K-reUUq=ScRzDmqup^h6jAb^9(d%?-W98 zLl?gmWfJRtU|qybCwLW&se%PpM#wfBFNAa&%NClno|zvFq(3)%7<0ePavDqT_S5>; z(49gBnWhd!;+>k*)_#(!uBprn_M7B4dvZdE{fRYLGPU=R(S42{2mOH6T1|UHz4`U+ zk~{orF;zB3;!Hi#*|Y)SQ4-SJ9(8%B?Zf`S?W-_>C9_kRo@9j7CSCv&{`MExPSbR! z-bC(Cs}LIM^-K61qd8olxr&IdY5c7_s^)*ElozA+`=u^3aNmn#b&p819hiDQ0S=1=XjPz^My)%IvtzWF9k? zhKjl$$X(;dpblz4>=ssnDLqMojhE*0c+s~e=pKkDzxY$vdmRc6;Rl8S8#Sg=+%w~@ z=mbRJS^khtDN0{KEk}HQ42thj{sPSe?jK9w#H844wc;4kcNF!IAEERCqg7ClkMVn| z$zL8ruCJ8NHM8K$Xw$!dJGY|YbEdc#-K_H4Hg(G&Gj-7*hhi#VcP$loX1d$8UFY2r zh?PsfCIBVV&#Uq(H>N~Ie(q| z0neNjk5I?L=>6F8D%uA|*xj8j7iax{h9S8d`XAoPvMh!rm!{tH1!5ZmH;1sM6of@_ z4}0q1r#YG9tew0!p4JEPsL0P25I;y6+|xXL8$YE{VBDal6Dk*A+v;R(_7-?=ZyIXx z&=IFw@1UDYdSTtR(4=Op@a4$U=sI>5V@iu@OW!MPb2A73hnz@TK{286S>hqLg}+zZ ze?V^fcV5#oZ}Wkr;_7CQO!9K(*}!vd-d*Zr9z(c24kyIn@4zn#_fof85F|~WbkEPH z4UcG_hnb?`e}|WHz7R5Z1opNI@o?X0}i{TAY`HJy-5Xc)E{x_FHWH*#<2Em<zgr}bUN4Ey*CTxWD6b1{i@H&Ta-7gd)`~;38AA{5EBDaoC%5hU1S367!pG*&M}pFGSR(Pepov3E_O!HJ^iWZ@!zn3& zi6r%!!~EJWUQw033$P;4HFiE`EFr%F4Ba%6qd{@cFpJUekzMzfVR3iFS;Y+Db_r!3 zmW3m}&@bjHs59Q{o>PgnIjwX7<0!{}w%7F6VxNF$FRmWUr+)x9k`;z`6I5iGo&{ia zU*}Rtx9hF0I${!^;ozuqSX!@pw#*p2EJ?CdEMq#e8qu~OjUIUF$l<;kk{@vrKnmT+>Ooj+d=2r`F4gjw`He+d3N_ek&km zytL^1H5+>I#?sM(qoA^ysbKQip?#-nj-YOE zpER+;SAZiM!^oLRn)>}u^GyC%oQ1!$_^J8#(#1(Cqb-$l+FRZv1Tj&wp&{C$uQ5XG zMHYk(^fZIY1JX8JD$}Cr66LpX`;;z9?_TeaBZMkuZyIdwp^H=B9xkNAeH@eX?*9A4 zunrttVwr9uxyX7af3c#JyXYHkf7o?)G`!{st_`a?}cap)c`x@N#Rb-Wsc!$#< zH}UO39O)VXHm%ozZ7TTKD^37;r09`NY9!rB}KAGV>&T zgAd`K_bSk0bL(UIdatmkAeA?fvVq^;e>BSdX&au~xQ=MHRQECK91r3;bTX zFN>d!6P;$oh@Fx`(HSH9q@V_?80gvp8i_ogT(2ir_4d+bqoO%KM-C}`hQ&q#cN#)> zJ72%wt$(GVlsxUIe-vo$!f!_V@*zALAm>ZFHuW;qE>pMD#)d5N?gVan8ciR<9lo!~ z_^#xSH_4ykqK0|!p?Lb_6OrwL;(VVM$y;ny*PEM{qr}__1P;E1=;R=@^3@`;F{1o& zW*mubhWnE;775n8$j=))dNI9OdT8#V8F==UHJPV~=rr?+Y~$)OlCEC0$wPUx>~l=h zJpX|J-Zm`;ImWWdSL&qTPMrg9Mg?!39cDFD*U2CZ(#wNG-h{CvG*K>1(Uu$hUR?}; z_=1xLpkmAknAa+KMz;(JWGNDm=Ff8_7^qjyfsTt~%95_BcmI`q^PhXKfluK{ zk@l|0hke7MsV!FcJ{ zIhA^`lz1~$yY64FsA4;>>+d&sC3ZaTPU$y?P{wKP+>e*Mt%q=D!S{fL&VBGD$Gc}6 z2D2nq2VIsy){HLz1EAuHAO4U`BS!F{Zd7CM5_B*xS{U_W^O*w0zmyJcqgP$)J<1SVg|z{GrT1ZIZY#d4;lNWb%JJ**h2y5ll}g1;xKbz0F!1P8csw7PmW*A@{V$f;1>sL9 zI}y`jjNm*Nc(#)8=KGUG<58Vv$7;HJGQ-LH8q!m%(3Sz=1gn(Ss12l zU3@~{bC^d(7(OOF(JmMTTbX_!;r6F3<==a($-k6Jn)Qms3-$hMOsK>wU(WCZdfGUH zlO3_H0Ws)gQ>%Fq?f>rytFGhu1%Mk2lW-NVe zp9n$Ij$h`VdDyimVw`T(^iQSJ&fFin==7+-tGDNgmhi_J?C&6o#xGhJ^!HgHF5}S4 zrOc^zn2oYjcd`5=8ZVoS>}y53v+;56mI=G)vj%~nt83-)2}^9%6Q z3h-$^{BtJ={Il=NJqt>;%bo7FaUw(9BgM;lPt$k99mA1;9t_xk+f^3I+o$OhWdW}H z$BB`1GUl}{KX{GN{D=yvG6(MaT>U?(&ScGhmP zNqu94dr@b9fY-Pw0qDGa+aU=TjT~#v_;{6=@}M2 zBdqFvgiu>XZ|%s>Dl*v~ucCb5FYqc-^7Hb|!qEV-zd-j-$vQX(dKp?;i}32?8n+Bc8yEGpo2c`hDvYsenP>N0x-Vf($nHI8 z$I=Z;tgAI-Lsj--Pqk6SJYel1_cfWolwa1&u=oKGlnGxS(YpUoE;LP+o~s~^_FF4q z?icc&>`rUkwKa6c);Y4`-MTxJcPqeoXWjSdSd}HX@tz7LDv4E0v9tLHwc{nb{xOEMdxg*Fr1>W8RIj4EcxaEi?)a}V6+N{ zgzn`YhwkZHDF~=<9ks#WuUKW^IV(8y;c>JR_yVGM4Tj6!($^+N%CXLJGEd~c3v)J; z&fAU{_1aogKAJJ1RO}JJTfjZIbkhCY1d1MItim`HunCLM(aEG&3l%hJ9*#D8>+`ug zjfU-4&bWQ4C&*i}k{Vag>n+bJTJQuTrw;P(7~8*7!~WObU_Q}QeJxe?ZXdNk7x8u< z!nc<0fbK*M48r}uUS(<`rKWH-<^nNLhDzQkC^~hk-V+G=^VFzKg$0_A=5Q!Ud^C z5kMQm9yC~AbEDuvA{@mTZ~A7y8b&yoSF4O$cP}h< zd63-KHRzg%Uy;ke1NKp@>@)1DCohQyC$cVtNBSfDk|(YU?$ChcHCrMyvNo7LoBrK_ zMV3w_=QkJc!e=V{X1ZHxhs$b&(^Jl6_7G+>UbX~y+;}z$%Z|k zD829l2tMNtPVI?Q#mg)%8Njgq!h|(K{sy57akUlN3k5cQFS7er#Bx77ng31)d!QKM z!JGQrCi}wyUeG=4$H`GW@eaf4L4eS+bLs~9=g#-Thi4?F4es3>Lcutqdq8ChhHFtq zoqT$P=i{1E+FL9vw;Y}+ftD;G2KF#Ck4pl%Q;-SyVYEn9wcLM$O`;#q@vb!%WQ+}p z5so_O*D9p>?y2}4TP?3D;TIKX!zlXlVJmFT| zCZ8=}Z2TstlZm(!zPFJJ8T4_`GEVQ8Gte;4iP1RXJJb21_BHIZK$Iv_wOP}6RI`$0 zMZH(b0ZFwXk%OLnzw-2`NU!KxW%9PEtO=i~^D{mWKooBV0mQ(6)atMh)qj!x)Cdk$ z#B<$~q*PDW%}86kH2!vWh4DsN(uIbPNHZ1O8#h66Y~cLmIk>JOC!VHR*`I`VFmF0L z%etcYAXl2E{J2`qhC0B|Z_o5!y$?=D`UHypx55;+dR;CL`^;ae-Zrx7nn~ehCxgN8 zz6(BaHelSt6Co{*KYChgi*^TmQWB4V&Dd{h(&O{71p`sv%CCB zW^uap_w(>>up_d?ySpfh`CD<1{`p~A%!5}98~)Nk?UaI?@PHM1_){zoe=G$)RKTF^ znJfu|xeIPC4jc(U;Rp|i!Gi)zM)mrX<=EHJaa}+ljF#3RIt_QFLops!Z~6nk@I>+l z9!+Lx7rBJnHn!g2DjyX?RhAN*OOxIZJ)kN?IZ;5LM7RGNoA}Bt|Ci_-*y_jM{ z*(N;^yJxj228~ONEUAtz?VEY2W%*Y`{}&;KnETa%bt?rWe@8t`V*) zw$$|Byv2(+F}X9)D9GLoKU%eW(q?ph1K9fk_)ir~&-a^-3W`-kZj$p$K4o%DyPWxE zy+l69-&AB&1V6E|B901k)^*dgl%!gu?dDUjj!-j2C;;CKDu3Ej|1${SUy44j(>-Qs z0g?I_Y%T-y77}uZM~M$c(+H{n_oi=Smr#Red$saX<)0eK@M6gndwAKLS*vZUR9>TB zrh|PC(Oo+&9-Ufkgv+c%D{zl;2}{ygkrs1~Z%0bnVY_^PC)wld*%+y^uMT;7%tO|+d2KOp->zTI6qA~C; zocnz0sGK^~%*rh?8T#JsygTnrS02v64Re!~^=O{~Y2SmG`bqV4GoOM?uakFh@UY`% z;J;#>U!AKfyqehJ<<#AoU6H3VCmR@NMmmKr))obkvh3=MiA^D-P{+Og1Pl9kFS%D2 zXzm+me&#;5^nQI~RDBmW-{sW;{33JbDtkNoL+E$KaF9pu^V8HK6!Ev8*$ut|HGd>9 z`DdOp9c8HDLV&ITU}enYizN#xZ>XM#)HN>7N7Mz{Pz)#QZS&%ZD3>JAu_g-oVFuHh ztgNyCP~xR;B)p-ABrya#w`XCrB+W{l$8W8lruw_V0DOmcnG1$^Gj64))+nRKd!V<} zBMh|3E*3{Iz?l(=7ZZ#3z9T%f1dhdoq6`>x=FCg{J*)~*| zsWRYuNuH&$)MoW94!%=|z%^{!vnh(W+Rrh#7Pwf{PySR}^-2_ja(Ej$ZRPQoF z=dv9S=^(E3^yj-xP0;4&Y=Gd~Wq)yg=9X2V#d3=e^w|frB{BqiX`6Fj*RtdQQjUA z17wP$;4J52gNZA*| zyE19aZWyNfUv(IYUjWfE!z8b0T(F_GW1ok}T8@PGA^R)XMMGd90${Q77wxEbae|)qxf_aV0)VYJK)K0AKkcB+}iEn}a zZWnqH=`ncO=(Db)nL81CA(+T2^fa%V5=%pOTtkIihF9jV5^Rt5zsqcXK@|T(pyV$f zMI5zw3EP~KTzTiOy}$r4Wz^h+Tg9W$dO!pGr2^3AiH2#S-s|2N=u7hgTP?w?5+S2i zGWf7wj9>Jww32`cSqD(Wu(uO&8Cam-lvhrn$RorUp9DW`QXaKLsM1FzREiIKk&a`g zWC_RK!0e+f!qckLHcE>GCI=L}p~At?vOlR-AS)umrRUTI^gxnT}Nejh#_s@}Z95t!=`}(vKL(JevgzPV~=jQe*!x;8#&J`21R9F0Y=$G~IkodgpCuav{2^)hy$dw{2qW&Ku2x`vEiGC~J=h(0 zDVrWAwi#n-=iOnbDO+X@3pmkF9XB@(jN*Tt=O^;t%MX9MJ7gAE(#w^mEXTYFkL!Yy z2+`6y`M2TL>e00ID_%+l(|rFDDLN+!tX^*ItqwnP#rWeQgNYZZJAC=5Viz;&Tm_PSy|e^Aa=-LQGiFEA@7E+&b&sR|4O> zi)(Y)!z+sr@+p<(HFN4R-tR z|G)bFY};+)h9G(O1V?$w^zfKCBlRG03{&dQ+(Zy*$>Htqlzi3&emC1Pu6H^S%9Oegc1KY-4-v#euO%&||?qJH%cpzt-Vx1!vE_boMV z!n3(Oj>nwzD0Yb^nnYea6kAUU0rY*5_b+j&_QPybUiG*r7?<9jFM)As!U<5NPfcok zcu)X%t4lh9TzO}|d<&i|`WM%ZT)_dIoxaH)h$LD1@RV8TAMby#!8T^Yvga)4B`flj zOXLHJ2~l>9sV#LC^{H(d{^w6>g5NtDIp%UAdU)>u%gId+b9Kgb7uGgh=bif^twELt zPc2n9af@~khPmcdTKe8KQepRkP zOTCWwZ53sMkjc|=kgV|2p69Dsdm#)ONEG2r&CGOx9xYWYooO@{v3u|o02bTyHM?zV zEmwdw!`YM1womFdM}nl8hRv(g`;jxg+H7s+;Y;PEm7{(@OKLuUu~&i zD1R-@NfC1;^#c3*f@%mNBO|9Vgge125qzGU%aRwb1aq{AHV)(y5~+J68pg43U`q|JAy zmhK#TUp#D*zu0X#E3dbJf`?=N4GPrEV*dWr*h*h z9A}Ngf;ih|?5`DermDymK6X4dJ{R-`-7r8hcfGu3f#PXSjt`1;{@h{gg1u(m z#>uX7N3IBYI9KZs?(*eqBGpTxGN~nn!84C{|J{>H_BdlL(w^?*`8oULB6=tlUt#S6 za;NfB8$r+bd2rKmUbbpV9hPYF!#}T!8{TSqDDT%?D8SBAKXrbt7+Fb}C-&)BjnQZm z2t2B%PW=#q*7gZ|(LkNI|DNDHIo$tbfR74Gc0kz05a&hNSozxQu4Em@ld^21wx^^; z5}B>&gYa+K z0x9{*1uPZfDWZJw5HWkj{%*!tuy+aQ?h?G3Zubc7SUSG3jWB*_l>PL)u8?i83l<5X z=WBoZ{LH%}&w;AE%uLqQnkg~^#Jqv!*d|yC^O_Iz#PR{|`tTGZtNj7bBIrSY9uqBM z0Ko8pK~Pj_{6`bEQ~wD%$*;@%nOmy508c8{hL{&-6db)e5&{Gu>MGd(%kNGTG`!Qy z!L=V(MT8#OcBZ(^YuYHP#PH)lEZ)$l^SN}$blYCoV?A%c85J!nmnpTseYv-au|;nI zqgkXE`LfC#V2}C6ur} z_GShUGCkT507sav=$tV(fs@sC!k!EAtZH54a9o*ui&|!g((ePjs9)M%D*B%UJih7} zv)yX4r>lz5bZdQs=faNiUTN+ky55sdtv0ZEqZ-$*DTQy8gExFFb#gc8-yPAtk zi|Vuz6@iGnPsoNTw{VI`+))D8%ahudJp6W83h`&{dHhYRy+bMb!oz1bqcFle!!eFK}LVa|se=PP{{$f_Yx5 zpL_+*qB5xsy*E`)k=p;H^9KNN1uYPw;;g>B#C@J>K3Zr;#>Y8>Nlqpa^8l~T=|B+8 zQJQSyy1P&4_r@)Ko&BLZ?eecDYb%X;1k+a;Pp~(fHv2t6yqgPr_0GW1#}4@ybKt8| zlo{Zw-D?i(?arwJR=-{o{|rr4^UsvOLr_t0FCb%lwe?ajDP&yI7huCi=OAnfzk{+D z?{4bgkRCjEe2hOL)1LVD6DMJxEI&N98-B>0wdixBe=+RT&WzI4h|ZQJJCrRK=K>s@ z2#R!d8u2e~gUv4eAHcT+o*|p(4c_^Vl*V{Y2R8@Un}h;FfgO>XCwyAd5e6%e_-B_* zOwH*E;&w^s9QdyYYKInri)8-9dg9M6C+2|$_{Im%xB1aX30_e~Oe9)5S%;4d2en*_8+v42YH#l+u$7J31+P zMib;;nV(X$GYn!<`i#N9U-AE!kN<;6%HIy#t+68lroCZrkPYayJalXiYY$`*M_mv1 zH5uBQ*>AWpjunviWsV)9Vg!o@GZgl&NdsBjws6-i56#jGmEnPcv;if;@vTZ+h!R^O zLGrAal!@Pf*clC48bNM$z7Mt))L?|=8yR8{8(&79Vd(9$^#g!JMM}_xirM%d%kxz) zZ?q@reSI7zZi((fgbSRf?63(*?K!%LXQL0$@6vCLAaBORNrTxUHJUflp{6I?%?!=b_Sn}i=K%`F*t_9 z%#P#9((~&z97N_I;T_XMpGebvU;OVdI`P0sQU}i&{+g0|>{gc{O2r{!m4AHz$~a9s zHsIi2mmE_;L!e2lteQ#6FA`Siaz_6lUw5ATIS>DJ$3hnpG@wY{{vh)Qp@Z?jIJ%d0cx3V-)k8Um%?_0s8XAHMOF`jg zY1(QPaXx$FAPv%|8>tmZs=Ki1GhMEEHA{R(Jt*nmA=(yf)?(PXLUX$2Tjo8;+>75D z@kPYH7Mqp6MjWnCn8o+ZsK?&kUYg1(m-wl&0qd2%B08~On^9)34!&?^ong8Tp|T{g zIooeTsAi;>-d;#Um4M`@7^3^<`{Z(67dIMN73hV?nO&m@VilOnFu9 zefO35`)cjQo5_^i7*ix-46ccha9xUkDg+Qh=LA&<#L~a05FBMu_=?2e&4Yx52?Dq1 zN?+|vBfga}3zqbAOPGVNh(mFcyX;G2GmWzx^POHhW`2q5jRJ`E@dsfYh{Gc z`+l?F2)56;cZ+11neWH!9>gM%8Q<>lOdog#f0O&&AQBThye(2U_se85_n*%0FGV0L~})7OjvV-ut0V27Q8 z%fURS+2jAU_tkN2Zt1$AP^3kRl$0QCXmKd++KsnRXmPjV?i!?c2oS7Lw9rz#xVw9C ziWGNuPw&?`XP>k8%$_-Ses|{F-#vH!Am0}f$d{F@wchu6pZ9sv(HwE`ddb+xNQ$w1 zc{tD_pLIH*&$5G{5nCrXht>nx=xM!$)eOI0lsU_(kP*2_PO4ppgM_Gd%`HrZge*~ zssN~{lCBNKOkqN<$h5!>N_CTUbnR1~Y9pS)C7^*JbN=ri^6It8VnBLZv3P(``VJk& zBLr{UuHyay0^dWwZ#AdAM+<7jL-mO@-&|QOHZ`Sg`cMi6zcxL6ajL3#HSh}({Y+Rz z@vL4E2-xe-ymrHOyukB=<=gf3inIGh@W{sXKGE8B(eRtO`qfII*FQjcwBGp-1G~Ny zRBob1SHAg#XQV95-PW;uZ1Rp=zh^n>Sxt0uIyB1dA`)_tOr$fOGQY$2;>CyCv8e@5 z@3Aj0eQw%9fCjzB$4F-t3GP^0Hf**J!E$X*R33rOI7%yzB4V-=mB+qDT+Clm)` zP+`-YV5Ue~x#vu_j(XkyXhE}zMywAS^4W$%ZiWt#9>zH+m2L~bZ_t+Iy>krC*Hn@? zSuEY^hcf7pW#iK#*$>63R4FgU(wsBa7aZYlh_1>ZOV{OWk5QJ(gE&Z@&_qhP5+pVh zgQyvU>aEHwRJ-=;GKZGP?Bq-qKzL0ix{<=}ZUz^rj~(A-v9@<4WPxK*Glx%*8%!D} zL*S=H0uyz_?jIt#MPc{(jbBxZX(M|Fuyh@yAxkuBl+T6b*pgT`oV7AHp1OAsb3_&w zkmATo<7|OFgd2`Z_V*&Joui7M|H8T8fP+RE+Cdo8E##G*3W)v`BI~GX_3*sJJZ)z- znTOeW$i&c`*F|gsgZKwoP6jEI+UI6-vdX+_yh?ykC_<@U38y^Iop9GzRJ0-Fbh08v+Q#2D7^0zI4?@(ZiAo zP&X4HFJ&(1c4Fu;=$?JdIu5{C2V`ylW!lFdKUhmH#{kN-g`I#h?J+qBgqHCiJNO?I z#Q*3q?SwWK%WYNv0iM>uvoG#Mh`6YrUE{;f^lMsYX8`A{B&zdM% ze;~0QucU=*gU%{_@Y4W^Ll74}f9Gfq4dAd&sV$mPKW>;1*-M*6U<-@eEWxSDH&s&a zq{O`6`fx1B_a5BOXYk=TxSsoFt>l8m#{i((85{w(FMnN6{%;)rkGoX={Q9-C+h&Qc zET5&}1p&>bvbuKJy{a<=Sm$?*via7)g@s|D3ssaHN>haJ(K+dcNp;*`(oT@zbXGc;};*{ z3pu0pW$O1?r9;i>MPBotez7D%UK$ve?Y-b?JWf&622hP*5&EBLR}svU>b>pbw(PqP z$b>oUzv4!5D1uC5bUAY@I5sOewELva`1#1uK_JjE2<>_+?>su+eMDM6IONMAtf6%U zg6MHd_S2p6TQ=IsL-ZJmhuH7c*hO#^3I(k_=x;%GR`bJA}PI+|PfK3npmmb5jtAfdkT zGEfkt8$~J}=BZ3bAU{$#dp2^eIX-XE2y_+B>6DQ?j)bXI0pZ{8jn(XZ9-sRph&GJG z8QH!oGmeTFy{?x?K0w^xKzN=0g&OXTdIRl#d1FYlD>bXig7Mv|C7~QJm@0YS!xanJ zKq~(|D6&$@8&fT9ATY=9eTqmNw?kx+Y9sZlK`*w&P%mLtd|fP20oUX2)$6S%>z+iL z0=hYXV`M>lt%)KA6q`Qa_4TUQaq1 z_hX2kiF{`eU7}Rafd)aeQGZQdk|ttgL&ENCj8UbU#wzz2?5uO;mL(y5wkOik61R_4 z-vktCo%_%AhX;}0lTy$iIKe93JL$qb5DhT^I>9PS@uuyFcyF7!@Tp*+OaWzWKE5Ie z4rSSFr@_cPIVV#_=SNF?wOj*6i`fx+VwGAH{CBhmY7>3=We_X0JW}A0CMYdP5zD;j zUfzSC4Ex*}Sx3i*NDT_+&K%J$AU(FjLJ!+*AUS6^5zHE6&3uHd~`;A`JZ)>f8 zAz7oIsPn%Z?odwr*o%k>I-EmNYWkKfvTxtLyy zxj99L=1|k4xy>&LZ|MS43jSI->>G56NhQT2CI?_syl7Mfwm8nGe=y~Lo%;VB$A5SL z{PUvGyBfI7o=}8)E0I`7|H7e9FF3&rS8!-gfM%m%3HfQ${jCnwlO=DA^GKQMa!E{` zjKwZx*NhnuvzT%#L#+^|a8*(AI{IcV6Y^XupHfTQm;Z4AuzN?P8$5kQ;o%FK|#+^R#>E~q^pbdQxnIqi5c%giJJ<|oH%FW^TJ!@`$e|)o1zV!^OSV_t3OtX?E5Xhu zrg?g=dL6qPyN*gqoR(;kNMk&$G$29CeA9VlQm=3^XZVU$EkV&42pG`=t5SBe+>QB7 zUEc7aKSszlEfu&@;~ndrB)tvaf@n~mO~WJ4v1xvQ+#W1$GiQw!LMuZ|vg|SoF+E~@ z6+l4G0MisRbLNQkQe}vNkyz#@1%ViVpSGOrU>S*{m}+BdhB6&Kz-KquKWJ^0Rheat z(p#(it`6)5Uqyue2!#8XyM9{JC&l!x)lQ-U^LT(?b=!?v_kwi!@-)DH;VP0*_w_QM zBBMtA6|qz~f^o(2%+;LqSP^5L5@Ha0EIKc3H2pcBX<^L7I}32FO58MYuYX>nU3iqq zvfy2}w04oo{>frwJtq7ewfRfOv>LUVFF#j8ZGHIo{Rl5THn=UBiy|Z6h_U@1GZz0F zVa!!w8Nl0zuU~#Cl1;HOO|dejPbLf0AWl0^8EoG1I+?d>on3o4#}EXjoktswe-N7^ zc_jROHiEOy8Q0m&6MHURV6;?0ZG8NYM~G?ReI%J4OET{L6*g#Uh_9~}7*Lb~BB>)k zq)6Dv@f9GcC}?TcW-nExLitltv6~L*E;K>C|4EQSSZKP9M8~*njokDC(SjqC>yKpx zNyhso+-?hI$ZMbF>@AS`L}inrUZo)T>F-_w3SV_z9*h)7X8qzG6NL9Qn(FC{ssFbo zzLRxHXAYTSCc!T%FJ)=xK>%j^_0B;7OwHQnR4XPWYXJ>K0-^6vAaD$T$7rADHVlwy z^&W0|f-$kS)YHtlJ)Ep&PaUq9PA+ahE`KS0II(7@nR^wC^C$JYgKXt z>#xA(JL&aRNqe`*JWsRJ(V6OF;4kr#k=sL%+qeB~=!E$O7&`-OXlsV8m*c)oUR1v^ z?6YS=L%MIg%+>WOWD(>osPW)&R>bLjHruyRW z-)Co*$M^5&xp-(v`mDXSOFm{)jZhagC9f7|aAY;7FIY^_jYxSxqNM5o02lvB>?Q5f z)3Y=$XvbwIws`I?qE7!hG9~=fU;tBEym?Sq__=An_k$IeF(0Y1{ayc0Gns6bw`nt& z%F<+AfEZeZ{7?Ujw9oC+l~#FerH;U(p(xIf)*$Oi#^sx_4*s4Kp@UAvSKuRlChp!@ z^FyAzV5gkn&nsZYoU%-&ZjI^hI=8~;bJ_n*>Gtp6C4c*OLjQ$IWA)!MNc&Z6_YW@N zVr~)B-%B`u<`)v|Wg{*viQKnQND{^v-z-u}0aFl>-Y;q?UZ!8;H(OXFiPtKlpkJm$ zoz~F#mlsY0K?haIt{_Nu3!bx6y+(nFcaAGn^O?j&t|OHO&?{{Ma%RR97H(L@E4pIzI^gIX*QyMQ6DEmx=DXQmYTzcy!%z05Wcjy*nQyJ z^E-Ei)`K!@)<`E(Sw8qYZZdP2?9vxdjIOlqNYPKT`6E<49U$Okt;?e8!|izho4rvi zTyUSmQx(pg+Y8gn*b%_G4gka%w}uIB$jW`bcmbU}G?unkmOnt5x|Mk~@9Q32wfji- z89m%S;9l@N97}4Lp-YT$ES-3C!dCv6nzP4K1+yht(w;7A|MOAe~)5D5) zF}sN(%H-?=#1-QF7j`an8jHP(IGPmU0oBuw=>1x|S}VQi2m5C0yFu3nf7PSy&dJ0^ zDt=wbmteIxQCE6FDg0%O1r0xRG(egb4ksFXln><5pV8mce(Z?<1{FrG2Oz3{siKv(nnthmjy)ZI9Ct(w=q9?lwx{YL{={jmFgWy zP*xk?@j4ZYe%&EoAo2jKYVYgBXE##-fj^zpc6Z$F)|)rvObG@Mcmn7g#sn0=?67&l zIu>WhDveIqVVamqLssI zOgjwi#_ZxuIvrfz;35LON?!J2GY z-1n}}Qm>G3m6az*d6(~9D?YTARL|KbAFgT(rR_3YNJDFJ_Z@gH9~@2oxvI?znCFv^ z_CRXL0*x28(7yTjtuZOUP!}4lYxTZuY^3nJ zEVaEH*WvSq!?AW<)hm_9BZs;nJ6w1Vo#g2Yf_Tvqpy$bloqS-*ASt`sWv}Man)(4+pU4Ar)~^F> zMYo1wH)Lban&u8MD}I0~8ZWuG=&ntEfOO|p5$C{cu7I81C%Abeb@IAy%-TxFFkUeQ zwQW&A`&K{styq6#>=FF+8S%$_Tjt<9A%L*kJUvh_JT7!>X7BbY-K=C3nofL*eb?`S zfta=frZ^T|O8Qk&Y*MUYrRxQ)kb+jt?OLvh z!NR1PpghZu7cjFJ^XStLfZ~UU-^+V2)}>JuzUvp3b@?0IRdeOKZb{@b3z4`p`1kp& zsIA5o17M5p+yh1SNBptvghCfGnA;5V4iw-fA>wPPiaOa(viasmnr*K+x0?+mt_$-W zeHFzwWEC94ldY|-3i5t{g1J+v34)6t!n!t=?XPqC&D!g?^LI17Z5!nuI4d8ilovaP zX^6O973Y>AiToXi(0N2&4X`VJYZ?D4Nn9O`{HZO^=qB3rsfWo+U*HC_5_0xack$rmXH+>JCg<<{naGh0)k) zy0Kcvl2T;*MT;2u9YyqH@~wnyX>kv1)wI{2z8C1k9S&t#rnyO#grkA&ADXMEp@ZP} z9O1VtIs@oDBdErbm*1MKV_|QH@g0NigbW<6H1gJZ7QON~S9w4+D?VJVE3Ke#)v=M6 zH9m00lZV{5y?$F>ba_R6$zic&`MbM}uzLyljZcK=u0HXi>W6=TMxq6#=s%S60o!*v zZXWF34!i*4IiV9Gs$w#L$iclIW^fuD9Dd zzW3UFyY8m)=j&lLMdVrDi#}p$rRNvIjF)JoA5f=9VXa0uh$ zP)9iC##pc^de{hhY@JipKPP*@%`~F@161AGQg9KsJIY2`b7Xt&`hA3Z+FB)vb`J6x z&CTQ)B$q(q^$Au$v#^xMSnd0)vX=u8fBQqJ!!+IKJc#`SY2*(OC*4g;<7vIE>KE&5 z?-7erK6{dlkz~j#z&XA*;k}CYu*(hZ>x1VUn?&l&oR~3mPSNiY%%rTFM92@TR-}F0 z)-0-7+@=aBns9}}+>2}oSrlm4iG zzR6amyFs*TGHcgctuO(03liU!Hqx;oJD5sG(7skmX8f!I=I294l*MK<4DiZI7Ff?} z*TmW#e>wLkkW9g8@G%LNS^f>G~H!TQ-4{ z?C8|a52Tit0>xynZ|ko=ecVu-&xm{Lv|tnNGK@PmhVo)jT8qxiKQQ3 ziI{t_pG(>3+Z@^x}@!0BLm;)4lYyK;a;7UMA#0 z!u8uSy~``nOO6Ly<`T*dNjBF7TC0WTVILJpo{llJw~xVR3itBgEUiozr`Q*Lo0G*Ee0-0mqMzN^tRcW}N~ z0u{p-HSnz&USK~qoygxs3>XeL)rMT*mg0TVO0j^mTEKicsXJTp$)%=H<^OblZ~U{ ztN9j5V+{!SQRvg0S|$>By&dL$EgGHgUHq|U?P*8&fR#l-5vpGr0b9m%`~k9RJho8b z?_p2Psmd!5Dw^p?r3%!n(vngNbpKr5_g?ofVr1oL+e%}mV4Fz6HxS8XN1*)_!xX%h zl=YpaTx)%so$mb;RB;JCHqL-HtN4_i8Z<0M448b@X*V9?KR_SGzc{m9JlGc98frWS zug6ZoA8gTQA3X_rkRn$VB6pfCSC(lyjx%-Bzjb3X@gj-*F-wD~Bpkz#y!7qWm7jJ4f)=YpiQYs&}i88eUQRg|znxFC$rAdu6onmfa+ z+5@Zu-NK}mjTaE-oZ(Zh%@O5DZn%5#q5xMvj(Q1FQiHp1D z7du6QJ}_)QbD)V?$`-u0v-bhaE`tNX>yet!j!5OWPj*tP12$dxprx@Ga9;uEJeT^E4FBG7yJ2y zwGO$f$IIjEGNJrMszK@y)$%oO(Yn~iSA!ytH+8Mscr4r^?lw?B9qrI`+t8v@`!9|J z@FGv+Zpy25nm_8a3Oe}i`Z$QbrAoeZR5-x@z^x;(xFEwgOqg{GO@-p+{1GypSm%DL zAZgO3XM8ieRBn2qf-&7HRxz5)HB5whX<|3I@%9f8=rRx>f4Qs9lmt?XE-D_JC$5(P zZh)q(ze|&UjZXh6Gi|i=dHnjYOtZ@CQcl8L0H^_~SI*oEdPLU_LTYwVTE<#p{bk6e zp3capMPi@@4h}ThB|Z@O-?A>lIadIz%M8EISW7m?D|1BW>;cwghea@b9B_?K8UR;I zTU&zxxcW}!Pq><&b{~r_?2`Jg`;*CFrv5E&S00&h6=P>yz{v&<*aH%J1n3(5l|

zFAK*d1ybCZrkPrtwXA&>D`W1NdlGsO0dACc;(~qG5JwHWsxmeWP@u#h`Wklp(`@>W zQU=k*L3Dsylu=VWGXzg0Oz8{YpCM3Aw{t`aAf@cPq@lm`thZ~(0GToNGNH5tQxHcg znG1}2D06d5sby`_#!Oh{!o=2tV|&6DI{Ud$u*HWDHEeI`U2e=rR7IgOz+Q&%3tct> zNYuwfbmieAILaWw)07KWN;03NyU|uZ|D;YRtI(}U=H&ea;Ca<2qbN7?#EU` z`_2-U9qlmaEw*<6sx|E92fU-(crcWBW!lMxC@S0{W8U@xT?;m? zck|%H3u%(N-N`dp)!DD z8KZm}raBT=m@=>;p!X_{z^r=KY|vb@hegZ!gv*vC{uD>wL86-?16oKk?d1h2%*0Z!&dJz(GA~BI+a^QFR^&#yESl%L8PwBecf1dg0apOR6( z@xI>=W*HmNeLfIjcJ-i)(HvaW!%@D&H)~PLHDyxU8&~45F>|lDV^?e|5F^Jt$6tnV-Al^C__56Iq$m4L*hm*+7Ivoh+vU~-F3o(7;u&P+`(Wk$wI@9ubmTuN zWNfd+6|0?vYoEd*9eyYj`xNm}Gnwz_p?MK2QxEOY! zhkJV;Q)I1jbEh*IlxwwmDMFTifXE2I5M}>3?q17jQ=b%8^RN_%jU7TFwk z{jR*(c#0<5MrEdwpQ#FCp`ML6#%DvKeK9^0v|!4ucl*H!ixlAn3TswK92Fy}R`Qo# zy@**iEHi#(N2FyDf;&`&NFvu4g#J@p2j5rKVE=K$mfdzsO(ARiyxrq!XF@1 zJx~=C_b)GN#Fx&Rk++8&u_yM*Q1mdat@881iTvC4rB_~5?hk9}mY-KA_slcJEHA`b zU&s*Q62v++pA|YQ$URj(e=~hNaXqN{i4~q__$K?KHnVxB^uc3{y-(k_t|ofeE)qp| zNq>OKw>(PTi>Wne9XX1=%QORZ5WiXcu5n95Ep<)!C<;%n+HdV;4pWAkG^kKuEN6RW2Uc634Z;;(Q?6kP`igv?c9nj~D`5rSA9K30~m`!())? zhl(qj4Cq<98gbvgwDvs&4ACLC??z9rT&{*l=Jc0mB~^B-tA~|s8ti|C*KaBzk)>C! z9Cn5;-(3QxcFwRXpf_+xsxt4vV5_B()0w%egRTVb`y?K<<}M6(FSM^l(GF1v&--g4jxlOU92tG||uhf|UqMI!D zQ4NDAcn~l!b^9%w_ntAIx#E5mSs&cR9Eo!D!^VoEbktO>7}naI6GE<$e}|HHX2*w4 z%yFeBB~NS07S57JuyZpE5(K|}ll-~EJWpQNyqZbJ#aqGhcjNy1p(?N(#FuvUsziBp zGd>xeUa?m4$41Kp{28`V8|D7iAimt_?y#668PQFGMUN=nm*Tc7br_B(dl`?o?tkHe zI=o67ARvSF38Gpm8n3vi_<_uUd+??N7`+@-=ND+s&Y>pN$=E$lCyk!fJ76RdE%OS8 zQ2DA{u*ADPz>#$}>){t7!_Z%|nIYbZw8+L{GpkrtRa`MjO?{L?ohvJ1Dv{0gAx6`Y zfr)or^{ePIg((1FMZwm~3w=0$0x^`vaydj9*tsTjZ)#oKNtAMct1)U9vZ+l@ zrC6~%C|}!o{8%+by-?Gm$gIHCrFQ2$@jD0b&f)>FAwA#9y7 z$$ox2zif2p=FU+T9I7%Agl8zIgZa&a*VcySzQ-UdyQAFJP+}9Jr@g=nezaA6llcKp zbz-}8rtkI5p-}qZ5hnQNJ0|v$8P!EzMf~bGZAjOlHTm4b+k>BE(COx=buE8M6LcAB z_W{-r&M=4Iv78a*x=hVXbGowFd#>g%wnad+L?yZTw=v28#`!;-cl7VCiAe`9dwf6^ z<7ipxcww?|l~Feee$Khi;iK#}A03@^(bAAxbmtrp(cIQipXm^FcCS&|p@H^8iiKsY z<_X@Te+0QSVhg>v$=0888cekISyj-;pj+8&O9@_?2Vpkr`swkU%eN6ML@3;C9~iSP z`8?Q9VYfsPdk>2dr(+&xLr=PuL;KNB{e_o3JAjV@{CKEd^^#1*Vr zwkC{h3Olks3EU0j3gM4ue!1?8eo8JB2*_$@-ws~WLDYNSyf<*PqcB&0Z{D%ZPw@&4 zv}hGk)&2CGKuG{|dm%la<1SsKlhpFu?(}YZJhys=&Q$l7mr`L2>esA-;r&yjgl|gqwIp+& z7zh{8A^-`*=q{LARlJnEbx)OV2u;{79WB`?l}U)imO;Lx^1I7{u#YCm=Ylm}x{cc? zE1-X`@M!rj^JAvI20E{2@=ot%zC28c%dCnCdW~W5LAO0*A#(rtYR(CrZqc@lYb;ONfg6{;gJ=>-sr9kqcq@1?6ppKZkAOB1G=CWq6b-(at6g_ebvBpEw?ZivPxy9@ z^={_I&W@a?pCY$`x#%YBasRE5O(}i(DD9md5!vMVr<942Qk0=vbE(DWc}~s3){sKFD)8wFi?&hmLW`L8+3-K_G=7WWJ79-fYUMGvWAKdImZ_aK$Bg_AA1webvW-q?v_tpu81^s!g%i{ z-)pt-^EU~#k5|@a@d3WVGx#6T6@LDXvHoV;!@4fvUNW5|3h>`k2z3Ayd zXJ}*jrz>XMPuR(XttoqOvH=0yDE8*9m=2Bt73GM_`h>*UczwEeYA-b<1O{|6QMMW3 zg%*dF3ATa zc*vA3)QG0rIEML@CeVce!()(x0w3wN097Npv|_Hzj`a^2)ph>e&juN#vgYsW2MF6E zrG?Z!dQy{pSl*7CUN1KuRpa$ux?$|D$gAsQCWx;_hd3Li2TbO059nUY*S&xAoqX{& zb}unBV6cy%NBHTTw9b!4LNDmO^DZqs$h{IML&lWtbT&O3119!`sq)%k*7ne6kfG8- z*GDy_a0uixKe^C@!@C6zS1N{;yo%*LLAT%i!VbR|!tMv(Z@96n`0Ct9;N~;e6Sl@| zXB^c|Zz_7$338!qsDAP=Oy%(~yN>ZNjMizfgz=rGY=g&`Ng4e}?1$QFc@)~@khX`f#HBHh+NTt6|aglKMdZ zien~ha1bSt07xKaqKH!{P(H9jlE!OEs`0d=&OPy)H24otx<}(VtKPD$(tq(X(&gFL z2UlNVrc0vhR7I$}2^SQjs&5h(Ux=zlwOjI>Vyj0W>TY2=^k6A7Ddfn?>Tpds=LE{B z(D%k?J;rfC+QS@yT6-ee|HdBkk9^KQYrjGRQbI%>5bxlK#Bi73_B7T9qiSgQASIFS z?p4#F^Y7@~CP6za@KkFdAcmPw@}zLCYUx$S#GA=pcofqaT)2VIzNnEN=(VOz))ZI6 zeKwDrGN;6(llToiqP{gz^I*xXU9&HO>)2qV+fbL8;1}&GLqT9!>UUiYPV=pN60BjFmhL zF*YK16^!ItWBMrhFaxj&1)#4b_ z9z{7gMxpiF=S&4es)@FA4$Bh^CUunRZa=LN7NL96_@tK#ujI<5z$%M}=(x3!nYlk%1x@-W&OPQan5TC47RRU5~5)0f;jWe8(!IJBono&R*y#%J^?X@}H33w&XRp-YW`E4p1x&LSEfopr zcHdk1p}9qV*9BVE&~eYGGWqC8zey86s1bfVeI5C}@6cirbB$s&^LoRgE~`sl>^a>rV}#MlFbc(`ykirHynKn8+G`rYkr%PjZZsvn>leSo!+d1q;( z@~Cr`d(HDaH*E|l(tDHksQIk&LoBf46d}3mh!={swO}H8CnJxLcjiBw;B*bZ>UTjq zF(Ux-`_ey~l(a;Ii8v%DJWpVZa)tMdHPi#r8EPdY?%24khO;tnKzzn=bA5BDNMl6j zu{JU>coM;@To#?xh|p>K%psypT~AOR>8Vyaq(0Wlm~_N-Jv%Yu!3WuOqs`nl z?_tU}>gKID)J=)R`cRL!YPo##VS2Sf;+vt|Du=v-EWMijs27Es;kaCw6DD;T02$~cb>1;du~MI zD@T}v``!dA`?^$=6ZhmcOm6F%mo=^sD*ZU3PL0T(S&9TOZ&km=2|u9}pFe%_P(nF@ zxxRCF3-&CN^u2P1tZG*LqqHffSbrEqNpe3m+;0!D%jMB{!e|5V#8H$zMp zB$nnygPHE^6hBEG6X{QlC@c&>ZlCHy!{;KPNq<2Jtn=o!C?~Tkq!f4OF2xcCebbbJ z*uV@fQU-0`wq1f_ifh~FjXBHt8}O9oF9R}4epR?=Dc|^MsMU+&{>XgDay=5`yo8Nx zlKDb1QAA@&*+;6oxp~bJEqbD=o8~K)_^)wBo$#4{0my+Crq`N)I-?oKV#GPFY4K zV4W|1hv*jBtK=Yq>O%sWT{^^Arfxm`VGC1<^qSjc!yKt@w(RS;dbaF&0PWN018)9p z190naQtU(lvyM;)Mhd{TyNRlwxCOX}|Mtmhp%NS{R6F?uYB z6Y<*D%I#_~S(aGCYOMwVai@rQb~rp7y>qjQ@}Hy_JQ zF0DB3`DA?(=B2JHLwmJQ*=oB(!1ii%>1GfQmsxb&6(5M#vC>hj*(+Dy0W{#RHs7iO zrb<&=2iS#Z7YZs9XcH3{0nNMEH)0(TBuUDu78?l)S?m1@$;l@7oyOq@JD#n)J^*%F zxZWFujI5b4Ha3pq+xEuiz_jGJ8_J?BOI-4F0IZ&e3x^O5%AMitEY&=Nd@jre1Npa| z0|x=6rT@YG)^T61OBW5XH)f%|2*jqn_OL<~U!PfGBaG=Je9C zf*3xwI3i+16j&6Pz+z!T&~J7_HMk6DjQl%`l}S)-V!KSTzb~DKgV1Z3SKC0^$e+WG z^LyP@TLVwkc%w7sy1|7XT7xSVbQM}58XUc;NZwQ6raU`)DxKlmW6yV*Y}Bn-Aj=}6 zgOZvE7jg;MH;_6hejV3enB0ncf$GyD9lc^WYf4{g=K_ z&kDti8U+CP>gzxCkZP(6h2x%-pN!8OC7c{S6Z&gSr|V8ix`B*JA1T=0?|S)&QmZ}9 z-F)pLzu-T`RC1#Zl#4RD{^Ohf>kRn6eEcV9K>YSClH$$gt9|XZ<=B-qaEJ=Vg~*I0YylEJ~HJ*hr{~8 zuBD(~aG2DqX3$b5UK3?LKNiFv59H0By-9XiQ0K}sjPocO;Cd2WH)Ht|(CoYCkplUp zua`A%AnQ1<)l~1J(Aed`0j#7dj9sNsv?DY`6?D!Zk(J0eB7lkB#N=VDKL<7xuxvL& zI|e>P(*A3)3XS7X%FsS#sV&6Y_`{3S)}#$4tWMEGOhB@)Lhq8BNnmOu4QSAGUg_@y z2U#l4z0#wjO8~<%@rv%BuU@t9ez20h!$}f|GmTULhhFueb+}R5VJg@aSU+iqGpLMMaTy>YsZGA6 zKq^iLdQ*1IxuCU2rp-lWA)?aTwVZFp-ywss64C^^=W&b?>9C*XZzc4Y@bJD@Ke+~- z)t--o9fw4rCxJLprXS>px_z#PAG$neL0wm)_f9&>Fyx@JvTtiE`IZ}o@7VgUT!a7O z2-chn$}gYCYa!fxTJmse-jr__`!WEYY{cDcNp-7n#9=?Oj4l^_6+htJg|Om&OjCEe zM;vK{wh-gySeg?Miq4Vxl^L;mSfX?WRSq{Bqyxrw1U2i2LwH7NaAV3K8MOMyU`7RD zNsq$3g$PlN$JuXfX(HKWrI$fC&^;o*h^EDAYw3lUTQ5?YpwN|AeLsZ4F&3S0MPw1= zQ2ws!`#PQLky4Q`gtuRNC$i2vWxP0t%FIJgul-S6WLx-^cb+}O5iL2He3^fMUoY0^ z=6mY(7!c=aiXN{3HK-q;D;@nAH){3D?>>W7th*{hC0KUVGmeu+BHwa>$S~phVg@#s zD0-fxJ3)jeyqDCt8h(jT4Ds4fhRx^n)b4<3og4SdU>g7e5B&i;t?6tyK;?PVstgka zVfAVgrwSAsVsF0=>p?Y*Hm(gUp{~0DXmY%uvh_ySh4CQk8F=Q90c-lqa{zWn_|v0L zsb}3(9#5xwUAZXRRu6PT<@$Ep6GLeMO~Ylt;m%?;E_2qBBcvdcr3-gb zkeGkv{g?S0PvZ&KY%iXY%7=v}?p<_#S6NVUkgvQkl>@oAutyckQn@%p=5r>W%FA31 z2RkfEi;el^+12e@7L8u`q8!&!Z(w9uTv==avs$m~IRvOEdy!gZ-j3IQl6DsKyGC?!qD6)=&Z-=0gHScFrb!QA`L`o5vaa`mXsBc~q@C=cilG z@7qr&$C`A_)XOaE9|}ZyG3k6QyykZ~O)xK?h?1t?^bknp$fo`}?+?NnN)jnIEz$~q z&+xW5o+%0&&<@B0iSPLf5PA@)<*n*a=r!(Nf6}4|4oOWXRQiHV5nWOMPd0`)LniXh zVM|X^Jl;D$<{7@d63bQ0j^<%~dlV@P@&{47C4r6w1`bFpSrgsB;?!?q=i%_&dj!JG zps-St&r_Q+#^tH}vFyr2HC^ex_#9dAc?9Ec86b(*9LH~}Of5zmx0YdCZskC8YeC}f zE**xo%q^lh)~3kTW&Ud>c#-6}iB*odJs+Lp03l*h62nK7e{ez9hEzA-3n+b~@03oZ z4x*{mRU0-qs9m$VIH}0*X!goapVq!Jm`iD}3Z>dM;+v7Ok4{=G7Y&=jOo=KLZej zf?S=w2nl+dv4V?O4zR+VMTr}>0Lk#}eEGw+x{9X({$hsckP1H9abcGR$hlIUr8;ui z8^P)xCmVaS(58X)89bvF5S;{CdKkD%X%r#P3CQT*eh2hrq9bM3nTCa+`~H@Vj9aR< zteoWy100VH27A^bQV^I5IMhsP8E&S{nx=v16f)h>36}B?XQ6oQ#ekuQ0txQCDeare z&$k->7IEvhLCb&dx%LEnM5i*8jmx}}{EKlpduHfs2r}E|W;QGcOzny*qK_XRcIZw0 zSH0R!ABeUUV5y_um%yBom4{1+;YBtmv?#trCyvZ$!U7zC!N>(NnMsb4pr4}ZP#S+e z8bnaqeC0J?KG@NpH|GX&rCk)v-mScr5iYn-Eum#9vm zsz)H!J_@_%3x+Xd^z}>hj6X01wp2vj>$gPttHI8Rf$9UP#_N|DbJhTEmRj@!<{)pr0aL9^&otsg$~My{HfYrmBntzb7O*Xe#JCpQEGEq&b~z)HG^4+CB1hV8>}-NM@s z`8>&LYE%)I_tO7LC4)DO|{jtG03yP=>+{r$en{`Oj)VhqAAtrc~3Bo-8xqltf9=+>h957+?U z^K&|G+W9ZXdY70}uz4;$0K5FxrTlAD{`Fn?*9`jCy7I5p_8+qct=5?qZVEWbT7J}g z!QD4`mnJlc+)vPzGrH6@oeq7EmmC+Z_xjn`F&l11Y3a!J)ImbbshNfWhFu@ed@&?9 zEoTX>F0B4e>-=eHPE``hZQ%$!CDCV^d{2>P4d(r^H7yYTk8EC%6}MzsecG&D;lcx{w*l0^D&~y7a;X>2u2>OAN!&rrHoT z`*&gw9nY}8i?3rVa~|`Zg;PH1m7hJ8H#3-v`2O0QY8%j`#7z?YRdGb&E3|0!`XqsZA{6rd_?2D-Fk%KQVR zhTkUq|2qFmP2vC7$Alr~k9w>YYbxQ+un^6V5vR4M;+!NhXBf;GTAngX$UDm=x1>NI zb}$Xqw4}R`D7sGc^Q0)%Dc;+a%;`%}@6M6$cnokg-q78 z)0%Y85S6Z!de4h>(IvzE(T-XEj%4!hNj(3jJQvc~_AQkfUyp-bS@m%jErhEppKn{7 z1~I=_r`ICF@V)}@!fa+jW$)_qg*<8i=O=*DOc@$n% z!&9@Vg6fLKid1%vG6%mShk znNI+S?_ub4YB0Ibcm`_#7x%cKLv77Fh-i4Z=WsUayMO*LgT)-G(aGji>KM zCnDHa0$cCl=u@oFpvSbkt+n*ylt)-FXz)r}UaisDp#@)N#GzQufsV>M9!sR78eWi^ z#&;u|F69d>L1_!7ap+VXaE2J literal 0 HcmV?d00001 diff --git a/docs/source/tutorials/figs/qd_alg.jpg b/docs/source/tutorials/figs/qd_alg.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3300f074943a68b785acbef91effda141e336230 GIT binary patch literal 251040 zcmeFYcUTkM_Afpu5PAoR1c-DgN)ZS(L8Ms#ktQHTKtOu$5{jr8snV3Df)s^-NbiDF z1yls3NC{P>gA_6RhWEX{bM!s$IrlvGd;h$XXXaVivoqOiuf13KtThLp4kiGmvzj`Z z00asFI>8TcFhysoqpohHZ=k2Cb6x|0KmdSF`@EBzJCq3kT-|)U475(8O)s0F5xoEu zpav)bDFCps_4c@MNz)Jj4;>A4v^Uu4kpAcKeGmYj1OOi-wDr;Gf42Wu6tk^|mk$6y z^ugXTcJ|)3ARPtLF8)3qhwZB%&34uKkcPq!X)kbqAkBG5JN!wD|Iz198h1$Bxw_eb zeGbR$VdrXhNVkFXZ9iXokcOQH>1aPEdw-A~0BHdiUsorP-T`SgS9=?80D#jSw)@!I zI)bz$NYi;48mNP`G5}D~Is8Ij{e||i4*)<^?(XVg;}!@2fAW0zD}d#2ZqeW*%SkE7$w^3`0H^;S$A7%}k6!Au|Zan}4?b^SA$ObAJo~m@RN_;{VxpH5~w|ZUO-3@ITuGasYra3IHnm ze&L7XaJ@MC_;@IuJn8T6f5OS$_Qc_Y{^R)HcKAone^31KeXxXPT|96)iq**W<* zxx1mA-2R<}{||rm%NP#HKi4%#u;!8hHmef=Qy&`uTY3Y)S!n^7MHYAm@(;P4r#1!- zcb*CF+@I?nq`~`tTz|Vjoe;@=12cm(yKs=BPJOHwRT%Zsr0bT%A zKt0d`v;#drKkyM40VaSMU=dgaz5_oX5C{T74`GEMA-oVlh!{i~f`O<)G$7|829V1T zYls8H4dM$4fkZ;?LJ}blAdeu0kTOUOqy^Fic?bCnnS?Ar)**XP7?cjm2IYndK~F+4 zP&Mc|s3G(U)B)-V4T45NW1(r#$I$1{N@xqT2l^2@0bPV{!2lR7j01KICIQ31)M0us zGuSnl7wiTs29^SQ3@d@v!a86dU=y%!uw6JMoE46SOTd-j+HfPdE!-1+15SWHfEU0k z;cf5_@JaY8oJ>JafuazjP^8eIFr{#y@TZ8TNTGO2Q9<#V;v>Zj#dk_dN)Ae4N_k3c z%FC43DT65ql$n%7%4W)UlqAY61OkCXh#^!EdI%eY4Q_WHRpk|^Lq*kQXqqd_Cq>iJ`rLLv!qn@GuLBmWVOrt_$ zNOPSgoFyp4SITdA$lCW8NCmEEPWw;EBzPx9R^m06AU^Gb_`(*4;d;M-ZLySQZouNsxewJ z1~H~EmNWJ-eq*9$5@J$kvSGTx^pL5BX^3fynUz_JS&!M3nZR7c+{HZ4f?yG1(O|J- ziDG%e(#k?&g|YIpsLc9*S~t(R?;orV1ryD@tJ`$P5y z_6ZIchY*JjhYLp>#|w@@j=dw?N7RnkAGvd+*(vF-?-Sgl(=lUVz^##4WpnaQIr8H81)482DQb_!>z^b z!JW?C%KeRpg9pcRo##GJBhLaaE3YcA6YqWACf=`TcC;GW1)YX&L$4k~9n(JMd+gD% z-eW)bg!zp4BKU}WWBfGy82)Sg_xWG(uL|%ATo4EmcqT9`NG*sFbQDY#>=4`*5*9KM zx+PR4G%w64tRoyG{7iUMgkA(I;wkc2WZ*dEam;b&Bw12c(nT^? zazu(n>a0|RRISvyw5YVL^h43r(&b>NM%A5t!k~BqdI{-hPA;y#!lh*adx<;xH+}sYS-1Ct1X|FJneP5;`Fw< zqI#%$^BLF~turxadNo)yj5Ho-e9`37bkKaJxvC|r6|B{)O`&~GJ3)I$hg-*1r%-40 zto+%~vu)?-&Rsh9;M~-C(eqyCYcD`AoV}2AVN_R8*G;!d575)mOVS(D7uNUGue(Tj zQUBt@i?aq&1|bF=msl@ZT`Ict-SD(woZ*O(h>@?+D`Q4u3*$oLZId%5i6#@KCrv|5 zdoCZn>~y)>3}I$$_S9_4T*Exse8xi7BHCi`itv?yD_xdHEnO@dtQf6qtjet^tWB(o ztoLp7Y#!TeUDdgoadp*J-8R*B(GF*K-)_NP#Xiw~?wZQA#B1{oDh^2w3yxUF6vuB) z>P`=w)~;(`&%VCxtmmBXeBff@LUg5awRWv>V{vnKYjfvu4{(3yA?6Y7G2yA`ne4gh zbV0f@? z@T-txA>kpDp=zOzZa{8az40oHKP)P22Cs!L2&V~m4u2aV8Ic&V8EFz(8^s-kk0RaF zy7?@cA=)c?=$6v0?A!3$PPcpS$lOW4LyobF>Aov@H|6d=!Isc{PwHOUy@S|mvAuC} zaar+{@ow>h3D|^!MCQbxL{id)q{{o~`!V-7ldY1wQck60r_!YQrcR`tPpeKBNRLn7 zf8hAweXJR))s@0J3k zzNKHwtjh*poO|)A98+HMQt)L)1#3l2C8RR2a<$5_YNGmb^}Cw0HLq%wYAfna)aBP7 ztAE(Q-VoPF(-_rw&=l0P)$Gyyt;L~*^vdehNULe(&DuD^!`lLEd6ZC9PeD=y!3qig62a1SM#qkiyn(VzC|xFFJ&x?EWcdAt-M(^ zU7cC;T02-LY#=xCH&1Q8+S1?p^4<0OkL{QpL z1VAA$7!(eppn!u;5+oG755SozSdK}lQL$)a`&%)7!?ukmyD{_8-&@@=(|e(Qup$YO2wJ(rhn?l|DoT}AVQp)&DC z^2`M9gcee{fDNxDzbX&0dTv-N^M7!$Qj(lsol(-;K~&=&2g-XCldhXQaEKB zJXfP%8Jafx+P7b^SazZF;_})UnAB2{#N;rfo?oMAEDVPiOqVPbHJ75iObWir#7hP! z58e!DBB*le0q>;)uyZQowLk6nugR7St0=CdxZJ#7+J)IQ z3jeBymh;l>R}-iJf^M>1#8LcLr=h(6ImdgaZc!giv5oLxv&&!z(uWV2u&<7{mj`6` zZhSn_y}mXR%^U3Jo#MV6v*ZXojuH9q&SzhbMg{q}ddg7TqtwC9B?bWs!r^ZN!tT^t zd6N`g7gyV`au>2>xXmeLBj9UUHwC});m%;s`OXv{xZL|9|5APhic6lH9SSHO z#lf(B2?-@~aM-j$*iOvsOZN!vBl2El-oq#gRQ8mw;0vkGo_&@TWkn(A7qu2=jtT)2 z&p6;&QMV-GRUj4{edht+qYk$vw$4)tY6<$g8dKm&i49s8Gr}WVW?zcUjx#%Y?OdB~ zHeDt}Ygv?N8QIKhm0_%L!bsxv9p5P@Wp(Gd^N6%q{e*o}Bc-xWnWN$Dft&~cR`6fX z$luLewI1a@E~)KElG&tk)MX^nD3XcWNM|%SGO2m)L!Q46a8ZNp|I%qPAWOA5KRk7f z_9$IqSf9Wq;H3w90F)V>tZ?+%4_p@rE{~J?=uL1y@?$!QM+f&qgQo&tHzfFITJvl7 z4q^J$sUT%zMVd!N{YgX&$dalNCO@2_&6wwxK zMoE5EsVzi20QPu|8_9jq=Q7;ZpZK?XW)|tnL=s5v>xalkvVSUtO}mqaEN@OWc>0b6 ztgxTG1KHKXh@MTzBB3YN57><5yTtB|c$ZR4JNPjQ!~)!RFeJJ9BP8wpi(HC@I{auw);g~8m(k6g7?p51k5oh; zF-Dc5dT{1koi!?osw+O%x}36yiE0k+i}LMizx8Sb@pf{4I+%b+BX&|Lopx&xr$#E( zGDM=L;{m0Zzf+2H`_5BMJDSJLGqbKOKyCfL6m=-HhWWp*r4fO3H%$f}03WKzng_s= zZ-0Q;l-9n$hHO>R%o3q7r4YVbSyeIQlXmg>&U}_{oPa!-nd@<~{on74QDBHUov@8jqJty)1PRomPHEC~KFzRm%GXm9(u56Nh}Q zGI4TzdinB2O6lIy1zpWu%D$j}hN^}bKEcoSbmWGix8`VMRxHa_qdUG0(h7OcX|E7$IaMtcH@0O)N|dhQmHzO@ zcAMHCNY4)?nRRTlhg;So^d|!aGGK(cjBAbY#G^YS*L%F#+CuIz^m{2jDYJ>Kr{v8Z z#H-LY^YFO_y%Ua)6ipd=^#1kc0_7M|{WGMjVxHy#Jy6cI1Y!%ToJ|dDSPy zfkQ3ydd_{<&V_Wp5Fsn_d-r=Q~bo?mTki{loo+ksH@6+}dv}@I)2^ z_F=!8<>Cfbt4MQo*>ZQ>Yn|bqPJl!Qnb!!w#wnj@h{k>@xJIF~xds+W5hCaig624L0i z_k-<=IxG9n)oS%pc2RmzD<{KpR2FlH*<_9bpi`6ahtmP@II9t#11*!yK6-in?Tnu2 zvjf0~(hmje#A$c(BinSyuA5O}9wB zdgCf^VorcJ4eyz;0ZQN;`N);*ZJ`68@zMbhYn&CgcDBPn>0DY`B9P`fFO%7PA6D7} z%Nmop-ZQy$FW1Up-6)(>oaCKBV69%yZ|cD_qG>j)?vN?s)QNiqY{Zc$zau}TaMCuh+ZfSBWeeZ`p{vI8wVHFYSLR+$kOtsw62|;Zg8NaT zi?WN+t<+;Jmm;K(a9_W2vZK=M`CV6dU2e#POS}V+)TOTo`%2g5 zNxv4quHEoaXo`XoPBnR|miy}`3w4iOF}8v>hH7It2{RW1?8#pqns{gOrY1q3Cw(Rk zjRFPN*$e5o^x6}&O10k(fExLq>)HEWMFHL|w_b;>$q)2Mr7oY5j$w^gSsU}v;*}CN z9jwe>jcs3`IaAE~-Ts=JhiCkBgiKdEBew?N8W7wr*NE<{3aQqAL!c=|EVi^vBn!Y| z1Cb-dbl(edSD=33y`ODty5(;mO_}@7Gxx{t$ZiVX^le(IGbKtz^6j^Ba@|jM@e1g~ z%wgICbLeTGy?l8|{CPnn(&3n)-Gp71;!t|Xg`GR7gvw0EmhJFa?R)FtL)Vj)litERdM;=T0){s1l2TCQ23Ynu&Jh-#V>jJzjc+r+3*i}^LeD4Hz51c zdpzS!p5vAMAqT+A#y*+uk@a#1xBZ{}p;~5}&U&}MA8{+~kh9dJdD0VaSJsRai>;W$ z(kM%~5G9>lxEa)=2N>Ik*GC0W*bHjd{PNy=6K$OF70hhk!f4 zBU^wiM8(mkg*?ez7QG|3=j|pk?C=;ME7z|iY|?!{GUouO%-)k-%=vh#ddqZp*msPJ z#4q3gXYNFA!5RQ>a4Ecexw5--0L0H608?V>XVx;GR?c!c$yXb+x%f^n$)xBjCRp09 zVVgbX&!+l)HuN9vG_9nzC>f3LT(9)%NR;Z(3}HI};<~VlV@;cwdD!scgSwqK8^I?muR*J2Sp!!ZF3Z^>>}vJ9|x% zUFf_k@R(`P?<35X%3`DZL zXGkaJ#|I)1380&Xz4YVCX#$oS z?yr4_$BNE<+x)(h>?=6%e8GXS`)>QUgnkq|oaDX5FIrDv9=fplOxIVGPgEPtERc>| zmTt2Pj!@A6O#2)8E;|coCb}fl3OsRkP{Q?z>U1{K=~Y?yRBWW)3y}^{@EUARjG{d4 znV3Js-2(UPmBCXH?RPwhXFMAIZ*IqMD4tt z63Vjwa6j$@`gtpA1x-r&bPR4Amo_KhS-fhZ#@r$FxOv%o=BXO5NXu0Q4>cEt40h#p zjlgTgp+6s;O2v%KcCHXWCo;nUhUv=-g-p=$mVPqt$e5MfZO0C>3MpniEL$P0y~isa z0vedG+hllZTQO_1tuX;}br&A_vY`8!9YfG&ANK_x9`@BYH&A%9cAYtIDY6h6>iNk7 z;Kt7h3w#63{xxSF!OC~-Zi0pwgp-07b@MSwQ^FoYNB>8?qdREF6kRmnl>TYCr+eRRSQ3MXt-gpqJ?$AD18m-DJaw6$omLFchVxC3 zs(T_Mmmyp1kDlxslnunbpA{0o3vmU}&3Om{-=v%8s?HC;C-Zz-=&7(V5dh9Vc_YkC zcERg~=D-%3OHA6EXpU){O}#eN#^3nHGKt5^$+L`WtblL6woimN#p40D`Fp2syOcdqz_jXosr>X8+UlocjgL0|geSNpV{Z9b$1btlix zay5TkT8g-{`K28#Tc4YJ#&>>5m&;=?onC6lX%Zs#FW z;MqCH*@t{+&aw|n80`Tjhn@9YAKpM*L&QLb@m}IMH?8d zGomNfWv=|p${J@W$*oP!6rbF^7%-No2#d(caJ!LfZ;}uJDAE!MDUxLxEY+O53BaWe z*Khf;8R5Iel{eQ|dM@*wO0v86PLRu7VVE+|KvxsE8d^J5KTh*<&fqa$ZUlry2MmkkdHfokdVQog^nCx z*o5@`j+zwHv$p#^7)f)@{W5uuxoilJ>%ENos^MY9Oh%b6q|ELOu&sAT8@#?Bt>h)| zru3qjwDL$~95GY_xwFGvV7or+~KCrRrsnrVNS|JKgABRa?Cp zI^wEie>0}EWw^CJGQudDYN4IedSa-**7)gzTpeHLZta}dbmUhCY9t~;rUkA~Xu^iwg0XU}2yCI}Twa~V1DX2?>c?AJ~hQEYURz`3oe+iF-)TG8!^%_R@KLFYefSY;w zVSVoVw@w}a%x1MmVq7bh#;=8vEyu>iPRKj(1~96>ulJvFh_qduF6ejYPLqPfYKsPP zBYL7O?2?9rYO&$j>stqaOW5~3An5)FanUQCG&zYn&48DVa1MJ*z>lf(#!_6tT9*Zr zwa2*Z^?BsoE^Rl}LP#q-Ep^Z8jOsL_)$S*pE$u?mNos1Th;=uL1W124Q>jz@>VqRON;s;i84CzLpEzsHfkymqW!bF2@dc#D zcH2H($o@0=Nl>^VJe(^fE&lOth5{}?yneju8rlI)qK~LyubXm@HhxgV$|7!XQ|Wvd zUm|1}iQ`8q$IDy$F5$ROq!+y|LO(#5sE_G-crZ|XWuWTB@K-Z{sqOV{GYDW zwxT`CP)qCp>`D~h5%-nK2S3jyo1POItyQAj#le7?AiB`;p$DtPY_%FPtKiEo zGw0460O9RgWgU4yDDt_p{`}hRHUqOXrLL~dJOCu#h|Cerk!=SR#9}#ldVIS(Y^}Q^ zNi%7Rd-}cdO;?HRtFF6|*83w2&>8%wd7^YAofIMLb~eL@R>xFHrBf~=R7n((OxkEX zr6i+ERkVxlyN+? z+t9WKhQ$TDA-~i7N0{gDU?8!!#uEXV6|`}sg*-+zWRBiBv|ZL`OGAd7<+%(-`vG_3 zSHhtExr4mT?U9p2AZ3Zo>^^l$t4q9mM<6LtXF5^Oz!CQO2K`Q`tLxj{mcTAxkB>#_ z13CqsrHwx6X?e@gM@gu(Dtc_yOe6u^)J2eX&kpt=Jk5IF?QF(n*}E+&&uv|9hmTeR zl7e1p3eEaWKA{i=;-$xU8D;rLB{$urecdmMV0^wZ`rL32I9AO=qeLsWW z9soJA&c=Fo!LWCZ+%S6p^dH45!(N50?YbTSR!j%LytCEWp|_T-pr_m8zPEGh08lsE zGse>thCWlzC-o)pk7WeLKFhGhbRpX{WGot-X#-1GDIVYX1p6SGOCX^o2kM_?UBxhW8{(RbStb^t`#r)b|j z#o|HBm~P6ThKBSR%?I$K?C`;3?5{#Z*6eCW_2>=&8S`(DuH7`bZw>?Z8iKdy1h#zu zW1)PKxr7Yg<$k7-vxQ%p3DfKs+H6tN9s!FM?(HYpb*>$`a65TJ|7DcF!P%P#6$XZ7 z1x{p(&1Eut$Al-3=F3=0Yy8C{Gu@HpU=?$TU_oZr>9wtfy4b)y@ z4rEyu5j0=y_I~M1nRG2`GCulJWMl+p(bAX17!@CQK_%WUQMNBN#n)O|8#y`>=jP!- zN$I6Pj0*ZzIpl1YzkO+WG(Vo^k#%eTezocoA`XYBz9f`xW3Y@ff+y+%utXgdAb;p) zh|ZdL?aat!AreZO?F=l%b3F;KJEeR2hYyex&uGxFb0`0^Tt}u3KNjtTm<^8(Sjc#1 zzs9Q9;Ce?fg7SvPySTTn2pb<1o=eb9EET_qt{oG)E3SKwlJGb+E$ z{g&7xk@`yUs}j+dQbbHMm^`<`Zp}`kyhf^l@3q9>g4fn{v%VU_Kph2gk&vh`Redtj z>|52Ej_dK!O0wmv8>{qnGkqR%YYQKq0*fIRCj;trn5xoBjXatk0n<>WXwqyBBJ9;= zFyDd&*W&mz7^)SG#TGL>%H}(h4U{AHd2Q54E-!S0EX{FzP`L@Vba#e#mm@U+U)6h5`8cKY9UfkTVbpdWn0*5 z0*5^wR6ghWgfM!xz=Pqv*EB2sG+h~TlRNIw^S`XsSxf3wRF=3yZE|-T@2q?MatB>& zQcFvhZI{tAXt%H_>)JG`fmg0%l->monotB4($N~t>$=hO(R$c;Z{ zvyB&Rix1{aMJ{DYdT6Bt(6%_dW_eN07K6^a4J0MKB4klRYFc2ZSV!34?@ovDa%yo) zQOS=$_I8MpDT};M=hysC_@F%#sehZ?A_@}9D_@rmKufmtp@=O90AtA$uOYpN%4R0U?eSx}RLXR$156{@D^?=`c%(G17PcV zYHC;)&#oqrga<&AfD>(eR`@iPb?mH1LZR?eT}4PDrOpK1x;FbnZDqM9>F!J2ha)bI z(ngT4x|Bg)ORd?X^E)#Auo+#i*|ipgz+>MDe7*f!1$AJJoy>{sjW@76P>&y@>)5m}zwU{k%O(+?{R~%y>cb*ak{d_>Q1CF&l9@*gvcw)&q{jMXiPU3FU_>hJbRnf5z$)a z5rwCuG*4=#1C;KL-+mC9u(f5VZ}AvXQ3`MZ59r{~tdQD>e41UzZ$^@qpGVvQwE!Npj+M7=KFX`YKvO!S-1 za(*`8l0p`)3b~n#)ZzAMjwH-wIYQ(11yjN{));@1^~j=6E7s^MMyMV?5cbXx)h2Yn zgaOnh@zk3CE6nCR&)1KmY4^*;AL`=Twb4RygsfXC2$g_w*dp`%cEZ@(%!E7C&0Pxj z@IX)^?wg7>svpsBmi3GyCE981BEk>T)q;T)Vi15`)~gyY74(}I(B+gx{jmK#x54fM zOfI%gE#im5Fod7x2|vQ=WRJC-)Q5i~w=bWsOIeldT)CpwBGM8aL_%i;K4afVyx=`i z_X0vIt_6qPw@0IR(v3M)ZcnVX#)bCFCJ*MsE@41aEbXR zxvso>oCN%Gk>>}Dfahxy(8GAqN4|0F0BGtu0A3rL+->A;oih1xCU%jpqs(tsT4?k>TE4p_TAJ#siU^eVw-lP`iy?`X z5j*MjZGPNT6hyz>a}ki20W#qIBHS z#aKimf+le=Ooy@w#hQA@+q|&0#!pkm7IhKQ_|1#4>dd{ml2rVOGSU?vB3p{|4dY>Letv%R9Gy&@hqmegkayjw=uGNG zRBjB_LPA!~L_&N3zcP~sAiZr-RqC2_?x++JGG<76>Y+`FAsztK_SyUU>IXnr(g6_j zoOmQe=~f%@`yK8&1>%*65s7gRmyar*NgGG(o~o} zWXmjGHT8l0&2u#nLlzwjz@Q_r39TvoTdhgj*D12t`C_`+W1*RK#;cQa!v3R$ee^le zWqsh{hLkqOqj7h>>SkeQ zsOEAyx8V;aMys<8mW->3ms$03>BC*<5W4+3FKN%_FGsQznpYxM{%=(|ut7FVz<_3b zj@$?)yZVP4p8c8;Xs>s@K3FwGMS{Os8sI^#T`1`9g9D=8-KY zta$b%m4o*B5jKYog{9G2ANfkyQWg0F(TK>qGalOLC{eb}@6a2xdyintT^Y2I?S>Qm zH6yS%yx5^i^;u^0f`?QEAB|Q>9TdwLKexKC5{p;9M6%kyp#^#^i=fxib;YVhZ)YQk z+{kqR;9_g^?t$?a@6TW&`Iew>*sm$cO_~|i<6)hOVLw2Z_=!Pn?QdW4%7>grS^tsy zIKDVfvkRjBzcm12+2yO;nS{k)x?llg+x2o+rR4kfa^n$i;{i@E+0NC-w+1(Z3w?E2 zf&)jm?g(=N2}$EboZj_yZ_<)p+xo*`Y?4=17pKL|xmjr}dLq1<9oY^D;Z;iN4*-y- zzz#5Mqy?i&or`AsicR*ES56z<@M6yOU2Ny<%w7A2E%wf4+86YEGV;9qN|$2#>8Q|8 z@Mqkkb>8iY{);%e-#opFp_tz%bRHlkJAW>4Er4@^Kd0TY{5%WJ_x@I(%OfHi}@z(WPBMl!hIg$1`eX&t+_ zZS|Ak>{l{PSVuW+^XC)F|Vl1oHkq^kU5bN zltK3skta{e-mg6XM%;hqYc==n27xOS`@;aQV*LN7Uy_{{^r#Pjj?Ai`!L8u(kqDXe zzdjh--zm9PW{gBo=u&l(ibH89XjiIC&ASL!CDVGtJ|^)5G1Pf4Wq1$%nN&GUtSEbv zd>2*Pzd+>hg6Kb}OX=m|>d)yyjb z^j~+48;gj^j-^wc}GtlIpa%wQfE9k{otuthk!4%^B01>@P5jR3yBK1n4 zLrB=KElJ#3SE|4F1}<1Ot(_yQf$Mq%`}1h>j1_IzG(Y0!%LCw@9*!3W7P3J=gcB)Y z%r)^<((Wd*Mmhen%+jmyj{IW3Cd%ap&MX8k{`8LlC@A~dN)KxvF%JZVxDus2X`vw> znCX-#==^vxbtJNa84#h2;pI~1_XUC}vJQ8{>fa8GK3`q&kU3UPx6M_ExW31rjf?eJ)+0?OOSX>Z{Td>tu=@Jz)^6~){pPO zOnPfC)Q!GHUF3eDe4G7+CTA&)mjb6s$0^7b1*pVU@y^%{&MkViNrrDx-ZoS9L{qH0( zs)};T{`{S(khW&%jbQNZEw7~JE*c#6yaQmow4BMl_br`$0EPd`>G0G;ZSKL7N$k!> zCAc{Q!Zs<2uLIG8?+mrG)?6c9Cn76M-d%?-$ zHubd#eE=zN9}OT3oM*xKswjq-Z&|#r- zGIffCT-niw{c4Gpe5bNO-(+2HZ`=JRgW~sEV72e=p1IkV^xm_*G0h}^9YQl#!=ymVLYhkTk>o1k-Wex1d7w=E%1dbKAp7V##3 zFLKoXJDPdQQe;)I?^gQVLPxbJBcz3AglA@cykzh+G^ii(j=g8cVe%vKR<1nra-bC6 zPSkIYL{lyNNX4_cSy=V*qmWAtAE+3<_}CWp^jK$PXRkOEAjK(zP&8Xj)H}nBEGL(H zKc9|R%dW2{MdCRfs<)6phCV{gO7;ql%vC4$ap@_Ae<7q&&M+Zk5|1FNx2%9rIFgio zi+P9e^RYC427|6NF?>C`<1~h=2JNBN+>B7m*@>n1lR8Dm2qbrYsp+F@h(mlLp%dO> zt=_Skhku(9XSq-#f^$!fq_bll2r}t28NMZ?K!wQP zYP=jqBVs1`*!6n_pkzVIiHOs<_Vd~Ds=3f3D$U%ACR+cZW*KPP!e~q^YMqDDifYd1=z0_t;jWJ9 zDlTC*Wk-h1iXV$h5d^NYYw9###7hS*T)K!u?k(Tss9~n{;QO5hzHeOpH zi*@z9C8rae_?s6|ogpkVZgXf5o=+oj>jtF0Zj`*$dT}LHa8#}h*njPrPzML3rS;tK zSz>)QJGY7g?h%ZoiYCkNUumP0W6wIRZ^uw=kpL#Cf++&>+naXwXUIu%xS-dsI}C)>|5wGY>UGcr z+^_&mK->5pmr2EM4rD+F!N!s3rVeGyKGwoHnHGN|ib<mii_; zj$gS`?+xQsXu>k*#$xclGm3{5HJKq{w%@sa+}_COw8C`kH4AiH`rxOsmZfM?8Ng-e zYS2wRt`y@cklA)$kd`I5a+Iv1XSOyDx*5!Wx*55|3p+YqADrg%&ffl_0Y3nkB%+?gRCK_$C?sATUnZORezoPRg`K=4q6tMOp_7?U;U#oDBvd*1@L1hQvd zyAJ9dYTw=was%j#^m9}cz}gy5oh}T@1!!?m@lr`O?RtgHuz8^5$wYEd@yl|^#>)|% zuKC+}nu;E#-*WH}nehqFD41va4soItNp=-J{%X*1lT$`6>Z)Vc5K2 ziGbf$L_-N)I^;6=Q-AE%iaZ(raU(0!ZfHHP*7{UQ5%od}nvSIGZKVl%Im*jni(lM- zLY_4%gH8@_%J|kABRTpdWb?k{b5Ul121JRQ0S^F{!?p(sh;L`ou2B34OevFFdnpPX z*Dp^sM4lquX$p@qLVjxuEv6FM28g~(inXd#ll8BIqGgc5D z-I5Kee?}I?ZhSYxPCWq=SN1t{yac&(?xFP#(rpCquhJR8HVC3Z329>N!-cCCW6yXi z5@Gn$jVilW1GhFy#LQQ(l@(V%m{nP36H%J5ga~sQ!wO~Rd1*JPH_tgl&-f{%r_pzh zvZ-Yhg3uV`(_iNGZzei?)%M&E*(amPt$N2=dc6vpNy;`=-w~^?{c4}4@;u`**R6XJ zVrNH~h){s@5T|PGmnc(Fwq82zrTT;)y?P;l{d>CqB(hb~aavOe6*|~1ZI}=Z=h1r9 z%J3Mk8vnRDjCS9+@*}%#H6OC9cbQ)}Bff1FGyiECPwQK9m(0?G-QBrGJ^;Xt#Ev`q zabu|Mf{(NO3+-DzPEqRZk`3Bo84<5<}5@@d_Ji4V!2Fc=Fx@rE@5gq9@ELCg_k) zE^J+}Wv~i()zlWmS7`TLdGPPmyi7GtP}!sy*(0zb@cmX8e-@>t0>CqAk^1^_@~H(i zG=~(P8jSGsVFMGaoAANsU!-2#Irs2(X-?7|_Bb9qi_UkLa7AGLJ=tC5>tT-LaRDh1;B|XOzseqZ|hA5jf zE@YvrK1!mKQORQ!rW~-?vs>JnUX+aByFTlE_lBN>u}+4o_FdTci8kKWY0mvHdiMxL zv*(vAQ5+7;u?i5J?M9H?WCFQ!@pJakO@6-D1?V5?TKobN8DQ!UGAh#{j!?Gcoy3AK z2_e5NbBY@arPb7rJNxEz56XD1=v`q)$g$m46VGJ{W;{%|dPr;44*v`4j~4>*tocyej=>%MTh!FyQZ>F2+V>NmPD#6s$0+xpdsxDhi#$8=S-M9^wF&5$PkIn4XocM6pl2#?dMdbJgZ-dwL4S zGi=?la$brK1zS0^z8n97pOLbUzVwR;SUG(!QRqF6EGw|z!P#X1%n2O-CIYM8F+Tv% z^Vp?)^1Yz1i=B<^JIma1GB#eX)k2<>2~vK8W`85>fBsQlCg8s*M&vRbE=(xlL)$K6 z{H94a&nN9L-nb9x+5g)Wk@_nb`7!M1_40svmHq3+z5OBv6UWDn;aVd;yTk`gh#*_A zvR2WSe78>5N{_M>tVu5emDKh&@zS2_Bzz!$r8clVESmRsWeai71NQoK@8q#+euE6( zp1dnZ4Vxard){la_RnF=5<7%C8wv0BJsqBjrp@TT!BI`~FJpH7lDg)2PpBzF9brL@ zVLN$Xbv+V9BeTgdXZN6gX#lpYZZ@qmM3RTY=7&m3>c=Pj2}_SE%#Y`qPTy{nuk7zO z_w#2uqTu4%rRO+?k?Qa%w_?^$a)j78zg~Ay*LG`P_l`Hys#NKy|sC)7RF zGE!}W4ZW{9$sM8*(Tj*4HVT}!I8Iom;X+q#p`ie#rBg{)3df^1#g$iAljYcJpp$El z;XjrU?-96Qr4bPHu~;G}TJ2UW=f`NZ7DIp#s|X_Ua;w44NzZ$0s&0mRc}DZcr=g>} z+9!X0$z_pQ@c~S_D>hZjNQ)|pLiaCll_IY5M~i)sR?odiV zaU=x`h8B=ix>JS@DJ5iJ=ujG@d~aNPKaa6k@80`3zV~~c<5+(T%ss??|LV%~Ixq2H z6T|;X>m-9QHU~BSqfCd{COJTaF1C5~Ru8uxNm2Lu_8TT%?ZO7h+MVkyIBg7v@k1-T z1FC1ZQo5l8R&Y3+C88Lo>w7TP?T^U1Vum+OQ`O+x0iN-vEq^W6S6LOE;(6%p7B3B4!10tb;h2>nL z728k$4BG-b*W?~3ym>$D9cRg&+ISi14V`xqpPOYtU@rt9`mt>9yZk8Bt~#ZbL4s7J zBzMicwzl$nFxA}gSCyHCKLf})dJRh-WRO&H___+ppK>f7RNY^}OuVx!s79@n-Iz6v z(d(nbM^cPnCqk1LOPaX5Fxk8+B-VPo~>3Xbp*-O z)2nnt^s;xi(dzOSpELED-()!hV3XOQ=<9(Amf@huBeAO)c~KPQgeuT!a3MHSJ~%RE zGxOlTLm6C8*5aD?j#jK%MqQc1xgV!zeQJtuMKYk_V@}n$G5hH8~OA$i8Cwa zQbyS~gM9CP&P0M^Bm#Vm0bd<(`ZpqvYH5IAa7@)B9!0LLiPJe*a5h^09wW;$JtFOX z2Jc7q-aU7HW^7pxZG~Rn1PPemg-n6q{(#&6mHp7S>?n-E*Vv1uiNr^eZdJIM^U7nW zxf2a5KYMVCHfg;LD@L!Zw!$I$Q82gp1vsg(+?gJnq98Bn=wz_bTf2SlyndXFhXZH& zxzoSg@0+qvO?9Wf;KXneDeB{7vCPAq$C@l~r z2%ozxjPtozFWygL_a)3Z@9`vIAt(BRlonhgFXFzx*IHz?EY#t%Bkjk_8C}gcG*p_y z(UCHQtot~zBLSiu1)OXC?<_oD^1uZI?HO<33GfVRIwx%6RL;SnO?sIljvs0rCWLN{ z7XdYfvn}2&J~jy&c!R$rT)%;|*Nk7qm8%PKT@b8#i-n_G1;-l}`cZKk`F~n21Jq>v z9NontXt0mO?9Cr$XnUDI*0(w*rURfWa3D}j0=*>Y@K{pM6bgt`zJ0Y*j4Q>>xKCbOogm18>tJb4*?^y{ZS4C9kS3ah8>0-QHXz zPLp`<8Xe&r$C_ZlgQ@_LlaPhHm>*b<5p-p%Yput?$jY50?CaaWZ0bhVRYYIw8t-vG zZF2eA=aLsNuioCYNAY2M2QPSqPP#dV;i@yo<3bhv+N);RFHBLf1E6N?yc5oV=8X-n zmUcE?hx3g=YOJ~lACLyv`Ih$@tVK*&tS3AllL<fX!rOjK z27QU%0uX6fkE||kQHygr z#9=5xb8WxcoMH@MLHc->tSTwtSl7ba&WlV>TM!?(HMC>4Fq>a!T2^48p}RJCw4>31 z$hXeJ>^!mkf&EodBwo*Xs=K7La%zH8Sc%_^gt(})9#qLd_dgBbEV%=kf$oRQ=;!?W z_kCC2zD*^zN(j-64UF+xG7-V9=pPs`e#U#3@s!cRlIAv)3Ulu=X|hZ6+0(z->q3~L z6o$kFN`6z(3kp3R-1m9!s*y^ngJVwlCW34h=?>_8(2RlLL~ z^r@Ju;fT$a(r_`7^UXNngIC_8_jPF@Ec6fI3o&=?MuY+SHkWg*IPGN`_tsI1O6Jmg zSmq!Zu^wtafzrXW3wSrI!8079DJ@=BCj72D0b}q*{C;eu@g|C{N?-YKrux3%v`2g8 z9I+S_3Po$0D%kqu8W=z`-7hnIz_R0ENYgPeoETrCuZtst)jEEf`2DUzmoz*=**~z(B=W?C>q@wOoOeA*@pJ?ZB&edNiFSwpMG?FwWc=xFmQ(zq%0invN6xUMplfhH z!#m#)(2wcM$p22hYwq^tDtL2?t`%C}SENxin%v85}S>j|^i7=4D3Zn=&^sTq=|MF2NS0cL`X&IvcuUfx3}u zcgAOV7H<0*g#tyES=>(TYRZ}k6!qX))^)Doo4>eK$&fyy%tun^M(1xe7+WUI>0Cay z{Wf@KwdocFg#5e-gWcYhzaFby96D=uIU->WiNSjC!|yoI(l%gOUVwnvdSH-dd#PWb zm0*^iup7^xk1-(1kl~@E&v2oiNMFly3v#SmTBkXo*hKr*yqrBAsi4G`l*$^HlDO4o zTH@Oz0Tt#sf1dtivT~4j{g;8gq$a*I7jkaH@Ur4heb8g3%nrzOIZN_aZD=1l~(FG{JfTLlc1e?SSpB-r*RBTXnZU0h2=6d%R+F0WQJJom!FA)-{GALtJnW zl&~92X5_&fJpt_|#H}XVIbuxOO+}qOkUf;eV{)qB!4Hsnky@@!a$s0er=uD>-LW1V z<@Z*lMV=VrDe(rm1;0>f`V*87WT$CF^YDn*aA8qv_>5{iLnE)m920+!OeUVqEX2to0MG6fvGAX=r5#_^JekonrC?;XXyv>sppQBa1drU}wn*;S?B-0$d9n z|G**+yC?oqxr941}1!g%T%=tdpF{|m2^c;E)E9tz)eq}sH>V9CpN z%`%GG=-CXOSqM9X1#d7ka{Z<_)9LgS1vY}YvQ?_%)=z?4aS0N-H`ViXU4ItyfeyDvLDseqJHE3R2 z9AfTn4fsCw(t=S{PD+~X2{!qHf?UbTWK@5N8_E9}++{d%%Kbq+l=~45-%G%69D{{X{ha|vU9hostM&}u2r|2$vfd)7cCN{9=%HEkDQ`M%TO{cFmkW+TbfQVz% zK_GF!lhoEU@^AV=|1M81O2~Xlgs6Qb-X&+J0Z}T$x&slz;%!#`IgB>|(Sd!^ZtxL@ zKHy0-N=5<%--N^Wn660SH)iA;1(p*4HRj;z=p^~Tq~y)~OK208qlqf-;X{Li=x?CP ziiUZzP8A1lDB5W!e<@#8tShqeLVT0uDuD>S+Ab5WC9T%56Ysq&@*~0e4ZBC!BSZ}&1tH&|}sd8k+ zth)$AkxDZDwqJ^I8vg=tHDF3nE#s#(v+~rvJXQkLZ z*Q%@&2dO8mPIc2r#1*PwoHFwz#iL~ymwwJk06B`eX4MNd{hukE2xP|g6dQU9;MXI4 zK7;3O4WpI z&9#XnbL?(~%z8fAYQAVWn0dRyrGAUu^SC%lGUNStY8SL!Ipqlk8486!P;nyOHcfmF zqS15+??{4pCFPOMzfMI}%UE&&U3a08IW8AdHhpGvN@-+nL5QW-tVCyTTSWN2%1s5T?o zG~fVt=GH=*A3x8uHgclCh3!oP)%8q~1@39PE+iMo-YBMZG!WB*t5}E)2T+G^>Omkb zwQvw1tA4;~8#2=DdOJ>5Tx;ezXDyd5rp2!;8Rz}gE-N(vD$FJL#EGboIY^KIK`y&U z;yskTszx~KUY$qF8Uwu?j0$i`$N78%CAPH*Andv}>w=tQM)TQjgO~$ev%uUT@vKbd z>8?GQzMikxI(cj!zp1uHT)?NwA0y@G7k7@dEmHsizWTvMRp~EX-#~W(&xJm}Nv7}2 zA)fKhe4PGDuA5!JR7-G3AH8} zwfe*hPsKvD2)fCg-+2Owaadir6r-QD4yEgIP17i|u|)_q9_ z+!6PADveWj#oO+jS9NQ<5v_e@mXMt^Ta*j#QPc-2xUuRiBQDZ zp`I_+z|q+vk&;vtEqgAnh{a>tXkd_q1-H)TYRWL)&OV?Fx8cL4 z2X(7w3*R^(4-uN{{L;^8kn6RSFn7<_$6}%^qfZ7J>*WF|6?f7oe8LF=BX^)Zon&3H zu~o5ME~Yo1mTM}2p-#2QPD?KSz%f+#5(GC*24|6ttM+LCi7aZ`F4$b+t znP{xrw<^liafZ;gpXv1(25O>yTVJf&TSJ1FaY0>H9lWi^0DR{Nuj9Fto~k<~KjqKY zV`IwYfq0wt#X_vTY)8QrV0igq&5wuB(<^+rk69J|h$_#My+Cl+Op@W1--z;u+;cc z)2fI(?hanQqRb<_2n^*MWCAj8H!z<}YTEP-M9RIXxIv-XN-BRvo}w2C!VLlnvd6^c zs0TC^K-4|Ek@cl7zJay=cv!xgmR%2`4~%>UBYl=16b@Q%tHsYY*TRIf)eBe# zexQU|?qlwrGU=BhGHeP)M4lr_;GoEc`K9}zhgtctugFAz{c-B9w0fl4WBW;sH_7$j zgLQQ+b=Gz79AGE^vMK;W-!B^&LYC=wzPK=smtuzJOb$q200@9jLSTB%0B92pK%Y;q zlvI3L*L#9^=|U03*Pfy%cz=_zBhW|fpSeu{E>B_VvL80t?`flYe$K$0_y3u!Yh-ICZT-*`{ zLsIkx5ilQ;U5&UuxX1zS_*@HN5fCsE%%mlw^;qb>AsF0KcvRweb@!qpDe*euzNk~O zV!HEs^ahhrR8zz=#BeHb62<32Zw{I569?b1a2OAiHLekzCWm7)teM!h^iYjlIEa(}H{X9?0H~(4V>-2x zueRiQ>mf_b-XCyADetHhfj))P6hyWyiB*5f2YUf%rUBKZjI?cjt8YhReBAl1B zlm5Snm8HUyPBVxKSfc;r<$}7fYkxc6`dY0~CcB>nl%1WshMsjAMT?~maoVZFbD(%b z-1in6GZ{7450Ym5dLVf>0&r?_OoQ~e>s7h0Buu~BaY(p%B@3}1xnTS>baUce`AnP5c!!Nmh3y^1n)fDG)`SJK<~>zd5X%q9{0n$FI|MTC^{z@Y?$t9CT#+G zHp+kB$|sKs2SD(qNiP5vFHobh-CmM@KzG#hLL#ZyVLe?59fw>ob55LtqBDGqsc=j+ z`mqBRcHU2f9r$Ixfe;h}6s?E|yY>?GAi*5#5i2X!H4aXhBZ@eZ^1TGUew3sKAY*v= zFv#4G70-2KVV6%+N-F&-@L<^&h%2O4Karp zD*5%nz8vtR_?wNg#jhNhe0k|G_St+~@UHVvNmeqc>$@ZT;O2JX=lUAt`Q<%+xMZJ< zHX_K3C}L5kkEm8=kSMF-dC|k+v9&rDNC-(px)YjZDSVrV1Kb*mnHk>3Lp*8rHQBp zN?r){;`S%_+9wX^H|iYsRgw1j`M?Ah{IH-*KdvRfZ4G|1$`|NANxk9kJL_E~9c(S? z0AS9G5(fuh2? zKA9LO{8QtjRG98);=KZA5=>eobDsDRp!8zgkFrAd{6%w1?5UkJw>eJgfH?qqeq|eY z`YwdPs`H(3n`-x12le>Z9ySQ8h||O_ihZ#St*w$ukE>y|91qWPQ$+7TK2~G#s29s2 zLEg*oeBjXhG%X%LBqj5Jbu|ybrSjbg+$i%@xQVm^h)9q1!_NmmdQ#E9zvl?p-Yap7 z#TpQ5%yFs4D)Q>El;`tG!Ds8+TUKJ-vqxVtJc|E8kZG|S+^9RUH#LcK#|%D+Ho6&h zGselKVmjCm&?zy1A;#ch|LS`Dq?J~=iT^`S%LwWF;5KZA4NwaBr26PUdZ!;i&Q}7^ zOK>+pINWPcy8oQ+=0}m9Tftm}657qDZI#9mpJ5w^A>dRMiiLNT`HGc_^ z8LOdn+q?t1gkuco)M=H~h<&xFl8nYI7W!b7Gf_^;=j5HE53vbgg|Y_2NAWfliSh#7 z+QJzR+ssw(%x&~YO6;vr;Y3a*5j9MzI%%k_$f8jFo6{PP&oa&z0E;Wo0e&^-h|1;=0HaPb9ep&(0Uqg{ z*YIQ=zzECJ10=_g7Z5e$&=Dtgz z*4kIORy=ZR+d>=UU`>hq8`X(M9oM&8nIt^jbZJ}k_CJ;M0tSfAj}MSP++YF#C-0k| zEuENkh^qBiS$r*kEZezjmz??w+7ZKe1^`0+7x~D}H_(sdC0>wYH0OU|=>sI~T9}AZ zho0w~IdWQ0BdtZ@h$u0<1glWr#Pk@u$YZm|`*7F)OXjiNz5?hdvPshr{#!AppVM}o zhvjQ?l0K7g`FOLN)JZ5x5GQ{M@BwoVJ>?!5Js4FJ%1u?nBlrFbdd6@ z6MI|pan{mKBu`ZkE1ZRuoD>eTpY+P-`gut}E~rzhd5xz`{K8Y{K!GRY_{Ba97u7$|`hXdX2X|5|r~kZ7>*3%_Jq-nA(0{=zAI6$>3nwt>RCC2#MACNZYb8+N9oIR}w_#Y7}W$WFWJ z0{7t?zDLA;zs=^t*rtjsSB&>pG&4>=Cpto1jP`f21F$OiF$Sx-@-%txwhVH;k%fq{ zIFD~4EW{uPpHskzqsE#ZpV-*WGAYlerTov~b|Gts>=yMi08)({zv5=qL)rAAQMl``3#-{?(!ooEt|MR&yCykn(Wpi|ubQ;(M4V zFG;|wu90Ce2UI?f`Xt-uL}oiJHqeaz4aG%80#+en*yafOl^WOURiwed^_Hj4_XUIK zFPuf38;wb?ka*MW;=5BI|39FcLED;IifGcEjZyaJoGT+$`bF`egV(ZfJQSBfI8ebs zWlLA^kV;9UI!J^$MAZ}Q)H)smEeb^&`C7kmJ0#QSPd9vEmS`y-bs2!yHm{S(k>NRc z6{OutCS|Heu?~npuhJAgQFwH&Qypr3N{KbGf;lz-QhMsxnf}-K=>M1hp7vltUD0IB z9DQ}x_*#OEZ7h(jfp6vjg65%D+SEX0CyyP>oGt2R_j;$IY&|nCP6J7l3n@IG@%=&` zgEevzYu4@r5QiSK`R>I7db|MNPy4Qe*Rs_^`L;SA?(3!Y{bz>m zzib@q@vV`)qug~EcQ{9+pFt!aq)7B;SuZKRy!_~b?c0E*I~f2_EYzGpl0agf?i#8> z!5jV1&pS)s2%$SPIb~dR;~mSHIK1^-h?WxdbHIgU(ftNW()TD*W56x3}V?=@Y zvLN!J8SQi_KBR!k7{Xd$$C#qveJ^|M^!1?IEa4x7?O0A-fU0Q=5V_DpSo*_-|LV@m zz>R12GMjnS2-73D%=&VXRL`u$G@38A-hoA`al8krW?Z`f7Nk>;(>0pqIU3_}B2>-H zeAX0tT~yyJQt3TiOd>CVUx=(~w9)AOhh+{o zslpYhqB{f_WMF-Nj9Bt7Zp_&eTJ4=>GRCSWI(goH^qIo>=nz&HfC~>I{KtqR6}1 zy~zYIz~?~8_0lO?bfxorv~pvNm^Dil_yupEoO;Uqrd|wSJhcwi%?-fS7f;`X(S1I*j(#{TJ1vPSH@XYsFp(BFIDon`F(>2A4klycjHbZC@? z?Lk*7VpU8s>o1;59+*1!Iq&UB4_THA=cBA;ALndbV&15q-cFsTV%=l>efW}Oz|I>^ zoEr`Kh=+U@F8dr`w4ie=xCb0N^8L|#B&nzCR^N&^e%)f)nQ}bhEc27b8jhAbu$Bi~ zMx&nvJRWwnw+Mp1^#*4m4mrL*o9}OvEJ4O-OF7!Z9gk6Eiksn!VX8@aiDYi1F$UdpS&&0aBmzGT=dHZ*>}oMpKYt3i%6V5 zc?Q&)&@b+nZgjAfQ=(_QRcDmJ4(3eErD_m_+ZTmi4wX$w#_)C1U46Q;gT2W8wMziB z-LMoTQWMi|_%xX2A~ONXFhK8OY;h@euoC9H{Kp>neLT{;>LO%s@1`wdR~YY&qqG6D z+s0#jw5STXxia)9dHShE-+TcZU}{C@`1fQ1ao02cYdV0zML3(XtzLXL;ci;bXi?)lZMkD&_$k4rxaR*N%Bvk`CBkgng9i+jicLly>Ohyz1>MROPVpalFOHW9j=D z{C$u1*8!V{x|$O0K>XIb*7mCwdDRWPdXnhq9!cM0Ve=;s_XXIb3XXVhMuWLgjxTDp z@AD4f@PjQaU3*Lhfb&-MC;LqT!0_8r7&dTwU^>`e&KAU-J6#fR74#7b+ZZmPk!|Be z|LKVXNGO4Y)m>F(C>Ly-{hBkQEVp8I1|+JegxFd+X+XmW?<|9_QVQkvtBO6((&15a zE(dw_Feh(@`ASk1kKea~fzMo|$Z1pd)-sY>f{z91!e%NppV%%i5{6Fb(+K+X-*o~iR=u#^X?*e<#D$*IyZ zGRl>amW#9rS?qCU;xX_OhOm2*#`@=CJYDc7FAciMsICkRs7l!GtVxs%cSDrOacER`p$>Jp~jR>J~Qs1GoM8(DP75 zszPEHLoj$aTtppErDs%Nx(#Xiv={l?T~Z!gkNP0SnDEDx94j}n9PJ@Q0knm(=}FSL;S~012h5&91nL9<2D zKgz-HQ-dU6j0Pi_i4PznXQ?g zH3HF$=TP<14o2P;+sYs|w{XMsPgkQ5IKn*D>unBrZ@!vneboYuJ_~E*0nh>r5<@mW z84Tag!`5rAZf-!js5&Cv8U}LT(|b~@9UwY;ZvC_+#ucr$^_!`e_5GOIhHpIj3r+Z^ zGf>W@PWP$Jil?LD(UT}Vb)I^zCv78!&Wq!u@NE%*0Pts%GOH3o$QyRNU;a|roHQos zzfv|QZ5;GpDVsmtI{8FjTFTyhRB(y1o|!(^-{FEgv+5B#CeC*~;_kbfKkw(jf0)Ro zfB+2tL}*cluaB4z@yjMK&c!vuZ*84J)%?EONGXlUfI~3#S6buOCv%FK_W^b&%@JbY zd|A+qm4{FF=UDH*+35!*8OyzWhU8rkGGFV52NkbTJ>lLdOwPy*^8vCVq(3XBXaQ~PB?8(aMxAOy6ag($S$5h|M8jg!wMRb!13emDY8$Yt|BxvVn0PW=R z{c_;`_=Anelav$JiBHvBix}X}XXLVTTH_thHIIJS9^?%ad9s9`IQBI@Kyq+}g^!FO zRLksW)6HFyQ91#O%2PSFPf|3;N7eVn77z0b+lQ7%(_a zzOhcy$qvu=5&vc&8{9kDBO{``OZI2>=gDpu?)@bBKQWH00JJpSr$r%Q&nR!_2W@zY z3mXm^_{IkJnCo8!V z+yeujlU3HAyDkp9{w-x?PGc(0_-!na0yy;fvmf@!k+D$oS=v~Rbo_gyfhRyUj!Kv*33#HX}(gY-iMT!vG&&8`cu|>A8KW&e~ zA8VG9y^}!dweW{8`kM<U+u+so_e=%+;zrJu(W$80hkicd19|0Dm+A2@YfUThI# zP|FR!!S(cW9)*Mf^eikWAHco-Q$v5^WTo|oMezG!^ZX0_bCSCUWCJ5b2=XxT5>8gJ zT^oAsQ6VGs7eIHA5#CFH8-Id3n(wutQL^s$$Y~VwI7vX+`CRwRSHl1}W?iE1&)vPP zlU3G9Pll=h=4`laou|n$NYwA$x#lp5r!x*9Y;Y^!jsu~fKXF4(R&pnKZU4XfI=@7F z`cKqV|6B{c69Z(5C&uHxPq9X7b)72UKJ^GYcicHE8ZA#joJMp5UyLU(aOoZ0iSfAa z*5|P*J24<=dr~~^`_4XAWt%6)17G{e4PagklO-CX%RiRU=4@6a9-VX@IJw=D$=U%c$iM#f^|HWE84#*sP6E}flZ0J1` zGe&5!UY)U?j#DN;7G=l|Mu~g=W<~hR*%C=fbo6yFSKBL?38s5 zIqy(AKob7U8iX?tTMO(jz-XVL?l?fKU9M#samSf7Gh1pnWfi)GlKTy9K%rTZoRrK^yq;_v^Hn)ExCvQYCN3!h5ihi z?;I8IfAF+(PJ~HghsgG@Oh*A+;$bEvRmHdZ6sVt%{LA@<{}8zI_y7O@HV;ItYEW)> zi!F{6dftW1h&(;G%lI|jrnTYiXj$$)We}J(CKE(NA^0(3*D(KD?nrSNNkzPQ@}%Aj z!F{qPWY@nKKX#fR;AVYO?DiZ=+uaP&N)LM2O#pKqs(LYxhyuXNzqOMFQtrl&=7 z#y>XW+%yW}2iK{|a*IZ(BRC}SedYjfEI#dz)}5vY3Z6bR4G(zgeM@hfR%U->V##C@ zXlR3Qp#;U}*r&pRd4yFhUyMjbSnII+mYsrOiJRR4-Zj3a;cK4uc<*7=Q7xTL_^QmT z80VqqQxYGSlfCoOC|i>!RanY2KoSp*fGTTd80IX{M;NhExAckW5Xa6S05~W(2Xdxo ztZ9s6Q-fsMbYZyl+tY{rD1rtAwy=O~&Fb~8x{eB#{`@#B#hjHqeM+IB9(u0UXr%!h zSikdga~kYDPTQo9rLT{STpXS&Ubwa>r6&e(ya*)8-FDNj-aQ|S<9RuZh(C>!6toPn zP5FtEGUpx)u$gX1FCqQ+K)H(yUYBwdA5&@SC#L+H0^?X{{QdeLGzZ!xIiaON`Wlll z?95vYM9PT4k(2^OtJ3FGlwDK-AVC#QCs4{6o@ZY|DyK)fa#Wp0pIdX1Qs2{fAoEpb zOKR)GFv)6Aqbj|UN^~@GS;n1HnIi!ch-R>>$PaEi=GXo0wbnyu^3E==o2|t%eo`aB zX;w~&J%yQ?b~+yIvn{^%4fM!_F237;#mn=K{mbX-97`eB>+x_w4Q*eGTHAwgmZ<@7 z*WwIv>n35lz8{Lf=x1ZDpbEiCXN;cyn z?HoH8z*+p>py{a(6ONj^eS8v$ffYm0DD!6|NZq)o_BCN$8OMPy%MSI(OjH@C{^S0TA|_ve8&-s4)<}l^Wi; z^4rvN6u@F-VvTCbL(eBaWOGc2;%7yh-MzhF{pmpyg|TL&(1&etE&xNLJMMpvZ+`)( z-Uyfe@gmY*^=mZxut2rr%QsMfPu?+KY>q=+9nE(fp#sy77mOoMH<*uxGiCt%RXxDl z3?TS)%1kF79qsuaosazSJ@8MX{O#Va?|%bf7;_Z7^$s{k3%-{%Uq5OZaAG|DIfqzbE%W+TT0( zSl0Y4761wSw^;Z?0{<-*{uT>>2ad1S%$BVDFZt&Iax>7%m~hx|a@K;2;o(`xBA&_dXe!Z*+|S0MoY_ZU9% z0_?(j{ReIHqf3pa3AybVE+{Gry}=pCW=?et zg23GKXDi8A|Ex>;#b4P;`j^6Te?rlxLr56;fcwd))kyAUH#%lQd$ zn~GCe<#ar_cD%f&UsBu#)mWuUA|-K(;&O_%hvqWAdNwwDdMEENf#up2JqPi3U4f5dzV10(Jm-m2@NaI!DH$!UKY7gf>TMO zM~k<@9F2O;pwx?b?>0y6k$8Whn{!2i3Za^>l9m;BPOv~Cyi^n@Ih}D3-{`eKrRMCa zzN=e}@=m(Y!{@l>(7iITjI^Nc9Y!4hglr~6ItO0`ORN|?!hDTTX-(M*18eXOL zuAK|WGqjwI=b2IA7!wa6{xFSXNXD%7Zs@snnKNj5)=vg3MWkg-!zdD9maZdVYPXFu z&D>_=Mm%^m^$iLhu57-dP}{$eFEfG;QtoLdOUXn}soFeRF;`e$S5$`uCYB@SV1dZ! zUd`n>%jIRpZV$EYmN@FTS6->3*ByDGIF52eu>-5L#G3$RgU?_FM|qXV%`3dTT{i&P z6C?L89%W)6i0+Th{RY}&{XkzL(|ll+JJmU zQ(RTvoWtA}AyU~97gH{B8Rs%6F%E2PI1l8kYa%eX$vVNQ+{e-4aNY%fcF}a^&NRmA z!5r;EM2FmN-R&$2SVM~IcdfzWb2Am)OKce(O zViNR}eyW6pB{e5es3eba_nl&!(UE9iIi+7k(XD-5_+^ndv8(7M6*>X*)we;;`V&89 z$;u{scDI6$%FzIMCQ*0FaInJ)ov@~Y_3xnw?}=cb#Gl>$xOwTO?Qp7I;;!_OoTuq= ze?!GQ1;7|#=p_u3P{TPueC||2o(0=3&J9~mAePMH9ldBjLT0-(dsvqdueSGf};3rZ?w zs@BX;Agpd30v3_4oWBf%Gj3~NW4jRFeEg+Bfl50D&?dts=hk_#{iQZta-(H#_4h=v zNmWaqUJJO44rIOSaJ+8)k~N6g_yGu4h5Z=lqn0~Cd0R=h%-4#U28_4aUU)MpUtnbz zl0l(TjB22Isj^I`_mF4HTnj?1ZHW|209q6FO!gzUs56X|0uXGXaV%qMxG@>H(*k15 z@vW?+&$gEO!ICw`UUEXk#(nOS1l@g}vI4)I_cn=?SetG!RzN{ z_U-g|mCuK zvgcxBWGAYgbQ)NWZqS8%UB#-&2PH+&mmcTYag;%GPzZ8+SvDt(PjL1_mdggOeFUZ6 zfXMdIzys5^>NHSlHwlmzE?in5z+(E>Q>tQ?;`g3#;W0=3|5YSPTKrq{e}z5EP918xY4W9~Rc z-(dyuHl-NbrA+sEx9ho2yf5TedYS|mk8ANG>+h zj1w|C+cz^!Y6#Xye4axE!-DK6TWD5aC6~6Vgj;I{$&BTD1UaL0iawkP?iEp4GdN56 z?ws^FIZzuWy8}3y)O%P|P-%voKmlX+;^S-$q#ZifBx~6%@^q6GQDa|=p&2PqY~;lr z4`p#`?NNi%Qn%Wzkr94EdlJQk%Xo4i+?%qDA_9VNupU5%*Uj*aiAU1wO-Ca@&^C@% zzuo=Lwr9mZzt8K;)e+Xs)Exrn_~TM=y^!6?bfp|Hn}-#~>cqN4#XKQMm`8Li@026;BX z%z|7K!W~1yw&Mm{(h{;9*+BM9r-Rhh!h-mH%S=j=fH@XWV3uZfA!wT}Y)^2*;P2T) zyvnB=$h@{(CkenDXh>|YzuGoM0U!nvKKxx54xTj6$8;)GZ_HC7SYgD`=yn-q=iz)6 z#B2uLuH*H`spnXp-oCk`%@va?zDYYK4svceI^hcEfWC^5 z+tX+IlNXF^njWzY1fw}fU_9k4#6j;#svdNc_TDEB-g%h6)NH!81o&RDK%)zhE@6FRB>2s`oUOK*D(yw&h0}LhcTXvuMg~UANqV=4 z(=FKb+~WqCl9KJ)eFMGK-Mw*fP-O-1(>b!!U*biU}X*Sk@W!t$B28WWsSo z1L!MUz@#c5TvAX2+nXh{su5Xp$A!{c?i}4vTE2V&w%)+VeAgAU!2}6yw_m~Q{(=8` z^Cj!`-rc>4mLl|yu`GkoCY(LGcaM?to%vuQ(x9ji5Nr2sb{`!{+5o~((0?Ak97s$g ztpg~gJ9XPW%LpKK!B_<3fuPcxU?YI&=&KjdM%#2>(g)5o*)g!~V)}6JC@cj4y}rLo za4aJK?4?8EBTrr2ogR84ojLe8kV9hn+F-ECsDWEqu;)yGxMdtO>8;Bh)_S|L{%l)m z)!p5V9-ykT%y?>oDp*w9*f7Itnfyz|l3V#ScEaxh+RNHCLDCnc!ah~eorI=L+Pz|5 z+kg17?vQ2wrQv?n(YEN}C!eE|JQFDPvH3M7y_nB1M`VklqHHH80ZVU?lEu92Y=C6< zbKwr6r!KfztT9d?Sd7a2DX*jKwYT2G_SLFT<{*7!80x-LGR0?FM)=lLNhIai666wP z5i+k+zOlCJEb@9eR<}Ft)TpaSp3dWMGv2W2wIb_+aD^%JZebn)=MBGmcyYIFoHrtDrh8j`SP{5f*f zWaPu=a*roLUQAVT0s#bgrLuG9!W_h>!JX9{bc;v0_&3HBo6iUE!-U9R1F8eywuYE- zEf5u0Wh$6eol{U?XFVSRT}S|lP38UsVLXOz8N5_3(Py^L?dOaQLD;)SK4Zja&6kn5 z;%QZMAe2=WVzeo}UNil_vB#%tSr=Qn$K*0ege+=3A`GK z)@Eo9fQXZ#h?@vJbX?yj_JRH2)9jf#sygg~^inv`smIZ<$ZJZH^wTHiT1(W`%USj* ziVesFM)jK!2?@>#eBq{Rn@L;m{5LP<*VX&*_vgj!PVkd9`%tVSF^mugCl$28;>(~E z2#;Sxb~z{2Sjjp+&k@%;UesDuOhGGjldBCpW(kPVQI)~8!L&2YE}0vUau%SauXB`a zZV&x!!Yo4xe)?2h_d714$moH)7=eXeEVG{2YU8fDbtPkn(cD8n$FmRoa%rAIM+iV}`{)Eq7kt94dgh@|X`b6~l%Gw9 z;vF042w{u&W`W4=T{CyX(yFJk>+918<)7vv1h!ac8*o!YI7%*dSnWp3Ju!GP^Y-A{ z@Y>*jzDH3Mv(ZMi1(Y@BI&F&tvDvz7%W&v{{@F@`tGVGgmUn=Df{I=}kOAWG(SmaW zFfUI{-Z~F4`J38garJC6h`U3a;y!C53v!9>tZ^^&6yAr3FRE|}=SRw~U3$RU7gQmW)REbX49jd%n0XY2up1N=!PV8Un4;^E|S7B?r4;_WgfXNYVT4$UX=_HtKWKE%f4pxg2hbc zy;3nHCMr2bk#IyQ^WK)yq~n24-Ju82b(X6jMu3B(o?I4>B1(3VAT>2aJkMakjVPRI zvBWN;cNQUmZ62)dTAKN)Qul?XJ+j(Mvp+&SVeS2!%-w(h$WQl_=U}HWo09vH z&TU?{Z6$>9y)f=E>HNWStq=%g20KvzEx0)-e7`O*kDprKi63rs_dSRu1%%C{T`;E3 z?n{#p@%_5&rkkmVTps)~_a-jItJRJ|l~eJPC0ESzZWUr}TzoZ;Zy?WXtjI&>HHExq zXtp=H4D!md(7BW=^9OvBZoL$7DmE^c1Zca30`S!YlCq@(U}f(f)bmT>D@UD)Z~_8f zqwE_Z!fA@`30jrD4hkH7i8fUEsL{mCur0?GFUlo{@%{2{=TNR;aR2+4`MaS!6nL>` z+Uj*0ES3V47sfUZl<~s?q_ORMyG%z&+v!?PhYf7EhqsaYXd>D}!iL^;*QP{4Tp-bt z^r>Zk8g$rc!NU%X-G7upMx7R=+=Sbi4({ep(i{%{fTeboTidgxe5oJR__coQV~5Qt zH95>4>0CrPB&DD4d=*mo)KxQ(s0BDM1bv6txq&e*B+Kj4%F}HBsH~J50V>vR2zLxI zPJ)lyobW|Wzc%#KQcQ-z20Nq4=!?ovZ{2!{-mzu`n_aF7V4)rJwUG*|qn;U}o1Spk zw`ei3?|L>sE$x&q5Tw|*tPa~7elr|DZ@Nz7xVPebfGQxswn>W9+;^TvC6bmYtzF%D zpDSq4Mpx>xQUwN~=EboLz5`O{*NR_oBSXhu@XJu1S%T$(=Z($Xb%X zkLRuC4V}Koe1vD|JH#J%N#ygw$Z`witJ#`y3FGICXV=i%o3F_DtOs}!_bbT-9;Xde zzF40C+`~=4A9+`|DO{jD=#UlvBAhk9Jg#`xPbs`XXaU@>(h0>Ko|R zSV`yeo8)6E%rhTW)m+qFQO)2aQ|;F|blRqD6-jz7uUq11+8k^K$L0_sSg(?z8ME~A z?)S2gf^mcmIEJ6>mCS`o@hOBPhEO;s#l_gKn6KFKDRWR70t6R>_aH11B0jxs=Cn1L zZMhM0O?B+UdJAw zsiGa55b`SIn%OiPClUhdB1$1s8casl+S}mOH;`YSA^G)UxP*Il}mD;w3!=x&%d> z|Gx7-3}yw;23p$mxCZER9j`X!pIFTImHPw!{q?pBPp)6_TB_(x72i`Z{?XNewdgy@ z_yyp;syb`!mpFYX?oe9z*!J+F!x_(@+f4kg1b8?i7&%Xz!l+P=IeQbb9_~6!kuHj! zdKh)zf=m7A3k>VmgAs8_9a=HA^UUg_5;PBj@_N0B^n4%i?G95@V^bR#(+{_CUBIan zXpdsWB;1gIfwgz54sBJ43~y$gp%UsEYA3UtX=5fr_vt0|x z7eU0Og?9%&*2h6^irnfkeamnqgMM1r?0+*)Ng>X)#CngBY(#ngQ zIPtCzI#8DQGz}38K5FU@-PuV+`8GZC!bvl5t-ZJ*lHZ9igFFqiuWP6V1_~$W!MF zPqnU;i-&jQSLBRxsAA3gNBU-9yHV5a7pns&$-r^3UO*$XJg32!I2=f9s0~PKX;ZM% z%C@s_vJae#EPV{zaEYgT_$A84FDNQ6$gDDL&N)T%gC`%pF*Ywj?)bYxiI6ATASl$S zgFE$u&ZLC8lV16pcJ|57F5zVr3U$aSs$`?c3nM}#iTt9BR15?d@21q5fkJD4sqopc z9=OK+cN0v*WD(HhB#r+B7tTGFLfU^GXm1!3;3q;N z)-xErOT1;wx*~L#9&fH$YbOrF`02x#aE=g$T*XMAR;Bn&kIFxvRW0`a3o}2E;<4Qx z>x=ACcw`A5CBb=a6$$jm)XL^EQ9I3k!!66THPfX+K;_aJE`yh)8O3GnfPV1ae9pcj z0(cC9ZPb{@vj7^T$aL0%oz>~_KBktnjVb>u8=cn7fpnK0*qkPDnhI!dOQ~N@O+n-a zCodw=H%WN_cNb&^k^u3??#933YOShnq`#?;b=G}h|Fu3_dJQj;oadaWZB$#{VE8Wg zL!^rH`tXrGzP|F~zqll?ckS{obh?~^mI`3@hP_NQrpP5g@U1EU8n(OsM`Gz2FOIQ_ zv#211(kaAVg@4g(^?3wpl6^zwcB;wv)L6<$!xttT-*H1;$7>vC_@%@Iu#F|V8FsZ` z9+R>dwR;;-zz0Nqfii|kh#DPJ@0-sCSJF5hz|OlRt10wOdjSH|Y5VuTgJMtzlq-b~ z*BM_m+2yG-SYXH^fcZR`rZZwu^v-^ZUu@QN=5a#Lbc>3nP54sa zIQsCit-~n(wUsc7zH2Q=&vXdvquiS=@{`0~c%$^Xcfhr)MNCG9%}`rQ*ojEc{Ti|p zAi9H+!6JjusqRAnuvXr1z~yej0;Ikg9D9d+3Ee0BuxsoTR;m{k*W zximDDJ0O9**{aFm{2|!OKtfRN-$ccKN2mGswym#(p#C|vX%$`B1@d-m8USAeFp2W2 zn<7Wq>qi=fmyTh3{@HmzuCC9I{qLgCf3r=~q|qMc*&klQ4{FZgG^1;uA1v^aF2V@9 zJ`s|H@Z3}F+%OC7?xH{jw|#}Ng=j~1<>~1RS1oS+Txzw!B&|sdPdqT|xkl}Ly~qT_ zC)%4<4cRIqM8sFUO;8>ZNlE0Bh0yaX@Tj~F;fuj?S$@j=$>I^VAbFB2 zULPIUq{GSTgIqLhU|2cKK?ayJvq`yfK-f1H8lztOP)1GOem#_xhVXk&V7W#`lsN#D ztv8W~ZIsn#hu2~Md^WmT9wC$b#{Qv52_fiS5JCDBt4mBOM14!CRpLZ{=Y=r)TQ;CQ zwX0Tn5YBgTsb15rD*^oZZ#2#uUoaF;af+?++H|Hp4vq4j$<|iS^ERF@?o@x3qO)1k ziwx*JMCO>bzg6Py`UW~0MlLvp2KMb!+m--K$Iul4ivxv^O^*_~ke46R;Y0%}WgJ4=#dg1o@guNS59%M0_+hPm-^&&R()8T5jT@`mba@1mZ1;l!Q(zOxy z-(@2Jz2`;wq^t<-00-emCqSHsZ|*{=l{=ciF@vv_V+F&nwR(uOUqI)8wjgkEW-!aD zx)O`iP>*3=kCRqxUHJfRq0~snyvVMsxY^pUqL!j!Z5N$-(P%+U?GfgJ>h9xm zt-W(kFMgyC@SLeOOKG8PfnrykuSiKbg zP}Fr2LNzW*g@FTj+<}ZW^^l_ql3;crj%e(J&{kUxrw7g@NWr$}&JtI5_rMPKuv%JL z!LrwJAOZX`=WV@`b|~dgcW11Kv)8FljP0-hIMMX>8gelFZSv>0eZmNL9^-@2aN`|i;80^S*k`t3H zE#kRv`E2z%8rc(HFblDTb3C(TW_sW?CnOx8VQRC*$NRn%cDo6;vjI@V;Chd(E8$;{ zQLCikJcTaUf0j9lYYi<0KGt|qbzbysM$)QF6m@pA<00;?IOY%D z(A!^bRJjqav{UJe1lhBtDsyghXCq%7-Y9DTiF(=lAi%FRx_6w0EXnqr`E3$a-_E;D z+ub>-$8x0>lMw#M`Q!~Z_MqSTH_M%tsKPrIN$&y)xyy*9qT>#e5EGv@%j3JK5!0jC zYDZICRQI~X?<)Xkz*C4!0Bv8dW$t86b5gX6FSnN&OsIfUsb34pSV$(ut)ug4vtv)<#vkx!E-VNrYUuayA7?A|_Zgs5i!$_&)W4P-%4VT# znz+gxjXkBwWvQwr)}lq*REhN$Y-4TcIv8FRKMka6)9Yc6t zhq6LuOrGk8htJ+IR59vhWbArf9$N_*dAv)~@kL->0(|~OblN^iA!3sIuog8Uc$8X0 z^Y?H86AWb6c}p7me9FHeea=-&!8J|pUzJH11q5_l=tCxRFzg7p^?%IpV) z)aa>7S|+HIxRk-k00BJynAWtz&uT@qsp!+PCD;!XK#t~C?~V%zFKuuH^xg5z3!T3vuVdx-q@ z_>y1u?7oFNDt~?7u3N*uAs*zEjA&v6yN$MB*%Ii`&{dDO;!F$IFg|PDJ{g{RgEu?M zBQ>!zRS%omE+ocbAVBXwoGl=G&GY)Njlnfu0wesF2le%-*JamYY~I}%x%XO^o6>U_ z=*KACnAKx{ewHH3CBZW~u9q{1b4^D^3@A-wQCq7G`(*JB&1q|kkRzukAWmUSkuM@2 z8~zt$&W#2L0Fzf=JRU*K^%vbNl3Ya{K3;BEsyL1`2p@l+mQH*)-e~y}$SqH^U1pqZ zU@W-S$*^}Yr_VJ1mMFe6zOSF9Pq(Jt*va4lhDV06Q>{)oYdm5EkEV5JL-_Tc_6Eo2 z-yB$l9C`ssY%qX>iZnj$Jbt?H@Zd&b+q305@9CB9imz>x#|Yp6_w+cHHUl!_!a#nIw039e`Jo^8k(24s>BUb{qU^B)q_5~^*e8h5FX?va zf>(?IJlEKK%5O`|+POpTZoo@12N)Emy;cCQ)jn!}YJC5^e!AyR`S#i!AfNOHCXA=~ zJE*3Q3UN>;U;G!xKX6mrP2>89l=LqplA;@y?xIgj5_c9&vT}y~-f;)RH|U-NJyl3W zG19i3zGw1K_l-+MQ}VtjbprDItLh@u6fkLW6}+hKleq0OXb%IR38~}iXaDz3m_^gY zWr?(1xhoCCZPP>4cMwLGKPu#-Gfw4-n(%^wh)Nra+MpLSNRvgGJwO)19{efzp8i*^ z@B#A@W-sFazA7$RvSleGnhG7nuslD=^nm|*_H;x02d40k^Lv8pVvB8vS?=#3hqME| zI!tY7OUF@U4)YDplX_Y;kzY9Q)DrgX-S9SN{#(?AYWa$ZEJn}uqD%@UffMbWedKO> zM6y_fk>#O&MSFuiI9hg2wn%a}rSQ$cDWMTeJVP2EbM7wC_Q`F)xH zi%<2lhc);M*5h+4>byzDk41KrC-@lg;5#S~xYFfC$Ra2(aQs_;A2@a@jGY}se9zn++%A6OJt>%zXEhorKd3=WKWSWNd5d7KmfMzw#f2@`=vJz zP9;Dmlb&s0K@fyi2Tp-nG~Ua3#r=QrZg_BXcppo^$ONLrG z#e%W6CbNAum(`||2dft1XR6N~hKwB77@@d}w2OE@+n+ssw*(4y5;`>W4s6T4Sn}Ri z4DsIb@vaT(@s>^ZFT>tS&*AASx?%j?0I6&!)>$V2LGLKNn3~p7r*4Cy-vX*3{~Y}M ze;M*W;EDgZW3p@j0sp5Hc&Qc(yl7-2nh<5M(5m*FHqDmBGuL_Q%n~x>mw?JdZ6f8) z0p(IUc1iDpjNyzPB*-b+QI>g5MBOQQD{PuRU_q9QltP@0_3?SMt3lqlqN0R=u0tk^ zf`yT1IJ^+{mhEa(tW(bo?PeJwltx|S(ZZl)gkHm)l-7LH+@CLg`p@>oD72NoTV#@h zj1KD6*hbYtl-?upl&)Ga37lL)9LRj-5iZR;-7LNrC4kphJF_(3>Ne1O`UDZxeTc6f zzW=gzW$!yE32^)M=~_IAK)!VQN4_+|W?N#N#n3%8Cn=5nWNlZWv(^hIFua>AcL|Fg zd~@$B*TUtV==NszsEs|$%T?P7mKAt+rjotnSEn>ZG)>qGf80TFN=F48??Ih<;L=;} z^Dy^U_=EOtTJD>?a_bEdp_ny%Ph@_oN+~D1n->} zH+b*;cE*p++XX%>UZyR!kayMRZbWl|a-p>Cq|rhyIFfD_&v}!i?D2v_TPc)VA6+j( zKFEuOCVi^L$$yjgqaCv3+=?7_V1WPUYUR(?lfPuGyfE3XB%iKY*Ic)o+p$TSW(*>e zLhh{KGJeYS!Hbm_>_S8J1oqz-qij4Ke{{gT&<27{PXdmn_`}NSxXnI3lMA@f|PxAuk>}Z3CETN z`qDoiRRtkh6`V^(OTj)(>rHD5q*3y->Z;1xMO5|C>x_o(%c+?xC3uPR#OBuO;w|yj zHTySyx4IvXua6&pL4Di$wEG=&ER_W~%&586Jj7{Nqyy5*)Cq6ciX)?{nMFG*H1dU+(4(s zRfRLxl;wt|OOcFoJlzJbZ$?DKm*3$;Gb(AffJEEwsGUzM_jf-lhIn-N%?tA5I&S~C zju8gi606;`HVwli9WH2yJw!f$w9rdxf@))+4qu9E#WD0Q9V;ddRlZO5YiR!&`0?eJ znZNQUNXWph!K7tr$g^pRXa0QGV!G4GGl~w%5c>Nu`bWcQ`A4@6crvP}Z)E(9$j^Uf zTM@cfzO6%j12+pXM?Bxz&#x$Q@pF?bs2AK0KiH5D4f? z02sq|AYqk^m^3p*b(qIr!S8G5m|X@v;a7GnZ*yxEy|gY*M_s4E~B(Gy+Z)w2X*$|d_vDi zZG%WI_q6{h`WDCR*G{Rs9~~=bj;h?%mCt+(FpLFXJBQw8B1jjTG<*k9EEOHDMI0Yx z@9JlUO^3kc^!HdXuvmu4lcs+G)y~wjdlsJ7<_sbq+gRqNs%&JZ5@N;^HrwhvOjj`g zuB)4=VPzN<;-!x{FYLP3l9S7%%X$}N$t>Q+Ocw2*xOC@n2(M0$v{)aOlUMci)A_>e z`>XGoKRi*v%f_sA%h5V2vA&VrM-~?jysH(szkT6u#x!j}^cc{BH&pghEWcirZFlOc zw4_cG-!0C=_u-9emJw&QFcoKa zR}VHQTU;v57fl!YN>`rdJf!>I1BP7P5dLgNLBzsTmL5YP zRtK;J`KjW7)cDcLpSLt{+de+tIrau@ZVb>kP7J6;HyCCEmwj;ZSndG9LMkT z$p53)<6b>%KrsqD3N@$VksjJ)YVXc%gOl}QE@6{ZlMfN?PA$E0DtCZ!%F3c(@b+_7 zAN7zHb{bqtPws8L$#y5u*#G(JI~AcpYFgiH8{d!1CjqG}txA-sT$Z=%j%B)borF(G zY_HhU((-X|Jb-gy%>;U3i8#fy*=#yMJTq2wEL0wJS)c|2bbPDGHk#=jg(};m%$y2d zc}k3^HQl6Y46eT=YECZ;HA48lw62_xeYI9!aRCaw9CJx5yy5vgoYu4LiO&wv?nD z6)rN$)0QAoX(jP3rj>iz*?h639wJ%lx?EPvP7?0Q7JlC|}oyN#}t+KI5p zNS8NKj4n?`fPrR*aeX99`uX6-n8a@xR1|Pzd)tYj;N9SuCBv;IU9oFLe(IFDxn(|! zRjs}{6?#G9%6kb$;BOyP*mma*^K<{2&oV-w4G*061>oSY_EANWy+%v+SS1Q_INoJ2 ze3OSj2MYgDZe#-5h*Az0)hN>WtgJum_Zt?97}sA%=46D=ilhH~8B6#zwx3cT9okkG63<6IAU?KVUuF<6F;C-nf@`;pj7`nJ#x_?^Zl?QUqHQH-%Jh^8Fis`O8{C6isA2?H5aO+$L5$h8loUo~6}aPxG(D zByX-?iA#NY#|%d_lGl#G(&XVhMeKWKdHW$jMJI2b=qFc<6m_Bb-n^uP2lFHta zs+oPR-d&NIjLOr~?e5DXO~d~BEG_|FplM5N^a<~?**0!)Re27%N!51jTC_6-EQe4e zuWbX6jgq}Yc`VxD;!w;4nr_#fke;_s9(L8Li?XYuGJd=R6d2RS;_L}7n)1js5EGDo zRX^*XU20?CqvF>!ZN95x!8JS)tHPPMt|F}>xv1Yhxi@#H0;ES=cOjtlLC z;NCJfSM3D8H}NlednoVbz0-5hxT)V~C-db@6V@xN6Ki=PkhzVuthsG9r$xS?iHug3 zZX!s6)?@Ic)*bcQ`PUg8*(R>NTISa@FL-{w_MlZ)7TFgqq%ys=I8a@*D=3E}PpFg=muCWlT<-7GXu zYUu#ToIb4PWR%|=drB?W6K-Fx}h(_gLWK78{v@U98Z>ND?kbV{tC z5}2E%iJ6%dyXx%$aS#7+<{8VttS0v5a)s14Uv6<2o~f~EeXm=b;L+P4wJMC?-(`gt zoPU3Q`%C~KV2>QLP;;sgK#d=C2# z0H?a)Kw`mHI=wS%Wy8|CVhMM62w?LP?5not4X^Q#@%Au zxn!nM+()zo5k|(^;)avhDZECQbTKN9Rg3NNPC&;xwP|mSYpJGq_3A}bjPkh=ZyQ`0 zcftXVAI+=J)A#6S0;sa$b#lzI;c!&WG;3M$l*Y-{!T?kLi$RQo%=>IwsZLFsuuJ80 z=~H~-yr!B77k~V9_^VZczPk#w0J7An7Rdx;Cz)_QXfsEb){iue!t?8Xuk}SbE2Hn4 znQzoEbC$bwNN=FggLf3JKh5bc+B-dEBW8OnYn1)e7nI!9V5Kiy%yzxA5(*+&5N>Qs zC#2)OtND2Q;;*}YYtPo!8S5<(7eKr}rzz3FHHv0z;@^mFye|KISpulDy7aZ>?@}7y zPD-6A7fqn}a8I9e0%QsW|0rGY9hYcHj;|^lJhm}E@FiBk6a9>i2~@l92}^zi%>=9_#>d2jVJyUc{~wE`))o8(dw`n3EkciDcn}{bg30iCybhp2LoBpk)o9-Y`LGGh=SUdOkus z$)3COu_hz6JGe5o#S*(J+zZC8JtY!TW;=-6akXDsJso79xAdl{5=o^S31DjdfS1t2 zOeRjEw758|m$w*qk%ZyLR3`*t0WmD_>$$O+m&+QIM1-YOCgEkDPR*EW z%2g8(@(ZGPxXfeo!OQ+v*|rwBHF2DaU25|C-m?X)c6B!LCf{ce?cfDGi}EOLO@l*1%z%3h@G# z)FOybR@WfI+^=RJCUHnG_Uz?07EdOrX*y%Ol;nFCo0%xXg#b=IB56V6((8}Pt?N(X36U&<@n0)TU+jG-n(JJ$Un6c^!)(=|A&8mZSD|;-@GR2<67x|2@ zU%CF?S@`J_Q9KeyPNR`X#Ckj7J)7oy#U{c^SiNwQ~NiBUnw!^L{m2t!$Dv)!s9hDx)=w`czxFkfQLYK2qV) zny$~WVmG6H!}K+H%Z-Zxz(^zqvLd7@039!|)n=RuSrgrPW>0l==}RSeoK2{4duaqs zVyLmJm-AsmrIPBbf)RMBMjYoeK`%|Cz8^k!x4OfCDAzimIw-C|ze{B+ayfz>&3T{n zar^sNMVb4UN*rI?6Di(HVP8Z`W0u%C$apw|qp#B~j?}rj>PRUlQLD|#x9B)d*FSLx zbLAYE5)y}Db6FBeN!t8tqcr4$#3LL+jUpNXiRJku>^30lYz|$=F8*x!Q?0 zsezOmLGQd7HvisaFut&>Nh%)!s@n{Y|5aW3|71Jk%s3?wlmqefVgzc=+9cD&c(v$Q zChfSg;`mAYoW+3#K&>pleW(Pa4s|lZ`E&OFBS}kA$ro-_dQWk>eL)iDbV2af2KSU6 zUb~qWuI?DlU^z&doe_AKKV>%%$Xts6!nuge2ZIW~5HhhIH~V+F=DL0$mj5KQ;wo2u zd0AVlzh<%E>;FTP0g)s7T@8u(v9V2BCEEf>taj^>$ndh#Jk@M5$fhudx>SH!dF$(Vn>n0c+@->?*bH^ z4Q$>o(3JDZP$p376WJ}9n2B&gsx!Zls|D|d>zDI{OkRx_uiLABVKkd?STYYRKNAv9 zH7alVBx(_c_ohm92^^>%DPp}{pukCMD113fMf>6f+)s&pTHRSvPmYCr`E^o zuHqa2MRsN~dKLLbvVCvjpph7_HhN{vRbR2vMmvjnd}^*R3Yq7PdtGfL=sZT}5_RVj zH3?1y3?~%mthR+I)|^XaNT<>Xa%l&xdUlh!Lyz4e*3^!r?;O_%9tUi-smCwm$n0ZX z=S}j0S8_jkir#XdGZy>UhR@xQS(ZhgGrENlHyJxUJDXSXJMGFm6fwTtiB!D2sS}%!Y_YxpyVM4j z(e-;TAKYgX1yNc?J!juqYyzimzR6Y9^6kt%6prUr6-)wH_D`+?vDELx>3^bb{^LYr zzPjx+mi@39%@0gaq4xGURJT^N=cPAVx386*x3l@HMfv@X`%78(XQH0I`ftIr(jTjI z{nG>*ic$cGW2KntjP;74*O}C3)~1k#$i~$`h2Sh78RPlhW%Fn9=~}4kEAg^LOoy|d z#hXolXgMfAaL_f;-lH@J?+-6-)~vZc75ETlCg)hkMuuJW>IPZ7m7vXz_9G3i9Ml}( z>#m={RX-`#^V_-b3n^IZ>)0vfuMhDsJtU@5D=r*}+@J2heZp9JXG68|?ZjdJ;;2P& zlo6{9Pp{jh%+c_xV=6g2e7>S(wn>-zI6E%869Y~n>vq{z*Vc2@sn3MH%8x%^6G2sDCmNOKtuRdGkz$64i!H z+gcspCv%%){6ELrv>je>jInjeN0)Rs(@wAy)D}x^?&&^Jk|LywePbk;GH!NU&F|}* zq5^;8z*9bjO;8~*jOsKdPSF$~)=mYlgy6M2agbX3hw>Za=Xg8Bxl~3$OmlZrJ)x9y z4U^W^;~OL2K^#E-yG0YCui%`vT3WiY2QWROXMj2g|2gB`?h}=~Rt5aq4==!`-H5Yr zIN5y{Jk70u2fhxKipdlKM^m`g7vT7Z@6lUuzEM|ZLT-^+5zVS`X}w@y{n+)x5{vi` zXwV(ft5CW=>XRLsZQ`?a?|+f2hmVIR_YEuLb%5<2Ch1^#3AR|@#vRh<3YE5r7vu5w zrsOnk#lDPd)!%JGa?NC1R>t34P*%8nV~7A}CUEKuQ$6Ij(h8(1R-}ND(PpxT|B&6N z8-H;0w~Z72KPvD<#h*rYZ?r^pZ6@U@w+}kjS>v=8&_j&G;yXyHVQmkwn>S}wAYG<0 zi}K1Y&pqs3ft6PnTHKAkuXO`l2x0;!$A1n zKox4ye7prE*tew$Xxc=*0%pcvuJ^xuP5h?>LRpW#$iwKfhJprl9&Puinyif8;@74MDaw z>nZ)HvLoesKF%dIG^)`oVLmu(5=HYJgjAHjwr6hl83Dk=Qk7YcRJhSoh4aZ$5(eJ_ zNrMMjH12eWb2Gy`2xUfZh}u%M#UpDEU2<7X?k?@V1^goz`+uf>``7Oj!lv}%ue>z7 ztA(At;U07Y-}QUqxQ;Q44}Gg3ZuAH!-fN9gdlu&X3qT}aJs>xggB#f3u^KfCKK6v= zz@ojN{ozx!rfYJ7H0^e}=T-FWCsV?~R7c#}v7PPM>dDAK-I;oEytrG))U4?Nsa!Z-1 z%0Jc6-^)P9s;h7*s)*6xPB9A#&^=Ie=GK0@%1O9u%R59!XjKqmWe%t znM}`(x|U_RbMwDO2%-^WbOcVpiqQDti!7Q>=(MP=<;$!13+^bt{Av4$AZ*-iZtG=RUmYUdvm%M&iv>oOoeI-)T zIeW#QHB>EAeKhxAJT(2Qme$B^VqQm3%`>P_GZlIQ)8diKpEv_p(C9zCkbmW!{Aahj z7(`(v-&GnS>JpkO+4;^iLbux1oUa{V13dA^3u1=0%0s2K%nXio#c7k=2W=qgP^kh* zjVGT9s)FQ`UXZmT9%BHFHxsY!uZwM+6&djoHd4Jl-=5F9YG>b8N_OyzJ;dX}XQZwU zO5AGrQj)Ji%U1IYTnai#*;a82q%J#Qp$yA^lP4cDyd#oJtz_+VWrIcm5yI zCj76ylFa|Dkn@x&#O@Xlop%6|MCW_*4Ekhz>D!`fGMp0NTJbQ>ZEzh$(xVS-ClCa@ z#{RCu5vjx`C87T8JmO120b3HZ=CwegsW&=<>P%oaG|K5;7IyUUCYQo*D`_TkB*ZKm zpW{AymsiCd00+Ni?ccQXvTP9~{YXa8FFx_YyW}FzWhh;!E_jv<{kBQG6B^_mV7Gf_ zvf0z-j_Z2p!w755L{RJ-$JQ#ay#&=3AI{q6 z)}Fk6KHOi8bD8cSd*lgoeC`B@fsF-!3ZiIZ{Pv5~2uZWAS$!{$ znIE8O6)89rWq$zIAwKW^iyhr3>uZ-|UPp&0Fau#xTDu!}pb6m7>9Y#G`1Z--f%G{z z6PfQyRP!M8M91`!VsNgMw&zaKLGUp91<{n25JVt10wZ!~ z3YB=TwT3C?3Gs9+37jmll5G1z^;+sy!Q={9_SOBNlUxwVA=hcTkPa}@;-EMYs;{Io zBPYQ*GdmXUoX$e;ykU>K6f$+-XUosbH*qxBh{QRAxPgS3B7lauv?eDoY@K)VA;iU! z#9w>Dl?a<7SGp4|eCRegc|KBgOzz_;a=XkNya!#-Nl2{5BO;tJWcBl>vC+EDnc6aL zC#e+|bgHxSb?;-(0><;skMjfyDv~lX)ivW4%E~u@ZrePCqUe8y_qn6Cnufv{6(k@~ zAQ2?mEoc4eYqLsS#4|nAA*Wu$#<1YQZW=-9r{@~6#)*4eUy>Q_Ab&B=@uY_!cApN*Kb^%wL3HNd9Jy7v6U)y1Vpu7P4{KtG#RrDzc1S-Zr1IlxrL%#oh>-&Mb#kXlOE#XF zs`g`Aza#O&E@?{LizC(L2dJ1Yq3Nox3_bM59oD4{MsV96my0=*EX_be1Wqi;hyF3c z7Fz2IzS|=W@V&c4rtUFF-<`})c2gV!Oh9e$rVRxw9l|K~HHC3js!x9e>!3N*ZDh`- z+H`QmqOM+%=8KEK(z@_3VtZ_>XKdx!}y<>^J6uM}nPo!=fj z<($t4&Cg-qY=^OLXahKBtgHfqHt4TD|4*+;FZ6pvw%j~PS^n9Zyp3$tn+<6q?3HhF zPg0)qU4Cv8xgrqXv~R*Q!ANvvXOd z#2;&s((fSZh3ji?*2a7bUq+3qrKLAYVM0Hx=^-X*`o4pRfG-PE12Pc<8Ua$bkKzSm zI7oRlIO9Uh;4;`vz>tvEJt%F_%~f@OS8@BaFr$rj%A0~-`EJy&-|hiGc>ch}MIiRh zn*vZ$%J8;Dmv8k1wu0_=2T=l5pSG;7vwVJQv|eJ#?g4fuq&72ef4pyGs}Ha_WADX> zYT_r*8=sQ5_cQb7Vr<$UB*{)ptW~*SWS2hqu!h3I2U5jMzlK-D6iC@L)G<21_#3^) zx3k_-x4uHhKO)HF`FT6VbpYu?V-~ORkO>DWlQQ(1YxqoSCQ!8cduM0FQ>P;WM)9;a z*ZrqK=;dhqKJ7Y$^yM?x_0_-RKGI(akS7PQ$G zhz*I^Dx;8dp79tgE@!31RvB-7d-RK(XU}I}S@NQqcDoVbwD>2YSicGB(~b?Nuaebn zTzPoogHSjV{}t~FGFBxf8Df!xTxoAcN%ynx7sV;z=iu{Ll12TnY}FS|`VH;13KBXa z;dRG~?&(tp#?oE%9c6>e7mT(*7`d2F{it1yZw)`daNGbGPTTYK00l?F5+TY{{)tsT z=9``ROCr$UeQT{LwI{# zJbHT%qi*#cn%d^TgLtn?T7qpc0dXCg5|m%^-1je^?c&7n^oPpjyhN|{QC1oCPB+x} zcwv8E0cKY7#t&qJ{&Qb`0CED1k3xXho}T3$`4^1x65{!S_m}HyY=E$%HemQO=l^s* ze@-a;-Sgtw``PuGww!dQ@gqVa5G8FdPU@g?t8^>gE9O1Z3H1#90_5$%FS+3=@rr(q ztl7s+{YOB8qY;Jl-a^Dpc*)F14#cZ_VZ+_x67of?N{uv z>i@ip%max2*7NTmQpk7EIg?z4^X{@+l&1X+?duKy+zH!1j{(R8^}eIY(LOFXR*L@) z`e`3?KOY8g5)@OS{p6l+Ijl<+{k#vQe;!7icKFqA!3zux`TujCew-&I&AuX6qLA9< zyhU`BSd=Ekv@pwQyI-!OBp|bn0xT;~((SP|>D1+7NC?9v&|_yf2ipGkm*Y;hx!wO< z+5fo%{;(A0tFr|>JUBTD_Fy=Ba35WLH6qlXElqi&c5|emv#l!|K9*LkkyD5d7tDHN z3`m}Rm;>BqrQa;?UvXtWUh8=PxP?E((G_!THTPE4SmlY(F>s5k!}CHM-c z0vVM0n>#Njmf!bV5D61fhe$a~x4Mgc^5XbAhtWiQji&8-vfuQ8;|D!*c1YTtft}7XFPz)e9$gZBM|< z8n3isBz}mh=WT6C3BBQ?15v&Nff_-MK+&IJAGD_zzMmHk+RJ~BTHCV&7%8*>Q`6Q| zbuex>>b-z<-bknIDKD;xhr(?KWgM&i3lmg4$kgf7t;PRbq$t>W`>dTwKQhomr0b2M zj#C-V|AAzTTE<9ODcwy1RSY|JNZl&3_5N?{`13dyP6BC=OoU8`h=nMIW|> z5Foo@+gnrEJ8{ZR>bGGZk2!2-k6r9v?KxtR#ZEgIAql^)M<-csyVsKgfx%6ZM7ql_ zMTt^w!{_3MkHEEfg{)5E<$P7D3n`!U_@P@jGM%0YMGJjY0`4awrj zJCCge69I00qvKx^9X^v!(xwedr_DYPA=0{@P)qc+6;w0hP>(@g!5zotkBoY`l^*vM zcmDc433BLDb_=uvUZ2!y;j00o*lpvi_ zdfRMACo7|p9^w-M0{-*4`&FGIo1zU7|1$l( zBn_p{&sCq=Wpd_Oo_MRlSz#va$2Y^ECs4lJWoS1RqU7RO{^4`g`;1r(Bany&BbN&s zox{hhbX~lK#jRj8I00c4(!?6NnwL%O1=M4);g%V)g&22A}jCO`?6ZBq7r_tZTJWO=;HGqZ7ahdcc)SeGUvM-{19 zMF8Ju4S+^AR)CJph~1_8wi48tdF@wjQN~`8u^Q9Cx^j!KDj^5gnT8{;X7Z@uxVTERryU^3f8<~n1CwnOoEeitZtB`c^ zsyyxZ>knOYviR(~+<cEK&NF(bVaxKPa+8_VaN zMJ~z*r=mxxMe+I`6@>6ly9GI@yfR4t5b~Hb8~z>S6X0K$7ZpsXe;3wiODXZef8%Y( zurf}n6-Vu3x!US|HM8@H5BHUQ)<~Z9$<&U{`p_I5kL#x%74T#EcsaKk!JKPG&$m;H z0Co+~16m#+@C@ibbz4%TxMvT;Tzx)0TFE^Nfvr?%(!dWf{K-s~yj*TOnSZWV4^QWR zRcfFzF4bX2PVA){%S+9pi~O^^V;>0`1Ao+47XThnM&i8WkypHNk#ULd?)r@-3Y z%f{cQ^(`ozAE660D$$eLq12G=uy?`tlM#aP!bUL>aqq-o=eW(Sw2Xodl`xC^4pi@y z$=yR(L`XPuA4u%GO%+mpfMGxUpl zdhP+r{;+1GvcrSyJ-+BCP06lJH~SVNQ73RH2XRHI9J90d0K07cn3ufwou zOIY%zwaNqQgX?PoQHswJE~S;A=!dq4`C-j69JlQ`F2>Y?SiJ8S&&M@=^OJ4@n^bb0 zJKH-t@yy6j!x50IR^c7DS~I=s++Jm6$m6U?E!$0I`EoJ2N`Ya-?yg<=8{iys0D<%0 z<1>D2_ljx-=*ictCYUZ>?Pig6X_wmPfi0#^)k)OeX*p9~<7QBFrn5_^M! zz@>9m=8(2F>i*Xf8HOL|H~X+n1)%g7D1<|eO-E&W6Kj!gMor;C^Ng&})wHD$sgy1W zlFxOg8VyiGOR)B4mFH4K$*2$BX_Kegh(psI>1qe*-ds*V`Z3w;?jL))^I}szPyLK8^ z5G5nm=n6eSkXq6t_mUz==a=2FtdcT1JDfUVozv=*#@oM5kYoY?M{w@XZw9YVurOH< z?u0ZfGYrzrUKV^K^MEbNK=tLSg(HW`R*C`x#h({yQFw|CcH*Kwi+4t`;Cel)rV^@5_+PT?a zUZLx^+n{bZ{>EkdLa{yP*4g-y0FsAomv3l&qE-hrZswvU&j94iG_QsgAX%|?m1MbG z2JyBY-|@)~=ldSHn3`&4w7G=!Sm1xqsTF?Y@qS@}`lKS2=pZxM#z$WOkwlR~JUsaL zgJKHsx%1NMKXV?#vov;Ma7q)3vWK!SX>xdqBz7IvILh1)PLGR1pE-i4K$mqwK%^iz z926KFB;%m)E0g8|;lyTwdsvSohiDELQ!WgNHAkWY?^ua2+oij6mHEhHA9|`P!Qz2PW@Mr02Hj}5@!7G0m*Lz@=1)mj9OVL(ey_;Xw+{1Ult{|`HAhst z()1m)ex@2wEF9k#v+d!>9|Am44#}beAW+EE%cxk*p7Z)rvC2GmRZGDO()pWVbNPw@ zMj-Ex5h!e%p5tJrFzRs1lAfQp%}A)J)mYs5qfA$|^Gvc|5^#Q~>;??qb%`q{78QRe zL|p=e=LqL-k9eA_h=32uEgWB=gM?$S=C1d#mY5XVFTd0xZ1Y*uB%UjlN;u7LD$AUYUsw4&QcUwEY*x%`|y|p^loZZM6f$d1` z97GE>QJ!pK5k}8eOU%@=WT;(G$r*FHdUOt(7l(D$c-gq{k|gz|$(n!7QG~sPrbqEm zWgC?&2gaqBdCu8$CFacp_8F{xaQUMp*>pO~c7wah6pH4wyC8e99Fq`0hoYEvN+R}+LkDcVQiuZt+cHp(3`=1vQAvoeCc!ySG{%#;+h*YLGaH4vLR&div5Q{^#U1_> zwV2bLks%p8r;s#}HhoX%pMuHVy}=51QM-~hA+46>aR(eL3w-QRqip}0r->e1gz^}wg(+{bV~7*6Xnz%K_tu* z)C4A?HTzV>;+gmU7tS-7n8+&=uQYnJ$&Q1|ePTWF{Prm(CbmlV`)6iL-GQSk5vAn6 z&?0j-!sN?r0;|clN9=yzEX5(8ivc;EpJ?I(!mkJ3mHaRE-UF(sZCx7<0FNHP@W)eBS4Mo}I4{e=E8HD;=FfM3eYAo^YVDpl5Y_fLI4B z{ZE`fw79Fe5JE={)3F`O2g#FPAq3yzcpQyQ(H?jL-T>CslS0wA=Sc2M@P@@LGN+pb zY$IGB-x2YPgR!`_ks3%yiiLL?1!JieXBG!t)UndjNz4(>&#X$UhlSW1FI>Nbr_p^D z%3du|D9|y>|0y}hi#NL|NP+*7Y>S9vm2vWws7P@UGW$g|eC81mI*ro;@0CP6T1DV- zk8F=&Rs$V=YSv|?KzG*MH9*O6c$=*dEmpXW1-H8JdL(CB`cGmB#y|(enY_ZFBOo^7 z7igPE#0w|pw|dE4q42zgVP@kXD75opK;t{uAsqbSLO7Y=la$p(q!&76$-(<@sI$53V4lnUg?6&U+!dj?&B{>eVtD(rW5+^S z*2fHCALj%7_EAviN3sp2kGWHm=FckTv==LKPAb6GU(G0)EcZlP zKkcn)0d*LmC+F^N#*EUKGSDvd=OEVZ2fhDHCg2L5q4~!}6g4r0zRpSdiLjC%}Jj}0KTEyLa z-F6}^6e8X8*(0VSC)b|FJAdNoTdgmp4q)gg76324#5}0YikJ4;*XPEWT)jHU`WyWP zkbdFrL`6k(Vp7ZlFK_#cyPtQwIE}I&M3Q`ABznCdrd7o!$FuyQlCV9~+w&YySZxK@ zPfz)J8Excjz+9mWx|W7W@=5zK=VRFIQJz4qPTLOs#f2hCFu(wo{4MFNE5JC#S9ZKs^{ zvT3%If0Sg2tl$oI3yKl0@ARe@+YkNdw8gHT)pbPusNu>vrz~w!NlVYNy@4sI<{hE z7z9ZRp^f4-$@{dj63F53t0t>1*uL~Ix>|#Vs}DaKvPWO-r^rrcOWr;p%h=$)`9t5_ zVtk~C>NoFKPQKjnB0vOACDN-xG$LW=N&y@h7k(%l*UHYde+Fu@h|6hI1YGMutTL!3 zXKehfYikTY!Zne^Y(AG~b-jg|V^q-aTko$+2aA(&K1_QjI$i>EUZK+?;u8;gzRjv) zKLIhTdvKjTcF=gY8T&TelLGJXD5P^=10>=KYFPWI=Wzrr^uYfiS}JMzP4L>rcDy&) z5_4@!x4{n32<4G}D;E64yRLNpfu^{M&^FWAQ07mp<0Bz6Ar221)BxPrF8nNL*mg2< zO|UBv#}K*-Y--xXaKfuD!^_rrR3zM-5a&jGh@+wGG%s-Fw4XIM?LygyrO!z!Y|>!1 zF~Td(;}H*_O->57k{KAnK0;%+(q_}Qcqg}l1V4zoo;XjBVeNI@#q@6a)Equ!y92RI zs<`Co!rQ|@1?j-&knokW*DaVE_Oqwv67OQsx}2FXSV|>g)9qo(*zF(?6}quwF&6FO zP4e42xl;em;J`&ax9xIJ?<0YX_Q{wZ7&uX&Cg&(JUJH8(AUbNbn+n1hUfN}KeZ8*7 zi*KYP(9Kc*Jo)M31w8dr65&Z6y})L?d!Gvw$T=WJ zS`Z7ABPnp6jd}S9#ftkg36|QC#b#}I-06=-va^5sbKRuU%|3DtGfi&P zW|_0uZ(ReJ@^5W=tv5NJ@Y4bCq%s zuY*qo>~*Y&7mZ`#C2z@DZC8AKOzeK)=^(&JSiA`+I=dfu_N_;Ti(T~1Q)dLjK8Pp0 zm}a_m@}M-7!ZFmM9!x#lZ_+&~C?#8F^KZVBS$<4_v}D-S!JXZ_VaWDm;u;-ywK@aD z0V4U#e*4bJ*5B>~6JoOnCjsEJqQ{^YvE}(NfWG{jB7GKCv(I8^RU3NN@p9)|bA|Kz zmY-RxscU#^^<=44_&cahh)q9+g!7068o&$Mc0>eDtdhU%=5XeR zs&Zjk6C)gH*S|a&rNa^jvyKziqTa-s=F55Y%bhn*wT3p)!B`pmP{FUPdYo)T_F7ii z1e$7eGzp#?=lZIs+(b*tn7~d)y3vg7YqWfYe6TwptP~QkkSvj*V`^bM+{L7 zEJUjv>x@5}Eh+6|OFt~N0O2_66Yld}SL@}2Wa#Mtbsxbx$Ru}L?&`|b759mc#C5$> z?_Wp0=6H22`BU3#Q%-a1Zt~TK%mzOBDhmQV5*avIyh;B;|820$vWvMqTvhJC+VplJ3NV% z1?gsuUAYL1{S~gacMD2JXbcyD$)IBrC<;tgfN|&o!$^n(Ia5{hosarSrwJ$MT-w`b zU0{n%J#@_#{kt~I)@uAwC&@&)458yk@AFR*$@(ogChllSc2*3jxny4V=Fb%rnq!s1^ofogzCdfK^2h|WOESd`2&jPb=yrDYd{x?xfo)7q0X zf<;_B_v6iO<#j5Jv5yjhL<2o|`RC9?v&)FnI51ik5$R6$Bzj~hcDT8$KktX-JG4E@ z3q9DPBGYrBj#RO4VhfFlX%k}@fy+HO7cO9LaGO=FjgKcAB=ZtLMh}p4XzVv|p0NTQ z?yOu(bOJ;SJA!a4P&<;Jv-0bUoyb?n>BP~%sEOEnz4>O8D6!ze_?9t-8bbi_y1ew6 zc+}Gc^eHWtlWk*56hoCNI486oszPDncMICA_l^)0hJ znnCP$`zr+e+dBIdVrlqT4*Ds#Nk_Vg4EjyhU_(JTeP7p;Ui$%GMid+-KN%3I;3_GE zO3DKfbhqR4$x-AyS8Ztrj`4Lx{no5TU0!zk++7DplmaBe(0YomWi*v@-3XU1g72OHWZ8xK@xJKbEY3lzJ?X%E-%v}4J(Ei zwMK?{q4hSo;<|IflNQR)s+^8&M#JUYLuT*ElbvcOFrE!)Vwaf@DY{ggZDrg-a&m&= zxE_U4|#Fh z?1V~d+6{6IAFY4T9v)$oe(D64DeV;{c?=?yFDOp2aYAw?L_LApJpu6oRu-(!ts1}7 zR;-VA3x)FACNQDOTiO8(&RJl>cKyC4A3g=aU0x(=MZ^|FcSWv2fx5P9OY15DE!TKO zU7cOCuJ@&X?~TGW#8}@sksU2Ul9j6d3lx)`!;^$u0Yl-R*mM+LM;mg980+YrnQxa7 zm)DV95$Jmv>I|Lt*BlynwWJ(-R^??5pQeRd%Uj<3uHz_cC?Cy-fDVoJg_~Nem+i;H ziQW(IyS5ZB*dM5Eq2o-4fO^pD)ip&9=_V;!Tx*1vuY12UYjk?(C4@$J)*!?xv%pGI z(G!a0*|aEMVyj2`(EM6*g`6kmuK$=$gOV80oJ2k{u14#dMd;2-T;Js8?9EK&WhJA_ zA+GLrv!+t873g-b56Bb~%HENGzR;cCcW$iV$=K;^YvZwZt4EEFv4&)hk$B@()3ZC6 zsF%14BN{iJbWfw~Qd~_=;Y-#ycuT6_eZrj^Enn%M>gb@S=V`KpnUKrKED>3(hA#$`?Ik`Fc3tPBL$y>9f6D z)ws+!8L<-%dbXZ+9zZmZao62u533~>DR+>jjX!SUFj44cnv^B|7RFewgyI$m36HZe z!1;xQnxtpGgd~EJ>fm!!lpg!H$!*Tm^k|ZTD=S|iaNO{E^}aKf2jv7a z^|{|5@7NuD`O*8c3xM24vD>h6gkbl<9;o5gH&KC3&=vRgMI9rOtHQ)1-BKp48muY! zpN&1|q216X`q_|(-(6*#-Vn(tL$4*ZJb<;qE-Nw|GKB86Sy>$L=T1FXKK2TGIoq7) zomI5EC3-*YM{{uC+x6IUrqtDwahqoAQ^fh39hXlVAClO%OFD?T7976aXn3MhQ*yiP zvel)*`Ohp6cSa&Z^c!)rrAb5debLTNU!?g5&YoAdA84SKt~jS=s(5DC4+jpyg=dUN z`H))%XjrTT$OSXMKt`XMXnEy^Qd>s=!qDK80gXxs5JlC${R|`e+ z%R|j~dklv%Of~~j6BrNLHV=#-vyyXBOLf7?_QFX#SThf2 zPa#3YxEcNEpATAdze4>OWdwMbNkI} zoy+$EGfGOGcAqF zq}A7rk(BKa%xC;Tt(tSV<}c+Vjj$1Bw%!mN%=Wi{NJ>>p|;vyE5_q@bH-$w z7-iAdB)OHgNWI?ASXFM(rB#1SwWH3n#J6OfWAlp|XCdQi6BW$U7|mEsB?p$~xL=*8 z(uV896$xZ&DQINbVtgS>ibeQ?!bF4mJzNv3p-8-5pe{h>Uo`P>MCw8mOWd{AQ7zen zJ5+Y3hy|t!g+lt;78%NxvpZGB>&b0?O;ges|3mco!4P3=N@>^y{naond5;%m5kSqc0i?RfgEn(N$ON#*2qSW$Gf_u-A;3tUocyaA8izQCl8Me1*(1<3?o|dIBVz&jwM)R!;F8FOpP2dx%fA_$_yI%R z_YT0rBL($p3NlQ7zh#GslCf4`c?Q@n%QJ|bQ`}R*(wJfLLku&{7p!?{uIiL~YK0R{ zbO{#ItF?{LA3Rx;<9lX1+$(n`RPcsxc+~|N)?bANR955f0|AiLUjfU1mXd-M&v3HXtaGsi-S4VnZ4rQJwK9LUHerkS7btaBD{4aJI&=VXeNWO+Js zFM2$D5XD>PJ{Ay)M5!oBt2-_(`e|pUrB+Oil2)uW1IYoFpPsrC;z{FrU2Vr%wkxaM z&~5;-e5xCspUIr;x>~qN>%xY7-NC`O5xY33J($-SyJDkMmt%;I18N5aH8`x%9)Mvs zsS)2bXuwp^V3ap&wR`wR;Xgl44ICo--#<)VG;l{Kt&zq0(L`%Vv@F|(J9@)cj4U=i zdwnYzL=HN|6;4MV#631gMj~{JF@&+T?RoFXk)KjrrHX~drUt$DUp={P)yJvujZ2AbU^U*ThD z^3N?xJ-Ht=_!h7nGma@ls{BMQgCizdbr5;zVGL*gl*H1-wpZy6YSFjuB*!K^Cv%}_nQ!wrgBF)_ z+3oaF7|486sYV<(&cd!qHTesH@s}P}f^8H8#=q?|;C&dx^l0o+gL+YOmwY%qJKL)3 zfo4F&bBC4@7)a*37G+uK!ym_eayK!EzW&JO7eXBuA_smngJrbprYZe&xl5TzdG?fD ztCiZD89-A!`IqFBe~+w&MA3}Vf7tZ!4E+(;%=JX>8_fWmPTlGI1^oYd+ir@w%uzzo zEyaR0Xxh?>G5|RrG)?BSDdA}FUUSH4GyCnA)zF(6W}(wjP3YoT&k%bTGp%3=T?wk% zD?#VrW47mJQ7nc@9d?>7i=lfAn2%KltO8U(L4XZZy0T_ptPhyMy|A{SK(0NHhp`;5 z5VlEb;xEVSlUl5VGhBsbEjT?_lQZ$S@NcC4{BWmqKC*(zLI+G1-(0*3&Se%{>>$Wp zEx)C5+7wEtqC%waaR=a~sT&$NiCF*u1_1z&wMYgil-M9eD)K9~4mvH^D&zWQDlWlE zM;IIj5?8EJwyyn55c$@wR^69Hd@?;Q{S4+o$>g1`uA}h=Ce+8>p*|Txnx{GY!(F%9 zyMqb9d#HO<+a zTTYM(q1-_%bb8>aY-a8SKJ z$3Z)FW#^OiQjN9I&VB-5-1Ja6dK)$eFFo@>_bbG~=xFX+P1pC01we>kCqjl z{|nc@@XV3emDPyS6{9OhFXel7>5r<=hCX!zcg3!xUv!s*j=%r#0bqWaR>vKP_2+tvU>vtHzxyb>Z*#H)BPrhq$d8+yoyT-1PdX2S9*T=)&GI{ zhlXbQXz<@(|M$iJyX*b^;Qc-9{5|OYJ_8Ls3aYs!8rQwm7T&B)@1zYKLz;yw{}@a> zIwdEWz~7P6$%UN9^70t1DSw4{fxP5dg&$f5%vjdAhVAAnM_-a>6u#S52H}igLowGL ztY=?WyI~?8cc2Oi%fH*Mk=|F}Ma%~p?X5~TM|{7XtG3c|M3wA_{9(5J7v^5h!%U`k z(tm&X-X* zNkPH~DoC!ZuEB-oxh`^^S6~^)9U=2)35~6W$B4}x0MEBJ>|8C%7+?ESaltJ>PNpYC6ko8<9A)5$eCqV|DxNJk@v(X9wNjJr7TQ2H{WM)iiYv~5w- zlDKI=Kw>8CyIgpvq{`7-LxF%B=kKn^9EHd$(4TLpAya68LADL;i`+hAv^y;Ud0|#X z5Vka_NS&0Vrkx!EQR-9B=WV*(wz~}68R4_7}LAF+69wYy&6eo?RywD#|jnrGGdlB*o_(UEq-h5M)+GyCWvh6p5 zj6y@(X^dLl2qfPS*IbV{3RNM3i6d%MR4ZXDn+9rgiFF1&CP7j{@JUz6S0VFG%naj8 zA8s8uFnC3@sWP5Vot-A516;fs?%Q`)L!Za?0-{LBAJF#ik@x?}_8-iO9?;%ohuh?u z*y+(Xay!_GVfq7aRhX0eCvVPk9D9l4{1`n5?Way#&y<&&SH^d12(Z^xM35E>R@qiz zP{u@v}kk-K7yMl81kPv-U?X#(W>j;#M32sFO?dXmqPFVQzmmz*JSjKmvDCHsuf@(scP>bdmRO5V6YQdEsL_l{4 zsqp{`gXNx7z`22>%*}>xkc0M;^fnqezk+pb>qsy49irfU&zaWa%y(xL$*5rI7E)%G zc=}X!=OuZ7=Hd^Ey#N8h7-8MPhmB5yG>W1&7A(O2Y5A(UpOXm+o^^BGqtF%Ru!JvM z2l~bgOzz#1c$t0owpcSz8!7&8?88WXqmAYP+NcG^dL@W21zKJq^deLszjxu|)mv-|hts5O&*fHvi5+V?Y^&zrKp zugkq4N5Ds2g(r{M<`_I)OM-n$gkN%)gO_*Lgn(KE6702?Jz6#1eGOfG)Ld-$oW{bnizGRHsUtV`ZkL!lE`qx6MxH}cCjCTL@0R_jr)jx~TP6Bb z8Z$e@{mCNgEUQ0aA4LXh$8hnKWD3(wE;v)eNgq7OduZy}{yIImwv34Q;|q0pylGm} zs1C-5%2nky&;+f1XLX-DDOCLKEZoUWcafXzSzVu1%a<)&%HYy7S7=|=y@2XG_v-oz zDJ6e2$OPQDh~x70%`yu8!Ockd%RUMSs2RE@?gRW9wRaG8qQmQm8cw) zy8jj8gv*vPoYe5^bwP7*2u~?9p<<4D6vz{x4W6o3A1t8wDu;dUj*}mw4~!aQdpCrd zpp5oV$+Eargu>tYuvik&pQw-!-=wvXSV=DinazgX+Bw{r-FdG{wls!nXy{B(h_4hMQux>{@T4abekq>c zEikjo(s6(@`-;{_(YsHmXlyceNW)J}??|=PVcv>$XQjmIn5#1|P;0V=r#~kO4gWB| z9GLE~q;+TLm4`D;*Mi95<9B=`RDtd%=(<}kzhJ9?6T|4HqZNujRU1*b1*`SWQgjK% znUii^r1ZbJ7SNv<))DJW{Za*;qoyw$TT$SC?p7(fLQb1r4awi$vz9BVB59-=`p#Tl zi=d)00dhj|Aj-qEQfkoQAY%N1kG5+WTxgoq#6b6CoXbSBI$k3Kp+>}Wat&Rni<{IQ z)IQe8;u%e6(__e*r)M;t_HZlrQ}oN!JUP2DiE7n+olYH{-O>ZRMUG5 zrdNf-EHyTkdEPBw6!GBXLb@!DJ`P zvON{mw6h|nbr_>L00*IfA4q8ZlZ^U9F6(EWdw%vtdr35_z?)BEkH;Joh*G|Mb0HLZ z^BtXFfu<7+t0=FmFfVb57P@d*-#B=znjv>H)CFsmTNu#sr=iDI&y#c3V}wgq8~%NB z65R>}q=DW8kDaDPp(Y+w)w^O~GJY~e`SRL5OKa**_+>N+1wRyGxsEvdzL9RG(hhIX z4bfULcKCU+$=WP+27PNz^ zPY&Wy6yl}6wX~rp%k!lFrl~Xh0)5@P*Ud;KIvz7i7Jq1wR#9Rd2Z+1lrgk^UaY5xf z1wZf%+`mHF8uqs%aBl$hRVKP%-w`Ki45aY{fN0T)!N`Ay>c+)&9X;07n9{;O#?L-0EU8o))8+Ffv- zPu@Nc)El?gwV2)n3FCV9qZXV%{QmkILHPf{A70z90)b$$QurRkI_xgaKksmwtBxg~ z0rLXaxxegqf7K!X#r;e_^1XhhgK0^2dtKRR4&lrZJMmN8Kz_=A1~tCA+?k(AXFThb z64aC0E$$dzjp@ZP?8mQe9*18)YKPBZASsOuhv7+8XpI;(?A1!WmoO9iSa*HO0hY8A z&_ZdoviN3E<5z-#C1-*p+-R2*!BJjF=+VW z&Xe80dv)-W-iz&WG(DXJ1BFkZ>A=9nY6L!rm4^0?U4XarY_^_IuF6&bu0pJ9yx8*m zyV3D;r3}u^p-6a~o0P~%5w4H#lzM+9N5u)hL2N!8f&@mgdxnycXmbH|+2(LEC|^p% zTL$Kbv$!*3kK%N;_bB)TM%=p{S4(%Z7%z?{J@Uvm-If##;mj6OW!mJeb+g^?_+}JeqWFhpxZLi3nqDn7T=gzl6r&qG{M2R5A2}$1EN#1Qm?1&a(n&1{o-Dj=M z_&!QfJZDas|5&J-(XC4!myu=*ra+=Qf9Q<2qh%@h-V)wX1kQY7(N;kq5Xg{b&s~?E zvb*N8P$#ek8xL6G${0P9L&vMq{|A|6eWv18@Z@cXy{>Lm6w#A`yXou;%Exg!xa7goO1C zLLj$wb7T(3WhNbtCmo&5F)Hr~x13oI(zEBCA&S_2sA?znnl(#;Oeml#oTuvb0OqwC zwGxejIa8zAAxaFT>QSsOTs#mL)#tmjbsuob{1T(|FAzrr*f@i?vy% zO3s$IC&if_>kWCMeg2VYo2{R}vQec0<$whH~CJo(!;AZ_Bdt3Y9u z4Hdg6O55e|3Pvr6O7&&Ipn|Fj9?kgQ-X5!HIUZpvvJLAZn@<{*@~>SqO_k(GU-NLY z?(Q*Qo_0R8C?(6TowjRqMym}vWD$VafZljL!v27qx3D->@O%DwnZa`e`yPrFJF4V*S={>-Z z$@xM=)VtlgB|elGlPUgfpa9S5ui6vDiLYKHB5&JVa;cgpA_C)@uve^O!@x4@8DeYwH>c(w zS{F9S&tOH5oyD(^A<+5EyKU0P5Um4ND*sSCZ2}5;S)%NVRku0XL`62x=SJH*i&IEM zjeS#2NV|CKF6)XI3RG7`v0A}sbe_|Szs7^I;Z~fMhl6P;3r@2i3aK`~VZ=2)X=?D9 z=S`~h@D&J6R>DYKeza}Ub66kzNVPsWdFs{2IuF;PTlvzo`}eK-+}%%KWJsr+VhETb zdL!=Z-gb)K$}Uf3=RnP}h3XWqF}Ey}IvJTeF&?uYoz%{%r<{QWt1b3Kr=#!9CIXD) zDSG-<)G<$&jqv#?qRKeU+~V$$^HJeq{^Zu7t5Uu@t*$=I`+g^LZ`^({XX;zf8SUtM z9xF3DZSnG%Zj4HqS+!xryUG5Yx1g%?{!dk%eR8rj+Pz=}dh*X8fp7c%pz$(1b3~5S-_9_1`@>kV(?4MB| z*@tE;T#oiYX)sxP2|xcY?Kc|RXEBoRJty5SH5hwwh zX*K-bvovtr4-jM8xhOOH)dUp_?+_n29T5@AF+%2n(_OD87b7lIyba)X$Ra)|yGH)- zn+cTeUlh{)S6Bc~kMw6z9Af@sJz3p0&J;0^^Il3H>1}Hm{R*LyBm>i}$e%`mKcOc7 zj$@!b0N`8#0Ox4K4nbje)sIbNrC=)dD(FD0chdeZu%Ev>C;lHwWb1yQnsH}U_dLeY zfq9YRC$UfM!AB#iVTEi**%_#WLz1YD1xZ!vQ?(35%?m8SJmR<^Exeea&zH-0_e^x*^l+ixg7+T4c zvmG($xT??5obyYyQ^%MITj*wFS3ra{()+eYtUFWY!;j?kXVO0NzkTKCpU)46Nfg@0 z^vJUk#WHHhjp&z#9`g3+r{&#!D6mA#{`h-E7&%-z6Y7=D3-0h0@28Es5>5=LAtJe< zLihMqF8oPO0;*z8s3h5EAc9We6I4&$B4W}#O!r#z$zY^oB2_S?@Hqu@cyHjQgt6F`#Y|4RgY%ek=#~okE$ukJjW3>COvWY=5^FQ<^H9S{>1T`%c#A43)I+n~ z4Dyn)F7hgQMH5!}wDP=h2Wkpk(JBzN!EIj^y^7nm_l-zj)xC`;>Qo^Ut7c$II?F2Q zPT)|!a85LsrLXOR3>p93t@&3D-kV4gk{y~%eJ%UdMMBfoq8FX2lSiYfxB6!KN6dbq zW~y59Kq+=WI{=)VJ4X#aZBtw7S26hk#BcwlgDJdW0MlT^twoYmN^T-3NiM0tT5eaf z-a=NQE1L6Re#!3q7DRNg+=GUufO|W$R5;VnslqY{k#V2uD}-8|yoH6i<9XCt7UOc| z#`@bi`?-&Ho?=Br`1`&c-3l9_j=gvWL4W2VHiBP(<#+S()cz=4GkbEiuS#QLyApqJ zBvqMSG=+~ED?h<4ZGWIRH}U{?1L@`hFf0TKK5Qf z6NdGToCkUE8+JJt0@u6Y*L*gJx?rq~9fo!D;X+YJ?KMWV74=qm&jpvVf4EZ+-aYXP zjDRWdobzuQ zmTs|hoax!$4Zu|a>^X(FFMs{_`9SO7S8Wn40?=jfb1ub93`-L;%GsgLY~nAC1)|*r ztZkmfjXpNh5?7p#>e%DRyt5zU%APcFh6I$3#JjlI!r1_^uNn6W;q5Gy8!WpFE{v_`NP>(gevKZajc9-}S7*O5MD;ZB83ETar z>&>5lj=1v5_V{<*JzRS>Z7VjgHn(mui$Bd@_`Lt3eZ-Ma+AUtUT3cy-3u8&wCNNd- z*JUa?o6Mii=yqL-yAXzf5N*2x-`aeB>cW1Z5w>{(Sd5I`b#wBka4$ zh92t_H_byZp_cTYd|_cct(9Wp0_Be9syU1gA}twd_8c4OVb&xTWeqbA9!me}M%fB9 zTi`h@8+j^n#3q+zATewS&^5b8vm=NkArN}91*BF9#1>lv)&SxT2dr0xZ>(2n!+r>$ zRepbp+;24n0}b;LxEt}maz20fsM}g_wqo`Yh5oJ949^!&IgWR+z6+3PG9sEC8#jy8 z8Rw0Uc{a9zFUIs-)X}{D(+ty`-E)%SruCjl|9uQ4AFJ5UI>Z|Xv$%V$GoOCb-{tjq z*A)=!GIAx}I`NSXqfL@`4$_i}Cqv)>qGFvvv5g0lC6j-nC_lh>{~~Jg^Jo8uC`xsb zX(PqM{_=NWES7E8V)1>?)+DRyE@r<t_nihTL_r9513N6ctl&?&^(iwnxmDnm{?~yp1{!I4_DmJw6A)#KFD2;OJYiS z#r0ee^$y4q?MUo0gb!JSoE++wQVkNBPPph!S)w%KN9+L%>H~1Y-rMgLnOl?%aModL zfzdZz8Db`4@oKh5igcGbv);9Txq3vQGnyHFS->|t9YVf+fXdi<=)swB7tC~^NU*rP z;jG@m)a9^v+$XP|@$3aCY&JAJA(baYT@7yW-mzvc+-3*)%B$m~&y9H^R6(x;zrtnd zT7ACCO_yHp{w>k4V zMj4zp`}_yi&67OQqUS0!r1UMNFWN`-XfL@zSszPJX7tvP+vnZeED?%G0NL}jT?vMO z=HzvF>U~3^%6_~3DHilQ?DS@z2bsL=T<~6AYN1lq(F4M534M99+2g7D7h@cO1v`jD zVUV)%##yZQ?l3Ueom9{teoqZ2$l?;ObaC%TW~_lJUTtE6x1_AlE;}P;1VR$iY9}VK z=W``0Q?QI*zU733zhlI6{x+49im)cu(*YqhPRN1Sm3Z~Ven%B}iGk|1v?^w*`$G5C zUe##5*O|c+bpCJZ3|f+=8U}o4t8JfDqjMIBAQ(13r2TN>?b-_&<0X6= zW|22e7egTbK&l=ximk6kvF)Q@gna0>ufh-AT-NeZ%w*J^Tz&4VPjY5}yD7-03SFts z^nB2JS@LB1y3T^(&yk0*n`lc>>J5{q09um|Mm110fv<`TeGjAWlFBhGBctC{_UiLQ zm2Y+c{@4DARnFHr7QBgi^jWT@G&i6Lt<6C|;im5cTh)WVD;^U;zAO%UNY}`ztT0YgP8T=O%%}aMk%>7@M(~aWv1H z0xhK%o;s6~wdZnU`M;Fbc)Ca^D2=RLy~J~#rp2qhWe#{KcM=omAl|L2)M; zFoo{Cu1*~LvSnG=XULxBR)dj0FtyIwWB#miOr+M)LtwW1-a|FG&iQ2F2?5GZ6%m2u zc6?G_GRJ{J$2M4j{yE8qZcln{C-lRG^4(65>S|XgA<@Q@%~>y zF8|M97tN}n)Cy;RMM^U-8*OJ22Rr_Z+1U-rrAfE>*1X}@gT__2XhS$Z;1BTdL?KPX zIq^R%Wqr9NWjR(?wvA{gcHJ4@D@Gxm7h6phlPOn(N$>>IZ91qvOE_U1?}h*i1jVRrk3FzT3bZ9evOp{=@s^wxkHq}euOUN1|b zB)ZT@#O_AJAwle;mgLQ4qGNlY2PQ)eQ1`gVN!{F@E6>x+FH~Gj5ZAY9-kFX`wsy_z zQ#18vm!C*u!z&K;O(!CH<^5}E(BJ$K(6@g;&i=RUKk`SmC9luu*Y-p%&uvBsgyRBW zV=tDGo?3`~Emxx{pm2`BT`Y@zS>LUsk_p|~n%Gt10i(i<)+EB`%F!ZlB?i&>cMX)* zM1zgSfvRR&T@e_5M)p2|N~~m%7ES-L73)g=_hH{(o`3OzVR^C8Pno_e|Iym0tbRB1;>()~fG4dK2jv^p{LOlq#S1P~p zhH9;Tlh5iM+EyY1M!$T4A-w)9OE}UW`fwgl4^{ISt_6lp7tavgngx?BJ#>LPDG5EA zWX4@oHgDyxc`U;!trGl3fo9o|X*07Tjh6i)2Lux4D-NOFkwD@#L66c(-)bgt9u+qv z%$W)ZtJlDfe{oU`jypuW=U6uyLU&E2IfyYGeA5t1%Qppk&iIO%#j=oD1?*dXqOO=Uy@3DDrrrClFL4ZN|GeAmtR)-qP6(z>W8=VC zM3jOeTJ$4vOtBXyU) zhmI8ey46GOfmW_Wv7(Kuv!hah+FXdTRc#(JKF~{luU|N<_r(1zL4JJdnINIPn&fzY zp+@|qDN2y5`AyJb1V2yz>bXX9=%u>~)9oP&QYne+bpXU+0#m~Xz4Q*gQW>@7Dc&m< z+`Vc@wzB$!HteOZ5Kw~u1q9xfc{su9h5^^f>ldHk>2ng_HG?QlG<@9SNLG0+bq3Le zI5G!>s*&p$Fcxh6stJ-#Tb8>TQXW&QY!sCVx7Nx}8q>u-!Q$sD=Qj3tkH1iof#Un- z+Hd(SJ&Xt~e6%yUcc(oK0w+EZM-QQLy|P!|F+Y(0hW2~TU6}*|{9JWlq9?s$GAOQa z#)`*qoMM&Xc7B1U_1%r2l*7mQj-9UJwjGU(jJ_Z(3%rOgjv4sP-&!)>wtJG$-VOzU z-?U>#69?VNnq&w9{oH6n`j~Dgc~coDse!A#g7e*3l+ssLbT-X6u;*nTirRN+Q5(lU z=sP%XDsCrg-FSc)+8sw5q3iWGk?|G26XQ_Ii=Gt9v1*2PUN6FiE{D`FK@E+rfu_|Q-I2G zyb(j~Gj2}!wK?iYpGIJYKt*yXV&RkyGewGM-;1dIXgwcFlR?Zm;I$s`SLS@{9c0^hr)mGtZot zC4xbAVJr~O#O4G?AC1UUtsW7-rjZHnTTT7G+fKf2>BueB}JpC5QXyK9>4-eF{%_U!WQbsMfFTogdm93mBw4R=%p@xV}b&x&wU}O2 zg+x8%*UjDq;CywrBmP^d(*e5gLWz|Wri_eb+7}SleNW01iH~@Z+h@#e0y=d9tZ_bf zmw_avGh!WHJS<=P>BZGsrxYjTuW@!!A}wDtKc#PKyIGhobtzvrWTbtm<;kWd ztG!;1_8BumpXCL%q@fH>w&{MpFty{con-R;H>CF=`Lyb=u!#34$MBammaLU`#NaW@ zhc!zj3B$q>_8nu2Y>|ShwsjlnMKFoMLykaO;p9Z&W`s9RbG>(0BGitITpylel~+%{ zes6iOPjA-KhGq`2k-OH=0Njv3pb9F{ziX&+uQ_`@Oz!l^{LhYJ$gBGQ;X!6bA5>?! z2G@+P@=a@ehKS7J*bl#CwI{1d+(^$04=(QmER>tyvrvAr)60GM?kPza=OuyjYxp?^ zSu74>5%$+E=?RJdpowGXr(e|a@}=H03oEw!7%GaUZbk3Bm@ZK|G@`jCcR?aD?WfdY z5%squEprr@BWggB)&X8V5|6#MflYjsY3-HeM%-N3nXgGMTzR5vAfSg8KM}I6XGE?) znH|Sz?gVRLv+cCAvy(yV#^Wf(dk*$q0tgKVx)~|;$uJ8enmGU!Olli31pwPmfc_b% zvW@fp{1wu01z^G>{bhHE-WzQ^{fOwPoBF2qzn>`mgQJM>P61%P!vg_deQO-|<^rH) z55I{my0RG@JZoe4@iQGV_5L{pEerkp7i=h*=IkC7*m~kFG35J<@b-TqUm*HvRzT6> zjpOsvf>Gt7apHGv+UD^6RTNjlGvHUUycEkzp0bQ{ZS}#$?^xc)hko?tzVuSet~6B7 zCTWu9-Pk_v^oz`Dtr+X`q9@LBxQ_{J`*?+9f+9xs-^=)hz4DixQ)-fu{+q}5bv6zA zFS$6ug#cFs%cL;w(oy<;YxD7BQf=v8ai}MbMj1z&`JM7XY(N3w;L1XwCGO0=L`21E zjOEKY%;{QjSIc!%IuIttV|kUoD-7fz(mkCs+Na-x<=Aj%wi&KPuiC z@)_^*Wm(EOZtoA%@y6WY#_5M@Le9F#ucf<42kzyA3d291_+=4ulMOZea*0i{Pw$CY zYjG8yM_nZE&f;P`2{oHo+CDjlu1lkPs}MfHh8;(@G>thMC2z#W>>Ar1WhZdCd;qG6Y-co%Nd(Jh! z-b~6`nPu#3`aEPVSOT%T^r!b`1ci9_2n&|?^|nif(g7-4d-=idpPHS&w&OL;@ET-4 z>g}aBV&#t0k28a|j`>BuLUKn3pv&w1xm-);x*6V+F86mkd6GAY!tMdOaA%>;bJ2F{ zP$~r%rr3lZ`{v+QDO~r|XeqeENv7zH2ZH5g&n}p?DLrP5JYP$0r1Vo){bDis)=XI`go=2xgHaOGh z)Wwim@_zrcH+U98Om9muwZP=BrdXb=)#eM0RTw@nUD4SZo4FEh>2mU7GRGL*&AXa( zMqV+fAPwf8<2j9)0pA=DEak83J6ccshSBj*2T5B^f_{e#=bmVEhO+ZyT7`tmsoO?C z=~hQa45wn<^d`7cm6wOqbC8Hbr(edKsQK#MRi==1J^kU7uD(KWQeB~(I-Pp87TOdW zAMT&)J7xbqu0U+yiAIN=_~}fmz({2p+i)m!b@ZRcG(6*RN>{sfHnXl!=q^;f`X(BK zP0WU|lqW0Yw!HU>fu5$OAh2q1m*Dy}rm=T;$MjMj2qQb$lD?L1!Mj`o zM+IP{wkv*7{0fd-M?E*tm~6HD_A8r1jz(i+^1SkdGm%Sl{(Q>FGhw>Ua-J6UE?)SMT-V>69Uzr?HvvIyL%6@M3XDgWH%YUv7Q z;4LPAnrZlqKlq|aw^Lg?P~l+U(2+=*kG-ki`i`?3B4~{^+d8SYM$;cAO1k?CrqU4T zf&h>bDpa0jbHdIkI-W%sTe~F{;xAx%1a{cbQ*$13`}N_XOvmpG85@^Mwj?f@AhT;3 zfrrFVvP~5kcYj-T{y5#(-@V>dEdfYm@ISlgH$LL0NcJueehBeTgRnum6_zRu97wsTJ|7k zLH{}Lg{9`{y~^3%e+3xOulkF@s~M+#%=8gR!U)DW0I9Ytj{ojGnED&T&iGy;TWrt1 z!tXqO+P=QMdR$n8K)2qtxOePg9Xy;=o>kb9`NK22^rhw;yu-$4_eHea%ygFV>{xte ze{0NV-1ZC_pV8m4bH_>=qXLE}_nPK7JQn<~fz}%cU8mn?gkz3a6Pxzg8%dfX+Qk|9`8~De3U8M$4?xi-OmO!>C}7>KYbLK0`O4} z@Yw!6V2jf7kUkb*B2g&>y8Vr=S%-8J@)#*GB+o<=6}}rR0N0dezvYWrYG%z_Q?e~s zO&bsGC-l_KVo}-aiz|9BcK-Cm2w+CY zN=u5LlyyGt9tFDOC>m}tL-7|K>WA++Qi{U6`b~u zzNn=&YLeP?-Gd`4dN2JP`fofy`%Vzb+{4re;Gg9~*#3qaeMxn>sH-DE+6#I7iHx+dMxoF zU>_5=`OOD*>3^LMz$F}vIAp0m^ZvraVnZiWtI5qtBWB<cb9dW$^*|6e>)c;Iyb zi@RXt-$xb)%*vU#fRTu6Su;Hly+HqaO`lio%<-b!7QN4%2y|`$Z-ll`Q>ht&oe)!k zl<-JhYLwsmnD>P$rh?Wke!7Q5GIY@>@RKJI=lNeKjmk z?TejlEuDmbwt9tHa%#i8t@a()sc)rfJ@3*unb~B};qZ_qoO7V+6vo!5OlMZMs`#$4-U`%Axdk$Vj=E$GV?A_@>b0VOwt-Q8;rnxz3l<$8bX4Duv@RV=?b) z#e?FT7xW|%ZwH*UUu$8G${=UUj(WPN*Ri7bg+gt;P~_IihmrK_`tE^aACLMNSTtpP zS;_o-Hsvk_K`%pklZiU}5uB@yGe<$1FO^8pU6J_;(2}B0roYK!-&`+3C+mIcn-t2d z(^rVB&R5pHcN?ZEM$eueTWt+0a5Ev1~DE=sk`{p=U(ob z#ht!qT=_yTt>5NCVHC=ig7=K>iiE#qobyz9LBZE}acgb`5Q|1kJK~*bb?+#!;-vBq0Zs^ zU8uZ3h0<&d^+>CVDj01nc7pMNI8@wtxkgIqyG5_66T`>u%7A*?PO|g1awiov)vgIT zX>1RH&%S#0p+jpjyK^H`3y#qEEN`?Da{=am{yBPT847 zAQX{@EgUIX-XuQ7V%_BM$!%thULOM3F}X_7ur zJb4(#dRqHS_zk&9LtFx_cvz=k5$4vx#g{N1e&Kjx$Z{E*m74=5*BLs_sc?rn^?iR` zE3GeYvasC`h(GLKyv$s4$2VM?0D*`x2zwL{e_OG1$+{%oAUsN)kXTG+7)v`! z@)2!YF5sNuaHxsDgXBwDxwK8W9(-TLb0%dOOo-ZKsas*rOd)5t$FhUPzysky>kZe^ zO-JiZ0$#Qu>TmT+hoWCUy2+M)irs__y5`Q${gox7{eqxboUc-rDMhV~t+yPbL)ioh z>C~h-)I=WWc<$T@<4e!(h+$%9d&269e102aV%dq>&<6J= zEK4A6W}L#rGo#uXZi(tsN`54#P2+ss7FB$kjOuv0h>`kK@frIRy)z>#>Nm@dq*7d* zC!QmJ9fk~bg+pYH$nk_LJGMVZ4XXycQH##Gi!JCF&7HC&QiWEqE09chQ-g{<&Y$%P z&YFg4P4;BBdrlU=^t*&4&liz$al@3@@QsQ_>47wOlA6f;yt9w&tG^mRYY35E&21I0 zSBHBvuUU!ntDvsEdC;-hbUp1%bLsHefyExos)VZ$;&f|eie2nok-p?+JKO#uqY{^m zuk@uk#co|}#LJodp>^K0s8{LYK9e4P5%iyWWV2IK^3yx?ThF|4uxz^e{+ioGdU)=_ zaT3EY)+5n1JY9@IweHT?9D|mTD6R0+o2L`R!d)qp#q#burBYVoXbMXU`K#ZweDtlL ze151Fv;gvU=XV_*%8I4@D%cR7mKaUqF_&tb;;y0)7m$!Rad^z)gA*y`)kO(nh%wUG zlrU&9;93zI^-D+D`p+E?DcG>Dqq_^B{ol#QkfJt zIAZFRxJm7YFawh!se?G#)S2PeDaO z9;9Xla9L)3I1Hx={+;jpcbflv>EDHoKWTCjK>$|~Y$Z*=#pC+U%6_QS&-Kk7THxJT z#n}^#R9UGbM?`p$#`{I+m;@$3IGNwSTxDe;4EKQnBy$9nfPS{Vc_5u5OSfwH-3#vz zMv4(#k@xei&ebUMX8f*x`X4H1c)yOd7^K#P+>)uKi1l+dC1Q3-lA3+e4dPwJQps~2_5#yUs<^H2l5s8h_j2&HgGCM;3%VaJ~rIS!l=nywbMtQH6o z=%k_CIOzymn4#PRtW6v_?_QCCz_olzt_$;3ef_E4huOVFwEcOsjnF2&n|o&law?c} zyN6x)T-@?3=i96%jU4-opcn~Tyd#cVV=AgX)1dm|+3*QjE=qCVYJy>$NiyEag;jL4 zCRH|9-VmQsqo=tAIDBa7By2lkx1#P%ICqfIU&;-l?j1SQ1TmccDR0!D#6EuQ()0EL zPf?Kaf%E*Xm=t_skW``6RZ2d3>4?HY&Q&vYCq^XMZR5on9e)t-ms(x+$898lc)!k< z>-!m^DZY-Wvj+%iRUhW(-Ooq{ktg(OYX&JMmnT8)(pQ#sz>Ip$LRFe>nVC7ap!eIQ zqxY{T7hZs>w#dmt9GQ4n{?l*d1^3#ShPZ+Ca}g-bWudc8E6e@Mwn4?;CqBFF2f5}A zTeV|sA_!%_b|Z*@=ePf4M@Le0kp9}K;qK}QQ^ zHGN|S);G-gPOHh;*~{8b*k1&Ps<4O3v$st>l(01Ws1^H!(UdGCF1@zAoKS-IVgRIW zmwtZf_`sZ-ZFu^6WsrcMLW`F1ZL}9EJXRJ0V8YHVZEj&esjG87g6obvT?M<@d;aq_ z(oIUuai07;&BUEgm-5mrXRGM>XipuviAm*$U;;|;J`YBzt7|ns_{1quqnDm6aXf)A z*e&Qc-~He8-l|-GYxDOZRrK$DC}?OdQOJ=HhSW`rn=eumgzYj?iShWYWC|(hx3Ob) zs>$QGk~-Aa52$RnW^WM{9WA_<(<`a2TB*|Sw@hGTqlHQcv}SX?B8%CvJGHJ+^s@;K zaaCTmyMFQ!XOI$xXjbZkCa{J(-v<(#NfvXP*y^5s>Myd6cTUyHLU# zY#qJg2##~-9H&0$SoXuMdf}#wrm1+#9k@= z#?it$ zZFD1l6TJW<8CfVk<+|oDIAM{?|A|Z)OJ^EL7j)o&BHh^DWhk6o%;}}O>&Iyi&#H#k z5E8P(zwcdswOe?Mr-m;zK_sQ$nG?6ih-995lRP0HvLj)&kv+QCa&<)iU+~r#3m_3W zswy%C4AeM~#!rrdgzh&WCkIF+{@@)yc3ULBTtEdIF%cO);MB9?+SBqV;}R9Lk&aE) zFvQ3EfGZxng3oN@@p(%)=G@%=kqWAr8!5RL=+xSkiCLHNdG!AW-#7)>|>K zo=rL>d)U|rWFX_4^nVll{EczNi_m^+HuvDJ1F+wiO+3p4Kn;GYi3eE&cPn9;RXcxY ze%Y#b|XLdORC#>7}42~oJTiCNs@Xhzcw6ebm`9r|y zrD1w|dnV2H*J{RaCDQZzwGPYB5i!3CaG)lrwiqBkQQQ!Lt+x*g$_T3)YqwJvDAL%G*b>5zauw%gbtP7!pLV$l>p4m)is%JID?Y`Vppz2E_;4$k~7*D)ZsR zQr|k^Ci7m(Wya9xLgCY5C@14J(!p~V)&mb#&$dWGZ`<}F`H{?&P>ER!(tJ?|!65iN zpZ1*r>uU)6xZ(lnm8j9nPPh5Pa2ay64#V$gB?@nQNu=a;d94QA|UDG1(0NO^l_aEh+^N2kS&sAfG)5zbbgb38AT|LNCf{SJH zUd>EbXX;u%>NV~>Dk6~_)Pdvt#gg;Y<|3fW`^A#O>sz!%d_(X_2@Ab0(2L}OQxHR$ zGA&Yr4%m0-oU5FS_d+hZf}aipPd1IR4OB~Nz8Ieyma&f2!IZWNuEGMeDKVZZ!$}91 zR8j4n&Q60*MHbFMnL>2Kd^Ro{8xgK3yNr{h;wqF8Dyq~x+evSxeMKL9pmx)`Um#;? z-7xe}Y_{sU%X1{EHl?fw!n+;MyVkOTt<16xO2NlKO%2u zgF|1)oZ;UvRw`Dr-6#qsbF7>yKWOll$k&#?4WhsQQiAb%STU&Hj-n{rF3)WbpGcfK@GIobqHsoENi8+QYLGr{Y~> z&NO{N3lBrA6U{MFtrrf$0=S6>gDHpW6_(Y47N^_Q)LMtWwADpkIxACNJM2Vs8&Q$R zM6MGfpZHnxAl(@$G^3RN2af4VO-~A`4lW7L@mI{n^U%fv%_6DuUq`HNDl!~UYfdC$ zwEdzPZ2>!kVnMa%A*MwL)*o0=FN;r=Eeh86m>;J<8tfZq3s0n-s#f=-1T=@MG@msI z4^A-AVeZ&{5=&u0yG7GfIXew0-HJIoO46G}Hpz~PURoLs6%CbFn#2Sv5hfBH{?#DT zqA5}7L4TBZ{j-E?-LYR(Wlc+0r!1YqqE{TyV)LDrpL2kFrcjlAsI-Y2uMS6#q3VV3NM{cnwJ2LG(Su zB9CNmevMZ6UIuCkOM*9(GT}?R$=*r5PWNv*QZHv!ME0`R#YiF{w7A`0U zpO5cH2#vnz%!FIB!m%H|_8nHaEq$6}+*~tb zyT7?a)`LW({Pp~5iBftH>m#l1U7v>yTmiAf>$71L#;(>I>_WXD(@PYb+xx%X0q6Fq zexxZQCKUkC?Ny65F|*z>!|n+C$p!I-5pcf^x=I@{4+MgMtFMve=Bm^TxVIkSa#r-` zmk`ELF<7Et(IEJ0HNyvjua47=0ztN0!Pjk-k@=vx8tc4dO~H~2%ES)buUkn@^C7IO z69IP3$i;2MEVpiTpA_F(9@N@Mq1;)rjK?p~A`T=f;s+WJqH%Itp;T=UCzd)4;>18w zL&*U#<;|b1BKF4^-`6^<>8L!NU?uf<>HWZphS0!37;en~chdjS3w!35oR2Nz)WhFC zW{>QtzD(MyOhI8|o$2h?b4pvs z%v&+~y)ihTpwWO(E>(2*(wu#GaDSz0?=koEnI0LvXe_7Hxsg_UQ~qxl;Bj2pQKh-{Bb`ZoS=oP9!ES{;oOq7Df3MW z+H(D;$fM!nz}0so!DioEmX>mEeg|FgC=Z_hCjYh%$g$Tt^1_vpOJ~Op-&K*L6Zh%b zIs@<6H0F{--ajBFOSU6&8E~4>f^rcxkgQ^kPs4vR!g)}!ZwAZ5wSVIb-`t$Y!bvP` zPGZuST<0_wS@y}mvfQBa@mkfS-}TVQL~IN$$F_79F1s1K867ddX(tRz9_XZ>~Hob$^pXN#~hK2IJOhxSX_;I&=(41s%eppPdhxD6)s{(Up@PAK^Jbz*!ih1DH*> z?I0c$l~c0_;#%Pxc}_g-n<#c$cycWW1b}Mby+Zg(VKm~IKbc-zTg$l>`rfg61+fP|MH~m$m4w+8atCiEh1ofsJ z?$zN7(2kR*tuKE3o}Zup;8x_DGdt3oeeT#D$iAEGVPz1)I>EB>y`%GM8tgBLe_!8v zmrlz#l|O-P#cb{MG-FMCKUnk@_>Iq0&}#Kz5YGq+Rt6#RIf>T|M>rp69fnZFvZEjn zX2n!ujahd3*C}?BgE4fZHz^=YU)F94!6>Gtm`pUnxauoT*@la-RLHk;+I*9svOd~# zv5MK*hnv-hXCDdL`ye_1&ok4+idUSh9j62?L^_&4dEps#IQr8#rrsXWh7=Cfa6css zkDZhsB1w6$0de_dAw=&KIXxl7p%#rZ zl1#n*MOQy_+=>h$#hkW-`8}2LcU%g};#GWh*Dy4{9*G!?9}feo)4~C!d0G|wm_L++ z{}pQx2`h>up=ZUfXX=sawW9@%H0@*Q-I{4-s3ESoiXzUfi z>gy%j!AHWNWH*Ckn4Y;dr*8=n444N`+zy)X}z^)b+tv$eUHi6Y>eS$7?e<~JU>gT$E#rDIf1UqpgBca2LIj0@}Z z{KB=2D?;6e2jw-O;skx))A)C8+i%fmh10^5rjqw9>FV?Y;UT_T8KfPthQM!6gL}j6 z)(c=;%Ty;9`^&x5S(YIb)DA{IWlT*<3+J}EsnmO4iM%U3s_nm3w;;nuyXt6Fn^-o@ zk5L)!mE3=Rgm-%N@(MMaM*<`Gp7V^C%X6~(l%W^D3w~qSX0Pwv^Pup*rf4W<$9XFy zKUKPd;(YviO{$re;=uK9Vg@@^o8KT~80AFv{7b(>Dix z11NW^B6fo{*oDQYZ(Y1eK;%|;Zyt*iZA~8L;ub3H-wm0Ptbcoc=TljaFlDDCB+ZHSUVN!Nx`L1QjCV_@VO-IM6n*M6OsTHuL zDU6+9J1|K)UI18Ju>&NhaBnb?b&TECUXrWw+V5mMJ?@BELHyh^j-@*u7o~Ez_i{4t zwZn=6Iq=6cxkyGvGJ2~o8-X9O7Q1DT zDt^h*GOr=()YsVO4<7R;#FL?9CS7;yk?Jh_@pa)W1dky6cA9MC!FrSns2fpRdtDL9 zG_d`A@HQVnpxgm|v*)gUw^~{2QE+}2;*7oiMZPT9VDf9D_`421?~>zCPM)nK=M?#N ze1;c4SlwxOe*-Ng6Y;J4|IVCM7x7pj2jEiW_^w<~z|d)ifU6=o89Xjkw=CE^H0M*6 z-$P^W>rjZ3+8A)pxACZDDjwvwYZE3rQ<2}$C~&lCg8T9iLny}Gxz=7!;&ED?0O-?J zoo-=+-_^gY0TNz`uy1yoZ$ayQGD%9EXB+9}g5OA^3Hnvuu-uIH*}by(!0qm>@+}3e zAgHJ_(p@3RPyLP&B9{0a0H$<%wh#W5OJV0PqfRzRLzEtcIzu2X98Zc>?j53b86tb_ zP44Y{3Hye{K&R1%S4^0U@6QHd!x8Tok80l1Bkt!*W6x_nb5CNfP;7 z3Aa*3W||TNgw(QSB6N11Gk_*{frv-$hZDI)hSX}8r|o?ekGwz|qY1ZiXSSdDukA&H zHvu~O8<+i>sSrM-x^;E69pq^q+zWnp1$TaJi?{gT^zMWCg_wOZZ|d{78np#Hs}zQh zbjzpgif#N_*IwA+UcKr0Z%=Z$O?po%5I&=LkZHc}A` zFiN|px^>>|#S1TYpLg-2!9A-0f-gb?0OX4m7sOcxXy?{~OoEJZGzE5VWaFsvEc-Er zC4m?rA^32bT(!c-AZK8R)upz9P(;#JAS)MlBDbJ_U>gD*1HwQPb5)oD!v2552*GCX>otwR%8pF;7Bzr$NKj)A z#~>ZH(jj+7L672xZg^rZ032Sj%xYSQn_sr<|HjeZ1!@?pZ5u^@-Wu;*ncrZy_U-Dk z6>4K^gAJa@?Z&RQxVYs`FC4X+1f?+;D3-}qHVvGDx@4(a#E^qGE}H=IA_#CO%lN^o zHi~MtZ7eF2r1cW1)oQmQ<44zYh&u++mLjV}<(4o6j7ENQc*Pq^>Y4>z^QDlD5 z`-C*TM@;q_Zp<=jM{z)=%B)2?>Y6r6GwtDps3y=}L-2sIr~)x(f?OG40z2wh`hyf# z%*8ty8G6DEa7jIHeo~Y_oa%gkCU0Ld@2%Me`ktw94@0;p8d`H7Jy(Ywwnr7W+jH{@ zKCsg$m$OhQc!6SC@uzqtr1JRnveXF-`!KkrIQYGsqp)Y*(t5DHI(k8V{mY`v!qPYr zm5}R92Yugvv?`BY>J!6VDNq>0zdR}$r0mSbnQ9S{N^nI>Dr9JgzvlQ`)YYXz-l*A` zpuzU0h=HQ8_4jfV$`B0ML|;saP4W)BnWbvo05E}hM--yljbWKjR8{-1PT>N4S?!|KYVT< z7j*26!KuFK#Q{d$F_Eh?!KNe1HZJ4+#B4;MyfX*uaboWET8Ggcs*@f=>r`?oYHMVk zHsk^oxWh3ztV!XIQO1Vz7$oNH^oz2YFF`qDqLf}K-;t8ybq6G!u*5-6o9*~1PfL~P z`-%(lh)y>d9Ev!V23XE6H5E&swHNJ}yn;>&l=$lt(CT^Hqe}Qt_EoMLPX-y>8NLPD zfnYK$a{apmF)<@SNT*_`EYLdQcYmYVai6T8xZ}3@dLOn5 zMz*K~x+RYOJ4t*i343=R%xgNf)?}gle(HgBYR#UngPkQ@AH*I#6B#|Lh7$+Dpfo_u z-^`XKovJz5n8loOA8eJfMp6fWixfIY~A9rtd~- z!M&zI{23g?&e49Y(tEx|*%?fOQl0>tj8D1WjF%FuNB(xa-eo{)jVG%R2VvR+74H$6`tmmb~QGo_WF}i8%v#@H!_RmO``r({6 zM@0;b>;k|*A4Qj9J0@@&EOYTYK9V+Aijs1r(CjKo>#1`ftT{vz3{O<^3ATq18$qk> zzZUziyIPA)6_vVgP9<;lm+%E4AEc>ne_kr#`svL)$;(B;t0;qzg~@)Ti%WIiMnNNA zZ;t&C-%XP?c;~=Mpe!o#l}??-K6!y-!DJamVWHp~uyob-J!u^*8|+gc6F$#i84b8l zSZ2fWHrD!K13oyx=8P`mlqQy9z064~RV~=xf4Knrs64PR0WPmSC|6n*H-r~zW@PHu z8J=nU_F)&?VdNWg>&` z`IP3|5?7~3MDSl*<%4G5Q@ZQ3OmKHYscqqJ=wy4ScGqDIEGcs za$Lcmu0mg2I)I9Qul5!t&EG5cYvp~ymxQ@~uOMc>zVp?8SU>(3NA^;Aj_PZ@CETuh zPSS;Pcv7`BqY8!zlwQQm@LSDb&cM1 zhXUC*(OsmnwO35zo6q_u-B0)>PX9kw8#|O(L4I5K*{QB~begymKHdrU_RF&d_AyI; zO9Qy#Z;fm}W33_jj7oPi0(&-r?vYo%U4jpaw4`pjVhdOA`P59B#2tJ^q*04%TO^vFfQ)IvA zWU2Msc2$}a?$f-qoK(7P0)bc6>8&GfD6VF_%l(HP{^hT|yZZm3eUwBmnO>Nbm6SPY z_ef!1Iu8LG$YLtJ#TOb{*abMUxII;6?RwGz^&6eCg9t%$67?V(X_2x^69EC?Y}fRa zYwrn72E7dcN3uaEfJQMQQbK^G>H+Mdtu3&%b{+sWR!>l-4gP>c9-lPrj`pPiN15$^ z90jIl2!ne#ywMA+GO)2y3#>~5lZ_w$`I)0@IF{95H@YQLLs{@mvq(Ky6Efx{Yz}mU z-aZg_80AK-1bkf}Jq`?SMft20wo&DC=}JG#wvR}b`s0k5tKB2JRP|sRoX1%fu$=IZc>wJ3hPMiG%jL3u{i@wmmk<2Wb=_$!lgrw|Ep@v>xtH7>mFo{+&qfdpB&1{}@c4+zZ?x6q#ztPXo#6G_|Dh(z1By9OOl9Fbp6yl{?D?;iB( z4BTkM!v;FqFHZ=ui(k)~Y;Rb3T6W!nxWS;mZgYf?n3FwoF02#j(stKJy z8wtMsaP?)yhx7ir3^ymk*5Pt0bYie#V#y6-uPUp~fC;=+=Q{M9m12QXBVo&lqu6gV zEvphL4`6qXq1VRg;@FaD(|E+tX ztwN4r{3Gb{CHyZP`d|9_AF8>`5e^~Bye-s)9Q3<6s94TaK7+sJvM_HcI$3d~=2&;Y z5Or4qi9fsXLKA0~=I=Vu|L)wd_3ySZG!L4l7}Qnxp-T-3{JCZSZnb94#LU7$5?^bX z@v0t~_|Yra&8O$pN+)191-9i^&o;FUz%b0*41T5k0r`I9mb1j4;&2TK>;|kG)?0&n zni5b`3~I{P&#gOyhC&Wltkg8fHv@e}PmXOUOaf!E@p}5-tAdzJEN$!&p6V?kbOfyd zTruL9x8_P**Ixbm9a|?2%za>QamzSx9rgW|qk1){Ag$S)*#y_PqlIgdlpuc#hK5D) zRX*gXy6wDx69>6Pp0H61-9;}<(_aL(u_+#2n&{{8A{tnGS!zv;|Eu3gk*3z1WuBU4 zapVUi=bFRf_TSu!&-{R}k*o>u{D2T7gU5_n%F)=9ImviRLEfvcNp}; zz>@zCU{Y{au((d(N=A3DJy>Q#<| z;HQVOVE*7BlNt~DP?=ABD*bwI4Y|^U{?t4TzIKy#H9c+{A!e$k!k0JnT|RCurcxZ3 zyiFPFBBTR$;XFIj(0gDsMy^(_5Q6@$-DCQ9pGtbF7Usf zagF)3AlUo_=(1V56zwSJHD|YWNEL!&fyM|}&(KTccgGZUim+UD>-e8a{{5|X)~xss zR_b{1mt9r~@}xYCX0DjV!b57@Un4sWWiRw_*udK(F`*B|OD^7&BO#h+I`3Ys#q3@t z_{A*dP$&y(EH7sI#0jxQE7~P-%ko8<{+4T>v$zKDRSnpQx!uiGWi+Remwp8iXp*@B zIydM4fp%{tX8+@Vn&BHDW{P+X)`j;6B(}u$jf+8*%F3F`+ED2lL;EHB7@7@%b|B5L zSN{^})=yrsO4!_l)TV9NmU746%t?e1 z`uauMY1_Qdfh=^5!dxIz+BQZBlD91mNK7}Uc@@|4ueRH~_lZYrJ#AdD(C-IgTL$NE z2Z;M^m73Ngx#)=VC6fLr0MZ|Ja+6y1)@u+$`e!t=ZRd8qcWYV!MbN;`AU2Qdd)VU! z4K^s}&&E^+)dz5;)hna-O!u$dkSf%KlbV4|4g7$}cHY&qjM;#F1+c3W_cSdY#1WR4 zam1_fjPf7vYY-!(F!cs2#GoH}sTMOx1VwPe&@5~8ouf1!2VDiit(-2X%6dRu3ATx4 z$7?;mSg_S)0KJ;Q`pr&*oxc`+9GE|ki04n6rOyVB3AOz%rw_zK_W`&UMDM^lxMgo9 zcL=Xr(Zoqv|D24pV29?&hCHy@JYSRNkV_~!unQ2K z?tL~-g&b{pRNh{t62T;BIr%)2KlI7yGtD5~4TaLSQ@!>JMhx*G`B0+;h!7&u=oVY&g(?*0JEybhxgf*Y8h_d@jho+{AjQV>39Jfs%ZDP<3=aR0%m3gn}EaCNRk&X0dW3zkj$g>HsT{f ze21^?)?{!2k<=xFrMVxFxQWcPru>S{O_-O*{fUZ=6X1&*8GgAI4U>!^T}u`gvtVv$ z*~m-eLXHd+y#P0bx2q+HhK>YSF6lfeqJN-af&gzbk}?hEqpKa!h1=(NLP7UrQ+P)- z4R<3F@a?#xJflAXy!9_PNKmeHvO$@H!+ShFZ5q*@{B z&2Z*4CNlC`FoFlxe?qx~54|yg#(Y}`GUO{}Vi|!hKE2WEzu)9KCDAn72Rp|MNgvKO zCZ5j-#2vdE4t)G!ou{D~MlzpHxZ^}mp=jEd*h1Qn%;q0*loIAx zON`>zbMGwCoS3~bylC)Eg=hjw@rWPgtH9RwE>%jchxDVH-+jsG*E6Ny(f})0I<)BV&j+HAqb%o(9nJ zCiVUxJAo=2otdij5^37OL!`_T3ySdDf!Ls8Z|Wn}l<$bM^~d?N&aOtQDwdrsmvhCi z2RWx6)mmw>yzkf>uO!15(;rJ)#~Q55I_DiejA*_NF|P?d6GWWiP(k2k<7E*sIag0-Y3EgWJH9Zaog!0z z5Q5x)?OnS9ZLMk%^VFB`(=P90MLrK0^M6Pj(se)cNKLYXjn&eqoZXT5XTG=#xCxYi z&DCs?_IL#3CiJ@x%u0i!;-mRbI9G7yLx94Q7GP&ao^LDy;R1K~BxQ{&dp)fPM`Csx z_HoI&@E?H5~cq}Z6%}|oVHfA z`*vV$O~in6vU*nZ`zsOQ%I8C>yD^S(N1-(m{KVI}K}zL>K|eTb5%~XrFr*o+@5>2W zdbX&kQ}O{LWnLuEnM_&T^DOEv^7-ND)S~k?l$zI_S%dtFmvK}~7V7|*q0fU!IYbUI zS=`8f`l)zs&ey|GG(Y= zM(3g}ZCk#el)RcXEqB1ZftzZ>t|>*ZauL-&a8b9iI{FJ(;6bZ4DE9Wa*2NR2Kj&O~ z1wo^(zFs13Eh-!qq+BJXT$}#^>3LfMn6Z`~xzmNiJd<~>c0BIrr*o^|a1{h16GwHw zYmP3(I4py&y>MP?P#j1URl0%!juc#CZPNvyOJ^h}fLHLQr;Wf}$j-m}g#D8Uggl5} zv1~jCKz58r95mWuh&uyWPJck5j!cm?l-LSdVa&`Rk#Wm6y17U;(%xU)5S4EjqNS7O zIkm`5hPBIb=#nN{LnjU|FHUr_&-9k%j%TobdF+eMkg`}S>NkGPT`kvR{Y*Q ztItR4{4UBcFrs~YS}d#r3JhMscc=}^EJ_>JWUv8(Nh?tUap6DrvV5%9Kd-0iy=4QZ zjl<1Vvw~{|{rW0L`U008G9GE6WhNnhm)cq&MGCh4)UQy_fx`NYPmfE7jda^R6eiRACk>tQEMKS(q_TzdP5W*VBG*g$5>sgEZG{!mdH#3jVzAboi z@K`24_f_tFLhMG!EGG;nyAhqL{#$i9L5v163a+CA1U@#AwrDR>q>U=IH-D~V6mp4s z{5>I|Pe?f?#bxU4BXQoO%WRhEddXh-h^wnEoKkKkltja46&r10SA5=$mKGq5r}PeD zPI%JM)%Ga6g&{*aQ-qc0#!z$CGfqdS&R>2+{wlr4*{IoDQKZqf>rT;Zx5hb2`hfB4 z&-9;so$k?X+*GuGnrGi_mU{HY%A>5lo~pa7#x6qjq(>@f)JHr;=-6*BPJ~oBISdY+ z54RboFz>5ha+|SKO$z9Xiz`+C9bZeHivqd~B6z57i!+$_RJnoPGb^dty(@Z$G zjm@u&FKGmN2C9%vK-Kn|cVnnVC|YMX+$8ND&*C6wKG=U9+&J znH-_HmP5bzyt?4VY96e%(R_+6{7W|72Dv>=*D8kWJlc{N&d)gAqfpD_JZwioF{fW3 z{B&CKvpL=1MIoL2&gQGT0)Wuz|UoRZN)>vs#XqVl{yd9e~Z9li?kzKCV;*fml zl})94Lt-Iuv{1H$2udQtFPbj;mMIekUCYZV`Zaw zazBUHi`g0}OLFQHJXeZb+2!p8oO7{t7iF_e*}a1LmEAH1-HD;=?K$tAc^I-Qm8fJP z+;rtNCW}q>%O6T8sw3ZWM0wLzLpJKBL9eJE5G`AcWb^znZdtWrBc|st;qkjO)}UVhi;`BuDs#ti5}mk0#OD5FBfaJ}O_eh%Y}4uE zl#9gqGmGWS?(h4W?y)T0$4Kh>f#a_60b1h1g&JFL34aZW3v)EFH-z9}%kgdPu;<@r zE0rGHtEXz0h#74%+&U(y>^vsHTVccEr3hSD)Z|2T%Z7xQ`OpgIv^0Az2!W%-L`|if zF$rUOUD@l%KKqwZR36hek2cu$HsP{)9ue_vRWpa z-K`viIC~~l~ht;u%)Ln49z@i%+#D=eP%61}k zhtVZ`%z-4YTn=4Wk44>%nCt4%9Xo)Bq z+%0x?D@jw#Y@V8Ac*rLQmpgb_9XbK`{8cNwgY(pE$xJd&j8XqjX!c8(2f&Pbi}UZ? z8duM)_Th0&EE{J2S>^LEkxaP6O|%`QEq+0o z9>?EpW>-_CH2FM0aF#oBmiD=8_}0B8D#=EKIDao0+RxbwgtQi0P$V#Boy^yD=_m`FwU)#0W0tB@WF!J#DF~ScMvxRkjY2V3R%KVwIs! zorn>QYw7p$W{-~lDH$(V8s@X6$H6h+4?3Ks$%Ae8XSBUQIe{z<{-Cv43Cka``~H$9 zY&NER*gfz5OYwnow4fTYNXm`2rgU&;&xh}@KO+JDB~XwH^e4R@CP1L$Px*rX66&Ay zV9-bWhL`d;%89pA!!G4SG3SPBaQK}J!J5BlPMQ{h(w5atfHno&eey4HI_XP!_i&|Z z8}~|XzS>{g<%rxEc+Rm?Ip+aqqqluP=EXXEW@vU+~b2+M}Fx_}M+LgQeJQHMf-Wk2<`i$>#%O)HuLT`|^(Ot(Mr2 zK>_?w!gRdG=>LD{aeSz4*Di9yM~l3Z^H4rZdd|L}YJyqHM=?C*we}$n{+ry4p8Z{} zYrC8{K17MfiHqw^+q&XIe>*$$q{-t0exS^18z(scE0o8@kox#KC0)V;xLo&l`lqCJ zeLBr2hP;cqU;?G3V>f-n&qAhivAmVUhnwgK)jpEp!_w%0pWpzy-wlAaMtR?eYb{ya z9|8XbF^j~py*%zUTPY$xrE3(^NJG^qI^%zC)WjY1c$H9l?S-pvg zRJTBz6O?yvE2W7?b7_y+IytoC$Y_iXEqGE~;+s@SajV>m&jdlN?f8Sy_h(y9$jYAQ zK0(dZxJ*|@h~j?tT2^U3DywT0PwTumJpGwwOaOdsxP^Y4MWx7hf*qyE9;6tDM-uv< zk1rPVq0{!ZbHdw@k2mjS#j!9xC-0LD;3)kl)P+4%gaa?1>QA)Yw}9BzsWKHGRMfn; z%ZDeX;32o>S~5F!)=3<*v&~!~zD`g*u$?9dKeM$&)c&W@O&}h-t>5LiSSe^hD0^nB zS(M*>&|2z9*8gDdJ)oN0)^*_^NE1P6f&>DB(z`&Y0hFpzq$*VbQHl_H4@E>VQUx1D zL8M4WdM^^1pwf%5zxZmx{%61mROnYL<#*19Q%hH9uPk&AZ1AT)zc~5N%kAbfa&Gj6gw7N0!7(XLdW+7!Ji z>=H(E*ovez!%v7nL_FtAi%s=Lsdgxa4~TBzKnD?2nN@DA2-I&9uel4Q{`-k5)z!cyTxfb%PiabFs&3R1b1(sxphquBTsEkyu2vTI^! z&G+-oq|mRtcLC~pz?Y_l{NGakcoT}S0TxbmVlR%NDl&rt5-VCDIL*TQgC^&{J!Us= z@e+xs8691NFWl6t?@n3$gz3J>(J9HVQK!In1-TDI}q@<#oSzYK#m6XnA$EbdGpidk+X=0fC z)<`U?La3ykL;C|IC3zZ=C9)?+Tj}cL3@2x=*1skk3Q+xxa47PBPB^5i^)Xx}ywMPg zETZTa3>3{p21<=RUTAcSY`RcBFj}}^RoY{(*C_wQ9ofQoLzCqJA#UMIi!METg8DpJ z%W&wV?f`~#7*_S=*gVr&p?9ZhvXz%!YNObj#f5! zc-~2qbBVCa$;*6~D344*8S>#6DLZRWEfGuilqubcR3Yw5TS`)qBtdB0lH?OdW(DIY zDa%`xROy*F)-1;!s>7k__&3|k`;Um6z>Kxb z(JvPF^4J+;;`S;25|PmjNH#K{S#rU+r1)Xut(2Q_wC9OSqXs&Z2G{mUm>TuH;sGJb zlsoNU=ozr3p_;T%z0dL8V!geGc9vF(acK70whuVsELv@|cX784RaTGikPiJjvBMEQ zrjy@MKG6>9^iN1rOK}D+a!_Sd0kCMI?*6J68c0rrln25-_BWkrp)gTTZ<&xh9x&yo zAsy)LPsN;s(<_U7aEj+`Lsf7!v_{VHD$Sw5^Y^);`6TBA3}L5wW`ZA-~4gXIX< zX^+T{)^qv~QgL=m$>1S!n@NnHZzF7Z0e52E+7vbhR;((=z60t9Z;Kog_S;DoiNcce z1WseQhS1>aC0eR7mMkF&FBmtyR&&U3GEzUBRF`gpHqF3NN$uyyHHKIWpj)hAF+Z%d z>szTz^xeYCGe&Z9CatBv8*W@PG6}l=F|j!k`ud&`c}*@8)p@V5ib)EVlPW7Cco{aJ z`I-p4vjV#OXiWw!G5Ol%5MFyb=fF$mRE`X5-kX`&Wmgylh2PdiqO_rRm?$T=rQ;%w z8Y-raj@R5W^MmcAQ`6W~|RI%$yP(<4XUH?QJ&iH4d?D87K+PL#CCp4TaIIHMrUDimrYsmAnX^nxFsuQ{BOB;jNBNhdZ4sDV(1#Bc=lzL!n< z@Q(&lZ>V4^B#%a~X?UkIs6fYWzgIl7tO`BmMdU- z>`iat0_^x=w#I_{-N)=fdkusPtj8`{CO8>xPrR2D#3~n}$f30rZya{aeHzX`kFsd= zLdI&mG2eJYrHTz1f9xZ1zxY%z-?w14TK40HTf7~uMmL!k%m(Wnu_yUd8z^5|5lu)= zyxQqCUOnGf*0L>N{HAV&mSS^Eo>8`4#8LLR@9{ANcD)E(dk@sc@i!-Jevi7rJ7}dY z$}=9w=n#CCWX1YJFuJgDNKk`Jatq@XqN1dFPFMPwvcI@+1g-h#Mn{SQxQQ|o;ERI6 zP2@<$qVTdH0nQc%H}D*Yob|6h+0a&Ui~8g7{4FA-Yry&~FWyY4pI}fnE!{&uPQ)-~ z4}d9~Sovi4g1O}te`NcKDrH|_`Eo?%9ke|iZ{%!n|L}2UHt~qFl7pd)a?AX+V3%ajLFgA)ll)Zv1b|0Q~K?I}v zol`mzG-Lbg-q-mSl&pB24pUa~`MUBlxW(8+^v*r29SqCsAahEQ8vu&O!EGP6jv&3pTJg{{-(l zA!8_o5Sv;Jt8-vVL5<`DOqhdwVIc+^Fs9dIelHS*qMlN1SA{;SA&NsU!iHz%Ib|5Q zZ_VswL>3N58>P;CO`7uk+O2KqcLF>!#r#pu+r3k$?dOcLkjYa+j-p}RrN)Kn>QB`a zjZ*JiT*?O5U%swn5P|&(`K=}7j7bc#2(|hX;{6kH|0iTupej5Fhzg8gVbf?Nj4bak z@up}0aD$848$Im#*>=6sUmTpV-#9p)%b{Xi8=p;w$1Mu!38MqOcHTG=$X@fJ^Gpr< zXttQ8!E|j{ZjfS%R%HlzbB}T=p$#Z#;?K zXeVn#8hTOTP$Q_pV*C@anc`~lW&72S94|YD9EHP8_N4Z#htmgbi}B3PqRaX((j8>U zMy56xk#P`YEeT1E`UbZZZ7O-_Q^V#K@q&?Y&5nZEOKBTrvh5`(2nsU{#;D0p$d;!q zOat4n5P&2_NL&!-4W7UnxoMh>LpCO|?&5?i&J+x{m!9AVt(SHD%*NR0IbAwz@~G}s z9(2ArtsijJo3dTGd6|EOh`;FF|06;~N5EOK^p3Vq{a|nO(h(E4qDv`4z-TwRO$gf8 zKAO<;pJj6(tqXg%$yrV_l!(u*0g>(Mg(>^{e0P8((v25uj&w;Jqt4&T2R4u*&m48n zRh?-Yc|C2rb`C*9KJGdalEl9C9sVNw)Dk&Wlcpqu<-rWY-isYoNR+e<@AH$PA3|cr zx4*miU32CBBuY|S#m#aq2`{1_iQ=#X8d_)&o_Ay;Fn zTIEmJF=!Nh+Q&dNQJy7At`)31_RjKI)S_P^rwf<(7Z4mYY3W-(24uEx6Zn!VfbV#= z^H1GK?_t>7O|usXjhcWfH!%R)oq*v3dG@vb6!+!yv9Ba|2rnZh@U8e^#IN?Q!_7$R zOF|&qG8;8}Ed~CP6#Vk~!&)V$G7_|zPGv%E#PJZfZ)6=!wUpk_=t#6hs;q5BmhIS# zqPoa%^ZxiXAyDpSI|zChyn2J|3w2$ElgjV2bvxERLJ0GIEav2(3H0g_tb>Q%6lV4B z6lP>r?qXy~W(`jh8`L(r!mKmDmbBD)??Yu4s$+vQ#&irUv_bK)2+-;yJ#aqz6ztbzZ z^2y9;$g@TU3OPx$oJ8)Mrfl)dZqD;Ix$@KKl*Fo0&t{0`Y0sz&k#SHE1O)Usa&@{~ z(-=0K^iFEZP6>(UZX%)V6wEbYsZ{c$Oi8kFr*1xHLZ|G;BQvK=z!Bgt zBqU9F{Km@G^R&M9=xa`VV|-`=5{(g|`g>v@kLsj&mOPj9p*p=kEChq@ zPs}ZDzP**<2DIF}>Bdnj8P#*u_)9+_KNhZBUg7>$F?1zSj^q)3nSmhVt#%Ac&UIFvIH?2V@p@)+Kwn}o zxQf?)Le@Z9XMNMl-5=jfwDtbFQjLb=g|cWYlH6BhGteioqw1PbmJCW{^6Q1!3dZPISXkljXgc3 zg~R!aUB0)YD71b%^!tB4bc<1TTcWKbyC>m-oOgt$ik4oNc8rD6pG^glh-qdvU*@pu zld9X+EEX9v4DBMy$VhF}Khe3W2*=YI>`Q=T1GOJ-TRWO4@O5MTf_oEGShLJeyKZU0 zU)c$Mv4=i+7TUB7Zp>j--+!)p+H~X=R^|j~+gH_dpj&4=UuvC+FZW`uPdRZydjp7o z{z-}b^*Oh=TZUdjLB^fyc#@i8<{Qq6a zS8x0&55JBr=5L;U4llQ#OBXHTfk40A-q%g_fVQxiqcX|*Fyms?PqneaG*A+Ow`4Q^ z{k1Z%rrsAv^qbR>WAK@xYw&^{ZQ)z%6qA5^Xbo%d{w09wc2w~7e@g&0$Haq$DJ`k+ zPP8S{7OpjMm>Gi*klH0s>ESZ6|Nksu`IiFyf2~0L&Eqd6|No?T>NN8g z76M#SN~-gZTCnZ%Kvv03De z5=xFs$Is4%(o?(rg=lau3tLgq;Pf@>Wv$k-%Zxf-A8N90$^J|16$RpuIKq)3wo@iHHrytPQ!T*Gu$Y<(0)YO_g{UX1dg9y z8t;volms%|#c3W}t(yJQt)L6j(k$vyjNPIPcO&x4`l9ifBWGhKGz#;6coC80z5jj?arO#mIy10OsQ`okSOC zWABlZ&HyK^9+{Q;-0m^@X%y7*m?XK1qIBlFB5p5gR~L4F?Pq6Cxt3nJpG$OzI&Zf4SD zDXH%)+njiR1v|>vG@}oi>+eV>)D8ymmC$E=DUnN1ip>EG6?6JjB+n& z=HyHUM?B~P#i-bVFDP?;e4$nPIALpqlLpCodDzo4X5hCB?k3oY2w#^erD7djqYc6u zNIHy`Uvax}T}I@T!te|cG%QOA6SyeAnBuY4uEyz&j&kx6gXzQ@C2@{vKbQRgf~I8x24YJ938vK^Ug)Hl20qC z#^bZ|LMit=$-=(*MNbwi2_JPouV5a>gTzG9e|m#&n|sToVv@&KI&+7Vts z0Zno-(_ot6`}S>2Urd*n)iHzC+Sxfk+kkSear>;hEaIR31OWLD-IoMr7EKL}gyC7*VAkuk-fym6 zeg^Wf7@2=ON*IoPYh=9Ve-N-UFl`e!Vy@ z4~hRTUzRri3Y7jtRL#-BPuq|2LfjiG3j##Ns-umygIVXGlw zB|NyPb_Pr<`M!JrxT#u)VZ5 zt{C=rv`MJC38;KGC%!`1OL7ZSI!gF$Hix7VTbyPrKIw|KU{LJ}&*`X`S;a8(RDoGlj7odvufOii_hV zzSGA@Yl&EiPI;Za>2d_G2Ca$uJ-n~=ZcME`yZVkfc+IV3FnA6$Q}ius&CaG1sfPfr zB5|Y0F*KCr?$;&lAmEh3naBaL*qrZ{trx46v?(=2mgT6-iz+)0z6cCt6w zAP%Rqvd(6r&q8i4NyN>-%8rJp5sk*pERCAe++?A}#+=-Jlx?WO1-b7eUUeq69dcb& z21+SUw87FYaZ<*LYkY36SM3`A&3iWijGi86)v|MAP+RFXHm9NajiS|UnMNYzN_TPi z1p5@M!3n<23cC=)-Tmr;-e6zR59dVkY=iv^1MDv>o{0#zkHdJ#=K4u)H6ud2jS+R% zBz|mtc2uVL28C|wjv^C;1}mw?LYH_8;7E^_*ky-TYKVqcr~@6Xk`w>Bmi>P%o}*8N z#;Nj!w}IU!p;zWiCafA&wtakW>9vxXF9@bwobR1tLt?09XekmusJ?c zp5s377*|#?c1`EX?7VvmASuMm%K<-fgv*GSoVN+WbF%A7=SEU(W~$E4jr11`51I!+ z9}zF5C`8|zl|n-|B%89gLKnj1a`NK2#k;b~2ihmsKD-A=g%j-oT=73dy9e6aAWK(h zq->7CROw7`+Ky|*`Tng9R8NuUt9$G0 zU0gY5zxi>0?>`=PEkBL@If)-JvBWXSiFBgL$?4RdDn3oG_i(MtjE<`39dgZifT5#4Mk+w+lI9$8P>HTpUt3C7LaAl#KXTsqS zWVo}spx+BgAN?y(PK8n!9EK6)sWIYi`LUY zP4Fd3VimhlC(^}NEA%YM@8$=;SLRIHx_Yx*k$7bF#r4FKN62WtmP-_YC!)hhW#wf~ zcXpmDtCXIg7C+v=;ZyOVPuwVc%)W#f^(eA4p)mZNhZn!Mc6sq@_({=YsYIuR7$;AE ziENVfb+pyIj+O4tn%)@5&*_wO#i{Q2RxZpVueaWrAaD6Lb#q~`Z2u~IN10TXG-k`7 z@0eEVebs30usEyScjyhGJxgb!RrT`(U4fYdM9@Gg)<9{4hqiu%Wna5fA{CwrKi4Pn zX&|VrcZJXGIvW)583tr+UqK}w=_NDXsN4OxWrkR@^0u<*zx@nYdLB1CMk-0fqCn)9 zs&D-eG4X8#U!nwHV)D)$>P$&at}VBV07lhCAJpu}eT28Os~5IV)4Wc(xIeb5jcZWl zAXFpAg^}H_1B*qHV(I69^s+EvrV|N_Dj)>N(II0rt|NQAIZ4TVIzOZf{(}#N-_p!A zi94D=s~kxzO?+v+$$bNVOdfWJI=sCwd+K_63xpcsSc~> zAKEV4<=Ud%JKo=P7!RR6yhGRfRV6pIPXJt(tjmXy+W+a>bkhi$>WQh}%#t-t<4rAA zrSWn)2Uf}tHakM`3=^euUD`@6qz6Oe_ZLsdBgDjj!|ntpKG0@gubcDKB@Q%D9+^y^ zmA|e!>$Neb!~cTrD7mo(2k&9;wns-Q<_1Tk>o$^+zbhuMh?_{gU)cRSh3Ak6H{Hqa z-v-#PvDGQ3ycmr;&d3SOD8wAi7{vna-Q`!7ForX*?su_0CV9hF6y{A6Fa+_Oc_L!~ z#30s^C~ps4)h37?^W@-ah7+yFm$E`F<7Hu^-@o^_P2Dn%aJp2jK}zlxp$W~E)sV6- z!&;0PZoIZEV`a=fC49d`e)04 z^UX=A|MH@BJ&wPSC+c$}V~k3+E;VX{ZMPR`98wR%ZlQL6jO>!@>zGx9xA{_59ezHJ zib32y6f%15bnFGARuD~PC~9dQuB2*i>A+Cl=Us(!x4W`_&<4;nw$&4IjIB1$5`RTo zR5=gcq&SPXlmU&KR47+cK12U)>OeGsKG7*<1(HBg*$-_#nk#Q3c8X-eoSAZ) znkQ_b#~_FXXN>-ZO2yFmT8jnqsm~3M{HjGlU6!P%Qm9?D)=WTb1T zbxT_@ZE}>WhEZlCohzwAe9-;Q+k=w(VNtIGGS#8-vzbcmPss8zj%r;Q9{!*&lZpj} zc~-qbwSUsqFIUDB2$ft1`i+PUv79eFIO+{+o}nesf*~Ew5?pN}eo>%wpe>a{xOS9k z%+!4*vg2B{#H6lJH*YD|hko(>)58Nwh$moipH1BSj@lr}_EyD~@+Xl_qtyy^iGk2A zG1+bR$wX7hjvQvHPe3|gLvwejdY7;>M~-?xU6@Hq=&GfVxhnn~>B2mL_FU-JimM~C zR_Cd!%M`EY&E7#BZf<93ntmUh{F3(Z)d`p{S-Y>e!`yPX&0J=oYEHpqQ+P3BUu|B( z%UXClZ|f%P0Zn~0#beeJaY9@T>oqW;UF!OTk_BUGkYnct7;2L&oHvIZxBAb>P zcoTopJgQ>WmQ2SJ`DFg9!)+59!)v$c%Fw5B;)o%zn9zg=VaYu?2I1IC;|gEKjnvo$ zLMI919s23p8x=Jm432u+!;&1rZ^xky` znY)>-ypBiws9v1-CCX=(xQfD|&tMIv+ba+?9#hFzR*Bc`vhpupA5@XnIz?(KWEdra zSwKSye+XYbM?ee7fIui9BoK(S!7Go}+MJ~7t*nQ-Y(p*8wevM7=e^c16syH--r*G3 z$6{EeHuEsY7F4i55qcX$m~VeLkqFpz+g!}Jj;GcyUaLlcno(zlmw3W7+AW>wV(1&u z31&bT<6Q6nbm9QHr~JDEOd<#>k4y{{_g9_m!{)Cj?29*wT{q+lb#oI`^G**?QZ zA5dKjCq*r$;?Xt>*D|vg@P5FF_uYPVgpC=cT~5AFCAx3=oB;zyX^I%x(YoCGYSafg zO1px)JuP{HSCtmbnlT*lHU6GvOJP+*d(5}71@)I2wD#lj6rn<_)&TlOMh1F^Ir=_n zEwI_JRnTyV+8r@Lz-lsR9;eA$KP1}2^9n1 zuBUSgWW^SNZ2Qf@5cxl&2K-MC*ZxnB?>`~D)9tyiW*&Q$c#tVhs3ndY&R!xrZ&h%N zDll<%hI8LX0w2KabsSlJLd(Yy(tedOvFMj>; z9lbOxS}eP@G}kUVC?;4pvO}T(bYc-3w!KWNPd;f6({d`E-5J<1?sn;8<`*v?Vn6S^4|Af8m@TdTbd<>j=A!CYgI*Q-z^Cv zu{y691*pW8U8`|iO-&>+2Drr9-ScX4wgH;g&nJ$Bl2UTshtR2W5Yo>R))E{*^rn$Yr<23cQ8=voRAwqKYu;DD zdHDmwE2VmfSOv0&oBh=rwAochb~96OsyHC)yCJp9l~j1@_sehy>ids`r_&a0cHO+F zJZ=%p44K!oA}j?0hyG+aEpN#*)VWP6BM0-mDqfFgwcZ?25`l_bMyCb^=1Y>0gcbH+ zX&Q>p?!?}syUe!o0wDxv)I_4GG0+48D8GrbibPo^YO$ zrdD^u1k_U!`HXDv2F0_N_h)CFZn}T+F1I5SSC_DiHOUGSAuuNRp`M`W7t?uf1+~cGK+ruxCwixZ}5_h!m>#1>7xYz^*y8Xf(Q?W@kaIHX_-hT zOG33;8SV@$1QjYEJZNGkm?5$rb0&G|(c=Re0@NtMmf6?3k7v)iKUoxmdOEY6FY?D& zP$T{6ay6VANjO7$a}w-uvPf^(z`3XKgo`aFG4PJ>jPTk8v|Ib#f*t{vpnM6BmMZl? z`60OErCJ&DK-s5K6%rcPGF-(>SgN1z9LwBI9u}*-bbN>n1<$#?g28zK zkhhn#dV|39K7u!v{DJXe+vL_jkJ*Ykdgo;-0B>V|wO-I2Q2+;u)dgUh-utBh`_*;B z2ZqQ05*)v1@d$e@v}Sb%=XnMANdW|^r+9%7leju1h$94&kvI2`<TiHxq+~(hIomUJDzG8vJTRUrJnM zyJnz-fl@&Lwqh^Ik@7G&dn&6e+SWenew91-6(f4v&oZY0HOIDk&jGBfv6TW9owcwv zdZ3UFN?N;;wmAZLVon?^EwxPgyNY7a^^W+nlDx%yZ*rk4Olb>^q_vX=bb|w|CQi=|mX!Zmpw?($I( zRJL1=4j$slncH0Z$ZU%5^@r4ZgjUQ zn9pxGf1Kf1CMhdAkc#M(w?4duHurj}rdOnU^xW5X)g8MU{4L9Gr>dB+_Vk5!p37Oh z%PIdFVeeG!4%vVWFLV^@byZOt4^F+cjG!>Lwn%t6ic5wqyRcLkWEtH|$#^uOl_ACB z|Hg811-@`yzj}dKK+KA(+O_DL&92$~pO8nD&+L4b)9w|_Mm?G$mOMit0qgY`w@dl_9_rAe>Xy0d6DmK5J_7QlTaCeA38g!DRJ9x=Yf zv_dkyz4ZY>VppUj*64=|Ex}w1lI*Agk>qfejTsq#w#b))Mhzj+N|LK9ein(_Wr-R* zfHF^1+3V8=(gUFD$K$uI zpZ^w|nMc}IxA2!>x{?+xMO*?2vyD3MjKHFW#mw?)_1hKkT@kHFHX`V$OHrikmByVF zC~ph@^L!GPkA-&T8jbh}F!CxzRAM7ooqC$Sk)h$1w-ymiXQqkb*N90VaTJu!K}{3c z5}Pp6n>Lc`Y>HRzpI2_=nBm9=C8)RrO|ebA^*9dWdm7|O?VBIu5_@%yYZ(3T49i>P zxpuq%$JA4IRfB0od4d~8Od3BDq?VYykR2+cu(JdG1DJcfKO%30w57sCV@Vu|2-cm{ z7-~D9U1i~Qq!*eWs-R=r8A!AwN2#9elK}u~Gh2Uq%xbYp{6VzjUKp|PLbbJ--CpPQ zmONeG(C6o-r;7##zTXcTc~Ui#dt(ISCD8zyX+_Ws*4ZLtGq0LfQy*)FyrIc>c*i%0 z6GEM-0G}t8LMCdPo=4u2i`AP{d0Y^~ml?tv6rl8B zvnkQl+GuyAjeNF?uCPhV6fdv-r$Ba*oiNs1Lc%DUgw_>L=t7y_%HNKM>cQTUSMEvI+etw0Lg>$mW5c;{{N<3wRvP`z{@?ntPVs=$o9 z<9t&0k!Jg33&8O}7~|ZTmJ~Ys_el02qSd1UO?)3mHXAkfiMn^wGp|k79*8bW{9Sap ztMv{M>^NegU2_-fuzyTygM7k|-llrMEsOIx)Z2>pkzxUBkGAPoxiQ8hpQOstC6i|$gqJz4iG=V}Y z7N!p4RDo{?eV+v=$h<49Y1gDAfI}gqoay}XXR`dn2StMTu76mMc+Kp!`jGG4>JLN~ zh|ms^hIk*8VKvhfKhcXh3a@iKqFo*I)WK-T<1z%XdS&6bRWJ}EQL8Ql10y~T!NQY@ z%e`_Id>(UX3qS8&i;?2NqRVl*QgS2b1O=sKJ`R>M<$bh(Prw&KgC@*yo`C9Nb^;X4 z)HFfc!=Xl5*U{n3muD7&3s*V(U}Xuz$|KOIGc8mlZGPq|KJK+}%+)9oS5t4-xBF4! z%B4m3l4Dh@Jg&q-)&nzC(iXz7e8NV()B1N+e^^u$_V~+NJTn*XEPS**;K__^YHH`f zAs^M~LBM|iJ5mT8U&5cc+_#ouwGcmw=wuiS?(+>4saCB5MILIWP}nKy2Q72RsAU%Xa_t5Bbkm+1K|;zAVfpg?1_Yo~c!IfQ~G#sTA4gP#yW+>_K*_WT?eHaO$6w;SJ*GcD(4_efd`3}cNo6m7y{ms=dx1RHJx2ltv4N3`l(U%L%2+y%%SypF-tLE~7;+0DgAz!}Fy}u?kj`)5lDvB~u zxSasc>SQEqkn9Sv_9)Q1#;adk`kaj(N==L`X(`3LY1fd%$ZOJF5p)$6<4$+JJNc?- z*Ti?M!}8^9%+c=Xl+MCFF+NWb_NemQ%o7Bd-y4mUj`UEMaw}?O5p~D+;8SG7Y{y7& zUWk2nhkXLxyo%hg4Z9e+F6da7P{-BLpbjyN4=Y%UR6rLXAb-9&?@rhGsu{zimpxfO zrV@u!ToEfwDIcz>GGad_->g4eiwtxu;baFH8Rn{+-=Q^>rzhn-CcV*qnkh0bGD-^Q z$pm%jt{#OMb$c-CMQ1O*8;pu}_s#r>YfQFAc7ev*-*_4S$q8HgG%z&5P|1(s1;GeQ zLiM_W0mf3%KA~9FiSSu%dM#eGp9yIvkFWQ4Qt=6@tsSpS{)A@)OIqmp;*o<2cJV<4 zyJ<74Wn1V*OYPWOqG$0VBE2mme($fRwk>(+$4~4HLJ7EUm2;?tbZCh5n^Q_1lg;%^ zml2zQ{U|RLoV+&dwpgnnTv<;|(2fivU|%pTOv5U6YInROr#3?JhzoN{o_|g>BQv?? znQg6&RUqmYYFdrzuZPT&$Plb0zUA{+NGKfC6mPXjSJs-G)^{_@=v_JA`Rd}v^5Y_d z7suNyiy)Dz3t>*>AmNV^9tpGcb$w(iUTUBpCUiyQ)Tlip!d)hyU8*;F9zia!m~YX~ z_1&MYs7SJwEtjN(!c%s)S1fH-XRdTT*@d8J>RB*n0-=j6yjBt#`q{FN;*x1gPOA#` zE@qLVSS8m-x;LdK3tbS=o-Z;95fRF2f?7{wAjmLWLQ)Cp0c>>^fHL2!H;A&wE9}0V zekkznc4l<{S%u*P6Qqe>PDs2FU5H68#6s&&h|Q~og~NN>9!7ZO(;Ij6@Pzu{zJ1dG zU0Ga^|KLR^QCGdX2LcpucWrVZmF=Mi9|3pZsGwgjFLw9~z zDdltbhYx0*B|G-cRAXVOv^~hd4?!H>+ZX(9J?8|x3ZY44G=Y^3J@ew$bAQgv|4hMu>hB1BL-g$=l!P2pUB{NIje9 zEgIBJb^tBb?C|b9Rs8(GgVlMZCWAYGwDl=R|T8PA2M=A#uaHm zSo{rqQ+*6Rmexf3sN7ex8Y-P&rE8XJNE>yVGxm(t3)N1!yY5uWY42LTv-v}plUbuZ zUj|SVE}q28BP#7cNKFXW{vm>lOYr0jEl9P^wJ}_?R5|Z{%aEQhOnsBtvx!0G>~s~> zBg5CbW4%e5QGL{cVB4o!p%^{6*(^4r^Y)RhO=VK4XY{viuY2=GHnTs#1U~uODEM#5 z#K0ijsRzORZ-XjF5}W>3!TNr*(ph%Tw@#sF0y9-v%~^C^=LXYrl+%{%ug_g|;Ng3GvO$5HZ+*($#;($r0uY>{dCM0G@2Ux_YQZT)j=dC3=0hhslj*5Qd1z6&|K z`-wZDLz##_wsU%gU`t&fM6YHKGy+y*ylD~H0)u$PgB9>RUc2|6u}Lv57!*FTui%n% z1VPh;^UKZvyo|3#EO;ye<$keYxH1gNhUjmsb7&bbGPXK*PBF^vOF0{^;}nX}F$8^- z^T{OmT~>TdrObJoSB?BQbgF5b#ND~O*+zJJ{_1T@+;h+ikZxarvgfY9uMn153e$X+ zx6d{>Hx=oO__HyBt@Mli#xJ`bNZj*!?fNIPweI{?*~*1S7Cr^mgtnAHpn-pu zm-i267Xu)8KR2G9ej$E$_SWM#YejqM-Cuo%NieB{gzTTc^u+A7T}oa})$+V(GNx%J zEM@ulI=_T|Hv1Bu-nDoeq$gD%B6yN~WG{2SQf{I^YM1wb?-Oso-;7v}0i6$E7CXGR zwXqlcviGZT2##;TVF_eyJ~=?%Oy%faaq19XdsQgl`&b*HoHX~QP*`BU`p33xrQFyZ z*9`-}_cXrS zy$C;U>O3`6>lexchHmjT~WYJZPoj2HaCHK`DC8d_qwmhc@Q9lFEn0kf^4YkhAZmp-e*b}=n8GH8}M|6~$yc);m zg{r$bDKeY@>H4Q0NFZRdGAs0a?K3qvW#7J-)9cRA=(`>oqB1zCG&N%#``X>YO&o0v zwPr?Y`PhOi2M+8*$50z&+;|w+`qoch7nz!JmA)x?-Y@jVm~T?74i%AcLafuY z6UUi%Px9)8>!LMJwmiI!n zS0%}p*}MODIXH-N)}l*zTksd|<=eQg8r4Zi%L|E+C`Tly5x&XM&3ux0GUd~dSENN5 zSHI$FP~7P53S(7;OKpeSjVFdT+fz*q9E|Q>o@mSTs7f9?Q7J8FDF88PNE?1bF&S$d zfOd|qnNA97=oMmnpuTrjB=|Vb?8o>@7ll@k4_EXKZpYaviLpp&t~uX|{2 zglv^`dbFpO}P4E%O64NSJNwT*FTq&tms3TPZYBQB=%4 zZBgwYLC-+PD>3!3)j3ezGX}1=UydWEU+}=~_$1G_#l5bIk9}?$tf+C_{UQj&S5GP) zV0}j@e*d`&GY11t0d+^v!h?y;QduXg#9X1#xkF5rc6{jOT}tUOs|T_A*-^>tj4#Hz z(iVs%45U0COo|$Tud`dVi$1ME zPoO8n?u4!-bJD;1ewHzT=_@MF{#&Qp{_83``}S%6PR`z*EYmrpnMM0k*nMQ>B?~}4 zL&oX7;z_yblr}H1EI#O$lwTO82uda~jp8BUjC)}k&I{EjO*`*iG4B;OT}-rygz@tA z7aNTdGaESDZm#Tk$sY08PKREzj_W4yf|^Z1V$*x|KDk9h)aqk3Cz?6l!ePdK4=ZU7 zVLc_;oMQKZ_p#O# zP=o<=P#Ud+1>sLhE&t`d(WFcFqq?s~3F$H4c%&ubC<#(9#hLNXaeR80!$?+n{Hb7z zB8m6q)2c2sZC@DF)E_7o84H&jO#_|JBK@^XBe8;e#Yo7`oA96~%aby1lqr$oHh$pRI3KmH zz3W1BF(3Ivjx1Tz09lUON>!Oyxl1X-kTR6A4Sow9M>)YMttz{~=SLg^&*-xHe68Fw zwLeV6L8bJ-06fkR!1n(SOi!*id+I1RLxw zP5Rcy5#Gd30Ky+;M4_M(kq2ki7yUG8S6HtNa4H%9eB zd0%B;$TADP_FC~N+%AgzgIo;7WO*YRlWuw4S1M9JEi;*uStsv4_mZk%rMSmx7aFt zdne8B`UyYLk!IR<@)Bl{ghNm~<+CsKOd5R<(yql04dGUn`c)Zo z+SN(%uTOsq=baUTgk7!}7^KvEa2!oWokqL2-9Pkk~tARDY=I+@vp) zk#IhFU7XL*()?+)yY*G;)M}EoOi-TxyYi0CX0REfvdML|-36!0@cepR6M=z^Zx|#P zTtf-0ztf!l>iwUZF?SuPf;ARP0?rHe_K03UO1y;7Gk9~&NJ95LR>xjy@Z5%88ZxRC00ES4$pE@D9GX=gMtiqoRE-A76`c%lT zKd}Z?M$+TI=@(3buPVPjb!%}RCA!z&fvO|0`X!yPgTQ7W z4xfO_MeSdo>GSqVY{PH;tAnNe?IXV(#lMgB-`DluW8mLo;Q!eeXtp&aEhq{+P!hR3 z2?Rl?SI^+QI{ucMokW`b@qc=nXSg*DP*{sEHSO0QWG}gc zN}Bh~Z#^I{a2jAj1r7Dt0BC$G>*eYh-mr|_(cB%c-lgf4Kd+OonHk`95o{?^;k0l^XZ%ner2#xss$e z>X*gjs1Nfl_7H(;or05ctH4<6@U7Qt`WPce9*=}hwj4Ek<46W?N~B|oJ4nAaYIFGL zzRWEP<7h*NIA)fkOdRJf2_MTL81&S3n(6u;ojzERh2)WAZyRX7Z6?xDmycy#LA*`l zMkV6?IP`FU3~>X2=B-(|g!#)+BB5$Z@J6G?vNY$Nguxq$XELsXL;mZeYvog=Rr6_bu+NXuTd4_V-`} zyCM)wg@}8=&WygYId>AfAQ7&kW-Sn1XZ@@V$M&L6#dq6QZBou4)eo+~-3JH(Le%xY zR)DxO`2Z6oFi6W>e(SrYbEcaO{xe+4$LJQQ=%b|!A~dRyeJ1$`8yKf64k+pkm$U4+ zR6f45y2)ouo21C)$Z5HmZV_BBZe2e`XLlnp5pg4(*Hq&o$bw}F>C~zqOm%@4JrS9U zGM56BLzQa3;5mS~5&pfMExVf4#xDP|evA4#roa8sA-mrS*PL&FQ7YE5gPa9NWCUR! z<#<<+rd50dRwH$pPc3jltbwcj!E|-OkNo4Z+7Q$jL z2fiix6O`$2{Mu+&7iyNv5(wCU3LOGs`nFqQ{vF5PKdF~rJFtJG zRpJHTo_0v6B6#h5oPHs)VRGBzUuKvyJ(r(f@H4CX3A&Pfth$<&8h)I&{`V(4-3t4< zq)X&K-MsY)+rdCa9NoyxSVv~>v)i^|c!}Yg;dtYDgy`){UuI@<0+dzQZ1xy(o7DPs zDAl{hEwREdLOqY?@)Cl^!6v{nxt113YW}0j>pLjE$aQj;~!q9F=&P1j_yN&DIk@VYZk#s_Hgt`v}VtVo0ZwUZs_9@?Q zPt_;Npr|AA7m?qqa5}nqQ@xfN-wk~d69LHWo+m$J$2mPTlz)jCviv~aNLuQbUk*CgNhPes z!M75Qlb>}MgFBlY&CBB}b2q>KSo=O@Y{72%a-_$pyv->|3^4=%k3$(@xjN~FU-b`) zQJlED=}|WUoU8lV=~W7ZY(bJw(&f6p!AD7bC&!%@lGk^Tn7xAaiVI4Fo56%?)P8oM zOX$!J`Jos;5EX7fxN5e$2BhFV1=7pko=C&7hSRAi73_{RPuJf!E$#200g|g>G9$)K zWrV(oTI_s-8Hv=_U(NDo`l*86-&(^+*GD zK)WY`Q>qrv#Hw3DzY2RWuwW1_WBJAQCOk_gQYMEH0};xYLiL>ukPW?fpF)@Rk8g-rxs55I26twzCU`9)OuUH-z}@;U1$@8-#d7aeOcwP{2_)j*dVtZ$#V``@}%tc zIsp1#4t?U8Opv`UzY>BvB+8fiBP-$2U)jvBR-G#4_rqeC-tPM)8QM((fB%0>=(yuM zsHJh>@gEKg``uI5zl!;3iS^kY({bRjEj}^;9$Ufv10&$Eg-zlu*!O_P_FuEeYVHiQ z#t4k6LrJ(jBG3Ti8h1D7AL2kNr8&3MnlH(ok*b!I2$%9C|Jz*AT4a&S=jvEPEiX zCSlm&@U{H0BF=rd4r~6IHa->#$pRA(*Br}&uYI{OX)Rzfnz6a^t$(8y#dUSQYt`c` zK75R~yFEeXi|PcJHd?IM99ash!yX#IHdAFw3+mN#HRnB?-Pg3yATW(0CsDK~n?Tfm z%3sJ@+lw%0%q;XBNZWfrFicvH9MPnOmcZ)8+D&>qi)8oFv@ zf2QSCciLL-Ihu)IzWJ&*3EZhTO!IA&;@6j&b$l<+0 zKv@$WmkI3UQ3}1t%>BzV_`iD|474DL4F8-j@&q}$3EvZY#}~Ym)d`5;eO$ZQ5hCepWxAyO+7jERNfpaqn}QF52GYYK;UB^tHf=gAjyMI@8H&moa3K{EVu@u*;IX!n*QmJo1RZ9>C*$`RQ+9m$7 zw%0BtzV$9oJ$7Gr_cMw^!l#(`#=(5v^eh$_P6c8qe@*GYgeh%|rdQPxIe@HZo&ILU z+FqU5viFB)Sx=&8sJoKtsDRb~UN1x2;-L#Z(j`l?JcJ`bQx!Txv`Wpr3*iDI-DVxP zV%;F=OmjzENi|PCg!n`7UU7I^@D5O>HMMf;hO3=!Z`dl~2;wsz0V1;?@vuC;XV;yR7G5h~Wh8ThndBsE!K zw>+Zc#$Z0((;mfmKgF?85_h1drvO^eq1qIXOBp1rh^6r{NW_;lTB{vk@(U*KT<`6|Gz}zNa-JWi&UDb?8s^PfTi8jktT(9x3pY|C z02at2TVS2~G>X~$ln-QRK2||T&;1@z zQL#SsU8%mL2Ah_Mi`s@Sf4wb#Z?~HM&04_b)Jnj@C_#=95b)*xLn2C7bqQ1ZZ~uTl zHrTRS_QV&?b)H5~*VX+!uKvH?_WsA!+J9chjkfzkRu0+Um~CndZe*o~AJTt0z3l%b z+HlR`O$~mqs4|wl{IVLG&41e=+g|co|IKWfXooJC|M(M4;CA4$-^$lQ?!JG&d4N+B zJ6o99>(w8igdRnbAXXAm=5Kvz2E$4pz|yE7u3GDxbxm*6cVy0l+`-3yS9msUvI)24DKscg_t zTGA<8i1n^<`Q3F==l%{7yIYRZ?~ zC>d+g%ks>UlG}h(;$)UODVeW_da^}|N|8PD6W|&#SVuK=CoHG40ZW;jypG9Y;n$R+ z31xdh-h%3N{#Kdi(y&RTApamorqvU;aL|1qD<3e+#S}|%aCxAo3(P&1~eHH{S?FsWX>ITaQ2d_4?0U!jvc0wS5tVGCMSH5n2aLe8F}!_GcpO5Z#Yl5bc?Rx3g|2%WX4T;#PSdc zk_#}+S(okiNcl)XIG@eA8ETjdzG6Dh6MXES?7%1cDbfdMM@GDZEefY zBe@4{Z)I5o&6T2NjYigY0*!V2;F`y4y1Kn<$~FarAWjkZ=L<+Y)t3_N<;?REO`L~*_98#d>C z$k$%WJk9wIF46-PVX@JGM_Fz0wU)fB!AzLCal7GK)x*p|7{dSrxOpLf(vlZcpmYyF zSyF)X8=;dN+rmE&CubcFm{t1U8{jV(0^UAq&|k~ke-yoE{==4X8W>-#Ya1t30F6Xi z*?~O<@HUPz)cyv*lU!O6*d_p#K}>>!-T_x>R2@+B{5Gx5`7k8G*-mgUevCm$K|NT+j$si>HT*rs}wfj{#5f-0%R4mdxM@y>q!pE=B^zWJ-jgVYE9?g+Jv9HpS88S zu3R1@961xD_}n~Nl|mEL#s+FtZ1!SL+`6>iO58P-o5Vx(4Y_9z#>n_iO+pI|H(OuL zZIPI|`U=;%LK5T$*;`RXB$QhfPlSj_H#}uI1l$h_mq@HxF70aH_ImPyBkWl0Bu22g z0gAp3Tb(cZBRgQg30F zU5mAE`_k?L-IaeibZDEH2&TTbl-5&Llg9yt;2+fY?DZ!Oj1vdEs-*~Qw8(gNue*#; z3Xa3O(y`p(`M7<5WIoU?+zns&971VFq;oo({Sokb)%`aB=5Wc1R=WkQnnU&2*a~1q4U;g80B?drN zseYW&rvUBU3|t{O+r}?%ctF7&o;Gf!KY;GZ~xm`?*8$a zwm+`DXIRE4a~VT_`!cl7Jd4?_Rr<&p3S(IoI8UIFp8iGpW&-a9m19m1)GtqYfIAM; z`KE8Xd7g{?;PHi{*k);md(18aL5dg@%Pzx3XXZ95ZW=|PUs^@!!{ndm|MS!2$s&*B z%RO$NP|sZ}eHZDp03ntIQ<0fQw0Li;&F9wiA1jd-h@C&<6r1^iO{}%lDJCZAMRki7 z@s#p;=136a#ZAwBO0`2OTh@hA`{hNy#xv9llgC?>!%LuY&geplwK*9)`?T@3@In-;R`>oAzM$=D#qLh^A zHUnFC!?=Jtjv`!5))CY$bN@_INug4j(0efp*chl&gcwSEh$I5Ck&SoRCCdi^gT$eC z5^Is&p#X%nc78mjst~kLaaTfe%Wr+jiV^D#Y|t8Rscks>tYDL|_q zQ2=1pP>>TptH?bxkLN1LfZkIR_wpyl7F2s&M~+mMcn(0XF+R_yo?&Zr(HX74x?u4;rD$ek`J)?DFm=x}9U8nX=s=fQ}G z3NUdDf=*U6Ka>5Ei9a^k5;|9Vr^F)d-4bhiBHkxQ?A_2VxDmSuX= zYqc(7Syp4laqVP|lyEAsR!q;rr@12&*)F>F5;O~|@!qeHjiHZ_CK{Wg>KBvWSPmXo zz*?t>`-a;)ZWuaE8zn+``=7P?*+13R+q_3mH0P@!awq-_IX7KjJ6 z`R|8U-SrL9&17)@aKOZywSHZH^q0m>g9g;gcGq08iIt~r=Un@0R4WN~9!@3d>?f*t z$t9`%O9ZUfaffuZ*3XjW{ z=osnK4vmDz)NN!+k%+peCgNp&dAy-MYU1r_K*IIhWBsb}i}x%xDxTv$*CQ;Z;Y$X! zmqyO}XbZ8te;0=U^No@E>_WEWqa41aXXQl5x=yU^yCyJbXBH#^?J^DDOa8^K{Bz%J z1Wmi8*-gnONA`~Ud{yoDJg1GeV_55bZH>d&y|Rt( zc(}d2G_{V)G%^VKVn|9qxTII7>uf5_~FLa+<#_%Jf5FoDF`J9eaq`b%g zXK>($zCzjW@VU2xm-@CYv`7%RR|#7)^Dr)XPxLLi+`Fx7f(9Q}T^0F@C;Yz;c@?yN z0@#!um-hsqCW?9pNbdn%0a1a#tif>^;5h_8l660=mj2uC_`rmkPT)%4I|=8!Kkflp zb2r_8t=#|6F=QJ2o6f;y4)p@M?(GJYnP+|{Jt;oTQRDX$3FUyqEad}APyE%`)Hy4q z7pfD%Xc9iI{5z%QiktTdG62Y2_yQ>8xC#{tBxj#gNEF$8pO9F1s2&_@7Jr3C?w+hx zjl14&{Lnw-^}jCdANvd&u8W0e%eI0PEZMzAS+O8$8T7e4UnT(E%AZW-j-&?AE%ShL z7h=8IEv6&i?Mm?yFHF;W>cgp2FC(enSv_>tu5kohPG$mBOhf25lIVduB<*ncBMfNj zFwDi6QNSCtD8?PO_uDw6JzVvfTMUk-N^;XjfZVG_wo(r-?Nn>#o*`mrdyCVG0^{N@ z&h#&Z0H6$*ylrQbFJo%+KAx!hGZk9;YmFy~#k6b=8{5##t7yCXmuM<_h_nOa(Cj5- zEhzj>6rmPCKonw=X93&Q{V+m#D{uqDSL$mFuimbT7&q!{IcBT+Rt8uS;8<3|G4NT^ z^1>#7K`=F+Bo(ewI~#i>=XyNidGq zB!>zl6Vu|%-~;#EgIsu@57`tP;mX{!k9QrnRAzSXlr+sB;M~3JNWRArVb_2A8FN

TQ3I{LQ725M{w{=Bvt#P*>&Z=#9RN7cp*fTKt3fp_YbE+w zUQEv{WmW0=3|k8Qjw_prj#%IQ5FSa(g5waUX+}YkE9Z~-o??Gd&hC}HlH)llb#dwQK*SzOCFiJw zE;9dp@+QI%-b;?!_zn-%AClp6aJm@NN~ylade%WunK_84%^1Os`7n|CHIl#B(6?7h zLQdD25McDmaN61&k`Hr+b=VP*NeH2La_wis=-9@?8gGAszZb$_6FIKpNp zDYk_;1pt<={}Kg zSYlOXA<6z^PbRUEg9g$+eABGz;x09 z8ek4zj!y+Y8m2_UniN7h+EN&mTYM~oCtX@RPHHnBg1ETW3z1_Qzs3}`% zfW&9kZ{yX55BuM>q(3U32>Z+mI+H&DZIxDCsC3Bp5SdOWrM=I zH;0Q(itN~ig-yJe>n753E#g`fTVX9?hI%uDnfxw}KAG0rH#BGew(b8v+_(WCf9*Gb zszPYBdDVf~^4iM|Cp0BFw8v}V} zL_OmWMCW;2)~XHW*}Ty6uH~-8OiM;PZLK>cf@6bJ?!7SvjJ5pX##Zv(gf~`#GBb^j zl8TC&E3$;g<*}2V?WmSp#+voc#?Ga1BW90Uvai)Gi!^q<6QpvrRTQ{P|Bt!IK3`q} z+u+SQmbEGRiV44oq{J6Qb{*2z&z4%2Hx_d<-l0QyNGH;`hY~CI6lThR2d#pF;tv6V z+n;tK#ei0Zkv(^Zex!Z#4-Xl$9QNN@JF3fAHU?GLr;< zzZQ;-mE-d})}|b@z=>-eM`q<{+vv{aCtguq;E4|+?+6e}I?xdrwD_>T(sO+KbN8$d zYR&eR(8a*&`T5F^y(0C$J~_Oz<{hCDR*_beafY#gF|f8m zEz#5!jg@=DbVCPn+51eetCav5vU)aKMSA*^L2)9 zIc4dwF(}*D?5q>0ZiuG$t6)d#oG0^g7)1JjoJ5q z!~}5K6UQW-1MPEq@0sH_?lSG)=WEeEAEfMPaZtX?eWn8F`c!Yd)~X&q#3wzF6yd$6 zgtRXlocQ;l_@MTDHIw^2Dcl)xQ$LFX>e&R$SZQuhiM+MWz16X!aLq-akP8ILeFd=A z3%Nb?iGS~Lv%NmYzxEAQ-ckRsfzO)7)C-OPb=aV)0h1lTex24~u|Gk)E5(JVEv@DECVf+pj(%}%BL|Jtt= zI+CV8M*NVgP&tSh>^CkuzGehpZ$A+Fh3WjZzwZt?VD@v4+TqIn&;MK0>Z;bZ@Zmhi zf^yia-G|~<57PW{t8irHtDY-SnqhY>M~hORgMOoSV z(!7kptad7m{%!NtPzW8!B{&j;u*W1dR4g|SWs}UbT6({2n8xq@idHydU}5a>`;nP+ zIN@5278AqqLvLWzK43ok$a8Ks<=gxCnFQj^Clo4jDIX^Dv@RJY=E7o}qN^%)Z-NQI zQQqGpYSJAhFKL$*M;xWa;$sZQrPBs{>Ut5ahUdcwgbIp?&YWbk$WWe{Gv_>s?XI`P0N+CM>qIE5g0eK z*&c>NZ|g6uDb3zJ2{v|@BNraCtzOrR{q%$l$_9pMgH)td+SUr2RWOmvMZ0E>A=DsIf=Va9_9X4s&R^&wB`f$m2 zs7jWGdVCcTvhg7S>hWA$pQh5d27*-jhFwJ%Wb^E&@_Jre$t;N&ABywT(kD!mP+w=M zwT!l#0gyE^enluIX_D;R)|C!vjZoEud(82(7kPUYaAzvvp{T9pzf6=#3Vi0?9{WK~ zUFR;W*qnb$&zoN&ky7C#8a{siTc0bdm))%U3(-5;v3G3Lc$C$k`9>%Ff(mx;8Cu9$ z1GudVsI~W)#i_&Km|^PE0QUfao8>r|ON}?u1z9mwqXpT_&ng~l5-9%CBnchm?n#N{?==4ex%p?tOpbkI z)!w!frkcq{MN?*xEma|KDLp>>rEseJ%ePf@R>`hCd<$931MTlGs{w$f2jM2Lz&8Pa z|5$@;y~j4)%8c%n1_Jc@Hp1UZzE@!7xQgVMs;P%Rcw&D zK4WD_rOuAVPQ~LkMSt}*9g!$pQZUHH>>>)Y^j9X0gK36l%|m|OG4B#oia{=qdZLzo ziGNreP}?_ZKkbR4y4k@x4}%IshQxaH`iIq0k!3tJNVY2rf2_n9p+Or}6P1|B<`Ofq zWo*`*eDDbH`-bnUFZu%N1a@tB-A~Z2h3>Gu=To%}_zo~->;H3?bIU*Q0+z0;jU*f~ zI|v%R4REbo2=o0Pph%xt$zRKAGhkV5`p2?b@?YQKcXqfSzH~@|Ol-XC?GG$zij4ag!E47|X!5e>lbvEU+94;6h?q<-Hs4vnbg&iQ{IXre65L>YV zgE#J8zVYtOBxuH2p=F`lJYR{f5KxR_pg%ip1SracnIo2#{g`Eb`exIMxEEOHl zri>X}h(2eJ^28)%jw3;24D(DPH!6eko-=fJu081?c98Za-H067o2znI?KUI$12?Qz z z9bhH+=-PHu7ZV5@Nd)1zW-*BN$}mh+wFoVGhq(=1O1MWQaP3YSuaZ$onrKspXoz@~ zq3F;>ZR4=ZSQMT8@zK|Jt?@5wys-|wWmB!QCXpX88UoN*YH2w`eq3j?^;2T#n4ds! zKi8%C!#ALFJl6cmvw?5G`c&+wDNo5|P7gFeX!3oa9baYAbdkAm7AEsgG4^WHbhEA7lyi=JHQPjeN8 zVV9&I+}z;5=*5BmN;Sj`W=FnRJ$LxHK#MHb3+TJw>dspIW|O(>X)5qkW#dTpi)q=Bi&JM+Zd z?1X5=SjItLpbJgSIuyQh-B-HoL0*5n^Xhy}&s@cEyn)8US{8(gE$AL-J9<;3{hr#f zTKkWDe!Yxt9j&gvzT&EVviu^y-vQrv2Q-_PA2)s?&`c1F=d$pAX14}>@qH{5#UYF{ zxHNVjPBLN=447V5?&^eir{W`)PHAh0JF)Jc0Dvfv3S~MpX=IfDHBVJID}@LRq9p2m zKFz~iu>KR|^vyT^aaGkxYc#w84sds}@GXE9!+&V6LfI*sNx5?uvA*N&0TG9?s(^f~ zhiew9En1n*%VN7SIfXgGvvgp)oM=?T}-FQnn1mhcDF@sTz3=oS{Jopf}M(Y^a+nmPA@BH5!( zWI`KZ5y#R(E#C9&Fb=P*k$XR)SwSgMgLqqVi)g#(IfsJi1vmK%yINlr_ut;*jz`je z9EaB7KC40^)5r$s`9;z*WC!s6fH`bdOKkiPt=R)Wg@HzYJiZ^*9(xXb+GA@2F~*SJcaezYrTn8@h}<6kD16(w(z8B9o? z1!|n&zko1`zC6pkF_GABPygTO{?LEv{$Bk5UiZhF`fcyT%Jl(vmH#bUARJPLA4`mg zC3R|X_DrEj;@JvCg&DZ6?SLQOsE-a(ZPQT!vulzu_c&6=uE;ZPxKZX=JyI%vEb^w& zwNpYvS^HP9tT7Z^f01Uzcs~2CaG^>BDVV5s0lP4DQ z@udsWQSMQsd{ox%T!4)G5A8Q6WnHVQq(tu5oX{-XTiphQsd>Ick1Re$U!Fu91hfyx z$}|9RODr3GdWHB~fFuDo#c{Nqe0&$=`{T1`5Jsae$UuSBedzJUB$z%q~#5 ziEHuVJegcRczuGeGg$XBy|@pytHZ^aw0zne(5kuCLX+3X67gQ7g@}TxPQ|P$$UC^( ziNJ~H*Y+4yeGu58fk0Yr&Je}bfdZsr2Z@$1`F~#5g9#==dBL14E`-8RJtrl_?j!e9!u-e2$`FEIk2>&8%$ zQ@rJs^W+}s_B(0g^^Uz6+9==sELRVMpsR`{cb?wFLC*s5JjULG9G8GrfgbroyxGYa zbvS@DW5zg6OSvF{Lejmb@0kD;d5xR5KwXP@QdvEbPxKs^kt@oHg=`u686bn6x%>pl z>71HP+kf5fBgC&uxjkjHQDph56#!G^$>5k*|V|mMC4;j8a4LKrtihnbW+i99&`VL=a&Cj2r7z7Jnswsv>xgW&A>R7{MVcY>^ zFuC#{sEd$6EaRB3ajn92(F3k5(3(j#GPV(nqzn(fw|PCIF!asR+*C>cD^Wo2O^ci4 z>o92V+D& zN>R#a{7v7F0ug_jy;RZhzbEO~B}sa-9i897$?j_HY)vee8!JV-%Nm58(c>V+ui9{} zzO__w4tqAay#Z@gLdbavthBM++!yclOs=P~#kgFE-FZbrnItR;_oSru7bb5nIF`5? zzvM%Ky0F0_I5$Pe-oKpbld^S^JNcj!Z1XU(i$ADo?lvT_S3PYLb?2>CiPd`w#)NmI z%+Rr1B)bad-r??*ulc)vW(rrJY}PO7Lmxvypo%Hotk&E5oU{j(La(+*R*hDy?~d1+ zQ{XrzRfwT&r%4P2Lof0+3qm26Vw@K$z1K#^izJQF-t3{;lSYEyZ(J8G$avr^%508^ z^fr+Fe60Mnwr)p4%=(q0v4yNrJWDHwWSJ?y5Y6$e(gB*66KZ_-iy=J~_4SX*ncJ|$ zRb-joJ81#UKDVjV_`Ky&gmb?AMJlt_hgXarNKOa2lt)!MOKbvo*dUb%-h-jzSgPM@ zAm!P0Ql6xn*fOCYQeyfZm$={onHj8sp56ydv1Z+8(y7`py`>R>95Y`%USTY zdvNqy!jL!`{oBF%X4x@{iaGl;09C^HuMC;K z3vLMqaA2Nm>nO`Pju}^(Q3TvLVu9$Hho<~PnhCaoZEaR}_&{JW-yBEJI&S*4k=>k( zyMsvcGW*VjtE<{ul96k>bdMjKn#;}Yw{hFcf{w>Y*wPJ{vZhQuyC0?&-wok?$V@E^ zatV#;2oj}og!WKFAOf@dv6Yhx)&~s&s`X#TBNec?p|37T42g^BsObV^WL^w$ncb%J zZu?YczX05%YiQY<-5}FfZ14t}Ug^fu#>y(hHWm3OpyVav{J~&vVr}^S+(RyUQtmTc zQ*x%5jxhxo;c~J9tWYhr!V1}wTcdi@Ki90kh+ z{RGi+Wy;$2<=g8oFNDf%krP^WnSbxlxn|j37>%vrb>Ul!;c8ep?@bN6=$JvEEm`dQN9ty^YvIj)_H9jc>hqeg zdfIZZQ&i2eUv59&zookvnC(YgN^VMH!g06}NVdhl!8#pY?u!NZPNo;ATA3@8s`iK^ zjgVkB#bS(6h-yn2WzzSLS-K)codW87>p&A2nOJv>gQHr(H|@={3Hxd<`Njh*IxGsI z#(Z3|s&WTleM%HX_j}QY#xizaBE93#XZs2+ZXH9Idu0VO$z;AFhi+lhOBaUBG8+o+ z#E%t?KXW&G6fW(H>x?jfwzvm~MV?wz?M&l8KK%)rD8C&wS_z+~6EpY0$@Xd-GDTTc zmq#|tO*C!uaTf{ntFJ@hS89Jhf;r#NF zs`Cx%G4zR>12mB0KiSxe`eetDH-8Cr;DoE6br2rz#Qxy`=n}HsN$>{Bkf@)arv9Ix zbMtSH_W&^`K!d!>SbH?-hxsPCm`9D*0<3Kc3BcR*_%6q065x4bcI;Sb5aYHJu9J+cIAP!6yoj0l?@R z@CGly;09Q80yO;G)BP{&wVS{-6?kiLJWSzMRRe9(Zu?b${4FW4CA}}dPA)*n-XIZs z&M-D_A?Bqvt`}KJS7?o<`>yr;c(6rzNujHYsO4tlgS}REe2XTj_lKGP{W<>R8xZ z^p3rNY7khCouL{ObOlqf(}Bw6=cwZ`DX zw97Fs6ghA^Y>G1j4!igbbVq^`-)iFsB1)-OyKT+5AMZeU$LfWeg}-~kqtG6|U<;(* zYRpt+ranWg^LLFxmmIf84!; zVwv5GY5Esa58UEbMznJ&w0$ev_g2+R=$u zg4$NECN9PvCoh^3jXC>k?MnNJwJ@TKUQxab2~2ROP^{zj9d|)sIL*;~TO3V}Q>lgx z^=*D#x>(BVpdMkDsv-=tI4b{Gu55@cvyo&eD7J6v(Wb>fX~|vO7Y!GxLw=J?Yi#M2Gb14cxESS0Xl{YukbKSTL^7 z*^EJO)H+f}PX9IND3?x!AR{leyWEZTm1Qgqf(6cCMQ4Qf>N)q;rTjT*Z#aQVDyDUw z&cSS5YCp}sCwcRQfisGaj7%mJ6jg`d@a~IMq`BS%BI1q<04=K(=uFRc=^rIreXl)u zCTGUFz$LVvS%%W7*LcgvY|~N-8}#g9Jp~h%pOgqvnQZuq-yY7G6ry(D1z)@ib)cH! zuFOP|k8F48CW%$cO_i_21fpdO@(kDjXO>d*(Kaw*f!35Jyu;Qui{d)vf@IK_)ie2Qi1B#1SHKT|C=f1bUxX8X$rvS2ETav zzMbCy$FF>j>}!;|9{>H1yt&JvIvKF<;k8*fxobd|F!hlwpit2VknAPmQDq{MY)40L zwpB+zDCfxq!!7F2RCK9VM%ddbR&ov>mLA339B=sm^Y0l(@5XMnBT4yHI18=VYl|lh zol{b#a?QHz^I`YyIp`HGm~L6k8IE-r2UbdIC#`lU5FhViH!nDwox_59-m_d0CH1PC zjEj06)urFP(dgq-!T#i#7?&7W6m!klX?sw9GuIA|5<1yUKE4gr3{Ri+D2$$!;*SfR zs#Q_RUtUUYLQ|;_2WU!4K(*^vc4wSDNvm-Ul}h*z^Mw$yPW_1qD-BCpjxH^bJB|W` z;Y2&+c-|CL=gt3^evTsG%omnAigO*&s>G3G_g5ame>>Sl{`;Avh0o+lDH!+$f(?q3 zjo5r+$phUvLFc#uU|Hv`xu<}U-xEGa9KlCeyS1ZShl!ICBdc}w+fUG}{urRbF*{n4 z$A?e%-5}qEc8M@@7C9h;oB^HdZeDt}@&$;;q7{$2@H1(YQs7oe^1k@8X#j<^K!7kx zl(yVsr5?g&RC~c&@8g_lYBvidLX;fnSAMrlO_~VLZ1u0z&0*1c!ro-*&F&qkVzZD> z05?CapZ#Dd%bXjay4$85>FBe&G@+YwGw(|JDthjpJN7G5Sa0*Ge?k$L1Zu~@U^o(Uw9OPG1(oTZNvo1=GnV>apo^D($6j|t&Uh9!;V`W)EWbfvr zwWTAInzgYynpze~`1{W)A6oZLD3rIF;9$L_y~8#96}DPo{SR>+A6zF9tI^k;2B6w2 z`tq~XfL%&r^3lmp(8zH4tA@OZLj0vU2*o#N)C@2xU#0fbe2X^Y;6Eb?#&IaNLNW(u zz{wz^l8*Llb$KsG99h;_O_&a;v#{1}GxaC}gI(c|c>wbVkcXEArDKzJ36B*+Z-c1H zLFQC8R{Tzxooq&vaeVh97^MlP@vi6@O30wrwsYvFZln;Mx|2UWSXI%iOqwI8FZUIgNWb zXVIx|T6Wa6B{H8YWORay!+$dZil?w7Ijb^Pkl*y4C8IGAnNoopM;PQhoZ?x&)*s#0 z$QiYB5Sg-R8;JMIh%j1XlB58uyT|&(dZ37zanHzz$<~ufQsuyjI(PHCV$P7N=&1I( z@vSVa^osYt)SXP3M7pAs(rB`!6|102{$WamEB%W_EXgF8`8xq!&SWgRZ9QUvJpyev zO!)7*JCQ@Kt69UIQ)K`}o>?}h^@k1lS;LczvWW>bq0Yb-)&lP$f2pm=y`iN_W5dT@ z!dZIlP!^daEHVzik4ed(7+h4$T7eAS%hwFK6#3OpEkA#FRG*t!_Z|q)D+8?*o$@c; z(a!mm8=a+n&C1`^>Nb+J?nEAAJ}j+t9Y31Ma-B)G7F@W?tEX($Lgj5qTwm7?VZrV^ ze1y@o%QoGxxF++gyF_4e)!PanPH@mujO&DYvn2MCNQ?;{swxGGCxf$w?4a%(^ zJSLle;;d2`3Ib~0)}4aG>WzB{&nVpogJ<5%ka1hmveMNBN9MVE>|u3hZ)A7vt7HG# z;Jh*o{UW)8VcY%xSUC9cH(xZ6_V9p>S5+j>3E}sW|B~8XnyY1icfyYVrQbKS?SJ}4 zQS7l6dRG>Vnt7W&4XosMA?Bx6mj5p9{l9BsW{7>F;gz7s-OLH1j8#Wc>WyXR{g*y? z5MJ>SPeNK=R@-}vtX zqn~Zn9$5+-S!}fRB6qjZ%q`Lzdl>d(Zxb)T^yt71K-{K}Gy|mJ#EUEGqm48=dH2L# zFx#yYJ>P_JcqA!+*b{2>c2|Z_uddTywz_RjZ7d8l;Ndp8pOc`0JQ&J5%H?d^Xlz7D!%Nci~ zi`XlaoX{4ZSpRekgqe(C)$BsG*h$#asurF^ssm;&c{eXmL|PWCk+IbNW-)W;AoYx>_JJU--2t@`EG1?2!_!sNk^N zjKb*uV(+`-noPTGLs1YBL_mp#qM#s%6a_<#=+Kqk1Sx`wO79R#C?bM%1Qlsg1Vlij z_a=nii}VsO^xjG0eQ?GZm^1U8`ki~v@18$miXr9A^X_Nuwbx$z^OI|AsSu~AV3gl= z%~e>Ca$UwuRyB^N`;V6Kv2{<|Qk9Ecg6tIOEp%bKCAL^*E~6N$PJahruc4fKjMBy? zJUC^o`XW0RCC!{}*W++w{^WxeM)haNv1gJ-in8@Cwe=~$*$Xf}N@Ua+)Zuy*OHn@2 z3kah%Q60mv2>7%|pfE{`0>_qqg^e_Sv!&prUw9#@mn7<7v>s?g@NCFbmj(|t+2wnK zf7`o0*@7D60>wyzr0P~kA2=(vWe4|!LiCd;27yzL4Rc%TvKG;z*(dd!&_s?HR`#A! zm6FbJf?tzSnUV~Jaw~(LwGX4yB`KsWjJ7p3xZ&s-Dp2(P+LBpii=xUoo7B&`TxQAm zeC=L1*vCln;f7z~0$rM1O9R@c1LA8H^r%C8Afv9;9s}lw6;-J9a=SGz8_kR7s>Zs3 zvzcUx^W@|n;dOEE7!d7U_V=Uji31Tp3jul+^HKOy`qGu(A&ZMR>QyOt(9^Gf-vXD} zw&(a^%sII52pE@Ht`Ylz`KgIT%50`kMJW{q7>r4p@lkeeMJQ;;rW6?=>C-c^B^Sgl zkTC1(dfRlCD|ENqbvYYAQCiY^=3jqCsFN)4 z=)Bu`MN=ccmG16DHewGCqpz3Dg+$%m%(vI*N7~g^DeMrway%{9Ud#?CRtTNm>&DTu zy7%MYJbMRp91`CldiuL+z4~_#+%2veS>X*z;Llt-odeqPL#@Ey{T=}Jg1}#0pk?$2 zxXAh~O#;H=hdID?fga6CoHS6haSo@gNSiV5jRDY;jZX;JW4{#r9<72)! z1*8n?40UN;s!s>m67#j6FK0f}^inA0lMjDPldxS-ZB9l8uiUl@EPl?A`5;5HmWk+v zUek=dVm?v1cUGrmEz&Baj?o%I?_8DV5b>yexJWjj7;3EpF?e=fQ|vG`Thzo_rskDQ z>C+MCE_ZxZc`?%MaPA2DruBhFc;G7n$c<@0qTD?XnlFw${?ov%PHLPMGP6n1h#iPk zm*=VRR$%j%pm$4gL=nWman0ZZ&G+Xrd*^7jl(DZjW0!$B+jocs^UmdBPK*TtLue!n zBi3~7)weepQ019RJk8OLsHY$}?ahNK$sZ5&u(Gqx{w3%fL&f$f`;Np(H|1cVRxw#P zoPlxVsS8MkYBoM@7b`fp&fTAHEgLiz#byd+^lveARI7e`A1gTfflxFj7d{|WN{@9D z+w#8rmg|lVwV9;8-5b=jyW$^u?D`u{MJrl?oc*7*{vAQ=;S9>Ph>85 zSEnu{!$)B>T`*v-$XH`=XRECGOWKCUz1?;%Si)n`Q3%q!g}lF}I8Yk4Q9O2P=^de~ zv+t7+)<2-)Y`tler;;U~r}Xep?Jp`75`-C-wlvqvrM-Pl$hm8m)6|f+>2>5wcWspi zf$iOsJ=;4H|K+HMAA4gt3i4v60I_!wvWHFnU47sCS2EyuUX&aY=xVkxr+@nNfdmDB z>`^44{0cTgr( zKcAz4Pz|zLWdiGu9N&st4kO_6x0Lta(adX??!pWT1)Tsyp&ORq2$Ujj12~QY_qYZg zCCpeY!2a>O%|@c18+06gXh6kJXN}H)Z`Sf#Ug_#Rl;I*7vB*~;nloXX7E(9c?ub^9 zfC(6@1i;N}-x_n2jy^{bOdVz=V7-1We zA#RSR_3Cm!ld%dsHTX6c++tYddTI<`^BvO6z7W=pZXSuZLF>+@t<^|Z_YZ$@P8V(vrZmAx z+6;shz&RZK=LeR5xHc^>>({(W0l%b&`#u|UqPLl|%TrdqNt6->)4Mq?88n6_6G&t2(j)vDyBq3_p5|9ASPWwf#oPWBsAxbw1H6<0xTENf!LF)KfVorYe9H2L_e-Gq%`JZstxl6cCB6hHz`NeIT^!9X{rbw` z*d?nqrFZ;N;;Y2+Rw1#a_0?21jOEo@+^=O}VO&(+x)M-KirlQphdkCXCFFUtzz<)8 zyd|c>^Uh{x%d=@25h?E(6Re8KPIPrC-%TH!G{@3o#4gAm(bUR?+J1*uxr2WIP{^fw4tbxvKe$i72dEus6GR5~V)zsS5!^u3Qhe(oFo6XxLjfD#9 z>({SD4Ngq#fQ?HCjE~9Lrc#?X`%?wNHRwn38kf6#@qfaE>vtIsDA%mD;qV%560fV>HZ~5^uqzsaYl62W2qHn9ub5lw7 zT9+oht1DUnpYQ&Cmw%Z8>K0R|Tn}UbLRkvIs$3l~9mLc)H%|M_|AdPJ?IL{%&lvho3nk z3ZbFH50qs2WFRDLp~)ol_NgYJ4D;U}u+h*xJ#HyMVQHhv{hI3U@|kB_5~%a@2{{=p zzsv#2%yshDKr_=Sw_vi@81r)}|8|Wba85O+e$7(&#QO?nO~-34%TQrBwCYb3rt1yz z&{)c{bJ8%AWZh4<-M6hpToUd2Yl28^^}bduT_2jU8zYEsneJRU^WuSVz7QMaPC`XJ zS=pei`OulDlUQ5Ssi7&1DJ_2r=^^-is1RJE!7FCeI5RblIx!`aI(MtymE!3=+K|{c zZO=qEzc#?9E109@_r^W1?t+Hn5gt&8;UMXsDSMY9oh;Q$%d6D}<}^96$B~3O!g_u6 zUG&NeYpX&qLMv@BETc;^UM#COYWXf0E7YHs`MULz4@L0{5m*eJF?;GLG7>Vh?BL6` z9MJK+%eyX+jeWP-KPvj&>yVfV$Psw`W~p$!={b4ZdaV#O+Fl9>v{q=mK=D~DHM69V zvn}Mc=Z9D>GqN;u=ys5VS5;W3jmMPj-fsBwLR9ObUgX!`t?gLSeT9R>=@w&#!vo|J zIl9bQO;{wYl9r|a{nfKJQN#%(>=|NDr~^>TSZ2Hn55eO+;sC@X^fs{$L{<@oHJ(zC)KL$^Mtmc+5;y zo;@ia1dsNCtMx19IWSSX2|*dBR8vtt%STy1gYw!v*k(`yweeY&6G`NCQw|;>TPMVy zr8`P3&T9mh@jV^rMOei?;ix+3Y{bA?bnlP|m z$^|~GzaCGGKU$8`{m>;~Guh?&Vc%wl#Ud5}1_p(@bJM?B9VY^-;|!ZxJ$|OsG|}Gu zDqqj!xt{`(GHi%Pke;jUyBkSJzbN{NjT>g?Z4%x$9)C$^K=Fyilb>AlxWxRO80hi| zlcg76X!qDlu<{^BpbJ8z%s0PI9PNFz+;?oHC_c=;_z++*LxskDRZ=Mej|s4C9DSc* zsfnTj&Fr^_->~SNnJ|w#E`D9cpd#jNmOo{vQ|9&Dkt~-ci~eh7Ekj?iP%Lyh#!BhV z>~X#55V^n#WAYg^;}v&BSf@ZMq7L;L(=xDPJ{^np$GmrJxl(JAK;xV4Yw0bo`?#q) zwt3@*Ecc5p%_B)Jzl0tsL#IleHB^Az=ebMisn{TcfE$*I-0yX`V`v#}*?f_E{q~dC zgwvrQ|Ii@$ajIiX0ntO)Bmm!(Jv4mKrdb^Dt0>ecDw6Mu%Y_;P$5n!8(szhEYRW`s zeZMKQn}_D;s{|nptPRNiFg|e)9McqBrFwK6eW|8v;VnV~U6x<_t*yLTfvAe7ZNYZH z*JZ+10;*cSEy^n*#MeCl31Ry zxpGJeY0eTAvjt&_iit92ZJaM-*S}HurrHB{$&Uzw4^AHOyNSi%AV z!FZICm|7hhsupS!Il~pXME&fHg!{*W)%#}6?)-4bS@W%l9b$zmU2D1H52?bwbXjg$ zB;{>8=^M%DHH`h9m>*0u|L^3T?06dHIRW6ETGKYWtRb`Dz*netcG?bjRgu zW&OvVtH@xWQ)gnFV7&>KV#(ACRMHmHPe(-J>k0RFWx2K676im>RN9gv9<$PFFB%qG zQe-d$s@;c(FF#-nq!to0e~~Wv@yq42LaJR%ahob4G{71PN_u)VnspqPbI)nJy#=I3A{T`261`kqwsa~VFKeT1qLStOQo0G z#*9gw=6G|O$kH$|3Xo5e?>V1B{;%fJK<&|-o0c^;q@~vqS1k-V^VqPQoh34!k1P{{A_u+aqmwMJBLo%Hu3dNKdjHpscb~4Je3qs*i5JK$c}L%| zqz<(iL;J<3WJMGlu{~N_a#8n_IMkk+rsstA7R%K1;{LJRJfqyW~^X>US5Hay4lFyj~B;;>&&I3{#u`* zy{4?I?C1BH4Se%oJ&E^k4;DRSLBM)Me~XOpEO*ark}tjCA8R+|mH2cb=a-9OvUMz}Y*AqW=s+voy`oc?%Q2NNNtH*# z+zsnVKCuB*T(Lu8f#Yc10n|+$0{^*G!w<45&+K{py~}p=j!~m}5Ti}hVyne1=Z$$= zMT-8ZH-haSXruBkeT8FePFPi7;H~gxlYdEO!i;Nl6?cWZ^&10kcXE75E1?c=xn76$ zH*Smck$&6ad6D;&EeIGC{BfgH74|9O0w5EJLai^A?~nqN22cw+2eDp@z>{j~9h+(A z=V_Ou@0af!YWT}mdcOIR|>As9qXL|pt3mDe$8J>`7+Z+$`T z82?1JXFGo<|LMcWc_^zhH)T>e zS|g}y4W4IdSdR#iPPmH@q3Nq}a=EVB8%Ga4P%>&*gzGjn$6ROU{sa-iGR*3|y^Hl1 zJtxriS*l9pd7%1|O|8sbPx3RLBqlQ9u*k*6tdiH|CfCvwhmn1`g;xSF_nqFSEe&rf zp7A_F2a$cgFk=;vc$j^P9PL(M|6=*Vq5_MEQ;P7%s2Bys*3Im%_k+dY^!;Eqa?#Th z=}Gg&d0Ny0v>wHUoD|3T`6bR=7pl)lP+wXv`^YEy1Pi(EFG$ovLdgqV6EDl1>1}p0 zQ=}ztwtcCMbkOfOd-H?6=%)UbuSrIKZb?>Aodj2a|A*>@=r3MgZDTf`*Vi*TE38E$ zc%e4M_efZoISgq#1L6!eVXKko7h{a^$7_-d$l;d?#L?tb)LCT1#WL|U5I=}I1acSx zd>V0M@+x2HZ-{oD=6 zu+K4cKBoe_o)i;UeWpv}rHNX?MM9W+0_6T`M`DIaWy}?T zoL@EJM_x^u62$t3it%8sXs^5?ja1U;?DXadfzxac1GG-wGFJk_f9mRH_=Szr z?F{+C`S|2y1V?<~)2?c$e(6c2hsx&m<=;yT1`Oq|^KY_66@g6g74v$PJ|5B&ePCn< zFEH2i`GEVf!S4bTpiFH5@-cv%i$-(iPcu0xnZ22ufktd-C1&UXkguCLc;3!sP0D8V1OT+=f3bHg^n-Cz1D4dOWJ*(NZdWY-nhY}YH& zg~tdyAS%YAdhI|pg{jDrj#ZzA!n&_iHte(MJomp)YRfe(p>aqc)aWHIUnA1C3(!hY zP}V(jQwLOylz2f9gn-L`LdKi)!9;2L`qc$GzKYRMt6ujbIHc`*S}tbzYNV|BjJ$n8PUuyYCVK-8wkY8k&-lzr z9*KCL{T>E-5=n|F({hF$Z0g*hqERc?q1!KaC<^iAX-J?3bRz>|czppKo;0CCE|Xb; z^f6O9>@~KYvSmY zE&<6HB7faN7O@Bzj&Tk`Q~D&Rs0O2qyB5kbLuPC>BTyDI!=b1V51>R;KKKR?EO^j3 zuU+wEJG@JfYJ5rdE=pr9jDVvioD16b^4VNYZioryzIBnz*$HGc{bcOGPJUwS<|t~J z?!b%x`YBlmt*JvOeb%n2%u9rk?oyDgmjkBgdBVO|pKBP_585W%a8;Py*=9^Qs{CL)AtNGrGC0Z!(rNC3>C<_M{>|s{quX z*+e7cm)Jh%*o8xnL_eoWl08IAMoI;r)or#MA?KMW&9M*ftBZEOT=SfWmV_-vXj-?~ z>4L{kUCh7nnhd(EsY+@ozgjd3jZ# zkOw9)3|`vkNUBj@r~(5ema!5iQLDgvTeA%ZJskM${$Q&=@dONsf!M9j28u*2v@6eH zoClQuUeYxFHqkN!2nCrM?C<^8YpZ?L;`LmYwPa(N~9zdt$%Ghm3pz71#RVlq((mC3S zD?ttL;8XQp>BYDbzC%<2nof+r=)wWWk=3KW7uY5QsJAJocL252|GsEv|Gm=Tlfatb zsVg)b<=zbnDQjW=;7@;7&i&o(=A}%W+wgbDKsh*(K4vIZl`roCHwyFb5MZ$SxtwPl zu?^K&*AEqWgxjko{+7LzbXGF2oGb>PA3RUUq+_;O6wr}pP0DvIzC#isN=1ve7-E;) z5*2Ncx?}v10Z~fkhVF!g5`JkOK9`Jq&2eI#K)OdBbo1rsQ9MqYD9-(IaQ9I;m z>o=zL~8B)p$J0!_9QI8g~|?9W7^moUE3>(i&7Q+7Yv$ zk8Fxsx8~0e^hxi|^QdsTT$*;_19%%O@bxMlJVXPaawCEm2r;uy^>-lY!joT6C*3kv zFPehi^WlF1vaRiPVLzO6v%UZhF<15S2=hNKtvVfx?2CV|tfFCX|B?7fpI-(I>mSav zNSGoii9AL|$|VAj9LWqRX)IuEygm?$_J^f^!fhr=Fj*7-W3px(H*((T6rkxg_Gmiy z+}Ye_pDpYx;eps*deiY|@??LC_iw)a9~JLLemQ1En#Iy6Y7UtWRrBac|EqXR+*;L4 zWyaJUU!eQ3BZ7o;pl030b~xZn9o|t3YzNA*F62 z@C@s_y4iuQSu{a#Ixt((DQGCiO;5`4!9!CfUj8$I)|QUr?n0S9MRP^EgR(T+#vwFa zD~VT#qLBU*Od~fWc1{+y`h2R2;C&4t3O>m~^J@C6&_r}a&@BiVLq_1Q9gbYDwtU8Y zU9OquANRi0;eED}^^n#ES8Jn=Hsh@RK(*!8u}d;vsNMhrI3Y|Vq;%gl^8emeu@@f? zni&{oE&eXNbJ}j*^+qir>WWY&L^y#{>qU_tJ2u$0sZ7SDagLxy4N8-1hV4ru1ktk~ zJjL$trEG&Lk*P<`bvCF$WIFNZ?*Iw^m;bB6d=gOC;!6firleg5%t-ZJgXTV)^B?kY- z-R$u<|KUp}-&Qo>r!E3y3U9F!{t*WnvSB5UKPr5*6IC1~JPdfk0=B7X>mMWgHl=wyWs z%MmioT5wdZ7_|xsYZZ0Yd~ztYYcy5OcHYsLMjvZY7+^SQ6J1B4Lf;i@ouL zk;y`sJh4Kz{auwmM}rqA5%kAx^@3w=1z5l;@KPsKaR-=7UB_!_ztoijO!gQ6vtI@O zKdv!}){ykJw!{YqLpCTjp! zf!w9tHi$BYGjjTPUA@Dzz#2@<8UR{S8dvUR#R!Q~+Cf`*x%||hIO{mgsfP#Y{sZ5g znJd2y2@Kw^BKlPkCzR>SygYUd4 ze^Mv98Mv4PGP(b(aD9tCjGDv{`cU(7Yefl3QSc#LF@)^!jOV*EH zsp|W%HOId6@F?}VCbkW;tr*3oI~ZggPm(KnP?GRqGlXqG`X*SRNB$p4TWp5mO9NY; zM5Lzl5!b8jEiK7eS=lW6rjSNu;B!8{k(1IDAhVErVBU8m0<+tX4Mc{06?N?9heZsqa4bW!J^jQm zysf`#Y!dQ%QpC#u!yT##Cjr)F(|*;oLQNMk*^7QoSTqu9$lsK--3$1JPuv7Pck-W) zCOVe$A$pFyMM7;*imyeQEHF0~?0E7Dz@=nln@XQ>&Rw{O3smO4laf)b7C0YJi=vUn zadV3hoKX`(s4YK8=d!f-_%hp#VZ%!GYT~CP!Q=~Pf+BOS&Yu6|%iVe2P*O?pE(gSz z0Sk&D&tp$?ET1@f1jaZJ`3ny-geE&aENWtdfl*OWX6Z|_KvHqx`ABkKwuw-s6S88m zamR%B!7+HNUr|%h?GN=NW)I(}MUm9@!nZvZ4&6*>={+vV6_s84H0I5D2{F!pM5dX~ z)1JeFc`}J$VgA7z?%lR3Bk?f9miQi~X9IoXM2RHn_Ud(xJOptI)NDSX`TPS!ATy%w z(d<;bU)S&0NNaz4Qr`aVzuwrW?~nq3u}E+)l9zv|YFEMvey;q=<)IfNcjW2h?$oJ3 zX6%cy(5V%oc4A~#9Z%HEna2C6bB^+{te=T~ZQM2*C>-b$IUHXkp39TAd-QR0vs-?y z?_|#yh>b$Oe~^DpyB^?Sf1D4T@3S0D<09-TA7SjF)8Q&$8Yw)Pyiiusj>co0`uRrx z&8w{ZGKHk<*DEZKG6^qP75Kyamlc4bQ~OB^i%Q+xb!8S3E1}WjTE;U{vXJ{dJk>!I zH4aC*F009{W*aqaR}g)Yr4(N_uy(>Qu(At^I*r1Oy))v}eaEB>>2IWQddgHVJGX64 zIacaF(Q+vgaQnDjn1`K4DfD*k6h>oBqPrh%1ui(toYql0AyXitBPKFRrG<&B+o-RK zT7;M+YvpLVyz-wjbPk7j0Vf+ze#K>De@$tQR>bLZx!v?nxX3mc!DA=vUkCjU(>v7FT(24pGXFSMeJBkJu2$bZn`l}8!jd>Lv6>J#f-NKmPiXdI9pXS zQuj_Qv0mcx!Y*v$a4YAP*q8WmIoC;y6;w&F>51j*Ct8u#o<$#Wb(1D%zq0i^Od-t< z)c%F{PusX#@PiwDAm$%S{fAIVedirO_J531D%bxcJtiHqPYyJf7O-FG-lvHjyhk9E zSCk8aE{o#;RAP^T4e8f&Ez3oJ{A`>~ZY`1ZjX0r7quIa;VrOH9x(j(}K3nAg)B6G= zbb#%zBWD^@YV$5cozF&wU3-*ggS_T`SybT|zR8<1ne&dr73xJJu3V(q#uTJho>6YG zLiN%qsIxsIU1&jz>e?wIp z4_Gj^H=9&s8TuM+7xOKl81{VS>CWaPz4ELy`nkkyC$ptB4LALzFT(bkI?8422r?GKw6A_)=YOGD-FeQY(&isD)UC0y!e9h>?h@`!-(Ap)N+w{^M~({ zR#0GA1msuktk13u8Lsv_L^%`pah@ZCXRbdJw;4p(X2zKZ?fWZ4J};_?`G3fhve(n4 zRXUE#vo(O0KF(AjmYC%rxfEl#Y`vu1yq}g_yQay_cChQM1zN`cCuoa*!{3tp3F~E^ zTgKwt8o^w^y|la3zVH(m<%mZ$C4UB7ebIlQLGafc^7kUp9x&O@on$KfnOniupeU^d z*Ji-m?M30=gF3ycmPZCl1RK;ipn{QKE?Bs`=)gd`H>MT&OW8NyO6NYxIAwA*$-N=J zK^cO$DDE>{%(?m<;u*V)WyiZ*BX}?(5ABQXKQs8f>$`{=3wqi3>%moW^+NXw?A1x^ zsT_?83`R%q`@>EzaG?pDUx6(BiN;3Xz&G>>V`%O4U1KP;*7XrdP-5PtfCmH)ib75^w>rd(_}jp^H}Rq6D;F~-4k@oFTuvi(koTAK`$}ei1eW2dHor8;DR zyEC%EmknRlbh{EzU|uj^%;?x6GG0VYSry!0k%b?*NWOg|ESxlyh~EA)VtI3&b5Eot=ENYT#6S{NHZ06l32D~#bfp&n+D(boD zF%0X+!#Pp(h0hrWjV#GXFE$7d? z2|$uUSUnT(2PU&&JWblU>dV+2opSnWlc*a$^VX{n-8rmq9YPa)B}QQ`R7z5BX|tv* zL@zUL^|UroEFN{{kPtSU$AtDy&r-tD<>hx$$qev*TXQd!R^ z+SCF4077`tq}7e_iPdd8@fr^aeWN`ZMrT0yh4@xj6>gM>Sc%ybF703KiZpdGL8@lP#%aab6Zpf~&(Ld~( z(m#r-s}lE*{0<@dXG&v#W}8kURl8%!B|B;#i#u*;Lbv@U^-0%B9R__PtFY*E{fE+FjaaA77l^ejm_IXLtUkKc>x?ZDS{x`Y>7SEZw#^SDIF;b`#2d z@z{_*)z`WkB}l0nGK@ENIDIRYAa)rs`?P$A=;L>Yj}^nmvtW#$O&$8sSFbge38Y`! zG6ILZi|RdsS|ic!ku^$;7zRB2^z}04kg$VTTTS!;v8_3~?ug?U<@=*r2^u4ZQE2=t zdW}Kb6$TtTIVg~?KCAq>aRRI7j=(e%?oag(Z>5k@e#SNMJ65ug z%n#b7YjdWm*PcMDi%Vb#c`9i%VZD@kxa+^MC>^A&PiZ5qJQy)Yex6a*A&~tqe$e4SXjKdAF zzEPONoemmVN>NTK!uqrzl}SS5Enk78Lg4Mbnr&K3i7KYBMDAq&RgR}YA+q-NtuWvw zanGtZMuBgJa2ot1S@Q|GEpj~ULT6q_m|DW?!Q|Ll6H&brj-qt;#Mmzm4~5=#OYkpD zvbBj}*zMI{-$ks_7izivaa%ur6fu+v=p{F4w)}g5(ojBoS2rK$4I*cTJT4)lqoCMg zo1ztzt6ptO>*+ZWuvd~vaE?3C+<-49b^TSxu5KZq^|8FCD3t`xX3SKbI^F--+{MA< zcte&=j9(&iW^;~PZmy_+b}XgNHnb%dZr&kG!3AU`-Y+cheTefwkNcsENhmk?@MX1_ zrgVVST|5!mg$8_lyVMJ34O7Z<0(Ll$noKQZPZs3~&l`MgRR|Ze$?41%ybVn2xo8Qr zI*QxVzxe}eDg?;AntWkDmvL+6#+jVb+eMRQ=fDvLT9;mBz}MwI>2r)3UjM>Zb|>2- z*GD3(9%4%$zI=)x)=MY~!XHXYKBQo~tkxB#fVbuS(sJdUU^Jd;94N)xsiO~I&wWVc zzv}V-A+<<5c~u9>;0*rdA7>bGx;phAZRlN%4-dyy2OX;)+clz0l65*7@HFI^I!Ov_ zSyvrU!Ig?zt6_vPP_nunSV~+HcKxpsi%hnyk@sefJP?aF+JcBG!RQ8IONDQXbug-9 z$RXp|B0B8}seY?)^QW$pVy~ILpwz^ij)qq*7|8y;w(@vCbMybp$$RHRaq(l#HVZgwlU|U1Bg17xZw^Y@mfKj5R8d*iIDOwDDpVdynAF#7=w2*^AxF?+GXEpL4+sA9Y(WSDiyLqv) zvJ%X~JiisTw4i)NuV1Pq^g*=Rg280rS!8fuE3|T`-Ad2mD)&)3%bOQjJb5Kx$0epD zAxMjw)>9HGwGm3fbsD$l>Z}uvx)ar&5ox_y%j-1VhvWB-?~L1v&7OSKGGCbAkb zy+Ibimb|s!9I9x^Y$*P|K44CA{zX+hgSnPJT5zL(Etr-_wpNA$jbcDl;R|Qyb!%*f zh1$z==IbT7+3xcLDdxS|&L}Ebl1#aV&*oGE=~98u{3@0-3h`;?*I@O`4Sk|fw&sZ| z!eL!rI_p-Up||(6cX2;XwgbYqtOIDg1c${}m2WXm=puX>!$FjK8U6bP1HS%Y=@&T> z-RTeV6iXT?)+SOZ$=HZO`J$Gide1Hm)Xp>%nPMs70lsk2B_A>JsnX|rW*k%96DV3y z7SqIQ%NJJ?h1_g%zedGAFduR=4djn6^-t>fazjfl(nh3aBVxoiT0XfcNOs=_dZ!%J z2{2X6KQgM*CAHMdLy0_(=GbIuUhzM8eV7y`D8U{(-ondQV=GR*6>>PpG$J%%!9Sma z&J+5=IN~moRUpz>bkw$|KI`hI(D$#dU=nqe*7~{;v z>gyrPeiMz>gPJ{OubpD3c|Xu8nW>Tt?~8dg7PPgN4|W0?)D-cjOW<4lv^%g9)_wKW zFmOa@1*6`=7ad25i87{dyaVDaei2^`>WoEejv8`zqWb%4^&`)fR|NP~05-r${#Q1j zCx3ST4C>v6y|L3xKgUk**H#c8ouw<6@>Hh`K?ZlSC%Ee_UOD)9fp*7wYPvZ*a_CP zrVNGW^o%-UeF;#-_p$sVSEO4dRx{y{l*t0taHd3euD}RZ8jgx*DiWjyo^Teg;j))0 zJeOEY&zzUEBZJ#fUg?ChtTww+o$~!q#VNqr{4EDHxy{hv=gf2n82*cm;5J_Yo^`8d z(WivQW?bk{P3QbOy05UTD4)VrC_#bG*6<~k|StoK8skJ40fI?mSD zc34~6G~20Z2~9>SnGwtErjLAU#z7XzvfMf35{|QwH6Xy>bNi$JS3K7 zRbSAwVT!U;m%t99&ARAQNJ+JcHWUQ z&ocsn8X{dU$!WDY57#Km`VS{V82y|K@!+?~5aaXZ6I=+qwf-cdeR$0Ps!jv7Gg00k zyt3N5DHIK7#-O`^7_b0uT%(9=Ha0xUH(G?Zw3-qkae}YSbuTlxT%B!bd{FGnqdJ_X zeKmZf-a$~Hl}<9zpKpkLlg@vwt~G9Yu@%z8c4cH1%jxo52et;UWAWMq-SUE|=qK%M zI9P;q>+9_>V|xWlYPaOD7;D$(kX}h$s$7cGs&_jG#ydQ#{Ax4ZJqnGV@pqcETo9gA z4=&vF>YCRpwG^6OKvf%x5f4F>PZ&^I`zbO_+$RXQ`BlBYTq^Bw!GuzbgZtbwr=$6e z6$Ace6}5c+M(_FhQ(DIwAA8(9VF2b>-H2_rL}|CjX9vil)%q_h`R7aX*^QEGEqX@^ zlG0b!ks8IgS>T+#w$)F@Dz#a5xb3hA)#|`P-AoTNkfb*F6X^Tfb@|X;x$j^0#%?d% zyTo=as0deHSKBVCNtOPT`O@p%^f{r*Db&qMIN12OJI$`X95_uautU6Hi753akcit6vwnHXGNK$5?9o{pSS&G;}$)Lo= zOE1q_nBA`Dc5R&LpW8`zMWdl#9eMjZP@VU!8fUW(#zn`}0VFWJXPNM?O8ft{=Wre9Y$+8! zpeKl>$MK?E1b#tSxpY5nGcGVEBmr4p}Oi`wl6*h6l6ytb?|6?NNho3EPSU zq3cW@k^qY1E*B#fz`}7!2E2R%;goLd<^|wds0#8ZB{JplAUesh0`D)Ce%anc5Oy}& z!AxfEM~{2cP$%wQxY6KO!Bk*C-g2c?U_6$_jV04p1J0tM6&ztUCc)iid87gogTsbY z2+Wp&KpiAvv9k#x@pWxT&px=nH&gFpV`BfuV8Ncp;j$H?W;Q{unMT!wMdz(ZRSFwL zAISpAI&DW7=8*rZi04_XLbR!8>9Ri0q8}JeFnDc#;ztE^1XP1?gQ{Z(a-dydt1>q?-8J zNm9FNn!5T?qP1zAHH{~sFN%s*rbOOECgE#}4?Uw6unHZ1@}5eOfpvZJ18U$}`6@^~ z!;TQ>%O$U!+$pcdxmOVSK-YGxBJQ=~Qo`=TO@b?8iuqrgY8I`FnWJ#zu~++}bZiXVT^$IR@U z;e<~^OvrY*mpecFmZP+yw43epTE*J-{@5Lb-Ncv6c$!v-@RYL z=ejOaCY?6WhznG6xC%Ue#gRW)`F&Z=@AvPr`(A#K-{p0aIdbGaBxC6{(_<|AwsWt; zK~}P`YG(V_wxP6rpGJD4c@ejRny5l~TeRyZtcWiH48a=wul>Nj7HPW0oTVAvY{bJz z7_k$aBnqi9M5pR!lK#a>+Rx>t_2v7w7d#j~e29?9VWJ|!vPNyT!VEOuPn)mYJR=+Z z?J9SOS3ycE%qXU7I%n(sJ+Aod4Bi@vdtM=)Qc~0chVjwYpn^jSf>i}0zNeq|n4Egq z=Au~agbCNj-ie18dPQm8uc=HuKQ|;m>URF33R42kQ9A38>E$e($9!Dlgr0Rx{P zwwmL2g=783M2~&Edv}QQYT(pObIO`$f>BI1L2qFM#@WsfrSD_uV_Xu|z`O~iLiDXs zwU)OpyE5aCMsS_LXcS95kk@TELR7K_g)CW0L)X%aI49oD-eX|?<5Z$UnSy4l)?~sh z_AL!OT_Ll>7Am-jdj9RmHfUF<2YOx#M4kl-+X=QjS{#>~A8>yM&tND!{N`IxiIZxh z&4x?H=-2Htus|wlfqu?8!4;{#l-}e+3;xm4DNv1v3vy(@mt|)Lu|N z4H-sKx+jp4TE)s0?ps9KOw9Wmxpw9Z=5j$8fRXW-ISDl5lVhpFgAmLmnk`1yg*7yD zG?Lyb|A6W878Q>MnrF{vS?gDyKJVTK$7owC z4jXmFPLbUkm<_cx8DD02Ua-rFlyIHjG%l8UQJxd?8RZiS_<=$y_n!yo!|CBqMZY{W z#zsLz!rF}U70R2IRc4Tpk5e87k5c~}DAh_|_f<=FyimN`YNaA^UJ1ENjek?T#(-|@ z1_i}PJ<7FimVL|Vvo7^b*T>%>IXpsS3umXK%|$ro5HC_Oi*~OfE+WhB zf*~@7Vp$yjTV^0o+O-ntlt-r&in@UHi`SSKGHw_SmNltXF^Ql|0aEazVPhn zyO9|QVmU{Pqzht6Sd1yZtjI7DE$T~Z(vJllx}Bsy_~ZmX19sKk`;wMLFuabFOrn)N z5;Be&lhZ@FG4BGzu{FfJl*EH5r^bVjh%+zE@PjNXZmGPA9q}RTpa|EbaTn!V7puQR zTtR{6Or}Y^yQnIGE(yB{>NjNoJO+U30foxyF4)jU6!+9I{Znz&Z*huaM{t4-VcykP z6V?Yh5MxI2+EF2rfpev^2U;WUlpn|O@c44~44-%xq4cGY#ej>dvT!@i!$#I{vD@}x$)}D8b1o4{Y)$Dsq7ajD1>JGOg1U|uI_%m_v_GG z%AvCLY$^54JhexmJlr&fQr7G$H!d0;Mnf@qGPvoh@Fx4EG-7f;UI_*kZzw}X3FAWj z-=jX_{YY>hq%z&-gPMr|NaV+);8O=D1@A}vKW`uGGWeV!*h)Yw{umP=+1tK^+TGm~ zoVEwDjtO$@r?^J;4{2DV*yFnz{)+F~AIu>K`JzA3M?+&4+YHj}Z#1`#0fX0aS$Ng{ zulhH)DMu&(MK}K|MR&NUVFJemI7+`o`hTZ7|KCP`_-(OH{eE2Ii;8q4`RnXI_=loEK`bLNRD$6W8Vtp8 zgix(lKe-k(-Y5AHCIPLt7Ef?k?JreS4H}!O8Y|7oSo0g&0J0$?z5Hwq?fN;d%`(1M zMcTC}TKrL(Espip=7CCx$1hKKKR`&nQc~qI21NFqtBSRQkR*Sz3RF~GRPC%WbWKm7 zf5iQ223O_HBws(vzDMH}26z@)JTG5fC|~bFO>yhqwjQBDVTMq%DS+V8E?QaKjC4yD zzp}-@wwJz_ONpEA{}KNgxBrKz|Ie<*MTmM2o$=4A@=t}be`1^&Qd%a%IfHcgF5pqx zZr{o?(Am0^gnFo*<96TL{AJ!f*BSojf?*!d7$%(k=F(aT6ex65?E2Ek4yoM~{Y2zn z_MWSib-(Le#@2-_w1}bsPabvOA9F6fH{8YMJLHxAt{FfOQzYfUYV30>!R;)t|EUKh zVo;_! zP4KTgAn39GhrRazYbtBkhJ&GtfD{3#3Q7~DO6VXGib`+NB_IOQI|88yDuym97=nmM z6Ag?d%silwp8L7) zDb7QDD&Bx|?fGrMgKkvV-B;MlS)0h`(i2-L-OwDWF>|Qj^Hj79e1b zm6{5cW5SX}T78Zbgs|Jl;L$c#wN{K^Zf;(;)wpQY^VKJRF#i^0X?swdx#0sFYTC)q zp1NYa5mv4b*sL%IXAkKAkC_5Ut7LAQn~af9$60TdktewA$MS8lYk4f1Nxi?IM`9vk zcZ2go7U00uHLoj?yXd#Yo>;RevU_=!VSc3?d}?fpP)S33E7 zV*BAf95=j3z{d~-V)nFN5CZdSR-1t|cNPKN1n;aMD~|EVepBJ{!@qv~*3x|+{9)`L zov^58(vGHhpW|kgY)!=s;V{T!*9Yr79tfv&ya0$~c{dEJR*dPGmEm~-?4|smYk1pKHH~rzh6@F}!QbR#u9%oNb$4rhC`Bk*2pG9o^JZJ|pb3(yF=+n-Y2 z@$J&Y3H$N*?{xYDYx-lOr$(mJz1{qN;O+WTUrOvYRL%Lns0jYWO&S30`}1u+-HBWA z5;qb83@TvvI!gwR0H`-$8dI;}56$5dao>&YQ4}B-o9a$u&wXe)o8T>dU@h zOI`c+M}ztQxpg>RA8}jZ`1Kpyf}yYNP*|Bd#`ZuL#AsM-frW3qAM(;ly=Mq zYzU9RnIC)Js}{F5g87HP?n1i%1vdRpx`F$P2>I>7qo7Xw7iUAJhr7ZkL#Wo(1)~!x z0^gk8x;lE-Xx6DT(cF^jQDyiUyrmd=9Ij=a;WwV1cQG#e)}`QB9itf#G7+)M-ScU5 zmJUUyqp_UAtj;&^^Z|R`cboC0jIfjnz|_9a6~FEqtiy-CrB2&bY_}@3NB=xkSdaV! z^44mB@8u{=9@{S}RA_Ekdw*~mqc5D3J|^nrq29yKqk%M_+5Wlw~U0@8rCFU7;3UKFMDYm7nwX>u*!>Mr$P< z)zg7VlKVl{zw{mW`3@ zHw}y^xNnc&OXf*~+wOkNEzXd-I$Y$O{PCI!prH2{b`WBTVCuO&%zb_7VaMxd)^DSt z-J0%)?CaihXAzpb%ag!h6Ys7rAnI{rJrsST?YeOs@=0H8q;W_g+IKl#LHZW882cxI z+R*a|S}6HBC{(b3?7>GH^FKsp{bQy4N2}-W@12l&GB9Rh1koo>7z9zF5~nPOqi{z> zV0h9jETv+siroWoNRU_>E`474_SXIB@Bo{9B23sQr^aUI5;MG*@TF{5VQh3_v(3j0 zS0Ly3f{{g%)d#QfWZrNyul{|Odp;4_J0%u&2aVi!#;4>ZLT(5v1)I$jqDWn(JvqWo zG1N^DuhQNu4Kr?pNWbKfl)U~QRT^K}1CU87q;aaRBl@&@n#E#YGvaEor{X2NaeWU3FU&Z z-p?;6fmv8^sD0koOM=j{PzQdwMqufm^F!YEpHZN{`)VYG9n&`+5d}YbHN!5=SzWhW zhKPO`ljrG`n7ij7WZpeHdfjT0s2)G2UOP5F!4~MjNbd$H4gl%dhB2+B7w1KTZiiTy zg5~tF71(<}fgZ#tFO=ZqDc3%k6qDLr`pDBn9Tfo*h?Qzy@Icy)SD*b@|1K>{4KNBn z=BtliuYtKP-hN%K0Y?57gS3eblgEXuIP~idcqaD4uCBD_G}<|fy1J8b?bcyYa{L-Q z-lH^}9|lkZ7>n(|nOCnnmR8t>MJd=Jos7$F%{)ZULdl6~-O1&s9Xp)@uDHnIcU07( ztVtAMv1*#`>Yd|q?sB=GdY8UDa|B%o1rgo117|9dfumC`98*uRKz9XHfXKvuQ8n1H zQ3dp)U+ake_x5v2rQaIui%5U&4J*d6#T{TUTikJR8W=yj<4kYU7P7$PFa*bN9-J7= z9k;lU%<}e}4pdzMx52KCF_NQ+&MW{}jp=oCMmowUKc=;o6LTaH+jwRFe@!R!&?wZv zqvWRZNf?AgQ=I2z}^0A$QYZ-JgqacOzVpj?@!oa9MdZ3pSK<)IB6 zq`5OYw`MKZb9EmJge@-sKQ;$$t@+{0dKdRzWwmBd;Q$b=THof}wNRRJDfZj}g-OHt ziOnWJ?CQHy(L1?kn|Zyi5iFp@;>YZ^aFSNFkXddH+*theDzI&0CjwN*>?g)+W1&^x_3kCA2`M%TvP!jm0x6>|5N=P z1D};3z;WR|{k1=V+8y!0I*AfpGxQUP?ySrL-<#5ZY5t7B>qZ1)_=wg~eANOb2p~gk z`?+rLqah@9vSu-B02c_TW!3+uF6d7Nt`tp#!a9Iw*&eFdV#xno@#EpgG`zUvcj3~k z(BF5#W5?9Ww*WY1Nz;)VXRE;CVr(ybTF4EE_^ED0RvxrI@BCTR+T`(Zm+F7QzF>>2 z<^6+O*vd1yIR6j#B|B3_5vMyQ7h~EF#(>MG7hjbpDQ9WF)yd6j2}-p{Q{~89YoMpT zXZc|Ohcq9T!}`V3wJQ>%GVg(c!V2^zlFKiqS|nQEwexY7q*EO0!`OkmAk3f#hF;#B zR9ma^-sOnixyMLP#?f)esw%J6GDe0X(6K|T=fEFFM(x!JM2Hj@mLC_K zhUw-iV_pg0Ekh~squrJ6w+c zcsz`9J0)BqOZ}P847fcxkFq@M=353ip-gNP@(^b`Qz&a$w7gmkEC-viH?3PA<8Cr;*OK`t;0 zcbeJIcS=})_BR#$2}G<>b~B1)J|QA1q_bHgp4xk>11d?yb{5ERQ2B<-DxDZZi&UL^ z!IgNYk1Yt6#uXNl{44GY+)0oC5>S7rH)Bu`St(vwlGAiz#Wu+p5rQ6M*?+vEqMTkk zu%<$f5QPRum!DIV6D%N28Tq%h`@hrL9BHlwi7WA=KdF5FjC)nkwi!vP-#8Re?7vg8GAIpg^ zlhHD$6riY3@rP+S$C12%I0xtOa`X(^l@bZu=2otkawF&ZvgDB)V8oOpM2A9LCT)>d zOW&7n?6=zTls)gBEWK!SYLLyNH~H^o-~8a{YL7PK;_YFdS=H8=U@~$gS*nzwCRrF4 z9Zi-|4BnvphLgtlZRlJNM+yZvf9KZOm*2VQ}jR~{nut?j#+SNkZqlO zO4VkpxWXh9-rGq4@F2^H3)<~Pe4f7%uDtG@1LKYy8+JK}%Oe9@Cq(WIse{600j!QF z`KVYZD^ZNZs^NWj zH?IM3ZolzX2FrrKq^|FK0E{X0@Hr=oZOki!lESj<%%luJjTH6)N1!_IzMI9#sm?uo z1yFJFq-N`C0emeL?>7P;{G@PjqKhQT<%YQ-g^($8B8xk8i4Jn#Kf8_tn^hpO$C(A{ z9eyr#j@=09mgv1jmPl5C?Ts-83h^9^4owzYM`o5^Ik!8F;4Y5B03jAld>wlI*`ToB9Sr>eGzQW>Tf)1dy7V+vk;e5=&l)^KE z!2$i!p!eTX{J-&|{oQf=m!D&7^L={zbMMeNU)*a&YHS+}%u7^H?73#%?DX!_ydQbk|!3zNjw`v zEzKYZFT#_wB2T8tr!rw*yNUHGMJ*MCz2!1csS(&1O=`Z=iAj_M{lNHThYuHx3$eN-7L`KX|Zjj#KNr;t3VL{TOsYofkyZ zH(OrqIAx-;VUoXjgd@J<92OzhB;y*Wa(w}MQs=F=-l$Mz5_@RYf^jgZ?}B6ap!|jH z=>9fRlA&EZun%aZgzj=l@(!u*0jcO zMiqu$icz)*;uY359of8?p{8q;AZ2w~VjdoOn+6-KHJwATql4=IHfKpCt?oVk$eJ^) z&ZV8UM!SE^*na&RU*rYK^p7!CqJdiMTD;Z91!qd-Jw~+JHy2?zA?`PLwdLjKL)YE1 z4A@TugF59%)KwVKZUE*%jkJXsP<Q=sGcMxL)< z84|U)yVq%kl)Qrs8=W4^7&R4YeL1b&>K_46&-kC6DyfN}knD6Aq1iQyudbB5B!lv? zIiTEH8%inbCXl76a%PF*%E^>S}PBvPt!aV*I>*h(;Zlc}n>bFLNT)l~2vZPeh+ zy{`IPTRvmk!EOLB*hQ%D^&v`Og%XU-@cNEY!gT6xE0CA*dZ4lXNjl9dil-IY8I>E) z#0FxXMy~M-bU6>66ia(k!7qQo6s_@5gPe!fK#ACkc>-ANhNn0kwJ5A60-=%l2mXQe z?Td5y%7imsWxG584AAH&(9^sanmv?|2mBec-vf_NM7u=@t5glQTnd?sXC&s{wQwQM zSc5?E>a`#*seEg#$J#Q?uhlOEuvalfKsr6D7B>!%XR|d$#v+@5^l5B>MoD65>;jFq zP6$v~QmByOC2~AOcn^UUdbtG1#{3pl{ofTfsC<*&z!e)CAvvn5U8Sj|Jo2qS=l3K| zy?bs>jwFR=G<(j)KEEuiylfV2;ER^w%=7xY@vHKJ$RK(rcOr39MCoDVn_wT(k#hfO zqBsPO*eYIRxLc7^${uyOx{IhR5~`RBt>M#p2>q_Zdo*f{}72XDt6?cEgqnr zpER^qx+I$KDlFO-!Oi}pNlWQ=>hFSBEdg?Gw6Hfm_MEXY7Vn`)Tq&#r#R@+~xOMSC z#$J6%jtOP{R!&1lS18`>YT(akdnYawa%sfZLL_oW(DZt-4ueKk7(|~)-)0&^E#22g zwD~z^@@Xmq%PNS6FK(z5=Yc8xqJt>nXb7e`e0^ZqP{3x|axYd(;O&P~ne75e+M4Y) z!HQNC=~%H6@95EK8!9%NVDHa7dr$2%8avst zc`{6`(>95mM@o@E%|<*03;Gripdc3i+9@}AY9j}oxu=P(c%-Q|T)hWyioZ7(n`Gba zeVAy-v(nx=YGX%4!Gn!MQcFkfn4i4%RQa)~qHu0s>ZhhE`q5OvhguNm)ITFhK+qLy ziT4A-ca|rC*;HNY$I?!dz1;L0xhC&jFVEgieB8|Ds}!_5O{>=IWw_2tZ=wjgH=7g|6g+ni@>;jIk*py&oT}I(T8K#E71tQ zr*f2sTeZA$co;FU4LKZYvXC!Hw7=rhe~KeYMH|3vgpLp%r~s6g@>{1EJiRWc9l6=Ekz(nRl!9Po8A4zNjGyq{igNasU{og1opjk> z<~+h%uBRW{&+|(kRrzm!@_*yT{<}Nhzc1mx!U}Zaf49(Rz{~WXD=xE*zkbb@muexC z)d)#%u64|I-0qIwanz}9+xk-jS3Dcz_CLWq{de~ekAvfjEBVx%Ystt>7FzD>AnV0q zq-w2H6Kvl|@A!}&@O=Azdjb9bi?)jxSig*(8!`hUa!FaXnzOUNt0mO_XHz8nAE7)X z#wUO!gDANil)q1#EP`FC@%(C3#I+PZDh5d{SGY3LEmd<(^@&1>^#(HLDi_goe5){c zbDu*?c0E>5ruK{=-1ZX9t_74VbC*62xgi~+Z1z$7GhJm1@e*%AD?1Gf234(UCX9=V z#Dvegx22C}W-o3ZCld!8?kB#X_nK|)#H#M&o3wo;+Ky3;dud@Gb#9#QAJr^f=&7iG z&4Vfj*=!YD?xx)Xz`b8%ZPhO~L^JvtNU_CKW+LMD2feVjhfhk~)}#OhQPpY9Qsm#5 z^vbq>`wDUCj#mEd5Y7XNBSGoTE#PiwM^nGl;mh7mo>7uu*f7$5hE+ll4i%$)7Hi9t~4V1 zEOWsd(%a5%y`eOx%rr};s-i4s;y$E~YBH7S^lgZ>K;%SBOn4jGqLgP7cGVZKv#Z?@ zIn@AHcQG>vBEYJO3z>e)LKCf-nLp}y{|r#b(U_!ji;X_P67mV5zO`R5CG`8f>@aT{&99$%B4pDZhFvJ`S6Y>-_`uSJTN1=4~oF?$nE5^sN040To&K)mkRsnfLv zCGQ}0^;ulJzAX5J{S?X#d z4jp)|WiDrA43jC3WP2ESfwB`7wHESagV(2%xM$J>7At+v;c7?rYr(BcRso z*Mn`n$B>+fnyOa5vI)^4?y4H|TTU0mvz`-!Lt4PBuc|nzgFaD9Q{n>Ht-UBXjbE&4 z7;|AJRojr!SXO^A z@lJU#b8 zYS^#Ce^PC}Q`Z;N&q?XKFVyXn?|uTrSlc{I1`6q9uH|Ceol|d0x>hv1_~C#RU{77$ zd3#N5Q0$zxu++I|N*s4c%8;C}zfE$_S}F3tsn}ILYJpl&3Oy@?IJ83z%_nzuQ~kRFSfl)gM>n7?TTBBpn{ti(sQMgnwoygby66w zCdPFcg1jD~ynyg<`|FeVL^(=RAd;`$@Ab{IL`X1Lv12p}_n{ug%e%JC1=gK^fz^(( z({5$6A!EL87lr_=Z&qF2e&TXpd_RMZ{;w$p1Bs~5*FWF&_H(InmW0`Nh@stjCH_cz z<4|G9bP090Q+#E!bY-kiEb5aJT4VxHguwkh;7O!l{9X)}bZr{k+LR)44&X{AYd;cJ zYX))PAY7*vnYLG1hws_E?V%Aq;eGk`9w=Dx@a;6r4RnB&==gzHV`EIP!6)ea-FOCj zYIQpvkQVXGXs{^~E46BR5K}K$MUI*rKVQf#LX-;8R!3`l0Fm*DaJ&xFlk<|a5tRA* zk3ej}G}fa5{kh_8lrP**Wbwqig4p8K=SW;Fe?ZWH+Iv3TaLN_C@F{2MVJH!9rj`fX z@5d?Jib5AJevy5U&Pg`jlx4DP5cl*ARdB}DRlTrXQ#m3wx^fWJA!$P3Q5uyGWMmc{ zgTS#qW3vNzFEc>E()L%SvcF2b+U-Q;WG1maxT}|BYNa5E0Ecx-HNBRgj-g2))|tNg zt;<$Ze^Rkou5Q`fS0dM@xeQ3_{DFAYqsG;}9j$|p z{U^Meg|p{NWj_J>D=g!34o!Fgmjf37oKbTqz4S>2sJ8t8A7lnJ42et_Hxkf>x(-13 zoNP8$kY55`$MFEDTzy3VBHzl76ARY$%Z7>01y%ymroaT8GYf9V0V?cz$Z}r#(C`{_Xd*OHhbv!hf zrlb1(RJ4KKW&iqzb$&U~&nHzy0bS_bPaxoL9|%trr4tw>k0b$BZObE|xS!$YbCLb~ z3jf2y`*$1uyC430r2O03{M%yxGMW9`9{yktJJ-n?I+q@EEPfp;a$yxgez2&DDai0o z^cYtFGVA=`G1wvw^VW+RZnx%!m&`Aj+iUVyvzj9c{uOfc^SeiD-SdB)cK_p)yv~mi zg4fh~lQH-Q3P;{9M|WcZP3%?Br3z=W(d*8iL?+(CYKw*=0aV#I#T)vaBzD zy7ZH*t1m@Vc+=`^?lf6Z%j}GnH!m7ljv?*3&NStA-vX$Ysov5ma)rez&3RmpC$GE9 z1)=~}{bYK{b38x9E^zhF-wY2hnqknasYd%T3%)xAa*<#0=Dt0A=S6D^=O41ste$G5 zMsA{NvHgpv&{!3C``c#+BbT>gokTb$W-WW+`^c>#*$HT$rm9{+RuRbD|fIwNdsZ2hO`>y6Gf zeLXv=@cAc@!0wzs3JM`3%NLCPEG=vjxWvy@C7VSy6(F*n7GZI*es_)*<{ZB? z-qq9^I~@9ABs@>DDI!ioUY8CsP*x)o72YrEa2s?na~sK)b99ar?07aK>AliHp{eKN zyadG7{!%58YRs-7))7q4#mh_uaRca7hdQXC{*jwUK9j`*e(|IG*)2_~;Dp|ED_ABE z>P)ppu%>{~G0dSHv z3X#(-(LSyZH<6Ogsb8YYi3dKHO$r9WX5(DHbH^lBdCAd$*}_748F9lCKzvAHHfA?_ zA#8TJAE?l|zb5KtQOYD{YB7Fu%iemvuY0aj@69Ji0PTj3+dvO#ttbdiyk3x!!XQu; z1<)?Mqf5@D*hl4<#Jv`5+8jWg78)oxkog#aPpX0f!hxng!?O#rjPvkL;G;oej?|YO ze(b7g1?S63?`29mV`n}s#FRyim}SWwsW)*$7DFuBEPw(&kt>G*0Eo7vEmC9M_WJfK z-!o%|Jk0taBB0cXy5s`Dd(V3gSn|px5UQ>aLbu5te!AcYcVydWsu=Os#IdsnV}#jB zw2plu4WqEP@svRJ6DY03!#&%`XURwr2pUkg5&Ym-fKKI$;SuALD^L1em~Nenhu*Mb zmbn3A#sy1t!W~9NA0>XNC^JKstP#cm`SqAxt%b0e<$ee|*?oXJ_SU-O(-F1u$cdAM zp+!YDu^Epc;I0!7aJ|v~$y)IlQ`;Zz`-u-2p=jN%sPMSIeK`V7WAjJ7=E(5BTTS0^ z7Pr%PA^=pIXeAchu(&`jw~n-l)5ixgKaipTCGtU4l|NC%)W&T|M6G=!HAvQ#H{>JQ z)dm1hbJq$(Jr_2FUhb-T0c$&*bN|2uktN}8_I`RYfPv8!$Rby6o(Pm?Wb@~2iYYK( zN59xPG^(q6x*OIzL&lv(pmSS|cC%2i@V>}aw0&8IZfN*bnXwUzw*kxia|q*#_YVMa z$FBsI`SE~dSGUJ6qBVWw73EXF)Pbs#^NFA7&OCkL_Pva0;a84NKmxI>`9*t2r_inw zddW!&?b{)J_YXKXQ|%4~0~6YZW>dz!$3{vox|Kzhqh+@LHsvM*$S5wru+&Lar?lwO zwdT026^0f;ey0kyHGu4xZ7_c@0q@-1e9tAqRVk{1nYoRZ-Q9gi4#F-I?4OvCGkm^* zxgMIPZ-XRZ2J@m4Qvo>M=65)rU(FV2zGJ-t!}2zs#ikp_&Sh$u2?drYZ zT9F^qxOr(nlKLT|qrDoS3j*Vz{f@+b@jLPER6GMP+es-bPS$LZFXj!%-f&7sjA~@L zQunw|(+6LpDrDJWk4bw?edC7=xk=4Q_%u7&Q86IBTwtMv)nZbg8tOYAcQ(F|i^Zcn zBmpt=3LH|4p+Y9CaGdQ%$2c**M#B_YiDQj7rs+FQ(meyHEp@>3hy? zw89a{Fx+m>had;=`{n~lu(=b(f>_>l1-<&z#-nSIeAzs;>%5O=x|{jIH#mB3eUk^3DtG0vbeu>($1doHhMsS!VE_o4OKPsA7p{ApD~wR zPVSGL4ykA+V|VqoI)bWrZ#M<#0?$z&xKdy)do5=dp`EC5rU0%dEBY{pujIi&GKy_* zwx8e={DosQ!mdM$xjs=Zl-kF0s>~rj+jA#Qyf7{9nGF|&7v)wrCxsUEr*?c^v=>up zTU!3OAtBVfvn?(zR@)1k5KPpmVbN;f!k5Q%<0sI~W4lXp`MO%HEmtiDhSgypJU$EJ zRKqtsLzJ!P`Ci@^539QpY2o!JcQH)ODH3-dHBjm2wv^{%YMCEjaqj0(HDRXomi zM#pzpeyoiWe~o!KCrrW3CBg%XB_)%RBG#`*zFUeD&g8G+x#t_vv*7x!Lj@7)L#C}n zmU+RH`M?A9$w&mlNk8gPRIK-T<}@8?KU;)O>N6TWlbvyKzPig8Uoa!(a;t5GtLe#@ zLADk2DfbB~n232Zg8ckN;?tqzp3Ubg({APH>E2LD@7QoZFSzPD?@7Rt;e-zIPbV`-DZg|8W}fQ0}E zrM|PAVz4t{Uf#%ockK22V}W!3d>wiN===GzvjnufVgYolZ$DyA>xv2IV8)U zv2Yi~r8f_|D{)O{*DCi>4}qioSUMQ&E_fD;g|oDn3sHZLL<7*6$jL!T@{cV3xxuU) z>BQ6CJF9(mci-u_dHajnGBMeuQ}Vr!^7$fs?(hu7$WYv_4HE7 z9p(xdq1y#2ZasTbvy7W29g68v7h+fyc~ZyLq!xS^=iF-2d?SRMsA3c9>I`e|%*RqJ ze%rz;oxojlGjhE4^H!ODin>}pzVIb=*V4$Vd(OdD?&K^j@}JzsOJ%PFUf3@7xGC?g zhY~@lk#S(jdQp(~?64`SWV0yN5n-a2f?|wR3|MadEm``3%4+G=^ z0H=zP?q%^eNZrj9bG7oGNVglE71oiH@Ah5}yr+9`_a-K#T^R;xrV5igjLEZi47z$q zU#xw-*H3vjT%8it81ABs3Wl+}6MvG>?j9|uqnyK*B-_YgfdpU0a% zv-8xeXy$eUL-^!8%$?I@YQv|rM9{)jp}4rzmutdOxdmsQou5kBcd)k*;#2v;yV1wn zM@Oc{JUKH~Y_(ZzTY)Ae%QG$zx}~|i&Ep3YlnR$G0V)X z@HS@Sg|o6>&b}1e9o4~92LsoYWRtvtN<4`X^*k`g9v0O0zlm&Kr!KtwlJQN*J1R99 zismhhAU(=&PGm)p?@P-N3-q#P^WdBEZagvyhBj`>2WcgLoY?PfOb5{ZbRt7A_2(<|v(}Sa2Tgp=82l7vm}+a8U1_us#6M!pf8-Pp;OIA+bHU16FrMn)dd-c&I;pc5i6l3R&spZyC=H%NpYTw=j_HBZ=WUwdWkZvQq zpxNx903}OdB`I9X&kmkkWUJqXe>_K&h?_`Yc}Rk3mi;ukKA9A-+1jr{^q zROHFWbG~%jz4XMV+7R;pwLdAN!NHjJN_^+-T|4?antPluyTl>R_Q^ujSTgWY^rP{=x z=Fi*T^&%Z7*D?X1O1v_Z=4PlUjYKW}THnf!_$}re-mX<;f?`(j(wxuOzz7>y0VL0y z$>>uwd7_XH-xH9F9I2vCSSXP6F>O$|o8eWEEbeQ!)R$kfscNcnRh?L|iWXoo(gcCC zFIL#g`t7{fSeo=(Q@kV^Dd{<#-4yVAm{ca(kx%d04pcjne*99A0&mE- z^_msT7EkP3n`zJ56@M(;__HH(^1ZI+HpF=xFAsI?R)@cLrhwj4^}ME^w{6di&ZP%j zW9kh|Hb$t@#CIYYh*N5FupqVrjO(;C>iOPMu%;rFvfc0iFF3Wz0 z@d5nPgFMsWiMZkJ+lKNNB38hGRrg^sWiW0sW-j^`EI7M)`@JzfVE5DTi28Yud*kvn zRb1_zUS=E*lBiegEWJ;!HSC)6!F{hSBdN*GvlsK1ofoW=)c2Wjki~EAG6*}i%?@el zq{8%?^fA|OrvIzB%;`(hHknR-f=RBg*NhG?6Y169sw*)W{DPE zfw$ld@Dqh1zoz5)@^3WBpO5d#2roOB-|M^vW=|(xJIRK?A-tQ<&-Z#=XnmS_tM7$? zq?aYFQU2p&6cCu7^EPb`No%&)pEit=-}?m zQ+!(j62npLU+M=iqnb{czrPya#Kw2Jlx{@PfD3sATwd47fkcflWOXC=>791xJayBd z9@DqVCer4HOGcl^C0WOOwZ%Cvzm49*Odt9zcMyrEn8=xk$f^p!g&%~`scbP^x0y>r=~t7(=9EC@pjI&kWC5h16$bd09UQt4Ya{Sc9h0bZ@nC+FOi! zi|Hr0KN>bFONrh9IQl()uAcxz3;|^O%oRLP!~+%bl=!aIOpwj^2^0*U`;vDLPA8wc zDV~N`J1A&x-Gc#XL4bGD97y~rX#nNhzkg$i4}OYcWR&ks`j44#lgIJDulxC{hmzUw0ymCtOz6G!R51zU)wcuY6Qwl9KxEkcMHrHc8c@tv4icaqj)mLxtSvrR)rQoq4y%=b3f(6Gjt$ z0ZwxB|F<;-TvukJ4%|H+j7!GEoi^msRVlmlFE(&S!L2#F)@%^Z2EIK zx2De`2_dL=<#~=%rfonWOWhF;ROTF($lfILQSOw-RsTSAInK(S6HzF&jJ_RB21cO1 zF}9hqFz3k=!n`$>#s}rkxB0xpaG1D@^*2v@&3%GpelN!K%sYWKvxeyoDTtMgwQ%zk zF8H;8g(gU=I%xtVBYWx0rqqcJU#DJj7x{K(zQY&CEazAlEkaBF8Uz9n1%u{51+4T* zWAg>mZv9PYX%)+MjA_FFis7-DInkv?*UXjYbu%F;EDAm&=+rrMJ_w#pP4b#mom~; znvaDl&3=^Cn)Dp3C%tgf2^o@5d^E#`u>;3bi}dC>G@ZQ-Ww-;2Qk-66RCNyoEjUuf zXYzf?u=f(q7H~(H7{1VT5R3(aO3T}1_wHNSyV7(tIfQipSeWJ(U4K{m9^du%Jf|%b zyTZD|T-d8Y#2~+6b#{?t`8+*G$KeHl)Hu-O-N0Z;KLMNf9U!F5{!f5VnA!CS`m_C^ zTK8L!^c9cq+p!SE+SRyiXJaDjUX7qJB9g%4M18}?i+N)c zE%k;$;MUdWyvW;^DOO z9YZNfoMInz(2_KYuD<(E=Du;Ce|E3Ks7wipn0eqSeIWP}SU^Q5=)YL{$gOhO805#v z*Fub;^_4vxEscxpAKbnz{;e_YdM{nA)6HordK6=|NN+V=I;1Tz@0z|Hi+f3ShKl=H z)kfcfGe(J2LAnvO7ursEuWtlP2}sEuf^O+n?!`#NwU@pRdDP0Dq^UYSohhg4ET`#P z5}q@bSJ3>AmsP&^``gW!vcm^9P#x3EubVJ1xT2XIh_^XX(lCuqTp1QxzHyzULKM`_ z!0{A;gUnZ@=_E8i?nVN&KbX^J#o}x5;Ji1V2rlfSjwffnp|3~2?@W2Gs4G&&V<(3m z-K`?)mQ{!vG(2U@HJgdMdy@MvN*;L|`l6IL?x(*)eA4l9$3jrcvV-8?mS zi=Sj#xoV{3_ECjJV0np=)cahsX&efU6eQJK7cUNrwvIf4;5f$?y9$|`E`|ecVL;_k z?T3C&trwQ%i_XqxhQ58dXVld4aZ2TFb^`^;r`LqCdv=()SPSy&iyvl+5aK97>h zAKvLRN3WH-o&SjRYM^2>^ojT+E6z8}XkGXAlBlpE7l@`n^OIedj;1z()nQ}aHIol| zs>IK;qTcsSOIqM=SB~H`g_F|E2Q7iGVJ*0G#@L8joY?I(vjf*neTqBW=djbTcnWq^ zFwaK1g72XH`VE4d-uF0g@OB19o$9&H86KqYG%k1vga_5`-wfXxKCLgxIVNkP*z8e2|GU%U@$+F0-W1S-c%28E?z>_T0or*a(O zG(y`n$qHi%IW#ZI^f8|7g)J>#{Z@dedKBkuoO|koR?-76IaOY^kc3`|xjP;_TQx0& zN4GBBlCHXU$kC$WcQ*{Xzoe%ABwlv2>IE1%S+z~Lv{ehR^s25?oh@&_M1j^oF?)7$ z456V=|FhftgNUPBCWWevl9Jt}ZIJ%h%u8yc%n7}h$iQT=s)HG>>wEG9N&1H}4Wy$M zqCQ~cMw9HpU~adDC&So?RZ@7G`NYj>^Tx-oG$~^>mk>0c$BKqao!R4V$2wb4oJ87$ z)V9p0n#4!;h zTX`g?5px5fL|Y%zj+#bI1GF;{pc8rB*ZH%mR`B(cDhxwBr$gHnL3HX65Ot=+>qj~| zb*^QUJW#64G+lBCHY@u(?g}VMX4`A&{+d!D_#tW~Gv0rh*t02U9~(?C)2O%NWdiUu)^GgjiDYX*>D;=@+a%k}pz{WPD)W07ee&Hpn>Q>oGZq%$4ir zmfeSiMT?a0bV`Banz*J7zIxQ26#wwlYlP|iHD*_$4!^cDQe0khWFR9UHG`b|!Dff% zOw20Nh`pOoQH0@zr&mQQ?^uvxN#KMr(jfN?X+eKA4K4XN9Yk>vZ2F`i19 zvfxStj6T;R{b0GiSKPQ50BfPVnxuxJBhuB-D$X!3speAc9HT7 zqx1KBOvA*bur8uRXd-PX*=@5migW%(tX}ta5Y~ye*gT!5n`tW)FQc_e7xu(%k0 z%50JB%(@sNuAGXC%O(^@NiC<9nN{$P?=`T<Wpu`ZLp$3j*vZI}ay5V2Pj44S|DwSETZyE*>6UV_tD9`x?c`(jmzQ=^zC} zV?Y3=PWzu&NwQSDBM=~l`~+H@gl|#s6F7mRd+{R%=6`5Th68j)*xN^w?3q? zy+i>-@E_sKJxdz;EFPH)xo$J1&Gr8-K<+Kk6rgo9eY){e)y*n>_okUUwF`b+LEHmH z^*@2mT=cb^YFu(`2{5E`6uujWp)P~*=*JTEEI4o!62e8A`6#w0n);X$aP@~olr8Fbg33BS?Fs! zIgu`-45L?gqsmh}!kdYPu=z(^G)KgQM2O&_?PkR<+i?d;!gU%C4%YiO7yPs9pR?0& z9iE*GVld4W?}^(Kcuh9+lulv2d*29__08{$ixY>bQ`PzC_pafpN-gsB6;~ckY)lY_ z;7eQcL)zIcSK2+7vh>Sd%=(ywhfbio)OXF*FWJs%bPU%1jgQA#KgoxZf!;b4S*9lcYZC&x`ju zoQ~spQqD%gjes$4uog+0)zyhIegs&7i>>B3JPG$%7(jxi6dV-- zxvD&iaEk|6nth64fGLji=xqO-elDKjh~)7e{{e?3R^!inbtV&o#~Ujl}v;KTI^aT)D(t>RL2#;!ft8 z)nRzJ{o`rv%m>R|y{DVgG7By@PF*e&jKDAP=UI7tE}+5BP1!CV98Emq&h zUJ=4d#HY`OlFuo9v3T#;Zy@E=ZH%rq(0e|{82Sl4?vVq)R;#CZ@)>L}eoCdg+h(Xn zT(o0vZrj$qcK-@0a{2qXxM<1>vUM`<;R1>h)xpFU4~NqiTRS!5Mfmt?X@RrHDlL$| zze2Hh(>DMzZq{tX>)dq$$7XYYA|U-&yUiBdb=>AUyrlTbx9r%D`7K>Pq`@jyBQ4h# zejepy`HvcE))&c+++qMlK1P6`Zw$Ne6-QX*G<2&u1D|%vJLXD+kIzzvpkBgrcAjFFY2|ZdAZPbgi7AVx95>HxXw8k(z<^e zZFkoci%~*9AX+t(_=MB%2dFEX)y?=?YB$21Ru?Mdo^-MeW*WVi>wdZI&P*FH)XB}p z=uR_5ty*GuR@0(KE6DJlul}BKPn4jbP;xFrD2=wt9bc__Si>ZGWA<8wjCU{-1k2mE zyM-MLik#7le;NaI&u&p^N|!C0dVvq*J#w==IId3ZYbGMvKgwW&Yt%FAMl{YjG#w*2jph`Z$4e z=h}!3^kQDva|J>04q5I;Fz@loMCBKYtfkw1Tde?L`;#8#e5@DGX}VaYI${}2m_^!; zmf$(Xa0Wix+;6kH>2|kmok~jh^u$$nJVD6G?f|~5KXI>4vz2VODc#4eqb7fI?77^CJ@dZOj9aPNm7x6|l42w@Q0e zRzdJz3R;-^Q;&`3Gz`r@&?f0;iwOMirX2VnFtc`XyyIN8+}XVN^HxIk^qn0UwP)DN zRV@~W9g`?B88yxbX(N$!Yhfyyka!+qEb>%2%T5dat2gS{w4N_H)rtS`6R5Q2@Pe$2 z3q4%&AclIRapEf>({$3&E3}7EC)iqV@588;{M%%#yx?$nJWEBJApchV|7!2Oqnb>+ zwecWm6lp3jbfSO=h*CroIwC|Y^deQHNE0ccgM^M^2u(yVgr?Ga?^QyRA|SmPAoSi# z{2piKozWTRocCSd`K|T+*6|OMhY)%0=PrBid*9c-E*dz|4|!`zTE;QRtYg!INiCH5;V!#gl7105D6r;u za*Nc`3J@uS-M1UO43{X>0_HI&w@D)uYv#4X&f39lFR&ebkZsvj!I^5e>I%O9yhD4bnm9(VkS-ieQr~GL6cSH;=m-mre$7 z(Y+Q!lW>~76Ww~RGqsmjz3#wof2e(bw~R6F^wM}$5R4;CzpJTEw3tFjfs{Kfq`eGz zbc8t_s-GKL?y_-R+0!@9t@sP*_+s|K>T}{@@{UHUyJ?XMizOXgIvyn4A*0=%q0e>n z3FC{o_aBwDy0E&R%{>m4--nZhoIaflrV7g3^^tRvPfmiTTz@pg$4D-DhvF#23kq@A znAN*~&9?+dcPd?z<5(6HNyAedW{b zErRPuFe%FNVAy?oSjW4oR&5LCqUyAA2W>91ymetz_NdS2Qj~_ER+|B$=W~@p$)~{d zg=Ixpzt51*pNciRJ9))k`xj|Ow$ssuyN#2CyQK0-HQZmF2g0cc!0wB@&={0g(XwDE zuItx+>HZS7&ML3K^-TF*M4UdpI@786+Q~CFH&dnN9&Q-mry0M*2%h)k#@F(g-JLAH#=|sDV+WQ zd(<5~cc$!vRko#LlpH61Da%XSW+nIb-E7(tnT?TuMj!5TL7nQD67y@uN$jCg&Wr%` z-FysCKl+dd)c%p~X|t+3IxvNik+G4QF0Da%$Mwo`-`;Lah8%TZgyJDG`_<3~&kOu9 zhd0gZCXK}-YFJM&inE}p4FXbJ&M!@`v5U?S+)afN6o;u?aNuIlb~BlA`^M{Nk+5Uo zh^c3{S**bplX#9D`Sl(G6nCT&4Q-G<=LLk&$3Ud4@6HHgeS2XWD;4y z02^0}y}zv|L&(0aN=cR2&8Ly7Z?<>o0-!KC7=aN++MV;shFD7xvHC)u!}$(=iWRQr zz5KCsIlzfcE<469S|1J9yWB#8&m{}VF3k!uSmbG~iko&&-L_EF-}nL&X4dW#k&BUg zW^yXfu>3(&4HV3!i0I4i4w@3-D}9_y`J@_>V&|3hOV*K4(DG0cL3ITBq{ed5+k%3!1C#Rf~L~+U?+IIG5Ve!edb;VWT)O#T`k^Hd>h9w!OMZ zNY0ilZ1qqnTIYW$UCMKTzzCs{A>?qgqb1UlI*kQ&>j0d}g<3L0A6k=B+Sorq%2wge zr!p!PZ(V+ww<+SF8&K-Qqc?@+wamQ$h74F<+#)Tc~S z5eq3bo^*v@w^}!~B=CUb(^?df7_rolwAA)u>uA}cAJV#5cqA(PjS1hGy6+Vv&qR=L= zCY%&+7#cY!?nFRS1?{nC+?A6vch|h~*ztC-1wfxPH6X2OTOQIPP;p_tFKCOB2u2dCoz&DMPws}= zg5kwYmG-Y!y4N#BzHKlPyPF1TzGH1yLl)Mvb+nXhTVx6^7yCgM2(M8p9%izB4Z(dJQ63rFzvlo?vkG1nR1TYR{59Y_5k@tDG7 zjgcIHDu6?{^>5q!=G$S|1Uty`ywPs>Ot(TueDyQWnR(z`_4Hw< z7XRwG!%XX|$!u1B+?a76T*5Mn-AK+6$fbOTJ~R!`N@rKQC{%fGFNW<%HxXySCeL)I zlmHv{ROVa#${Rs&# z4$_foSZ(Xrl)J(`3`-?Zs~{3RU9t>DHnh(X)QG1?bxzeli~&Jxf3=}h{70+oGiG=9 zA1b|CT>zhDDBV3t;YM@MIA?LltlrIL%ep|BWlC$B%s0R$Isndc+HP@P%}nw1(n!_f z7tr-bvvvAI#Us@-2zI*5gBLz~+2#q;&qw4lu)28+?0LCsDNUqH2_C^2;AdH+`*r{mR>YQ$$v@16#gPT1u`Ws!w7zn857bw{<D4a>d+jn8Qc>d%!-p1)TQPo>8;v#`HEFHlc$As$|`!2n8|P&f9j6?eDm z?9-Td)!>wK6hzGfR2)Q-#Wi5!+2q^&Ch$J9dZpktx$Pq^PYq0c87A5{<^`7wV^t&@`{9ZKf)5je3|S;w#& zNK2{cSEDWuHh$DLp78OahB3doBo8F!IY#piI3|9{4a?4YDy$IU?L%9A5fM_^<559^ zy(z8-xTOPE0AmXR@>b6kGm=DCZmVYmYO2J#aHVO=+tdw7T^gB&_;S8#?%<6#W-Z|= zW!+g++)1*Y*1hO$ud3261k}-V7%ED!xNBbXJ2+#VDa~yb;WqP?gZi$cU|HML?pBiVehPDg{&13r?%}LsB5#o9=5|rM;ao1 z)M73s+#*b*A$rgkLxEKUv8&q6&U@eO+IaghQP;egH@f!GnP&ce>if6eem<1gJgE(N z`q*j6J5*FOq8Z{q*RpG-)mΞG2rQe;!a^!bA++#Yexq{!Z-XdO;X)AUeKnjCM=I zm+p`HTR$#p$%WJZ8W=bkk(o|A^_(Zrv6ua~ToeXXn@Xn?BFz{b&n zE|2`tcPSpxpoRu~;aEWD=)>EHDJgDNWvr57dITB+g6fPr>L0<&8k(qEg7wMNwB`{&@t!QBVEu7n65ETS_44Xfnf%Y!PBZ zZ>0%9PY1-7&y&7w`{OU5NPpDx#;E$f)3RsstUU!rq^C}h`qs7|Uy>Ko9F1JPbnm9F zKUHN*aCTqzwj%fu#p(wHQ^Dz4KCVWOuHd29b~A$QiY_>}R6WZ#@goImytwobHr?SH z%giL_8W&E>6i3d8j!)vf5Fy$Xf{J@X(0i`Zb`C=sZgEK$ z(jxMRO{q8w1GAMnp~tK_w&x%iyYN=;I1l!wzIU1~W^U#-wt$a*@T>f*Mla)OMhdSN zr>e$9BM0q8(W9R;HK=KjxPr0GMx{ftp4NxQ;_9Ej)?R#;Cm&4aCx8gQZ#lX4p;2)7 z311o@AjJcuQS6a@^~jl1eeqi1=6@Ex$^9-MqP<7VE4z4Fzxtd=J8Tk5XHU|oKnlgf z#FdY-pK30JrF9BeupPwM>a}ZMKvr4gLrUeV>L1SW z-R5J-w*`#@Lg#4$0!a`%?^%7R??l7nsijxq8my3~u7xHfMVX7;2ezgHs?^YJP*^(@ zIyX<-C#MH(_t9 zeN$P1>xBd9OA1;;Ww4oE-*fRNHWRgl=v~(abNO+*u=4%*NjI!LNo}_Hs@D72>}Nq8 zf;Zr!5Z7dgZ~IM^4u;*5rUw|RUzEBhdrWj))C4~Ue!CpAh_f%Z&YW3y8 zOUL<9z((|v0=Zzn$!7EB`KqAKg_ycgX6IV-L^)1}mJ~1}jz#O#IJ-ZP?7nmP^3{T* zqcrv@c9@9H9B~RDm^f{#)n)!I#qa+k^cnwAwF_TRulO$_FB;bs4gJzhsYxY+j`R7> z*pk$O8HNVCbkx#$ZDembn%m3Xat;(%}~iJEMG`T)>L1%#?AyenksG$ETOf}DEIoxh{7rE z#0!EQ{7$VOtrtRVOnStxmIM(p#bHkphby+iC|_ePJiJbRW(}=(&CtykCo%sqC6nWs zU73RR#uYSI<1Ck1XWc4Wz$m2X)U~C_T|J5=k{tPuaFu38b^|w-C!CfsmM3LsAEmCP z=T90ttF4=)uz)}iW3+&~4zIC(%G!X)^c|~0Hr?|T?bPoLC}M~rn1{C$$F4H)9)%pF zF`#MjtnCUCE;AndTwNip71D2y_*>ULr!b5NcWRM0|7_hDWZh&y!bvl1=;Mx!6@XtYxIH2l%TfC5y2sG4(By=t0V$g^m91b0$f!)` z!q#Ga;<3eF_+p|!$% zV(TV)Aq6uWjhUXTD^;S~xiFV^vV?`R1#Cb9Ss987m0s?UhBjKICk8ok-5sHdRZw$= zpS4MyOYzqkVO%M(o)LBA1QR5Oq@^M)U68j+id-LGiq)Rt1>ITH&>N?~@8eMJ;R+(f za_Z^&SHiUxet!edD;EnT9FC9D-Rpf0%8K4#TC4~`ipkmtREZ-RK#z;aCOzFLQbD)D1}Ew z>Jo?#^pb-PXdShW4pW^rCCvtfx>&b1L7WNkEXE?eUD|4?ypLzv|ED?tfxWVl+85>| zpv}R}Ts2FHB7nlWLt0rT&1R!S3&_v9gyn#!IZ$Xgf8km`!WKY$Ayxg$KIm~<3ONnPgKb(%%P?jgX zFsvv`Uw;Y*X20Z0I`lRXlY9Dwx{hM~%X6wh&lURD4vl4cHnrut8%a}0oJ22;By+G! zx~*dfQvS}8Y~^Jbfr?;bNbp+*8kzZ;hmDdIgk-vGIXXeAH|jb%)`xn$Myxke3JQky zN&y63T@iDIdYr$IoT)S;G)v%-W-(&A+QIP_l#LdNaE&PSym$% zVEBp?nR0LR7|(O^$+w1{sBOVY6N;eVxW`s~Nujq$Q^{zK0~MieG*;D&*O+2}4vyVv zF6rq#U#3S8=a@K?^s*$nxZ}JGBpk%e9pR(E!5J67bhm?U2f1(04!QbClOnlDngiTV zC|0c45WAwqoOw;sGx@hyx;MdUcV*1a1xHG1IC-ER&v`zIB=rK3QP?$7u<@>#^sQ## zh4krnb83}&z*EWqu$E!TUSS^RDrcT6q&lr|UZ;83Xc$PVX&82cMUW0zO7l4PElUHz+2kQMJ5G zb3^Dw)>33864dB?B-h9ux3oEU%+}ssbdXQ$S%k+YttHDP1yy-l zkZ~D2(sDOztp6 z#_eLF{NxT_w(33&3{R6k9M749%fr~~K%}H>k?ajp)E()&lGm38s-=WbW{)KS4^hs< zt9dpJ+r?%7+Z!Tg1vvy!v36uQ!307xB5))(RS`H@?`}*)O!6vq{rVhHDYU%ErlT#1 zaVVq$o{-fTMCX)-c$2+zB&%1^A@U1|^h~|*=uHNL#8l<-TVXHfOJXzNfCi(uyV~k~ zUu5CUQm>~=v>~rKNzu_9p>QJ@0HEvcQqX*1)>g35AE~1fC)C|-jDD`#8|L(in;-&&T8~Nr&s?Cw+jo~UDt=05 z_D%SPV1?EMpqtX<;WeavPY62zLa`fTM?}{<*JA{G9hxdaxb!a6{o>FxX;+W(0z!Hd zgm=*Lg=F$2!Kpl}Hrp)xSNGRsbMfOQ6C=pvfe-cWL5Q*|UBl4KFQd#(^zNqq&1dzz z(XTj9S8O#wApk0ob&59i(~C2@$z2hO1@SQ>lBh|HWenE%oR|ZD4{JxkB+c=QLSSSl zfq^4ts60qtvL9}qFd3|(3}f;3Zf-$GOTeWfEmUr4*jUp=Nk{4q$(eSp?OtKMyM!#D zFm4-W4wQ!CZKyHEKyW%|Ro?k{=`ro|62C`+J{iX!0Ve?r_*7V?4)5G&R=I~SSA)6ZK3#ffMOw;Qc$EI3!)2;4@RA6JhbB+Vti zX06s8$qiJ|%gecm*!Qg?tw-TjjBT13oT2E~wRPv6uy8x9%!6L5)FhhjsgLcoPc7DF z&5Xl$qLGt2yRwXtJ%*cg2MuU<8j`*Jpr(%^t_LiVADo%5a6QwK4Hd>7bD2bqM{;n6 zA~X*)0K|mE^}*IDKK8bn^`0eD3AZ!~3TJ|^{s;5v)Q>2g%1vZKQcUtKLCfu4V&JJ% zkK1UuwM>;kEf5ccf}X|D{mRAS@RQ{g{=@guee|Egc73V*Haobx z$(S};cs04M^ULTQI&&GRpX;H^?z7F}`~0>p<5YuE+s8?2Q`O%wbD6fEC_L0WE;V|7 zu--mFcBG!nc|PuS@(4KtMbAV*l-Qsspo|H%=4#(US5G?bX`~heKy?|>SJcqa8lcaa zDso06BW=3nfOaCSAKiE5H(3Ft%K+vO_o8}*`jDY8lln8f*Yn{Esb}mOyRVSc8#~L3 zY&_~h(XV}^`c=YaT<2hP=hIg{@_1W0T^R9YZSGFq4p8#IAl^&;$%(_4ot>GiDEuxf z#JW=HT;+=ObWCj>{h&P4IbCci$fKUEgoQ{qJ9sShF!hKY{wR(k88VUEjECR{v%54D zgWio`y+-N)g&e=X?~MPoL;erm2RKe2$si%4kzpibOQM~-KpNU7$tvd@4UyDcv+F%E zxiMFPPX&H%W6*M@*!UZH(NZVK_oJqp7Ofb=IMso7u#wJ zRKJRqIA@>FJn_*jJDQ-8AgZLX4!g{}Bax-Me|<>Oemu{|-f6>h;{nuqjfXh4K{eJHp+DPYDfqL202 zk;0kONR4FP!osCHX_+vM%xpx52mfc}4m@gKa##CmF7JDL5UfKc{2FNhb3V34<#XH_ zfM@Y~^}rTyN2&M2lU~w|qA2eYRPGSU`B>$Vn+@?v{~|Iv7pvp$f>>XhpMSd_^T$;* zlWEGzX1sheO=DX>fjjDv8S6Tb^m|x=Zye>(ca3NzlA<|k&O7to*J+@r>^=| zUoExmWo#C&Mz1KQ*7gbb8M0$!W*+`9R>(msfH z{?k@oWrn`n=qIg06g88J`@ZFo6mU$Sy&36TDM!g3g?EJay(*^FvU~DH&Iw83T#edP z0)hpG6u!Q*O^oe#ov#3E!nWpAs4L?ni|@{(~P9MWNU4axPGXB z@U^=8OWYh#;1_V9eq}znB3j{e;P9E;hm;nP*`f>e@@ zH{Oof!y?`ss5pi4x1^v}ZXIjduI1+Fp>jvz!BssM>4{f;l*;C0X5&(t#L-Ee>v~G> zmAD^05kDM8x<8~sES58LR7nMu-{tKYlx5*Z;h1=EchbD<)bwRvikvI8>F$h~W64dW zYxTqil1_|h9I!20xMXlRwdA3)T#kCz03`)>;ex@X=ZkHKkUIHR>Fzru0@Z*VK z47O`r`zQrf79PUzqNu=7);y~;^f5&5O!b+s@1JxoH!L`gJv%fmxUW))>oK`JDPxnM zgMU`i_m;?GB84WA3Qyr4kayS80HVu)1zcPCxRadtCh;7!QG&{K?s(Q5P6=J>k@A8U zUE^-d-Lu-WW;IxE+H%s$(=0(TQuIDKw32k9Xjs8X27jm%F-(;q*o_79gKcoSVVTE8 za~yKyN%6`cMnZh*g=~3R{Lut!pvE*P_t%u~?;?1=Udy^V@Sl43XoBt)9zgu|^r(_H zMMzhyk_F%&98Qqsn`%*ZGnev$@0gLY^>)w3Q5c6%ioKNL8I0rI_i^Q9S1I@cQXC9w zgqrgkWOy_h?KoXH>u#UZL^|+}wi|`G@ z?y^b~ILEb8``GbF@YQ#6Jq$u1(#xc_3-)$R+u~k=-A6Uw^}c28Jnuvcpl;bjqi()0 znA4`gV>$I`1UvK)UbgNgBti3rJKkoz0hiRVZNXuHfRm4uPKwc4u1cS_nfaHi#EOfC zSLfi-0*zw+QZ9IK_Q+yS*vI_B%R%J7(65H$DoQ{O3vUSG+YH+oNa~%3Hm4M}nmd+S zr=FW#Mkh$)SgbohPVIs!s>RpJS#_DZdb+x>aQo4Us@~A5FW`8;@@h7)cc6;dl0W%l@kTRJ@Y6 z#+%TU6jetP{9+dj9xm(w=mNv~PEbwvHAy*03UqA*x0pZL^ogPp# zKrx==rQ!V*)jbY?nXRU?&sg9U%VLIkGyrfkY`+{mS`n&6#)gmCGpa}@K9m9mTe5&8 zWa7SG{+!oc`#XY!rASGOTE<<)t3VxSGhXZ_q%Uh`kc^3U*QqOww2visGVJBA)cDXD zXePNy_eEa)Ci3{N@?G`{-0`%aJ)ovXz~$Y^nZ$hWPqNi*59KM2kthoZ2|2UvGECa@ zbyjc#XAn+fo6FQhuL6?Hf4?Bb+NiWp1ACw6MvF}UeQvAZ5(CU>#3Fi=3LO-BBgOeb zFzAsnbRguzem+u*#q`t+oC){TQ ziczq%MD95tL{vEYd;7_p>09mJ!DxlB30@F9HXs!U9K?X~8gV1wu*-r-mmsGap)2$v zW*~HM0B(NuMw%C9g7!j3*3r9iw69BE{~8_t--euY2Fr>;>ui>Mi|yA^9+_ncQNO*H z7-LO&6$Jpf;MPb2>i+hkR9!awTMMt2lF(e)54-k5b%S3EtNy!E_HTZF{BL{b`|z%A z1z8HyBKnJ@EQ=j0AvSH3;R+uN64RpxN64q0ilx)aUPb|l^*b$$_Ec1GjuH+sPu3D3 zu}&LdF>>N+Y-d0I6e#GcKVkq;d67HPs?zkL&ff&l!=S8+pk_d%U;_xOD$}2{a zJV(lNt{KA`-SFa{-y{YZ0$mE>nHx0h!3)rvXwK(&-CPoq8QE>3C~*(_HBfF z1g+-6Ok+RAg*EGvGS0KIkGsdxHM+QezM=|*Xy zHb07jO<13jR$bBlb-Bscmj^)hBm8T<=8=Wp>owoROp8=Mb=pI=0;u^e>eiw3HBq*K zNyE<-+q$dPjk#-0{Yp#REtO^Hzbc;`4u{(wK__F5*pK8{Y00dRZ8wP5;MiP8>ciS? zE6b4dqLZWs{z*G-ln^7jugWJE-OS=V%t%Qkj=Dqj3gNmQqlARp)QT@#4G1UVJw(Ij zPwP!z;aKt!udl%wfejFVV#K_G@4MMk7SHo&$*J`mC4e>3=+gW-v&$e>R4_R=-5Hq5 z1^>=eCXrR|g!Bp$AV#8WvUXTN%N@}T&0v&d94zI$;&s}EqJ(WYRVw;CaLU1T>+}fK zG*^hv;>F!l0npmZQ5{v(t#R>e!%dJ@{ut*pE2>no47~l*;mCHOBN!Aq zdh>@u&y&|QGd``l@^V44Uwt$!I_*5XgBXA;vJ4!_H#p?M{ z_CpeLQk`$6IJMLcfLCJ!rf?rno;Y(_?ErxPvULJK0%m99lx7w0;CqB+x_Fi9vlqTO zRf>Jgwv|v$0-$Qk%1Q@$ro5!W1nO@DD1CgpB_sQMb&BphcTkaY`i2Vkw>$@3tH+Ie z_j1R3y_jb*b*aX|ne9g%uc)_+cbQX5f{;u(G=;*;t% zis}Om_LXQ$o&iz4GKjJ1KSRcd0;lAo(lSUgY+CjEcAqyDG=PZyiv;zp@w zWJ-o738WCk$2}r|IV9xFyAGsz_-^+L)|eciOUeAdO-O!wO&6TGQ#1zOHF;FM zeP;Sk^#$&uyC=908=_aJGJD6D>9 zD;j}*U1p3vyg6_1EMbRt>{dPA!DHI+-+KDf*j2YHIR&$>`QDue zbarVIt9im9(K}7}_&FCC*z1W^SHXR9-C6c4R#C+LwUIqGUtct+X+EYeu~Nr@gZk>D zf8%8EJKCNrbK{=emKkp^_JkfEuFoZ$T&^XXW*Z6FzFCfbsoWTeoI#SYbhVd+W zDC0;(H~5`G##o`sbahK@LSd@aiR8M+Ll?bxb_MJiypB(j_Vv9*RIlV`R+n-gu2moC zbBzY`7e#GdfBP2Xk-E-iN{JR7XS2f@41enI+vr%BH^*~O$WQM&VTz#~Jx@lTh&d$1 zym=GeeLEmP>fqwM&5{C;$<6)(`UU>oPxsi*RO6?l=7WIkiIV;oP#}=p9Aw|avlD%I zAMl314&GX03owYlmxw564$#$0+TOdsa>QM5BMV)6GMJ@4O-|e{6ou0Fi7gK*fk}{v zKT(pntFt;?;ZSl_{${wE7o3b_8*K+r(Zg7I@z)rdTa)OXGvR{y3-WVcmHYbSPCT8X zQj})k2*d1ay6l8dQDD`p45TRw?aITomW|(0>tS6Ori<&xsNhp42S8@_PG+$Qio!ln z>zefrhDLxB?5Vp#`eenC3ZXe;_0lB{1x1xY|y_%`O`pGeLyRoa55JPD9sK zWnay+8$ullKU?k{fr)r;wR5?_Oy}wDt94_@RWaYLGD9;k#F=rN=7K-`Lom_ zCoz;$;W)&jB|b~hQ!gBbhi+uV?Pz}*8;&6E-X~rv+gs~6Ir#kU&FiIg3PPyOx^!`HrOZkBeJf&h&UOy-2&`%96K%C4w&9~L{Y$1njQ#SU@H1`m3 zEo1R|t1pD8orA&}?MuYN`e4o6u#fp}@e0D9=HBJZh28?Vf`Xg%@DQG+CV+A4W&4bN zVq0l_T26w6u6PQKb-QAE z)^!`>5pj>4Qyd)BeYj*xZWZRYIfHSK?tY5Z${ zY0_7Z&xl}}2DESP&o3NjWTl?51vSx?%iT$QlTowAkEqpR(!9@%XWWgzP`RO#yu)2d zKSf;!jCzD$`%a^z7J(EU++!;M=9MZpDAoH^ISv)MZmNglUaGTbR@6|40C zhf|Ca!hou9gIKWCRK#}b3;|FT-jz`DSP>93;P)s}@mwBmXBu!HrJi)_rHf41dC6+w zd;>tC%h%YU0fCsXrX~WbOQz2F3qAel`U@rH5v5onkp;zpp zF{CJemeP3?wTCe`sl;7ZV)^QMt2W$Y@i&uZ>0wRtUG{?Ap>RsQ5p=X<4xv@kiTmP{ zcE#Il$86oON|kQM0$1kv?kK?4*?rMZslmyb1PK?&TH*Wy`}b8u8{@9GzR5~j=}-yw z`tCUbO)3ZUqKitm_`VsG5jw-yb>)8G))xDfxJslJ`(@8(O*8Ii!>TqHwRy^zb5W|BrBiRn@a`5rNf0lgrnYM?zW`%PY$g*J!F8qUpKOk zQEKCifz8TV&j+Ur!Kc0bgwEg!&x=yz)0qeNXp1BaDsTX0NoYQ@&*BRx0-#2Ukh_>` zdFj&}lggDLSqCY13EZRYv<5M#+cUO&1MSr#Gxzm(?WTfwlUb(n6psnVRfgzIYRPZA z0f)$tAm|#rog9Pci?YG_*mcJs1I15n{j#sodV;GRu9}eN`3QS&yO|U$p?F-wHSH~J zTx?^3sJ>+Pf*mJg$IGD7M&SYyjGCiD15Go>1;gA@UN;)ra8ZDQUL)K2!xQi_aELAWX8v{mqWohvsfWG`$D)?X5u?rRPU=L zm!jkZJ#!S39G~x6SzHtZLsOrChuFH0Yi{`i7F8T>E8a71mgHSC-<2cW7p}x_5W#6A zt>FdnInDv`?J+7Dai1vDi{Q^EGeYE60R*?+kxO5aa)mL9#uj^UZl`*Lc*l2t!vh8-5qS`!OL{u;K8-_ zofKW@WKers>d4h0Rh0k~fjwoKqy4JTQn%#A(_Aii^#IhUzw9o$0 z=X9+uuir1e(UY_B@2}M!$h)c9z(O)ZBC$S;lemj8xV#d$HOhtZkCc~uw8)1U$3q(x z$f%9`QFH6|`{lu`{D@IWlmy1l>(&bnj)c);@bQ~_ObPESnIc2)O?%xG^m0ylw0ZRP zMNy#MKLUlpT8_<>1wPGXZEQ+XO(q3%hu$;H9A7`Lu%-ftaaotwoC)LyFDG&}l@Ao|!2 zk|>b?xE?`Z^K`C+(x!e8ozES2Q5Fh1Y62qp0y@H-${p^ur`Z=6rJA$0I4UA|43sbQ zQlqJf!LvRY-2Lw81I4@Q5&8LR%>9dezB{jzq6XYb&&oG$F>)y>smgF}@*Z`Lq@0Q| zI2$0%$YAJ8L~``7$vJ2QitC(q60A6tmU)|F}C0WiuakxO7Yib}Zi?PG`Yw zYhH*SQNK4NL>l;didB@ovUaf;h4u@{H1QDp7{oU!us_Dj=0>I4?_(?60YQs3v-@9i zOx1iM<0aS5q1HrLTCD+>HX8{DW8oIx!FQh4wkL~q@%zTlt+SpXUI&nA`pHBkedN=} zHc8em?b6RG-U}-cKHX7B>UFH!T~$-;b-&C^wg%aKpFDqYQau4rJU=v3j-1i zU2_|n^#0CIgaH!DbJkE^8L>P8$$h5|%aN?7tcTP8Z4H+W>7}fl_$(+HJ zx@m0RY>N_g1^5px_96=wb(Ahaw_3Dl-o1z35PRC(%Ch#v|K9=!eRIn9$3f>epZ)hI ze}{1k>08;tHkfjc%+is1`fR={BTLdRr-FDG`>TAx_8NzEo)5JE2IO~nL@WeKESyu`fItIG?q?)%l5)jOZC&ywaArw`v4(?~@T-%KlBrG9bfwmNSR zE61g2m45QO7Py@cNiTlA6^4=~-rtLehW1OUZO-E|-5hCo^Y!m(vq>CAWFwt7i@$)F zy1TAC(XSXQKpBAn!pj~^b7SpVT(*IPRd-5)#$TE+?VV(4O;=m?Svjthy$tr~8o;t3 z=DE$D>BdjnYmt?4F@%lS+*e(`2b_opTlAanl@?=K1fgpOVf$E5sNTZKN)8HB*d| zUF+(4v^+Q4{ctHnN1O8+RhK_;d*Z{d&$skluT8xRPJPV-5Ygb5UDj|*rF!pN!DicK z>w7=y; z9}AfP27~R>lm72Jn275oHe--)T@R%Y#B4J?g3agwk{o!ht^B{Vbu>8j`GsgH{Icsh zc&S9M3dU`=?S|Ov`@w98C5EIwccG9KjuUQYFU3zY!?-PgRG;(eG%zI%{?>--u1z}| zlBW+5)2{W~;vV&8oQtsgOGNR$WEFT}oD)4f1ZgrqHgX7HMH>s2H=gL}))+BjcCogH z9qa-F&0>mL`_&;Lvpp({e;JDpNco;mdQK~f_D5qeyy_I3`X=q7qt-3>{_~k^u7WfsH)Q=j_y~-Ano>~7~=9Q#=@;1O+=z=I;Hp^ZE zx*)_#a^d?0v=ajF{WS4DzK#7-_kP#`hd69xJHKxin2*1W*$ayp`2tha9YOldQ3QCT zX{3{ooGkgm(oMdAEA+ZB{Z>ElY4cFeuPlLc8^4X+6w|}7Oh)4~6mpf$nA&aoYYwp4 z*^akN*s#nKCN!w`l|?MTr%s!&+4+u4w@O-fZD0^x<)hzN$=_?JKV_p&5O^{iJVNE> zhM1L4eq(iAn~X!y#ySxAG`3RF&24?&Ap7@4pz_Xwsq3YnK!a|dYa6>WhqEjei`i32 zon`8LDRaC{cjy7|DYuOp7F+RE>fyJCdbNXq_YO`R?QdYeir@cAQFeA@JGXmR)9epp z+;5)r>w0YSfB`1a)@Q+p`nBC*Gw}?XW@*2F_8?vOkFi;}^4n8SOa7Bhj{egWZZZ9~ zB-h!g%=gOmAmt3c)5A!6q#xc-tZGXX$=mj)b#tfuy=TxrHp|*^|1wwE4}Kq7!GE%} zKWMJ#j}7?4KUZmGK#;_*6A^a<@HXq79|fPX10W<-1UECd#k107Go#~QuA?vKUw!+J zCiw?VxcW~P`A5AF91xQJ+O;j|OvvSC_EN&M*e=){K%Kd-Oy^7e;TR3-f1en}50d7l zM-dkq@U3g`CD&avQD#t}dh`JHqc(p58P5T{Ywc1WD~NHWUqD*77<(RzIwp-gU6Hlp#lHVu>IJ6|F9SS(I|i43sk=j9Kc}}+&LG=X|}b)6CuQ80xp-&y~z6@i*x9f~nBY3}nVDNP%pZ9QvB0J#2Jr)M~Ca!S6dlU z-%RzppI!rj(>nX9nZ2@MXaS?|)F2W-Bbx;RYuN1z=r4;n_O}-NgIWGd=l=R&k{o~+ zE3q>d2DcUvCy~cHsDR*Zlc=G4=c7o{MWY8#i?h~WNiNAR1xiT3HnO!69aM9<~tKy=1;14T~ zCQC@TZYKTH?S6BmKlTCzKlB)pfBJ?WdI9Z~>5%lox|6w2C9QGW+&hX;+45!M*}n0j6Cc>Mto(j4rtugGSyEcT*akX};*`F6(Z9#HKO^j)5%!;c z8z2k)8DamnP5l{R|BSGIM%aJLW&9xi`x#;Xu`Bo)VgJ_=cIp*61) zMyvjrgx;?~=JWyBOyX^I6oSIG#50VH#7l#@y-xl!0vih`-zmt^k^Zkad;NKS{U71h de$I>k4CnW=zkc@D&pGgO4*dUh4oH0&_&?1aeFy*m literal 0 HcmV?d00001 diff --git a/docs/source/tutorials/qaoa_quantum_dropout.ipynb b/docs/source/tutorials/qaoa_quantum_dropout.ipynb new file mode 100644 index 00000000..008ca304 --- /dev/null +++ b/docs/source/tutorials/qaoa_quantum_dropout.ipynb @@ -0,0 +1,1040 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Quantum Dropout for QAOA" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Overview" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In the previous tutorial, we introduced solving the [Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) by QAOA and the dilemma of QAOA on the hard problem. In this tutorial, we will introduce a simple trick to alleviate this dilemma, namely quantum dropout, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more details.\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## NAE3SAT and Hard Problem" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's briefly review the NAE3SAT and the difference between the easy and hard problem.\n", + "\n", + "Let the set of clauses in the NAE3SAT be $\\mathcal{C}$. In each clause, there are three literals and each literal is represented by a spin. Spins up ($s=1$, $\\text{bit}=0$) and down ($s=-1$, $\\text{bit}=1$) represent false and true respectively. NAE3SAT requires the three spins in each clause are not all equal to each other, in other words, at least one is up, and at least one is down. The Hamiltonian of the NAE3SAT is as follows\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $H_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT.\n", + "\n", + "The difference between the easy and hard problem is the energy landscape, as shown in the following figure.\n", + "\n", + "\n", + "\n", + "The global minimum is located in a large and smooth neighborhood for a simpler problem and a narrow region for a harder problem. It is worth noting that when the system size is relatively small, most of the randomly generated problems are easy, and hard problems need to be constructed with special methods, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Quantum Dropout" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "The algorithm is shown in the following figure.\n", + "\n", + "\n", + "\n", + "We first implement the classical algorithm that can be done in polynomial time, such as simulated annealing method (SA). If the result is satisfactory, we stop the procedure since there is no point in a quantum solver. Otherwise, these failed classical results, typically low-lying excited states (local minima), offer insights as we prepare quantum dropout for QAOA: whether a clause should be kept or available for quantum dropout to underweight the distracting local minima and enhance the chances to locate the true ground state. Specifically, the clauses violated by low-lying excited states should be all kept, and the other clauses can be randomly discarded at the ratio $R$.\n", + "\n", + "Finally, we optimize the PQC with respect to the original cost function $H_C$ with a complete set of clauses to ensure the uniqueness of the global minimum. The current procedure does not incur obvious overhead to the conventional QAOA since the preliminary approaches and the quantum-dropout controls are both inexpensive on a classical computer." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "### The code" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 175, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import optax\n", + "import jax.numpy as jnp\n", + "import tensorflow as tf\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from functools import partial\n", + "from IPython.display import clear_output\n", + "import random\n", + "\n", + "K = tc.set_backend('jax')\n", + "\n", + "nlayers = 30 # the number of layers\n", + "ncircuits = 6 # six circuits with different initial parameters are going to be optimized at the same time\n", + "R = 0.5 # dropout ratio, 0 means no dropout, 1 means all dropout" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.070466200Z", + "start_time": "2023-06-30T07:04:52.893906200Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We use the same NAE3SAT as the previous tutorial." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 176, + "outputs": [], + "source": [ + "# a hard graph instance\n", + "hard_clauses = [[4, 1, 7], [5, 11, 8], [4, 1, 8], [4, 11, 8], [4, 1, 10], [5, 11, 8], [4, 1, 8], [1, 11, 8], [4, 1, 7], [0, 11, 8], [4, 1, 10], [4, 11, 8], [5, 0, 10], [0, 6, 7], [5, 0, 11], [0, 6, 7], [5, 0, 9], [3, 6, 7], [5, 0, 8], [5, 6, 7], [5, 0, 10], [3, 6, 7], [5, 0, 10], [1, 6, 7], [2, 4, 6], [1, 8, 11], [2, 4, 6], [2, 8, 11], [2, 4, 9], [5, 8, 11], [2, 4, 10], [2, 8, 11], [2, 4, 10], [4, 8, 11], [2, 4, 8], [4, 8, 11], [3, 0, 9], [5, 11, 7], [3, 0, 10], [2, 11, 7], [3, 0, 9], [0, 11, 7], [3, 0, 9], [5, 11, 7], [3, 0, 10], [3, 11, 7], [3, 0, 7], [4, 11, 7], [5, 0, 10], [4, 0, 10], [2, 5, 6], [2, 11, 10], [2, 6, 10], [2, 4, 9], [0, 9, 10], [3, 0, 7], [2, 5, 6], [1, 10, 9], [1, 4, 11], [5, 10, 11], [0, 4, 8], [0, 9, 8], [2, 11, 10], [2, 8, 6], [3, 6, 7], [0, 8, 10], [4, 0, 9], [3, 5, 8], [5, 11, 10], [2, 11, 10], [4, 11, 8], [1, 3, 11]]\n", + "cost_factor = 1 / len(hard_clauses) / 4" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.085860400Z", + "start_time": "2023-06-30T07:04:52.913910400Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 177, + "outputs": [], + "source": [ + "# convert to a NetworkX graph\n", + "def construct_graph(clauses):\n", + " graph = nx.Graph()\n", + " for i, j, k in clauses:\n", + " graph.add_edge(i, j, weight=0)\n", + " graph.add_edge(j, k, weight=0)\n", + " graph.add_edge(k, i, weight=0)\n", + " for i, j, k in clauses:\n", + " graph[i][j]['weight'] += 1\n", + " graph[j][k]['weight'] += 1\n", + " graph[k][i]['weight'] += 1\n", + " return graph" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.090006Z", + "start_time": "2023-06-30T07:04:52.919783900Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 178, + "outputs": [ + { + "data": { + "text/plain": "

", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot original hard graph\n", + "hard_graph = construct_graph(hard_clauses)\n", + "pos = nx.spring_layout(hard_graph)\n", + "nx.draw_networkx(hard_graph, with_labels=True, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.098283300Z", + "start_time": "2023-06-30T07:04:52.932252Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We first use the brutal force method (BF) to obtain the true solution." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 179, + "outputs": [], + "source": [ + "def b2s(bit):\n", + " return 1 - 2 * int(bit)\n", + "\n", + "def energy(cfg, graph, n_cls, normalize=True):\n", + " factor = 1 / n_cls / 4\n", + " E = 0.25\n", + " for a, b in graph.edges:\n", + " E += cfg[a] * cfg[b] * graph[a][b]['weight'] * factor\n", + " return E if normalize else E / factor\n", + "\n", + "def brutal_force(graph):\n", + " num_nodes, n_cls = graph.number_of_nodes(), len(hard_clauses)\n", + " min_cost, best_case = 1., []\n", + " for i in range(2 ** num_nodes):\n", + " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + "\n", + " cost = energy(list(map(b2s, case)), graph, n_cls)\n", + "\n", + " gap = min_cost - cost\n", + " if gap > 1e-6:\n", + " min_cost = cost\n", + " best_case = [case]\n", + " elif abs(gap) < 1e-6:\n", + " best_case.append(case)\n", + "\n", + " return best_case, min_cost" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.178133800Z", + "start_time": "2023-06-30T07:04:53.126416600Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 180, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost: 0.000\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print BF results\n", + "bf_best_cases, bf_best = brutal_force(hard_graph)\n", + "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.442102700Z", + "start_time": "2023-06-30T07:04:53.126416600Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Then we start to execute the algorithm loop shown in the figure above. The algorithm starts from the classical method - SA." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 181, + "outputs": [], + "source": [ + "def sim_annealing(graph, t_max: int, T: float):\n", + " num_nodes, num_cls = graph.number_of_nodes(), len(hard_clauses)\n", + " state = np.random.randint(0, 2, num_nodes)\n", + " next_state = state.copy()\n", + " E = energy(1 - 2 * state, graph, num_cls, normalize=False)\n", + " t = 0\n", + " while t < t_max:\n", + " temper = (1 - t / t_max) * T\n", + " flip_idx = np.random.randint(num_nodes)\n", + " next_state[flip_idx] = 1 - next_state[flip_idx]\n", + " next_E = energy(1 - 2 * next_state, graph, num_cls, normalize=False)\n", + " if next_E <= E or np.exp(-(next_E - E) / temper) > np.random.rand():\n", + " state[flip_idx] = 1 - state[flip_idx]\n", + " E = next_E\n", + " else:\n", + " next_state[flip_idx] = 1 - next_state[flip_idx]\n", + " t += 1\n", + " return tuple(state), E" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.444340600Z", + "start_time": "2023-06-30T07:04:53.442102700Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 182, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of low-lying excited states: 21\n" + ] + } + ], + "source": [ + "# obtain the low-lying excited states\n", + "ll_excited, n_exp = set(), 100\n", + "for _ in range(n_exp):\n", + " sa_case, sa_cost = sim_annealing(hard_graph, 200, 1)\n", + " if sa_cost > 1e-6:\n", + " ll_excited.add(sa_case)\n", + "print(f'number of low-lying excited states: {len(ll_excited)}')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:56.794388500Z", + "start_time": "2023-06-30T07:04:53.442661600Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 183, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of clauses should be kept: 12\n", + "number of clauses can be discarded: 60\n", + "number of clauses after dropout: 42\n" + ] + } + ], + "source": [ + "# obtain the clauses violated by low-lying excited states and the clauses can be discarded\n", + "def get_clauses(ll_exc_st, clauses):\n", + " kept, drop = [], []\n", + " for cls in clauses:\n", + " violated = False\n", + " for state in ll_exc_st:\n", + " if sum(state[i] for i in cls) in [0, 3]:\n", + " kept.append(cls)\n", + " violated = True\n", + " break\n", + " if not violated:\n", + " drop.append(cls)\n", + " return kept, drop\n", + "\n", + "kept_clauses, drop_clauses = get_clauses(ll_excited, hard_clauses)\n", + "num_selected = int((1 - R) * len(drop_clauses))\n", + "num_after_drop = len(kept_clauses) + num_selected\n", + "driving_factor = 1 / num_after_drop / 4\n", + "print(f'number of clauses should be kept: {len(kept_clauses)}')\n", + "print(f'number of clauses can be discarded: {len(drop_clauses)}')\n", + "print(f'number of clauses after dropout: {num_after_drop}')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:56.798234600Z", + "start_time": "2023-06-30T07:04:56.794388500Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "There are two ways of quantum dropout. One isotropic or uniform, i.e., $\\hat H_{C_1} = \\hat H_{C_2} = \\cdots = \\hat H_{C_p}$. The other is random or different, i.e., $\\hat H_{C_i}\\neq\\hat H_{C_j}$ if $i\\neq j$." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "### Isotropic Quantum Dropout" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 184, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get the graph after dropout\n", + "iso_clauses = kept_clauses + random.sample(drop_clauses, num_selected)\n", + "iso_graph = construct_graph(iso_clauses)\n", + "nx.draw_networkx(iso_graph, with_labels=True, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:56.975607Z", + "start_time": "2023-06-30T07:04:56.798234600Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The PQC is similar to the regular QAOA, but the cost Hamiltonian is the original Hamiltonian but the driving Hamiltonian is the one after dropout." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 185, + "outputs": [], + "source": [ + "def QAOAansatz_iso(params, g, each=1, return_circuit=False):\n", + " n = g.number_of_nodes() # the number of nodes\n", + "\n", + " # PQC loop\n", + " def pqc_loop(s_, params_):\n", + " c_ = tc.Circuit(n, inputs=s_)\n", + " for j in range(each):\n", + " # driving layer\n", + " for a, b in g.edges:\n", + " c_.RZZ(a, b, theta=g[a][b]['weight'] * params_[2 * j] * driving_factor)\n", + " # mixing layer\n", + " for i in range(n):\n", + " c_.RX(i, theta=params_[2 * j + 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(n)\n", + " for i in range(n):\n", + " c0.H(i)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, K.reshape(params, [nlayers // each, 2 * each]), s0)\n", + " c = tc.Circuit(n, inputs=s)\n", + "\n", + " # whether to return the circuit\n", + " if return_circuit is True:\n", + " return c\n", + "\n", + " # calculate the loss function\n", + " loss = 0.25\n", + " for a, b in hard_graph.edges:\n", + " loss += c.expectation_ps(z=[a, b]) * hard_graph[a][b]['weight'] * cost_factor\n", + "\n", + " return K.real(loss)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:56.978247300Z", + "start_time": "2023-06-30T07:04:56.976145900Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Here, several circuits with different initial parameters are optimized/trained at the same time." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 186, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "backend = type(K).__name__\n", + "# use vvag to get the losses and gradients with different random circuit instances\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz_iso, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "\n", + "params_iso = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", + "if backend == 'JaxBackend':\n", + " opt = K.optimizer(optax.adam(1e-2))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(2000):\n", + " loss, grads = QAOA_vvag(params_iso, iso_graph)\n", + " params_iso = opt.update(grads, params_iso) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", + " plt.show()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we can also use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 187, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #0\n", + "measurement prob: 0.018767010420560837\n", + "output: 111000100101\n", + "cost: 0.04574383422732353\n", + "max prob: 0.04061311483383179\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #1\n", + "measurement prob: 0.01276576891541481\n", + "output: 111001011000\n", + "cost: 0.04524344578385353\n", + "max prob: 0.04112391918897629\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #2\n", + "measurement prob: 0.0424429252743721\n", + "output: 000111011110\n", + "cost: 0.03893017768859863\n", + "max prob: 0.048920851200819016\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #3\n", + "measurement prob: 0.0024669470731168985\n", + "output: 011101011100\n", + "cost: 0.03952330723404884\n", + "max prob: 0.04860881343483925\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #4\n", + "measurement prob: 0.018215017393231392\n", + "output: 000111000101\n", + "cost: 0.045170776546001434\n", + "max prob: 0.04154610633850098\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #5\n", + "measurement prob: 0.03104996867477894\n", + "output: 111000011000\n", + "cost: 0.041469376534223557\n", + "max prob: 0.04604189097881317\n", + "bit strings: ['111111000000']\n", + "\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print QAOA results\n", + "for num_circuit in range(ncircuits):\n", + " print(f'Circuit #{num_circuit}')\n", + " c = QAOAansatz_iso(params=params_iso[num_circuit], g=iso_graph, return_circuit=True)\n", + " loss = QAOAansatz_iso(params=params_iso[num_circuit], g=iso_graph)\n", + "\n", + " # measurement output\n", + " m_out, m_prob = c.sample()\n", + " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", + " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", + "\n", + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:26:06.999371800Z", + "start_time": "2023-06-30T07:25:37.198477Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "On average, QAOA with isotropic quantum dropout improves the probability of correct solution (max prob) by nearly 0.01 compared to regular QAOA.\n", + "\n", + "It should be noted that isotropic quantum dropout will lead to more ground state degeneracy, so it does not necessarily lead to better results than conventional QAOA. However, it has a high upper limit, which means that it is possible to get much better results, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more analysis and details." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "### Random Quantum Dropout" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Because the dropout of each layer is different, we need to generate $\\text{nlayers}$ graphs after dropout. In order to perform just-in-time (JIT) compilation more conveniently, here we only save the weights in the order of the edges of the original $\\text{hard\\_graph}$, instead of saving each graph after dropout." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 188, + "outputs": [], + "source": [ + "def graph_weights(graph):\n", + " gw = []\n", + " for a, b in hard_graph.edges:\n", + " gw.append(graph[a].get(b, default={'weight': 0})['weight'])\n", + " return jnp.asarray(gw)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:26:07.002622300Z", + "start_time": "2023-06-30T07:26:06.999371800Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 189, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get the graph after dropout\n", + "rnd_graphs_w = []\n", + "for _ in range(nlayers):\n", + " rnd_clauses = kept_clauses + random.sample(drop_clauses, num_selected)\n", + " rnd_graph = construct_graph(rnd_clauses)\n", + " rnd_graphs_w.append(graph_weights(rnd_graph))\n", + "rnd_graphs_w = jnp.stack(rnd_graphs_w, axis=0)\n", + "nx.draw_networkx(rnd_graph, with_labels=True, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:26:07.185324Z", + "start_time": "2023-06-30T07:26:06.999940800Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The ansatz needs to accept $\\text{nlayers}$ weights of graphs as inputs." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 190, + "outputs": [], + "source": [ + "def QAOAansatz_rnd(params, g, each=1, return_circuit=False):\n", + " n = hard_graph.number_of_nodes() # the number of nodes\n", + " rep = nlayers // each\n", + " g = g.reshape(rep, each, g.shape[-1]) * driving_factor\n", + "\n", + " # PQC loop\n", + " def pqc_loop(s_, pkg):\n", + " params_, g_ = pkg\n", + " c_ = tc.Circuit(n, inputs=s_)\n", + " for j in range(each):\n", + " # driving layer\n", + " for i, (a, b) in enumerate(hard_graph.edges):\n", + " c_.RZZ(a, b, theta=g_[j][i] * params_[2 * j])\n", + " # mixing layer\n", + " for i in range(n):\n", + " c_.RX(i, theta=params_[2 * j + 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(n)\n", + " for i in range(n):\n", + " c0.H(i)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, [K.reshape(params, [rep, 2 * each]), g], s0)\n", + " c = tc.Circuit(n, inputs=s)\n", + "\n", + " # whether to return the circuit\n", + " if return_circuit is True:\n", + " return c\n", + "\n", + " # calculate the loss function\n", + " loss = 0.25\n", + " for a, b in hard_graph.edges:\n", + " loss += c.expectation_ps(z=[a, b]) * hard_graph[a][b]['weight'] * cost_factor\n", + "\n", + " return K.real(loss)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:26:07.283590400Z", + "start_time": "2023-06-30T07:26:07.174051300Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Then, we perform the optimization step, and also optimize several circuits in parallel. Since graph weights Jax arrays are non-hashable static arguments and not supported when using vmap, we use $\\text{partial}$ to wrap the ansatz and accept the graph weights input." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 191, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "backend = type(K).__name__\n", + "# use vvag to get the losses and gradients with different random circuit instances\n", + "QAOA_vvag = K.jit(K.vvag(partial(QAOAansatz_rnd, g=rnd_graphs_w), argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "\n", + "params_rnd = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", + "if backend == 'JaxBackend':\n", + " opt = K.optimizer(optax.adam(1e-2))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(2000):\n", + " loss, grads = QAOA_vvag(params_rnd)\n", + " params_rnd = opt.update(grads, params_rnd) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", + " plt.show()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 192, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #0\n", + "measurement prob: 0.02918497659265995\n", + "output: 111000011000\n", + "cost: 0.03293716907501221\n", + "max prob: 0.06192261725664139\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #1\n", + "measurement prob: 0.0033539484720677137\n", + "output: 111010100001\n", + "cost: 0.03257792443037033\n", + "max prob: 0.06247476115822792\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #2\n", + "measurement prob: 0.0022312484215945005\n", + "output: 101110000001\n", + "cost: 0.033498045057058334\n", + "max prob: 0.062363043427467346\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #3\n", + "measurement prob: 0.02523483708500862\n", + "output: 111000100101\n", + "cost: 0.037150800228118896\n", + "max prob: 0.052470263093709946\n", + "bit strings: ['000000111111', '111111000000']\n", + "\n", + "Circuit #4\n", + "measurement prob: 0.034201640635728836\n", + "output: 111000100001\n", + "cost: 0.034923672676086426\n", + "max prob: 0.05888247489929199\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #5\n", + "measurement prob: 0.03789209946990013\n", + "output: 000111011110\n", + "cost: 0.0331316813826561\n", + "max prob: 0.06241282820701599\n", + "bit strings: ['111111000000']\n", + "\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print QAOA results\n", + "for num_circuit in range(ncircuits):\n", + " print(f'Circuit #{num_circuit}')\n", + " c = QAOAansatz_rnd(params=params_rnd[num_circuit], g=rnd_graphs_w, return_circuit=True)\n", + " loss = QAOAansatz_rnd(params=params_rnd[num_circuit], g=rnd_graphs_w)\n", + "\n", + " # measurement output\n", + " m_out, m_prob = c.sample()\n", + " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", + " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", + "\n", + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:49:27.992557200Z", + "start_time": "2023-06-30T07:48:48.070158100Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "On average, QAOA with random quantum dropout improves the probability of correct solution (max prob) by more than 0.02 compared to regular QAOA.\n", + "\n", + "Compared with isotropic quantum dropout, the standard deviation of the probability of correct solution obtained by random quantum dropout is smaller, but the upper limit is lower. From the physical picture, QAOA after random quantum dropout works like a quantum interferometer. QAOA circuits with different dropouts over driving layers may work through a focusing effect on the true ground state: different clause sets lead to different energy landscapes and minima, whose configurations receive constructive interference and enhanced amplitudes. Being the only common minimum of all $\\hat{H}_{C_i}$ irrespective of the dropouts, the true ground state remains stand-out through all driving layers. Please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more analysis and details." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 193, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OS info: Linux-5.4.119-1-tlinux4-0010.2-x86_64-with-glibc2.28\n", + "Python version: 3.10.11\n", + "Numpy version: 1.23.5\n", + "Scipy version: 1.11.0\n", + "Pandas version: 2.0.2\n", + "TensorNetwork version: 0.4.6\n", + "Cotengra is not installed\n", + "TensorFlow version: 2.12.0\n", + "TensorFlow GPU: []\n", + "TensorFlow CUDA infos: {'cpu_compiler': '/dt9/usr/bin/gcc', 'cuda_compute_capabilities': ['sm_35', 'sm_50', 'sm_60', 'sm_70', 'sm_75', 'compute_80'], 'cuda_version': '11.8', 'cudnn_version': '8', 'is_cuda_build': True, 'is_rocm_build': False, 'is_tensorrt_build': True}\n", + "Jax version: 0.4.13\n", + "Jax installation doesn't support GPU\n", + "JaxLib version: 0.4.13\n", + "PyTorch version: 2.0.1\n", + "PyTorch GPU support: False\n", + "PyTorch GPUs: []\n", + "Cupy is not installed\n", + "Qiskit version: 0.24.1\n", + "Cirq version: 1.1.0\n", + "TensorCircuit version 0.10.0\n" + ] + } + ], + "source": [ + "tc.about()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:49:27.995399900Z", + "start_time": "2023-06-30T07:49:27.993157500Z" + } + } + } + ], + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 8c8f2895d1c13beacf376298dd87d6445d8cd373 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sun, 2 Jul 2023 15:26:44 +0800 Subject: [PATCH 512/725] update --- check_all.sh | 0 docs/source/tutorials/figs/landscape.jpg | Bin 0 -> 66616 bytes docs/source/tutorials/figs/qd_alg.jpg | Bin 0 -> 251040 bytes docs/source/tutorials/qaoa_nae3sat.ipynb | 1070 +++++++++++++++++ .../tutorials/qaoa_quantum_dropout.ipynb | 1040 ++++++++++++++++ 5 files changed, 2110 insertions(+) mode change 100755 => 100644 check_all.sh create mode 100644 docs/source/tutorials/figs/landscape.jpg create mode 100644 docs/source/tutorials/figs/qd_alg.jpg create mode 100644 docs/source/tutorials/qaoa_nae3sat.ipynb create mode 100644 docs/source/tutorials/qaoa_quantum_dropout.ipynb diff --git a/check_all.sh b/check_all.sh old mode 100755 new mode 100644 diff --git a/docs/source/tutorials/figs/landscape.jpg b/docs/source/tutorials/figs/landscape.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3ffd79028ebaf7bcfe39d2dbc41bc259789ba5a3 GIT binary patch literal 66616 zcmeFZ1yo$iwl2Jy#@*e51b1uPf(H%m1PksGTmlL15Ik6L2(H1M;Fci4g9Uegopb(s z_TJ|nxpKz6;~(!8qq@JYRjaCI=~uI6@%Z&|1;CV-mXiiRFd$$6`UgC&p=!%XN*bxC zDND;emjXZ_06>*}Ze{NPg9!k3_O8xqG7^;9I=YkyqW}zm1i%9v0AOP3;;8sSS{;Bo zIVnj>7igqk_&0Yk3qVr>fGHMP6-vtA!v8}E%hb`?6#zgg(AZpN<}RjC{053`JzO1s zg&#pN?n|3r7zXwic7_%ZiV1&V%Rgi0KgIbo7W;+G?Ci~;aekHA(ag^57w&=LckXWH zPz-(!#i8z2<{nTy4aGFJZgy5sdu3jqKk zs^#zS%im#Fb5CeF0YK8h@wKy+;7;gZee(ZPh;Q#6`uUuUn1=!d; zJUm#f%uQK;Rp?*bKaKF0n13JqE;Xr>1#k-jfe=7wARG`8hyp|lVghl3ARrNt6zDlf4Wt7y23dmaL2e))P%tP0 z6c0)R<$#JoRiGwNCuk5f0s0171?_-NKsPX87*rTs7&4frFl;ao7;zW{7{{&yd!o%XgQo^#p3c||5YQUPpI>GwEM#84S7QxoT_P|cTuEHL{ zKER>Dk-{;-3Bbw0X~S8n}OSeyMTv>$A_nb=YyAp*MYZ&_lA#z z&xEgp?|`3xUxz9IOouFttd4Ar9EkiL zxdOQtc@g;(1qFo)g&#!~#R??=jg5f)6k7`04Eqgs9(FhO zIu00z8b=bx6ek!bAEy^*6Bizr4p$D>8aD#B9CsA=2oD>N8&4C@6E7X_Gu{e582>50 z9KJ1n41P8KEdC7v8G$%~IYAgf1;Hf2B_Ro+7@;{~IAJB>4B-tCC6N@74N)9X1JM#O zEHNXoDzOJ~7I81}PZC@bK@wAvaFS}0c~TfsMp89WZ_+%{FQn&W z@yW%=t;rL~+sJn)a41A5tSAyG+9`G^@hHV9Z7JVV_D~)@A$=nI#O+DWlhG%)RCH7t zR6$ggR7=#z)DUV5>O|@;>LVHo8bul(no^p1S|nNs?JL?8+J4&0r*u!Xp1ytB@N}Dw zkWP-yi>{Pzksgg+l-`LxmwuW7o&myO!;r}^&IrTE!}y9ZopFo_hKZNSiYb$6f*FpP zpV^){mwAo_l|`Jzou!mzl@*`$IcpGW1M2}B4Vx}o99uuz13M49Eqgxu0tYsSJVy{m zGsg)hBc~~6I_ESO8kaPeKUX8yF*g&pId>NKR~{T5MV_}jT|D=^e7w%Q6}&rqG>_Ex;?_Do`zOD99pcBUmE1Ekq||E|f2{E=(nCBAg?< zB0?!*Eb>8QMf8cNiD<6qni#d1nb=3MEpY~MYw*wVM}R9rAd94rjoXlE|or#;gRu{>5zq!RgjI7os%PzGnFfrJCf&<_m%HaKvj65 zkfyNqobkEy^JYaDMR~;p#YH7rC3~d?Wk6X@IYD_zg-*pur9~B9RYf&j^@kdVnvYul z3!E25FG^lqs7t8Fs4r;HYq)82X<}&VYZhx>YCY46*ILnL)ArRK)*;rh(rMI1(ACua zsC%v_rI)0)sn4Sysy}N$XW(ftXh>{mYxvm+!^p&_#u(06%ech&&P3TH*W~=A+{=uY zN2ZddDW-d7VrGeEJLbaX@#b3=!WQus+m^zX36?vrL|-Mp`e`L;m1cEpEo+@^eQBd? zQ)u&Ot7ThhhiGSP*JO`vZ)4x%K3Lflr}McmWfuRJt8YCN$#?LEJ|W_%s?ddo}NtH2x9+tjp(u{1_fe107SW?IyfIm^@Uix>vvHzvMe$hi zUh(S*iV5|Jl!@VqXGum$gUQ^<*(t~=ZYeA8pTBQRrAduVy-RzQHj^%qUYS9f5teb8 zX_h&eC6-l@O_m*zee=QU!`B>{oci3SxygC(dG2{X@-_4O3m^r>ABjIke7rBTFI*{7 zE9xocD=sb}Er}_GDRnE|Dbp_-FMn3vSiw?}Q;A<0@d^0k_G!1uxN5dqp}MOEQd3b& zTbogbQx{$js()R7)bOfdrBSDGqDj7~t68wQu7$Owu=Po6`e(e)F>T0gZ`vN)z1q(^ z96Nq?T6V5?8FejmYj;ogsP>HZD)bKYN%wX4i}$w=2oJOl3Jf+4L53QJd57!2@O-Ho z;TfqLZ?@l# z=iTRT7XlXH7Q>e?my*Aee$QQISgu^*UHQEFZ1v09i?xMy)AhX#myNs4H$TvRByUk{ z6>oEHx9&*qjPL60Ztgkm-Tn;S$J)<0pg*WR6g&KKqv4y0_x_&YzWG7nVe!%K@$vBhKo>W2cxetm={1x; zJT3r|04gFP8X_7NIyx2s9zGrxE)mob5aSb&lamrtl8}+nk&#eR(fx8%%xqA{%qJ)) z_{;x)?pGopG!ztc6m%>M3~WLyEG%pS5<*;D0&)UENi$+D zF#qjDIshz0m~Pm3FhB)>us|?aFpoU|1yoQtC?|osUqb(KAQ&(#96SOd5;6)jLLDXm z0|J9#V8L*3uuzf&@`XMJV6ot^pKyr7(Qv(V4nji4 zCmC;viSLsJXN-b~HREi7MIS-ZHpxqEoN_6mLz z68iRCSa^IwVp4L-`_#1Dy!?WXg+;|B)it$s^$m?p&0XC+y?y-ygF};3(=)SkU%$<- zuB~ru{@B{y**!ivJv+a+yt=;mB^L+)|5>cRNcLB9VL|1BfrSObBK(pI1mp2ba4cB3 zCmitD;;INHPB>JYfrz*gaXD3;NYq?vM|dxtCy?=JxL0Y9e~I=d$^K)41^t&K`-@<| z$u$q4f}u@-1%m~M0_VE)xdF)k&;QHn08$x2d^XP-A7RIr!hDI?q{Tol1@|qs7@B zFyn*Lh97^$*eZNcN;B~SDtvv~Gipa>$*Ls%N)@D+d2?17<5P(DY)_Bn;A=bA!H5NZ|si|I`~_O@0|EFi=WRMvc`|rsC$3LmH~M!+Zme zV9$>LWEf|R!=K{~-*KfL2nk!!MCzng{3)A7Svi^$IblV&UwOC~GEJxn3q0(SL^KvC zy#Ar7FdPeJOl8L$P+{m}CkUJ(H3k>tHYta+pRjy=1Qz-q66FjGev|U|692DY{jDAr zRqk^5^99&J6p0dThNnge(M^m+&}V8hCEksj{u_YPxoxo(}snzmexZyA`gAjVTXhB z5%;$hlN8ln23a_4>SKh!cJpwD-?RSb4M`3$LXJ{>tK!=t8RT^-H@qc~R zhDrI${?*<1Tg7iW|AK{?f?;Y2|vvYoca19(PK z$7b`Bsc`> zri7>qO5corv-GKgOsn*`rI zsSmK)>L(yb=CaoH%d)5s#oXLX|9P;1I)udwF~M9-cZ3ZhaOd~vWxK{dY~Npg1mvmn z9?ZsW1E6E005A}tNmrSooaT;@e7(hYQ=i0=Dz-=%e@&!mkdOXZoT{3eB21xjAptJo z^F+Lc!mCX!K{Xx+o(;zcVtnH!;Tw2~uBjBgVt527bsmAe2jzP_JTJJ{k3gsLH4Jn* zF*@Ufr;A!%i7Z2Ea%GX;Sk3axH`<+Eo zWvHeHvFrTj_Bd|db{h<9+Hl#EG6QGS62iNZ)G_5^exPdY5g^)a!>QBRoLZrhel;_> zlds{MU$OCunuZjo^QSm<_(JhuMlF*W||!Fwp4$olEQZ zd^Wg9+{U*M(Iji5pRC*9<7D8>^8yL75AdjxSm&hzApA@K=ouG!f!@G8TS>C8 zBpxI1{ka1vMyf2tb+E%^E;xYD;(MV>(ZXigzDWk+V7GoPCqB`&*ondGb=XfEr-36* zSqyABp6zmNk!TIpESVbNT$u|fBJhOt@tj;4Kf#e;!?$9j{%_l!NR?P6>}sjL7Pr59 zmlK(49@pA9)Ypo3@TDIB^&5h?M_krWzY}`96z%+g6k1*U%%shHW(Mf8=Ws40uE;wg zZBZkjtkg&0)}LBqll@G=AeDE1_N*^d#?Yy$Q-hAEYaK$PRiLjc=}|KpMPU{}Wv{Ye z;I|hU97?nj{R(vYJb8Okwo^mBh6}RS6jyM$fEi~=JULbUp@$yx$RtFc*7i3~Lb)64z{ z(G8Sh|GAL4hj8mHKNd-DUGvZP%`v>A7evqAOAPQ6ku(S0a`KN65#rTV7=A2V9d0S= zMBz>14krNxc%uB7504`V9-SI#`-nQ&SfMN}_LF{@kk*hm$TCRZh%I6L={jgj)+zg= zPOEQfXR;^ld)5UKcOZ58X!IJ{S32~asLZNZmq7@!qSR5=ER#R_LNhCBwbFsJlD6zb z@ZkEU6secj)B|Hzyr=VisyO{PXFQ0}XG1?mGL)LSiYh>0e(>1xF3^qb=BW7*m{3$c z>KSv&|0+j~Z&6)uVL|&o0Xtq!C|>!+^FKrrBQiqq-_Wai1R7%Q>EoN5H%0Itfq@3o zN5FyNMwQl;xbE`8AZg_L(t~1a_5SG60%ko|aO8RgJ(v?pUPjr_vkUb|ir39fJ56C# z@&Yu{G&NykJ3>@?0=~cJFuJO`6Vj-QFo9(qDiz{Pf8U+t{&je>pAw>kC{21IW#Yp< z!}62c{I%a4O#=bW2$OH}t{bbK#k07cjtxq>A9VbKKY4t#iso%}6*oULw77eFd~G-R ztUr+F>T@l5)v@ce*9*9My=lPI8@Lz`E6^C~Gdl^!x)Z$k1RI@7IHra`oicvs=CNku zAgDamkQgmV|N5?IrW-RhKa~3OH$T%34OsJP8_5o;eOD%$&oXjqyb={zdLc4qk$9B; zfZ^hKN%rrnCxGe7V~ymh7|+&LE`#g!Fiinv7;vrqh5DsJ7M_IVlbQfdHy@U@{A0?- zs2p~E-7ltD*j-|UF2J*Jz}P)2vvWV_^>R@530(F=`v$a?R8^1GA0!QFAA!o_MC zc(t~#gcdfFEa21g4kS>H9ikssjdBfD^lU@u5(X+&{xrk>nq~jXzG;lq=8~MKuKshF zf^Egh1BkQ<36LYPKW7{M@6mSjL)0U10RxS zKVS(HJOtKfU!f5^0ytV_wR;8}sP3O+kdv7;xwWU`fl*vg251D(hOXpu(3Mbv;*XW{8VI# zI&S9Rj#6$pZ{_3rPJf=X7!6X1vn3xmA*1b)Y-9k7fqREyWJWz?7A#zHS*Q+a2Yd}d zPZFqWgH7fEntimaj11HuDdm+Y*ee&=`Z_llgM!Tt6_2JxaYosfc}OinA!Lo^C@dJt zQ>247RZ}dksIpv_f}Og?E9L(9w7;dZw=N)xgvHd0W!Q#_EQo z1tO0iK9>Msm^0oHo{{3}*_qJ|{Jj4Px6z#-a+WJ2lt1)aV4D^2qO7-#wTdQSOG&B1`N zSxiFX8Xqme0$}V2sR#-XdIZ*u?gEXW!d*QAXXq)r!miPH(~mC>06To`RnLI&m&%>PZO8 zglUvSNs)#INF87YzyZKEW5L1O!d)er=Gq_&WL)kznn-|Vof)Z5ZY==vhk01*gQoHw zl^5GR*iQ6_nC;yYQ*r0F4+XcVr{ub|GbC5DA!{5gw`6 zl^DOpYEAH2ORev~BBrOS$qb=ODA7Y6WsoZqh4xWsTqX8gvQrB_Y$H5B5=yOw>`)cp z6y!8Du7bdGOh_00wD#z}m_>BnH0@;xk;yx129FKEaV2C_nT(Is%Lu0{`3CRKsYt^> zU{gaKP6ZZfJ>v+F!M)P4nr(hbxNjVd$E;oUs;Za`qI5rM5~8<(bt<=Eg*_ z)UcSIl+n2X5U743Eu`gD{j8xePEU1BkDm@qYv?oILfBH~a7lFjJ;kdW--`&m3A>ch z=Fjo$aSYd8)M2P^BjJWj;}KqDFjSP>%2m(s-dD^M)mu8G6U#L~M)|;zD;5!CPlpwj zE)-swEJuA;w<7;(Ni+}dln@SZr&IiFVX{$NxJ&oUU5aX{r_^7kBkF%Xqm1uAK%fTg zl_-_>xHIKC37)2MjqdRZD4G^8zl=EGaL{bT%WuScr2+j{dXE6rQp|m;|IV|d$))*T zU)1DN){SI786s-Nj#AVh!~x+_(LYYdy3?R8AA#l+@lzqeqWa-?`5pn7u+9?8yrw>A z%e+7Mw-D}=QD*mud)vb7Eiy>=k&U<&*! zZjQ>npjVO*I27wio}?uMZO{*~v+hoL@HG7Jav-MKH8~V^Sf>D|x#@AZ1%*_#A^ytx zXKPF3eqvFCl$<_2adk?s2iHGCC*j}oie|l1S%=(L_SAB!Rf%rsZ(*^LjKw>NN~*5B zpNBF$QDAbDbH9E^8A-j*Z!koFfDo6J2^Ihb$ze6;cei$tqjodj8GiM!Aw@~!daEPkeEcmg0Z}pPU=>iXWxZu7N z(UnH_*u*7G_^je8>@*!NLhd7^jQXLq6;w&&Ny^!UxT$`|EQ8v;4H-1XpgrabwHIPx zX(eD5`o@xMp*kQjx>w`wD2p;kYPMpA`ri0x^L#dIK9PgyiCliv5X_elEHmZ~bON-? zW>nJk$n$pMM__{o;oegQ%Gt~-Du2IdsDq%2J5(O!pP&5}Tz<+mKvj9H`wRU8pOJ`S z>8Ot(BfcO*sbh@Q_3Z;UUrIbF2Ts}bp;{W!>*8pM;6d=gIR)F&xxwF2xR1ky|F_RQ z%1qXH2#&OcTdM}?Ev~H0&m-_{&ix|FhTf`BUF&5KXF+{3oPt?oaBYC&>t1{HVg}yiJr~_X zMzu&$X~y-R`xg<`qkjFCbAw7c}S9}8Grs?5vTv0D{9lNJ=JhwH*eE$a_(iM0Ia zls2EApFeNF$6YL4K;QL3^TnUi-o{l`9ix^AN#>1>^eIv2*s8x!JskWfp=IT9m_v&f z?7fy}>SAYm;X_`AVyQ#{9+IMtA|HO5RsR0O zr~g=S{~M(BpH{^m(?&koxj0>vbUqGE#*3BikIz+XIsS@`i+bKCBjNHgoF3dO!UNsH zS!3KB#XJJi!v;pb*A|r~{vx4IibVIiMDIyh-2CC7TVK(8|G`HfHy5gUF1aA~ZA(E6 zn&%)j$#`RkOW?d8_|-fbSaBuQ2&V^f|Dius4)Z_3j(GTt1I<`YXSVof-iXa!eZPf4 z(8G8|(dn&VZ<~#a-KMLT0p7})7T;WZ(<6}J-yz(7uJw@Xf06>#_j~t3AE}-n9{6u8 zAA#>RpsMfey8`I>1^Ka*r!cOs_igqy-yQG>X!!5aJpv5=7yYfOh8R*5h7Vg0ijM#w zI%9Mb_6Q6a-B%srY6VZo{97&<|Itjml>(tWeL?i*Ecg+SDz}rw+E3T7uRe4c9pUu< z`BlPiZr)|E)Y*A{=>D5uIDPpT4O9Gd`-aUY=rSh#2#i}+)Hk+c()MK0*63NP$IfGt zg|2+KUPvb!AfhDaiagfQnvl73x*L;Z(w|{sD)3=3_o%)kFWaXtqqvfA9Tc&76Yn8x zmTZL@wG&^K7ud1>q2xPaOCri=5iL&NXnz*cBl*olRzc9G^@KSxI1%^!Jem}qeM{e# z?Z_AdXf%`LUJPvhNNjkwzCmsm!#!aL{IXISmaP3ko9Z^uXXsPeE{&BX_t z0tAY;Af^6Ckvo1yNf!{O8hdxNt3HuO;QLsc%QAoAmjx@9=FcMgh!@2iYJ-%n~zxVI}TJ1;M>M~ZZYspaeE;7mOP^C?>*xjb&$D?b7YpC_5mneTHEH)xR$ z%;7q=0+wW6M3U1-Uax;i8N7alceID5Gg-`nm(8tl7O$qu+bpt~6sP}56SlY;a2D@? zh`fcR=*u+pU9n@do}zZq04sf zn|)7&=2q8r_4YZjMPWX(Gyl8Aj|1N#-d(iHOVnU5$o3B@6GHaF_t{uAhmb5C<@-sR zz!kXIP8lw}QhbLq4vJbEuIrR-m4Q)wqZy1k^JBU(3Le{vQZ8P+8EuqNJY-VOBY#Mu zs$nek5?LU_tRT=BAD9d*M5h+DN`bGeupa>>a$V-qi+AcFQ8VEc5*a1giL4qfquv?< zQ8HQI4{rDDFF3WKwkoZ4U^^-y6nD@a z6^S*>uuLcEyiCFiFdzB^F{jn`#h_};G@%?9lCi#+UH=jMZVHiD2K!lF24j%>#sh?| zSgnvsX-=`g`w|}mzDliFIkhj}YE)jRWTew@q`v%;>>MxjftcV()*(Z|iN+b|!4Ice zL6sqbfE@X6`-$k%Qo4yXMq?}}o6<+@HX`xOH99oJ^fCahaku^^Yc)GMlBW&rKP&~f zO_kK5?5+CboSkbkZ+e$CcH=6ga5XYkrL@|r-l~O^9}qb6a&l@xp1frg-(?Crs!yff zB~Gg4B(z&^0(EgAX;TkSi(L;@8uar+0CKsqEj}VC-MjC;O06RJc-yl@yUqd(yczZx zdI~b$%Le7A`^&2O`~5+-)KT+;#7JFyDO4l$j9=F?M>@AXw-vRIqHAw9gNE5|dfcN% z0oVXUO7J39R>l?>cY2wRIVoLB(?i!MwlFj}e@`_%;|VPhL#Kq?(1p8Nd`-=+tsGTP z*+HjTI01bQCo%_RNQY3--c-X2z2y4xHA>b> z5GMNzw6?><3dyqgeTaoE4DP17SG=``^p90LH3QeVw$S*_7t!Qd)bk>8Lss7zfr$dEI@*H(bvlY7+ z=K}If40jwKYYo-(^3C8-Xsq$gnWD;Q`t~~_Hxjb0OR~tO3l-9%7!Sm0>R06lxKgPp zG4-eqSvSXow%U-`GCw9JRn{ooT+o`Vt7UA-D=B4FN9GM(v!-y?c=J}M9jDyAsWrN} z6}{mk-m{53K9x`LdLfpRkJBV2jA9@0N+=rX60eRgWZw-=($DaR6lsg#hrvGCC_={I zzzzyEWu6SZizM5ML$amh;px3{WCx@`x2Nmm@+A{7LhWHJwu>5V79)7WR&&^|bjL1K z-94X1dY;_aQ@6{->Q}SG7YqK!1 zCG9%fHPWm0^9%noGoIPGKmMG4@j$Dr{UE#D`v^1}x9=?(-SboCRtqVYw#8T&(pV&G zVLiizk!%!HLgep*5b{IFPNgbCZP%A*zu35Ntqd}kkXDh0JL96R!2JZa@azpQ8MSP@ zTkKu>g4C0AzR#a&F|*Pf&6dOExbu22)YDq9Z4ST`spz@H zb#x4=F)7x%pk3)){$YR06}ef zPkaau*P-sr`i6TZGrb{oYC@ka>df1Yyzje>8OUv(~+ro?Ul`b_kCkLFzpqs`HBIbaEz<%8Z-9p!Fmmnv{#N5jWtAzn5 zi8TxPN5}sE1JB4Ajw>G|Rs84P_}}pA?mi&<58(UXKzR_9Ye?xA_O)N5i9Z5{SdYN= zHygUH`OKxH(tHB!zK<3(G?BrA>XtyXXW8zwdfu0rbAcm52Gc!8j`#>C`$LVKGc>%l z<%OG+y9a&$nVq^ zRKLjcd8T1IzbDqSw+*$E#ny{JaEz~k1C3JMe^>RC+K7SPDi7Y!?79XxUUFX6F`r0<-Vp?2P^_PFJ$$?s^ z;JvNzl$bKgw9MSp)b0WzKNw?s7jLC4=6+O-oXM|FoN$EtCaEL9Hy1r=aXGtAXNj(f`iAd7e?EQsG*4=Dsre5y(Eh9aVV1`yF6kpB7U6WGE-6Hh6pQ z#rF^_>{d7OeS7}RO^-l4Gl@x5?32_^V~>EIchMMQQ(2id0>yPCO!H3uG^2}cPH#$G zeXfFTsh?J4&O702U=D^{E5xR*Q+rA{@^>zb zeJB&f*luXn*xWdIC%>f7x*s=8$Jzmyf|_jI$lInrrf2fm;do3ne>$3sbo|=bM9a{J z%#>=-I3l;O@s4Ln^W;`lky<%nNRUsNUQHgRsb2{~8HAw*ua!0%(Vff`%Xyk~31b#Bas&i;A^gnkMj&`WAj!!~PoBr`8yiLsn!m?WBk z`^DQ`Xy@56rEn_v*|?-#b^>vZ53{>6NxJZ@O8KT*e8axzI}yHB%UI`ubnok}7UC}a zXwW;Xc*}n@^&npT2+S=&=at62@(RmtU6F#-1!NVpH7!o zTAV1hOP}1S_+c5@zCoJ{73v!_h1l8b$QAD>@*NekH=4T$h`T>up8;t({;S?g@&}VA zI;+?{s~K;6!wGDt7!R%k9DCx2{2YuCq~o}HHy3eZV>>^ks|Jpd=wwGaIxAV@>SyYG zOuV=)vs3#lz|qmDsGdyLK$EaM&+oqQn6(!tq+4pmzQTWmzYCu2Mk9qDbk4$5e` zo3w1T@!tK~I0GZ4m(*<8H6OZSzcD`{1QYFPl%GK>ADu|ES99&_-5?mMOyy-cg>zR! zzU-tv9kju4@GsAmaU))k@OWL7|4~jK97trYfm~Q>94|v^Hl?t%X?3bQJG;~{->GKQ z=2krYvDjP5T=2z3#6Fw*;^MH){M_F3bWOb;JyjqQ6X~mftVR`Jlw%C8`8F_HxdHaxA zJfkZ`Tbp}kfWy_H$e@|Aks^#d(VCy&lHocv^7%r*n(=e#V%uS@46$q9pziaVEmy0U z*)q-I#nnW8gUmKXp34tVl>w#}?aJ~sl8w>%h3J_X)Pfmhb-}xEhDWE|43yW}ExqwB zUo&2@BNhpjBgq(@pO7-Gue5e&$Jc1X3qn}DT2(wKeYUfE(O#>0JG$F=_%>|Ix9wO} z^=TtW#UFiXtl}(!;r3C(9lLyBoQZ zpGmL<9n$q)o!qw<>w#t|GcBstmsP`Ch@2c*)wz&yR8C2N!Fi#gq2_CYzQ^0~&NX3q z{?Kb=0oQUzR17B?@DJSn@JijE3kr3-H z#=kbJ+f3TutRiHb2r8F%NYcz-AE}5}lrx-PP~b9b+#VlW`-VzwnPQK+%;k4PIE^mg zr~}zK*($f=`B8Cj%#z6TM$p_Qej*_-CQ+JnU1$USZC29L2tfOr= z%83gH8vqDl>;&MZ)H=xtN^9Ab+U*)3F_SV4IY%VvvSLM=6&%;OU+c*a=gnSB)wBI! zXwK4ACYG{sT<+vDXm`k(*0M8m#SJ{xUvI_ z_NG`l7j{s1R8{V(pA^vsTHX(#SOm$8-O))#9PCm)LeyT|(@||Etp2J(MMyDUA$NL1 z%2`<7bcl}X8w$<>Y4#uA_zfCt78F_xZZaDFN*Mjon!H`z&m&2F!>+g7Eyr5}3vFh$ zmV<=1ZTB|L^9l_w>B4FB9n~yix2E7})|W*?=&kr$1m#L!-B2C#CX=Ax(Ko4uNYNDF zPr2B+&B=`aX!ZQaa5kL$GOpiQa)4dlEDr{RK!>O-IhD38T4M=iD7P`UKcKTmq4_MoP*H9dN?af2 zm-{|hKeuF6&B){1MjS;CVNBGYDRHJ*r~8tYcsB9XD&F6sQERO)f!nBMGD^he-RdF8{1=1NslV>1C?WZv*t0heryjFCh*$Z~&HHaRF+Kv({u^k}qY~TpGi!A}rU?fhaXY-$m$=>e zk-9PvG?l9&SRWB6?EvYmbFVr1_3-=9}#xHo_5KdAl&&IpY0Qd4Yh7WG16 z5r8fdspZJAkYs|rIODuuHm5%=kh6TSgh~WCd#*JYeSK`;KRAa zRELA`#FmCCkouMU>fGzzc74X$(z2QqEY*uQD-t-)4j!@}k;e_-;~ z&;7cZ#=9zV-HE7A+J>{cUx2mPli9AKCjs9PPfa5K1M^qk7R0W2M2K(^*y}&34u<(J z#>c?@gCbb*XsZbDt)A05dhsAu z1FfvP>>EbL)Gi)8DD(dGHLX!TYcjIQ(xTGr%ukV1`ATE?>=t@HC3q*@9tlf; zC9od9n#X_EfzjXQk9?-fL>H3(Fw$mw814UFYH3F8#4)NJHio77%DYr=|7+E7#+F%t zDdFA^+r9m?{+0>0GRfMD$=sZ74(YG_{mXrmNZT%B))ys=v_Zk&>aH@?8?$jpyyYF! zPFjt2+rgc?Ha3Gl-?w77+Daoy(>u)(!8-MNlU)Rx6x;LRPgL2O*N4Qe6JF1uEs%LR zO*Tbot(K|5%yK5$CR9r{@lylrBmrPyNz0gW6J|158-kIYJYfM+sW&~|Nx3^le&!<> zpZ(*KKKjVC)eSUDH6lQSo~;}&X%X(-@o!aHLyfj^zuI_eo6SE0rz1zz9^0Ifj$9`R zfpd79H*JC5xxB0|pST39|A=Z{M-|M#2@Z~)$&`nr)n*n{CN|s-RmQJ49bF_6fBZgG zU`dhTep?1ri~k_Th_OGLs{UEmuBC*t>hd0py#^_xo;|O`X*(7WgICh!&j@T6_f~jAzMKldDVfaPajXl@r zl0F~LelCK%=0WO2MmSjPXdD!EXZeujwaz`l)u}sM8SG%nfkxKZl_g!>vd?9qf`7+=HG4Jlm&UFx5v$fF z#0mR4z;5B8h9rzSNN(^@jM(*m=+cPiU#Ub&|7Z{GoK5_Xj$@%mg1_DD!5gyq4%AJ{ zC6B+O>A04Np;;mI$s>_lr}2B1w!2-N37OW6Z)zhU&_fXM;&Sx0t1+~(@T@4!TY5G5 zzQUAg5c#Vh1>vS% zjH7M{gqrdk0d^%?>UDouD+X^uv$w%y2M)6w{Ifo;SdO@5N=L4&R3W@ilLdzo`)r>n zv{Eb+od#8VXp!SJ=T=gZTST9_krN!3=?o` zss?XI{Lzo%8k#Y|11or6McJ$BLcAly+1`CV|CtGE`j?CA0oc zH>5vOPaU(^n;3DWOik0kh`6YP@mvL=Xc-DlJk^)z#O?FK+f1{B5W6GsiD8`u8Yx?X{m!kQ^aD*+&U8X zgyh{zDlk9c_JT`XaP%v1RCyFd7jauFSm)cou6pbS;yNYoR2U6oesCXX%t+F(H^+y0 z!qrVWnXOK~H6=ZfreYG-$i+bo3{Ner1m}(m+DsGe#07W@JmnajlUD%fe^W@MMj7K`1YL=#&B$Pgls`6}A}lUqvvR)PP*@Bfr~@~_4s z;Psa#{auMjMI(feBSW{8Vo*5^X$Mic;#J(KZ}Wl#P>*~bKCd;l6J2rbdmq{+TxO(F zgAZ@2V-CGypqB%@51n2*&Rwp2R=dY27_6yJ>s~8xeL#-)el2(L^ARYJ?9Af2eLBoE zcfSn7k93JA1=+i?Gk!9>Lg8 zbr1i8ypfDJK(G?~s$1!(Oz&W0IJ3n>v78G=b`dk~scrJLtlcC~5Nx*Tsc#w?nPs?pV6&rZ6GpCOYrYiG)B%{khnhGtX>}W7O#5iC z4$B?|yYFN>cjW`_DZt%gG(eZJPDBaDZ+--j?l`A?p66O&d^29hpyKd=^MHT0?tHcp z%fFI=Wtg%m8mj9Ns;&6sR{hRoLkjT?@5(^NzI{f#GAUL()29#U{@qz{lRg}8>)*QO ziMFL+upOhL1BQgbwW!fe6+!>b(%^@W!n%zw!KI2_n!|fck_`z?k(Yv7SDqsIPN^B| ziiS!93mBoL5kV6}t7Pn&%lP}nZ1uWLzf7Ta^6t(ydVw=V+$)?O_%(KL@w%sB zk3Rw7hG_+YoFVncUCtdXj>RtNGkzi>1j-=9Gs?KT(yy+*nk*Kxg74p52P}Tr$TR&R z*|Fivzc)VnRrg_1sM_!3PIb#N)o6OxTUWJ?IL5rzd|~3CZEYVq0O`VizhwVUVZ4Mj z3Y@Q=hFCm5TRiN)2H?jHMaGthf)WCdh^To2*OkNSv!FynrVh!)(IW`_a6rY`&ab~2 zjM2#Ml##S9LR(}_KwRFF!pBKO8(00sE8#8x9Do2gLO!4^<9pt!9_!)8wZ7+vA^aAE z)#AuDHrfr22i7T3)3%<39FUntDR8lCXuv^-9srJ)+h)@17Qt&fHt!a<$lKI!jh62V z&M*s5(vAc`bd_SV7f{PxPvZVA#6HqNu9CN@9ZLc58e+F4vZMUMoJ#NjWEs(i;ej7X}m=4X-FNfN?j63iH1GM6uq)rI~D^8;f^70G~)vQSjvl&*MhA*sWe|+&L@ho;7NE=-mnvcy-+7J0pLx^e8x4u(W)g)TrM<9XrNuW$9j$wD zd3*`i>EH_pEYhqhwvP==Eq;S1Pf{h_@w~D5zdS z|6P}A7$7$$CcsA>{kjA1tLI#Io=zRtv%Il4*yu=>Do7m1(^;jRThW|~uMJ)&Jz?f~ zwqCzCRdq=yB*nZ3N3Wrk)MU*%xkG!M_np2%uS54}x*RU=5h!brBGdYz6fQ<6O5c?w zjP7hxTq%vCL6u)`*|+v-s!KDI=uXAG-EE>$9XbQ32K-GG%Rjwl{~x)E|JQLO-8|4D z6?uBXuvs||Ix)=xIKPMy(cyx4UW-OQFo|3J6=uM#<@}8?P7kVE@}yh!9ec;SxO^BilehQ= z4|^~pWFApat4-UPqZZRy00X#V4x`drvS1lq&=qtaKm@^Z2S--*FA9OWVU!4_>0#Qk z3m0}Yj~Dc$sl$1?inb9>X|m*m5(a;i{chj$`$-gU!;pC{`m?8j|BOsxr1>XlzXx=7 zy=_Q`Fqc6}%=vnuZiMW+Q#w?V94aA`#xb~>0H?k2@KeUsK8=?KdtQ(0#aA|k4^_*Mow23;1HVYdT}ZeN@-uY`0Yp%w8A2FD0g>)jTIp^90qKwi zDM3000g)jTkWT6DZV-?hN*W32@VE9k_nf`mXYYH@IrseTAATko*P8jR_xrxj`#jIf zZZv2AFKn&;_oU- zv|6x%{2L5xYz}|d)PQ|=tc%8UcYffhqe5R9+l~hMi7t9H2YXD4IMB9B5b<$0bE;!I zN!wJJ0~uZ2bf5_&_Xzlk7_m=acy4hrw6Me!KYNCkpTPlMpBVPyRM)-AxgOYV!$Q^L zLQ9L8ngaa6))|4aLDsGhNCG*)tg`#YU2*Gj9WK$j_pIxX{QQHju*RQZe|43e)HGLJ zwFmE`tO-%!cyx_>jH=;F_G|o2>js(HQ&-V7vu`RoDT8}%U9j@2B4PNQ=zModi{z)8 z3-i=G$QAfe?Ch~VwaMw+%V!r+j6;X+T!LlQ;kMJ!y$JMs8(B1OH~k^a?Vk7R)}1Nj z$$M&;?=_R-ao`gOGq;*Xd@z$%$b`kr{r@cLnt067cnfW$!bnCzm}?@OdR zzhFJ4BWh#6yLs#APrVeY+~*&1$3NQNe*4_u zg!8l_zK-zh^tL1l(pyU%oDN=QhkQUZ#6)TA{`Wk0R$J4X?G!6-zoVZb6ajo$l#>C@ zQYvi5tzikBeOjusCrl`Iw9m_4E2>!;1z8eFV&L0p|}tJ zZ$gmn#rn!7QGDawLfgVn`4_H0Z!FBxt;H7DdHOjRgfYV7Yf*OSx+fCzjD(;-vOfU^ zndp7IPejum#aK-BD+co0Sn!woU*KAC$&*aka4`3Pfw>2!K=p%Qor%c;Or*{0)Ne-n z^i&=+DZ9%`d%cmTU zq+W%R-zoR{CDcDR3_*IupX;4B__*-V9%9x;vUyB^kzv7x=A5vFPs?ljp!@0^5;GR{ z2B@=lNI7hN9Z;b9PA6mM(t}1HxoDDL6h~pOl|?PXFmlgxaA)-MyYI@99@1_9S9RL| zsvXFY$HLjvspc0CuO_=6544hfkv_ zu7yjoDiE1oAYi50Q?pvDxVltUYq)=E%5yLnLLnN<<+{d~fWvscA)?y7lMchX-te*7 zhEdu3&JJ_Na>r>WETENDhOY~54$~~&m~ylnM@%)MJ?d~rMXDEL4`4&dzt*Y9Ox-bc zX6lil4Zk6cal_-LfeRD$zz5`uuM=ORO1m87$zR1&XVtBb%U`5$>6LQ4_%s zzM@b31{EGe4uz(~F*x}ANlbBxo0YT7AWAUoJGFKp(PEL5<2ZjHJ@-KE3I#Ix2aNuL zBPVio+eW~{iPhyf*>Te#pfVbOs_I>&-gv=XBM%A`OY4R@@(4fWaByVPiSgXvHNBWI zimX$DO8-6MGM#tJlOHWyEPc0vvEP+l5?;GwQ~MADYUYY(+hL{it2+}@WKO~4T1dnG zBA>V>y(iE|^sJ&tgPuMRV_(>^FkrD?ux*fIQpWT~zGRXK-B*bd37{!_%F*;I_w&ML-&8i|Q74j+0s@I+F1_%Kh{V@B`GV}|e&JzsGQXG|?L z0sv)6ADwdN>U?QgStXH#j}7WEGe55=$2Fr637(T@)-U zD|<39gK&GK{CV;qko+nD?hCq*w7k4kwi}mLSxK2({OnD*P`Kc6OZY|J^bA6FK@?}o zO>RhcI$~gwqeqHbit2np>ZSVjjx3|?ufN|PDQ@-#Z*8P&kKIX@y%$}wjNr*`qP@XJ z8Q;Oz??Dh*E}r$gREm;7bZ5*f19f>2Fl{R(hKe~Xx>pFZd7?)8#Bj}95f8OZ@ixcq zful&6wrE4|@<39Pj_6U`Nn&TWUHM?`>amGGfs$_3612c0&iF)BUO*v<$hKDhfIcdT z-_|#1O~MzuQ~6~4^NXkJ=K@x>pDzaK`8$NnSZzcdQ>*dEbsLk$z;b5tK;owb^s|rz z?O%TFpoqlFuwqoJIg?4RYG7U06_LTi1~kXgQj4R%$E+sq1HW&EB?5|z{QbAIn|T7KPWz!`qDW<`CxgdbqJ zU~;gEDLxAmyUQ>7;F}I-$|d`tPD|Md)m1?uH^B}$A>YfSIQ`TObfV)<%g>;a@gB%k z81!sBKPCMEP^975yyUQOCCn9=d4%uyjp7X%#y-8Pt%rTqeu0%?2sKq*oU#0O%uoL7 zaM>otgcx;ch1KZ-W1p5c!#=C^^OqN(Q4C8zGR2iyiap#R zs&fc^c-wZNA;hdQhCyn8icA1Th)*sH#W4O@L@0`Xp}HVV>cT=5r&Ut%W(Oi;lL@O9GZR<75- z%X8O-F!9*0H4mYp?R#YS=!v=iekJ}d+abi=UUIwHd#rBi)QYxx=v-h^cSMUAl3aPtMBj%p4=)8 zMq$X=4TAR;e}bnm_lw-NXf&=RjVUDbsrPG&c3uN0Ukl4JIuyz0M-i=o98(uUiS$*& z6w%``7=D^pQ{1W_@+iNA=rWV1ra&`i?HSo%j`0G|Hjd|~?VhuXl&pj`idu_=620(k zC_Z%W_CgQ`hi5p_6!*wu*W*wTvXP}cs=-U|1?}D7ECZBK5ReJuvCSxKm4vC%-+cJ_ zWmb9Hq=JQNTe}sF%gd+*AI8&U1|oHDsY9+_?VSvae70_S%x2@8@;5ld2B5GBhyBb@ zX2fnovTKp{$Mifs1=A{}bt2Ag8zN;wZGdE-b+IX+y4%`_T6}SCS4A zTyfeDzY9m9IdnMqiqrY>tQGn^-ff$cu~FDx^bBf_Nv}?sqP52wi-bl3L-h0oXJtGiv8(YLeKhEV7lYjfCl+}0u5bT^k0I8hChf!C9`uYy3 zx4x-9E+4f8zaxS6{BTmtV9A(Za$0lrNGrvwn|Tork0*{N(99|)RmPv+FG#ohMwc_A zYti+avp7x^(0&D4#Nfp(=qio1ihV=VyN?iMUn1exQcI>~c+ zpdn1g?zB8!gzyaW0bYim2_Xl^`<{T*`mScGCV^09!p)YoJ+_LP+8||rgm>XrqkL@I zx1iK$BAl2$CZ z!5?4=`~hY((=<~rKpl1TM2OGkh0oe_DDeHSrj#F_+(;xRizb&5)Q%~Z;(JCLuqKY- zk_H_%u-h%gIo#%1)a}ig@h-pG8tJ6x3%XtXQ5wJLE<}?SUv_qX+ozSL;v`7{p)YZ^ zs1~`9{)n(n0b6Nh%A%*|2jBydH}arKuz-H}?EO%&^0UoyMRm9=QCN`bP}EnjTI7eu z^gE^EvwkxxuBvQ^?T;V1TAb{zo=tj+Cu`0xRD$l;1XFJ$UeB%|J6^_1UukiGW< zD-Wg$*}g0~TEWH-z-l)>CrjQ&xUHfx!OD(HRdJP$6DYCf_!jM`Jq<+yGGuA^<0ThQ z7IbMybn{6=UuyKoykZG<8^FPM>e~$FkB2}+=z(IGj^%R?Asf6(n!4HunDA_0S8vHY z=ChcDZ+C?Sm7pJ{blOeuTy_h`Lb)E1GvcN(g(GB}s5UH_{ZG2NDrz1-AS#v8S$;GP zf1x2AD$&!Efd#eLAnNeHRZKA?hUi4CK1{m)NmC}lHL&`3vPnKJgCJ-5?No++*%)M<%+Ozw{akk z)D2m^y@;iPlG}pN8$lT(X7I}(UxxnjbG3Caa8G~jPaD*Fx|IwFjjQg55 z)0})#B8G!hwV5z*Wg6Rrj&Orb_`9uk@=`yjYU**US10$i|Rc_jO5*0kh z1A6l1Zb@4Y+<&?NK?xotx}a`G+o$bAg-GbCBSaOeKHJh)RD^f4LFMSb?ZB&cZbsc(Hqi(E%TTw*-MSF=$qJBJ4T+hW{8+{d>~?XDY$xJRg!g;rarO z1$?9aby;x4fq9DCfjUKG#_)SVT53bph$h4;1|IApYr=wmUA>MbGeTD-lvlqiF{ZOO z{DIg*XUt;k&W9)C3?4qMvn-R7U_e<%jF4QFBLw9-Yt53;`^8C=3hoXev5?sdcTNkPbw$RZ9+Nq(XgTE zjgH}2nI02~^I+2lK{k!7LqurvJdVgH`47JQgV#=OJ>D&)mn1{jr@z?YSVsA)5lWzu zg+H)HQ`A{o`;B35_Z~qIi;yyQ(9!*AS8IE@uD~E14I01ZE;wF5==cX;q1a2&h3h|n zy_x3;gr2rg8eeTS0wa_Q{qkYWuj%XW$ZJ2VmrW>)hx}m_yW^3whxaFuWZQGOc zNuSN6SifHOQyFFic#(dGZ2kbQ*MXuE9O_t_x93@vZ7Rzvk95*92bR4))=V-M8A0<(Z;2g?>kvCF_0X*O(**~Oach;QP{?Gls8!yhBS;{# zO~YJ6M*}*=Pd+!kK1-N%W(bKSd2!cqTGReCdg(nsrS$oX2X)k<0ume;P^~2E|Cm|~ zV%o$AMYv+3Q)lfS1TR}8>XYT&!?j#$0ByMDabRG^@QG>saD6TwwOF49uy9& zP}-Rvx~@IP^|`V5yH#xw!<}g|LskV7JN8#TY&(rSGCO=-16Csn8=Gccj~5ph$(iNu zf2es#3ZJ1<%=$7_SmJpUDE6iqywyz4Qf0lp_eu(pBx>LSk zwro}q+0rYyQEYm3mGxTOj8Eawq(CIu4tLbY3wA3?iI@#nmyw2JW*bh1+^$)+h=bB1 zbe8kC`02%@I=hdjJZ3CK?JBEkX+0fNliBLY%}ik=?_Lj{j2$w0x4D%$26tpl^XHzjH>q+@ z;)mH-(35qz4=$|Dx=NJoQKe7me_XZ|hY7H)ZMe7M{Qw?D%g|B~H@h9tdl#L!V9Puw zTv;)ldGF8Mwi3+vk>1(^}|L1@X=uw=l11lC&52O6EKKf8$(NoYWxabfKNARE>mi1n)mF2 z=G%sKBtDTn(k$s4cohOXa@eQtk0)cyGH?jsQrRr=FTzA-aC$8+TA*L=e7@gDxXsrg zbp+-T#=7!$j1fB+w6^*%oZ?!AAAkT4IUi+Y3-X`?Y7N~Kx!pMC{QmuO6*$BFi|Mcc zvbe>y9ui)rEPf@${^N6E?z}WN&vOCoqMaUjPp1H`+*)NZfJHf=OA^3K(IvNSGT$&D zsSnVhm`i})p5qE#B(HoG166@TdMbzkh(m{hI|kYoHD0k=gzY=e!TVw8u0jd8vUnWE zX8R$KV5m8bfn~yPy*~>KPmuav;T1)9=O?JSH- zX+@s-s@ckcGresDhe4VUGg77}kcKO1ALgruM^i6GrSA@A0a2&d-4d=EJFg@OZ}g1n-x>kPW!FK~N#tWvvQ06(|sOsd@G_&As%)$y`# zy5R?)hyMmLHLNsMHb|KC>d{Nb?5~et$ft=nQbfPdjQ?Utc`x=4&0PUh!%wP0>7N`R z9yS?Jj9t(_6VB+hyR#0DBR7kF)!K^?e8}sL~AV23;~}$^Q+d0`Ev%#lTTM-H3^qsLuu_}F7@@{Lt)ZwE3f;5 zQ>DbpwHtx-Xr(>-WTt4B5q8hqAC5V%&8<_kQO;ppj*Kl zc@|>e1-MJl9z}PpkW4<>1ks!}cX?;=T9D2BaZ%MiIBGy0))f#N&PjKx^PC=x7)yp=#9%9p9PKH4{j8<8cAKLcNngl*^z7$ zIs{jJ@ruA^6=uLyBUq>mtBe=@);Kr2&Uv9gvHi@sKKFi|LM63z;yWqva&4k}H~ha` zN66@zzz*}M*+#hS2-gjthTJ!PuI1kTG48VjpELF&F@y{`9M2Kp?*hz!`C5HvX z7mArrOk9I0)XCZT6V>uwOI(9L3sN&Ras`g_&&lf4&5bLzSm24o#Afb=GPfndYfc}1 zg29R%y4O2t$cADUdby^g(F`Kpda(}x|ocj6Ad1hL8Twn{Tdlb1; z;RXzj`z*g4Y20j41gTTyUXq}Ck@0oo4#N)s)ZANMQHEH+y(R+b>sO(D0$WE@A^v&o}0w<4R1NhgtYi|0D}sOd;pc?-#Bk> zjqNm4A1js=ilg7sn|!T_Db>U12Mbe zf{_yb?9md-hpVm%adR^Y@g;SoFeZ9V*e&05ILc|HPE)nPMq$G$e!w&)3A6GB&Vr-o z-6k5jl@7HP|Ij%@gzy|?i>LLYJXr%Sjnt+1upLdRjP=1h{dP+vISu)eFTYtcJs*HH ze|Hq-MmWwD${zSgT^V6dWQ3REp$Xj`l_wOM7^wadyd-*$oSxNT>;@ZWCq|^F2PT<- zSMk@)2i?${i?h~pX{oi6R#*I%S1Zqs!LE?L^s9g9a{Wm+{9k#Wn`T=h;p|C(a#cB) z^qG~$BpB%dJuQrJyNY|sxe9F9WEjZa-Sjr6=e#3LEB$%8{VbEca03;)gJR++$w`Os zWoKI4H6g5u*psBT8~r55?ySCDeJ?equ;a*On`h*lp}rojqbEr=S!*IRRgrV!d{4&4 z_pZLe!wHMN`cFGFVNY&$A9F!kPf{0Ca`K-reUUq=ScRzDmqup^h6jAb^9(d%?-W98 zLl?gmWfJRtU|qybCwLW&se%PpM#wfBFNAa&%NClno|zvFq(3)%7<0ePavDqT_S5>; z(49gBnWhd!;+>k*)_#(!uBprn_M7B4dvZdE{fRYLGPU=R(S42{2mOH6T1|UHz4`U+ zk~{orF;zB3;!Hi#*|Y)SQ4-SJ9(8%B?Zf`S?W-_>C9_kRo@9j7CSCv&{`MExPSbR! z-bC(Cs}LIM^-K61qd8olxr&IdY5c7_s^)*ElozA+`=u^3aNmn#b&p819hiDQ0S=1=XjPz^My)%IvtzWF9k? zhKjl$$X(;dpblz4>=ssnDLqMojhE*0c+s~e=pKkDzxY$vdmRc6;Rl8S8#Sg=+%w~@ z=mbRJS^khtDN0{KEk}HQ42thj{sPSe?jK9w#H844wc;4kcNF!IAEERCqg7ClkMVn| z$zL8ruCJ8NHM8K$Xw$!dJGY|YbEdc#-K_H4Hg(G&Gj-7*hhi#VcP$loX1d$8UFY2r zh?PsfCIBVV&#Uq(H>N~Ie(q| z0neNjk5I?L=>6F8D%uA|*xj8j7iax{h9S8d`XAoPvMh!rm!{tH1!5ZmH;1sM6of@_ z4}0q1r#YG9tew0!p4JEPsL0P25I;y6+|xXL8$YE{VBDal6Dk*A+v;R(_7-?=ZyIXx z&=IFw@1UDYdSTtR(4=Op@a4$U=sI>5V@iu@OW!MPb2A73hnz@TK{286S>hqLg}+zZ ze?V^fcV5#oZ}Wkr;_7CQO!9K(*}!vd-d*Zr9z(c24kyIn@4zn#_fof85F|~WbkEPH z4UcG_hnb?`e}|WHz7R5Z1opNI@o?X0}i{TAY`HJy-5Xc)E{x_FHWH*#<2Em<zgr}bUN4Ey*CTxWD6b1{i@H&Ta-7gd)`~;38AA{5EBDaoC%5hU1S367!pG*&M}pFGSR(Pepov3E_O!HJ^iWZ@!zn3& zi6r%!!~EJWUQw033$P;4HFiE`EFr%F4Ba%6qd{@cFpJUekzMzfVR3iFS;Y+Db_r!3 zmW3m}&@bjHs59Q{o>PgnIjwX7<0!{}w%7F6VxNF$FRmWUr+)x9k`;z`6I5iGo&{ia zU*}Rtx9hF0I${!^;ozuqSX!@pw#*p2EJ?CdEMq#e8qu~OjUIUF$l<;kk{@vrKnmT+>Ooj+d=2r`F4gjw`He+d3N_ek&km zytL^1H5+>I#?sM(qoA^ysbKQip?#-nj-YOE zpER+;SAZiM!^oLRn)>}u^GyC%oQ1!$_^J8#(#1(Cqb-$l+FRZv1Tj&wp&{C$uQ5XG zMHYk(^fZIY1JX8JD$}Cr66LpX`;;z9?_TeaBZMkuZyIdwp^H=B9xkNAeH@eX?*9A4 zunrttVwr9uxyX7af3c#JyXYHkf7o?)G`!{st_`a?}cap)c`x@N#Rb-Wsc!$#< zH}UO39O)VXHm%ozZ7TTKD^37;r09`NY9!rB}KAGV>&T zgAd`K_bSk0bL(UIdatmkAeA?fvVq^;e>BSdX&au~xQ=MHRQECK91r3;bTX zFN>d!6P;$oh@Fx`(HSH9q@V_?80gvp8i_ogT(2ir_4d+bqoO%KM-C}`hQ&q#cN#)> zJ72%wt$(GVlsxUIe-vo$!f!_V@*zALAm>ZFHuW;qE>pMD#)d5N?gVan8ciR<9lo!~ z_^#xSH_4ykqK0|!p?Lb_6OrwL;(VVM$y;ny*PEM{qr}__1P;E1=;R=@^3@`;F{1o& zW*mubhWnE;775n8$j=))dNI9OdT8#V8F==UHJPV~=rr?+Y~$)OlCEC0$wPUx>~l=h zJpX|J-Zm`;ImWWdSL&qTPMrg9Mg?!39cDFD*U2CZ(#wNG-h{CvG*K>1(Uu$hUR?}; z_=1xLpkmAknAa+KMz;(JWGNDm=Ff8_7^qjyfsTt~%95_BcmI`q^PhXKfluK{ zk@l|0hke7MsV!FcJ{ zIhA^`lz1~$yY64FsA4;>>+d&sC3ZaTPU$y?P{wKP+>e*Mt%q=D!S{fL&VBGD$Gc}6 z2D2nq2VIsy){HLz1EAuHAO4U`BS!F{Zd7CM5_B*xS{U_W^O*w0zmyJcqgP$)J<1SVg|z{GrT1ZIZY#d4;lNWb%JJ**h2y5ll}g1;xKbz0F!1P8csw7PmW*A@{V$f;1>sL9 zI}y`jjNm*Nc(#)8=KGUG<58Vv$7;HJGQ-LH8q!m%(3Sz=1gn(Ss12l zU3@~{bC^d(7(OOF(JmMTTbX_!;r6F3<==a($-k6Jn)Qms3-$hMOsK>wU(WCZdfGUH zlO3_H0Ws)gQ>%Fq?f>rytFGhu1%Mk2lW-NVe zp9n$Ij$h`VdDyimVw`T(^iQSJ&fFin==7+-tGDNgmhi_J?C&6o#xGhJ^!HgHF5}S4 zrOc^zn2oYjcd`5=8ZVoS>}y53v+;56mI=G)vj%~nt83-)2}^9%6Q z3h-$^{BtJ={Il=NJqt>;%bo7FaUw(9BgM;lPt$k99mA1;9t_xk+f^3I+o$OhWdW}H z$BB`1GUl}{KX{GN{D=yvG6(MaT>U?(&ScGhmP zNqu94dr@b9fY-Pw0qDGa+aU=TjT~#v_;{6=@}M2 zBdqFvgiu>XZ|%s>Dl*v~ucCb5FYqc-^7Hb|!qEV-zd-j-$vQX(dKp?;i}32?8n+Bc8yEGpo2c`hDvYsenP>N0x-Vf($nHI8 z$I=Z;tgAI-Lsj--Pqk6SJYel1_cfWolwa1&u=oKGlnGxS(YpUoE;LP+o~s~^_FF4q z?icc&>`rUkwKa6c);Y4`-MTxJcPqeoXWjSdSd}HX@tz7LDv4E0v9tLHwc{nb{xOEMdxg*Fr1>W8RIj4EcxaEi?)a}V6+N{ zgzn`YhwkZHDF~=<9ks#WuUKW^IV(8y;c>JR_yVGM4Tj6!($^+N%CXLJGEd~c3v)J; z&fAU{_1aogKAJJ1RO}JJTfjZIbkhCY1d1MItim`HunCLM(aEG&3l%hJ9*#D8>+`ug zjfU-4&bWQ4C&*i}k{Vag>n+bJTJQuTrw;P(7~8*7!~WObU_Q}QeJxe?ZXdNk7x8u< z!nc<0fbK*M48r}uUS(<`rKWH-<^nNLhDzQkC^~hk-V+G=^VFzKg$0_A=5Q!Ud^C z5kMQm9yC~AbEDuvA{@mTZ~A7y8b&yoSF4O$cP}h< zd63-KHRzg%Uy;ke1NKp@>@)1DCohQyC$cVtNBSfDk|(YU?$ChcHCrMyvNo7LoBrK_ zMV3w_=QkJc!e=V{X1ZHxhs$b&(^Jl6_7G+>UbX~y+;}z$%Z|k zD829l2tMNtPVI?Q#mg)%8Njgq!h|(K{sy57akUlN3k5cQFS7er#Bx77ng31)d!QKM z!JGQrCi}wyUeG=4$H`GW@eaf4L4eS+bLs~9=g#-Thi4?F4es3>Lcutqdq8ChhHFtq zoqT$P=i{1E+FL9vw;Y}+ftD;G2KF#Ck4pl%Q;-SyVYEn9wcLM$O`;#q@vb!%WQ+}p z5so_O*D9p>?y2}4TP?3D;TIKX!zlXlVJmFT| zCZ8=}Z2TstlZm(!zPFJJ8T4_`GEVQ8Gte;4iP1RXJJb21_BHIZK$Iv_wOP}6RI`$0 zMZH(b0ZFwXk%OLnzw-2`NU!KxW%9PEtO=i~^D{mWKooBV0mQ(6)atMh)qj!x)Cdk$ z#B<$~q*PDW%}86kH2!vWh4DsN(uIbPNHZ1O8#h66Y~cLmIk>JOC!VHR*`I`VFmF0L z%etcYAXl2E{J2`qhC0B|Z_o5!y$?=D`UHypx55;+dR;CL`^;ae-Zrx7nn~ehCxgN8 zz6(BaHelSt6Co{*KYChgi*^TmQWB4V&Dd{h(&O{71p`sv%CCB zW^uap_w(>>up_d?ySpfh`CD<1{`p~A%!5}98~)Nk?UaI?@PHM1_){zoe=G$)RKTF^ znJfu|xeIPC4jc(U;Rp|i!Gi)zM)mrX<=EHJaa}+ljF#3RIt_QFLops!Z~6nk@I>+l z9!+Lx7rBJnHn!g2DjyX?RhAN*OOxIZJ)kN?IZ;5LM7RGNoA}Bt|Ci_-*y_jM{ z*(N;^yJxj228~ONEUAtz?VEY2W%*Y`{}&;KnETa%bt?rWe@8t`V*) zw$$|Byv2(+F}X9)D9GLoKU%eW(q?ph1K9fk_)ir~&-a^-3W`-kZj$p$K4o%DyPWxE zy+l69-&AB&1V6E|B901k)^*dgl%!gu?dDUjj!-j2C;;CKDu3Ej|1${SUy44j(>-Qs z0g?I_Y%T-y77}uZM~M$c(+H{n_oi=Smr#Red$saX<)0eK@M6gndwAKLS*vZUR9>TB zrh|PC(Oo+&9-Ufkgv+c%D{zl;2}{ygkrs1~Z%0bnVY_^PC)wld*%+y^uMT;7%tO|+d2KOp->zTI6qA~C; zocnz0sGK^~%*rh?8T#JsygTnrS02v64Re!~^=O{~Y2SmG`bqV4GoOM?uakFh@UY`% z;J;#>U!AKfyqehJ<<#AoU6H3VCmR@NMmmKr))obkvh3=MiA^D-P{+Og1Pl9kFS%D2 zXzm+me&#;5^nQI~RDBmW-{sW;{33JbDtkNoL+E$KaF9pu^V8HK6!Ev8*$ut|HGd>9 z`DdOp9c8HDLV&ITU}enYizN#xZ>XM#)HN>7N7Mz{Pz)#QZS&%ZD3>JAu_g-oVFuHh ztgNyCP~xR;B)p-ABrya#w`XCrB+W{l$8W8lruw_V0DOmcnG1$^Gj64))+nRKd!V<} zBMh|3E*3{Iz?l(=7ZZ#3z9T%f1dhdoq6`>x=FCg{J*)~*| zsWRYuNuH&$)MoW94!%=|z%^{!vnh(W+Rrh#7Pwf{PySR}^-2_ja(Ej$ZRPQoF z=dv9S=^(E3^yj-xP0;4&Y=Gd~Wq)yg=9X2V#d3=e^w|frB{BqiX`6Fj*RtdQQjUA z17wP$;4J52gNZA*| zyE19aZWyNfUv(IYUjWfE!z8b0T(F_GW1ok}T8@PGA^R)XMMGd90${Q77wxEbae|)qxf_aV0)VYJK)K0AKkcB+}iEn}a zZWnqH=`ncO=(Db)nL81CA(+T2^fa%V5=%pOTtkIihF9jV5^Rt5zsqcXK@|T(pyV$f zMI5zw3EP~KTzTiOy}$r4Wz^h+Tg9W$dO!pGr2^3AiH2#S-s|2N=u7hgTP?w?5+S2i zGWf7wj9>Jww32`cSqD(Wu(uO&8Cam-lvhrn$RorUp9DW`QXaKLsM1FzREiIKk&a`g zWC_RK!0e+f!qckLHcE>GCI=L}p~At?vOlR-AS)umrRUTI^gxnT}Nejh#_s@}Z95t!=`}(vKL(JevgzPV~=jQe*!x;8#&J`21R9F0Y=$G~IkodgpCuav{2^)hy$dw{2qW&Ku2x`vEiGC~J=h(0 zDVrWAwi#n-=iOnbDO+X@3pmkF9XB@(jN*Tt=O^;t%MX9MJ7gAE(#w^mEXTYFkL!Yy z2+`6y`M2TL>e00ID_%+l(|rFDDLN+!tX^*ItqwnP#rWeQgNYZZJAC=5Viz;&Tm_PSy|e^Aa=-LQGiFEA@7E+&b&sR|4O> zi)(Y)!z+sr@+p<(HFN4R-tR z|G)bFY};+)h9G(O1V?$w^zfKCBlRG03{&dQ+(Zy*$>Htqlzi3&emC1Pu6H^S%9Oegc1KY-4-v#euO%&||?qJH%cpzt-Vx1!vE_boMV z!n3(Oj>nwzD0Yb^nnYea6kAUU0rY*5_b+j&_QPybUiG*r7?<9jFM)As!U<5NPfcok zcu)X%t4lh9TzO}|d<&i|`WM%ZT)_dIoxaH)h$LD1@RV8TAMby#!8T^Yvga)4B`flj zOXLHJ2~l>9sV#LC^{H(d{^w6>g5NtDIp%UAdU)>u%gId+b9Kgb7uGgh=bif^twELt zPc2n9af@~khPmcdTKe8KQepRkP zOTCWwZ53sMkjc|=kgV|2p69Dsdm#)ONEG2r&CGOx9xYWYooO@{v3u|o02bTyHM?zV zEmwdw!`YM1womFdM}nl8hRv(g`;jxg+H7s+;Y;PEm7{(@OKLuUu~&i zD1R-@NfC1;^#c3*f@%mNBO|9Vgge125qzGU%aRwb1aq{AHV)(y5~+J68pg43U`q|JAy zmhK#TUp#D*zu0X#E3dbJf`?=N4GPrEV*dWr*h*h z9A}Ngf;ih|?5`DermDymK6X4dJ{R-`-7r8hcfGu3f#PXSjt`1;{@h{gg1u(m z#>uX7N3IBYI9KZs?(*eqBGpTxGN~nn!84C{|J{>H_BdlL(w^?*`8oULB6=tlUt#S6 za;NfB8$r+bd2rKmUbbpV9hPYF!#}T!8{TSqDDT%?D8SBAKXrbt7+Fb}C-&)BjnQZm z2t2B%PW=#q*7gZ|(LkNI|DNDHIo$tbfR74Gc0kz05a&hNSozxQu4Em@ld^21wx^^; z5}B>&gYa+K z0x9{*1uPZfDWZJw5HWkj{%*!tuy+aQ?h?G3Zubc7SUSG3jWB*_l>PL)u8?i83l<5X z=WBoZ{LH%}&w;AE%uLqQnkg~^#Jqv!*d|yC^O_Iz#PR{|`tTGZtNj7bBIrSY9uqBM z0Ko8pK~Pj_{6`bEQ~wD%$*;@%nOmy508c8{hL{&-6db)e5&{Gu>MGd(%kNGTG`!Qy z!L=V(MT8#OcBZ(^YuYHP#PH)lEZ)$l^SN}$blYCoV?A%c85J!nmnpTseYv-au|;nI zqgkXE`LfC#V2}C6ur} z_GShUGCkT507sav=$tV(fs@sC!k!EAtZH54a9o*ui&|!g((ePjs9)M%D*B%UJih7} zv)yX4r>lz5bZdQs=faNiUTN+ky55sdtv0ZEqZ-$*DTQy8gExFFb#gc8-yPAtk zi|Vuz6@iGnPsoNTw{VI`+))D8%ahudJp6W83h`&{dHhYRy+bMb!oz1bqcFle!!eFK}LVa|se=PP{{$f_Yx5 zpL_+*qB5xsy*E`)k=p;H^9KNN1uYPw;;g>B#C@J>K3Zr;#>Y8>Nlqpa^8l~T=|B+8 zQJQSyy1P&4_r@)Ko&BLZ?eecDYb%X;1k+a;Pp~(fHv2t6yqgPr_0GW1#}4@ybKt8| zlo{Zw-D?i(?arwJR=-{o{|rr4^UsvOLr_t0FCb%lwe?ajDP&yI7huCi=OAnfzk{+D z?{4bgkRCjEe2hOL)1LVD6DMJxEI&N98-B>0wdixBe=+RT&WzI4h|ZQJJCrRK=K>s@ z2#R!d8u2e~gUv4eAHcT+o*|p(4c_^Vl*V{Y2R8@Un}h;FfgO>XCwyAd5e6%e_-B_* zOwH*E;&w^s9QdyYYKInri)8-9dg9M6C+2|$_{Im%xB1aX30_e~Oe9)5S%;4d2en*_8+v42YH#l+u$7J31+P zMib;;nV(X$GYn!<`i#N9U-AE!kN<;6%HIy#t+68lroCZrkPYayJalXiYY$`*M_mv1 zH5uBQ*>AWpjunviWsV)9Vg!o@GZgl&NdsBjws6-i56#jGmEnPcv;if;@vTZ+h!R^O zLGrAal!@Pf*clC48bNM$z7Mt))L?|=8yR8{8(&79Vd(9$^#g!JMM}_xirM%d%kxz) zZ?q@reSI7zZi((fgbSRf?63(*?K!%LXQL0$@6vCLAaBORNrTxUHJUflp{6I?%?!=b_Sn}i=K%`F*t_9 z%#P#9((~&z97N_I;T_XMpGebvU;OVdI`P0sQU}i&{+g0|>{gc{O2r{!m4AHz$~a9s zHsIi2mmE_;L!e2lteQ#6FA`Siaz_6lUw5ATIS>DJ$3hnpG@wY{{vh)Qp@Z?jIJ%d0cx3V-)k8Um%?_0s8XAHMOF`jg zY1(QPaXx$FAPv%|8>tmZs=Ki1GhMEEHA{R(Jt*nmA=(yf)?(PXLUX$2Tjo8;+>75D z@kPYH7Mqp6MjWnCn8o+ZsK?&kUYg1(m-wl&0qd2%B08~On^9)34!&?^ong8Tp|T{g zIooeTsAi;>-d;#Um4M`@7^3^<`{Z(67dIMN73hV?nO&m@VilOnFu9 zefO35`)cjQo5_^i7*ix-46ccha9xUkDg+Qh=LA&<#L~a05FBMu_=?2e&4Yx52?Dq1 zN?+|vBfga}3zqbAOPGVNh(mFcyX;G2GmWzx^POHhW`2q5jRJ`E@dsfYh{Gc z`+l?F2)56;cZ+11neWH!9>gM%8Q<>lOdog#f0O&&AQBThye(2U_se85_n*%0FGV0L~})7OjvV-ut0V27Q8 z%fURS+2jAU_tkN2Zt1$AP^3kRl$0QCXmKd++KsnRXmPjV?i!?c2oS7Lw9rz#xVw9C ziWGNuPw&?`XP>k8%$_-Ses|{F-#vH!Am0}f$d{F@wchu6pZ9sv(HwE`ddb+xNQ$w1 zc{tD_pLIH*&$5G{5nCrXht>nx=xM!$)eOI0lsU_(kP*2_PO4ppgM_Gd%`HrZge*~ zssN~{lCBNKOkqN<$h5!>N_CTUbnR1~Y9pS)C7^*JbN=ri^6It8VnBLZv3P(``VJk& zBLr{UuHyay0^dWwZ#AdAM+<7jL-mO@-&|QOHZ`Sg`cMi6zcxL6ajL3#HSh}({Y+Rz z@vL4E2-xe-ymrHOyukB=<=gf3inIGh@W{sXKGE8B(eRtO`qfII*FQjcwBGp-1G~Ny zRBob1SHAg#XQV95-PW;uZ1Rp=zh^n>Sxt0uIyB1dA`)_tOr$fOGQY$2;>CyCv8e@5 z@3Aj0eQw%9fCjzB$4F-t3GP^0Hf**J!E$X*R33rOI7%yzB4V-=mB+qDT+Clm)` zP+`-YV5Ue~x#vu_j(XkyXhE}zMywAS^4W$%ZiWt#9>zH+m2L~bZ_t+Iy>krC*Hn@? zSuEY^hcf7pW#iK#*$>63R4FgU(wsBa7aZYlh_1>ZOV{OWk5QJ(gE&Z@&_qhP5+pVh zgQyvU>aEHwRJ-=;GKZGP?Bq-qKzL0ix{<=}ZUz^rj~(A-v9@<4WPxK*Glx%*8%!D} zL*S=H0uyz_?jIt#MPc{(jbBxZX(M|Fuyh@yAxkuBl+T6b*pgT`oV7AHp1OAsb3_&w zkmATo<7|OFgd2`Z_V*&Joui7M|H8T8fP+RE+Cdo8E##G*3W)v`BI~GX_3*sJJZ)z- znTOeW$i&c`*F|gsgZKwoP6jEI+UI6-vdX+_yh?ykC_<@U38y^Iop9GzRJ0-Fbh08v+Q#2D7^0zI4?@(ZiAo zP&X4HFJ&(1c4Fu;=$?JdIu5{C2V`ylW!lFdKUhmH#{kN-g`I#h?J+qBgqHCiJNO?I z#Q*3q?SwWK%WYNv0iM>uvoG#Mh`6YrUE{;f^lMsYX8`A{B&zdM% ze;~0QucU=*gU%{_@Y4W^Ll74}f9Gfq4dAd&sV$mPKW>;1*-M*6U<-@eEWxSDH&s&a zq{O`6`fx1B_a5BOXYk=TxSsoFt>l8m#{i((85{w(FMnN6{%;)rkGoX={Q9-C+h&Qc zET5&}1p&>bvbuKJy{a<=Sm$?*via7)g@s|D3ssaHN>haJ(K+dcNp;*`(oT@zbXGc;};*{ z3pu0pW$O1?r9;i>MPBotez7D%UK$ve?Y-b?JWf&622hP*5&EBLR}svU>b>pbw(PqP z$b>oUzv4!5D1uC5bUAY@I5sOewELva`1#1uK_JjE2<>_+?>su+eMDM6IONMAtf6%U zg6MHd_S2p6TQ=IsL-ZJmhuH7c*hO#^3I(k_=x;%GR`bJA}PI+|PfK3npmmb5jtAfdkT zGEfkt8$~J}=BZ3bAU{$#dp2^eIX-XE2y_+B>6DQ?j)bXI0pZ{8jn(XZ9-sRph&GJG z8QH!oGmeTFy{?x?K0w^xKzN=0g&OXTdIRl#d1FYlD>bXig7Mv|C7~QJm@0YS!xanJ zKq~(|D6&$@8&fT9ATY=9eTqmNw?kx+Y9sZlK`*w&P%mLtd|fP20oUX2)$6S%>z+iL z0=hYXV`M>lt%)KA6q`Qa_4TUQaq1 z_hX2kiF{`eU7}Rafd)aeQGZQdk|ttgL&ENCj8UbU#wzz2?5uO;mL(y5wkOik61R_4 z-vktCo%_%AhX;}0lTy$iIKe93JL$qb5DhT^I>9PS@uuyFcyF7!@Tp*+OaWzWKE5Ie z4rSSFr@_cPIVV#_=SNF?wOj*6i`fx+VwGAH{CBhmY7>3=We_X0JW}A0CMYdP5zD;j zUfzSC4Ex*}Sx3i*NDT_+&K%J$AU(FjLJ!+*AUS6^5zHE6&3uHd~`;A`JZ)>f8 zAz7oIsPn%Z?odwr*o%k>I-EmNYWkKfvTxtLyy zxj99L=1|k4xy>&LZ|MS43jSI->>G56NhQT2CI?_syl7Mfwm8nGe=y~Lo%;VB$A5SL z{PUvGyBfI7o=}8)E0I`7|H7e9FF3&rS8!-gfM%m%3HfQ${jCnwlO=DA^GKQMa!E{` zjKwZx*NhnuvzT%#L#+^|a8*(AI{IcV6Y^XupHfTQm;Z4AuzN?P8$5kQ;o%FK|#+^R#>E~q^pbdQxnIqi5c%giJJ<|oH%FW^TJ!@`$e|)o1zV!^OSV_t3OtX?E5Xhu zrg?g=dL6qPyN*gqoR(;kNMk&$G$29CeA9VlQm=3^XZVU$EkV&42pG`=t5SBe+>QB7 zUEc7aKSszlEfu&@;~ndrB)tvaf@n~mO~WJ4v1xvQ+#W1$GiQw!LMuZ|vg|SoF+E~@ z6+l4G0MisRbLNQkQe}vNkyz#@1%ViVpSGOrU>S*{m}+BdhB6&Kz-KquKWJ^0Rheat z(p#(it`6)5Uqyue2!#8XyM9{JC&l!x)lQ-U^LT(?b=!?v_kwi!@-)DH;VP0*_w_QM zBBMtA6|qz~f^o(2%+;LqSP^5L5@Ha0EIKc3H2pcBX<^L7I}32FO58MYuYX>nU3iqq zvfy2}w04oo{>frwJtq7ewfRfOv>LUVFF#j8ZGHIo{Rl5THn=UBiy|Z6h_U@1GZz0F zVa!!w8Nl0zuU~#Cl1;HOO|dejPbLf0AWl0^8EoG1I+?d>on3o4#}EXjoktswe-N7^ zc_jROHiEOy8Q0m&6MHURV6;?0ZG8NYM~G?ReI%J4OET{L6*g#Uh_9~}7*Lb~BB>)k zq)6Dv@f9GcC}?TcW-nExLitltv6~L*E;K>C|4EQSSZKP9M8~*njokDC(SjqC>yKpx zNyhso+-?hI$ZMbF>@AS`L}inrUZo)T>F-_w3SV_z9*h)7X8qzG6NL9Qn(FC{ssFbo zzLRxHXAYTSCc!T%FJ)=xK>%j^_0B;7OwHQnR4XPWYXJ>K0-^6vAaD$T$7rADHVlwy z^&W0|f-$kS)YHtlJ)Ep&PaUq9PA+ahE`KS0II(7@nR^wC^C$JYgKXt z>#xA(JL&aRNqe`*JWsRJ(V6OF;4kr#k=sL%+qeB~=!E$O7&`-OXlsV8m*c)oUR1v^ z?6YS=L%MIg%+>WOWD(>osPW)&R>bLjHruyRW z-)Co*$M^5&xp-(v`mDXSOFm{)jZhagC9f7|aAY;7FIY^_jYxSxqNM5o02lvB>?Q5f z)3Y=$XvbwIws`I?qE7!hG9~=fU;tBEym?Sq__=An_k$IeF(0Y1{ayc0Gns6bw`nt& z%F<+AfEZeZ{7?Ujw9oC+l~#FerH;U(p(xIf)*$Oi#^sx_4*s4Kp@UAvSKuRlChp!@ z^FyAzV5gkn&nsZYoU%-&ZjI^hI=8~;bJ_n*>Gtp6C4c*OLjQ$IWA)!MNc&Z6_YW@N zVr~)B-%B`u<`)v|Wg{*viQKnQND{^v-z-u}0aFl>-Y;q?UZ!8;H(OXFiPtKlpkJm$ zoz~F#mlsY0K?haIt{_Nu3!bx6y+(nFcaAGn^O?j&t|OHO&?{{Ma%RR97H(L@E4pIzI^gIX*QyMQ6DEmx=DXQmYTzcy!%z05Wcjy*nQyJ z^E-Ei)`K!@)<`E(Sw8qYZZdP2?9vxdjIOlqNYPKT`6E<49U$Okt;?e8!|izho4rvi zTyUSmQx(pg+Y8gn*b%_G4gka%w}uIB$jW`bcmbU}G?unkmOnt5x|Mk~@9Q32wfji- z89m%S;9l@N97}4Lp-YT$ES-3C!dCv6nzP4K1+yht(w;7A|MOAe~)5D5) zF}sN(%H-?=#1-QF7j`an8jHP(IGPmU0oBuw=>1x|S}VQi2m5C0yFu3nf7PSy&dJ0^ zDt=wbmteIxQCE6FDg0%O1r0xRG(egb4ksFXln><5pV8mce(Z?<1{FrG2Oz3{siKv(nnthmjy)ZI9Ct(w=q9?lwx{YL{={jmFgWy zP*xk?@j4ZYe%&EoAo2jKYVYgBXE##-fj^zpc6Z$F)|)rvObG@Mcmn7g#sn0=?67&l zIu>WhDveIqVVamqLssI zOgjwi#_ZxuIvrfz;35LON?!J2GY z-1n}}Qm>G3m6az*d6(~9D?YTARL|KbAFgT(rR_3YNJDFJ_Z@gH9~@2oxvI?znCFv^ z_CRXL0*x28(7yTjtuZOUP!}4lYxTZuY^3nJ zEVaEH*WvSq!?AW<)hm_9BZs;nJ6w1Vo#g2Yf_Tvqpy$bloqS-*ASt`sWv}Man)(4+pU4Ar)~^F> zMYo1wH)Lban&u8MD}I0~8ZWuG=&ntEfOO|p5$C{cu7I81C%Abeb@IAy%-TxFFkUeQ zwQW&A`&K{styq6#>=FF+8S%$_Tjt<9A%L*kJUvh_JT7!>X7BbY-K=C3nofL*eb?`S zfta=frZ^T|O8Qk&Y*MUYrRxQ)kb+jt?OLvh z!NR1PpghZu7cjFJ^XStLfZ~UU-^+V2)}>JuzUvp3b@?0IRdeOKZb{@b3z4`p`1kp& zsIA5o17M5p+yh1SNBptvghCfGnA;5V4iw-fA>wPPiaOa(viasmnr*K+x0?+mt_$-W zeHFzwWEC94ldY|-3i5t{g1J+v34)6t!n!t=?XPqC&D!g?^LI17Z5!nuI4d8ilovaP zX^6O973Y>AiToXi(0N2&4X`VJYZ?D4Nn9O`{HZO^=qB3rsfWo+U*HC_5_0xack$rmXH+>JCg<<{naGh0)k) zy0Kcvl2T;*MT;2u9YyqH@~wnyX>kv1)wI{2z8C1k9S&t#rnyO#grkA&ADXMEp@ZP} z9O1VtIs@oDBdErbm*1MKV_|QH@g0NigbW<6H1gJZ7QON~S9w4+D?VJVE3Ke#)v=M6 zH9m00lZV{5y?$F>ba_R6$zic&`MbM}uzLyljZcK=u0HXi>W6=TMxq6#=s%S60o!*v zZXWF34!i*4IiV9Gs$w#L$iclIW^fuD9Dd zzW3UFyY8m)=j&lLMdVrDi#}p$rRNvIjF)JoA5f=9VXa0uh$ zP)9iC##pc^de{hhY@JipKPP*@%`~F@161AGQg9KsJIY2`b7Xt&`hA3Z+FB)vb`J6x z&CTQ)B$q(q^$Au$v#^xMSnd0)vX=u8fBQqJ!!+IKJc#`SY2*(OC*4g;<7vIE>KE&5 z?-7erK6{dlkz~j#z&XA*;k}CYu*(hZ>x1VUn?&l&oR~3mPSNiY%%rTFM92@TR-}F0 z)-0-7+@=aBns9}}+>2}oSrlm4iG zzR6amyFs*TGHcgctuO(03liU!Hqx;oJD5sG(7skmX8f!I=I294l*MK<4DiZI7Ff?} z*TmW#e>wLkkW9g8@G%LNS^f>G~H!TQ-4{ z?C8|a52Tit0>xynZ|ko=ecVu-&xm{Lv|tnNGK@PmhVo)jT8qxiKQQ3 ziI{t_pG(>3+Z@^x}@!0BLm;)4lYyK;a;7UMA#0 z!u8uSy~``nOO6Ly<`T*dNjBF7TC0WTVILJpo{llJw~xVR3itBgEUiozr`Q*Lo0G*Ee0-0mqMzN^tRcW}N~ z0u{p-HSnz&USK~qoygxs3>XeL)rMT*mg0TVO0j^mTEKicsXJTp$)%=H<^OblZ~U{ ztN9j5V+{!SQRvg0S|$>By&dL$EgGHgUHq|U?P*8&fR#l-5vpGr0b9m%`~k9RJho8b z?_p2Psmd!5Dw^p?r3%!n(vngNbpKr5_g?ofVr1oL+e%}mV4Fz6HxS8XN1*)_!xX%h zl=YpaTx)%so$mb;RB;JCHqL-HtN4_i8Z<0M448b@X*V9?KR_SGzc{m9JlGc98frWS zug6ZoA8gTQA3X_rkRn$VB6pfCSC(lyjx%-Bzjb3X@gj-*F-wD~Bpkz#y!7qWm7jJ4f)=YpiQYs&}i88eUQRg|znxFC$rAdu6onmfa+ z+5@Zu-NK}mjTaE-oZ(Zh%@O5DZn%5#q5xMvj(Q1FQiHp1D z7du6QJ}_)QbD)V?$`-u0v-bhaE`tNX>yet!j!5OWPj*tP12$dxprx@Ga9;uEJeT^E4FBG7yJ2y zwGO$f$IIjEGNJrMszK@y)$%oO(Yn~iSA!ytH+8Mscr4r^?lw?B9qrI`+t8v@`!9|J z@FGv+Zpy25nm_8a3Oe}i`Z$QbrAoeZR5-x@z^x;(xFEwgOqg{GO@-p+{1GypSm%DL zAZgO3XM8ieRBn2qf-&7HRxz5)HB5whX<|3I@%9f8=rRx>f4Qs9lmt?XE-D_JC$5(P zZh)q(ze|&UjZXh6Gi|i=dHnjYOtZ@CQcl8L0H^_~SI*oEdPLU_LTYwVTE<#p{bk6e zp3capMPi@@4h}ThB|Z@O-?A>lIadIz%M8EISW7m?D|1BW>;cwghea@b9B_?K8UR;I zTU&zxxcW}!Pq><&b{~r_?2`Jg`;*CFrv5E&S00&h6=P>yz{v&<*aH%J1n3(5l|

zFAK*d1ybCZrkPrtwXA&>D`W1NdlGsO0dACc;(~qG5JwHWsxmeWP@u#h`Wklp(`@>W zQU=k*L3Dsylu=VWGXzg0Oz8{YpCM3Aw{t`aAf@cPq@lm`thZ~(0GToNGNH5tQxHcg znG1}2D06d5sby`_#!Oh{!o=2tV|&6DI{Ud$u*HWDHEeI`U2e=rR7IgOz+Q&%3tct> zNYuwfbmieAILaWw)07KWN;03NyU|uZ|D;YRtI(}U=H&ea;Ca<2qbN7?#EU` z`_2-U9qlmaEw*<6sx|E92fU-(crcWBW!lMxC@S0{W8U@xT?;m? zck|%H3u%(N-N`dp)!DD z8KZm}raBT=m@=>;p!X_{z^r=KY|vb@hegZ!gv*vC{uD>wL86-?16oKk?d1h2%*0Z!&dJz(GA~BI+a^QFR^&#yESl%L8PwBecf1dg0apOR6( z@xI>=W*HmNeLfIjcJ-i)(HvaW!%@D&H)~PLHDyxU8&~45F>|lDV^?e|5F^Jt$6tnV-Al^C__56Iq$m4L*hm*+7Ivoh+vU~-F3o(7;u&P+`(Wk$wI@9ubmTuN zWNfd+6|0?vYoEd*9eyYj`xNm}Gnwz_p?MK2QxEOY! zhkJV;Q)I1jbEh*IlxwwmDMFTifXE2I5M}>3?q17jQ=b%8^RN_%jU7TFwk z{jR*(c#0<5MrEdwpQ#FCp`ML6#%DvKeK9^0v|!4ucl*H!ixlAn3TswK92Fy}R`Qo# zy@**iEHi#(N2FyDf;&`&NFvu4g#J@p2j5rKVE=K$mfdzsO(ARiyxrq!XF@1 zJx~=C_b)GN#Fx&Rk++8&u_yM*Q1mdat@881iTvC4rB_~5?hk9}mY-KA_slcJEHA`b zU&s*Q62v++pA|YQ$URj(e=~hNaXqN{i4~q__$K?KHnVxB^uc3{y-(k_t|ofeE)qp| zNq>OKw>(PTi>Wne9XX1=%QORZ5WiXcu5n95Ep<)!C<;%n+HdV;4pWAkG^kKuEN6RW2Uc634Z;;(Q?6kP`igv?c9nj~D`5rSA9K30~m`!())? zhl(qj4Cq<98gbvgwDvs&4ACLC??z9rT&{*l=Jc0mB~^B-tA~|s8ti|C*KaBzk)>C! z9Cn5;-(3QxcFwRXpf_+xsxt4vV5_B()0w%egRTVb`y?K<<}M6(FSM^l(GF1v&--g4jxlOU92tG||uhf|UqMI!D zQ4NDAcn~l!b^9%w_ntAIx#E5mSs&cR9Eo!D!^VoEbktO>7}naI6GE<$e}|HHX2*w4 z%yFeBB~NS07S57JuyZpE5(K|}ll-~EJWpQNyqZbJ#aqGhcjNy1p(?N(#FuvUsziBp zGd>xeUa?m4$41Kp{28`V8|D7iAimt_?y#668PQFGMUN=nm*Tc7br_B(dl`?o?tkHe zI=o67ARvSF38Gpm8n3vi_<_uUd+??N7`+@-=ND+s&Y>pN$=E$lCyk!fJ76RdE%OS8 zQ2DA{u*ADPz>#$}>){t7!_Z%|nIYbZw8+L{GpkrtRa`MjO?{L?ohvJ1Dv{0gAx6`Y zfr)or^{ePIg((1FMZwm~3w=0$0x^`vaydj9*tsTjZ)#oKNtAMct1)U9vZ+l@ zrC6~%C|}!o{8%+by-?Gm$gIHCrFQ2$@jD0b&f)>FAwA#9y7 z$$ox2zif2p=FU+T9I7%Agl8zIgZa&a*VcySzQ-UdyQAFJP+}9Jr@g=nezaA6llcKp zbz-}8rtkI5p-}qZ5hnQNJ0|v$8P!EzMf~bGZAjOlHTm4b+k>BE(COx=buE8M6LcAB z_W{-r&M=4Iv78a*x=hVXbGowFd#>g%wnad+L?yZTw=v28#`!;-cl7VCiAe`9dwf6^ z<7ipxcww?|l~Feee$Khi;iK#}A03@^(bAAxbmtrp(cIQipXm^FcCS&|p@H^8iiKsY z<_X@Te+0QSVhg>v$=0888cekISyj-;pj+8&O9@_?2Vpkr`swkU%eN6ML@3;C9~iSP z`8?Q9VYfsPdk>2dr(+&xLr=PuL;KNB{e_o3JAjV@{CKEd^^#1*Vr zwkC{h3Olks3EU0j3gM4ue!1?8eo8JB2*_$@-ws~WLDYNSyf<*PqcB&0Z{D%ZPw@&4 zv}hGk)&2CGKuG{|dm%la<1SsKlhpFu?(}YZJhys=&Q$l7mr`L2>esA-;r&yjgl|gqwIp+& z7zh{8A^-`*=q{LARlJnEbx)OV2u;{79WB`?l}U)imO;Lx^1I7{u#YCm=Ylm}x{cc? zE1-X`@M!rj^JAvI20E{2@=ot%zC28c%dCnCdW~W5LAO0*A#(rtYR(CrZqc@lYb;ONfg6{;gJ=>-sr9kqcq@1?6ppKZkAOB1G=CWq6b-(at6g_ebvBpEw?ZivPxy9@ z^={_I&W@a?pCY$`x#%YBasRE5O(}i(DD9md5!vMVr<942Qk0=vbE(DWc}~s3){sKFD)8wFi?&hmLW`L8+3-K_G=7WWJ79-fYUMGvWAKdImZ_aK$Bg_AA1webvW-q?v_tpu81^s!g%i{ z-)pt-^EU~#k5|@a@d3WVGx#6T6@LDXvHoV;!@4fvUNW5|3h>`k2z3Ayd zXJ}*jrz>XMPuR(XttoqOvH=0yDE8*9m=2Bt73GM_`h>*UczwEeYA-b<1O{|6QMMW3 zg%*dF3ATa zc*vA3)QG0rIEML@CeVce!()(x0w3wN097Npv|_Hzj`a^2)ph>e&juN#vgYsW2MF6E zrG?Z!dQy{pSl*7CUN1KuRpa$ux?$|D$gAsQCWx;_hd3Li2TbO059nUY*S&xAoqX{& zb}unBV6cy%NBHTTw9b!4LNDmO^DZqs$h{IML&lWtbT&O3119!`sq)%k*7ne6kfG8- z*GDy_a0uixKe^C@!@C6zS1N{;yo%*LLAT%i!VbR|!tMv(Z@96n`0Ct9;N~;e6Sl@| zXB^c|Zz_7$338!qsDAP=Oy%(~yN>ZNjMizfgz=rGY=g&`Ng4e}?1$QFc@)~@khX`f#HBHh+NTt6|aglKMdZ zien~ha1bSt07xKaqKH!{P(H9jlE!OEs`0d=&OPy)H24otx<}(VtKPD$(tq(X(&gFL z2UlNVrc0vhR7I$}2^SQjs&5h(Ux=zlwOjI>Vyj0W>TY2=^k6A7Ddfn?>Tpds=LE{B z(D%k?J;rfC+QS@yT6-ee|HdBkk9^KQYrjGRQbI%>5bxlK#Bi73_B7T9qiSgQASIFS z?p4#F^Y7@~CP6za@KkFdAcmPw@}zLCYUx$S#GA=pcofqaT)2VIzNnEN=(VOz))ZI6 zeKwDrGN;6(llToiqP{gz^I*xXU9&HO>)2qV+fbL8;1}&GLqT9!>UUiYPV=pN60BjFmhL zF*YK16^!ItWBMrhFaxj&1)#4b_ z9z{7gMxpiF=S&4es)@FA4$Bh^CUunRZa=LN7NL96_@tK#ujI<5z$%M}=(x3!nYlk%1x@-W&OPQan5TC47RRU5~5)0f;jWe8(!IJBono&R*y#%J^?X@}H33w&XRp-YW`E4p1x&LSEfopr zcHdk1p}9qV*9BVE&~eYGGWqC8zey86s1bfVeI5C}@6cirbB$s&^LoRgE~`sl>^a>rV}#MlFbc(`ykirHynKn8+G`rYkr%PjZZsvn>leSo!+d1q;( z@~Cr`d(HDaH*E|l(tDHksQIk&LoBf46d}3mh!={swO}H8CnJxLcjiBw;B*bZ>UTjq zF(Ux-`_ey~l(a;Ii8v%DJWpVZa)tMdHPi#r8EPdY?%24khO;tnKzzn=bA5BDNMl6j zu{JU>coM;@To#?xh|p>K%psypT~AOR>8Vyaq(0Wlm~_N-Jv%Yu!3WuOqs`nl z?_tU}>gKID)J=)R`cRL!YPo##VS2Sf;+vt|Du=v-EWMijs27Es;kaCw6DD;T02$~cb>1;du~MI zD@T}v``!dA`?^$=6ZhmcOm6F%mo=^sD*ZU3PL0T(S&9TOZ&km=2|u9}pFe%_P(nF@ zxxRCF3-&CN^u2P1tZG*LqqHffSbrEqNpe3m+;0!D%jMB{!e|5V#8H$zMp zB$nnygPHE^6hBEG6X{QlC@c&>ZlCHy!{;KPNq<2Jtn=o!C?~Tkq!f4OF2xcCebbbJ z*uV@fQU-0`wq1f_ifh~FjXBHt8}O9oF9R}4epR?=Dc|^MsMU+&{>XgDay=5`yo8Nx zlKDb1QAA@&*+;6oxp~bJEqbD=o8~K)_^)wBo$#4{0my+Crq`N)I-?oKV#GPFY4K zV4W|1hv*jBtK=Yq>O%sWT{^^Arfxm`VGC1<^qSjc!yKt@w(RS;dbaF&0PWN018)9p z190naQtU(lvyM;)Mhd{TyNRlwxCOX}|Mtmhp%NS{R6F?uYB z6Y<*D%I#_~S(aGCYOMwVai@rQb~rp7y>qjQ@}Hy_JQ zF0DB3`DA?(=B2JHLwmJQ*=oB(!1ii%>1GfQmsxb&6(5M#vC>hj*(+Dy0W{#RHs7iO zrb<&=2iS#Z7YZs9XcH3{0nNMEH)0(TBuUDu78?l)S?m1@$;l@7oyOq@JD#n)J^*%F zxZWFujI5b4Ha3pq+xEuiz_jGJ8_J?BOI-4F0IZ&e3x^O5%AMitEY&=Nd@jre1Npa| z0|x=6rT@YG)^T61OBW5XH)f%|2*jqn_OL<~U!PfGBaG=Je9C zf*3xwI3i+16j&6Pz+z!T&~J7_HMk6DjQl%`l}S)-V!KSTzb~DKgV1Z3SKC0^$e+WG z^LyP@TLVwkc%w7sy1|7XT7xSVbQM}58XUc;NZwQ6raU`)DxKlmW6yV*Y}Bn-Aj=}6 zgOZvE7jg;MH;_6hejV3enB0ncf$GyD9lc^WYf4{g=K_ z&kDti8U+CP>gzxCkZP(6h2x%-pN!8OC7c{S6Z&gSr|V8ix`B*JA1T=0?|S)&QmZ}9 z-F)pLzu-T`RC1#Zl#4RD{^Ohf>kRn6eEcV9K>YSClH$$gt9|XZ<=B-qaEJ=Vg~*I0YylEJ~HJ*hr{~8 zuBD(~aG2DqX3$b5UK3?LKNiFv59H0By-9XiQ0K}sjPocO;Cd2WH)Ht|(CoYCkplUp zua`A%AnQ1<)l~1J(Aed`0j#7dj9sNsv?DY`6?D!Zk(J0eB7lkB#N=VDKL<7xuxvL& zI|e>P(*A3)3XS7X%FsS#sV&6Y_`{3S)}#$4tWMEGOhB@)Lhq8BNnmOu4QSAGUg_@y z2U#l4z0#wjO8~<%@rv%BuU@t9ez20h!$}f|GmTULhhFueb+}R5VJg@aSU+iqGpLMMaTy>YsZGA6 zKq^iLdQ*1IxuCU2rp-lWA)?aTwVZFp-ywss64C^^=W&b?>9C*XZzc4Y@bJD@Ke+~- z)t--o9fw4rCxJLprXS>px_z#PAG$neL0wm)_f9&>Fyx@JvTtiE`IZ}o@7VgUT!a7O z2-chn$}gYCYa!fxTJmse-jr__`!WEYY{cDcNp-7n#9=?Oj4l^_6+htJg|Om&OjCEe zM;vK{wh-gySeg?Miq4Vxl^L;mSfX?WRSq{Bqyxrw1U2i2LwH7NaAV3K8MOMyU`7RD zNsq$3g$PlN$JuXfX(HKWrI$fC&^;o*h^EDAYw3lUTQ5?YpwN|AeLsZ4F&3S0MPw1= zQ2ws!`#PQLky4Q`gtuRNC$i2vWxP0t%FIJgul-S6WLx-^cb+}O5iL2He3^fMUoY0^ z=6mY(7!c=aiXN{3HK-q;D;@nAH){3D?>>W7th*{hC0KUVGmeu+BHwa>$S~phVg@#s zD0-fxJ3)jeyqDCt8h(jT4Ds4fhRx^n)b4<3og4SdU>g7e5B&i;t?6tyK;?PVstgka zVfAVgrwSAsVsF0=>p?Y*Hm(gUp{~0DXmY%uvh_ySh4CQk8F=Q90c-lqa{zWn_|v0L zsb}3(9#5xwUAZXRRu6PT<@$Ep6GLeMO~Ylt;m%?;E_2qBBcvdcr3-gb zkeGkv{g?S0PvZ&KY%iXY%7=v}?p<_#S6NVUkgvQkl>@oAutyckQn@%p=5r>W%FA31 z2RkfEi;el^+12e@7L8u`q8!&!Z(w9uTv==avs$m~IRvOEdy!gZ-j3IQl6DsKyGC?!qD6)=&Z-=0gHScFrb!QA`L`o5vaa`mXsBc~q@C=cilG z@7qr&$C`A_)XOaE9|}ZyG3k6QyykZ~O)xK?h?1t?^bknp$fo`}?+?NnN)jnIEz$~q z&+xW5o+%0&&<@B0iSPLf5PA@)<*n*a=r!(Nf6}4|4oOWXRQiHV5nWOMPd0`)LniXh zVM|X^Jl;D$<{7@d63bQ0j^<%~dlV@P@&{47C4r6w1`bFpSrgsB;?!?q=i%_&dj!JG zps-St&r_Q+#^tH}vFyr2HC^ex_#9dAc?9Ec86b(*9LH~}Of5zmx0YdCZskC8YeC}f zE**xo%q^lh)~3kTW&Ud>c#-6}iB*odJs+Lp03l*h62nK7e{ez9hEzA-3n+b~@03oZ z4x*{mRU0-qs9m$VIH}0*X!goapVq!Jm`iD}3Z>dM;+v7Ok4{=G7Y&=jOo=KLZej zf?S=w2nl+dv4V?O4zR+VMTr}>0Lk#}eEGw+x{9X({$hsckP1H9abcGR$hlIUr8;ui z8^P)xCmVaS(58X)89bvF5S;{CdKkD%X%r#P3CQT*eh2hrq9bM3nTCa+`~H@Vj9aR< zteoWy100VH27A^bQV^I5IMhsP8E&S{nx=v16f)h>36}B?XQ6oQ#ekuQ0txQCDeare z&$k->7IEvhLCb&dx%LEnM5i*8jmx}}{EKlpduHfs2r}E|W;QGcOzny*qK_XRcIZw0 zSH0R!ABeUUV5y_um%yBom4{1+;YBtmv?#trCyvZ$!U7zC!N>(NnMsb4pr4}ZP#S+e z8bnaqeC0J?KG@NpH|GX&rCk)v-mScr5iYn-Eum#9vm zsz)H!J_@_%3x+Xd^z}>hj6X01wp2vj>$gPttHI8Rf$9UP#_N|DbJhTEmRj@!<{)pr0aL9^&otsg$~My{HfYrmBntzb7O*Xe#JCpQEGEq&b~z)HG^4+CB1hV8>}-NM@s z`8>&LYE%)I_tO7LC4)DO|{jtG03yP=>+{r$en{`Oj)VhqAAtrc~3Bo-8xqltf9=+>h957+?U z^K&|G+W9ZXdY70}uz4;$0K5FxrTlAD{`Fn?*9`jCy7I5p_8+qct=5?qZVEWbT7J}g z!QD4`mnJlc+)vPzGrH6@oeq7EmmC+Z_xjn`F&l11Y3a!J)ImbbshNfWhFu@ed@&?9 zEoTX>F0B4e>-=eHPE``hZQ%$!CDCV^d{2>P4d(r^H7yYTk8EC%6}MzsecG&D;lcx{w*l0^D&~y7a;X>2u2>OAN!&rrHoT z`*&gw9nY}8i?3rVa~|`Zg;PH1m7hJ8H#3-v`2O0QY8%j`#7z?YRdGb&E3|0!`XqsZA{6rd_?2D-Fk%KQVR zhTkUq|2qFmP2vC7$Alr~k9w>YYbxQ+un^6V5vR4M;+!NhXBf;GTAngX$UDm=x1>NI zb}$Xqw4}R`D7sGc^Q0)%Dc;+a%;`%}@6M6$cnokg-q78 z)0%Y85S6Z!de4h>(IvzE(T-XEj%4!hNj(3jJQvc~_AQkfUyp-bS@m%jErhEppKn{7 z1~I=_r`ICF@V)}@!fa+jW$)_qg*<8i=O=*DOc@$n% z!&9@Vg6fLKid1%vG6%mShk znNI+S?_ub4YB0Ibcm`_#7x%cKLv77Fh-i4Z=WsUayMO*LgT)-G(aGji>KM zCnDHa0$cCl=u@oFpvSbkt+n*ylt)-FXz)r}UaisDp#@)N#GzQufsV>M9!sR78eWi^ z#&;u|F69d>L1_!7ap+VXaE2J literal 0 HcmV?d00001 diff --git a/docs/source/tutorials/figs/qd_alg.jpg b/docs/source/tutorials/figs/qd_alg.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3300f074943a68b785acbef91effda141e336230 GIT binary patch literal 251040 zcmeFYcUTkM_Afpu5PAoR1c-DgN)ZS(L8Ms#ktQHTKtOu$5{jr8snV3Df)s^-NbiDF z1yls3NC{P>gA_6RhWEX{bM!s$IrlvGd;h$XXXaVivoqOiuf13KtThLp4kiGmvzj`Z z00asFI>8TcFhysoqpohHZ=k2Cb6x|0KmdSF`@EBzJCq3kT-|)U475(8O)s0F5xoEu zpav)bDFCps_4c@MNz)Jj4;>A4v^Uu4kpAcKeGmYj1OOi-wDr;Gf42Wu6tk^|mk$6y z^ugXTcJ|)3ARPtLF8)3qhwZB%&34uKkcPq!X)kbqAkBG5JN!wD|Iz198h1$Bxw_eb zeGbR$VdrXhNVkFXZ9iXokcOQH>1aPEdw-A~0BHdiUsorP-T`SgS9=?80D#jSw)@!I zI)bz$NYi;48mNP`G5}D~Is8Ij{e||i4*)<^?(XVg;}!@2fAW0zD}d#2ZqeW*%SkE7$w^3`0H^;S$A7%}k6!Au|Zan}4?b^SA$ObAJo~m@RN_;{VxpH5~w|ZUO-3@ITuGasYra3IHnm ze&L7XaJ@MC_;@IuJn8T6f5OS$_Qc_Y{^R)HcKAone^31KeXxXPT|96)iq**W<* zxx1mA-2R<}{||rm%NP#HKi4%#u;!8hHmef=Qy&`uTY3Y)S!n^7MHYAm@(;P4r#1!- zcb*CF+@I?nq`~`tTz|Vjoe;@=12cm(yKs=BPJOHwRT%Zsr0bT%A zKt0d`v;#drKkyM40VaSMU=dgaz5_oX5C{T74`GEMA-oVlh!{i~f`O<)G$7|829V1T zYls8H4dM$4fkZ;?LJ}blAdeu0kTOUOqy^Fic?bCnnS?Ar)**XP7?cjm2IYndK~F+4 zP&Mc|s3G(U)B)-V4T45NW1(r#$I$1{N@xqT2l^2@0bPV{!2lR7j01KICIQ31)M0us zGuSnl7wiTs29^SQ3@d@v!a86dU=y%!uw6JMoE46SOTd-j+HfPdE!-1+15SWHfEU0k z;cf5_@JaY8oJ>JafuazjP^8eIFr{#y@TZ8TNTGO2Q9<#V;v>Zj#dk_dN)Ae4N_k3c z%FC43DT65ql$n%7%4W)UlqAY61OkCXh#^!EdI%eY4Q_WHRpk|^Lq*kQXqqd_Cq>iJ`rLLv!qn@GuLBmWVOrt_$ zNOPSgoFyp4SITdA$lCW8NCmEEPWw;EBzPx9R^m06AU^Gb_`(*4;d;M-ZLySQZouNsxewJ z1~H~EmNWJ-eq*9$5@J$kvSGTx^pL5BX^3fynUz_JS&!M3nZR7c+{HZ4f?yG1(O|J- ziDG%e(#k?&g|YIpsLc9*S~t(R?;orV1ryD@tJ`$P5y z_6ZIchY*JjhYLp>#|w@@j=dw?N7RnkAGvd+*(vF-?-Sgl(=lUVz^##4WpnaQIr8H81)482DQb_!>z^b z!JW?C%KeRpg9pcRo##GJBhLaaE3YcA6YqWACf=`TcC;GW1)YX&L$4k~9n(JMd+gD% z-eW)bg!zp4BKU}WWBfGy82)Sg_xWG(uL|%ATo4EmcqT9`NG*sFbQDY#>=4`*5*9KM zx+PR4G%w64tRoyG{7iUMgkA(I;wkc2WZ*dEam;b&Bw12c(nT^? zazu(n>a0|RRISvyw5YVL^h43r(&b>NM%A5t!k~BqdI{-hPA;y#!lh*adx<;xH+}sYS-1Ct1X|FJneP5;`Fw< zqI#%$^BLF~turxadNo)yj5Ho-e9`37bkKaJxvC|r6|B{)O`&~GJ3)I$hg-*1r%-40 zto+%~vu)?-&Rsh9;M~-C(eqyCYcD`AoV}2AVN_R8*G;!d575)mOVS(D7uNUGue(Tj zQUBt@i?aq&1|bF=msl@ZT`Ict-SD(woZ*O(h>@?+D`Q4u3*$oLZId%5i6#@KCrv|5 zdoCZn>~y)>3}I$$_S9_4T*Exse8xi7BHCi`itv?yD_xdHEnO@dtQf6qtjet^tWB(o ztoLp7Y#!TeUDdgoadp*J-8R*B(GF*K-)_NP#Xiw~?wZQA#B1{oDh^2w3yxUF6vuB) z>P`=w)~;(`&%VCxtmmBXeBff@LUg5awRWv>V{vnKYjfvu4{(3yA?6Y7G2yA`ne4gh zbV0f@? z@T-txA>kpDp=zOzZa{8az40oHKP)P22Cs!L2&V~m4u2aV8Ic&V8EFz(8^s-kk0RaF zy7?@cA=)c?=$6v0?A!3$PPcpS$lOW4LyobF>Aov@H|6d=!Isc{PwHOUy@S|mvAuC} zaar+{@ow>h3D|^!MCQbxL{id)q{{o~`!V-7ldY1wQck60r_!YQrcR`tPpeKBNRLn7 zf8hAweXJR))s@0J3k zzNKHwtjh*poO|)A98+HMQt)L)1#3l2C8RR2a<$5_YNGmb^}Cw0HLq%wYAfna)aBP7 ztAE(Q-VoPF(-_rw&=l0P)$Gyyt;L~*^vdehNULe(&DuD^!`lLEd6ZC9PeD=y!3qig62a1SM#qkiyn(VzC|xFFJ&x?EWcdAt-M(^ zU7cC;T02-LY#=xCH&1Q8+S1?p^4<0OkL{QpL z1VAA$7!(eppn!u;5+oG755SozSdK}lQL$)a`&%)7!?ukmyD{_8-&@@=(|e(Qup$YO2wJ(rhn?l|DoT}AVQp)&DC z^2`M9gcee{fDNxDzbX&0dTv-N^M7!$Qj(lsol(-;K~&=&2g-XCldhXQaEKB zJXfP%8Jafx+P7b^SazZF;_})UnAB2{#N;rfo?oMAEDVPiOqVPbHJ75iObWir#7hP! z58e!DBB*le0q>;)uyZQowLk6nugR7St0=CdxZJ#7+J)IQ z3jeBymh;l>R}-iJf^M>1#8LcLr=h(6ImdgaZc!giv5oLxv&&!z(uWV2u&<7{mj`6` zZhSn_y}mXR%^U3Jo#MV6v*ZXojuH9q&SzhbMg{q}ddg7TqtwC9B?bWs!r^ZN!tT^t zd6N`g7gyV`au>2>xXmeLBj9UUHwC});m%;s`OXv{xZL|9|5APhic6lH9SSHO z#lf(B2?-@~aM-j$*iOvsOZN!vBl2El-oq#gRQ8mw;0vkGo_&@TWkn(A7qu2=jtT)2 z&p6;&QMV-GRUj4{edht+qYk$vw$4)tY6<$g8dKm&i49s8Gr}WVW?zcUjx#%Y?OdB~ zHeDt}Ygv?N8QIKhm0_%L!bsxv9p5P@Wp(Gd^N6%q{e*o}Bc-xWnWN$Dft&~cR`6fX z$luLewI1a@E~)KElG&tk)MX^nD3XcWNM|%SGO2m)L!Q46a8ZNp|I%qPAWOA5KRk7f z_9$IqSf9Wq;H3w90F)V>tZ?+%4_p@rE{~J?=uL1y@?$!QM+f&qgQo&tHzfFITJvl7 z4q^J$sUT%zMVd!N{YgX&$dalNCO@2_&6wwxK zMoE5EsVzi20QPu|8_9jq=Q7;ZpZK?XW)|tnL=s5v>xalkvVSUtO}mqaEN@OWc>0b6 ztgxTG1KHKXh@MTzBB3YN57><5yTtB|c$ZR4JNPjQ!~)!RFeJJ9BP8wpi(HC@I{auw);g~8m(k6g7?p51k5oh; zF-Dc5dT{1koi!?osw+O%x}36yiE0k+i}LMizx8Sb@pf{4I+%b+BX&|Lopx&xr$#E( zGDM=L;{m0Zzf+2H`_5BMJDSJLGqbKOKyCfL6m=-HhWWp*r4fO3H%$f}03WKzng_s= zZ-0Q;l-9n$hHO>R%o3q7r4YVbSyeIQlXmg>&U}_{oPa!-nd@<~{on74QDBHUov@8jqJty)1PRomPHEC~KFzRm%GXm9(u56Nh}Q zGI4TzdinB2O6lIy1zpWu%D$j}hN^}bKEcoSbmWGix8`VMRxHa_qdUG0(h7OcX|E7$IaMtcH@0O)N|dhQmHzO@ zcAMHCNY4)?nRRTlhg;So^d|!aGGK(cjBAbY#G^YS*L%F#+CuIz^m{2jDYJ>Kr{v8Z z#H-LY^YFO_y%Ua)6ipd=^#1kc0_7M|{WGMjVxHy#Jy6cI1Y!%ToJ|dDSPy zfkQ3ydd_{<&V_Wp5Fsn_d-r=Q~bo?mTki{loo+ksH@6+}dv}@I)2^ z_F=!8<>Cfbt4MQo*>ZQ>Yn|bqPJl!Qnb!!w#wnj@h{k>@xJIF~xds+W5hCaig624L0i z_k-<=IxG9n)oS%pc2RmzD<{KpR2FlH*<_9bpi`6ahtmP@II9t#11*!yK6-in?Tnu2 zvjf0~(hmje#A$c(BinSyuA5O}9wB zdgCf^VorcJ4eyz;0ZQN;`N);*ZJ`68@zMbhYn&CgcDBPn>0DY`B9P`fFO%7PA6D7} z%Nmop-ZQy$FW1Up-6)(>oaCKBV69%yZ|cD_qG>j)?vN?s)QNiqY{Zc$zau}TaMCuh+ZfSBWeeZ`p{vI8wVHFYSLR+$kOtsw62|;Zg8NaT zi?WN+t<+;Jmm;K(a9_W2vZK=M`CV6dU2e#POS}V+)TOTo`%2g5 zNxv4quHEoaXo`XoPBnR|miy}`3w4iOF}8v>hH7It2{RW1?8#pqns{gOrY1q3Cw(Rk zjRFPN*$e5o^x6}&O10k(fExLq>)HEWMFHL|w_b;>$q)2Mr7oY5j$w^gSsU}v;*}CN z9jwe>jcs3`IaAE~-Ts=JhiCkBgiKdEBew?N8W7wr*NE<{3aQqAL!c=|EVi^vBn!Y| z1Cb-dbl(edSD=33y`ODty5(;mO_}@7Gxx{t$ZiVX^le(IGbKtz^6j^Ba@|jM@e1g~ z%wgICbLeTGy?l8|{CPnn(&3n)-Gp71;!t|Xg`GR7gvw0EmhJFa?R)FtL)Vj)litERdM;=T0){s1l2TCQ23Ynu&Jh-#V>jJzjc+r+3*i}^LeD4Hz51c zdpzS!p5vAMAqT+A#y*+uk@a#1xBZ{}p;~5}&U&}MA8{+~kh9dJdD0VaSJsRai>;W$ z(kM%~5G9>lxEa)=2N>Ik*GC0W*bHjd{PNy=6K$OF70hhk!f4 zBU^wiM8(mkg*?ez7QG|3=j|pk?C=;ME7z|iY|?!{GUouO%-)k-%=vh#ddqZp*msPJ z#4q3gXYNFA!5RQ>a4Ecexw5--0L0H608?V>XVx;GR?c!c$yXb+x%f^n$)xBjCRp09 zVVgbX&!+l)HuN9vG_9nzC>f3LT(9)%NR;Z(3}HI};<~VlV@;cwdD!scgSwqK8^I?muR*J2Sp!!ZF3Z^>>}vJ9|x% zUFf_k@R(`P?<35X%3`DZL zXGkaJ#|I)1380&Xz4YVCX#$oS z?yr4_$BNE<+x)(h>?=6%e8GXS`)>QUgnkq|oaDX5FIrDv9=fplOxIVGPgEPtERc>| zmTt2Pj!@A6O#2)8E;|coCb}fl3OsRkP{Q?z>U1{K=~Y?yRBWW)3y}^{@EUARjG{d4 znV3Js-2(UPmBCXH?RPwhXFMAIZ*IqMD4tt z63Vjwa6j$@`gtpA1x-r&bPR4Amo_KhS-fhZ#@r$FxOv%o=BXO5NXu0Q4>cEt40h#p zjlgTgp+6s;O2v%KcCHXWCo;nUhUv=-g-p=$mVPqt$e5MfZO0C>3MpniEL$P0y~isa z0vedG+hllZTQO_1tuX;}br&A_vY`8!9YfG&ANK_x9`@BYH&A%9cAYtIDY6h6>iNk7 z;Kt7h3w#63{xxSF!OC~-Zi0pwgp-07b@MSwQ^FoYNB>8?qdREF6kRmnl>TYCr+eRRSQ3MXt-gpqJ?$AD18m-DJaw6$omLFchVxC3 zs(T_Mmmyp1kDlxslnunbpA{0o3vmU}&3Om{-=v%8s?HC;C-Zz-=&7(V5dh9Vc_YkC zcERg~=D-%3OHA6EXpU){O}#eN#^3nHGKt5^$+L`WtblL6woimN#p40D`Fp2syOcdqz_jXosr>X8+UlocjgL0|geSNpV{Z9b$1btlix zay5TkT8g-{`K28#Tc4YJ#&>>5m&;=?onC6lX%Zs#FW z;MqCH*@t{+&aw|n80`Tjhn@9YAKpM*L&QLb@m}IMH?8d zGomNfWv=|p${J@W$*oP!6rbF^7%-No2#d(caJ!LfZ;}uJDAE!MDUxLxEY+O53BaWe z*Khf;8R5Iel{eQ|dM@*wO0v86PLRu7VVE+|KvxsE8d^J5KTh*<&fqa$ZUlry2MmkkdHfokdVQog^nCx z*o5@`j+zwHv$p#^7)f)@{W5uuxoilJ>%ENos^MY9Oh%b6q|ELOu&sAT8@#?Bt>h)| zru3qjwDL$~95GY_xwFGvV7or+~KCrRrsnrVNS|JKgABRa?Cp zI^wEie>0}EWw^CJGQudDYN4IedSa-**7)gzTpeHLZta}dbmUhCY9t~;rUkA~Xu^iwg0XU}2yCI}Twa~V1DX2?>c?AJ~hQEYURz`3oe+iF-)TG8!^%_R@KLFYefSY;w zVSVoVw@w}a%x1MmVq7bh#;=8vEyu>iPRKj(1~96>ulJvFh_qduF6ejYPLqPfYKsPP zBYL7O?2?9rYO&$j>stqaOW5~3An5)FanUQCG&zYn&48DVa1MJ*z>lf(#!_6tT9*Zr zwa2*Z^?BsoE^Rl}LP#q-Ep^Z8jOsL_)$S*pE$u?mNos1Th;=uL1W124Q>jz@>VqRON;s;i84CzLpEzsHfkymqW!bF2@dc#D zcH2H($o@0=Nl>^VJe(^fE&lOth5{}?yneju8rlI)qK~LyubXm@HhxgV$|7!XQ|Wvd zUm|1}iQ`8q$IDy$F5$ROq!+y|LO(#5sE_G-crZ|XWuWTB@K-Z{sqOV{GYDW zwxT`CP)qCp>`D~h5%-nK2S3jyo1POItyQAj#le7?AiB`;p$DtPY_%FPtKiEo zGw0460O9RgWgU4yDDt_p{`}hRHUqOXrLL~dJOCu#h|Cerk!=SR#9}#ldVIS(Y^}Q^ zNi%7Rd-}cdO;?HRtFF6|*83w2&>8%wd7^YAofIMLb~eL@R>xFHrBf~=R7n((OxkEX zr6i+ERkVxlyN+? z+t9WKhQ$TDA-~i7N0{gDU?8!!#uEXV6|`}sg*-+zWRBiBv|ZL`OGAd7<+%(-`vG_3 zSHhtExr4mT?U9p2AZ3Zo>^^l$t4q9mM<6LtXF5^Oz!CQO2K`Q`tLxj{mcTAxkB>#_ z13CqsrHwx6X?e@gM@gu(Dtc_yOe6u^)J2eX&kpt=Jk5IF?QF(n*}E+&&uv|9hmTeR zl7e1p3eEaWKA{i=;-$xU8D;rLB{$urecdmMV0^wZ`rL32I9AO=qeLsWW z9soJA&c=Fo!LWCZ+%S6p^dH45!(N50?YbTSR!j%LytCEWp|_T-pr_m8zPEGh08lsE zGse>thCWlzC-o)pk7WeLKFhGhbRpX{WGot-X#-1GDIVYX1p6SGOCX^o2kM_?UBxhW8{(RbStb^t`#r)b|j z#o|HBm~P6ThKBSR%?I$K?C`;3?5{#Z*6eCW_2>=&8S`(DuH7`bZw>?Z8iKdy1h#zu zW1)PKxr7Yg<$k7-vxQ%p3DfKs+H6tN9s!FM?(HYpb*>$`a65TJ|7DcF!P%P#6$XZ7 z1x{p(&1Eut$Al-3=F3=0Yy8C{Gu@HpU=?$TU_oZr>9wtfy4b)y@ z4rEyu5j0=y_I~M1nRG2`GCulJWMl+p(bAX17!@CQK_%WUQMNBN#n)O|8#y`>=jP!- zN$I6Pj0*ZzIpl1YzkO+WG(Vo^k#%eTezocoA`XYBz9f`xW3Y@ff+y+%utXgdAb;p) zh|ZdL?aat!AreZO?F=l%b3F;KJEeR2hYyex&uGxFb0`0^Tt}u3KNjtTm<^8(Sjc#1 zzs9Q9;Ce?fg7SvPySTTn2pb<1o=eb9EET_qt{oG)E3SKwlJGb+E$ z{g&7xk@`yUs}j+dQbbHMm^`<`Zp}`kyhf^l@3q9>g4fn{v%VU_Kph2gk&vh`Redtj z>|52Ej_dK!O0wmv8>{qnGkqR%YYQKq0*fIRCj;trn5xoBjXatk0n<>WXwqyBBJ9;= zFyDd&*W&mz7^)SG#TGL>%H}(h4U{AHd2Q54E-!S0EX{FzP`L@Vba#e#mm@U+U)6h5`8cKY9UfkTVbpdWn0*5 z0*5^wR6ghWgfM!xz=Pqv*EB2sG+h~TlRNIw^S`XsSxf3wRF=3yZE|-T@2q?MatB>& zQcFvhZI{tAXt%H_>)JG`fmg0%l->monotB4($N~t>$=hO(R$c;Z{ zvyB&Rix1{aMJ{DYdT6Bt(6%_dW_eN07K6^a4J0MKB4klRYFc2ZSV!34?@ovDa%yo) zQOS=$_I8MpDT};M=hysC_@F%#sehZ?A_@}9D_@rmKufmtp@=O90AtA$uOYpN%4R0U?eSx}RLXR$156{@D^?=`c%(G17PcV zYHC;)&#oqrga<&AfD>(eR`@iPb?mH1LZR?eT}4PDrOpK1x;FbnZDqM9>F!J2ha)bI z(ngT4x|Bg)ORd?X^E)#Auo+#i*|ipgz+>MDe7*f!1$AJJoy>{sjW@76P>&y@>)5m}zwU{k%O(+?{R~%y>cb*ak{d_>Q1CF&l9@*gvcw)&q{jMXiPU3FU_>hJbRnf5z$)a z5rwCuG*4=#1C;KL-+mC9u(f5VZ}AvXQ3`MZ59r{~tdQD>e41UzZ$^@qpGVvQwE!Npj+M7=KFX`YKvO!S-1 za(*`8l0p`)3b~n#)ZzAMjwH-wIYQ(11yjN{));@1^~j=6E7s^MMyMV?5cbXx)h2Yn zgaOnh@zk3CE6nCR&)1KmY4^*;AL`=Twb4RygsfXC2$g_w*dp`%cEZ@(%!E7C&0Pxj z@IX)^?wg7>svpsBmi3GyCE981BEk>T)q;T)Vi15`)~gyY74(}I(B+gx{jmK#x54fM zOfI%gE#im5Fod7x2|vQ=WRJC-)Q5i~w=bWsOIeldT)CpwBGM8aL_%i;K4afVyx=`i z_X0vIt_6qPw@0IR(v3M)ZcnVX#)bCFCJ*MsE@41aEbXR zxvso>oCN%Gk>>}Dfahxy(8GAqN4|0F0BGtu0A3rL+->A;oih1xCU%jpqs(tsT4?k>TE4p_TAJ#siU^eVw-lP`iy?`X z5j*MjZGPNT6hyz>a}ki20W#qIBHS z#aKimf+le=Ooy@w#hQA@+q|&0#!pkm7IhKQ_|1#4>dd{ml2rVOGSU?vB3p{|4dY>Letv%R9Gy&@hqmegkayjw=uGNG zRBjB_LPA!~L_&N3zcP~sAiZr-RqC2_?x++JGG<76>Y+`FAsztK_SyUU>IXnr(g6_j zoOmQe=~f%@`yK8&1>%*65s7gRmyar*NgGG(o~o} zWXmjGHT8l0&2u#nLlzwjz@Q_r39TvoTdhgj*D12t`C_`+W1*RK#;cQa!v3R$ee^le zWqsh{hLkqOqj7h>>SkeQ zsOEAyx8V;aMys<8mW->3ms$03>BC*<5W4+3FKN%_FGsQznpYxM{%=(|ut7FVz<_3b zj@$?)yZVP4p8c8;Xs>s@K3FwGMS{Os8sI^#T`1`9g9D=8-KY zta$b%m4o*B5jKYog{9G2ANfkyQWg0F(TK>qGalOLC{eb}@6a2xdyintT^Y2I?S>Qm zH6yS%yx5^i^;u^0f`?QEAB|Q>9TdwLKexKC5{p;9M6%kyp#^#^i=fxib;YVhZ)YQk z+{kqR;9_g^?t$?a@6TW&`Iew>*sm$cO_~|i<6)hOVLw2Z_=!Pn?QdW4%7>grS^tsy zIKDVfvkRjBzcm12+2yO;nS{k)x?llg+x2o+rR4kfa^n$i;{i@E+0NC-w+1(Z3w?E2 zf&)jm?g(=N2}$EboZj_yZ_<)p+xo*`Y?4=17pKL|xmjr}dLq1<9oY^D;Z;iN4*-y- zzz#5Mqy?i&or`AsicR*ES56z<@M6yOU2Ny<%w7A2E%wf4+86YEGV;9qN|$2#>8Q|8 z@Mqkkb>8iY{);%e-#opFp_tz%bRHlkJAW>4Er4@^Kd0TY{5%WJ_x@I(%OfHi}@z(WPBMl!hIg$1`eX&t+_ zZS|Ak>{l{PSVuW+^XC)F|Vl1oHkq^kU5bN zltK3skta{e-mg6XM%;hqYc==n27xOS`@;aQV*LN7Uy_{{^r#Pjj?Ai`!L8u(kqDXe zzdjh--zm9PW{gBo=u&l(ibH89XjiIC&ASL!CDVGtJ|^)5G1Pf4Wq1$%nN&GUtSEbv zd>2*Pzd+>hg6Kb}OX=m|>d)yyjb z^j~+48;gj^j-^wc}GtlIpa%wQfE9k{otuthk!4%^B01>@P5jR3yBK1n4 zLrB=KElJ#3SE|4F1}<1Ot(_yQf$Mq%`}1h>j1_IzG(Y0!%LCw@9*!3W7P3J=gcB)Y z%r)^<((Wd*Mmhen%+jmyj{IW3Cd%ap&MX8k{`8LlC@A~dN)KxvF%JZVxDus2X`vw> znCX-#==^vxbtJNa84#h2;pI~1_XUC}vJQ8{>fa8GK3`q&kU3UPx6M_ExW31rjf?eJ)+0?OOSX>Z{Td>tu=@Jz)^6~){pPO zOnPfC)Q!GHUF3eDe4G7+CTA&)mjb6s$0^7b1*pVU@y^%{&MkViNrrDx-ZoS9L{qH0( zs)};T{`{S(khW&%jbQNZEw7~JE*c#6yaQmow4BMl_br`$0EPd`>G0G;ZSKL7N$k!> zCAc{Q!Zs<2uLIG8?+mrG)?6c9Cn76M-d%?-$ zHubd#eE=zN9}OT3oM*xKswjq-Z&|#r- zGIffCT-niw{c4Gpe5bNO-(+2HZ`=JRgW~sEV72e=p1IkV^xm_*G0h}^9YQl#!=ymVLYhkTk>o1k-Wex1d7w=E%1dbKAp7V##3 zFLKoXJDPdQQe;)I?^gQVLPxbJBcz3AglA@cykzh+G^ii(j=g8cVe%vKR<1nra-bC6 zPSkIYL{lyNNX4_cSy=V*qmWAtAE+3<_}CWp^jK$PXRkOEAjK(zP&8Xj)H}nBEGL(H zKc9|R%dW2{MdCRfs<)6phCV{gO7;ql%vC4$ap@_Ae<7q&&M+Zk5|1FNx2%9rIFgio zi+P9e^RYC427|6NF?>C`<1~h=2JNBN+>B7m*@>n1lR8Dm2qbrYsp+F@h(mlLp%dO> zt=_Skhku(9XSq-#f^$!fq_bll2r}t28NMZ?K!wQP zYP=jqBVs1`*!6n_pkzVIiHOs<_Vd~Ds=3f3D$U%ACR+cZW*KPP!e~q^YMqDDifYd1=z0_t;jWJ9 zDlTC*Wk-h1iXV$h5d^NYYw9###7hS*T)K!u?k(Tss9~n{;QO5hzHeOpH zi*@z9C8rae_?s6|ogpkVZgXf5o=+oj>jtF0Zj`*$dT}LHa8#}h*njPrPzML3rS;tK zSz>)QJGY7g?h%ZoiYCkNUumP0W6wIRZ^uw=kpL#Cf++&>+naXwXUIu%xS-dsI}C)>|5wGY>UGcr z+^_&mK->5pmr2EM4rD+F!N!s3rVeGyKGwoHnHGN|ib<mii_; zj$gS`?+xQsXu>k*#$xclGm3{5HJKq{w%@sa+}_COw8C`kH4AiH`rxOsmZfM?8Ng-e zYS2wRt`y@cklA)$kd`I5a+Iv1XSOyDx*5!Wx*55|3p+YqADrg%&ffl_0Y3nkB%+?gRCK_$C?sATUnZORezoPRg`K=4q6tMOp_7?U;U#oDBvd*1@L1hQvd zyAJ9dYTw=was%j#^m9}cz}gy5oh}T@1!!?m@lr`O?RtgHuz8^5$wYEd@yl|^#>)|% zuKC+}nu;E#-*WH}nehqFD41va4soItNp=-J{%X*1lT$`6>Z)Vc5K2 ziGbf$L_-N)I^;6=Q-AE%iaZ(raU(0!ZfHHP*7{UQ5%od}nvSIGZKVl%Im*jni(lM- zLY_4%gH8@_%J|kABRTpdWb?k{b5Ul121JRQ0S^F{!?p(sh;L`ou2B34OevFFdnpPX z*Dp^sM4lquX$p@qLVjxuEv6FM28g~(inXd#ll8BIqGgc5D z-I5Kee?}I?ZhSYxPCWq=SN1t{yac&(?xFP#(rpCquhJR8HVC3Z329>N!-cCCW6yXi z5@Gn$jVilW1GhFy#LQQ(l@(V%m{nP36H%J5ga~sQ!wO~Rd1*JPH_tgl&-f{%r_pzh zvZ-Yhg3uV`(_iNGZzei?)%M&E*(amPt$N2=dc6vpNy;`=-w~^?{c4}4@;u`**R6XJ zVrNH~h){s@5T|PGmnc(Fwq82zrTT;)y?P;l{d>CqB(hb~aavOe6*|~1ZI}=Z=h1r9 z%J3Mk8vnRDjCS9+@*}%#H6OC9cbQ)}Bff1FGyiECPwQK9m(0?G-QBrGJ^;Xt#Ev`q zabu|Mf{(NO3+-DzPEqRZk`3Bo84<5<}5@@d_Ji4V!2Fc=Fx@rE@5gq9@ELCg_k) zE^J+}Wv~i()zlWmS7`TLdGPPmyi7GtP}!sy*(0zb@cmX8e-@>t0>CqAk^1^_@~H(i zG=~(P8jSGsVFMGaoAANsU!-2#Irs2(X-?7|_Bb9qi_UkLa7AGLJ=tC5>tT-LaRDh1;B|XOzseqZ|hA5jf zE@YvrK1!mKQORQ!rW~-?vs>JnUX+aByFTlE_lBN>u}+4o_FdTci8kKWY0mvHdiMxL zv*(vAQ5+7;u?i5J?M9H?WCFQ!@pJakO@6-D1?V5?TKobN8DQ!UGAh#{j!?Gcoy3AK z2_e5NbBY@arPb7rJNxEz56XD1=v`q)$g$m46VGJ{W;{%|dPr;44*v`4j~4>*tocyej=>%MTh!FyQZ>F2+V>NmPD#6s$0+xpdsxDhi#$8=S-M9^wF&5$PkIn4XocM6pl2#?dMdbJgZ-dwL4S zGi=?la$brK1zS0^z8n97pOLbUzVwR;SUG(!QRqF6EGw|z!P#X1%n2O-CIYM8F+Tv% z^Vp?)^1Yz1i=B<^JIma1GB#eX)k2<>2~vK8W`85>fBsQlCg8s*M&vRbE=(xlL)$K6 z{H94a&nN9L-nb9x+5g)Wk@_nb`7!M1_40svmHq3+z5OBv6UWDn;aVd;yTk`gh#*_A zvR2WSe78>5N{_M>tVu5emDKh&@zS2_Bzz!$r8clVESmRsWeai71NQoK@8q#+euE6( zp1dnZ4Vxard){la_RnF=5<7%C8wv0BJsqBjrp@TT!BI`~FJpH7lDg)2PpBzF9brL@ zVLN$Xbv+V9BeTgdXZN6gX#lpYZZ@qmM3RTY=7&m3>c=Pj2}_SE%#Y`qPTy{nuk7zO z_w#2uqTu4%rRO+?k?Qa%w_?^$a)j78zg~Ay*LG`P_l`Hys#NKy|sC)7RF zGE!}W4ZW{9$sM8*(Tj*4HVT}!I8Iom;X+q#p`ie#rBg{)3df^1#g$iAljYcJpp$El z;XjrU?-96Qr4bPHu~;G}TJ2UW=f`NZ7DIp#s|X_Ua;w44NzZ$0s&0mRc}DZcr=g>} z+9!X0$z_pQ@c~S_D>hZjNQ)|pLiaCll_IY5M~i)sR?odiV zaU=x`h8B=ix>JS@DJ5iJ=ujG@d~aNPKaa6k@80`3zV~~c<5+(T%ss??|LV%~Ixq2H z6T|;X>m-9QHU~BSqfCd{COJTaF1C5~Ru8uxNm2Lu_8TT%?ZO7h+MVkyIBg7v@k1-T z1FC1ZQo5l8R&Y3+C88Lo>w7TP?T^U1Vum+OQ`O+x0iN-vEq^W6S6LOE;(6%p7B3B4!10tb;h2>nL z728k$4BG-b*W?~3ym>$D9cRg&+ISi14V`xqpPOYtU@rt9`mt>9yZk8Bt~#ZbL4s7J zBzMicwzl$nFxA}gSCyHCKLf})dJRh-WRO&H___+ppK>f7RNY^}OuVx!s79@n-Iz6v z(d(nbM^cPnCqk1LOPaX5Fxk8+B-VPo~>3Xbp*-O z)2nnt^s;xi(dzOSpELED-()!hV3XOQ=<9(Amf@huBeAO)c~KPQgeuT!a3MHSJ~%RE zGxOlTLm6C8*5aD?j#jK%MqQc1xgV!zeQJtuMKYk_V@}n$G5hH8~OA$i8Cwa zQbyS~gM9CP&P0M^Bm#Vm0bd<(`ZpqvYH5IAa7@)B9!0LLiPJe*a5h^09wW;$JtFOX z2Jc7q-aU7HW^7pxZG~Rn1PPemg-n6q{(#&6mHp7S>?n-E*Vv1uiNr^eZdJIM^U7nW zxf2a5KYMVCHfg;LD@L!Zw!$I$Q82gp1vsg(+?gJnq98Bn=wz_bTf2SlyndXFhXZH& zxzoSg@0+qvO?9Wf;KXneDeB{7vCPAq$C@l~r z2%ozxjPtozFWygL_a)3Z@9`vIAt(BRlonhgFXFzx*IHz?EY#t%Bkjk_8C}gcG*p_y z(UCHQtot~zBLSiu1)OXC?<_oD^1uZI?HO<33GfVRIwx%6RL;SnO?sIljvs0rCWLN{ z7XdYfvn}2&J~jy&c!R$rT)%;|*Nk7qm8%PKT@b8#i-n_G1;-l}`cZKk`F~n21Jq>v z9NontXt0mO?9Cr$XnUDI*0(w*rURfWa3D}j0=*>Y@K{pM6bgt`zJ0Y*j4Q>>xKCbOogm18>tJb4*?^y{ZS4C9kS3ah8>0-QHXz zPLp`<8Xe&r$C_ZlgQ@_LlaPhHm>*b<5p-p%Yput?$jY50?CaaWZ0bhVRYYIw8t-vG zZF2eA=aLsNuioCYNAY2M2QPSqPP#dV;i@yo<3bhv+N);RFHBLf1E6N?yc5oV=8X-n zmUcE?hx3g=YOJ~lACLyv`Ih$@tVK*&tS3AllL<fX!rOjK z27QU%0uX6fkE||kQHygr z#9=5xb8WxcoMH@MLHc->tSTwtSl7ba&WlV>TM!?(HMC>4Fq>a!T2^48p}RJCw4>31 z$hXeJ>^!mkf&EodBwo*Xs=K7La%zH8Sc%_^gt(})9#qLd_dgBbEV%=kf$oRQ=;!?W z_kCC2zD*^zN(j-64UF+xG7-V9=pPs`e#U#3@s!cRlIAv)3Ulu=X|hZ6+0(z->q3~L z6o$kFN`6z(3kp3R-1m9!s*y^ngJVwlCW34h=?>_8(2RlLL~ z^r@Ju;fT$a(r_`7^UXNngIC_8_jPF@Ec6fI3o&=?MuY+SHkWg*IPGN`_tsI1O6Jmg zSmq!Zu^wtafzrXW3wSrI!8079DJ@=BCj72D0b}q*{C;eu@g|C{N?-YKrux3%v`2g8 z9I+S_3Po$0D%kqu8W=z`-7hnIz_R0ENYgPeoETrCuZtst)jEEf`2DUzmoz*=**~z(B=W?C>q@wOoOeA*@pJ?ZB&edNiFSwpMG?FwWc=xFmQ(zq%0invN6xUMplfhH z!#m#)(2wcM$p22hYwq^tDtL2?t`%C}SENxin%v85}S>j|^i7=4D3Zn=&^sTq=|MF2NS0cL`X&IvcuUfx3}u zcgAOV7H<0*g#tyES=>(TYRZ}k6!qX))^)Doo4>eK$&fyy%tun^M(1xe7+WUI>0Cay z{Wf@KwdocFg#5e-gWcYhzaFby96D=uIU->WiNSjC!|yoI(l%gOUVwnvdSH-dd#PWb zm0*^iup7^xk1-(1kl~@E&v2oiNMFly3v#SmTBkXo*hKr*yqrBAsi4G`l*$^HlDO4o zTH@Oz0Tt#sf1dtivT~4j{g;8gq$a*I7jkaH@Ur4heb8g3%nrzOIZN_aZD=1l~(FG{JfTLlc1e?SSpB-r*RBTXnZU0h2=6d%R+F0WQJJom!FA)-{GALtJnW zl&~92X5_&fJpt_|#H}XVIbuxOO+}qOkUf;eV{)qB!4Hsnky@@!a$s0er=uD>-LW1V z<@Z*lMV=VrDe(rm1;0>f`V*87WT$CF^YDn*aA8qv_>5{iLnE)m920+!OeUVqEX2to0MG6fvGAX=r5#_^JekonrC?;XXyv>sppQBa1drU}wn*;S?B-0$d9n z|G**+yC?oqxr941}1!g%T%=tdpF{|m2^c;E)E9tz)eq}sH>V9CpN z%`%GG=-CXOSqM9X1#d7ka{Z<_)9LgS1vY}YvQ?_%)=z?4aS0N-H`ViXU4ItyfeyDvLDseqJHE3R2 z9AfTn4fsCw(t=S{PD+~X2{!qHf?UbTWK@5N8_E9}++{d%%Kbq+l=~45-%G%69D{{X{ha|vU9hostM&}u2r|2$vfd)7cCN{9=%HEkDQ`M%TO{cFmkW+TbfQVz% zK_GF!lhoEU@^AV=|1M81O2~Xlgs6Qb-X&+J0Z}T$x&slz;%!#`IgB>|(Sd!^ZtxL@ zKHy0-N=5<%--N^Wn660SH)iA;1(p*4HRj;z=p^~Tq~y)~OK208qlqf-;X{Li=x?CP ziiUZzP8A1lDB5W!e<@#8tShqeLVT0uDuD>S+Ab5WC9T%56Ysq&@*~0e4ZBC!BSZ}&1tH&|}sd8k+ zth)$AkxDZDwqJ^I8vg=tHDF3nE#s#(v+~rvJXQkLZ z*Q%@&2dO8mPIc2r#1*PwoHFwz#iL~ymwwJk06B`eX4MNd{hukE2xP|g6dQU9;MXI4 zK7;3O4WpI z&9#XnbL?(~%z8fAYQAVWn0dRyrGAUu^SC%lGUNStY8SL!Ipqlk8486!P;nyOHcfmF zqS15+??{4pCFPOMzfMI}%UE&&U3a08IW8AdHhpGvN@-+nL5QW-tVCyTTSWN2%1s5T?o zG~fVt=GH=*A3x8uHgclCh3!oP)%8q~1@39PE+iMo-YBMZG!WB*t5}E)2T+G^>Omkb zwQvw1tA4;~8#2=DdOJ>5Tx;ezXDyd5rp2!;8Rz}gE-N(vD$FJL#EGboIY^KIK`y&U z;yskTszx~KUY$qF8Uwu?j0$i`$N78%CAPH*Andv}>w=tQM)TQjgO~$ev%uUT@vKbd z>8?GQzMikxI(cj!zp1uHT)?NwA0y@G7k7@dEmHsizWTvMRp~EX-#~W(&xJm}Nv7}2 zA)fKhe4PGDuA5!JR7-G3AH8} zwfe*hPsKvD2)fCg-+2Owaadir6r-QD4yEgIP17i|u|)_q9_ z+!6PADveWj#oO+jS9NQ<5v_e@mXMt^Ta*j#QPc-2xUuRiBQDZ zp`I_+z|q+vk&;vtEqgAnh{a>tXkd_q1-H)TYRWL)&OV?Fx8cL4 z2X(7w3*R^(4-uN{{L;^8kn6RSFn7<_$6}%^qfZ7J>*WF|6?f7oe8LF=BX^)Zon&3H zu~o5ME~Yo1mTM}2p-#2QPD?KSz%f+#5(GC*24|6ttM+LCi7aZ`F4$b+t znP{xrw<^liafZ;gpXv1(25O>yTVJf&TSJ1FaY0>H9lWi^0DR{Nuj9Fto~k<~KjqKY zV`IwYfq0wt#X_vTY)8QrV0igq&5wuB(<^+rk69J|h$_#My+Cl+Op@W1--z;u+;cc z)2fI(?hanQqRb<_2n^*MWCAj8H!z<}YTEP-M9RIXxIv-XN-BRvo}w2C!VLlnvd6^c zs0TC^K-4|Ek@cl7zJay=cv!xgmR%2`4~%>UBYl=16b@Q%tHsYY*TRIf)eBe# zexQU|?qlwrGU=BhGHeP)M4lr_;GoEc`K9}zhgtctugFAz{c-B9w0fl4WBW;sH_7$j zgLQQ+b=Gz79AGE^vMK;W-!B^&LYC=wzPK=smtuzJOb$q200@9jLSTB%0B92pK%Y;q zlvI3L*L#9^=|U03*Pfy%cz=_zBhW|fpSeu{E>B_VvL80t?`flYe$K$0_y3u!Yh-ICZT-*`{ zLsIkx5ilQ;U5&UuxX1zS_*@HN5fCsE%%mlw^;qb>AsF0KcvRweb@!qpDe*euzNk~O zV!HEs^ahhrR8zz=#BeHb62<32Zw{I569?b1a2OAiHLekzCWm7)teM!h^iYjlIEa(}H{X9?0H~(4V>-2x zueRiQ>mf_b-XCyADetHhfj))P6hyWyiB*5f2YUf%rUBKZjI?cjt8YhReBAl1B zlm5Snm8HUyPBVxKSfc;r<$}7fYkxc6`dY0~CcB>nl%1WshMsjAMT?~maoVZFbD(%b z-1in6GZ{7450Ym5dLVf>0&r?_OoQ~e>s7h0Buu~BaY(p%B@3}1xnTS>baUce`AnP5c!!Nmh3y^1n)fDG)`SJK<~>zd5X%q9{0n$FI|MTC^{z@Y?$t9CT#+G zHp+kB$|sKs2SD(qNiP5vFHobh-CmM@KzG#hLL#ZyVLe?59fw>ob55LtqBDGqsc=j+ z`mqBRcHU2f9r$Ixfe;h}6s?E|yY>?GAi*5#5i2X!H4aXhBZ@eZ^1TGUew3sKAY*v= zFv#4G70-2KVV6%+N-F&-@L<^&h%2O4Karp zD*5%nz8vtR_?wNg#jhNhe0k|G_St+~@UHVvNmeqc>$@ZT;O2JX=lUAt`Q<%+xMZJ< zHX_K3C}L5kkEm8=kSMF-dC|k+v9&rDNC-(px)YjZDSVrV1Kb*mnHk>3Lp*8rHQBp zN?r){;`S%_+9wX^H|iYsRgw1j`M?Ah{IH-*KdvRfZ4G|1$`|NANxk9kJL_E~9c(S? z0AS9G5(fuh2? zKA9LO{8QtjRG98);=KZA5=>eobDsDRp!8zgkFrAd{6%w1?5UkJw>eJgfH?qqeq|eY z`YwdPs`H(3n`-x12le>Z9ySQ8h||O_ihZ#St*w$ukE>y|91qWPQ$+7TK2~G#s29s2 zLEg*oeBjXhG%X%LBqj5Jbu|ybrSjbg+$i%@xQVm^h)9q1!_NmmdQ#E9zvl?p-Yap7 z#TpQ5%yFs4D)Q>El;`tG!Ds8+TUKJ-vqxVtJc|E8kZG|S+^9RUH#LcK#|%D+Ho6&h zGselKVmjCm&?zy1A;#ch|LS`Dq?J~=iT^`S%LwWF;5KZA4NwaBr26PUdZ!;i&Q}7^ zOK>+pINWPcy8oQ+=0}m9Tftm}657qDZI#9mpJ5w^A>dRMiiLNT`HGc_^ z8LOdn+q?t1gkuco)M=H~h<&xFl8nYI7W!b7Gf_^;=j5HE53vbgg|Y_2NAWfliSh#7 z+QJzR+ssw(%x&~YO6;vr;Y3a*5j9MzI%%k_$f8jFo6{PP&oa&z0E;Wo0e&^-h|1;=0HaPb9ep&(0Uqg{ z*YIQ=zzECJ10=_g7Z5e$&=Dtgz z*4kIORy=ZR+d>=UU`>hq8`X(M9oM&8nIt^jbZJ}k_CJ;M0tSfAj}MSP++YF#C-0k| zEuENkh^qBiS$r*kEZezjmz??w+7ZKe1^`0+7x~D}H_(sdC0>wYH0OU|=>sI~T9}AZ zho0w~IdWQ0BdtZ@h$u0<1glWr#Pk@u$YZm|`*7F)OXjiNz5?hdvPshr{#!AppVM}o zhvjQ?l0K7g`FOLN)JZ5x5GQ{M@BwoVJ>?!5Js4FJ%1u?nBlrFbdd6@ z6MI|pan{mKBu`ZkE1ZRuoD>eTpY+P-`gut}E~rzhd5xz`{K8Y{K!GRY_{Ba97u7$|`hXdX2X|5|r~kZ7>*3%_Jq-nA(0{=zAI6$>3nwt>RCC2#MACNZYb8+N9oIR}w_#Y7}W$WFWJ z0{7t?zDLA;zs=^t*rtjsSB&>pG&4>=Cpto1jP`f21F$OiF$Sx-@-%txwhVH;k%fq{ zIFD~4EW{uPpHskzqsE#ZpV-*WGAYlerTov~b|Gts>=yMi08)({zv5=qL)rAAQMl``3#-{?(!ooEt|MR&yCykn(Wpi|ubQ;(M4V zFG;|wu90Ce2UI?f`Xt-uL}oiJHqeaz4aG%80#+en*yafOl^WOURiwed^_Hj4_XUIK zFPuf38;wb?ka*MW;=5BI|39FcLED;IifGcEjZyaJoGT+$`bF`egV(ZfJQSBfI8ebs zWlLA^kV;9UI!J^$MAZ}Q)H)smEeb^&`C7kmJ0#QSPd9vEmS`y-bs2!yHm{S(k>NRc z6{OutCS|Heu?~npuhJAgQFwH&Qypr3N{KbGf;lz-QhMsxnf}-K=>M1hp7vltUD0IB z9DQ}x_*#OEZ7h(jfp6vjg65%D+SEX0CyyP>oGt2R_j;$IY&|nCP6J7l3n@IG@%=&` zgEevzYu4@r5QiSK`R>I7db|MNPy4Qe*Rs_^`L;SA?(3!Y{bz>m zzib@q@vV`)qug~EcQ{9+pFt!aq)7B;SuZKRy!_~b?c0E*I~f2_EYzGpl0agf?i#8> z!5jV1&pS)s2%$SPIb~dR;~mSHIK1^-h?WxdbHIgU(ftNW()TD*W56x3}V?=@Y zvLN!J8SQi_KBR!k7{Xd$$C#qveJ^|M^!1?IEa4x7?O0A-fU0Q=5V_DpSo*_-|LV@m zz>R12GMjnS2-73D%=&VXRL`u$G@38A-hoA`al8krW?Z`f7Nk>;(>0pqIU3_}B2>-H zeAX0tT~yyJQt3TiOd>CVUx=(~w9)AOhh+{o zslpYhqB{f_WMF-Nj9Bt7Zp_&eTJ4=>GRCSWI(goH^qIo>=nz&HfC~>I{KtqR6}1 zy~zYIz~?~8_0lO?bfxorv~pvNm^Dil_yupEoO;Uqrd|wSJhcwi%?-fS7f;`X(S1I*j(#{TJ1vPSH@XYsFp(BFIDon`F(>2A4klycjHbZC@? z?Lk*7VpU8s>o1;59+*1!Iq&UB4_THA=cBA;ALndbV&15q-cFsTV%=l>efW}Oz|I>^ zoEr`Kh=+U@F8dr`w4ie=xCb0N^8L|#B&nzCR^N&^e%)f)nQ}bhEc27b8jhAbu$Bi~ zMx&nvJRWwnw+Mp1^#*4m4mrL*o9}OvEJ4O-OF7!Z9gk6Eiksn!VX8@aiDYi1F$UdpS&&0aBmzGT=dHZ*>}oMpKYt3i%6V5 zc?Q&)&@b+nZgjAfQ=(_QRcDmJ4(3eErD_m_+ZTmi4wX$w#_)C1U46Q;gT2W8wMziB z-LMoTQWMi|_%xX2A~ONXFhK8OY;h@euoC9H{Kp>neLT{;>LO%s@1`wdR~YY&qqG6D z+s0#jw5STXxia)9dHShE-+TcZU}{C@`1fQ1ao02cYdV0zML3(XtzLXL;ci;bXi?)lZMkD&_$k4rxaR*N%Bvk`CBkgng9i+jicLly>Ohyz1>MROPVpalFOHW9j=D z{C$u1*8!V{x|$O0K>XIb*7mCwdDRWPdXnhq9!cM0Ve=;s_XXIb3XXVhMuWLgjxTDp z@AD4f@PjQaU3*Lhfb&-MC;LqT!0_8r7&dTwU^>`e&KAU-J6#fR74#7b+ZZmPk!|Be z|LKVXNGO4Y)m>F(C>Ly-{hBkQEVp8I1|+JegxFd+X+XmW?<|9_QVQkvtBO6((&15a zE(dw_Feh(@`ASk1kKea~fzMo|$Z1pd)-sY>f{z91!e%NppV%%i5{6Fb(+K+X-*o~iR=u#^X?*e<#D$*IyZ zGRl>amW#9rS?qCU;xX_OhOm2*#`@=CJYDc7FAciMsICkRs7l!GtVxs%cSDrOacER`p$>Jp~jR>J~Qs1GoM8(DP75 zszPEHLoj$aTtppErDs%Nx(#Xiv={l?T~Z!gkNP0SnDEDx94j}n9PJ@Q0knm(=}FSL;S~012h5&91nL9<2D zKgz-HQ-dU6j0Pi_i4PznXQ?g zH3HF$=TP<14o2P;+sYs|w{XMsPgkQ5IKn*D>unBrZ@!vneboYuJ_~E*0nh>r5<@mW z84Tag!`5rAZf-!js5&Cv8U}LT(|b~@9UwY;ZvC_+#ucr$^_!`e_5GOIhHpIj3r+Z^ zGf>W@PWP$Jil?LD(UT}Vb)I^zCv78!&Wq!u@NE%*0Pts%GOH3o$QyRNU;a|roHQos zzfv|QZ5;GpDVsmtI{8FjTFTyhRB(y1o|!(^-{FEgv+5B#CeC*~;_kbfKkw(jf0)Ro zfB+2tL}*cluaB4z@yjMK&c!vuZ*84J)%?EONGXlUfI~3#S6buOCv%FK_W^b&%@JbY zd|A+qm4{FF=UDH*+35!*8OyzWhU8rkGGFV52NkbTJ>lLdOwPy*^8vCVq(3XBXaQ~PB?8(aMxAOy6ag($S$5h|M8jg!wMRb!13emDY8$Yt|BxvVn0PW=R z{c_;`_=Anelav$JiBHvBix}X}XXLVTTH_thHIIJS9^?%ad9s9`IQBI@Kyq+}g^!FO zRLksW)6HFyQ91#O%2PSFPf|3;N7eVn77z0b+lQ7%(_a zzOhcy$qvu=5&vc&8{9kDBO{``OZI2>=gDpu?)@bBKQWH00JJpSr$r%Q&nR!_2W@zY z3mXm^_{IkJnCo8!V z+yeujlU3HAyDkp9{w-x?PGc(0_-!na0yy;fvmf@!k+D$oS=v~Rbo_gyfhRyUj!Kv*33#HX}(gY-iMT!vG&&8`cu|>A8KW&e~ zA8VG9y^}!dweW{8`kM<U+u+so_e=%+;zrJu(W$80hkicd19|0Dm+A2@YfUThI# zP|FR!!S(cW9)*Mf^eikWAHco-Q$v5^WTo|oMezG!^ZX0_bCSCUWCJ5b2=XxT5>8gJ zT^oAsQ6VGs7eIHA5#CFH8-Id3n(wutQL^s$$Y~VwI7vX+`CRwRSHl1}W?iE1&)vPP zlU3G9Pll=h=4`laou|n$NYwA$x#lp5r!x*9Y;Y^!jsu~fKXF4(R&pnKZU4XfI=@7F z`cKqV|6B{c69Z(5C&uHxPq9X7b)72UKJ^GYcicHE8ZA#joJMp5UyLU(aOoZ0iSfAa z*5|P*J24<=dr~~^`_4XAWt%6)17G{e4PagklO-CX%RiRU=4@6a9-VX@IJw=D$=U%c$iM#f^|HWE84#*sP6E}flZ0J1` zGe&5!UY)U?j#DN;7G=l|Mu~g=W<~hR*%C=fbo6yFSKBL?38s5 zIqy(AKob7U8iX?tTMO(jz-XVL?l?fKU9M#samSf7Gh1pnWfi)GlKTy9K%rTZoRrK^yq;_v^Hn)ExCvQYCN3!h5ihi z?;I8IfAF+(PJ~HghsgG@Oh*A+;$bEvRmHdZ6sVt%{LA@<{}8zI_y7O@HV;ItYEW)> zi!F{6dftW1h&(;G%lI|jrnTYiXj$$)We}J(CKE(NA^0(3*D(KD?nrSNNkzPQ@}%Aj z!F{qPWY@nKKX#fR;AVYO?DiZ=+uaP&N)LM2O#pKqs(LYxhyuXNzqOMFQtrl&=7 z#y>XW+%yW}2iK{|a*IZ(BRC}SedYjfEI#dz)}5vY3Z6bR4G(zgeM@hfR%U->V##C@ zXlR3Qp#;U}*r&pRd4yFhUyMjbSnII+mYsrOiJRR4-Zj3a;cK4uc<*7=Q7xTL_^QmT z80VqqQxYGSlfCoOC|i>!RanY2KoSp*fGTTd80IX{M;NhExAckW5Xa6S05~W(2Xdxo ztZ9s6Q-fsMbYZyl+tY{rD1rtAwy=O~&Fb~8x{eB#{`@#B#hjHqeM+IB9(u0UXr%!h zSikdga~kYDPTQo9rLT{STpXS&Ubwa>r6&e(ya*)8-FDNj-aQ|S<9RuZh(C>!6toPn zP5FtEGUpx)u$gX1FCqQ+K)H(yUYBwdA5&@SC#L+H0^?X{{QdeLGzZ!xIiaON`Wlll z?95vYM9PT4k(2^OtJ3FGlwDK-AVC#QCs4{6o@ZY|DyK)fa#Wp0pIdX1Qs2{fAoEpb zOKR)GFv)6Aqbj|UN^~@GS;n1HnIi!ch-R>>$PaEi=GXo0wbnyu^3E==o2|t%eo`aB zX;w~&J%yQ?b~+yIvn{^%4fM!_F237;#mn=K{mbX-97`eB>+x_w4Q*eGTHAwgmZ<@7 z*WwIv>n35lz8{Lf=x1ZDpbEiCXN;cyn z?HoH8z*+p>py{a(6ONj^eS8v$ffYm0DD!6|NZq)o_BCN$8OMPy%MSI(OjH@C{^S0TA|_ve8&-s4)<}l^Wi; z^4rvN6u@F-VvTCbL(eBaWOGc2;%7yh-MzhF{pmpyg|TL&(1&etE&xNLJMMpvZ+`)( z-Uyfe@gmY*^=mZxut2rr%QsMfPu?+KY>q=+9nE(fp#sy77mOoMH<*uxGiCt%RXxDl z3?TS)%1kF79qsuaosazSJ@8MX{O#Va?|%bf7;_Z7^$s{k3%-{%Uq5OZaAG|DIfqzbE%W+TT0( zSl0Y4761wSw^;Z?0{<-*{uT>>2ad1S%$BVDFZt&Iax>7%m~hx|a@K;2;o(`xBA&_dXe!Z*+|S0MoY_ZU9% z0_?(j{ReIHqf3pa3AybVE+{Gry}=pCW=?et zg23GKXDi8A|Ex>;#b4P;`j^6Te?rlxLr56;fcwd))kyAUH#%lQd$ zn~GCe<#ar_cD%f&UsBu#)mWuUA|-K(;&O_%hvqWAdNwwDdMEENf#up2JqPi3U4f5dzV10(Jm-m2@NaI!DH$!UKY7gf>TMO zM~k<@9F2O;pwx?b?>0y6k$8Whn{!2i3Za^>l9m;BPOv~Cyi^n@Ih}D3-{`eKrRMCa zzN=e}@=m(Y!{@l>(7iITjI^Nc9Y!4hglr~6ItO0`ORN|?!hDTTX-(M*18eXOL zuAK|WGqjwI=b2IA7!wa6{xFSXNXD%7Zs@snnKNj5)=vg3MWkg-!zdD9maZdVYPXFu z&D>_=Mm%^m^$iLhu57-dP}{$eFEfG;QtoLdOUXn}soFeRF;`e$S5$`uCYB@SV1dZ! zUd`n>%jIRpZV$EYmN@FTS6->3*ByDGIF52eu>-5L#G3$RgU?_FM|qXV%`3dTT{i&P z6C?L89%W)6i0+Th{RY}&{XkzL(|ll+JJmU zQ(RTvoWtA}AyU~97gH{B8Rs%6F%E2PI1l8kYa%eX$vVNQ+{e-4aNY%fcF}a^&NRmA z!5r;EM2FmN-R&$2SVM~IcdfzWb2Am)OKce(O zViNR}eyW6pB{e5es3eba_nl&!(UE9iIi+7k(XD-5_+^ndv8(7M6*>X*)we;;`V&89 z$;u{scDI6$%FzIMCQ*0FaInJ)ov@~Y_3xnw?}=cb#Gl>$xOwTO?Qp7I;;!_OoTuq= ze?!GQ1;7|#=p_u3P{TPueC||2o(0=3&J9~mAePMH9ldBjLT0-(dsvqdueSGf};3rZ?w zs@BX;Agpd30v3_4oWBf%Gj3~NW4jRFeEg+Bfl50D&?dts=hk_#{iQZta-(H#_4h=v zNmWaqUJJO44rIOSaJ+8)k~N6g_yGu4h5Z=lqn0~Cd0R=h%-4#U28_4aUU)MpUtnbz zl0l(TjB22Isj^I`_mF4HTnj?1ZHW|209q6FO!gzUs56X|0uXGXaV%qMxG@>H(*k15 z@vW?+&$gEO!ICw`UUEXk#(nOS1l@g}vI4)I_cn=?SetG!RzN{ z_U-g|mCuK zvgcxBWGAYgbQ)NWZqS8%UB#-&2PH+&mmcTYag;%GPzZ8+SvDt(PjL1_mdggOeFUZ6 zfXMdIzys5^>NHSlHwlmzE?in5z+(E>Q>tQ?;`g3#;W0=3|5YSPTKrq{e}z5EP918xY4W9~Rc z-(dyuHl-NbrA+sEx9ho2yf5TedYS|mk8ANG>+h zj1w|C+cz^!Y6#Xye4axE!-DK6TWD5aC6~6Vgj;I{$&BTD1UaL0iawkP?iEp4GdN56 z?ws^FIZzuWy8}3y)O%P|P-%voKmlX+;^S-$q#ZifBx~6%@^q6GQDa|=p&2PqY~;lr z4`p#`?NNi%Qn%Wzkr94EdlJQk%Xo4i+?%qDA_9VNupU5%*Uj*aiAU1wO-Ca@&^C@% zzuo=Lwr9mZzt8K;)e+Xs)Exrn_~TM=y^!6?bfp|Hn}-#~>cqN4#XKQMm`8Li@026;BX z%z|7K!W~1yw&Mm{(h{;9*+BM9r-Rhh!h-mH%S=j=fH@XWV3uZfA!wT}Y)^2*;P2T) zyvnB=$h@{(CkenDXh>|YzuGoM0U!nvKKxx54xTj6$8;)GZ_HC7SYgD`=yn-q=iz)6 z#B2uLuH*H`spnXp-oCk`%@va?zDYYK4svceI^hcEfWC^5 z+tX+IlNXF^njWzY1fw}fU_9k4#6j;#svdNc_TDEB-g%h6)NH!81o&RDK%)zhE@6FRB>2s`oUOK*D(yw&h0}LhcTXvuMg~UANqV=4 z(=FKb+~WqCl9KJ)eFMGK-Mw*fP-O-1(>b!!U*biU}X*Sk@W!t$B28WWsSo z1L!MUz@#c5TvAX2+nXh{su5Xp$A!{c?i}4vTE2V&w%)+VeAgAU!2}6yw_m~Q{(=8` z^Cj!`-rc>4mLl|yu`GkoCY(LGcaM?to%vuQ(x9ji5Nr2sb{`!{+5o~((0?Ak97s$g ztpg~gJ9XPW%LpKK!B_<3fuPcxU?YI&=&KjdM%#2>(g)5o*)g!~V)}6JC@cj4y}rLo za4aJK?4?8EBTrr2ogR84ojLe8kV9hn+F-ECsDWEqu;)yGxMdtO>8;Bh)_S|L{%l)m z)!p5V9-ykT%y?>oDp*w9*f7Itnfyz|l3V#ScEaxh+RNHCLDCnc!ah~eorI=L+Pz|5 z+kg17?vQ2wrQv?n(YEN}C!eE|JQFDPvH3M7y_nB1M`VklqHHH80ZVU?lEu92Y=C6< zbKwr6r!KfztT9d?Sd7a2DX*jKwYT2G_SLFT<{*7!80x-LGR0?FM)=lLNhIai666wP z5i+k+zOlCJEb@9eR<}Ft)TpaSp3dWMGv2W2wIb_+aD^%JZebn)=MBGmcyYIFoHrtDrh8j`SP{5f*f zWaPu=a*roLUQAVT0s#bgrLuG9!W_h>!JX9{bc;v0_&3HBo6iUE!-U9R1F8eywuYE- zEf5u0Wh$6eol{U?XFVSRT}S|lP38UsVLXOz8N5_3(Py^L?dOaQLD;)SK4Zja&6kn5 z;%QZMAe2=WVzeo}UNil_vB#%tSr=Qn$K*0ege+=3A`GK z)@Eo9fQXZ#h?@vJbX?yj_JRH2)9jf#sygg~^inv`smIZ<$ZJZH^wTHiT1(W`%USj* ziVesFM)jK!2?@>#eBq{Rn@L;m{5LP<*VX&*_vgj!PVkd9`%tVSF^mugCl$28;>(~E z2#;Sxb~z{2Sjjp+&k@%;UesDuOhGGjldBCpW(kPVQI)~8!L&2YE}0vUau%SauXB`a zZV&x!!Yo4xe)?2h_d714$moH)7=eXeEVG{2YU8fDbtPkn(cD8n$FmRoa%rAIM+iV}`{)Eq7kt94dgh@|X`b6~l%Gw9 z;vF042w{u&W`W4=T{CyX(yFJk>+918<)7vv1h!ac8*o!YI7%*dSnWp3Ju!GP^Y-A{ z@Y>*jzDH3Mv(ZMi1(Y@BI&F&tvDvz7%W&v{{@F@`tGVGgmUn=Df{I=}kOAWG(SmaW zFfUI{-Z~F4`J38garJC6h`U3a;y!C53v!9>tZ^^&6yAr3FRE|}=SRw~U3$RU7gQmW)REbX49jd%n0XY2up1N=!PV8Un4;^E|S7B?r4;_WgfXNYVT4$UX=_HtKWKE%f4pxg2hbc zy;3nHCMr2bk#IyQ^WK)yq~n24-Ju82b(X6jMu3B(o?I4>B1(3VAT>2aJkMakjVPRI zvBWN;cNQUmZ62)dTAKN)Qul?XJ+j(Mvp+&SVeS2!%-w(h$WQl_=U}HWo09vH z&TU?{Z6$>9y)f=E>HNWStq=%g20KvzEx0)-e7`O*kDprKi63rs_dSRu1%%C{T`;E3 z?n{#p@%_5&rkkmVTps)~_a-jItJRJ|l~eJPC0ESzZWUr}TzoZ;Zy?WXtjI&>HHExq zXtp=H4D!md(7BW=^9OvBZoL$7DmE^c1Zca30`S!YlCq@(U}f(f)bmT>D@UD)Z~_8f zqwE_Z!fA@`30jrD4hkH7i8fUEsL{mCur0?GFUlo{@%{2{=TNR;aR2+4`MaS!6nL>` z+Uj*0ES3V47sfUZl<~s?q_ORMyG%z&+v!?PhYf7EhqsaYXd>D}!iL^;*QP{4Tp-bt z^r>Zk8g$rc!NU%X-G7upMx7R=+=Sbi4({ep(i{%{fTeboTidgxe5oJR__coQV~5Qt zH95>4>0CrPB&DD4d=*mo)KxQ(s0BDM1bv6txq&e*B+Kj4%F}HBsH~J50V>vR2zLxI zPJ)lyobW|Wzc%#KQcQ-z20Nq4=!?ovZ{2!{-mzu`n_aF7V4)rJwUG*|qn;U}o1Spk zw`ei3?|L>sE$x&q5Tw|*tPa~7elr|DZ@Nz7xVPebfGQxswn>W9+;^TvC6bmYtzF%D zpDSq4Mpx>xQUwN~=EboLz5`O{*NR_oBSXhu@XJu1S%T$(=Z($Xb%X zkLRuC4V}Koe1vD|JH#J%N#ygw$Z`witJ#`y3FGICXV=i%o3F_DtOs}!_bbT-9;Xde zzF40C+`~=4A9+`|DO{jD=#UlvBAhk9Jg#`xPbs`XXaU@>(h0>Ko|R zSV`yeo8)6E%rhTW)m+qFQO)2aQ|;F|blRqD6-jz7uUq11+8k^K$L0_sSg(?z8ME~A z?)S2gf^mcmIEJ6>mCS`o@hOBPhEO;s#l_gKn6KFKDRWR70t6R>_aH11B0jxs=Cn1L zZMhM0O?B+UdJAw zsiGa55b`SIn%OiPClUhdB1$1s8casl+S}mOH;`YSA^G)UxP*Il}mD;w3!=x&%d> z|Gx7-3}yw;23p$mxCZER9j`X!pIFTImHPw!{q?pBPp)6_TB_(x72i`Z{?XNewdgy@ z_yyp;syb`!mpFYX?oe9z*!J+F!x_(@+f4kg1b8?i7&%Xz!l+P=IeQbb9_~6!kuHj! zdKh)zf=m7A3k>VmgAs8_9a=HA^UUg_5;PBj@_N0B^n4%i?G95@V^bR#(+{_CUBIan zXpdsWB;1gIfwgz54sBJ43~y$gp%UsEYA3UtX=5fr_vt0|x z7eU0Og?9%&*2h6^irnfkeamnqgMM1r?0+*)Ng>X)#CngBY(#ngQ zIPtCzI#8DQGz}38K5FU@-PuV+`8GZC!bvl5t-ZJ*lHZ9igFFqiuWP6V1_~$W!MF zPqnU;i-&jQSLBRxsAA3gNBU-9yHV5a7pns&$-r^3UO*$XJg32!I2=f9s0~PKX;ZM% z%C@s_vJae#EPV{zaEYgT_$A84FDNQ6$gDDL&N)T%gC`%pF*Ywj?)bYxiI6ATASl$S zgFE$u&ZLC8lV16pcJ|57F5zVr3U$aSs$`?c3nM}#iTt9BR15?d@21q5fkJD4sqopc z9=OK+cN0v*WD(HhB#r+B7tTGFLfU^GXm1!3;3q;N z)-xErOT1;wx*~L#9&fH$YbOrF`02x#aE=g$T*XMAR;Bn&kIFxvRW0`a3o}2E;<4Qx z>x=ACcw`A5CBb=a6$$jm)XL^EQ9I3k!!66THPfX+K;_aJE`yh)8O3GnfPV1ae9pcj z0(cC9ZPb{@vj7^T$aL0%oz>~_KBktnjVb>u8=cn7fpnK0*qkPDnhI!dOQ~N@O+n-a zCodw=H%WN_cNb&^k^u3??#933YOShnq`#?;b=G}h|Fu3_dJQj;oadaWZB$#{VE8Wg zL!^rH`tXrGzP|F~zqll?ckS{obh?~^mI`3@hP_NQrpP5g@U1EU8n(OsM`Gz2FOIQ_ zv#211(kaAVg@4g(^?3wpl6^zwcB;wv)L6<$!xttT-*H1;$7>vC_@%@Iu#F|V8FsZ` z9+R>dwR;;-zz0Nqfii|kh#DPJ@0-sCSJF5hz|OlRt10wOdjSH|Y5VuTgJMtzlq-b~ z*BM_m+2yG-SYXH^fcZR`rZZwu^v-^ZUu@QN=5a#Lbc>3nP54sa zIQsCit-~n(wUsc7zH2Q=&vXdvquiS=@{`0~c%$^Xcfhr)MNCG9%}`rQ*ojEc{Ti|p zAi9H+!6JjusqRAnuvXr1z~yej0;Ikg9D9d+3Ee0BuxsoTR;m{k*W zximDDJ0O9**{aFm{2|!OKtfRN-$ccKN2mGswym#(p#C|vX%$`B1@d-m8USAeFp2W2 zn<7Wq>qi=fmyTh3{@HmzuCC9I{qLgCf3r=~q|qMc*&klQ4{FZgG^1;uA1v^aF2V@9 zJ`s|H@Z3}F+%OC7?xH{jw|#}Ng=j~1<>~1RS1oS+Txzw!B&|sdPdqT|xkl}Ly~qT_ zC)%4<4cRIqM8sFUO;8>ZNlE0Bh0yaX@Tj~F;fuj?S$@j=$>I^VAbFB2 zULPIUq{GSTgIqLhU|2cKK?ayJvq`yfK-f1H8lztOP)1GOem#_xhVXk&V7W#`lsN#D ztv8W~ZIsn#hu2~Md^WmT9wC$b#{Qv52_fiS5JCDBt4mBOM14!CRpLZ{=Y=r)TQ;CQ zwX0Tn5YBgTsb15rD*^oZZ#2#uUoaF;af+?++H|Hp4vq4j$<|iS^ERF@?o@x3qO)1k ziwx*JMCO>bzg6Py`UW~0MlLvp2KMb!+m--K$Iul4ivxv^O^*_~ke46R;Y0%}WgJ4=#dg1o@guNS59%M0_+hPm-^&&R()8T5jT@`mba@1mZ1;l!Q(zOxy z-(@2Jz2`;wq^t<-00-emCqSHsZ|*{=l{=ciF@vv_V+F&nwR(uOUqI)8wjgkEW-!aD zx)O`iP>*3=kCRqxUHJfRq0~snyvVMsxY^pUqL!j!Z5N$-(P%+U?GfgJ>h9xm zt-W(kFMgyC@SLeOOKG8PfnrykuSiKbg zP}Fr2LNzW*g@FTj+<}ZW^^l_ql3;crj%e(J&{kUxrw7g@NWr$}&JtI5_rMPKuv%JL z!LrwJAOZX`=WV@`b|~dgcW11Kv)8FljP0-hIMMX>8gelFZSv>0eZmNL9^-@2aN`|i;80^S*k`t3H zE#kRv`E2z%8rc(HFblDTb3C(TW_sW?CnOx8VQRC*$NRn%cDo6;vjI@V;Chd(E8$;{ zQLCikJcTaUf0j9lYYi<0KGt|qbzbysM$)QF6m@pA<00;?IOY%D z(A!^bRJjqav{UJe1lhBtDsyghXCq%7-Y9DTiF(=lAi%FRx_6w0EXnqr`E3$a-_E;D z+ub>-$8x0>lMw#M`Q!~Z_MqSTH_M%tsKPrIN$&y)xyy*9qT>#e5EGv@%j3JK5!0jC zYDZICRQI~X?<)Xkz*C4!0Bv8dW$t86b5gX6FSnN&OsIfUsb34pSV$(ut)ug4vtv)<#vkx!E-VNrYUuayA7?A|_Zgs5i!$_&)W4P-%4VT# znz+gxjXkBwWvQwr)}lq*REhN$Y-4TcIv8FRKMka6)9Yc6t zhq6LuOrGk8htJ+IR59vhWbArf9$N_*dAv)~@kL->0(|~OblN^iA!3sIuog8Uc$8X0 z^Y?H86AWb6c}p7me9FHeea=-&!8J|pUzJH11q5_l=tCxRFzg7p^?%IpV) z)aa>7S|+HIxRk-k00BJynAWtz&uT@qsp!+PCD;!XK#t~C?~V%zFKuuH^xg5z3!T3vuVdx-q@ z_>y1u?7oFNDt~?7u3N*uAs*zEjA&v6yN$MB*%Ii`&{dDO;!F$IFg|PDJ{g{RgEu?M zBQ>!zRS%omE+ocbAVBXwoGl=G&GY)Njlnfu0wesF2le%-*JamYY~I}%x%XO^o6>U_ z=*KACnAKx{ewHH3CBZW~u9q{1b4^D^3@A-wQCq7G`(*JB&1q|kkRzukAWmUSkuM@2 z8~zt$&W#2L0Fzf=JRU*K^%vbNl3Ya{K3;BEsyL1`2p@l+mQH*)-e~y}$SqH^U1pqZ zU@W-S$*^}Yr_VJ1mMFe6zOSF9Pq(Jt*va4lhDV06Q>{)oYdm5EkEV5JL-_Tc_6Eo2 z-yB$l9C`ssY%qX>iZnj$Jbt?H@Zd&b+q305@9CB9imz>x#|Yp6_w+cHHUl!_!a#nIw039e`Jo^8k(24s>BUb{qU^B)q_5~^*e8h5FX?va zf>(?IJlEKK%5O`|+POpTZoo@12N)Emy;cCQ)jn!}YJC5^e!AyR`S#i!AfNOHCXA=~ zJE*3Q3UN>;U;G!xKX6mrP2>89l=LqplA;@y?xIgj5_c9&vT}y~-f;)RH|U-NJyl3W zG19i3zGw1K_l-+MQ}VtjbprDItLh@u6fkLW6}+hKleq0OXb%IR38~}iXaDz3m_^gY zWr?(1xhoCCZPP>4cMwLGKPu#-Gfw4-n(%^wh)Nra+MpLSNRvgGJwO)19{efzp8i*^ z@B#A@W-sFazA7$RvSleGnhG7nuslD=^nm|*_H;x02d40k^Lv8pVvB8vS?=#3hqME| zI!tY7OUF@U4)YDplX_Y;kzY9Q)DrgX-S9SN{#(?AYWa$ZEJn}uqD%@UffMbWedKO> zM6y_fk>#O&MSFuiI9hg2wn%a}rSQ$cDWMTeJVP2EbM7wC_Q`F)xH zi%<2lhc);M*5h+4>byzDk41KrC-@lg;5#S~xYFfC$Ra2(aQs_;A2@a@jGY}se9zn++%A6OJt>%zXEhorKd3=WKWSWNd5d7KmfMzw#f2@`=vJz zP9;Dmlb&s0K@fyi2Tp-nG~Ua3#r=QrZg_BXcppo^$ONLrG z#e%W6CbNAum(`||2dft1XR6N~hKwB77@@d}w2OE@+n+ssw*(4y5;`>W4s6T4Sn}Ri z4DsIb@vaT(@s>^ZFT>tS&*AASx?%j?0I6&!)>$V2LGLKNn3~p7r*4Cy-vX*3{~Y}M ze;M*W;EDgZW3p@j0sp5Hc&Qc(yl7-2nh<5M(5m*FHqDmBGuL_Q%n~x>mw?JdZ6f8) z0p(IUc1iDpjNyzPB*-b+QI>g5MBOQQD{PuRU_q9QltP@0_3?SMt3lqlqN0R=u0tk^ zf`yT1IJ^+{mhEa(tW(bo?PeJwltx|S(ZZl)gkHm)l-7LH+@CLg`p@>oD72NoTV#@h zj1KD6*hbYtl-?upl&)Ga37lL)9LRj-5iZR;-7LNrC4kphJF_(3>Ne1O`UDZxeTc6f zzW=gzW$!yE32^)M=~_IAK)!VQN4_+|W?N#N#n3%8Cn=5nWNlZWv(^hIFua>AcL|Fg zd~@$B*TUtV==NszsEs|$%T?P7mKAt+rjotnSEn>ZG)>qGf80TFN=F48??Ih<;L=;} z^Dy^U_=EOtTJD>?a_bEdp_ny%Ph@_oN+~D1n->} zH+b*;cE*p++XX%>UZyR!kayMRZbWl|a-p>Cq|rhyIFfD_&v}!i?D2v_TPc)VA6+j( zKFEuOCVi^L$$yjgqaCv3+=?7_V1WPUYUR(?lfPuGyfE3XB%iKY*Ic)o+p$TSW(*>e zLhh{KGJeYS!Hbm_>_S8J1oqz-qij4Ke{{gT&<27{PXdmn_`}NSxXnI3lMA@f|PxAuk>}Z3CETN z`qDoiRRtkh6`V^(OTj)(>rHD5q*3y->Z;1xMO5|C>x_o(%c+?xC3uPR#OBuO;w|yj zHTySyx4IvXua6&pL4Di$wEG=&ER_W~%&586Jj7{Nqyy5*)Cq6ciX)?{nMFG*H1dU+(4(s zRfRLxl;wt|OOcFoJlzJbZ$?DKm*3$;Gb(AffJEEwsGUzM_jf-lhIn-N%?tA5I&S~C zju8gi606;`HVwli9WH2yJw!f$w9rdxf@))+4qu9E#WD0Q9V;ddRlZO5YiR!&`0?eJ znZNQUNXWph!K7tr$g^pRXa0QGV!G4GGl~w%5c>Nu`bWcQ`A4@6crvP}Z)E(9$j^Uf zTM@cfzO6%j12+pXM?Bxz&#x$Q@pF?bs2AK0KiH5D4f? z02sq|AYqk^m^3p*b(qIr!S8G5m|X@v;a7GnZ*yxEy|gY*M_s4E~B(Gy+Z)w2X*$|d_vDi zZG%WI_q6{h`WDCR*G{Rs9~~=bj;h?%mCt+(FpLFXJBQw8B1jjTG<*k9EEOHDMI0Yx z@9JlUO^3kc^!HdXuvmu4lcs+G)y~wjdlsJ7<_sbq+gRqNs%&JZ5@N;^HrwhvOjj`g zuB)4=VPzN<;-!x{FYLP3l9S7%%X$}N$t>Q+Ocw2*xOC@n2(M0$v{)aOlUMci)A_>e z`>XGoKRi*v%f_sA%h5V2vA&VrM-~?jysH(szkT6u#x!j}^cc{BH&pghEWcirZFlOc zw4_cG-!0C=_u-9emJw&QFcoKa zR}VHQTU;v57fl!YN>`rdJf!>I1BP7P5dLgNLBzsTmL5YP zRtK;J`KjW7)cDcLpSLt{+de+tIrau@ZVb>kP7J6;HyCCEmwj;ZSndG9LMkT z$p53)<6b>%KrsqD3N@$VksjJ)YVXc%gOl}QE@6{ZlMfN?PA$E0DtCZ!%F3c(@b+_7 zAN7zHb{bqtPws8L$#y5u*#G(JI~AcpYFgiH8{d!1CjqG}txA-sT$Z=%j%B)borF(G zY_HhU((-X|Jb-gy%>;U3i8#fy*=#yMJTq2wEL0wJS)c|2bbPDGHk#=jg(};m%$y2d zc}k3^HQl6Y46eT=YECZ;HA48lw62_xeYI9!aRCaw9CJx5yy5vgoYu4LiO&wv?nD z6)rN$)0QAoX(jP3rj>iz*?h639wJ%lx?EPvP7?0Q7JlC|}oyN#}t+KI5p zNS8NKj4n?`fPrR*aeX99`uX6-n8a@xR1|Pzd)tYj;N9SuCBv;IU9oFLe(IFDxn(|! zRjs}{6?#G9%6kb$;BOyP*mma*^K<{2&oV-w4G*061>oSY_EANWy+%v+SS1Q_INoJ2 ze3OSj2MYgDZe#-5h*Az0)hN>WtgJum_Zt?97}sA%=46D=ilhH~8B6#zwx3cT9okkG63<6IAU?KVUuF<6F;C-nf@`;pj7`nJ#x_?^Zl?QUqHQH-%Jh^8Fis`O8{C6isA2?H5aO+$L5$h8loUo~6}aPxG(D zByX-?iA#NY#|%d_lGl#G(&XVhMeKWKdHW$jMJI2b=qFc<6m_Bb-n^uP2lFHta zs+oPR-d&NIjLOr~?e5DXO~d~BEG_|FplM5N^a<~?**0!)Re27%N!51jTC_6-EQe4e zuWbX6jgq}Yc`VxD;!w;4nr_#fke;_s9(L8Li?XYuGJd=R6d2RS;_L}7n)1js5EGDo zRX^*XU20?CqvF>!ZN95x!8JS)tHPPMt|F}>xv1Yhxi@#H0;ES=cOjtlLC z;NCJfSM3D8H}NlednoVbz0-5hxT)V~C-db@6V@xN6Ki=PkhzVuthsG9r$xS?iHug3 zZX!s6)?@Ic)*bcQ`PUg8*(R>NTISa@FL-{w_MlZ)7TFgqq%ys=I8a@*D=3E}PpFg=muCWlT<-7GXu zYUu#ToIb4PWR%|=drB?W6K-Fx}h(_gLWK78{v@U98Z>ND?kbV{tC z5}2E%iJ6%dyXx%$aS#7+<{8VttS0v5a)s14Uv6<2o~f~EeXm=b;L+P4wJMC?-(`gt zoPU3Q`%C~KV2>QLP;;sgK#d=C2# z0H?a)Kw`mHI=wS%Wy8|CVhMM62w?LP?5not4X^Q#@%Au zxn!nM+()zo5k|(^;)avhDZECQbTKN9Rg3NNPC&;xwP|mSYpJGq_3A}bjPkh=ZyQ`0 zcftXVAI+=J)A#6S0;sa$b#lzI;c!&WG;3M$l*Y-{!T?kLi$RQo%=>IwsZLFsuuJ80 z=~H~-yr!B77k~V9_^VZczPk#w0J7An7Rdx;Cz)_QXfsEb){iue!t?8Xuk}SbE2Hn4 znQzoEbC$bwNN=FggLf3JKh5bc+B-dEBW8OnYn1)e7nI!9V5Kiy%yzxA5(*+&5N>Qs zC#2)OtND2Q;;*}YYtPo!8S5<(7eKr}rzz3FHHv0z;@^mFye|KISpulDy7aZ>?@}7y zPD-6A7fqn}a8I9e0%QsW|0rGY9hYcHj;|^lJhm}E@FiBk6a9>i2~@l92}^zi%>=9_#>d2jVJyUc{~wE`))o8(dw`n3EkciDcn}{bg30iCybhp2LoBpk)o9-Y`LGGh=SUdOkus z$)3COu_hz6JGe5o#S*(J+zZC8JtY!TW;=-6akXDsJso79xAdl{5=o^S31DjdfS1t2 zOeRjEw758|m$w*qk%ZyLR3`*t0WmD_>$$O+m&+QIM1-YOCgEkDPR*EW z%2g8(@(ZGPxXfeo!OQ+v*|rwBHF2DaU25|C-m?X)c6B!LCf{ce?cfDGi}EOLO@l*1%z%3h@G# z)FOybR@WfI+^=RJCUHnG_Uz?07EdOrX*y%Ol;nFCo0%xXg#b=IB56V6((8}Pt?N(X36U&<@n0)TU+jG-n(JJ$Un6c^!)(=|A&8mZSD|;-@GR2<67x|2@ zU%CF?S@`J_Q9KeyPNR`X#Ckj7J)7oy#U{c^SiNwQ~NiBUnw!^L{m2t!$Dv)!s9hDx)=w`czxFkfQLYK2qV) zny$~WVmG6H!}K+H%Z-Zxz(^zqvLd7@039!|)n=RuSrgrPW>0l==}RSeoK2{4duaqs zVyLmJm-AsmrIPBbf)RMBMjYoeK`%|Cz8^k!x4OfCDAzimIw-C|ze{B+ayfz>&3T{n zar^sNMVb4UN*rI?6Di(HVP8Z`W0u%C$apw|qp#B~j?}rj>PRUlQLD|#x9B)d*FSLx zbLAYE5)y}Db6FBeN!t8tqcr4$#3LL+jUpNXiRJku>^30lYz|$=F8*x!Q?0 zsezOmLGQd7HvisaFut&>Nh%)!s@n{Y|5aW3|71Jk%s3?wlmqefVgzc=+9cD&c(v$Q zChfSg;`mAYoW+3#K&>pleW(Pa4s|lZ`E&OFBS}kA$ro-_dQWk>eL)iDbV2af2KSU6 zUb~qWuI?DlU^z&doe_AKKV>%%$Xts6!nuge2ZIW~5HhhIH~V+F=DL0$mj5KQ;wo2u zd0AVlzh<%E>;FTP0g)s7T@8u(v9V2BCEEf>taj^>$ndh#Jk@M5$fhudx>SH!dF$(Vn>n0c+@->?*bH^ z4Q$>o(3JDZP$p376WJ}9n2B&gsx!Zls|D|d>zDI{OkRx_uiLABVKkd?STYYRKNAv9 zH7alVBx(_c_ohm92^^>%DPp}{pukCMD113fMf>6f+)s&pTHRSvPmYCr`E^o zuHqa2MRsN~dKLLbvVCvjpph7_HhN{vRbR2vMmvjnd}^*R3Yq7PdtGfL=sZT}5_RVj zH3?1y3?~%mthR+I)|^XaNT<>Xa%l&xdUlh!Lyz4e*3^!r?;O_%9tUi-smCwm$n0ZX z=S}j0S8_jkir#XdGZy>UhR@xQS(ZhgGrENlHyJxUJDXSXJMGFm6fwTtiB!D2sS}%!Y_YxpyVM4j z(e-;TAKYgX1yNc?J!juqYyzimzR6Y9^6kt%6prUr6-)wH_D`+?vDELx>3^bb{^LYr zzPjx+mi@39%@0gaq4xGURJT^N=cPAVx386*x3l@HMfv@X`%78(XQH0I`ftIr(jTjI z{nG>*ic$cGW2KntjP;74*O}C3)~1k#$i~$`h2Sh78RPlhW%Fn9=~}4kEAg^LOoy|d z#hXolXgMfAaL_f;-lH@J?+-6-)~vZc75ETlCg)hkMuuJW>IPZ7m7vXz_9G3i9Ml}( z>#m={RX-`#^V_-b3n^IZ>)0vfuMhDsJtU@5D=r*}+@J2heZp9JXG68|?ZjdJ;;2P& zlo6{9Pp{jh%+c_xV=6g2e7>S(wn>-zI6E%869Y~n>vq{z*Vc2@sn3MH%8x%^6G2sDCmNOKtuRdGkz$64i!H z+gcspCv%%){6ELrv>je>jInjeN0)Rs(@wAy)D}x^?&&^Jk|LywePbk;GH!NU&F|}* zq5^;8z*9bjO;8~*jOsKdPSF$~)=mYlgy6M2agbX3hw>Za=Xg8Bxl~3$OmlZrJ)x9y z4U^W^;~OL2K^#E-yG0YCui%`vT3WiY2QWROXMj2g|2gB`?h}=~Rt5aq4==!`-H5Yr zIN5y{Jk70u2fhxKipdlKM^m`g7vT7Z@6lUuzEM|ZLT-^+5zVS`X}w@y{n+)x5{vi` zXwV(ft5CW=>XRLsZQ`?a?|+f2hmVIR_YEuLb%5<2Ch1^#3AR|@#vRh<3YE5r7vu5w zrsOnk#lDPd)!%JGa?NC1R>t34P*%8nV~7A}CUEKuQ$6Ij(h8(1R-}ND(PpxT|B&6N z8-H;0w~Z72KPvD<#h*rYZ?r^pZ6@U@w+}kjS>v=8&_j&G;yXyHVQmkwn>S}wAYG<0 zi}K1Y&pqs3ft6PnTHKAkuXO`l2x0;!$A1n zKox4ye7prE*tew$Xxc=*0%pcvuJ^xuP5h?>LRpW#$iwKfhJprl9&Puinyif8;@74MDaw z>nZ)HvLoesKF%dIG^)`oVLmu(5=HYJgjAHjwr6hl83Dk=Qk7YcRJhSoh4aZ$5(eJ_ zNrMMjH12eWb2Gy`2xUfZh}u%M#UpDEU2<7X?k?@V1^goz`+uf>``7Oj!lv}%ue>z7 ztA(At;U07Y-}QUqxQ;Q44}Gg3ZuAH!-fN9gdlu&X3qT}aJs>xggB#f3u^KfCKK6v= zz@ojN{ozx!rfYJ7H0^e}=T-FWCsV?~R7c#}v7PPM>dDAK-I;oEytrG))U4?Nsa!Z-1 z%0Jc6-^)P9s;h7*s)*6xPB9A#&^=Ie=GK0@%1O9u%R59!XjKqmWe%t znM}`(x|U_RbMwDO2%-^WbOcVpiqQDti!7Q>=(MP=<;$!13+^bt{Av4$AZ*-iZtG=RUmYUdvm%M&iv>oOoeI-)T zIeW#QHB>EAeKhxAJT(2Qme$B^VqQm3%`>P_GZlIQ)8diKpEv_p(C9zCkbmW!{Aahj z7(`(v-&GnS>JpkO+4;^iLbux1oUa{V13dA^3u1=0%0s2K%nXio#c7k=2W=qgP^kh* zjVGT9s)FQ`UXZmT9%BHFHxsY!uZwM+6&djoHd4Jl-=5F9YG>b8N_OyzJ;dX}XQZwU zO5AGrQj)Ji%U1IYTnai#*;a82q%J#Qp$yA^lP4cDyd#oJtz_+VWrIcm5yI zCj76ylFa|Dkn@x&#O@Xlop%6|MCW_*4Ekhz>D!`fGMp0NTJbQ>ZEzh$(xVS-ClCa@ z#{RCu5vjx`C87T8JmO120b3HZ=CwegsW&=<>P%oaG|K5;7IyUUCYQo*D`_TkB*ZKm zpW{AymsiCd00+Ni?ccQXvTP9~{YXa8FFx_YyW}FzWhh;!E_jv<{kBQG6B^_mV7Gf_ zvf0z-j_Z2p!w755L{RJ-$JQ#ay#&=3AI{q6 z)}Fk6KHOi8bD8cSd*lgoeC`B@fsF-!3ZiIZ{Pv5~2uZWAS$!{$ znIE8O6)89rWq$zIAwKW^iyhr3>uZ-|UPp&0Fau#xTDu!}pb6m7>9Y#G`1Z--f%G{z z6PfQyRP!M8M91`!VsNgMw&zaKLGUp91<{n25JVt10wZ!~ z3YB=TwT3C?3Gs9+37jmll5G1z^;+sy!Q={9_SOBNlUxwVA=hcTkPa}@;-EMYs;{Io zBPYQ*GdmXUoX$e;ykU>K6f$+-XUosbH*qxBh{QRAxPgS3B7lauv?eDoY@K)VA;iU! z#9w>Dl?a<7SGp4|eCRegc|KBgOzz_;a=XkNya!#-Nl2{5BO;tJWcBl>vC+EDnc6aL zC#e+|bgHxSb?;-(0><;skMjfyDv~lX)ivW4%E~u@ZrePCqUe8y_qn6Cnufv{6(k@~ zAQ2?mEoc4eYqLsS#4|nAA*Wu$#<1YQZW=-9r{@~6#)*4eUy>Q_Ab&B=@uY_!cApN*Kb^%wL3HNd9Jy7v6U)y1Vpu7P4{KtG#RrDzc1S-Zr1IlxrL%#oh>-&Mb#kXlOE#XF zs`g`Aza#O&E@?{LizC(L2dJ1Yq3Nox3_bM59oD4{MsV96my0=*EX_be1Wqi;hyF3c z7Fz2IzS|=W@V&c4rtUFF-<`})c2gV!Oh9e$rVRxw9l|K~HHC3js!x9e>!3N*ZDh`- z+H`QmqOM+%=8KEK(z@_3VtZ_>XKdx!}y<>^J6uM}nPo!=fj z<($t4&Cg-qY=^OLXahKBtgHfqHt4TD|4*+;FZ6pvw%j~PS^n9Zyp3$tn+<6q?3HhF zPg0)qU4Cv8xgrqXv~R*Q!ANvvXOd z#2;&s((fSZh3ji?*2a7bUq+3qrKLAYVM0Hx=^-X*`o4pRfG-PE12Pc<8Ua$bkKzSm zI7oRlIO9Uh;4;`vz>tvEJt%F_%~f@OS8@BaFr$rj%A0~-`EJy&-|hiGc>ch}MIiRh zn*vZ$%J8;Dmv8k1wu0_=2T=l5pSG;7vwVJQv|eJ#?g4fuq&72ef4pyGs}Ha_WADX> zYT_r*8=sQ5_cQb7Vr<$UB*{)ptW~*SWS2hqu!h3I2U5jMzlK-D6iC@L)G<21_#3^) zx3k_-x4uHhKO)HF`FT6VbpYu?V-~ORkO>DWlQQ(1YxqoSCQ!8cduM0FQ>P;WM)9;a z*ZrqK=;dhqKJ7Y$^yM?x_0_-RKGI(akS7PQ$G zhz*I^Dx;8dp79tgE@!31RvB-7d-RK(XU}I}S@NQqcDoVbwD>2YSicGB(~b?Nuaebn zTzPoogHSjV{}t~FGFBxf8Df!xTxoAcN%ynx7sV;z=iu{Ll12TnY}FS|`VH;13KBXa z;dRG~?&(tp#?oE%9c6>e7mT(*7`d2F{it1yZw)`daNGbGPTTYK00l?F5+TY{{)tsT z=9``ROCr$UeQT{LwI{# zJbHT%qi*#cn%d^TgLtn?T7qpc0dXCg5|m%^-1je^?c&7n^oPpjyhN|{QC1oCPB+x} zcwv8E0cKY7#t&qJ{&Qb`0CED1k3xXho}T3$`4^1x65{!S_m}HyY=E$%HemQO=l^s* ze@-a;-Sgtw``PuGww!dQ@gqVa5G8FdPU@g?t8^>gE9O1Z3H1#90_5$%FS+3=@rr(q ztl7s+{YOB8qY;Jl-a^Dpc*)F14#cZ_VZ+_x67of?N{uv z>i@ip%max2*7NTmQpk7EIg?z4^X{@+l&1X+?duKy+zH!1j{(R8^}eIY(LOFXR*L@) z`e`3?KOY8g5)@OS{p6l+Ijl<+{k#vQe;!7icKFqA!3zux`TujCew-&I&AuX6qLA9< zyhU`BSd=Ekv@pwQyI-!OBp|bn0xT;~((SP|>D1+7NC?9v&|_yf2ipGkm*Y;hx!wO< z+5fo%{;(A0tFr|>JUBTD_Fy=Ba35WLH6qlXElqi&c5|emv#l!|K9*LkkyD5d7tDHN z3`m}Rm;>BqrQa;?UvXtWUh8=PxP?E((G_!THTPE4SmlY(F>s5k!}CHM-c z0vVM0n>#Njmf!bV5D61fhe$a~x4Mgc^5XbAhtWiQji&8-vfuQ8;|D!*c1YTtft}7XFPz)e9$gZBM|< z8n3isBz}mh=WT6C3BBQ?15v&Nff_-MK+&IJAGD_zzMmHk+RJ~BTHCV&7%8*>Q`6Q| zbuex>>b-z<-bknIDKD;xhr(?KWgM&i3lmg4$kgf7t;PRbq$t>W`>dTwKQhomr0b2M zj#C-V|AAzTTE<9ODcwy1RSY|JNZl&3_5N?{`13dyP6BC=OoU8`h=nMIW|> z5Foo@+gnrEJ8{ZR>bGGZk2!2-k6r9v?KxtR#ZEgIAql^)M<-csyVsKgfx%6ZM7ql_ zMTt^w!{_3MkHEEfg{)5E<$P7D3n`!U_@P@jGM%0YMGJjY0`4awrj zJCCge69I00qvKx^9X^v!(xwedr_DYPA=0{@P)qc+6;w0hP>(@g!5zotkBoY`l^*vM zcmDc433BLDb_=uvUZ2!y;j00o*lpvi_ zdfRMACo7|p9^w-M0{-*4`&FGIo1zU7|1$l( zBn_p{&sCq=Wpd_Oo_MRlSz#va$2Y^ECs4lJWoS1RqU7RO{^4`g`;1r(Bany&BbN&s zox{hhbX~lK#jRj8I00c4(!?6NnwL%O1=M4);g%V)g&22A}jCO`?6ZBq7r_tZTJWO=;HGqZ7ahdcc)SeGUvM-{19 zMF8Ju4S+^AR)CJph~1_8wi48tdF@wjQN~`8u^Q9Cx^j!KDj^5gnT8{;X7Z@uxVTERryU^3f8<~n1CwnOoEeitZtB`c^ zsyyxZ>knOYviR(~+<cEK&NF(bVaxKPa+8_VaN zMJ~z*r=mxxMe+I`6@>6ly9GI@yfR4t5b~Hb8~z>S6X0K$7ZpsXe;3wiODXZef8%Y( zurf}n6-Vu3x!US|HM8@H5BHUQ)<~Z9$<&U{`p_I5kL#x%74T#EcsaKk!JKPG&$m;H z0Co+~16m#+@C@ibbz4%TxMvT;Tzx)0TFE^Nfvr?%(!dWf{K-s~yj*TOnSZWV4^QWR zRcfFzF4bX2PVA){%S+9pi~O^^V;>0`1Ao+47XThnM&i8WkypHNk#ULd?)r@-3Y z%f{cQ^(`ozAE660D$$eLq12G=uy?`tlM#aP!bUL>aqq-o=eW(Sw2Xodl`xC^4pi@y z$=yR(L`XPuA4u%GO%+mpfMGxUpl zdhP+r{;+1GvcrSyJ-+BCP06lJH~SVNQ73RH2XRHI9J90d0K07cn3ufwou zOIY%zwaNqQgX?PoQHswJE~S;A=!dq4`C-j69JlQ`F2>Y?SiJ8S&&M@=^OJ4@n^bb0 zJKH-t@yy6j!x50IR^c7DS~I=s++Jm6$m6U?E!$0I`EoJ2N`Ya-?yg<=8{iys0D<%0 z<1>D2_ljx-=*ictCYUZ>?Pig6X_wmPfi0#^)k)OeX*p9~<7QBFrn5_^M! zz@>9m=8(2F>i*Xf8HOL|H~X+n1)%g7D1<|eO-E&W6Kj!gMor;C^Ng&})wHD$sgy1W zlFxOg8VyiGOR)B4mFH4K$*2$BX_Kegh(psI>1qe*-ds*V`Z3w;?jL))^I}szPyLK8^ z5G5nm=n6eSkXq6t_mUz==a=2FtdcT1JDfUVozv=*#@oM5kYoY?M{w@XZw9YVurOH< z?u0ZfGYrzrUKV^K^MEbNK=tLSg(HW`R*C`x#h({yQFw|CcH*Kwi+4t`;Cel)rV^@5_+PT?a zUZLx^+n{bZ{>EkdLa{yP*4g-y0FsAomv3l&qE-hrZswvU&j94iG_QsgAX%|?m1MbG z2JyBY-|@)~=ldSHn3`&4w7G=!Sm1xqsTF?Y@qS@}`lKS2=pZxM#z$WOkwlR~JUsaL zgJKHsx%1NMKXV?#vov;Ma7q)3vWK!SX>xdqBz7IvILh1)PLGR1pE-i4K$mqwK%^iz z926KFB;%m)E0g8|;lyTwdsvSohiDELQ!WgNHAkWY?^ua2+oij6mHEhHA9|`P!Qz2PW@Mr02Hj}5@!7G0m*Lz@=1)mj9OVL(ey_;Xw+{1Ult{|`HAhst z()1m)ex@2wEF9k#v+d!>9|Am44#}beAW+EE%cxk*p7Z)rvC2GmRZGDO()pWVbNPw@ zMj-Ex5h!e%p5tJrFzRs1lAfQp%}A)J)mYs5qfA$|^Gvc|5^#Q~>;??qb%`q{78QRe zL|p=e=LqL-k9eA_h=32uEgWB=gM?$S=C1d#mY5XVFTd0xZ1Y*uB%UjlN;u7LD$AUYUsw4&QcUwEY*x%`|y|p^loZZM6f$d1` z97GE>QJ!pK5k}8eOU%@=WT;(G$r*FHdUOt(7l(D$c-gq{k|gz|$(n!7QG~sPrbqEm zWgC?&2gaqBdCu8$CFacp_8F{xaQUMp*>pO~c7wah6pH4wyC8e99Fq`0hoYEvN+R}+LkDcVQiuZt+cHp(3`=1vQAvoeCc!ySG{%#;+h*YLGaH4vLR&div5Q{^#U1_> zwV2bLks%p8r;s#}HhoX%pMuHVy}=51QM-~hA+46>aR(eL3w-QRqip}0r->e1gz^}wg(+{bV~7*6Xnz%K_tu* z)C4A?HTzV>;+gmU7tS-7n8+&=uQYnJ$&Q1|ePTWF{Prm(CbmlV`)6iL-GQSk5vAn6 z&?0j-!sN?r0;|clN9=yzEX5(8ivc;EpJ?I(!mkJ3mHaRE-UF(sZCx7<0FNHP@W)eBS4Mo}I4{e=E8HD;=FfM3eYAo^YVDpl5Y_fLI4B z{ZE`fw79Fe5JE={)3F`O2g#FPAq3yzcpQyQ(H?jL-T>CslS0wA=Sc2M@P@@LGN+pb zY$IGB-x2YPgR!`_ks3%yiiLL?1!JieXBG!t)UndjNz4(>&#X$UhlSW1FI>Nbr_p^D z%3du|D9|y>|0y}hi#NL|NP+*7Y>S9vm2vWws7P@UGW$g|eC81mI*ro;@0CP6T1DV- zk8F=&Rs$V=YSv|?KzG*MH9*O6c$=*dEmpXW1-H8JdL(CB`cGmB#y|(enY_ZFBOo^7 z7igPE#0w|pw|dE4q42zgVP@kXD75opK;t{uAsqbSLO7Y=la$p(q!&76$-(<@sI$53V4lnUg?6&U+!dj?&B{>eVtD(rW5+^S z*2fHCALj%7_EAviN3sp2kGWHm=FckTv==LKPAb6GU(G0)EcZlP zKkcn)0d*LmC+F^N#*EUKGSDvd=OEVZ2fhDHCg2L5q4~!}6g4r0zRpSdiLjC%}Jj}0KTEyLa z-F6}^6e8X8*(0VSC)b|FJAdNoTdgmp4q)gg76324#5}0YikJ4;*XPEWT)jHU`WyWP zkbdFrL`6k(Vp7ZlFK_#cyPtQwIE}I&M3Q`ABznCdrd7o!$FuyQlCV9~+w&YySZxK@ zPfz)J8Excjz+9mWx|W7W@=5zK=VRFIQJz4qPTLOs#f2hCFu(wo{4MFNE5JC#S9ZKs^{ zvT3%If0Sg2tl$oI3yKl0@ARe@+YkNdw8gHT)pbPusNu>vrz~w!NlVYNy@4sI<{hE z7z9ZRp^f4-$@{dj63F53t0t>1*uL~Ix>|#Vs}DaKvPWO-r^rrcOWr;p%h=$)`9t5_ zVtk~C>NoFKPQKjnB0vOACDN-xG$LW=N&y@h7k(%l*UHYde+Fu@h|6hI1YGMutTL!3 zXKehfYikTY!Zne^Y(AG~b-jg|V^q-aTko$+2aA(&K1_QjI$i>EUZK+?;u8;gzRjv) zKLIhTdvKjTcF=gY8T&TelLGJXD5P^=10>=KYFPWI=Wzrr^uYfiS}JMzP4L>rcDy&) z5_4@!x4{n32<4G}D;E64yRLNpfu^{M&^FWAQ07mp<0Bz6Ar221)BxPrF8nNL*mg2< zO|UBv#}K*-Y--xXaKfuD!^_rrR3zM-5a&jGh@+wGG%s-Fw4XIM?LygyrO!z!Y|>!1 zF~Td(;}H*_O->57k{KAnK0;%+(q_}Qcqg}l1V4zoo;XjBVeNI@#q@6a)Equ!y92RI zs<`Co!rQ|@1?j-&knokW*DaVE_Oqwv67OQsx}2FXSV|>g)9qo(*zF(?6}quwF&6FO zP4e42xl;em;J`&ax9xIJ?<0YX_Q{wZ7&uX&Cg&(JUJH8(AUbNbn+n1hUfN}KeZ8*7 zi*KYP(9Kc*Jo)M31w8dr65&Z6y})L?d!Gvw$T=WJ zS`Z7ABPnp6jd}S9#ftkg36|QC#b#}I-06=-va^5sbKRuU%|3DtGfi&P zW|_0uZ(ReJ@^5W=tv5NJ@Y4bCq%s zuY*qo>~*Y&7mZ`#C2z@DZC8AKOzeK)=^(&JSiA`+I=dfu_N_;Ti(T~1Q)dLjK8Pp0 zm}a_m@}M-7!ZFmM9!x#lZ_+&~C?#8F^KZVBS$<4_v}D-S!JXZ_VaWDm;u;-ywK@aD z0V4U#e*4bJ*5B>~6JoOnCjsEJqQ{^YvE}(NfWG{jB7GKCv(I8^RU3NN@p9)|bA|Kz zmY-RxscU#^^<=44_&cahh)q9+g!7068o&$Mc0>eDtdhU%=5XeR zs&Zjk6C)gH*S|a&rNa^jvyKziqTa-s=F55Y%bhn*wT3p)!B`pmP{FUPdYo)T_F7ii z1e$7eGzp#?=lZIs+(b*tn7~d)y3vg7YqWfYe6TwptP~QkkSvj*V`^bM+{L7 zEJUjv>x@5}Eh+6|OFt~N0O2_66Yld}SL@}2Wa#Mtbsxbx$Ru}L?&`|b759mc#C5$> z?_Wp0=6H22`BU3#Q%-a1Zt~TK%mzOBDhmQV5*avIyh;B;|820$vWvMqTvhJC+VplJ3NV% z1?gsuUAYL1{S~gacMD2JXbcyD$)IBrC<;tgfN|&o!$^n(Ia5{hosarSrwJ$MT-w`b zU0{n%J#@_#{kt~I)@uAwC&@&)458yk@AFR*$@(ogChllSc2*3jxny4V=Fb%rnq!s1^ofogzCdfK^2h|WOESd`2&jPb=yrDYd{x?xfo)7q0X zf<;_B_v6iO<#j5Jv5yjhL<2o|`RC9?v&)FnI51ik5$R6$Bzj~hcDT8$KktX-JG4E@ z3q9DPBGYrBj#RO4VhfFlX%k}@fy+HO7cO9LaGO=FjgKcAB=ZtLMh}p4XzVv|p0NTQ z?yOu(bOJ;SJA!a4P&<;Jv-0bUoyb?n>BP~%sEOEnz4>O8D6!ze_?9t-8bbi_y1ew6 zc+}Gc^eHWtlWk*56hoCNI486oszPDncMICA_l^)0hJ znnCP$`zr+e+dBIdVrlqT4*Ds#Nk_Vg4EjyhU_(JTeP7p;Ui$%GMid+-KN%3I;3_GE zO3DKfbhqR4$x-AyS8Ztrj`4Lx{no5TU0!zk++7DplmaBe(0YomWi*v@-3XU1g72OHWZ8xK@xJKbEY3lzJ?X%E-%v}4J(Ei zwMK?{q4hSo;<|IflNQR)s+^8&M#JUYLuT*ElbvcOFrE!)Vwaf@DY{ggZDrg-a&m&= zxE_U4|#Fh z?1V~d+6{6IAFY4T9v)$oe(D64DeV;{c?=?yFDOp2aYAw?L_LApJpu6oRu-(!ts1}7 zR;-VA3x)FACNQDOTiO8(&RJl>cKyC4A3g=aU0x(=MZ^|FcSWv2fx5P9OY15DE!TKO zU7cOCuJ@&X?~TGW#8}@sksU2Ul9j6d3lx)`!;^$u0Yl-R*mM+LM;mg980+YrnQxa7 zm)DV95$Jmv>I|Lt*BlynwWJ(-R^??5pQeRd%Uj<3uHz_cC?Cy-fDVoJg_~Nem+i;H ziQW(IyS5ZB*dM5Eq2o-4fO^pD)ip&9=_V;!Tx*1vuY12UYjk?(C4@$J)*!?xv%pGI z(G!a0*|aEMVyj2`(EM6*g`6kmuK$=$gOV80oJ2k{u14#dMd;2-T;Js8?9EK&WhJA_ zA+GLrv!+t873g-b56Bb~%HENGzR;cCcW$iV$=K;^YvZwZt4EEFv4&)hk$B@()3ZC6 zsF%14BN{iJbWfw~Qd~_=;Y-#ycuT6_eZrj^Enn%M>gb@S=V`KpnUKrKED>3(hA#$`?Ik`Fc3tPBL$y>9f6D z)ws+!8L<-%dbXZ+9zZmZao62u533~>DR+>jjX!SUFj44cnv^B|7RFewgyI$m36HZe z!1;xQnxtpGgd~EJ>fm!!lpg!H$!*Tm^k|ZTD=S|iaNO{E^}aKf2jv7a z^|{|5@7NuD`O*8c3xM24vD>h6gkbl<9;o5gH&KC3&=vRgMI9rOtHQ)1-BKp48muY! zpN&1|q216X`q_|(-(6*#-Vn(tL$4*ZJb<;qE-Nw|GKB86Sy>$L=T1FXKK2TGIoq7) zomI5EC3-*YM{{uC+x6IUrqtDwahqoAQ^fh39hXlVAClO%OFD?T7976aXn3MhQ*yiP zvel)*`Ohp6cSa&Z^c!)rrAb5debLTNU!?g5&YoAdA84SKt~jS=s(5DC4+jpyg=dUN z`H))%XjrTT$OSXMKt`XMXnEy^Qd>s=!qDK80gXxs5JlC${R|`e+ z%R|j~dklv%Of~~j6BrNLHV=#-vyyXBOLf7?_QFX#SThf2 zPa#3YxEcNEpATAdze4>OWdwMbNkI} zoy+$EGfGOGcAqF zq}A7rk(BKa%xC;Tt(tSV<}c+Vjj$1Bw%!mN%=Wi{NJ>>p|;vyE5_q@bH-$w z7-iAdB)OHgNWI?ASXFM(rB#1SwWH3n#J6OfWAlp|XCdQi6BW$U7|mEsB?p$~xL=*8 z(uV896$xZ&DQINbVtgS>ibeQ?!bF4mJzNv3p-8-5pe{h>Uo`P>MCw8mOWd{AQ7zen zJ5+Y3hy|t!g+lt;78%NxvpZGB>&b0?O;ges|3mco!4P3=N@>^y{naond5;%m5kSqc0i?RfgEn(N$ON#*2qSW$Gf_u-A;3tUocyaA8izQCl8Me1*(1<3?o|dIBVz&jwM)R!;F8FOpP2dx%fA_$_yI%R z_YT0rBL($p3NlQ7zh#GslCf4`c?Q@n%QJ|bQ`}R*(wJfLLku&{7p!?{uIiL~YK0R{ zbO{#ItF?{LA3Rx;<9lX1+$(n`RPcsxc+~|N)?bANR955f0|AiLUjfU1mXd-M&v3HXtaGsi-S4VnZ4rQJwK9LUHerkS7btaBD{4aJI&=VXeNWO+Js zFM2$D5XD>PJ{Ay)M5!oBt2-_(`e|pUrB+Oil2)uW1IYoFpPsrC;z{FrU2Vr%wkxaM z&~5;-e5xCspUIr;x>~qN>%xY7-NC`O5xY33J($-SyJDkMmt%;I18N5aH8`x%9)Mvs zsS)2bXuwp^V3ap&wR`wR;Xgl44ICo--#<)VG;l{Kt&zq0(L`%Vv@F|(J9@)cj4U=i zdwnYzL=HN|6;4MV#631gMj~{JF@&+T?RoFXk)KjrrHX~drUt$DUp={P)yJvujZ2AbU^U*ThD z^3N?xJ-Ht=_!h7nGma@ls{BMQgCizdbr5;zVGL*gl*H1-wpZy6YSFjuB*!K^Cv%}_nQ!wrgBF)_ z+3oaF7|486sYV<(&cd!qHTesH@s}P}f^8H8#=q?|;C&dx^l0o+gL+YOmwY%qJKL)3 zfo4F&bBC4@7)a*37G+uK!ym_eayK!EzW&JO7eXBuA_smngJrbprYZe&xl5TzdG?fD ztCiZD89-A!`IqFBe~+w&MA3}Vf7tZ!4E+(;%=JX>8_fWmPTlGI1^oYd+ir@w%uzzo zEyaR0Xxh?>G5|RrG)?BSDdA}FUUSH4GyCnA)zF(6W}(wjP3YoT&k%bTGp%3=T?wk% zD?#VrW47mJQ7nc@9d?>7i=lfAn2%KltO8U(L4XZZy0T_ptPhyMy|A{SK(0NHhp`;5 z5VlEb;xEVSlUl5VGhBsbEjT?_lQZ$S@NcC4{BWmqKC*(zLI+G1-(0*3&Se%{>>$Wp zEx)C5+7wEtqC%waaR=a~sT&$NiCF*u1_1z&wMYgil-M9eD)K9~4mvH^D&zWQDlWlE zM;IIj5?8EJwyyn55c$@wR^69Hd@?;Q{S4+o$>g1`uA}h=Ce+8>p*|Txnx{GY!(F%9 zyMqb9d#HO<+a zTTYM(q1-_%bb8>aY-a8SKJ z$3Z)FW#^OiQjN9I&VB-5-1Ja6dK)$eFFo@>_bbG~=xFX+P1pC01we>kCqjl z{|nc@@XV3emDPyS6{9OhFXel7>5r<=hCX!zcg3!xUv!s*j=%r#0bqWaR>vKP_2+tvU>vtHzxyb>Z*#H)BPrhq$d8+yoyT-1PdX2S9*T=)&GI{ zhlXbQXz<@(|M$iJyX*b^;Qc-9{5|OYJ_8Ls3aYs!8rQwm7T&B)@1zYKLz;yw{}@a> zIwdEWz~7P6$%UN9^70t1DSw4{fxP5dg&$f5%vjdAhVAAnM_-a>6u#S52H}igLowGL ztY=?WyI~?8cc2Oi%fH*Mk=|F}Ma%~p?X5~TM|{7XtG3c|M3wA_{9(5J7v^5h!%U`k z(tm&X-X* zNkPH~DoC!ZuEB-oxh`^^S6~^)9U=2)35~6W$B4}x0MEBJ>|8C%7+?ESaltJ>PNpYC6ko8<9A)5$eCqV|DxNJk@v(X9wNjJr7TQ2H{WM)iiYv~5w- zlDKI=Kw>8CyIgpvq{`7-LxF%B=kKn^9EHd$(4TLpAya68LADL;i`+hAv^y;Ud0|#X z5Vka_NS&0Vrkx!EQR-9B=WV*(wz~}68R4_7}LAF+69wYy&6eo?RywD#|jnrGGdlB*o_(UEq-h5M)+GyCWvh6p5 zj6y@(X^dLl2qfPS*IbV{3RNM3i6d%MR4ZXDn+9rgiFF1&CP7j{@JUz6S0VFG%naj8 zA8s8uFnC3@sWP5Vot-A516;fs?%Q`)L!Za?0-{LBAJF#ik@x?}_8-iO9?;%ohuh?u z*y+(Xay!_GVfq7aRhX0eCvVPk9D9l4{1`n5?Way#&y<&&SH^d12(Z^xM35E>R@qiz zP{u@v}kk-K7yMl81kPv-U?X#(W>j;#M32sFO?dXmqPFVQzmmz*JSjKmvDCHsuf@(scP>bdmRO5V6YQdEsL_l{4 zsqp{`gXNx7z`22>%*}>xkc0M;^fnqezk+pb>qsy49irfU&zaWa%y(xL$*5rI7E)%G zc=}X!=OuZ7=Hd^Ey#N8h7-8MPhmB5yG>W1&7A(O2Y5A(UpOXm+o^^BGqtF%Ru!JvM z2l~bgOzz#1c$t0owpcSz8!7&8?88WXqmAYP+NcG^dL@W21zKJq^deLszjxu|)mv-|hts5O&*fHvi5+V?Y^&zrKp zugkq4N5Ds2g(r{M<`_I)OM-n$gkN%)gO_*Lgn(KE6702?Jz6#1eGOfG)Ld-$oW{bnizGRHsUtV`ZkL!lE`qx6MxH}cCjCTL@0R_jr)jx~TP6Bb z8Z$e@{mCNgEUQ0aA4LXh$8hnKWD3(wE;v)eNgq7OduZy}{yIImwv34Q;|q0pylGm} zs1C-5%2nky&;+f1XLX-DDOCLKEZoUWcafXzSzVu1%a<)&%HYy7S7=|=y@2XG_v-oz zDJ6e2$OPQDh~x70%`yu8!Ockd%RUMSs2RE@?gRW9wRaG8qQmQm8cw) zy8jj8gv*vPoYe5^bwP7*2u~?9p<<4D6vz{x4W6o3A1t8wDu;dUj*}mw4~!aQdpCrd zpp5oV$+Eargu>tYuvik&pQw-!-=wvXSV=DinazgX+Bw{r-FdG{wls!nXy{B(h_4hMQux>{@T4abekq>c zEikjo(s6(@`-;{_(YsHmXlyceNW)J}??|=PVcv>$XQjmIn5#1|P;0V=r#~kO4gWB| z9GLE~q;+TLm4`D;*Mi95<9B=`RDtd%=(<}kzhJ9?6T|4HqZNujRU1*b1*`SWQgjK% znUii^r1ZbJ7SNv<))DJW{Za*;qoyw$TT$SC?p7(fLQb1r4awi$vz9BVB59-=`p#Tl zi=d)00dhj|Aj-qEQfkoQAY%N1kG5+WTxgoq#6b6CoXbSBI$k3Kp+>}Wat&Rni<{IQ z)IQe8;u%e6(__e*r)M;t_HZlrQ}oN!JUP2DiE7n+olYH{-O>ZRMUG5 zrdNf-EHyTkdEPBw6!GBXLb@!DJ`P zvON{mw6h|nbr_>L00*IfA4q8ZlZ^U9F6(EWdw%vtdr35_z?)BEkH;Joh*G|Mb0HLZ z^BtXFfu<7+t0=FmFfVb57P@d*-#B=znjv>H)CFsmTNu#sr=iDI&y#c3V}wgq8~%NB z65R>}q=DW8kDaDPp(Y+w)w^O~GJY~e`SRL5OKa**_+>N+1wRyGxsEvdzL9RG(hhIX z4bfULcKCU+$=WP+27PNz^ zPY&Wy6yl}6wX~rp%k!lFrl~Xh0)5@P*Ud;KIvz7i7Jq1wR#9Rd2Z+1lrgk^UaY5xf z1wZf%+`mHF8uqs%aBl$hRVKP%-w`Ki45aY{fN0T)!N`Ay>c+)&9X;07n9{;O#?L-0EU8o))8+Ffv- zPu@Nc)El?gwV2)n3FCV9qZXV%{QmkILHPf{A70z90)b$$QurRkI_xgaKksmwtBxg~ z0rLXaxxegqf7K!X#r;e_^1XhhgK0^2dtKRR4&lrZJMmN8Kz_=A1~tCA+?k(AXFThb z64aC0E$$dzjp@ZP?8mQe9*18)YKPBZASsOuhv7+8XpI;(?A1!WmoO9iSa*HO0hY8A z&_ZdoviN3E<5z-#C1-*p+-R2*!BJjF=+VW z&Xe80dv)-W-iz&WG(DXJ1BFkZ>A=9nY6L!rm4^0?U4XarY_^_IuF6&bu0pJ9yx8*m zyV3D;r3}u^p-6a~o0P~%5w4H#lzM+9N5u)hL2N!8f&@mgdxnycXmbH|+2(LEC|^p% zTL$Kbv$!*3kK%N;_bB)TM%=p{S4(%Z7%z?{J@Uvm-If##;mj6OW!mJeb+g^?_+}JeqWFhpxZLi3nqDn7T=gzl6r&qG{M2R5A2}$1EN#1Qm?1&a(n&1{o-Dj=M z_&!QfJZDas|5&J-(XC4!myu=*ra+=Qf9Q<2qh%@h-V)wX1kQY7(N;kq5Xg{b&s~?E zvb*N8P$#ek8xL6G${0P9L&vMq{|A|6eWv18@Z@cXy{>Lm6w#A`yXou;%Exg!xa7goO1C zLLj$wb7T(3WhNbtCmo&5F)Hr~x13oI(zEBCA&S_2sA?znnl(#;Oeml#oTuvb0OqwC zwGxejIa8zAAxaFT>QSsOTs#mL)#tmjbsuob{1T(|FAzrr*f@i?vy% zO3s$IC&if_>kWCMeg2VYo2{R}vQec0<$whH~CJo(!;AZ_Bdt3Y9u z4Hdg6O55e|3Pvr6O7&&Ipn|Fj9?kgQ-X5!HIUZpvvJLAZn@<{*@~>SqO_k(GU-NLY z?(Q*Qo_0R8C?(6TowjRqMym}vWD$VafZljL!v27qx3D->@O%DwnZa`e`yPrFJF4V*S={>-Z z$@xM=)VtlgB|elGlPUgfpa9S5ui6vDiLYKHB5&JVa;cgpA_C)@uve^O!@x4@8DeYwH>c(w zS{F9S&tOH5oyD(^A<+5EyKU0P5Um4ND*sSCZ2}5;S)%NVRku0XL`62x=SJH*i&IEM zjeS#2NV|CKF6)XI3RG7`v0A}sbe_|Szs7^I;Z~fMhl6P;3r@2i3aK`~VZ=2)X=?D9 z=S`~h@D&J6R>DYKeza}Ub66kzNVPsWdFs{2IuF;PTlvzo`}eK-+}%%KWJsr+VhETb zdL!=Z-gb)K$}Uf3=RnP}h3XWqF}Ey}IvJTeF&?uYoz%{%r<{QWt1b3Kr=#!9CIXD) zDSG-<)G<$&jqv#?qRKeU+~V$$^HJeq{^Zu7t5Uu@t*$=I`+g^LZ`^({XX;zf8SUtM z9xF3DZSnG%Zj4HqS+!xryUG5Yx1g%?{!dk%eR8rj+Pz=}dh*X8fp7c%pz$(1b3~5S-_9_1`@>kV(?4MB| z*@tE;T#oiYX)sxP2|xcY?Kc|RXEBoRJty5SH5hwwh zX*K-bvovtr4-jM8xhOOH)dUp_?+_n29T5@AF+%2n(_OD87b7lIyba)X$Ra)|yGH)- zn+cTeUlh{)S6Bc~kMw6z9Af@sJz3p0&J;0^^Il3H>1}Hm{R*LyBm>i}$e%`mKcOc7 zj$@!b0N`8#0Ox4K4nbje)sIbNrC=)dD(FD0chdeZu%Ev>C;lHwWb1yQnsH}U_dLeY zfq9YRC$UfM!AB#iVTEi**%_#WLz1YD1xZ!vQ?(35%?m8SJmR<^Exeea&zH-0_e^x*^l+ixg7+T4c zvmG($xT??5obyYyQ^%MITj*wFS3ra{()+eYtUFWY!;j?kXVO0NzkTKCpU)46Nfg@0 z^vJUk#WHHhjp&z#9`g3+r{&#!D6mA#{`h-E7&%-z6Y7=D3-0h0@28Es5>5=LAtJe< zLihMqF8oPO0;*z8s3h5EAc9We6I4&$B4W}#O!r#z$zY^oB2_S?@Hqu@cyHjQgt6F`#Y|4RgY%ek=#~okE$ukJjW3>COvWY=5^FQ<^H9S{>1T`%c#A43)I+n~ z4Dyn)F7hgQMH5!}wDP=h2Wkpk(JBzN!EIj^y^7nm_l-zj)xC`;>Qo^Ut7c$II?F2Q zPT)|!a85LsrLXOR3>p93t@&3D-kV4gk{y~%eJ%UdMMBfoq8FX2lSiYfxB6!KN6dbq zW~y59Kq+=WI{=)VJ4X#aZBtw7S26hk#BcwlgDJdW0MlT^twoYmN^T-3NiM0tT5eaf z-a=NQE1L6Re#!3q7DRNg+=GUufO|W$R5;VnslqY{k#V2uD}-8|yoH6i<9XCt7UOc| z#`@bi`?-&Ho?=Br`1`&c-3l9_j=gvWL4W2VHiBP(<#+S()cz=4GkbEiuS#QLyApqJ zBvqMSG=+~ED?h<4ZGWIRH}U{?1L@`hFf0TKK5Qf z6NdGToCkUE8+JJt0@u6Y*L*gJx?rq~9fo!D;X+YJ?KMWV74=qm&jpvVf4EZ+-aYXP zjDRWdobzuQ zmTs|hoax!$4Zu|a>^X(FFMs{_`9SO7S8Wn40?=jfb1ub93`-L;%GsgLY~nAC1)|*r ztZkmfjXpNh5?7p#>e%DRyt5zU%APcFh6I$3#JjlI!r1_^uNn6W;q5Gy8!WpFE{v_`NP>(gevKZajc9-}S7*O5MD;ZB83ETar z>&>5lj=1v5_V{<*JzRS>Z7VjgHn(mui$Bd@_`Lt3eZ-Ma+AUtUT3cy-3u8&wCNNd- z*JUa?o6Mii=yqL-yAXzf5N*2x-`aeB>cW1Z5w>{(Sd5I`b#wBka4$ zh92t_H_byZp_cTYd|_cct(9Wp0_Be9syU1gA}twd_8c4OVb&xTWeqbA9!me}M%fB9 zTi`h@8+j^n#3q+zATewS&^5b8vm=NkArN}91*BF9#1>lv)&SxT2dr0xZ>(2n!+r>$ zRepbp+;24n0}b;LxEt}maz20fsM}g_wqo`Yh5oJ949^!&IgWR+z6+3PG9sEC8#jy8 z8Rw0Uc{a9zFUIs-)X}{D(+ty`-E)%SruCjl|9uQ4AFJ5UI>Z|Xv$%V$GoOCb-{tjq z*A)=!GIAx}I`NSXqfL@`4$_i}Cqv)>qGFvvv5g0lC6j-nC_lh>{~~Jg^Jo8uC`xsb zX(PqM{_=NWES7E8V)1>?)+DRyE@r<t_nihTL_r9513N6ctl&?&^(iwnxmDnm{?~yp1{!I4_DmJw6A)#KFD2;OJYiS z#r0ee^$y4q?MUo0gb!JSoE++wQVkNBPPph!S)w%KN9+L%>H~1Y-rMgLnOl?%aModL zfzdZz8Db`4@oKh5igcGbv);9Txq3vQGnyHFS->|t9YVf+fXdi<=)swB7tC~^NU*rP z;jG@m)a9^v+$XP|@$3aCY&JAJA(baYT@7yW-mzvc+-3*)%B$m~&y9H^R6(x;zrtnd zT7ACCO_yHp{w>k4V zMj4zp`}_yi&67OQqUS0!r1UMNFWN`-XfL@zSszPJX7tvP+vnZeED?%G0NL}jT?vMO z=HzvF>U~3^%6_~3DHilQ?DS@z2bsL=T<~6AYN1lq(F4M534M99+2g7D7h@cO1v`jD zVUV)%##yZQ?l3Ueom9{teoqZ2$l?;ObaC%TW~_lJUTtE6x1_AlE;}P;1VR$iY9}VK z=W``0Q?QI*zU733zhlI6{x+49im)cu(*YqhPRN1Sm3Z~Ven%B}iGk|1v?^w*`$G5C zUe##5*O|c+bpCJZ3|f+=8U}o4t8JfDqjMIBAQ(13r2TN>?b-_&<0X6= zW|22e7egTbK&l=ximk6kvF)Q@gna0>ufh-AT-NeZ%w*J^Tz&4VPjY5}yD7-03SFts z^nB2JS@LB1y3T^(&yk0*n`lc>>J5{q09um|Mm110fv<`TeGjAWlFBhGBctC{_UiLQ zm2Y+c{@4DARnFHr7QBgi^jWT@G&i6Lt<6C|;im5cTh)WVD;^U;zAO%UNY}`ztT0YgP8T=O%%}aMk%>7@M(~aWv1H z0xhK%o;s6~wdZnU`M;Fbc)Ca^D2=RLy~J~#rp2qhWe#{KcM=omAl|L2)M; zFoo{Cu1*~LvSnG=XULxBR)dj0FtyIwWB#miOr+M)LtwW1-a|FG&iQ2F2?5GZ6%m2u zc6?G_GRJ{J$2M4j{yE8qZcln{C-lRG^4(65>S|XgA<@Q@%~>y zF8|M97tN}n)Cy;RMM^U-8*OJ22Rr_Z+1U-rrAfE>*1X}@gT__2XhS$Z;1BTdL?KPX zIq^R%Wqr9NWjR(?wvA{gcHJ4@D@Gxm7h6phlPOn(N$>>IZ91qvOE_U1?}h*i1jVRrk3FzT3bZ9evOp{=@s^wxkHq}euOUN1|b zB)ZT@#O_AJAwle;mgLQ4qGNlY2PQ)eQ1`gVN!{F@E6>x+FH~Gj5ZAY9-kFX`wsy_z zQ#18vm!C*u!z&K;O(!CH<^5}E(BJ$K(6@g;&i=RUKk`SmC9luu*Y-p%&uvBsgyRBW zV=tDGo?3`~Emxx{pm2`BT`Y@zS>LUsk_p|~n%Gt10i(i<)+EB`%F!ZlB?i&>cMX)* zM1zgSfvRR&T@e_5M)p2|N~~m%7ES-L73)g=_hH{(o`3OzVR^C8Pno_e|Iym0tbRB1;>()~fG4dK2jv^p{LOlq#S1P~p zhH9;Tlh5iM+EyY1M!$T4A-w)9OE}UW`fwgl4^{ISt_6lp7tavgngx?BJ#>LPDG5EA zWX4@oHgDyxc`U;!trGl3fo9o|X*07Tjh6i)2Lux4D-NOFkwD@#L66c(-)bgt9u+qv z%$W)ZtJlDfe{oU`jypuW=U6uyLU&E2IfyYGeA5t1%Qppk&iIO%#j=oD1?*dXqOO=Uy@3DDrrrClFL4ZN|GeAmtR)-qP6(z>W8=VC zM3jOeTJ$4vOtBXyU) zhmI8ey46GOfmW_Wv7(Kuv!hah+FXdTRc#(JKF~{luU|N<_r(1zL4JJdnINIPn&fzY zp+@|qDN2y5`AyJb1V2yz>bXX9=%u>~)9oP&QYne+bpXU+0#m~Xz4Q*gQW>@7Dc&m< z+`Vc@wzB$!HteOZ5Kw~u1q9xfc{su9h5^^f>ldHk>2ng_HG?QlG<@9SNLG0+bq3Le zI5G!>s*&p$Fcxh6stJ-#Tb8>TQXW&QY!sCVx7Nx}8q>u-!Q$sD=Qj3tkH1iof#Un- z+Hd(SJ&Xt~e6%yUcc(oK0w+EZM-QQLy|P!|F+Y(0hW2~TU6}*|{9JWlq9?s$GAOQa z#)`*qoMM&Xc7B1U_1%r2l*7mQj-9UJwjGU(jJ_Z(3%rOgjv4sP-&!)>wtJG$-VOzU z-?U>#69?VNnq&w9{oH6n`j~Dgc~coDse!A#g7e*3l+ssLbT-X6u;*nTirRN+Q5(lU z=sP%XDsCrg-FSc)+8sw5q3iWGk?|G26XQ_Ii=Gt9v1*2PUN6FiE{D`FK@E+rfu_|Q-I2G zyb(j~Gj2}!wK?iYpGIJYKt*yXV&RkyGewGM-;1dIXgwcFlR?Zm;I$s`SLS@{9c0^hr)mGtZot zC4xbAVJr~O#O4G?AC1UUtsW7-rjZHnTTT7G+fKf2>BueB}JpC5QXyK9>4-eF{%_U!WQbsMfFTogdm93mBw4R=%p@xV}b&x&wU}O2 zg+x8%*UjDq;CywrBmP^d(*e5gLWz|Wri_eb+7}SleNW01iH~@Z+h@#e0y=d9tZ_bf zmw_avGh!WHJS<=P>BZGsrxYjTuW@!!A}wDtKc#PKyIGhobtzvrWTbtm<;kWd ztG!;1_8BumpXCL%q@fH>w&{MpFty{con-R;H>CF=`Lyb=u!#34$MBammaLU`#NaW@ zhc!zj3B$q>_8nu2Y>|ShwsjlnMKFoMLykaO;p9Z&W`s9RbG>(0BGitITpylel~+%{ zes6iOPjA-KhGq`2k-OH=0Njv3pb9F{ziX&+uQ_`@Oz!l^{LhYJ$gBGQ;X!6bA5>?! z2G@+P@=a@ehKS7J*bl#CwI{1d+(^$04=(QmER>tyvrvAr)60GM?kPza=OuyjYxp?^ zSu74>5%$+E=?RJdpowGXr(e|a@}=H03oEw!7%GaUZbk3Bm@ZK|G@`jCcR?aD?WfdY z5%squEprr@BWggB)&X8V5|6#MflYjsY3-HeM%-N3nXgGMTzR5vAfSg8KM}I6XGE?) znH|Sz?gVRLv+cCAvy(yV#^Wf(dk*$q0tgKVx)~|;$uJ8enmGU!Olli31pwPmfc_b% zvW@fp{1wu01z^G>{bhHE-WzQ^{fOwPoBF2qzn>`mgQJM>P61%P!vg_deQO-|<^rH) z55I{my0RG@JZoe4@iQGV_5L{pEerkp7i=h*=IkC7*m~kFG35J<@b-TqUm*HvRzT6> zjpOsvf>Gt7apHGv+UD^6RTNjlGvHUUycEkzp0bQ{ZS}#$?^xc)hko?tzVuSet~6B7 zCTWu9-Pk_v^oz`Dtr+X`q9@LBxQ_{J`*?+9f+9xs-^=)hz4DixQ)-fu{+q}5bv6zA zFS$6ug#cFs%cL;w(oy<;YxD7BQf=v8ai}MbMj1z&`JM7XY(N3w;L1XwCGO0=L`21E zjOEKY%;{QjSIc!%IuIttV|kUoD-7fz(mkCs+Na-x<=Aj%wi&KPuiC z@)_^*Wm(EOZtoA%@y6WY#_5M@Le9F#ucf<42kzyA3d291_+=4ulMOZea*0i{Pw$CY zYjG8yM_nZE&f;P`2{oHo+CDjlu1lkPs}MfHh8;(@G>thMC2z#W>>Ar1WhZdCd;qG6Y-co%Nd(Jh! z-b~6`nPu#3`aEPVSOT%T^r!b`1ci9_2n&|?^|nif(g7-4d-=idpPHS&w&OL;@ET-4 z>g}aBV&#t0k28a|j`>BuLUKn3pv&w1xm-);x*6V+F86mkd6GAY!tMdOaA%>;bJ2F{ zP$~r%rr3lZ`{v+QDO~r|XeqeENv7zH2ZH5g&n}p?DLrP5JYP$0r1Vo){bDis)=XI`go=2xgHaOGh z)Wwim@_zrcH+U98Om9muwZP=BrdXb=)#eM0RTw@nUD4SZo4FEh>2mU7GRGL*&AXa( zMqV+fAPwf8<2j9)0pA=DEak83J6ccshSBj*2T5B^f_{e#=bmVEhO+ZyT7`tmsoO?C z=~hQa45wn<^d`7cm6wOqbC8Hbr(edKsQK#MRi==1J^kU7uD(KWQeB~(I-Pp87TOdW zAMT&)J7xbqu0U+yiAIN=_~}fmz({2p+i)m!b@ZRcG(6*RN>{sfHnXl!=q^;f`X(BK zP0WU|lqW0Yw!HU>fu5$OAh2q1m*Dy}rm=T;$MjMj2qQb$lD?L1!Mj`o zM+IP{wkv*7{0fd-M?E*tm~6HD_A8r1jz(i+^1SkdGm%Sl{(Q>FGhw>Ua-J6UE?)SMT-V>69Uzr?HvvIyL%6@M3XDgWH%YUv7Q z;4LPAnrZlqKlq|aw^Lg?P~l+U(2+=*kG-ki`i`?3B4~{^+d8SYM$;cAO1k?CrqU4T zf&h>bDpa0jbHdIkI-W%sTe~F{;xAx%1a{cbQ*$13`}N_XOvmpG85@^Mwj?f@AhT;3 zfrrFVvP~5kcYj-T{y5#(-@V>dEdfYm@ISlgH$LL0NcJueehBeTgRnum6_zRu97wsTJ|7k zLH{}Lg{9`{y~^3%e+3xOulkF@s~M+#%=8gR!U)DW0I9Ytj{ojGnED&T&iGy;TWrt1 z!tXqO+P=QMdR$n8K)2qtxOePg9Xy;=o>kb9`NK22^rhw;yu-$4_eHea%ygFV>{xte ze{0NV-1ZC_pV8m4bH_>=qXLE}_nPK7JQn<~fz}%cU8mn?gkz3a6Pxzg8%dfX+Qk|9`8~De3U8M$4?xi-OmO!>C}7>KYbLK0`O4} z@Yw!6V2jf7kUkb*B2g&>y8Vr=S%-8J@)#*GB+o<=6}}rR0N0dezvYWrYG%z_Q?e~s zO&bsGC-l_KVo}-aiz|9BcK-Cm2w+CY zN=u5LlyyGt9tFDOC>m}tL-7|K>WA++Qi{U6`b~u zzNn=&YLeP?-Gd`4dN2JP`fofy`%Vzb+{4re;Gg9~*#3qaeMxn>sH-DE+6#I7iHx+dMxoF zU>_5=`OOD*>3^LMz$F}vIAp0m^ZvraVnZiWtI5qtBWB<cb9dW$^*|6e>)c;Iyb zi@RXt-$xb)%*vU#fRTu6Su;Hly+HqaO`lio%<-b!7QN4%2y|`$Z-ll`Q>ht&oe)!k zl<-JhYLwsmnD>P$rh?Wke!7Q5GIY@>@RKJI=lNeKjmk z?TejlEuDmbwt9tHa%#i8t@a()sc)rfJ@3*unb~B};qZ_qoO7V+6vo!5OlMZMs`#$4-U`%Axdk$Vj=E$GV?A_@>b0VOwt-Q8;rnxz3l<$8bX4Duv@RV=?b) z#e?FT7xW|%ZwH*UUu$8G${=UUj(WPN*Ri7bg+gt;P~_IihmrK_`tE^aACLMNSTtpP zS;_o-Hsvk_K`%pklZiU}5uB@yGe<$1FO^8pU6J_;(2}B0roYK!-&`+3C+mIcn-t2d z(^rVB&R5pHcN?ZEM$eueTWt+0a5Ev1~DE=sk`{p=U(ob z#ht!qT=_yTt>5NCVHC=ig7=K>iiE#qobyz9LBZE}acgb`5Q|1kJK~*bb?+#!;-vBq0Zs^ zU8uZ3h0<&d^+>CVDj01nc7pMNI8@wtxkgIqyG5_66T`>u%7A*?PO|g1awiov)vgIT zX>1RH&%S#0p+jpjyK^H`3y#qEEN`?Da{=am{yBPT847 zAQX{@EgUIX-XuQ7V%_BM$!%thULOM3F}X_7ur zJb4(#dRqHS_zk&9LtFx_cvz=k5$4vx#g{N1e&Kjx$Z{E*m74=5*BLs_sc?rn^?iR` zE3GeYvasC`h(GLKyv$s4$2VM?0D*`x2zwL{e_OG1$+{%oAUsN)kXTG+7)v`! z@)2!YF5sNuaHxsDgXBwDxwK8W9(-TLb0%dOOo-ZKsas*rOd)5t$FhUPzysky>kZe^ zO-JiZ0$#Qu>TmT+hoWCUy2+M)irs__y5`Q${gox7{eqxboUc-rDMhV~t+yPbL)ioh z>C~h-)I=WWc<$T@<4e!(h+$%9d&269e102aV%dq>&<6J= zEK4A6W}L#rGo#uXZi(tsN`54#P2+ss7FB$kjOuv0h>`kK@frIRy)z>#>Nm@dq*7d* zC!QmJ9fk~bg+pYH$nk_LJGMVZ4XXycQH##Gi!JCF&7HC&QiWEqE09chQ-g{<&Y$%P z&YFg4P4;BBdrlU=^t*&4&liz$al@3@@QsQ_>47wOlA6f;yt9w&tG^mRYY35E&21I0 zSBHBvuUU!ntDvsEdC;-hbUp1%bLsHefyExos)VZ$;&f|eie2nok-p?+JKO#uqY{^m zuk@uk#co|}#LJodp>^K0s8{LYK9e4P5%iyWWV2IK^3yx?ThF|4uxz^e{+ioGdU)=_ zaT3EY)+5n1JY9@IweHT?9D|mTD6R0+o2L`R!d)qp#q#burBYVoXbMXU`K#ZweDtlL ze151Fv;gvU=XV_*%8I4@D%cR7mKaUqF_&tb;;y0)7m$!Rad^z)gA*y`)kO(nh%wUG zlrU&9;93zI^-D+D`p+E?DcG>Dqq_^B{ol#QkfJt zIAZFRxJm7YFawh!se?G#)S2PeDaO z9;9Xla9L)3I1Hx={+;jpcbflv>EDHoKWTCjK>$|~Y$Z*=#pC+U%6_QS&-Kk7THxJT z#n}^#R9UGbM?`p$#`{I+m;@$3IGNwSTxDe;4EKQnBy$9nfPS{Vc_5u5OSfwH-3#vz zMv4(#k@xei&ebUMX8f*x`X4H1c)yOd7^K#P+>)uKi1l+dC1Q3-lA3+e4dPwJQps~2_5#yUs<^H2l5s8h_j2&HgGCM;3%VaJ~rIS!l=nywbMtQH6o z=%k_CIOzymn4#PRtW6v_?_QCCz_olzt_$;3ef_E4huOVFwEcOsjnF2&n|o&law?c} zyN6x)T-@?3=i96%jU4-opcn~Tyd#cVV=AgX)1dm|+3*QjE=qCVYJy>$NiyEag;jL4 zCRH|9-VmQsqo=tAIDBa7By2lkx1#P%ICqfIU&;-l?j1SQ1TmccDR0!D#6EuQ()0EL zPf?Kaf%E*Xm=t_skW``6RZ2d3>4?HY&Q&vYCq^XMZR5on9e)t-ms(x+$898lc)!k< z>-!m^DZY-Wvj+%iRUhW(-Ooq{ktg(OYX&JMmnT8)(pQ#sz>Ip$LRFe>nVC7ap!eIQ zqxY{T7hZs>w#dmt9GQ4n{?l*d1^3#ShPZ+Ca}g-bWudc8E6e@Mwn4?;CqBFF2f5}A zTeV|sA_!%_b|Z*@=ePf4M@Le0kp9}K;qK}QQ^ zHGN|S);G-gPOHh;*~{8b*k1&Ps<4O3v$st>l(01Ws1^H!(UdGCF1@zAoKS-IVgRIW zmwtZf_`sZ-ZFu^6WsrcMLW`F1ZL}9EJXRJ0V8YHVZEj&esjG87g6obvT?M<@d;aq_ z(oIUuai07;&BUEgm-5mrXRGM>XipuviAm*$U;;|;J`YBzt7|ns_{1quqnDm6aXf)A z*e&Qc-~He8-l|-GYxDOZRrK$DC}?OdQOJ=HhSW`rn=eumgzYj?iShWYWC|(hx3Ob) zs>$QGk~-Aa52$RnW^WM{9WA_<(<`a2TB*|Sw@hGTqlHQcv}SX?B8%CvJGHJ+^s@;K zaaCTmyMFQ!XOI$xXjbZkCa{J(-v<(#NfvXP*y^5s>Myd6cTUyHLU# zY#qJg2##~-9H&0$SoXuMdf}#wrm1+#9k@= z#?it$ zZFD1l6TJW<8CfVk<+|oDIAM{?|A|Z)OJ^EL7j)o&BHh^DWhk6o%;}}O>&Iyi&#H#k z5E8P(zwcdswOe?Mr-m;zK_sQ$nG?6ih-995lRP0HvLj)&kv+QCa&<)iU+~r#3m_3W zswy%C4AeM~#!rrdgzh&WCkIF+{@@)yc3ULBTtEdIF%cO);MB9?+SBqV;}R9Lk&aE) zFvQ3EfGZxng3oN@@p(%)=G@%=kqWAr8!5RL=+xSkiCLHNdG!AW-#7)>|>K zo=rL>d)U|rWFX_4^nVll{EczNi_m^+HuvDJ1F+wiO+3p4Kn;GYi3eE&cPn9;RXcxY ze%Y#b|XLdORC#>7}42~oJTiCNs@Xhzcw6ebm`9r|y zrD1w|dnV2H*J{RaCDQZzwGPYB5i!3CaG)lrwiqBkQQQ!Lt+x*g$_T3)YqwJvDAL%G*b>5zauw%gbtP7!pLV$l>p4m)is%JID?Y`Vppz2E_;4$k~7*D)ZsR zQr|k^Ci7m(Wya9xLgCY5C@14J(!p~V)&mb#&$dWGZ`<}F`H{?&P>ER!(tJ?|!65iN zpZ1*r>uU)6xZ(lnm8j9nPPh5Pa2ay64#V$gB?@nQNu=a;d94QA|UDG1(0NO^l_aEh+^N2kS&sAfG)5zbbgb38AT|LNCf{SJH zUd>EbXX;u%>NV~>Dk6~_)Pdvt#gg;Y<|3fW`^A#O>sz!%d_(X_2@Ab0(2L}OQxHR$ zGA&Yr4%m0-oU5FS_d+hZf}aipPd1IR4OB~Nz8Ieyma&f2!IZWNuEGMeDKVZZ!$}91 zR8j4n&Q60*MHbFMnL>2Kd^Ro{8xgK3yNr{h;wqF8Dyq~x+evSxeMKL9pmx)`Um#;? z-7xe}Y_{sU%X1{EHl?fw!n+;MyVkOTt<16xO2NlKO%2u zgF|1)oZ;UvRw`Dr-6#qsbF7>yKWOll$k&#?4WhsQQiAb%STU&Hj-n{rF3)WbpGcfK@GIobqHsoENi8+QYLGr{Y~> z&NO{N3lBrA6U{MFtrrf$0=S6>gDHpW6_(Y47N^_Q)LMtWwADpkIxACNJM2Vs8&Q$R zM6MGfpZHnxAl(@$G^3RN2af4VO-~A`4lW7L@mI{n^U%fv%_6DuUq`HNDl!~UYfdC$ zwEdzPZ2>!kVnMa%A*MwL)*o0=FN;r=Eeh86m>;J<8tfZq3s0n-s#f=-1T=@MG@msI z4^A-AVeZ&{5=&u0yG7GfIXew0-HJIoO46G}Hpz~PURoLs6%CbFn#2Sv5hfBH{?#DT zqA5}7L4TBZ{j-E?-LYR(Wlc+0r!1YqqE{TyV)LDrpL2kFrcjlAsI-Y2uMS6#q3VV3NM{cnwJ2LG(Su zB9CNmevMZ6UIuCkOM*9(GT}?R$=*r5PWNv*QZHv!ME0`R#YiF{w7A`0U zpO5cH2#vnz%!FIB!m%H|_8nHaEq$6}+*~tb zyT7?a)`LW({Pp~5iBftH>m#l1U7v>yTmiAf>$71L#;(>I>_WXD(@PYb+xx%X0q6Fq zexxZQCKUkC?Ny65F|*z>!|n+C$p!I-5pcf^x=I@{4+MgMtFMve=Bm^TxVIkSa#r-` zmk`ELF<7Et(IEJ0HNyvjua47=0ztN0!Pjk-k@=vx8tc4dO~H~2%ES)buUkn@^C7IO z69IP3$i;2MEVpiTpA_F(9@N@Mq1;)rjK?p~A`T=f;s+WJqH%Itp;T=UCzd)4;>18w zL&*U#<;|b1BKF4^-`6^<>8L!NU?uf<>HWZphS0!37;en~chdjS3w!35oR2Nz)WhFC zW{>QtzD(MyOhI8|o$2h?b4pvs z%v&+~y)ihTpwWO(E>(2*(wu#GaDSz0?=koEnI0LvXe_7Hxsg_UQ~qxl;Bj2pQKh-{Bb`ZoS=oP9!ES{;oOq7Df3MW z+H(D;$fM!nz}0so!DioEmX>mEeg|FgC=Z_hCjYh%$g$Tt^1_vpOJ~Op-&K*L6Zh%b zIs@<6H0F{--ajBFOSU6&8E~4>f^rcxkgQ^kPs4vR!g)}!ZwAZ5wSVIb-`t$Y!bvP` zPGZuST<0_wS@y}mvfQBa@mkfS-}TVQL~IN$$F_79F1s1K867ddX(tRz9_XZ>~Hob$^pXN#~hK2IJOhxSX_;I&=(41s%eppPdhxD6)s{(Up@PAK^Jbz*!ih1DH*> z?I0c$l~c0_;#%Pxc}_g-n<#c$cycWW1b}Mby+Zg(VKm~IKbc-zTg$l>`rfg61+fP|MH~m$m4w+8atCiEh1ofsJ z?$zN7(2kR*tuKE3o}Zup;8x_DGdt3oeeT#D$iAEGVPz1)I>EB>y`%GM8tgBLe_!8v zmrlz#l|O-P#cb{MG-FMCKUnk@_>Iq0&}#Kz5YGq+Rt6#RIf>T|M>rp69fnZFvZEjn zX2n!ujahd3*C}?BgE4fZHz^=YU)F94!6>Gtm`pUnxauoT*@la-RLHk;+I*9svOd~# zv5MK*hnv-hXCDdL`ye_1&ok4+idUSh9j62?L^_&4dEps#IQr8#rrsXWh7=Cfa6css zkDZhsB1w6$0de_dAw=&KIXxl7p%#rZ zl1#n*MOQy_+=>h$#hkW-`8}2LcU%g};#GWh*Dy4{9*G!?9}feo)4~C!d0G|wm_L++ z{}pQx2`h>up=ZUfXX=sawW9@%H0@*Q-I{4-s3ESoiXzUfi z>gy%j!AHWNWH*Ckn4Y;dr*8=n444N`+zy)X}z^)b+tv$eUHi6Y>eS$7?e<~JU>gT$E#rDIf1UqpgBca2LIj0@}Z z{KB=2D?;6e2jw-O;skx))A)C8+i%fmh10^5rjqw9>FV?Y;UT_T8KfPthQM!6gL}j6 z)(c=;%Ty;9`^&x5S(YIb)DA{IWlT*<3+J}EsnmO4iM%U3s_nm3w;;nuyXt6Fn^-o@ zk5L)!mE3=Rgm-%N@(MMaM*<`Gp7V^C%X6~(l%W^D3w~qSX0Pwv^Pup*rf4W<$9XFy zKUKPd;(YviO{$re;=uK9Vg@@^o8KT~80AFv{7b(>Dix z11NW^B6fo{*oDQYZ(Y1eK;%|;Zyt*iZA~8L;ub3H-wm0Ptbcoc=TljaFlDDCB+ZHSUVN!Nx`L1QjCV_@VO-IM6n*M6OsTHuL zDU6+9J1|K)UI18Ju>&NhaBnb?b&TECUXrWw+V5mMJ?@BELHyh^j-@*u7o~Ez_i{4t zwZn=6Iq=6cxkyGvGJ2~o8-X9O7Q1DT zDt^h*GOr=()YsVO4<7R;#FL?9CS7;yk?Jh_@pa)W1dky6cA9MC!FrSns2fpRdtDL9 zG_d`A@HQVnpxgm|v*)gUw^~{2QE+}2;*7oiMZPT9VDf9D_`421?~>zCPM)nK=M?#N ze1;c4SlwxOe*-Ng6Y;J4|IVCM7x7pj2jEiW_^w<~z|d)ifU6=o89Xjkw=CE^H0M*6 z-$P^W>rjZ3+8A)pxACZDDjwvwYZE3rQ<2}$C~&lCg8T9iLny}Gxz=7!;&ED?0O-?J zoo-=+-_^gY0TNz`uy1yoZ$ayQGD%9EXB+9}g5OA^3Hnvuu-uIH*}by(!0qm>@+}3e zAgHJ_(p@3RPyLP&B9{0a0H$<%wh#W5OJV0PqfRzRLzEtcIzu2X98Zc>?j53b86tb_ zP44Y{3Hye{K&R1%S4^0U@6QHd!x8Tok80l1Bkt!*W6x_nb5CNfP;7 z3Aa*3W||TNgw(QSB6N11Gk_*{frv-$hZDI)hSX}8r|o?ekGwz|qY1ZiXSSdDukA&H zHvu~O8<+i>sSrM-x^;E69pq^q+zWnp1$TaJi?{gT^zMWCg_wOZZ|d{78np#Hs}zQh zbjzpgif#N_*IwA+UcKr0Z%=Z$O?po%5I&=LkZHc}A` zFiN|px^>>|#S1TYpLg-2!9A-0f-gb?0OX4m7sOcxXy?{~OoEJZGzE5VWaFsvEc-Er zC4m?rA^32bT(!c-AZK8R)upz9P(;#JAS)MlBDbJ_U>gD*1HwQPb5)oD!v2552*GCX>otwR%8pF;7Bzr$NKj)A z#~>ZH(jj+7L672xZg^rZ032Sj%xYSQn_sr<|HjeZ1!@?pZ5u^@-Wu;*ncrZy_U-Dk z6>4K^gAJa@?Z&RQxVYs`FC4X+1f?+;D3-}qHVvGDx@4(a#E^qGE}H=IA_#CO%lN^o zHi~MtZ7eF2r1cW1)oQmQ<44zYh&u++mLjV}<(4o6j7ENQc*Pq^>Y4>z^QDlD5 z`-C*TM@;q_Zp<=jM{z)=%B)2?>Y6r6GwtDps3y=}L-2sIr~)x(f?OG40z2wh`hyf# z%*8ty8G6DEa7jIHeo~Y_oa%gkCU0Ld@2%Me`ktw94@0;p8d`H7Jy(Ywwnr7W+jH{@ zKCsg$m$OhQc!6SC@uzqtr1JRnveXF-`!KkrIQYGsqp)Y*(t5DHI(k8V{mY`v!qPYr zm5}R92Yugvv?`BY>J!6VDNq>0zdR}$r0mSbnQ9S{N^nI>Dr9JgzvlQ`)YYXz-l*A` zpuzU0h=HQ8_4jfV$`B0ML|;saP4W)BnWbvo05E}hM--yljbWKjR8{-1PT>N4S?!|KYVT< z7j*26!KuFK#Q{d$F_Eh?!KNe1HZJ4+#B4;MyfX*uaboWET8Ggcs*@f=>r`?oYHMVk zHsk^oxWh3ztV!XIQO1Vz7$oNH^oz2YFF`qDqLf}K-;t8ybq6G!u*5-6o9*~1PfL~P z`-%(lh)y>d9Ev!V23XE6H5E&swHNJ}yn;>&l=$lt(CT^Hqe}Qt_EoMLPX-y>8NLPD zfnYK$a{apmF)<@SNT*_`EYLdQcYmYVai6T8xZ}3@dLOn5 zMz*K~x+RYOJ4t*i343=R%xgNf)?}gle(HgBYR#UngPkQ@AH*I#6B#|Lh7$+Dpfo_u z-^`XKovJz5n8loOA8eJfMp6fWixfIY~A9rtd~- z!M&zI{23g?&e49Y(tEx|*%?fOQl0>tj8D1WjF%FuNB(xa-eo{)jVG%R2VvR+74H$6`tmmb~QGo_WF}i8%v#@H!_RmO``r({6 zM@0;b>;k|*A4Qj9J0@@&EOYTYK9V+Aijs1r(CjKo>#1`ftT{vz3{O<^3ATq18$qk> zzZUziyIPA)6_vVgP9<;lm+%E4AEc>ne_kr#`svL)$;(B;t0;qzg~@)Ti%WIiMnNNA zZ;t&C-%XP?c;~=Mpe!o#l}??-K6!y-!DJamVWHp~uyob-J!u^*8|+gc6F$#i84b8l zSZ2fWHrD!K13oyx=8P`mlqQy9z064~RV~=xf4Knrs64PR0WPmSC|6n*H-r~zW@PHu z8J=nU_F)&?VdNWg>&` z`IP3|5?7~3MDSl*<%4G5Q@ZQ3OmKHYscqqJ=wy4ScGqDIEGcs za$Lcmu0mg2I)I9Qul5!t&EG5cYvp~ymxQ@~uOMc>zVp?8SU>(3NA^;Aj_PZ@CETuh zPSS;Pcv7`BqY8!zlwQQm@LSDb&cM1 zhXUC*(OsmnwO35zo6q_u-B0)>PX9kw8#|O(L4I5K*{QB~begymKHdrU_RF&d_AyI; zO9Qy#Z;fm}W33_jj7oPi0(&-r?vYo%U4jpaw4`pjVhdOA`P59B#2tJ^q*04%TO^vFfQ)IvA zWU2Msc2$}a?$f-qoK(7P0)bc6>8&GfD6VF_%l(HP{^hT|yZZm3eUwBmnO>Nbm6SPY z_ef!1Iu8LG$YLtJ#TOb{*abMUxII;6?RwGz^&6eCg9t%$67?V(X_2x^69EC?Y}fRa zYwrn72E7dcN3uaEfJQMQQbK^G>H+Mdtu3&%b{+sWR!>l-4gP>c9-lPrj`pPiN15$^ z90jIl2!ne#ywMA+GO)2y3#>~5lZ_w$`I)0@IF{95H@YQLLs{@mvq(Ky6Efx{Yz}mU z-aZg_80AK-1bkf}Jq`?SMft20wo&DC=}JG#wvR}b`s0k5tKB2JRP|sRoX1%fu$=IZc>wJ3hPMiG%jL3u{i@wmmk<2Wb=_$!lgrw|Ep@v>xtH7>mFo{+&qfdpB&1{}@c4+zZ?x6q#ztPXo#6G_|Dh(z1By9OOl9Fbp6yl{?D?;iB( z4BTkM!v;FqFHZ=ui(k)~Y;Rb3T6W!nxWS;mZgYf?n3FwoF02#j(stKJy z8wtMsaP?)yhx7ir3^ymk*5Pt0bYie#V#y6-uPUp~fC;=+=Q{M9m12QXBVo&lqu6gV zEvphL4`6qXq1VRg;@FaD(|E+tX ztwN4r{3Gb{CHyZP`d|9_AF8>`5e^~Bye-s)9Q3<6s94TaK7+sJvM_HcI$3d~=2&;Y z5Or4qi9fsXLKA0~=I=Vu|L)wd_3ySZG!L4l7}Qnxp-T-3{JCZSZnb94#LU7$5?^bX z@v0t~_|Yra&8O$pN+)191-9i^&o;FUz%b0*41T5k0r`I9mb1j4;&2TK>;|kG)?0&n zni5b`3~I{P&#gOyhC&Wltkg8fHv@e}PmXOUOaf!E@p}5-tAdzJEN$!&p6V?kbOfyd zTruL9x8_P**Ixbm9a|?2%za>QamzSx9rgW|qk1){Ag$S)*#y_PqlIgdlpuc#hK5D) zRX*gXy6wDx69>6Pp0H61-9;}<(_aL(u_+#2n&{{8A{tnGS!zv;|Eu3gk*3z1WuBU4 zapVUi=bFRf_TSu!&-{R}k*o>u{D2T7gU5_n%F)=9ImviRLEfvcNp}; zz>@zCU{Y{au((d(N=A3DJy>Q#<| z;HQVOVE*7BlNt~DP?=ABD*bwI4Y|^U{?t4TzIKy#H9c+{A!e$k!k0JnT|RCurcxZ3 zyiFPFBBTR$;XFIj(0gDsMy^(_5Q6@$-DCQ9pGtbF7Usf zagF)3AlUo_=(1V56zwSJHD|YWNEL!&fyM|}&(KTccgGZUim+UD>-e8a{{5|X)~xss zR_b{1mt9r~@}xYCX0DjV!b57@Un4sWWiRw_*udK(F`*B|OD^7&BO#h+I`3Ys#q3@t z_{A*dP$&y(EH7sI#0jxQE7~P-%ko8<{+4T>v$zKDRSnpQx!uiGWi+Remwp8iXp*@B zIydM4fp%{tX8+@Vn&BHDW{P+X)`j;6B(}u$jf+8*%F3F`+ED2lL;EHB7@7@%b|B5L zSN{^})=yrsO4!_l)TV9NmU746%t?e1 z`uauMY1_Qdfh=^5!dxIz+BQZBlD91mNK7}Uc@@|4ueRH~_lZYrJ#AdD(C-IgTL$NE z2Z;M^m73Ngx#)=VC6fLr0MZ|Ja+6y1)@u+$`e!t=ZRd8qcWYV!MbN;`AU2Qdd)VU! z4K^s}&&E^+)dz5;)hna-O!u$dkSf%KlbV4|4g7$}cHY&qjM;#F1+c3W_cSdY#1WR4 zam1_fjPf7vYY-!(F!cs2#GoH}sTMOx1VwPe&@5~8ouf1!2VDiit(-2X%6dRu3ATx4 z$7?;mSg_S)0KJ;Q`pr&*oxc`+9GE|ki04n6rOyVB3AOz%rw_zK_W`&UMDM^lxMgo9 zcL=Xr(Zoqv|D24pV29?&hCHy@JYSRNkV_~!unQ2K z?tL~-g&b{pRNh{t62T;BIr%)2KlI7yGtD5~4TaLSQ@!>JMhx*G`B0+;h!7&u=oVY&g(?*0JEybhxgf*Y8h_d@jho+{AjQV>39Jfs%ZDP<3=aR0%m3gn}EaCNRk&X0dW3zkj$g>HsT{f ze21^?)?{!2k<=xFrMVxFxQWcPru>S{O_-O*{fUZ=6X1&*8GgAI4U>!^T}u`gvtVv$ z*~m-eLXHd+y#P0bx2q+HhK>YSF6lfeqJN-af&gzbk}?hEqpKa!h1=(NLP7UrQ+P)- z4R<3F@a?#xJflAXy!9_PNKmeHvO$@H!+ShFZ5q*@{B z&2Z*4CNlC`FoFlxe?qx~54|yg#(Y}`GUO{}Vi|!hKE2WEzu)9KCDAn72Rp|MNgvKO zCZ5j-#2vdE4t)G!ou{D~MlzpHxZ^}mp=jEd*h1Qn%;q0*loIAx zON`>zbMGwCoS3~bylC)Eg=hjw@rWPgtH9RwE>%jchxDVH-+jsG*E6Ny(f})0I<)BV&j+HAqb%o(9nJ zCiVUxJAo=2otdij5^37OL!`_T3ySdDf!Ls8Z|Wn}l<$bM^~d?N&aOtQDwdrsmvhCi z2RWx6)mmw>yzkf>uO!15(;rJ)#~Q55I_DiejA*_NF|P?d6GWWiP(k2k<7E*sIag0-Y3EgWJH9Zaog!0z z5Q5x)?OnS9ZLMk%^VFB`(=P90MLrK0^M6Pj(se)cNKLYXjn&eqoZXT5XTG=#xCxYi z&DCs?_IL#3CiJ@x%u0i!;-mRbI9G7yLx94Q7GP&ao^LDy;R1K~BxQ{&dp)fPM`Csx z_HoI&@E?H5~cq}Z6%}|oVHfA z`*vV$O~in6vU*nZ`zsOQ%I8C>yD^S(N1-(m{KVI}K}zL>K|eTb5%~XrFr*o+@5>2W zdbX&kQ}O{LWnLuEnM_&T^DOEv^7-ND)S~k?l$zI_S%dtFmvK}~7V7|*q0fU!IYbUI zS=`8f`l)zs&ey|GG(Y= zM(3g}ZCk#el)RcXEqB1ZftzZ>t|>*ZauL-&a8b9iI{FJ(;6bZ4DE9Wa*2NR2Kj&O~ z1wo^(zFs13Eh-!qq+BJXT$}#^>3LfMn6Z`~xzmNiJd<~>c0BIrr*o^|a1{h16GwHw zYmP3(I4py&y>MP?P#j1URl0%!juc#CZPNvyOJ^h}fLHLQr;Wf}$j-m}g#D8Uggl5} zv1~jCKz58r95mWuh&uyWPJck5j!cm?l-LSdVa&`Rk#Wm6y17U;(%xU)5S4EjqNS7O zIkm`5hPBIb=#nN{LnjU|FHUr_&-9k%j%TobdF+eMkg`}S>NkGPT`kvR{Y*Q ztItR4{4UBcFrs~YS}d#r3JhMscc=}^EJ_>JWUv8(Nh?tUap6DrvV5%9Kd-0iy=4QZ zjl<1Vvw~{|{rW0L`U008G9GE6WhNnhm)cq&MGCh4)UQy_fx`NYPmfE7jda^R6eiRACk>tQEMKS(q_TzdP5W*VBG*g$5>sgEZG{!mdH#3jVzAboi z@K`24_f_tFLhMG!EGG;nyAhqL{#$i9L5v163a+CA1U@#AwrDR>q>U=IH-D~V6mp4s z{5>I|Pe?f?#bxU4BXQoO%WRhEddXh-h^wnEoKkKkltja46&r10SA5=$mKGq5r}PeD zPI%JM)%Ga6g&{*aQ-qc0#!z$CGfqdS&R>2+{wlr4*{IoDQKZqf>rT;Zx5hb2`hfB4 z&-9;so$k?X+*GuGnrGi_mU{HY%A>5lo~pa7#x6qjq(>@f)JHr;=-6*BPJ~oBISdY+ z54RboFz>5ha+|SKO$z9Xiz`+C9bZeHivqd~B6z57i!+$_RJnoPGb^dty(@Z$G zjm@u&FKGmN2C9%vK-Kn|cVnnVC|YMX+$8ND&*C6wKG=U9+&J znH-_HmP5bzyt?4VY96e%(R_+6{7W|72Dv>=*D8kWJlc{N&d)gAqfpD_JZwioF{fW3 z{B&CKvpL=1MIoL2&gQGT0)Wuz|UoRZN)>vs#XqVl{yd9e~Z9li?kzKCV;*fml zl})94Lt-Iuv{1H$2udQtFPbj;mMIekUCYZV`Zaw zazBUHi`g0}OLFQHJXeZb+2!p8oO7{t7iF_e*}a1LmEAH1-HD;=?K$tAc^I-Qm8fJP z+;rtNCW}q>%O6T8sw3ZWM0wLzLpJKBL9eJE5G`AcWb^znZdtWrBc|st;qkjO)}UVhi;`BuDs#ti5}mk0#OD5FBfaJ}O_eh%Y}4uE zl#9gqGmGWS?(h4W?y)T0$4Kh>f#a_60b1h1g&JFL34aZW3v)EFH-z9}%kgdPu;<@r zE0rGHtEXz0h#74%+&U(y>^vsHTVccEr3hSD)Z|2T%Z7xQ`OpgIv^0Az2!W%-L`|if zF$rUOUD@l%KKqwZR36hek2cu$HsP{)9ue_vRWpa z-K`viIC~~l~ht;u%)Ln49z@i%+#D=eP%61}k zhtVZ`%z-4YTn=4Wk44>%nCt4%9Xo)Bq z+%0x?D@jw#Y@V8Ac*rLQmpgb_9XbK`{8cNwgY(pE$xJd&j8XqjX!c8(2f&Pbi}UZ? z8duM)_Th0&EE{J2S>^LEkxaP6O|%`QEq+0o z9>?EpW>-_CH2FM0aF#oBmiD=8_}0B8D#=EKIDao0+RxbwgtQi0P$V#Boy^yD=_m`FwU)#0W0tB@WF!J#DF~ScMvxRkjY2V3R%KVwIs! zorn>QYw7p$W{-~lDH$(V8s@X6$H6h+4?3Ks$%Ae8XSBUQIe{z<{-Cv43Cka``~H$9 zY&NER*gfz5OYwnow4fTYNXm`2rgU&;&xh}@KO+JDB~XwH^e4R@CP1L$Px*rX66&Ay zV9-bWhL`d;%89pA!!G4SG3SPBaQK}J!J5BlPMQ{h(w5atfHno&eey4HI_XP!_i&|Z z8}~|XzS>{g<%rxEc+Rm?Ip+aqqqluP=EXXEW@vU+~b2+M}Fx_}M+LgQeJQHMf-Wk2<`i$>#%O)HuLT`|^(Ot(Mr2 zK>_?w!gRdG=>LD{aeSz4*Di9yM~l3Z^H4rZdd|L}YJyqHM=?C*we}$n{+ry4p8Z{} zYrC8{K17MfiHqw^+q&XIe>*$$q{-t0exS^18z(scE0o8@kox#KC0)V;xLo&l`lqCJ zeLBr2hP;cqU;?G3V>f-n&qAhivAmVUhnwgK)jpEp!_w%0pWpzy-wlAaMtR?eYb{ya z9|8XbF^j~py*%zUTPY$xrE3(^NJG^qI^%zC)WjY1c$H9l?S-pvg zRJTBz6O?yvE2W7?b7_y+IytoC$Y_iXEqGE~;+s@SajV>m&jdlN?f8Sy_h(y9$jYAQ zK0(dZxJ*|@h~j?tT2^U3DywT0PwTumJpGwwOaOdsxP^Y4MWx7hf*qyE9;6tDM-uv< zk1rPVq0{!ZbHdw@k2mjS#j!9xC-0LD;3)kl)P+4%gaa?1>QA)Yw}9BzsWKHGRMfn; z%ZDeX;32o>S~5F!)=3<*v&~!~zD`g*u$?9dKeM$&)c&W@O&}h-t>5LiSSe^hD0^nB zS(M*>&|2z9*8gDdJ)oN0)^*_^NE1P6f&>DB(z`&Y0hFpzq$*VbQHl_H4@E>VQUx1D zL8M4WdM^^1pwf%5zxZmx{%61mROnYL<#*19Q%hH9uPk&AZ1AT)zc~5N%kAbfa&Gj6gw7N0!7(XLdW+7!Ji z>=H(E*ovez!%v7nL_FtAi%s=Lsdgxa4~TBzKnD?2nN@DA2-I&9uel4Q{`-k5)z!cyTxfb%PiabFs&3R1b1(sxphquBTsEkyu2vTI^! z&G+-oq|mRtcLC~pz?Y_l{NGakcoT}S0TxbmVlR%NDl&rt5-VCDIL*TQgC^&{J!Us= z@e+xs8691NFWl6t?@n3$gz3J>(J9HVQK!In1-TDI}q@<#oSzYK#m6XnA$EbdGpidk+X=0fC z)<`U?La3ykL;C|IC3zZ=C9)?+Tj}cL3@2x=*1skk3Q+xxa47PBPB^5i^)Xx}ywMPg zETZTa3>3{p21<=RUTAcSY`RcBFj}}^RoY{(*C_wQ9ofQoLzCqJA#UMIi!METg8DpJ z%W&wV?f`~#7*_S=*gVr&p?9ZhvXz%!YNObj#f5! zc-~2qbBVCa$;*6~D344*8S>#6DLZRWEfGuilqubcR3Yw5TS`)qBtdB0lH?OdW(DIY zDa%`xROy*F)-1;!s>7k__&3|k`;Um6z>Kxb z(JvPF^4J+;;`S;25|PmjNH#K{S#rU+r1)Xut(2Q_wC9OSqXs&Z2G{mUm>TuH;sGJb zlsoNU=ozr3p_;T%z0dL8V!geGc9vF(acK70whuVsELv@|cX784RaTGikPiJjvBMEQ zrjy@MKG6>9^iN1rOK}D+a!_Sd0kCMI?*6J68c0rrln25-_BWkrp)gTTZ<&xh9x&yo zAsy)LPsN;s(<_U7aEj+`Lsf7!v_{VHD$Sw5^Y^);`6TBA3}L5wW`ZA-~4gXIX< zX^+T{)^qv~QgL=m$>1S!n@NnHZzF7Z0e52E+7vbhR;((=z60t9Z;Kog_S;DoiNcce z1WseQhS1>aC0eR7mMkF&FBmtyR&&U3GEzUBRF`gpHqF3NN$uyyHHKIWpj)hAF+Z%d z>szTz^xeYCGe&Z9CatBv8*W@PG6}l=F|j!k`ud&`c}*@8)p@V5ib)EVlPW7Cco{aJ z`I-p4vjV#OXiWw!G5Ol%5MFyb=fF$mRE`X5-kX`&Wmgylh2PdiqO_rRm?$T=rQ;%w z8Y-raj@R5W^MmcAQ`6W~|RI%$yP(<4XUH?QJ&iH4d?D87K+PL#CCp4TaIIHMrUDimrYsmAnX^nxFsuQ{BOB;jNBNhdZ4sDV(1#Bc=lzL!n< z@Q(&lZ>V4^B#%a~X?UkIs6fYWzgIl7tO`BmMdU- z>`iat0_^x=w#I_{-N)=fdkusPtj8`{CO8>xPrR2D#3~n}$f30rZya{aeHzX`kFsd= zLdI&mG2eJYrHTz1f9xZ1zxY%z-?w14TK40HTf7~uMmL!k%m(Wnu_yUd8z^5|5lu)= zyxQqCUOnGf*0L>N{HAV&mSS^Eo>8`4#8LLR@9{ANcD)E(dk@sc@i!-Jevi7rJ7}dY z$}=9w=n#CCWX1YJFuJgDNKk`Jatq@XqN1dFPFMPwvcI@+1g-h#Mn{SQxQQ|o;ERI6 zP2@<$qVTdH0nQc%H}D*Yob|6h+0a&Ui~8g7{4FA-Yry&~FWyY4pI}fnE!{&uPQ)-~ z4}d9~Sovi4g1O}te`NcKDrH|_`Eo?%9ke|iZ{%!n|L}2UHt~qFl7pd)a?AX+V3%ajLFgA)ll)Zv1b|0Q~K?I}v zol`mzG-Lbg-q-mSl&pB24pUa~`MUBlxW(8+^v*r29SqCsAahEQ8vu&O!EGP6jv&3pTJg{{-(l zA!8_o5Sv;Jt8-vVL5<`DOqhdwVIc+^Fs9dIelHS*qMlN1SA{;SA&NsU!iHz%Ib|5Q zZ_VswL>3N58>P;CO`7uk+O2KqcLF>!#r#pu+r3k$?dOcLkjYa+j-p}RrN)Kn>QB`a zjZ*JiT*?O5U%swn5P|&(`K=}7j7bc#2(|hX;{6kH|0iTupej5Fhzg8gVbf?Nj4bak z@up}0aD$848$Im#*>=6sUmTpV-#9p)%b{Xi8=p;w$1Mu!38MqOcHTG=$X@fJ^Gpr< zXttQ8!E|j{ZjfS%R%HlzbB}T=p$#Z#;?K zXeVn#8hTOTP$Q_pV*C@anc`~lW&72S94|YD9EHP8_N4Z#htmgbi}B3PqRaX((j8>U zMy56xk#P`YEeT1E`UbZZZ7O-_Q^V#K@q&?Y&5nZEOKBTrvh5`(2nsU{#;D0p$d;!q zOat4n5P&2_NL&!-4W7UnxoMh>LpCO|?&5?i&J+x{m!9AVt(SHD%*NR0IbAwz@~G}s z9(2ArtsijJo3dTGd6|EOh`;FF|06;~N5EOK^p3Vq{a|nO(h(E4qDv`4z-TwRO$gf8 zKAO<;pJj6(tqXg%$yrV_l!(u*0g>(Mg(>^{e0P8((v25uj&w;Jqt4&T2R4u*&m48n zRh?-Yc|C2rb`C*9KJGdalEl9C9sVNw)Dk&Wlcpqu<-rWY-isYoNR+e<@AH$PA3|cr zx4*miU32CBBuY|S#m#aq2`{1_iQ=#X8d_)&o_Ay;Fn zTIEmJF=!Nh+Q&dNQJy7At`)31_RjKI)S_P^rwf<(7Z4mYY3W-(24uEx6Zn!VfbV#= z^H1GK?_t>7O|usXjhcWfH!%R)oq*v3dG@vb6!+!yv9Ba|2rnZh@U8e^#IN?Q!_7$R zOF|&qG8;8}Ed~CP6#Vk~!&)V$G7_|zPGv%E#PJZfZ)6=!wUpk_=t#6hs;q5BmhIS# zqPoa%^ZxiXAyDpSI|zChyn2J|3w2$ElgjV2bvxERLJ0GIEav2(3H0g_tb>Q%6lV4B z6lP>r?qXy~W(`jh8`L(r!mKmDmbBD)??Yu4s$+vQ#&irUv_bK)2+-;yJ#aqz6ztbzZ z^2y9;$g@TU3OPx$oJ8)Mrfl)dZqD;Ix$@KKl*Fo0&t{0`Y0sz&k#SHE1O)Usa&@{~ z(-=0K^iFEZP6>(UZX%)V6wEbYsZ{c$Oi8kFr*1xHLZ|G;BQvK=z!Bgt zBqU9F{Km@G^R&M9=xa`VV|-`=5{(g|`g>v@kLsj&mOPj9p*p=kEChq@ zPs}ZDzP**<2DIF}>Bdnj8P#*u_)9+_KNhZBUg7>$F?1zSj^q)3nSmhVt#%Ac&UIFvIH?2V@p@)+Kwn}o zxQf?)Le@Z9XMNMl-5=jfwDtbFQjLb=g|cWYlH6BhGteioqw1PbmJCW{^6Q1!3dZPISXkljXgc3 zg~R!aUB0)YD71b%^!tB4bc<1TTcWKbyC>m-oOgt$ik4oNc8rD6pG^glh-qdvU*@pu zld9X+EEX9v4DBMy$VhF}Khe3W2*=YI>`Q=T1GOJ-TRWO4@O5MTf_oEGShLJeyKZU0 zU)c$Mv4=i+7TUB7Zp>j--+!)p+H~X=R^|j~+gH_dpj&4=UuvC+FZW`uPdRZydjp7o z{z-}b^*Oh=TZUdjLB^fyc#@i8<{Qq6a zS8x0&55JBr=5L;U4llQ#OBXHTfk40A-q%g_fVQxiqcX|*Fyms?PqneaG*A+Ow`4Q^ z{k1Z%rrsAv^qbR>WAK@xYw&^{ZQ)z%6qA5^Xbo%d{w09wc2w~7e@g&0$Haq$DJ`k+ zPP8S{7OpjMm>Gi*klH0s>ESZ6|Nksu`IiFyf2~0L&Eqd6|No?T>NN8g z76M#SN~-gZTCnZ%Kvv03De z5=xFs$Is4%(o?(rg=lau3tLgq;Pf@>Wv$k-%Zxf-A8N90$^J|16$RpuIKq)3wo@iHHrytPQ!T*Gu$Y<(0)YO_g{UX1dg9y z8t;volms%|#c3W}t(yJQt)L6j(k$vyjNPIPcO&x4`l9ifBWGhKGz#;6coC80z5jj?arO#mIy10OsQ`okSOC zWABlZ&HyK^9+{Q;-0m^@X%y7*m?XK1qIBlFB5p5gR~L4F?Pq6Cxt3nJpG$OzI&Zf4SD zDXH%)+njiR1v|>vG@}oi>+eV>)D8ymmC$E=DUnN1ip>EG6?6JjB+n& z=HyHUM?B~P#i-bVFDP?;e4$nPIALpqlLpCodDzo4X5hCB?k3oY2w#^erD7djqYc6u zNIHy`Uvax}T}I@T!te|cG%QOA6SyeAnBuY4uEyz&j&kx6gXzQ@C2@{vKbQRgf~I8x24YJ938vK^Ug)Hl20qC z#^bZ|LMit=$-=(*MNbwi2_JPouV5a>gTzG9e|m#&n|sToVv@&KI&+7Vts z0Zno-(_ot6`}S>2Urd*n)iHzC+Sxfk+kkSear>;hEaIR31OWLD-IoMr7EKL}gyC7*VAkuk-fym6 zeg^Wf7@2=ON*IoPYh=9Ve-N-UFl`e!Vy@ z4~hRTUzRri3Y7jtRL#-BPuq|2LfjiG3j##Ns-umygIVXGlw zB|NyPb_Pr<`M!JrxT#u)VZ5 zt{C=rv`MJC38;KGC%!`1OL7ZSI!gF$Hix7VTbyPrKIw|KU{LJ}&*`X`S;a8(RDoGlj7odvufOii_hV zzSGA@Yl&EiPI;Za>2d_G2Ca$uJ-n~=ZcME`yZVkfc+IV3FnA6$Q}ius&CaG1sfPfr zB5|Y0F*KCr?$;&lAmEh3naBaL*qrZ{trx46v?(=2mgT6-iz+)0z6cCt6w zAP%Rqvd(6r&q8i4NyN>-%8rJp5sk*pERCAe++?A}#+=-Jlx?WO1-b7eUUeq69dcb& z21+SUw87FYaZ<*LYkY36SM3`A&3iWijGi86)v|MAP+RFXHm9NajiS|UnMNYzN_TPi z1p5@M!3n<23cC=)-Tmr;-e6zR59dVkY=iv^1MDv>o{0#zkHdJ#=K4u)H6ud2jS+R% zBz|mtc2uVL28C|wjv^C;1}mw?LYH_8;7E^_*ky-TYKVqcr~@6Xk`w>Bmi>P%o}*8N z#;Nj!w}IU!p;zWiCafA&wtakW>9vxXF9@bwobR1tLt?09XekmusJ?c zp5s377*|#?c1`EX?7VvmASuMm%K<-fgv*GSoVN+WbF%A7=SEU(W~$E4jr11`51I!+ z9}zF5C`8|zl|n-|B%89gLKnj1a`NK2#k;b~2ihmsKD-A=g%j-oT=73dy9e6aAWK(h zq->7CROw7`+Ky|*`Tng9R8NuUt9$G0 zU0gY5zxi>0?>`=PEkBL@If)-JvBWXSiFBgL$?4RdDn3oG_i(MtjE<`39dgZifT5#4Mk+w+lI9$8P>HTpUt3C7LaAl#KXTsqS zWVo}spx+BgAN?y(PK8n!9EK6)sWIYi`LUY zP4Fd3VimhlC(^}NEA%YM@8$=;SLRIHx_Yx*k$7bF#r4FKN62WtmP-_YC!)hhW#wf~ zcXpmDtCXIg7C+v=;ZyOVPuwVc%)W#f^(eA4p)mZNhZn!Mc6sq@_({=YsYIuR7$;AE ziENVfb+pyIj+O4tn%)@5&*_wO#i{Q2RxZpVueaWrAaD6Lb#q~`Z2u~IN10TXG-k`7 z@0eEVebs30usEyScjyhGJxgb!RrT`(U4fYdM9@Gg)<9{4hqiu%Wna5fA{CwrKi4Pn zX&|VrcZJXGIvW)583tr+UqK}w=_NDXsN4OxWrkR@^0u<*zx@nYdLB1CMk-0fqCn)9 zs&D-eG4X8#U!nwHV)D)$>P$&at}VBV07lhCAJpu}eT28Os~5IV)4Wc(xIeb5jcZWl zAXFpAg^}H_1B*qHV(I69^s+EvrV|N_Dj)>N(II0rt|NQAIZ4TVIzOZf{(}#N-_p!A zi94D=s~kxzO?+v+$$bNVOdfWJI=sCwd+K_63xpcsSc~> zAKEV4<=Ud%JKo=P7!RR6yhGRfRV6pIPXJt(tjmXy+W+a>bkhi$>WQh}%#t-t<4rAA zrSWn)2Uf}tHakM`3=^euUD`@6qz6Oe_ZLsdBgDjj!|ntpKG0@gubcDKB@Q%D9+^y^ zmA|e!>$Neb!~cTrD7mo(2k&9;wns-Q<_1Tk>o$^+zbhuMh?_{gU)cRSh3Ak6H{Hqa z-v-#PvDGQ3ycmr;&d3SOD8wAi7{vna-Q`!7ForX*?su_0CV9hF6y{A6Fa+_Oc_L!~ z#30s^C~ps4)h37?^W@-ah7+yFm$E`F<7Hu^-@o^_P2Dn%aJp2jK}zlxp$W~E)sV6- z!&;0PZoIZEV`a=fC49d`e)04 z^UX=A|MH@BJ&wPSC+c$}V~k3+E;VX{ZMPR`98wR%ZlQL6jO>!@>zGx9xA{_59ezHJ zib32y6f%15bnFGARuD~PC~9dQuB2*i>A+Cl=Us(!x4W`_&<4;nw$&4IjIB1$5`RTo zR5=gcq&SPXlmU&KR47+cK12U)>OeGsKG7*<1(HBg*$-_#nk#Q3c8X-eoSAZ) znkQ_b#~_FXXN>-ZO2yFmT8jnqsm~3M{HjGlU6!P%Qm9?D)=WTb1T zbxT_@ZE}>WhEZlCohzwAe9-;Q+k=w(VNtIGGS#8-vzbcmPss8zj%r;Q9{!*&lZpj} zc~-qbwSUsqFIUDB2$ft1`i+PUv79eFIO+{+o}nesf*~Ew5?pN}eo>%wpe>a{xOS9k z%+!4*vg2B{#H6lJH*YD|hko(>)58Nwh$moipH1BSj@lr}_EyD~@+Xl_qtyy^iGk2A zG1+bR$wX7hjvQvHPe3|gLvwejdY7;>M~-?xU6@Hq=&GfVxhnn~>B2mL_FU-JimM~C zR_Cd!%M`EY&E7#BZf<93ntmUh{F3(Z)d`p{S-Y>e!`yPX&0J=oYEHpqQ+P3BUu|B( z%UXClZ|f%P0Zn~0#beeJaY9@T>oqW;UF!OTk_BUGkYnct7;2L&oHvIZxBAb>P zcoTopJgQ>WmQ2SJ`DFg9!)+59!)v$c%Fw5B;)o%zn9zg=VaYu?2I1IC;|gEKjnvo$ zLMI919s23p8x=Jm432u+!;&1rZ^xky` znY)>-ypBiws9v1-CCX=(xQfD|&tMIv+ba+?9#hFzR*Bc`vhpupA5@XnIz?(KWEdra zSwKSye+XYbM?ee7fIui9BoK(S!7Go}+MJ~7t*nQ-Y(p*8wevM7=e^c16syH--r*G3 z$6{EeHuEsY7F4i55qcX$m~VeLkqFpz+g!}Jj;GcyUaLlcno(zlmw3W7+AW>wV(1&u z31&bT<6Q6nbm9QHr~JDEOd<#>k4y{{_g9_m!{)Cj?29*wT{q+lb#oI`^G**?QZ zA5dKjCq*r$;?Xt>*D|vg@P5FF_uYPVgpC=cT~5AFCAx3=oB;zyX^I%x(YoCGYSafg zO1px)JuP{HSCtmbnlT*lHU6GvOJP+*d(5}71@)I2wD#lj6rn<_)&TlOMh1F^Ir=_n zEwI_JRnTyV+8r@Lz-lsR9;eA$KP1}2^9n1 zuBUSgWW^SNZ2Qf@5cxl&2K-MC*ZxnB?>`~D)9tyiW*&Q$c#tVhs3ndY&R!xrZ&h%N zDll<%hI8LX0w2KabsSlJLd(Yy(tedOvFMj>; z9lbOxS}eP@G}kUVC?;4pvO}T(bYc-3w!KWNPd;f6({d`E-5J<1?sn;8<`*v?Vn6S^4|Af8m@TdTbd<>j=A!CYgI*Q-z^Cv zu{y691*pW8U8`|iO-&>+2Drr9-ScX4wgH;g&nJ$Bl2UTshtR2W5Yo>R))E{*^rn$Yr<23cQ8=voRAwqKYu;DD zdHDmwE2VmfSOv0&oBh=rwAochb~96OsyHC)yCJp9l~j1@_sehy>ids`r_&a0cHO+F zJZ=%p44K!oA}j?0hyG+aEpN#*)VWP6BM0-mDqfFgwcZ?25`l_bMyCb^=1Y>0gcbH+ zX&Q>p?!?}syUe!o0wDxv)I_4GG0+48D8GrbibPo^YO$ zrdD^u1k_U!`HXDv2F0_N_h)CFZn}T+F1I5SSC_DiHOUGSAuuNRp`M`W7t?uf1+~cGK+ruxCwixZ}5_h!m>#1>7xYz^*y8Xf(Q?W@kaIHX_-hT zOG33;8SV@$1QjYEJZNGkm?5$rb0&G|(c=Re0@NtMmf6?3k7v)iKUoxmdOEY6FY?D& zP$T{6ay6VANjO7$a}w-uvPf^(z`3XKgo`aFG4PJ>jPTk8v|Ib#f*t{vpnM6BmMZl? z`60OErCJ&DK-s5K6%rcPGF-(>SgN1z9LwBI9u}*-bbN>n1<$#?g28zK zkhhn#dV|39K7u!v{DJXe+vL_jkJ*Ykdgo;-0B>V|wO-I2Q2+;u)dgUh-utBh`_*;B z2ZqQ05*)v1@d$e@v}Sb%=XnMANdW|^r+9%7leju1h$94&kvI2`<TiHxq+~(hIomUJDzG8vJTRUrJnM zyJnz-fl@&Lwqh^Ik@7G&dn&6e+SWenew91-6(f4v&oZY0HOIDk&jGBfv6TW9owcwv zdZ3UFN?N;;wmAZLVon?^EwxPgyNY7a^^W+nlDx%yZ*rk4Olb>^q_vX=bb|w|CQi=|mX!Zmpw?($I( zRJL1=4j$slncH0Z$ZU%5^@r4ZgjUQ zn9pxGf1Kf1CMhdAkc#M(w?4duHurj}rdOnU^xW5X)g8MU{4L9Gr>dB+_Vk5!p37Oh z%PIdFVeeG!4%vVWFLV^@byZOt4^F+cjG!>Lwn%t6ic5wqyRcLkWEtH|$#^uOl_ACB z|Hg811-@`yzj}dKK+KA(+O_DL&92$~pO8nD&+L4b)9w|_Mm?G$mOMit0qgY`w@dl_9_rAe>Xy0d6DmK5J_7QlTaCeA38g!DRJ9x=Yf zv_dkyz4ZY>VppUj*64=|Ex}w1lI*Agk>qfejTsq#w#b))Mhzj+N|LK9ein(_Wr-R* zfHF^1+3V8=(gUFD$K$uI zpZ^w|nMc}IxA2!>x{?+xMO*?2vyD3MjKHFW#mw?)_1hKkT@kHFHX`V$OHrikmByVF zC~ph@^L!GPkA-&T8jbh}F!CxzRAM7ooqC$Sk)h$1w-ymiXQqkb*N90VaTJu!K}{3c z5}Pp6n>Lc`Y>HRzpI2_=nBm9=C8)RrO|ebA^*9dWdm7|O?VBIu5_@%yYZ(3T49i>P zxpuq%$JA4IRfB0od4d~8Od3BDq?VYykR2+cu(JdG1DJcfKO%30w57sCV@Vu|2-cm{ z7-~D9U1i~Qq!*eWs-R=r8A!AwN2#9elK}u~Gh2Uq%xbYp{6VzjUKp|PLbbJ--CpPQ zmONeG(C6o-r;7##zTXcTc~Ui#dt(ISCD8zyX+_Ws*4ZLtGq0LfQy*)FyrIc>c*i%0 z6GEM-0G}t8LMCdPo=4u2i`AP{d0Y^~ml?tv6rl8B zvnkQl+GuyAjeNF?uCPhV6fdv-r$Ba*oiNs1Lc%DUgw_>L=t7y_%HNKM>cQTUSMEvI+etw0Lg>$mW5c;{{N<3wRvP`z{@?ntPVs=$o9 z<9t&0k!Jg33&8O}7~|ZTmJ~Ys_el02qSd1UO?)3mHXAkfiMn^wGp|k79*8bW{9Sap ztMv{M>^NegU2_-fuzyTygM7k|-llrMEsOIx)Z2>pkzxUBkGAPoxiQ8hpQOstC6i|$gqJz4iG=V}Y z7N!p4RDo{?eV+v=$h<49Y1gDAfI}gqoay}XXR`dn2StMTu76mMc+Kp!`jGG4>JLN~ zh|ms^hIk*8VKvhfKhcXh3a@iKqFo*I)WK-T<1z%XdS&6bRWJ}EQL8Ql10y~T!NQY@ z%e`_Id>(UX3qS8&i;?2NqRVl*QgS2b1O=sKJ`R>M<$bh(Prw&KgC@*yo`C9Nb^;X4 z)HFfc!=Xl5*U{n3muD7&3s*V(U}Xuz$|KOIGc8mlZGPq|KJK+}%+)9oS5t4-xBF4! z%B4m3l4Dh@Jg&q-)&nzC(iXz7e8NV()B1N+e^^u$_V~+NJTn*XEPS**;K__^YHH`f zAs^M~LBM|iJ5mT8U&5cc+_#ouwGcmw=wuiS?(+>4saCB5MILIWP}nKy2Q72RsAU%Xa_t5Bbkm+1K|;zAVfpg?1_Yo~c!IfQ~G#sTA4gP#yW+>_K*_WT?eHaO$6w;SJ*GcD(4_efd`3}cNo6m7y{ms=dx1RHJx2ltv4N3`l(U%L%2+y%%SypF-tLE~7;+0DgAz!}Fy}u?kj`)5lDvB~u zxSasc>SQEqkn9Sv_9)Q1#;adk`kaj(N==L`X(`3LY1fd%$ZOJF5p)$6<4$+JJNc?- z*Ti?M!}8^9%+c=Xl+MCFF+NWb_NemQ%o7Bd-y4mUj`UEMaw}?O5p~D+;8SG7Y{y7& zUWk2nhkXLxyo%hg4Z9e+F6da7P{-BLpbjyN4=Y%UR6rLXAb-9&?@rhGsu{zimpxfO zrV@u!ToEfwDIcz>GGad_->g4eiwtxu;baFH8Rn{+-=Q^>rzhn-CcV*qnkh0bGD-^Q z$pm%jt{#OMb$c-CMQ1O*8;pu}_s#r>YfQFAc7ev*-*_4S$q8HgG%z&5P|1(s1;GeQ zLiM_W0mf3%KA~9FiSSu%dM#eGp9yIvkFWQ4Qt=6@tsSpS{)A@)OIqmp;*o<2cJV<4 zyJ<74Wn1V*OYPWOqG$0VBE2mme($fRwk>(+$4~4HLJ7EUm2;?tbZCh5n^Q_1lg;%^ zml2zQ{U|RLoV+&dwpgnnTv<;|(2fivU|%pTOv5U6YInROr#3?JhzoN{o_|g>BQv?? znQg6&RUqmYYFdrzuZPT&$Plb0zUA{+NGKfC6mPXjSJs-G)^{_@=v_JA`Rd}v^5Y_d z7suNyiy)Dz3t>*>AmNV^9tpGcb$w(iUTUBpCUiyQ)Tlip!d)hyU8*;F9zia!m~YX~ z_1&MYs7SJwEtjN(!c%s)S1fH-XRdTT*@d8J>RB*n0-=j6yjBt#`q{FN;*x1gPOA#` zE@qLVSS8m-x;LdK3tbS=o-Z;95fRF2f?7{wAjmLWLQ)Cp0c>>^fHL2!H;A&wE9}0V zekkznc4l<{S%u*P6Qqe>PDs2FU5H68#6s&&h|Q~og~NN>9!7ZO(;Ij6@Pzu{zJ1dG zU0Ga^|KLR^QCGdX2LcpucWrVZmF=Mi9|3pZsGwgjFLw9~z zDdltbhYx0*B|G-cRAXVOv^~hd4?!H>+ZX(9J?8|x3ZY44G=Y^3J@ew$bAQgv|4hMu>hB1BL-g$=l!P2pUB{NIje9 zEgIBJb^tBb?C|b9Rs8(GgVlMZCWAYGwDl=R|T8PA2M=A#uaHm zSo{rqQ+*6Rmexf3sN7ex8Y-P&rE8XJNE>yVGxm(t3)N1!yY5uWY42LTv-v}plUbuZ zUj|SVE}q28BP#7cNKFXW{vm>lOYr0jEl9P^wJ}_?R5|Z{%aEQhOnsBtvx!0G>~s~> zBg5CbW4%e5QGL{cVB4o!p%^{6*(^4r^Y)RhO=VK4XY{viuY2=GHnTs#1U~uODEM#5 z#K0ijsRzORZ-XjF5}W>3!TNr*(ph%Tw@#sF0y9-v%~^C^=LXYrl+%{%ug_g|;Ng3GvO$5HZ+*($#;($r0uY>{dCM0G@2Ux_YQZT)j=dC3=0hhslj*5Qd1z6&|K z`-wZDLz##_wsU%gU`t&fM6YHKGy+y*ylD~H0)u$PgB9>RUc2|6u}Lv57!*FTui%n% z1VPh;^UKZvyo|3#EO;ye<$keYxH1gNhUjmsb7&bbGPXK*PBF^vOF0{^;}nX}F$8^- z^T{OmT~>TdrObJoSB?BQbgF5b#ND~O*+zJJ{_1T@+;h+ikZxarvgfY9uMn153e$X+ zx6d{>Hx=oO__HyBt@Mli#xJ`bNZj*!?fNIPweI{?*~*1S7Cr^mgtnAHpn-pu zm-i267Xu)8KR2G9ej$E$_SWM#YejqM-Cuo%NieB{gzTTc^u+A7T}oa})$+V(GNx%J zEM@ulI=_T|Hv1Bu-nDoeq$gD%B6yN~WG{2SQf{I^YM1wb?-Oso-;7v}0i6$E7CXGR zwXqlcviGZT2##;TVF_eyJ~=?%Oy%faaq19XdsQgl`&b*HoHX~QP*`BU`p33xrQFyZ z*9`-}_cXrS zy$C;U>O3`6>lexchHmjT~WYJZPoj2HaCHK`DC8d_qwmhc@Q9lFEn0kf^4YkhAZmp-e*b}=n8GH8}M|6~$yc);m zg{r$bDKeY@>H4Q0NFZRdGAs0a?K3qvW#7J-)9cRA=(`>oqB1zCG&N%#``X>YO&o0v zwPr?Y`PhOi2M+8*$50z&+;|w+`qoch7nz!JmA)x?-Y@jVm~T?74i%AcLafuY z6UUi%Px9)8>!LMJwmiI!n zS0%}p*}MODIXH-N)}l*zTksd|<=eQg8r4Zi%L|E+C`Tly5x&XM&3ux0GUd~dSENN5 zSHI$FP~7P53S(7;OKpeSjVFdT+fz*q9E|Q>o@mSTs7f9?Q7J8FDF88PNE?1bF&S$d zfOd|qnNA97=oMmnpuTrjB=|Vb?8o>@7ll@k4_EXKZpYaviLpp&t~uX|{2 zglv^`dbFpO}P4E%O64NSJNwT*FTq&tms3TPZYBQB=%4 zZBgwYLC-+PD>3!3)j3ezGX}1=UydWEU+}=~_$1G_#l5bIk9}?$tf+C_{UQj&S5GP) zV0}j@e*d`&GY11t0d+^v!h?y;QduXg#9X1#xkF5rc6{jOT}tUOs|T_A*-^>tj4#Hz z(iVs%45U0COo|$Tud`dVi$1ME zPoO8n?u4!-bJD;1ewHzT=_@MF{#&Qp{_83``}S%6PR`z*EYmrpnMM0k*nMQ>B?~}4 zL&oX7;z_yblr}H1EI#O$lwTO82uda~jp8BUjC)}k&I{EjO*`*iG4B;OT}-rygz@tA z7aNTdGaESDZm#Tk$sY08PKREzj_W4yf|^Z1V$*x|KDk9h)aqk3Cz?6l!ePdK4=ZU7 zVLc_;oMQKZ_p#O# zP=o<=P#Ud+1>sLhE&t`d(WFcFqq?s~3F$H4c%&ubC<#(9#hLNXaeR80!$?+n{Hb7z zB8m6q)2c2sZC@DF)E_7o84H&jO#_|JBK@^XBe8;e#Yo7`oA96~%aby1lqr$oHh$pRI3KmH zz3W1BF(3Ivjx1Tz09lUON>!Oyxl1X-kTR6A4Sow9M>)YMttz{~=SLg^&*-xHe68Fw zwLeV6L8bJ-06fkR!1n(SOi!*id+I1RLxw zP5Rcy5#Gd30Ky+;M4_M(kq2ki7yUG8S6HtNa4H%9eB zd0%B;$TADP_FC~N+%AgzgIo;7WO*YRlWuw4S1M9JEi;*uStsv4_mZk%rMSmx7aFt zdne8B`UyYLk!IR<@)Bl{ghNm~<+CsKOd5R<(yql04dGUn`c)Zo z+SN(%uTOsq=baUTgk7!}7^KvEa2!oWokqL2-9Pkk~tARDY=I+@vp) zk#IhFU7XL*()?+)yY*G;)M}EoOi-TxyYi0CX0REfvdML|-36!0@cepR6M=z^Zx|#P zTtf-0ztf!l>iwUZF?SuPf;ARP0?rHe_K03UO1y;7Gk9~&NJ95LR>xjy@Z5%88ZxRC00ES4$pE@D9GX=gMtiqoRE-A76`c%lT zKd}Z?M$+TI=@(3buPVPjb!%}RCA!z&fvO|0`X!yPgTQ7W z4xfO_MeSdo>GSqVY{PH;tAnNe?IXV(#lMgB-`DluW8mLo;Q!eeXtp&aEhq{+P!hR3 z2?Rl?SI^+QI{ucMokW`b@qc=nXSg*DP*{sEHSO0QWG}gc zN}Bh~Z#^I{a2jAj1r7Dt0BC$G>*eYh-mr|_(cB%c-lgf4Kd+OonHk`95o{?^;k0l^XZ%ner2#xss$e z>X*gjs1Nfl_7H(;or05ctH4<6@U7Qt`WPce9*=}hwj4Ek<46W?N~B|oJ4nAaYIFGL zzRWEP<7h*NIA)fkOdRJf2_MTL81&S3n(6u;ojzERh2)WAZyRX7Z6?xDmycy#LA*`l zMkV6?IP`FU3~>X2=B-(|g!#)+BB5$Z@J6G?vNY$Nguxq$XELsXL;mZeYvog=Rr6_bu+NXuTd4_V-`} zyCM)wg@}8=&WygYId>AfAQ7&kW-Sn1XZ@@V$M&L6#dq6QZBou4)eo+~-3JH(Le%xY zR)DxO`2Z6oFi6W>e(SrYbEcaO{xe+4$LJQQ=%b|!A~dRyeJ1$`8yKf64k+pkm$U4+ zR6f45y2)ouo21C)$Z5HmZV_BBZe2e`XLlnp5pg4(*Hq&o$bw}F>C~zqOm%@4JrS9U zGM56BLzQa3;5mS~5&pfMExVf4#xDP|evA4#roa8sA-mrS*PL&FQ7YE5gPa9NWCUR! z<#<<+rd50dRwH$pPc3jltbwcj!E|-OkNo4Z+7Q$jL z2fiix6O`$2{Mu+&7iyNv5(wCU3LOGs`nFqQ{vF5PKdF~rJFtJG zRpJHTo_0v6B6#h5oPHs)VRGBzUuKvyJ(r(f@H4CX3A&Pfth$<&8h)I&{`V(4-3t4< zq)X&K-MsY)+rdCa9NoyxSVv~>v)i^|c!}Yg;dtYDgy`){UuI@<0+dzQZ1xy(o7DPs zDAl{hEwREdLOqY?@)Cl^!6v{nxt113YW}0j>pLjE$aQj;~!q9F=&P1j_yN&DIk@VYZk#s_Hgt`v}VtVo0ZwUZs_9@?Q zPt_;Npr|AA7m?qqa5}nqQ@xfN-wk~d69LHWo+m$J$2mPTlz)jCviv~aNLuQbUk*CgNhPes z!M75Qlb>}MgFBlY&CBB}b2q>KSo=O@Y{72%a-_$pyv->|3^4=%k3$(@xjN~FU-b`) zQJlED=}|WUoU8lV=~W7ZY(bJw(&f6p!AD7bC&!%@lGk^Tn7xAaiVI4Fo56%?)P8oM zOX$!J`Jos;5EX7fxN5e$2BhFV1=7pko=C&7hSRAi73_{RPuJf!E$#200g|g>G9$)K zWrV(oTI_s-8Hv=_U(NDo`l*86-&(^+*GD zK)WY`Q>qrv#Hw3DzY2RWuwW1_WBJAQCOk_gQYMEH0};xYLiL>ukPW?fpF)@Rk8g-rxs55I26twzCU`9)OuUH-z}@;U1$@8-#d7aeOcwP{2_)j*dVtZ$#V``@}%tc zIsp1#4t?U8Opv`UzY>BvB+8fiBP-$2U)jvBR-G#4_rqeC-tPM)8QM((fB%0>=(yuM zsHJh>@gEKg``uI5zl!;3iS^kY({bRjEj}^;9$Ufv10&$Eg-zlu*!O_P_FuEeYVHiQ z#t4k6LrJ(jBG3Ti8h1D7AL2kNr8&3MnlH(ok*b!I2$%9C|Jz*AT4a&S=jvEPEiX zCSlm&@U{H0BF=rd4r~6IHa->#$pRA(*Br}&uYI{OX)Rzfnz6a^t$(8y#dUSQYt`c` zK75R~yFEeXi|PcJHd?IM99ash!yX#IHdAFw3+mN#HRnB?-Pg3yATW(0CsDK~n?Tfm z%3sJ@+lw%0%q;XBNZWfrFicvH9MPnOmcZ)8+D&>qi)8oFv@ zf2QSCciLL-Ihu)IzWJ&*3EZhTO!IA&;@6j&b$l<+0 zKv@$WmkI3UQ3}1t%>BzV_`iD|474DL4F8-j@&q}$3EvZY#}~Ym)d`5;eO$ZQ5hCepWxAyO+7jERNfpaqn}QF52GYYK;UB^tHf=gAjyMI@8H&moa3K{EVu@u*;IX!n*QmJo1RZ9>C*$`RQ+9m$7 zw%0BtzV$9oJ$7Gr_cMw^!l#(`#=(5v^eh$_P6c8qe@*GYgeh%|rdQPxIe@HZo&ILU z+FqU5viFB)Sx=&8sJoKtsDRb~UN1x2;-L#Z(j`l?JcJ`bQx!Txv`Wpr3*iDI-DVxP zV%;F=OmjzENi|PCg!n`7UU7I^@D5O>HMMf;hO3=!Z`dl~2;wsz0V1;?@vuC;XV;yR7G5h~Wh8ThndBsE!K zw>+Zc#$Z0((;mfmKgF?85_h1drvO^eq1qIXOBp1rh^6r{NW_;lTB{vk@(U*KT<`6|Gz}zNa-JWi&UDb?8s^PfTi8jktT(9x3pY|C z02at2TVS2~G>X~$ln-QRK2||T&;1@z zQL#SsU8%mL2Ah_Mi`s@Sf4wb#Z?~HM&04_b)Jnj@C_#=95b)*xLn2C7bqQ1ZZ~uTl zHrTRS_QV&?b)H5~*VX+!uKvH?_WsA!+J9chjkfzkRu0+Um~CndZe*o~AJTt0z3l%b z+HlR`O$~mqs4|wl{IVLG&41e=+g|co|IKWfXooJC|M(M4;CA4$-^$lQ?!JG&d4N+B zJ6o99>(w8igdRnbAXXAm=5Kvz2E$4pz|yE7u3GDxbxm*6cVy0l+`-3yS9msUvI)24DKscg_t zTGA<8i1n^<`Q3F==l%{7yIYRZ?~ zC>d+g%ks>UlG}h(;$)UODVeW_da^}|N|8PD6W|&#SVuK=CoHG40ZW;jypG9Y;n$R+ z31xdh-h%3N{#Kdi(y&RTApamorqvU;aL|1qD<3e+#S}|%aCxAo3(P&1~eHH{S?FsWX>ITaQ2d_4?0U!jvc0wS5tVGCMSH5n2aLe8F}!_GcpO5Z#Yl5bc?Rx3g|2%WX4T;#PSdc zk_#}+S(okiNcl)XIG@eA8ETjdzG6Dh6MXES?7%1cDbfdMM@GDZEefY zBe@4{Z)I5o&6T2NjYigY0*!V2;F`y4y1Kn<$~FarAWjkZ=L<+Y)t3_N<;?REO`L~*_98#d>C z$k$%WJk9wIF46-PVX@JGM_Fz0wU)fB!AzLCal7GK)x*p|7{dSrxOpLf(vlZcpmYyF zSyF)X8=;dN+rmE&CubcFm{t1U8{jV(0^UAq&|k~ke-yoE{==4X8W>-#Ya1t30F6Xi z*?~O<@HUPz)cyv*lU!O6*d_p#K}>>!-T_x>R2@+B{5Gx5`7k8G*-mgUevCm$K|NT+j$si>HT*rs}wfj{#5f-0%R4mdxM@y>q!pE=B^zWJ-jgVYE9?g+Jv9HpS88S zu3R1@961xD_}n~Nl|mEL#s+FtZ1!SL+`6>iO58P-o5Vx(4Y_9z#>n_iO+pI|H(OuL zZIPI|`U=;%LK5T$*;`RXB$QhfPlSj_H#}uI1l$h_mq@HxF70aH_ImPyBkWl0Bu22g z0gAp3Tb(cZBRgQg30F zU5mAE`_k?L-IaeibZDEH2&TTbl-5&Llg9yt;2+fY?DZ!Oj1vdEs-*~Qw8(gNue*#; z3Xa3O(y`p(`M7<5WIoU?+zns&971VFq;oo({Sokb)%`aB=5Wc1R=WkQnnU&2*a~1q4U;g80B?drN zseYW&rvUBU3|t{O+r}?%ctF7&o;Gf!KY;GZ~xm`?*8$a zwm+`DXIRE4a~VT_`!cl7Jd4?_Rr<&p3S(IoI8UIFp8iGpW&-a9m19m1)GtqYfIAM; z`KE8Xd7g{?;PHi{*k);md(18aL5dg@%Pzx3XXZ95ZW=|PUs^@!!{ndm|MS!2$s&*B z%RO$NP|sZ}eHZDp03ntIQ<0fQw0Li;&F9wiA1jd-h@C&<6r1^iO{}%lDJCZAMRki7 z@s#p;=136a#ZAwBO0`2OTh@hA`{hNy#xv9llgC?>!%LuY&geplwK*9)`?T@3@In-;R`>oAzM$=D#qLh^A zHUnFC!?=Jtjv`!5))CY$bN@_INug4j(0efp*chl&gcwSEh$I5Ck&SoRCCdi^gT$eC z5^Is&p#X%nc78mjst~kLaaTfe%Wr+jiV^D#Y|t8Rscks>tYDL|_q zQ2=1pP>>TptH?bxkLN1LfZkIR_wpyl7F2s&M~+mMcn(0XF+R_yo?&Zr(HX74x?u4;rD$ek`J)?DFm=x}9U8nX=s=fQ}G z3NUdDf=*U6Ka>5Ei9a^k5;|9Vr^F)d-4bhiBHkxQ?A_2VxDmSuX= zYqc(7Syp4laqVP|lyEAsR!q;rr@12&*)F>F5;O~|@!qeHjiHZ_CK{Wg>KBvWSPmXo zz*?t>`-a;)ZWuaE8zn+``=7P?*+13R+q_3mH0P@!awq-_IX7KjJ6 z`R|8U-SrL9&17)@aKOZywSHZH^q0m>g9g;gcGq08iIt~r=Un@0R4WN~9!@3d>?f*t z$t9`%O9ZUfaffuZ*3XjW{ z=osnK4vmDz)NN!+k%+peCgNp&dAy-MYU1r_K*IIhWBsb}i}x%xDxTv$*CQ;Z;Y$X! zmqyO}XbZ8te;0=U^No@E>_WEWqa41aXXQl5x=yU^yCyJbXBH#^?J^DDOa8^K{Bz%J z1Wmi8*-gnONA`~Ud{yoDJg1GeV_55bZH>d&y|Rt( zc(}d2G_{V)G%^VKVn|9qxTII7>uf5_~FLa+<#_%Jf5FoDF`J9eaq`b%g zXK>($zCzjW@VU2xm-@CYv`7%RR|#7)^Dr)XPxLLi+`Fx7f(9Q}T^0F@C;Yz;c@?yN z0@#!um-hsqCW?9pNbdn%0a1a#tif>^;5h_8l660=mj2uC_`rmkPT)%4I|=8!Kkflp zb2r_8t=#|6F=QJ2o6f;y4)p@M?(GJYnP+|{Jt;oTQRDX$3FUyqEad}APyE%`)Hy4q z7pfD%Xc9iI{5z%QiktTdG62Y2_yQ>8xC#{tBxj#gNEF$8pO9F1s2&_@7Jr3C?w+hx zjl14&{Lnw-^}jCdANvd&u8W0e%eI0PEZMzAS+O8$8T7e4UnT(E%AZW-j-&?AE%ShL z7h=8IEv6&i?Mm?yFHF;W>cgp2FC(enSv_>tu5kohPG$mBOhf25lIVduB<*ncBMfNj zFwDi6QNSCtD8?PO_uDw6JzVvfTMUk-N^;XjfZVG_wo(r-?Nn>#o*`mrdyCVG0^{N@ z&h#&Z0H6$*ylrQbFJo%+KAx!hGZk9;YmFy~#k6b=8{5##t7yCXmuM<_h_nOa(Cj5- zEhzj>6rmPCKonw=X93&Q{V+m#D{uqDSL$mFuimbT7&q!{IcBT+Rt8uS;8<3|G4NT^ z^1>#7K`=F+Bo(ewI~#i>=XyNidGq zB!>zl6Vu|%-~;#EgIsu@57`tP;mX{!k9QrnRAzSXlr+sB;M~3JNWRArVb_2A8FN

TQ3I{LQ725M{w{=Bvt#P*>&Z=#9RN7cp*fTKt3fp_YbE+w zUQEv{WmW0=3|k8Qjw_prj#%IQ5FSa(g5waUX+}YkE9Z~-o??Gd&hC}HlH)llb#dwQK*SzOCFiJw zE;9dp@+QI%-b;?!_zn-%AClp6aJm@NN~ylade%WunK_84%^1Os`7n|CHIl#B(6?7h zLQdD25McDmaN61&k`Hr+b=VP*NeH2La_wis=-9@?8gGAszZb$_6FIKpNp zDYk_;1pt<={}Kg zSYlOXA<6z^PbRUEg9g$+eABGz;x09 z8ek4zj!y+Y8m2_UniN7h+EN&mTYM~oCtX@RPHHnBg1ETW3z1_Qzs3}`% zfW&9kZ{yX55BuM>q(3U32>Z+mI+H&DZIxDCsC3Bp5SdOWrM=I zH;0Q(itN~ig-yJe>n753E#g`fTVX9?hI%uDnfxw}KAG0rH#BGew(b8v+_(WCf9*Gb zszPYBdDVf~^4iM|Cp0BFw8v}V} zL_OmWMCW;2)~XHW*}Ty6uH~-8OiM;PZLK>cf@6bJ?!7SvjJ5pX##Zv(gf~`#GBb^j zl8TC&E3$;g<*}2V?WmSp#+voc#?Ga1BW90Uvai)Gi!^q<6QpvrRTQ{P|Bt!IK3`q} z+u+SQmbEGRiV44oq{J6Qb{*2z&z4%2Hx_d<-l0QyNGH;`hY~CI6lThR2d#pF;tv6V z+n;tK#ei0Zkv(^Zex!Z#4-Xl$9QNN@JF3fAHU?GLr;< zzZQ;-mE-d})}|b@z=>-eM`q<{+vv{aCtguq;E4|+?+6e}I?xdrwD_>T(sO+KbN8$d zYR&eR(8a*&`T5F^y(0C$J~_Oz<{hCDR*_beafY#gF|f8m zEz#5!jg@=DbVCPn+51eetCav5vU)aKMSA*^L2)9 zIc4dwF(}*D?5q>0ZiuG$t6)d#oG0^g7)1JjoJ5q z!~}5K6UQW-1MPEq@0sH_?lSG)=WEeEAEfMPaZtX?eWn8F`c!Yd)~X&q#3wzF6yd$6 zgtRXlocQ;l_@MTDHIw^2Dcl)xQ$LFX>e&R$SZQuhiM+MWz16X!aLq-akP8ILeFd=A z3%Nb?iGS~Lv%NmYzxEAQ-ckRsfzO)7)C-OPb=aV)0h1lTex24~u|Gk)E5(JVEv@DECVf+pj(%}%BL|Jtt= zI+CV8M*NVgP&tSh>^CkuzGehpZ$A+Fh3WjZzwZt?VD@v4+TqIn&;MK0>Z;bZ@Zmhi zf^yia-G|~<57PW{t8irHtDY-SnqhY>M~hORgMOoSV z(!7kptad7m{%!NtPzW8!B{&j;u*W1dR4g|SWs}UbT6({2n8xq@idHydU}5a>`;nP+ zIN@5278AqqLvLWzK43ok$a8Ks<=gxCnFQj^Clo4jDIX^Dv@RJY=E7o}qN^%)Z-NQI zQQqGpYSJAhFKL$*M;xWa;$sZQrPBs{>Ut5ahUdcwgbIp?&YWbk$WWe{Gv_>s?XI`P0N+CM>qIE5g0eK z*&c>NZ|g6uDb3zJ2{v|@BNraCtzOrR{q%$l$_9pMgH)td+SUr2RWOmvMZ0E>A=DsIf=Va9_9X4s&R^&wB`f$m2 zs7jWGdVCcTvhg7S>hWA$pQh5d27*-jhFwJ%Wb^E&@_Jre$t;N&ABywT(kD!mP+w=M zwT!l#0gyE^enluIX_D;R)|C!vjZoEud(82(7kPUYaAzvvp{T9pzf6=#3Vi0?9{WK~ zUFR;W*qnb$&zoN&ky7C#8a{siTc0bdm))%U3(-5;v3G3Lc$C$k`9>%Ff(mx;8Cu9$ z1GudVsI~W)#i_&Km|^PE0QUfao8>r|ON}?u1z9mwqXpT_&ng~l5-9%CBnchm?n#N{?==4ex%p?tOpbkI z)!w!frkcq{MN?*xEma|KDLp>>rEseJ%ePf@R>`hCd<$931MTlGs{w$f2jM2Lz&8Pa z|5$@;y~j4)%8c%n1_Jc@Hp1UZzE@!7xQgVMs;P%Rcw&D zK4WD_rOuAVPQ~LkMSt}*9g!$pQZUHH>>>)Y^j9X0gK36l%|m|OG4B#oia{=qdZLzo ziGNreP}?_ZKkbR4y4k@x4}%IshQxaH`iIq0k!3tJNVY2rf2_n9p+Or}6P1|B<`Ofq zWo*`*eDDbH`-bnUFZu%N1a@tB-A~Z2h3>Gu=To%}_zo~->;H3?bIU*Q0+z0;jU*f~ zI|v%R4REbo2=o0Pph%xt$zRKAGhkV5`p2?b@?YQKcXqfSzH~@|Ol-XC?GG$zij4ag!E47|X!5e>lbvEU+94;6h?q<-Hs4vnbg&iQ{IXre65L>YV zgE#J8zVYtOBxuH2p=F`lJYR{f5KxR_pg%ip1SracnIo2#{g`Eb`exIMxEEOHl zri>X}h(2eJ^28)%jw3;24D(DPH!6eko-=fJu081?c98Za-H067o2znI?KUI$12?Qz z z9bhH+=-PHu7ZV5@Nd)1zW-*BN$}mh+wFoVGhq(=1O1MWQaP3YSuaZ$onrKspXoz@~ zq3F;>ZR4=ZSQMT8@zK|Jt?@5wys-|wWmB!QCXpX88UoN*YH2w`eq3j?^;2T#n4ds! zKi8%C!#ALFJl6cmvw?5G`c&+wDNo5|P7gFeX!3oa9baYAbdkAm7AEsgG4^WHbhEA7lyi=JHQPjeN8 zVV9&I+}z;5=*5BmN;Sj`W=FnRJ$LxHK#MHb3+TJw>dspIW|O(>X)5qkW#dTpi)q=Bi&JM+Zd z?1X5=SjItLpbJgSIuyQh-B-HoL0*5n^Xhy}&s@cEyn)8US{8(gE$AL-J9<;3{hr#f zTKkWDe!Yxt9j&gvzT&EVviu^y-vQrv2Q-_PA2)s?&`c1F=d$pAX14}>@qH{5#UYF{ zxHNVjPBLN=447V5?&^eir{W`)PHAh0JF)Jc0Dvfv3S~MpX=IfDHBVJID}@LRq9p2m zKFz~iu>KR|^vyT^aaGkxYc#w84sds}@GXE9!+&V6LfI*sNx5?uvA*N&0TG9?s(^f~ zhiew9En1n*%VN7SIfXgGvvgp)oM=?T}-FQnn1mhcDF@sTz3=oS{Jopf}M(Y^a+nmPA@BH5!( zWI`KZ5y#R(E#C9&Fb=P*k$XR)SwSgMgLqqVi)g#(IfsJi1vmK%yINlr_ut;*jz`je z9EaB7KC40^)5r$s`9;z*WC!s6fH`bdOKkiPt=R)Wg@HzYJiZ^*9(xXb+GA@2F~*SJcaezYrTn8@h}<6kD16(w(z8B9o? z1!|n&zko1`zC6pkF_GABPygTO{?LEv{$Bk5UiZhF`fcyT%Jl(vmH#bUARJPLA4`mg zC3R|X_DrEj;@JvCg&DZ6?SLQOsE-a(ZPQT!vulzu_c&6=uE;ZPxKZX=JyI%vEb^w& zwNpYvS^HP9tT7Z^f01Uzcs~2CaG^>BDVV5s0lP4DQ z@udsWQSMQsd{ox%T!4)G5A8Q6WnHVQq(tu5oX{-XTiphQsd>Ick1Re$U!Fu91hfyx z$}|9RODr3GdWHB~fFuDo#c{Nqe0&$=`{T1`5Jsae$UuSBedzJUB$z%q~#5 ziEHuVJegcRczuGeGg$XBy|@pytHZ^aw0zne(5kuCLX+3X67gQ7g@}TxPQ|P$$UC^( ziNJ~H*Y+4yeGu58fk0Yr&Je}bfdZsr2Z@$1`F~#5g9#==dBL14E`-8RJtrl_?j!e9!u-e2$`FEIk2>&8%$ zQ@rJs^W+}s_B(0g^^Uz6+9==sELRVMpsR`{cb?wFLC*s5JjULG9G8GrfgbroyxGYa zbvS@DW5zg6OSvF{Lejmb@0kD;d5xR5KwXP@QdvEbPxKs^kt@oHg=`u686bn6x%>pl z>71HP+kf5fBgC&uxjkjHQDph56#!G^$>5k*|V|mMC4;j8a4LKrtihnbW+i99&`VL=a&Cj2r7z7Jnswsv>xgW&A>R7{MVcY>^ zFuC#{sEd$6EaRB3ajn92(F3k5(3(j#GPV(nqzn(fw|PCIF!asR+*C>cD^Wo2O^ci4 z>o92V+D& zN>R#a{7v7F0ug_jy;RZhzbEO~B}sa-9i897$?j_HY)vee8!JV-%Nm58(c>V+ui9{} zzO__w4tqAay#Z@gLdbavthBM++!yclOs=P~#kgFE-FZbrnItR;_oSru7bb5nIF`5? zzvM%Ky0F0_I5$Pe-oKpbld^S^JNcj!Z1XU(i$ADo?lvT_S3PYLb?2>CiPd`w#)NmI z%+Rr1B)bad-r??*ulc)vW(rrJY}PO7Lmxvypo%Hotk&E5oU{j(La(+*R*hDy?~d1+ zQ{XrzRfwT&r%4P2Lof0+3qm26Vw@K$z1K#^izJQF-t3{;lSYEyZ(J8G$avr^%508^ z^fr+Fe60Mnwr)p4%=(q0v4yNrJWDHwWSJ?y5Y6$e(gB*66KZ_-iy=J~_4SX*ncJ|$ zRb-joJ81#UKDVjV_`Ky&gmb?AMJlt_hgXarNKOa2lt)!MOKbvo*dUb%-h-jzSgPM@ zAm!P0Ql6xn*fOCYQeyfZm$={onHj8sp56ydv1Z+8(y7`py`>R>95Y`%USTY zdvNqy!jL!`{oBF%X4x@{iaGl;09C^HuMC;K z3vLMqaA2Nm>nO`Pju}^(Q3TvLVu9$Hho<~PnhCaoZEaR}_&{JW-yBEJI&S*4k=>k( zyMsvcGW*VjtE<{ul96k>bdMjKn#;}Yw{hFcf{w>Y*wPJ{vZhQuyC0?&-wok?$V@E^ zatV#;2oj}og!WKFAOf@dv6Yhx)&~s&s`X#TBNec?p|37T42g^BsObV^WL^w$ncb%J zZu?YczX05%YiQY<-5}FfZ14t}Ug^fu#>y(hHWm3OpyVav{J~&vVr}^S+(RyUQtmTc zQ*x%5jxhxo;c~J9tWYhr!V1}wTcdi@Ki90kh+ z{RGi+Wy;$2<=g8oFNDf%krP^WnSbxlxn|j37>%vrb>Ul!;c8ep?@bN6=$JvEEm`dQN9ty^YvIj)_H9jc>hqeg zdfIZZQ&i2eUv59&zookvnC(YgN^VMH!g06}NVdhl!8#pY?u!NZPNo;ATA3@8s`iK^ zjgVkB#bS(6h-yn2WzzSLS-K)codW87>p&A2nOJv>gQHr(H|@={3Hxd<`Njh*IxGsI z#(Z3|s&WTleM%HX_j}QY#xizaBE93#XZs2+ZXH9Idu0VO$z;AFhi+lhOBaUBG8+o+ z#E%t?KXW&G6fW(H>x?jfwzvm~MV?wz?M&l8KK%)rD8C&wS_z+~6EpY0$@Xd-GDTTc zmq#|tO*C!uaTf{ntFJ@hS89Jhf;r#NF zs`Cx%G4zR>12mB0KiSxe`eetDH-8Cr;DoE6br2rz#Qxy`=n}HsN$>{Bkf@)arv9Ix zbMtSH_W&^`K!d!>SbH?-hxsPCm`9D*0<3Kc3BcR*_%6q065x4bcI;Sb5aYHJu9J+cIAP!6yoj0l?@R z@CGly;09Q80yO;G)BP{&wVS{-6?kiLJWSzMRRe9(Zu?b${4FW4CA}}dPA)*n-XIZs z&M-D_A?Bqvt`}KJS7?o<`>yr;c(6rzNujHYsO4tlgS}REe2XTj_lKGP{W<>R8xZ z^p3rNY7khCouL{ObOlqf(}Bw6=cwZ`DX zw97Fs6ghA^Y>G1j4!igbbVq^`-)iFsB1)-OyKT+5AMZeU$LfWeg}-~kqtG6|U<;(* zYRpt+ranWg^LLFxmmIf84!; zVwv5GY5Esa58UEbMznJ&w0$ev_g2+R=$u zg4$NECN9PvCoh^3jXC>k?MnNJwJ@TKUQxab2~2ROP^{zj9d|)sIL*;~TO3V}Q>lgx z^=*D#x>(BVpdMkDsv-=tI4b{Gu55@cvyo&eD7J6v(Wb>fX~|vO7Y!GxLw=J?Yi#M2Gb14cxESS0Xl{YukbKSTL^7 z*^EJO)H+f}PX9IND3?x!AR{leyWEZTm1Qgqf(6cCMQ4Qf>N)q;rTjT*Z#aQVDyDUw z&cSS5YCp}sCwcRQfisGaj7%mJ6jg`d@a~IMq`BS%BI1q<04=K(=uFRc=^rIreXl)u zCTGUFz$LVvS%%W7*LcgvY|~N-8}#g9Jp~h%pOgqvnQZuq-yY7G6ry(D1z)@ib)cH! zuFOP|k8F48CW%$cO_i_21fpdO@(kDjXO>d*(Kaw*f!35Jyu;Qui{d)vf@IK_)ie2Qi1B#1SHKT|C=f1bUxX8X$rvS2ETav zzMbCy$FF>j>}!;|9{>H1yt&JvIvKF<;k8*fxobd|F!hlwpit2VknAPmQDq{MY)40L zwpB+zDCfxq!!7F2RCK9VM%ddbR&ov>mLA339B=sm^Y0l(@5XMnBT4yHI18=VYl|lh zol{b#a?QHz^I`YyIp`HGm~L6k8IE-r2UbdIC#`lU5FhViH!nDwox_59-m_d0CH1PC zjEj06)urFP(dgq-!T#i#7?&7W6m!klX?sw9GuIA|5<1yUKE4gr3{Ri+D2$$!;*SfR zs#Q_RUtUUYLQ|;_2WU!4K(*^vc4wSDNvm-Ul}h*z^Mw$yPW_1qD-BCpjxH^bJB|W` z;Y2&+c-|CL=gt3^evTsG%omnAigO*&s>G3G_g5ame>>Sl{`;Avh0o+lDH!+$f(?q3 zjo5r+$phUvLFc#uU|Hv`xu<}U-xEGa9KlCeyS1ZShl!ICBdc}w+fUG}{urRbF*{n4 z$A?e%-5}qEc8M@@7C9h;oB^HdZeDt}@&$;;q7{$2@H1(YQs7oe^1k@8X#j<^K!7kx zl(yVsr5?g&RC~c&@8g_lYBvidLX;fnSAMrlO_~VLZ1u0z&0*1c!ro-*&F&qkVzZD> z05?CapZ#Dd%bXjay4$85>FBe&G@+YwGw(|JDthjpJN7G5Sa0*Ge?k$L1Zu~@U^o(Uw9OPG1(oTZNvo1=GnV>apo^D($6j|t&Uh9!;V`W)EWbfvr zwWTAInzgYynpze~`1{W)A6oZLD3rIF;9$L_y~8#96}DPo{SR>+A6zF9tI^k;2B6w2 z`tq~XfL%&r^3lmp(8zH4tA@OZLj0vU2*o#N)C@2xU#0fbe2X^Y;6Eb?#&IaNLNW(u zz{wz^l8*Llb$KsG99h;_O_&a;v#{1}GxaC}gI(c|c>wbVkcXEArDKzJ36B*+Z-c1H zLFQC8R{Tzxooq&vaeVh97^MlP@vi6@O30wrwsYvFZln;Mx|2UWSXI%iOqwI8FZUIgNWb zXVIx|T6Wa6B{H8YWORay!+$dZil?w7Ijb^Pkl*y4C8IGAnNoopM;PQhoZ?x&)*s#0 z$QiYB5Sg-R8;JMIh%j1XlB58uyT|&(dZ37zanHzz$<~ufQsuyjI(PHCV$P7N=&1I( z@vSVa^osYt)SXP3M7pAs(rB`!6|102{$WamEB%W_EXgF8`8xq!&SWgRZ9QUvJpyev zO!)7*JCQ@Kt69UIQ)K`}o>?}h^@k1lS;LczvWW>bq0Yb-)&lP$f2pm=y`iN_W5dT@ z!dZIlP!^daEHVzik4ed(7+h4$T7eAS%hwFK6#3OpEkA#FRG*t!_Z|q)D+8?*o$@c; z(a!mm8=a+n&C1`^>Nb+J?nEAAJ}j+t9Y31Ma-B)G7F@W?tEX($Lgj5qTwm7?VZrV^ ze1y@o%QoGxxF++gyF_4e)!PanPH@mujO&DYvn2MCNQ?;{swxGGCxf$w?4a%(^ zJSLle;;d2`3Ib~0)}4aG>WzB{&nVpogJ<5%ka1hmveMNBN9MVE>|u3hZ)A7vt7HG# z;Jh*o{UW)8VcY%xSUC9cH(xZ6_V9p>S5+j>3E}sW|B~8XnyY1icfyYVrQbKS?SJ}4 zQS7l6dRG>Vnt7W&4XosMA?Bx6mj5p9{l9BsW{7>F;gz7s-OLH1j8#Wc>WyXR{g*y? z5MJ>SPeNK=R@-}vtX zqn~Zn9$5+-S!}fRB6qjZ%q`Lzdl>d(Zxb)T^yt71K-{K}Gy|mJ#EUEGqm48=dH2L# zFx#yYJ>P_JcqA!+*b{2>c2|Z_uddTywz_RjZ7d8l;Ndp8pOc`0JQ&J5%H?d^Xlz7D!%Nci~ zi`XlaoX{4ZSpRekgqe(C)$BsG*h$#asurF^ssm;&c{eXmL|PWCk+IbNW-)W;AoYx>_JJU--2t@`EG1?2!_!sNk^N zjKb*uV(+`-noPTGLs1YBL_mp#qM#s%6a_<#=+Kqk1Sx`wO79R#C?bM%1Qlsg1Vlij z_a=nii}VsO^xjG0eQ?GZm^1U8`ki~v@18$miXr9A^X_Nuwbx$z^OI|AsSu~AV3gl= z%~e>Ca$UwuRyB^N`;V6Kv2{<|Qk9Ecg6tIOEp%bKCAL^*E~6N$PJahruc4fKjMBy? zJUC^o`XW0RCC!{}*W++w{^WxeM)haNv1gJ-in8@Cwe=~$*$Xf}N@Ua+)Zuy*OHn@2 z3kah%Q60mv2>7%|pfE{`0>_qqg^e_Sv!&prUw9#@mn7<7v>s?g@NCFbmj(|t+2wnK zf7`o0*@7D60>wyzr0P~kA2=(vWe4|!LiCd;27yzL4Rc%TvKG;z*(dd!&_s?HR`#A! zm6FbJf?tzSnUV~Jaw~(LwGX4yB`KsWjJ7p3xZ&s-Dp2(P+LBpii=xUoo7B&`TxQAm zeC=L1*vCln;f7z~0$rM1O9R@c1LA8H^r%C8Afv9;9s}lw6;-J9a=SGz8_kR7s>Zs3 zvzcUx^W@|n;dOEE7!d7U_V=Uji31Tp3jul+^HKOy`qGu(A&ZMR>QyOt(9^Gf-vXD} zw&(a^%sII52pE@Ht`Ylz`KgIT%50`kMJW{q7>r4p@lkeeMJQ;;rW6?=>C-c^B^Sgl zkTC1(dfRlCD|ENqbvYYAQCiY^=3jqCsFN)4 z=)Bu`MN=ccmG16DHewGCqpz3Dg+$%m%(vI*N7~g^DeMrway%{9Ud#?CRtTNm>&DTu zy7%MYJbMRp91`CldiuL+z4~_#+%2veS>X*z;Llt-odeqPL#@Ey{T=}Jg1}#0pk?$2 zxXAh~O#;H=hdID?fga6CoHS6haSo@gNSiV5jRDY;jZX;JW4{#r9<72)! z1*8n?40UN;s!s>m67#j6FK0f}^inA0lMjDPldxS-ZB9l8uiUl@EPl?A`5;5HmWk+v zUek=dVm?v1cUGrmEz&Baj?o%I?_8DV5b>yexJWjj7;3EpF?e=fQ|vG`Thzo_rskDQ z>C+MCE_ZxZc`?%MaPA2DruBhFc;G7n$c<@0qTD?XnlFw${?ov%PHLPMGP6n1h#iPk zm*=VRR$%j%pm$4gL=nWman0ZZ&G+Xrd*^7jl(DZjW0!$B+jocs^UmdBPK*TtLue!n zBi3~7)weepQ019RJk8OLsHY$}?ahNK$sZ5&u(Gqx{w3%fL&f$f`;Np(H|1cVRxw#P zoPlxVsS8MkYBoM@7b`fp&fTAHEgLiz#byd+^lveARI7e`A1gTfflxFj7d{|WN{@9D z+w#8rmg|lVwV9;8-5b=jyW$^u?D`u{MJrl?oc*7*{vAQ=;S9>Ph>85 zSEnu{!$)B>T`*v-$XH`=XRECGOWKCUz1?;%Si)n`Q3%q!g}lF}I8Yk4Q9O2P=^de~ zv+t7+)<2-)Y`tler;;U~r}Xep?Jp`75`-C-wlvqvrM-Pl$hm8m)6|f+>2>5wcWspi zf$iOsJ=;4H|K+HMAA4gt3i4v60I_!wvWHFnU47sCS2EyuUX&aY=xVkxr+@nNfdmDB z>`^44{0cTgr( zKcAz4Pz|zLWdiGu9N&st4kO_6x0Lta(adX??!pWT1)Tsyp&ORq2$Ujj12~QY_qYZg zCCpeY!2a>O%|@c18+06gXh6kJXN}H)Z`Sf#Ug_#Rl;I*7vB*~;nloXX7E(9c?ub^9 zfC(6@1i;N}-x_n2jy^{bOdVz=V7-1We zA#RSR_3Cm!ld%dsHTX6c++tYddTI<`^BvO6z7W=pZXSuZLF>+@t<^|Z_YZ$@P8V(vrZmAx z+6;shz&RZK=LeR5xHc^>>({(W0l%b&`#u|UqPLl|%TrdqNt6->)4Mq?88n6_6G&t2(j)vDyBq3_p5|9ASPWwf#oPWBsAxbw1H6<0xTENf!LF)KfVorYe9H2L_e-Gq%`JZstxl6cCB6hHz`NeIT^!9X{rbw` z*d?nqrFZ;N;;Y2+Rw1#a_0?21jOEo@+^=O}VO&(+x)M-KirlQphdkCXCFFUtzz<)8 zyd|c>^Uh{x%d=@25h?E(6Re8KPIPrC-%TH!G{@3o#4gAm(bUR?+J1*uxr2WIP{^fw4tbxvKe$i72dEus6GR5~V)zsS5!^u3Qhe(oFo6XxLjfD#9 z>({SD4Ngq#fQ?HCjE~9Lrc#?X`%?wNHRwn38kf6#@qfaE>vtIsDA%mD;qV%560fV>HZ~5^uqzsaYl62W2qHn9ub5lw7 zT9+oht1DUnpYQ&Cmw%Z8>K0R|Tn}UbLRkvIs$3l~9mLc)H%|M_|AdPJ?IL{%&lvho3nk z3ZbFH50qs2WFRDLp~)ol_NgYJ4D;U}u+h*xJ#HyMVQHhv{hI3U@|kB_5~%a@2{{=p zzsv#2%yshDKr_=Sw_vi@81r)}|8|Wba85O+e$7(&#QO?nO~-34%TQrBwCYb3rt1yz z&{)c{bJ8%AWZh4<-M6hpToUd2Yl28^^}bduT_2jU8zYEsneJRU^WuSVz7QMaPC`XJ zS=pei`OulDlUQ5Ssi7&1DJ_2r=^^-is1RJE!7FCeI5RblIx!`aI(MtymE!3=+K|{c zZO=qEzc#?9E109@_r^W1?t+Hn5gt&8;UMXsDSMY9oh;Q$%d6D}<}^96$B~3O!g_u6 zUG&NeYpX&qLMv@BETc;^UM#COYWXf0E7YHs`MULz4@L0{5m*eJF?;GLG7>Vh?BL6` z9MJK+%eyX+jeWP-KPvj&>yVfV$Psw`W~p$!={b4ZdaV#O+Fl9>v{q=mK=D~DHM69V zvn}Mc=Z9D>GqN;u=ys5VS5;W3jmMPj-fsBwLR9ObUgX!`t?gLSeT9R>=@w&#!vo|J zIl9bQO;{wYl9r|a{nfKJQN#%(>=|NDr~^>TSZ2Hn55eO+;sC@X^fs{$L{<@oHJ(zC)KL$^Mtmc+5;y zo;@ia1dsNCtMx19IWSSX2|*dBR8vtt%STy1gYw!v*k(`yweeY&6G`NCQw|;>TPMVy zr8`P3&T9mh@jV^rMOei?;ix+3Y{bA?bnlP|m z$^|~GzaCGGKU$8`{m>;~Guh?&Vc%wl#Ud5}1_p(@bJM?B9VY^-;|!ZxJ$|OsG|}Gu zDqqj!xt{`(GHi%Pke;jUyBkSJzbN{NjT>g?Z4%x$9)C$^K=Fyilb>AlxWxRO80hi| zlcg76X!qDlu<{^BpbJ8z%s0PI9PNFz+;?oHC_c=;_z++*LxskDRZ=Mej|s4C9DSc* zsfnTj&Fr^_->~SNnJ|w#E`D9cpd#jNmOo{vQ|9&Dkt~-ci~eh7Ekj?iP%Lyh#!BhV z>~X#55V^n#WAYg^;}v&BSf@ZMq7L;L(=xDPJ{^np$GmrJxl(JAK;xV4Yw0bo`?#q) zwt3@*Ecc5p%_B)Jzl0tsL#IleHB^Az=ebMisn{TcfE$*I-0yX`V`v#}*?f_E{q~dC zgwvrQ|Ii@$ajIiX0ntO)Bmm!(Jv4mKrdb^Dt0>ecDw6Mu%Y_;P$5n!8(szhEYRW`s zeZMKQn}_D;s{|nptPRNiFg|e)9McqBrFwK6eW|8v;VnV~U6x<_t*yLTfvAe7ZNYZH z*JZ+10;*cSEy^n*#MeCl31Ry zxpGJeY0eTAvjt&_iit92ZJaM-*S}HurrHB{$&Uzw4^AHOyNSi%AV z!FZICm|7hhsupS!Il~pXME&fHg!{*W)%#}6?)-4bS@W%l9b$zmU2D1H52?bwbXjg$ zB;{>8=^M%DHH`h9m>*0u|L^3T?06dHIRW6ETGKYWtRb`Dz*netcG?bjRgu zW&OvVtH@xWQ)gnFV7&>KV#(ACRMHmHPe(-J>k0RFWx2K676im>RN9gv9<$PFFB%qG zQe-d$s@;c(FF#-nq!to0e~~Wv@yq42LaJR%ahob4G{71PN_u)VnspqPbI)nJy#=I3A{T`261`kqwsa~VFKeT1qLStOQo0G z#*9gw=6G|O$kH$|3Xo5e?>V1B{;%fJK<&|-o0c^;q@~vqS1k-V^VqPQoh34!k1P{{A_u+aqmwMJBLo%Hu3dNKdjHpscb~4Je3qs*i5JK$c}L%| zqz<(iL;J<3WJMGlu{~N_a#8n_IMkk+rsstA7R%K1;{LJRJfqyW~^X>US5Hay4lFyj~B;;>&&I3{#u`* zy{4?I?C1BH4Se%oJ&E^k4;DRSLBM)Me~XOpEO*ark}tjCA8R+|mH2cb=a-9OvUMz}Y*AqW=s+voy`oc?%Q2NNNtH*# z+zsnVKCuB*T(Lu8f#Yc10n|+$0{^*G!w<45&+K{py~}p=j!~m}5Ti}hVyne1=Z$$= zMT-8ZH-haSXruBkeT8FePFPi7;H~gxlYdEO!i;Nl6?cWZ^&10kcXE75E1?c=xn76$ zH*Smck$&6ad6D;&EeIGC{BfgH74|9O0w5EJLai^A?~nqN22cw+2eDp@z>{j~9h+(A z=V_Ou@0af!YWT}mdcOIR|>As9qXL|pt3mDe$8J>`7+Z+$`T z82?1JXFGo<|LMcWc_^zhH)T>e zS|g}y4W4IdSdR#iPPmH@q3Nq}a=EVB8%Ga4P%>&*gzGjn$6ROU{sa-iGR*3|y^Hl1 zJtxriS*l9pd7%1|O|8sbPx3RLBqlQ9u*k*6tdiH|CfCvwhmn1`g;xSF_nqFSEe&rf zp7A_F2a$cgFk=;vc$j^P9PL(M|6=*Vq5_MEQ;P7%s2Bys*3Im%_k+dY^!;Eqa?#Th z=}Gg&d0Ny0v>wHUoD|3T`6bR=7pl)lP+wXv`^YEy1Pi(EFG$ovLdgqV6EDl1>1}p0 zQ=}ztwtcCMbkOfOd-H?6=%)UbuSrIKZb?>Aodj2a|A*>@=r3MgZDTf`*Vi*TE38E$ zc%e4M_efZoISgq#1L6!eVXKko7h{a^$7_-d$l;d?#L?tb)LCT1#WL|U5I=}I1acSx zd>V0M@+x2HZ-{oD=6 zu+K4cKBoe_o)i;UeWpv}rHNX?MM9W+0_6T`M`DIaWy}?T zoL@EJM_x^u62$t3it%8sXs^5?ja1U;?DXadfzxac1GG-wGFJk_f9mRH_=Szr z?F{+C`S|2y1V?<~)2?c$e(6c2hsx&m<=;yT1`Oq|^KY_66@g6g74v$PJ|5B&ePCn< zFEH2i`GEVf!S4bTpiFH5@-cv%i$-(iPcu0xnZ22ufktd-C1&UXkguCLc;3!sP0D8V1OT+=f3bHg^n-Cz1D4dOWJ*(NZdWY-nhY}YH& zg~tdyAS%YAdhI|pg{jDrj#ZzA!n&_iHte(MJomp)YRfe(p>aqc)aWHIUnA1C3(!hY zP}V(jQwLOylz2f9gn-L`LdKi)!9;2L`qc$GzKYRMt6ujbIHc`*S}tbzYNV|BjJ$n8PUuyYCVK-8wkY8k&-lzr z9*KCL{T>E-5=n|F({hF$Z0g*hqERc?q1!KaC<^iAX-J?3bRz>|czppKo;0CCE|Xb; z^f6O9>@~KYvSmY zE&<6HB7faN7O@Bzj&Tk`Q~D&Rs0O2qyB5kbLuPC>BTyDI!=b1V51>R;KKKR?EO^j3 zuU+wEJG@JfYJ5rdE=pr9jDVvioD16b^4VNYZioryzIBnz*$HGc{bcOGPJUwS<|t~J z?!b%x`YBlmt*JvOeb%n2%u9rk?oyDgmjkBgdBVO|pKBP_585W%a8;Py*=9^Qs{CL)AtNGrGC0Z!(rNC3>C<_M{>|s{quX z*+e7cm)Jh%*o8xnL_eoWl08IAMoI;r)or#MA?KMW&9M*ftBZEOT=SfWmV_-vXj-?~ z>4L{kUCh7nnhd(EsY+@ozgjd3jZ# zkOw9)3|`vkNUBj@r~(5ema!5iQLDgvTeA%ZJskM${$Q&=@dONsf!M9j28u*2v@6eH zoClQuUeYxFHqkN!2nCrM?C<^8YpZ?L;`LmYwPa(N~9zdt$%Ghm3pz71#RVlq((mC3S zD?ttL;8XQp>BYDbzC%<2nof+r=)wWWk=3KW7uY5QsJAJocL252|GsEv|Gm=Tlfatb zsVg)b<=zbnDQjW=;7@;7&i&o(=A}%W+wgbDKsh*(K4vIZl`roCHwyFb5MZ$SxtwPl zu?^K&*AEqWgxjko{+7LzbXGF2oGb>PA3RUUq+_;O6wr}pP0DvIzC#isN=1ve7-E;) z5*2Ncx?}v10Z~fkhVF!g5`JkOK9`Jq&2eI#K)OdBbo1rsQ9MqYD9-(IaQ9I;m z>o=zL~8B)p$J0!_9QI8g~|?9W7^moUE3>(i&7Q+7Yv$ zk8Fxsx8~0e^hxi|^QdsTT$*;_19%%O@bxMlJVXPaawCEm2r;uy^>-lY!joT6C*3kv zFPehi^WlF1vaRiPVLzO6v%UZhF<15S2=hNKtvVfx?2CV|tfFCX|B?7fpI-(I>mSav zNSGoii9AL|$|VAj9LWqRX)IuEygm?$_J^f^!fhr=Fj*7-W3px(H*((T6rkxg_Gmiy z+}Ye_pDpYx;eps*deiY|@??LC_iw)a9~JLLemQ1En#Iy6Y7UtWRrBac|EqXR+*;L4 zWyaJUU!eQ3BZ7o;pl030b~xZn9o|t3YzNA*F62 z@C@s_y4iuQSu{a#Ixt((DQGCiO;5`4!9!CfUj8$I)|QUr?n0S9MRP^EgR(T+#vwFa zD~VT#qLBU*Od~fWc1{+y`h2R2;C&4t3O>m~^J@C6&_r}a&@BiVLq_1Q9gbYDwtU8Y zU9OquANRi0;eED}^^n#ES8Jn=Hsh@RK(*!8u}d;vsNMhrI3Y|Vq;%gl^8emeu@@f? zni&{oE&eXNbJ}j*^+qir>WWY&L^y#{>qU_tJ2u$0sZ7SDagLxy4N8-1hV4ru1ktk~ zJjL$trEG&Lk*P<`bvCF$WIFNZ?*Iw^m;bB6d=gOC;!6firleg5%t-ZJgXTV)^B?kY- z-R$u<|KUp}-&Qo>r!E3y3U9F!{t*WnvSB5UKPr5*6IC1~JPdfk0=B7X>mMWgHl=wyWs z%MmioT5wdZ7_|xsYZZ0Yd~ztYYcy5OcHYsLMjvZY7+^SQ6J1B4Lf;i@ouL zk;y`sJh4Kz{auwmM}rqA5%kAx^@3w=1z5l;@KPsKaR-=7UB_!_ztoijO!gQ6vtI@O zKdv!}){ykJw!{YqLpCTjp! zf!w9tHi$BYGjjTPUA@Dzz#2@<8UR{S8dvUR#R!Q~+Cf`*x%||hIO{mgsfP#Y{sZ5g znJd2y2@Kw^BKlPkCzR>SygYUd4 ze^Mv98Mv4PGP(b(aD9tCjGDv{`cU(7Yefl3QSc#LF@)^!jOV*EH zsp|W%HOId6@F?}VCbkW;tr*3oI~ZggPm(KnP?GRqGlXqG`X*SRNB$p4TWp5mO9NY; zM5Lzl5!b8jEiK7eS=lW6rjSNu;B!8{k(1IDAhVErVBU8m0<+tX4Mc{06?N?9heZsqa4bW!J^jQm zysf`#Y!dQ%QpC#u!yT##Cjr)F(|*;oLQNMk*^7QoSTqu9$lsK--3$1JPuv7Pck-W) zCOVe$A$pFyMM7;*imyeQEHF0~?0E7Dz@=nln@XQ>&Rw{O3smO4laf)b7C0YJi=vUn zadV3hoKX`(s4YK8=d!f-_%hp#VZ%!GYT~CP!Q=~Pf+BOS&Yu6|%iVe2P*O?pE(gSz z0Sk&D&tp$?ET1@f1jaZJ`3ny-geE&aENWtdfl*OWX6Z|_KvHqx`ABkKwuw-s6S88m zamR%B!7+HNUr|%h?GN=NW)I(}MUm9@!nZvZ4&6*>={+vV6_s84H0I5D2{F!pM5dX~ z)1JeFc`}J$VgA7z?%lR3Bk?f9miQi~X9IoXM2RHn_Ud(xJOptI)NDSX`TPS!ATy%w z(d<;bU)S&0NNaz4Qr`aVzuwrW?~nq3u}E+)l9zv|YFEMvey;q=<)IfNcjW2h?$oJ3 zX6%cy(5V%oc4A~#9Z%HEna2C6bB^+{te=T~ZQM2*C>-b$IUHXkp39TAd-QR0vs-?y z?_|#yh>b$Oe~^DpyB^?Sf1D4T@3S0D<09-TA7SjF)8Q&$8Yw)Pyiiusj>co0`uRrx z&8w{ZGKHk<*DEZKG6^qP75Kyamlc4bQ~OB^i%Q+xb!8S3E1}WjTE;U{vXJ{dJk>!I zH4aC*F009{W*aqaR}g)Yr4(N_uy(>Qu(At^I*r1Oy))v}eaEB>>2IWQddgHVJGX64 zIacaF(Q+vgaQnDjn1`K4DfD*k6h>oBqPrh%1ui(toYql0AyXitBPKFRrG<&B+o-RK zT7;M+YvpLVyz-wjbPk7j0Vf+ze#K>De@$tQR>bLZx!v?nxX3mc!DA=vUkCjU(>v7FT(24pGXFSMeJBkJu2$bZn`l}8!jd>Lv6>J#f-NKmPiXdI9pXS zQuj_Qv0mcx!Y*v$a4YAP*q8WmIoC;y6;w&F>51j*Ct8u#o<$#Wb(1D%zq0i^Od-t< z)c%F{PusX#@PiwDAm$%S{fAIVedirO_J531D%bxcJtiHqPYyJf7O-FG-lvHjyhk9E zSCk8aE{o#;RAP^T4e8f&Ez3oJ{A`>~ZY`1ZjX0r7quIa;VrOH9x(j(}K3nAg)B6G= zbb#%zBWD^@YV$5cozF&wU3-*ggS_T`SybT|zR8<1ne&dr73xJJu3V(q#uTJho>6YG zLiN%qsIxsIU1&jz>e?wIp z4_Gj^H=9&s8TuM+7xOKl81{VS>CWaPz4ELy`nkkyC$ptB4LALzFT(bkI?8422r?GKw6A_)=YOGD-FeQY(&isD)UC0y!e9h>?h@`!-(Ap)N+w{^M~({ zR#0GA1msuktk13u8Lsv_L^%`pah@ZCXRbdJw;4p(X2zKZ?fWZ4J};_?`G3fhve(n4 zRXUE#vo(O0KF(AjmYC%rxfEl#Y`vu1yq}g_yQay_cChQM1zN`cCuoa*!{3tp3F~E^ zTgKwt8o^w^y|la3zVH(m<%mZ$C4UB7ebIlQLGafc^7kUp9x&O@on$KfnOniupeU^d z*Ji-m?M30=gF3ycmPZCl1RK;ipn{QKE?Bs`=)gd`H>MT&OW8NyO6NYxIAwA*$-N=J zK^cO$DDE>{%(?m<;u*V)WyiZ*BX}?(5ABQXKQs8f>$`{=3wqi3>%moW^+NXw?A1x^ zsT_?83`R%q`@>EzaG?pDUx6(BiN;3Xz&G>>V`%O4U1KP;*7XrdP-5PtfCmH)ib75^w>rd(_}jp^H}Rq6D;F~-4k@oFTuvi(koTAK`$}ei1eW2dHor8;DR zyEC%EmknRlbh{EzU|uj^%;?x6GG0VYSry!0k%b?*NWOg|ESxlyh~EA)VtI3&b5Eot=ENYT#6S{NHZ06l32D~#bfp&n+D(boD zF%0X+!#Pp(h0hrWjV#GXFE$7d? z2|$uUSUnT(2PU&&JWblU>dV+2opSnWlc*a$^VX{n-8rmq9YPa)B}QQ`R7z5BX|tv* zL@zUL^|UroEFN{{kPtSU$AtDy&r-tD<>hx$$qev*TXQd!R^ z+SCF4077`tq}7e_iPdd8@fr^aeWN`ZMrT0yh4@xj6>gM>Sc%ybF703KiZpdGL8@lP#%aab6Zpf~&(Ld~( z(m#r-s}lE*{0<@dXG&v#W}8kURl8%!B|B;#i#u*;Lbv@U^-0%B9R__PtFY*E{fE+FjaaA77l^ejm_IXLtUkKc>x?ZDS{x`Y>7SEZw#^SDIF;b`#2d z@z{_*)z`WkB}l0nGK@ENIDIRYAa)rs`?P$A=;L>Yj}^nmvtW#$O&$8sSFbge38Y`! zG6ILZi|RdsS|ic!ku^$;7zRB2^z}04kg$VTTTS!;v8_3~?ug?U<@=*r2^u4ZQE2=t zdW}Kb6$TtTIVg~?KCAq>aRRI7j=(e%?oag(Z>5k@e#SNMJ65ug z%n#b7YjdWm*PcMDi%Vb#c`9i%VZD@kxa+^MC>^A&PiZ5qJQy)Yex6a*A&~tqe$e4SXjKdAF zzEPONoemmVN>NTK!uqrzl}SS5Enk78Lg4Mbnr&K3i7KYBMDAq&RgR}YA+q-NtuWvw zanGtZMuBgJa2ot1S@Q|GEpj~ULT6q_m|DW?!Q|Ll6H&brj-qt;#Mmzm4~5=#OYkpD zvbBj}*zMI{-$ks_7izivaa%ur6fu+v=p{F4w)}g5(ojBoS2rK$4I*cTJT4)lqoCMg zo1ztzt6ptO>*+ZWuvd~vaE?3C+<-49b^TSxu5KZq^|8FCD3t`xX3SKbI^F--+{MA< zcte&=j9(&iW^;~PZmy_+b}XgNHnb%dZr&kG!3AU`-Y+cheTefwkNcsENhmk?@MX1_ zrgVVST|5!mg$8_lyVMJ34O7Z<0(Ll$noKQZPZs3~&l`MgRR|Ze$?41%ybVn2xo8Qr zI*QxVzxe}eDg?;AntWkDmvL+6#+jVb+eMRQ=fDvLT9;mBz}MwI>2r)3UjM>Zb|>2- z*GD3(9%4%$zI=)x)=MY~!XHXYKBQo~tkxB#fVbuS(sJdUU^Jd;94N)xsiO~I&wWVc zzv}V-A+<<5c~u9>;0*rdA7>bGx;phAZRlN%4-dyy2OX;)+clz0l65*7@HFI^I!Ov_ zSyvrU!Ig?zt6_vPP_nunSV~+HcKxpsi%hnyk@sefJP?aF+JcBG!RQ8IONDQXbug-9 z$RXp|B0B8}seY?)^QW$pVy~ILpwz^ij)qq*7|8y;w(@vCbMybp$$RHRaq(l#HVZgwlU|U1Bg17xZw^Y@mfKj5R8d*iIDOwDDpVdynAF#7=w2*^AxF?+GXEpL4+sA9Y(WSDiyLqv) zvJ%X~JiisTw4i)NuV1Pq^g*=Rg280rS!8fuE3|T`-Ad2mD)&)3%bOQjJb5Kx$0epD zAxMjw)>9HGwGm3fbsD$l>Z}uvx)ar&5ox_y%j-1VhvWB-?~L1v&7OSKGGCbAkb zy+Ibimb|s!9I9x^Y$*P|K44CA{zX+hgSnPJT5zL(Etr-_wpNA$jbcDl;R|Qyb!%*f zh1$z==IbT7+3xcLDdxS|&L}Ebl1#aV&*oGE=~98u{3@0-3h`;?*I@O`4Sk|fw&sZ| z!eL!rI_p-Up||(6cX2;XwgbYqtOIDg1c${}m2WXm=puX>!$FjK8U6bP1HS%Y=@&T> z-RTeV6iXT?)+SOZ$=HZO`J$Gide1Hm)Xp>%nPMs70lsk2B_A>JsnX|rW*k%96DV3y z7SqIQ%NJJ?h1_g%zedGAFduR=4djn6^-t>fazjfl(nh3aBVxoiT0XfcNOs=_dZ!%J z2{2X6KQgM*CAHMdLy0_(=GbIuUhzM8eV7y`D8U{(-ondQV=GR*6>>PpG$J%%!9Sma z&J+5=IN~moRUpz>bkw$|KI`hI(D$#dU=nqe*7~{;v z>gyrPeiMz>gPJ{OubpD3c|Xu8nW>Tt?~8dg7PPgN4|W0?)D-cjOW<4lv^%g9)_wKW zFmOa@1*6`=7ad25i87{dyaVDaei2^`>WoEejv8`zqWb%4^&`)fR|NP~05-r${#Q1j zCx3ST4C>v6y|L3xKgUk**H#c8ouw<6@>Hh`K?ZlSC%Ee_UOD)9fp*7wYPvZ*a_CP zrVNGW^o%-UeF;#-_p$sVSEO4dRx{y{l*t0taHd3euD}RZ8jgx*DiWjyo^Teg;j))0 zJeOEY&zzUEBZJ#fUg?ChtTww+o$~!q#VNqr{4EDHxy{hv=gf2n82*cm;5J_Yo^`8d z(WivQW?bk{P3QbOy05UTD4)VrC_#bG*6<~k|StoK8skJ40fI?mSD zc34~6G~20Z2~9>SnGwtErjLAU#z7XzvfMf35{|QwH6Xy>bNi$JS3K7 zRbSAwVT!U;m%t99&ARAQNJ+JcHWUQ z&ocsn8X{dU$!WDY57#Km`VS{V82y|K@!+?~5aaXZ6I=+qwf-cdeR$0Ps!jv7Gg00k zyt3N5DHIK7#-O`^7_b0uT%(9=Ha0xUH(G?Zw3-qkae}YSbuTlxT%B!bd{FGnqdJ_X zeKmZf-a$~Hl}<9zpKpkLlg@vwt~G9Yu@%z8c4cH1%jxo52et;UWAWMq-SUE|=qK%M zI9P;q>+9_>V|xWlYPaOD7;D$(kX}h$s$7cGs&_jG#ydQ#{Ax4ZJqnGV@pqcETo9gA z4=&vF>YCRpwG^6OKvf%x5f4F>PZ&^I`zbO_+$RXQ`BlBYTq^Bw!GuzbgZtbwr=$6e z6$Ace6}5c+M(_FhQ(DIwAA8(9VF2b>-H2_rL}|CjX9vil)%q_h`R7aX*^QEGEqX@^ zlG0b!ks8IgS>T+#w$)F@Dz#a5xb3hA)#|`P-AoTNkfb*F6X^Tfb@|X;x$j^0#%?d% zyTo=as0deHSKBVCNtOPT`O@p%^f{r*Db&qMIN12OJI$`X95_uautU6Hi753akcit6vwnHXGNK$5?9o{pSS&G;}$)Lo= zOE1q_nBA`Dc5R&LpW8`zMWdl#9eMjZP@VU!8fUW(#zn`}0VFWJXPNM?O8ft{=Wre9Y$+8! zpeKl>$MK?E1b#tSxpY5nGcGVEBmr4p}Oi`wl6*h6l6ytb?|6?NNho3EPSU zq3cW@k^qY1E*B#fz`}7!2E2R%;goLd<^|wds0#8ZB{JplAUesh0`D)Ce%anc5Oy}& z!AxfEM~{2cP$%wQxY6KO!Bk*C-g2c?U_6$_jV04p1J0tM6&ztUCc)iid87gogTsbY z2+Wp&KpiAvv9k#x@pWxT&px=nH&gFpV`BfuV8Ncp;j$H?W;Q{unMT!wMdz(ZRSFwL zAISpAI&DW7=8*rZi04_XLbR!8>9Ri0q8}JeFnDc#;ztE^1XP1?gQ{Z(a-dydt1>q?-8J zNm9FNn!5T?qP1zAHH{~sFN%s*rbOOECgE#}4?Uw6unHZ1@}5eOfpvZJ18U$}`6@^~ z!;TQ>%O$U!+$pcdxmOVSK-YGxBJQ=~Qo`=TO@b?8iuqrgY8I`FnWJ#zu~++}bZiXVT^$IR@U z;e<~^OvrY*mpecFmZP+yw43epTE*J-{@5Lb-Ncv6c$!v-@RYL z=ejOaCY?6WhznG6xC%Ue#gRW)`F&Z=@AvPr`(A#K-{p0aIdbGaBxC6{(_<|AwsWt; zK~}P`YG(V_wxP6rpGJD4c@ejRny5l~TeRyZtcWiH48a=wul>Nj7HPW0oTVAvY{bJz z7_k$aBnqi9M5pR!lK#a>+Rx>t_2v7w7d#j~e29?9VWJ|!vPNyT!VEOuPn)mYJR=+Z z?J9SOS3ycE%qXU7I%n(sJ+Aod4Bi@vdtM=)Qc~0chVjwYpn^jSf>i}0zNeq|n4Egq z=Au~agbCNj-ie18dPQm8uc=HuKQ|;m>URF33R42kQ9A38>E$e($9!Dlgr0Rx{P zwwmL2g=783M2~&Edv}QQYT(pObIO`$f>BI1L2qFM#@WsfrSD_uV_Xu|z`O~iLiDXs zwU)OpyE5aCMsS_LXcS95kk@TELR7K_g)CW0L)X%aI49oD-eX|?<5Z$UnSy4l)?~sh z_AL!OT_Ll>7Am-jdj9RmHfUF<2YOx#M4kl-+X=QjS{#>~A8>yM&tND!{N`IxiIZxh z&4x?H=-2Htus|wlfqu?8!4;{#l-}e+3;xm4DNv1v3vy(@mt|)Lu|N z4H-sKx+jp4TE)s0?ps9KOw9Wmxpw9Z=5j$8fRXW-ISDl5lVhpFgAmLmnk`1yg*7yD zG?Lyb|A6W878Q>MnrF{vS?gDyKJVTK$7owC z4jXmFPLbUkm<_cx8DD02Ua-rFlyIHjG%l8UQJxd?8RZiS_<=$y_n!yo!|CBqMZY{W z#zsLz!rF}U70R2IRc4Tpk5e87k5c~}DAh_|_f<=FyimN`YNaA^UJ1ENjek?T#(-|@ z1_i}PJ<7FimVL|Vvo7^b*T>%>IXpsS3umXK%|$ro5HC_Oi*~OfE+WhB zf*~@7Vp$yjTV^0o+O-ntlt-r&in@UHi`SSKGHw_SmNltXF^Ql|0aEazVPhn zyO9|QVmU{Pqzht6Sd1yZtjI7DE$T~Z(vJllx}Bsy_~ZmX19sKk`;wMLFuabFOrn)N z5;Be&lhZ@FG4BGzu{FfJl*EH5r^bVjh%+zE@PjNXZmGPA9q}RTpa|EbaTn!V7puQR zTtR{6Or}Y^yQnIGE(yB{>NjNoJO+U30foxyF4)jU6!+9I{Znz&Z*huaM{t4-VcykP z6V?Yh5MxI2+EF2rfpev^2U;WUlpn|O@c44~44-%xq4cGY#ej>dvT!@i!$#I{vD@}x$)}D8b1o4{Y)$Dsq7ajD1>JGOg1U|uI_%m_v_GG z%AvCLY$^54JhexmJlr&fQr7G$H!d0;Mnf@qGPvoh@Fx4EG-7f;UI_*kZzw}X3FAWj z-=jX_{YY>hq%z&-gPMr|NaV+);8O=D1@A}vKW`uGGWeV!*h)Yw{umP=+1tK^+TGm~ zoVEwDjtO$@r?^J;4{2DV*yFnz{)+F~AIu>K`JzA3M?+&4+YHj}Z#1`#0fX0aS$Ng{ zulhH)DMu&(MK}K|MR&NUVFJemI7+`o`hTZ7|KCP`_-(OH{eE2Ii;8q4`RnXI_=loEK`bLNRD$6W8Vtp8 zgix(lKe-k(-Y5AHCIPLt7Ef?k?JreS4H}!O8Y|7oSo0g&0J0$?z5Hwq?fN;d%`(1M zMcTC}TKrL(Espip=7CCx$1hKKKR`&nQc~qI21NFqtBSRQkR*Sz3RF~GRPC%WbWKm7 zf5iQ223O_HBws(vzDMH}26z@)JTG5fC|~bFO>yhqwjQBDVTMq%DS+V8E?QaKjC4yD zzp}-@wwJz_ONpEA{}KNgxBrKz|Ie<*MTmM2o$=4A@=t}be`1^&Qd%a%IfHcgF5pqx zZr{o?(Am0^gnFo*<96TL{AJ!f*BSojf?*!d7$%(k=F(aT6ex65?E2Ek4yoM~{Y2zn z_MWSib-(Le#@2-_w1}bsPabvOA9F6fH{8YMJLHxAt{FfOQzYfUYV30>!R;)t|EUKh zVo;_! zP4KTgAn39GhrRazYbtBkhJ&GtfD{3#3Q7~DO6VXGib`+NB_IOQI|88yDuym97=nmM z6Ag?d%silwp8L7) zDb7QDD&Bx|?fGrMgKkvV-B;MlS)0h`(i2-L-OwDWF>|Qj^Hj79e1b zm6{5cW5SX}T78Zbgs|Jl;L$c#wN{K^Zf;(;)wpQY^VKJRF#i^0X?swdx#0sFYTC)q zp1NYa5mv4b*sL%IXAkKAkC_5Ut7LAQn~af9$60TdktewA$MS8lYk4f1Nxi?IM`9vk zcZ2go7U00uHLoj?yXd#Yo>;RevU_=!VSc3?d}?fpP)S33E7 zV*BAf95=j3z{d~-V)nFN5CZdSR-1t|cNPKN1n;aMD~|EVepBJ{!@qv~*3x|+{9)`L zov^58(vGHhpW|kgY)!=s;V{T!*9Yr79tfv&ya0$~c{dEJR*dPGmEm~-?4|smYk1pKHH~rzh6@F}!QbR#u9%oNb$4rhC`Bk*2pG9o^JZJ|pb3(yF=+n-Y2 z@$J&Y3H$N*?{xYDYx-lOr$(mJz1{qN;O+WTUrOvYRL%Lns0jYWO&S30`}1u+-HBWA z5;qb83@TvvI!gwR0H`-$8dI;}56$5dao>&YQ4}B-o9a$u&wXe)o8T>dU@h zOI`c+M}ztQxpg>RA8}jZ`1Kpyf}yYNP*|Bd#`ZuL#AsM-frW3qAM(;ly=Mq zYzU9RnIC)Js}{F5g87HP?n1i%1vdRpx`F$P2>I>7qo7Xw7iUAJhr7ZkL#Wo(1)~!x z0^gk8x;lE-Xx6DT(cF^jQDyiUyrmd=9Ij=a;WwV1cQG#e)}`QB9itf#G7+)M-ScU5 zmJUUyqp_UAtj;&^^Z|R`cboC0jIfjnz|_9a6~FEqtiy-CrB2&bY_}@3NB=xkSdaV! z^44mB@8u{=9@{S}RA_Ekdw*~mqc5D3J|^nrq29yKqk%M_+5Wlw~U0@8rCFU7;3UKFMDYm7nwX>u*!>Mr$P< z)zg7VlKVl{zw{mW`3@ zHw}y^xNnc&OXf*~+wOkNEzXd-I$Y$O{PCI!prH2{b`WBTVCuO&%zb_7VaMxd)^DSt z-J0%)?CaihXAzpb%ag!h6Ys7rAnI{rJrsST?YeOs@=0H8q;W_g+IKl#LHZW882cxI z+R*a|S}6HBC{(b3?7>GH^FKsp{bQy4N2}-W@12l&GB9Rh1koo>7z9zF5~nPOqi{z> zV0h9jETv+siroWoNRU_>E`474_SXIB@Bo{9B23sQr^aUI5;MG*@TF{5VQh3_v(3j0 zS0Ly3f{{g%)d#QfWZrNyul{|Odp;4_J0%u&2aVi!#;4>ZLT(5v1)I$jqDWn(JvqWo zG1N^DuhQNu4Kr?pNWbKfl)U~QRT^K}1CU87q;aaRBl@&@n#E#YGvaEor{X2NaeWU3FU&Z z-p?;6fmv8^sD0koOM=j{PzQdwMqufm^F!YEpHZN{`)VYG9n&`+5d}YbHN!5=SzWhW zhKPO`ljrG`n7ij7WZpeHdfjT0s2)G2UOP5F!4~MjNbd$H4gl%dhB2+B7w1KTZiiTy zg5~tF71(<}fgZ#tFO=ZqDc3%k6qDLr`pDBn9Tfo*h?Qzy@Icy)SD*b@|1K>{4KNBn z=BtliuYtKP-hN%K0Y?57gS3eblgEXuIP~idcqaD4uCBD_G}<|fy1J8b?bcyYa{L-Q z-lH^}9|lkZ7>n(|nOCnnmR8t>MJd=Jos7$F%{)ZULdl6~-O1&s9Xp)@uDHnIcU07( ztVtAMv1*#`>Yd|q?sB=GdY8UDa|B%o1rgo117|9dfumC`98*uRKz9XHfXKvuQ8n1H zQ3dp)U+ake_x5v2rQaIui%5U&4J*d6#T{TUTikJR8W=yj<4kYU7P7$PFa*bN9-J7= z9k;lU%<}e}4pdzMx52KCF_NQ+&MW{}jp=oCMmowUKc=;o6LTaH+jwRFe@!R!&?wZv zqvWRZNf?AgQ=I2z}^0A$QYZ-JgqacOzVpj?@!oa9MdZ3pSK<)IB6 zq`5OYw`MKZb9EmJge@-sKQ;$$t@+{0dKdRzWwmBd;Q$b=THof}wNRRJDfZj}g-OHt ziOnWJ?CQHy(L1?kn|Zyi5iFp@;>YZ^aFSNFkXddH+*theDzI&0CjwN*>?g)+W1&^x_3kCA2`M%TvP!jm0x6>|5N=P z1D};3z;WR|{k1=V+8y!0I*AfpGxQUP?ySrL-<#5ZY5t7B>qZ1)_=wg~eANOb2p~gk z`?+rLqah@9vSu-B02c_TW!3+uF6d7Nt`tp#!a9Iw*&eFdV#xno@#EpgG`zUvcj3~k z(BF5#W5?9Ww*WY1Nz;)VXRE;CVr(ybTF4EE_^ED0RvxrI@BCTR+T`(Zm+F7QzF>>2 z<^6+O*vd1yIR6j#B|B3_5vMyQ7h~EF#(>MG7hjbpDQ9WF)yd6j2}-p{Q{~89YoMpT zXZc|Ohcq9T!}`V3wJQ>%GVg(c!V2^zlFKiqS|nQEwexY7q*EO0!`OkmAk3f#hF;#B zR9ma^-sOnixyMLP#?f)esw%J6GDe0X(6K|T=fEFFM(x!JM2Hj@mLC_K zhUw-iV_pg0Ekh~squrJ6w+c zcsz`9J0)BqOZ}P847fcxkFq@M=353ip-gNP@(^b`Qz&a$w7gmkEC-viH?3PA<8Cr;*OK`t;0 zcbeJIcS=})_BR#$2}G<>b~B1)J|QA1q_bHgp4xk>11d?yb{5ERQ2B<-DxDZZi&UL^ z!IgNYk1Yt6#uXNl{44GY+)0oC5>S7rH)Bu`St(vwlGAiz#Wu+p5rQ6M*?+vEqMTkk zu%<$f5QPRum!DIV6D%N28Tq%h`@hrL9BHlwi7WA=KdF5FjC)nkwi!vP-#8Re?7vg8GAIpg^ zlhHD$6riY3@rP+S$C12%I0xtOa`X(^l@bZu=2otkawF&ZvgDB)V8oOpM2A9LCT)>d zOW&7n?6=zTls)gBEWK!SYLLyNH~H^o-~8a{YL7PK;_YFdS=H8=U@~$gS*nzwCRrF4 z9Zi-|4BnvphLgtlZRlJNM+yZvf9KZOm*2VQ}jR~{nut?j#+SNkZqlO zO4VkpxWXh9-rGq4@F2^H3)<~Pe4f7%uDtG@1LKYy8+JK}%Oe9@Cq(WIse{600j!QF z`KVYZD^ZNZs^NWj zH?IM3ZolzX2FrrKq^|FK0E{X0@Hr=oZOki!lESj<%%luJjTH6)N1!_IzMI9#sm?uo z1yFJFq-N`C0emeL?>7P;{G@PjqKhQT<%YQ-g^($8B8xk8i4Jn#Kf8_tn^hpO$C(A{ z9eyr#j@=09mgv1jmPl5C?Ts-83h^9^4owzYM`o5^Ik!8F;4Y5B03jAld>wlI*`ToB9Sr>eGzQW>Tf)1dy7V+vk;e5=&l)^KE z!2$i!p!eTX{J-&|{oQf=m!D&7^L={zbMMeNU)*a&YHS+}%u7^H?73#%?DX!_ydQbk|!3zNjw`v zEzKYZFT#_wB2T8tr!rw*yNUHGMJ*MCz2!1csS(&1O=`Z=iAj_M{lNHThYuHx3$eN-7L`KX|Zjj#KNr;t3VL{TOsYofkyZ zH(OrqIAx-;VUoXjgd@J<92OzhB;y*Wa(w}MQs=F=-l$Mz5_@RYf^jgZ?}B6ap!|jH z=>9fRlA&EZun%aZgzj=l@(!u*0jcO zMiqu$icz)*;uY359of8?p{8q;AZ2w~VjdoOn+6-KHJwATql4=IHfKpCt?oVk$eJ^) z&ZV8UM!SE^*na&RU*rYK^p7!CqJdiMTD;Z91!qd-Jw~+JHy2?zA?`PLwdLjKL)YE1 z4A@TugF59%)KwVKZUE*%jkJXsP<Q=sGcMxL)< z84|U)yVq%kl)Qrs8=W4^7&R4YeL1b&>K_46&-kC6DyfN}knD6Aq1iQyudbB5B!lv? zIiTEH8%inbCXl76a%PF*%E^>S}PBvPt!aV*I>*h(;Zlc}n>bFLNT)l~2vZPeh+ zy{`IPTRvmk!EOLB*hQ%D^&v`Og%XU-@cNEY!gT6xE0CA*dZ4lXNjl9dil-IY8I>E) z#0FxXMy~M-bU6>66ia(k!7qQo6s_@5gPe!fK#ACkc>-ANhNn0kwJ5A60-=%l2mXQe z?Td5y%7imsWxG584AAH&(9^sanmv?|2mBec-vf_NM7u=@t5glQTnd?sXC&s{wQwQM zSc5?E>a`#*seEg#$J#Q?uhlOEuvalfKsr6D7B>!%XR|d$#v+@5^l5B>MoD65>;jFq zP6$v~QmByOC2~AOcn^UUdbtG1#{3pl{ofTfsC<*&z!e)CAvvn5U8Sj|Jo2qS=l3K| zy?bs>jwFR=G<(j)KEEuiylfV2;ER^w%=7xY@vHKJ$RK(rcOr39MCoDVn_wT(k#hfO zqBsPO*eYIRxLc7^${uyOx{IhR5~`RBt>M#p2>q_Zdo*f{}72XDt6?cEgqnr zpER^qx+I$KDlFO-!Oi}pNlWQ=>hFSBEdg?Gw6Hfm_MEXY7Vn`)Tq&#r#R@+~xOMSC z#$J6%jtOP{R!&1lS18`>YT(akdnYawa%sfZLL_oW(DZt-4ueKk7(|~)-)0&^E#22g zwD~z^@@Xmq%PNS6FK(z5=Yc8xqJt>nXb7e`e0^ZqP{3x|axYd(;O&P~ne75e+M4Y) z!HQNC=~%H6@95EK8!9%NVDHa7dr$2%8avst zc`{6`(>95mM@o@E%|<*03;Gripdc3i+9@}AY9j}oxu=P(c%-Q|T)hWyioZ7(n`Gba zeVAy-v(nx=YGX%4!Gn!MQcFkfn4i4%RQa)~qHu0s>ZhhE`q5OvhguNm)ITFhK+qLy ziT4A-ca|rC*;HNY$I?!dz1;L0xhC&jFVEgieB8|Ds}!_5O{>=IWw_2tZ=wjgH=7g|6g+ni@>;jIk*py&oT}I(T8K#E71tQ zr*f2sTeZA$co;FU4LKZYvXC!Hw7=rhe~KeYMH|3vgpLp%r~s6g@>{1EJiRWc9l6=Ekz(nRl!9Po8A4zNjGyq{igNasU{og1opjk> z<~+h%uBRW{&+|(kRrzm!@_*yT{<}Nhzc1mx!U}Zaf49(Rz{~WXD=xE*zkbb@muexC z)d)#%u64|I-0qIwanz}9+xk-jS3Dcz_CLWq{de~ekAvfjEBVx%Ystt>7FzD>AnV0q zq-w2H6Kvl|@A!}&@O=Azdjb9bi?)jxSig*(8!`hUa!FaXnzOUNt0mO_XHz8nAE7)X z#wUO!gDANil)q1#EP`FC@%(C3#I+PZDh5d{SGY3LEmd<(^@&1>^#(HLDi_goe5){c zbDu*?c0E>5ruK{=-1ZX9t_74VbC*62xgi~+Z1z$7GhJm1@e*%AD?1Gf234(UCX9=V z#Dvegx22C}W-o3ZCld!8?kB#X_nK|)#H#M&o3wo;+Ky3;dud@Gb#9#QAJr^f=&7iG z&4Vfj*=!YD?xx)Xz`b8%ZPhO~L^JvtNU_CKW+LMD2feVjhfhk~)}#OhQPpY9Qsm#5 z^vbq>`wDUCj#mEd5Y7XNBSGoTE#PiwM^nGl;mh7mo>7uu*f7$5hE+ll4i%$)7Hi9t~4V1 zEOWsd(%a5%y`eOx%rr};s-i4s;y$E~YBH7S^lgZ>K;%SBOn4jGqLgP7cGVZKv#Z?@ zIn@AHcQG>vBEYJO3z>e)LKCf-nLp}y{|r#b(U_!ji;X_P67mV5zO`R5CG`8f>@aT{&99$%B4pDZhFvJ`S6Y>-_`uSJTN1=4~oF?$nE5^sN040To&K)mkRsnfLv zCGQ}0^;ulJzAX5J{S?X#d z4jp)|WiDrA43jC3WP2ESfwB`7wHESagV(2%xM$J>7At+v;c7?rYr(BcRso z*Mn`n$B>+fnyOa5vI)^4?y4H|TTU0mvz`-!Lt4PBuc|nzgFaD9Q{n>Ht-UBXjbE&4 z7;|AJRojr!SXO^A z@lJU#b8 zYS^#Ce^PC}Q`Z;N&q?XKFVyXn?|uTrSlc{I1`6q9uH|Ceol|d0x>hv1_~C#RU{77$ zd3#N5Q0$zxu++I|N*s4c%8;C}zfE$_S}F3tsn}ILYJpl&3Oy@?IJ83z%_nzuQ~kRFSfl)gM>n7?TTBBpn{ti(sQMgnwoygby66w zCdPFcg1jD~ynyg<`|FeVL^(=RAd;`$@Ab{IL`X1Lv12p}_n{ug%e%JC1=gK^fz^(( z({5$6A!EL87lr_=Z&qF2e&TXpd_RMZ{;w$p1Bs~5*FWF&_H(InmW0`Nh@stjCH_cz z<4|G9bP090Q+#E!bY-kiEb5aJT4VxHguwkh;7O!l{9X)}bZr{k+LR)44&X{AYd;cJ zYX))PAY7*vnYLG1hws_E?V%Aq;eGk`9w=Dx@a;6r4RnB&==gzHV`EIP!6)ea-FOCj zYIQpvkQVXGXs{^~E46BR5K}K$MUI*rKVQf#LX-;8R!3`l0Fm*DaJ&xFlk<|a5tRA* zk3ej}G}fa5{kh_8lrP**Wbwqig4p8K=SW;Fe?ZWH+Iv3TaLN_C@F{2MVJH!9rj`fX z@5d?Jib5AJevy5U&Pg`jlx4DP5cl*ARdB}DRlTrXQ#m3wx^fWJA!$P3Q5uyGWMmc{ zgTS#qW3vNzFEc>E()L%SvcF2b+U-Q;WG1maxT}|BYNa5E0Ecx-HNBRgj-g2))|tNg zt;<$Ze^Rkou5Q`fS0dM@xeQ3_{DFAYqsG;}9j$|p z{U^Meg|p{NWj_J>D=g!34o!Fgmjf37oKbTqz4S>2sJ8t8A7lnJ42et_Hxkf>x(-13 zoNP8$kY55`$MFEDTzy3VBHzl76ARY$%Z7>01y%ymroaT8GYf9V0V?cz$Z}r#(C`{_Xd*OHhbv!hf zrlb1(RJ4KKW&iqzb$&U~&nHzy0bS_bPaxoL9|%trr4tw>k0b$BZObE|xS!$YbCLb~ z3jf2y`*$1uyC430r2O03{M%yxGMW9`9{yktJJ-n?I+q@EEPfp;a$yxgez2&DDai0o z^cYtFGVA=`G1wvw^VW+RZnx%!m&`Aj+iUVyvzj9c{uOfc^SeiD-SdB)cK_p)yv~mi zg4fh~lQH-Q3P;{9M|WcZP3%?Br3z=W(d*8iL?+(CYKw*=0aV#I#T)vaBzD zy7ZH*t1m@Vc+=`^?lf6Z%j}GnH!m7ljv?*3&NStA-vX$Ysov5ma)rez&3RmpC$GE9 z1)=~}{bYK{b38x9E^zhF-wY2hnqknasYd%T3%)xAa*<#0=Dt0A=S6D^=O41ste$G5 zMsA{NvHgpv&{!3C``c#+BbT>gokTb$W-WW+`^c>#*$HT$rm9{+RuRbD|fIwNdsZ2hO`>y6Gf zeLXv=@cAc@!0wzs3JM`3%NLCPEG=vjxWvy@C7VSy6(F*n7GZI*es_)*<{ZB? z-qq9^I~@9ABs@>DDI!ioUY8CsP*x)o72YrEa2s?na~sK)b99ar?07aK>AliHp{eKN zyadG7{!%58YRs-7))7q4#mh_uaRca7hdQXC{*jwUK9j`*e(|IG*)2_~;Dp|ED_ABE z>P)ppu%>{~G0dSHv z3X#(-(LSyZH<6Ogsb8YYi3dKHO$r9WX5(DHbH^lBdCAd$*}_748F9lCKzvAHHfA?_ zA#8TJAE?l|zb5KtQOYD{YB7Fu%iemvuY0aj@69Ji0PTj3+dvO#ttbdiyk3x!!XQu; z1<)?Mqf5@D*hl4<#Jv`5+8jWg78)oxkog#aPpX0f!hxng!?O#rjPvkL;G;oej?|YO ze(b7g1?S63?`29mV`n}s#FRyim}SWwsW)*$7DFuBEPw(&kt>G*0Eo7vEmC9M_WJfK z-!o%|Jk0taBB0cXy5s`Dd(V3gSn|px5UQ>aLbu5te!AcYcVydWsu=Os#IdsnV}#jB zw2plu4WqEP@svRJ6DY03!#&%`XURwr2pUkg5&Ym-fKKI$;SuALD^L1em~Nenhu*Mb zmbn3A#sy1t!W~9NA0>XNC^JKstP#cm`SqAxt%b0e<$ee|*?oXJ_SU-O(-F1u$cdAM zp+!YDu^Epc;I0!7aJ|v~$y)IlQ`;Zz`-u-2p=jN%sPMSIeK`V7WAjJ7=E(5BTTS0^ z7Pr%PA^=pIXeAchu(&`jw~n-l)5ixgKaipTCGtU4l|NC%)W&T|M6G=!HAvQ#H{>JQ z)dm1hbJq$(Jr_2FUhb-T0c$&*bN|2uktN}8_I`RYfPv8!$Rby6o(Pm?Wb@~2iYYK( zN59xPG^(q6x*OIzL&lv(pmSS|cC%2i@V>}aw0&8IZfN*bnXwUzw*kxia|q*#_YVMa z$FBsI`SE~dSGUJ6qBVWw73EXF)Pbs#^NFA7&OCkL_Pva0;a84NKmxI>`9*t2r_inw zddW!&?b{)J_YXKXQ|%4~0~6YZW>dz!$3{vox|Kzhqh+@LHsvM*$S5wru+&Lar?lwO zwdT026^0f;ey0kyHGu4xZ7_c@0q@-1e9tAqRVk{1nYoRZ-Q9gi4#F-I?4OvCGkm^* zxgMIPZ-XRZ2J@m4Qvo>M=65)rU(FV2zGJ-t!}2zs#ikp_&Sh$u2?drYZ zT9F^qxOr(nlKLT|qrDoS3j*Vz{f@+b@jLPER6GMP+es-bPS$LZFXj!%-f&7sjA~@L zQunw|(+6LpDrDJWk4bw?edC7=xk=4Q_%u7&Q86IBTwtMv)nZbg8tOYAcQ(F|i^Zcn zBmpt=3LH|4p+Y9CaGdQ%$2c**M#B_YiDQj7rs+FQ(meyHEp@>3hy? zw89a{Fx+m>had;=`{n~lu(=b(f>_>l1-<&z#-nSIeAzs;>%5O=x|{jIH#mB3eUk^3DtG0vbeu>($1doHhMsS!VE_o4OKPsA7p{ApD~wR zPVSGL4ykA+V|VqoI)bWrZ#M<#0?$z&xKdy)do5=dp`EC5rU0%dEBY{pujIi&GKy_* zwx8e={DosQ!mdM$xjs=Zl-kF0s>~rj+jA#Qyf7{9nGF|&7v)wrCxsUEr*?c^v=>up zTU!3OAtBVfvn?(zR@)1k5KPpmVbN;f!k5Q%<0sI~W4lXp`MO%HEmtiDhSgypJU$EJ zRKqtsLzJ!P`Ci@^539QpY2o!JcQH)ODH3-dHBjm2wv^{%YMCEjaqj0(HDRXomi zM#pzpeyoiWe~o!KCrrW3CBg%XB_)%RBG#`*zFUeD&g8G+x#t_vv*7x!Lj@7)L#C}n zmU+RH`M?A9$w&mlNk8gPRIK-T<}@8?KU;)O>N6TWlbvyKzPig8Uoa!(a;t5GtLe#@ zLADk2DfbB~n232Zg8ckN;?tqzp3Ubg({APH>E2LD@7QoZFSzPD?@7Rt;e-zIPbV`-DZg|8W}fQ0}E zrM|PAVz4t{Uf#%ockK22V}W!3d>wiN===GzvjnufVgYolZ$DyA>xv2IV8)U zv2Yi~r8f_|D{)O{*DCi>4}qioSUMQ&E_fD;g|oDn3sHZLL<7*6$jL!T@{cV3xxuU) z>BQ6CJF9(mci-u_dHajnGBMeuQ}Vr!^7$fs?(hu7$WYv_4HE7 z9p(xdq1y#2ZasTbvy7W29g68v7h+fyc~ZyLq!xS^=iF-2d?SRMsA3c9>I`e|%*RqJ ze%rz;oxojlGjhE4^H!ODin>}pzVIb=*V4$Vd(OdD?&K^j@}JzsOJ%PFUf3@7xGC?g zhY~@lk#S(jdQp(~?64`SWV0yN5n-a2f?|wR3|MadEm``3%4+G=^ z0H=zP?q%^eNZrj9bG7oGNVglE71oiH@Ah5}yr+9`_a-K#T^R;xrV5igjLEZi47z$q zU#xw-*H3vjT%8it81ABs3Wl+}6MvG>?j9|uqnyK*B-_YgfdpU0a% zv-8xeXy$eUL-^!8%$?I@YQv|rM9{)jp}4rzmutdOxdmsQou5kBcd)k*;#2v;yV1wn zM@Oc{JUKH~Y_(ZzTY)Ae%QG$zx}~|i&Ep3YlnR$G0V)X z@HS@Sg|o6>&b}1e9o4~92LsoYWRtvtN<4`X^*k`g9v0O0zlm&Kr!KtwlJQN*J1R99 zismhhAU(=&PGm)p?@P-N3-q#P^WdBEZagvyhBj`>2WcgLoY?PfOb5{ZbRt7A_2(<|v(}Sa2Tgp=82l7vm}+a8U1_us#6M!pf8-Pp;OIA+bHU16FrMn)dd-c&I;pc5i6l3R&spZyC=H%NpYTw=j_HBZ=WUwdWkZvQq zpxNx903}OdB`I9X&kmkkWUJqXe>_K&h?_`Yc}Rk3mi;ukKA9A-+1jr{^q zROHFWbG~%jz4XMV+7R;pwLdAN!NHjJN_^+-T|4?antPluyTl>R_Q^ujSTgWY^rP{=x z=Fi*T^&%Z7*D?X1O1v_Z=4PlUjYKW}THnf!_$}re-mX<;f?`(j(wxuOzz7>y0VL0y z$>>uwd7_XH-xH9F9I2vCSSXP6F>O$|o8eWEEbeQ!)R$kfscNcnRh?L|iWXoo(gcCC zFIL#g`t7{fSeo=(Q@kV^Dd{<#-4yVAm{ca(kx%d04pcjne*99A0&mE- z^_msT7EkP3n`zJ56@M(;__HH(^1ZI+HpF=xFAsI?R)@cLrhwj4^}ME^w{6di&ZP%j zW9kh|Hb$t@#CIYYh*N5FupqVrjO(;C>iOPMu%;rFvfc0iFF3Wz0 z@d5nPgFMsWiMZkJ+lKNNB38hGRrg^sWiW0sW-j^`EI7M)`@JzfVE5DTi28Yud*kvn zRb1_zUS=E*lBiegEWJ;!HSC)6!F{hSBdN*GvlsK1ofoW=)c2Wjki~EAG6*}i%?@el zq{8%?^fA|OrvIzB%;`(hHknR-f=RBg*NhG?6Y169sw*)W{DPE zfw$ld@Dqh1zoz5)@^3WBpO5d#2roOB-|M^vW=|(xJIRK?A-tQ<&-Z#=XnmS_tM7$? zq?aYFQU2p&6cCu7^EPb`No%&)pEit=-}?m zQ+!(j62npLU+M=iqnb{czrPya#Kw2Jlx{@PfD3sATwd47fkcflWOXC=>791xJayBd z9@DqVCer4HOGcl^C0WOOwZ%Cvzm49*Odt9zcMyrEn8=xk$f^p!g&%~`scbP^x0y>r=~t7(=9EC@pjI&kWC5h16$bd09UQt4Ya{Sc9h0bZ@nC+FOi! zi|Hr0KN>bFONrh9IQl()uAcxz3;|^O%oRLP!~+%bl=!aIOpwj^2^0*U`;vDLPA8wc zDV~N`J1A&x-Gc#XL4bGD97y~rX#nNhzkg$i4}OYcWR&ks`j44#lgIJDulxC{hmzUw0ymCtOz6G!R51zU)wcuY6Qwl9KxEkcMHrHc8c@tv4icaqj)mLxtSvrR)rQoq4y%=b3f(6Gjt$ z0ZwxB|F<;-TvukJ4%|H+j7!GEoi^msRVlmlFE(&S!L2#F)@%^Z2EIK zx2De`2_dL=<#~=%rfonWOWhF;ROTF($lfILQSOw-RsTSAInK(S6HzF&jJ_RB21cO1 zF}9hqFz3k=!n`$>#s}rkxB0xpaG1D@^*2v@&3%GpelN!K%sYWKvxeyoDTtMgwQ%zk zF8H;8g(gU=I%xtVBYWx0rqqcJU#DJj7x{K(zQY&CEazAlEkaBF8Uz9n1%u{51+4T* zWAg>mZv9PYX%)+MjA_FFis7-DInkv?*UXjYbu%F;EDAm&=+rrMJ_w#pP4b#mom~; znvaDl&3=^Cn)Dp3C%tgf2^o@5d^E#`u>;3bi}dC>G@ZQ-Ww-;2Qk-66RCNyoEjUuf zXYzf?u=f(q7H~(H7{1VT5R3(aO3T}1_wHNSyV7(tIfQipSeWJ(U4K{m9^du%Jf|%b zyTZD|T-d8Y#2~+6b#{?t`8+*G$KeHl)Hu-O-N0Z;KLMNf9U!F5{!f5VnA!CS`m_C^ zTK8L!^c9cq+p!SE+SRyiXJaDjUX7qJB9g%4M18}?i+N)c zE%k;$;MUdWyvW;^DOO z9YZNfoMInz(2_KYuD<(E=Du;Ce|E3Ks7wipn0eqSeIWP}SU^Q5=)YL{$gOhO805#v z*Fub;^_4vxEscxpAKbnz{;e_YdM{nA)6HordK6=|NN+V=I;1Tz@0z|Hi+f3ShKl=H z)kfcfGe(J2LAnvO7ursEuWtlP2}sEuf^O+n?!`#NwU@pRdDP0Dq^UYSohhg4ET`#P z5}q@bSJ3>AmsP&^``gW!vcm^9P#x3EubVJ1xT2XIh_^XX(lCuqTp1QxzHyzULKM`_ z!0{A;gUnZ@=_E8i?nVN&KbX^J#o}x5;Ji1V2rlfSjwffnp|3~2?@W2Gs4G&&V<(3m z-K`?)mQ{!vG(2U@HJgdMdy@MvN*;L|`l6IL?x(*)eA4l9$3jrcvV-8?mS zi=Sj#xoV{3_ECjJV0np=)cahsX&efU6eQJK7cUNrwvIf4;5f$?y9$|`E`|ecVL;_k z?T3C&trwQ%i_XqxhQ58dXVld4aZ2TFb^`^;r`LqCdv=()SPSy&iyvl+5aK97>h zAKvLRN3WH-o&SjRYM^2>^ojT+E6z8}XkGXAlBlpE7l@`n^OIedj;1z()nQ}aHIol| zs>IK;qTcsSOIqM=SB~H`g_F|E2Q7iGVJ*0G#@L8joY?I(vjf*neTqBW=djbTcnWq^ zFwaK1g72XH`VE4d-uF0g@OB19o$9&H86KqYG%k1vga_5`-wfXxKCLgxIVNkP*z8e2|GU%U@$+F0-W1S-c%28E?z>_T0or*a(O zG(y`n$qHi%IW#ZI^f8|7g)J>#{Z@dedKBkuoO|koR?-76IaOY^kc3`|xjP;_TQx0& zN4GBBlCHXU$kC$WcQ*{Xzoe%ABwlv2>IE1%S+z~Lv{ehR^s25?oh@&_M1j^oF?)7$ z456V=|FhftgNUPBCWWevl9Jt}ZIJ%h%u8yc%n7}h$iQT=s)HG>>wEG9N&1H}4Wy$M zqCQ~cMw9HpU~adDC&So?RZ@7G`NYj>^Tx-oG$~^>mk>0c$BKqao!R4V$2wb4oJ87$ z)V9p0n#4!;h zTX`g?5px5fL|Y%zj+#bI1GF;{pc8rB*ZH%mR`B(cDhxwBr$gHnL3HX65Ot=+>qj~| zb*^QUJW#64G+lBCHY@u(?g}VMX4`A&{+d!D_#tW~Gv0rh*t02U9~(?C)2O%NWdiUu)^GgjiDYX*>D;=@+a%k}pz{WPD)W07ee&Hpn>Q>oGZq%$4ir zmfeSiMT?a0bV`Banz*J7zIxQ26#wwlYlP|iHD*_$4!^cDQe0khWFR9UHG`b|!Dff% zOw20Nh`pOoQH0@zr&mQQ?^uvxN#KMr(jfN?X+eKA4K4XN9Yk>vZ2F`i19 zvfxStj6T;R{b0GiSKPQ50BfPVnxuxJBhuB-D$X!3speAc9HT7 zqx1KBOvA*bur8uRXd-PX*=@5migW%(tX}ta5Y~ye*gT!5n`tW)FQc_e7xu(%k0 z%50JB%(@sNuAGXC%O(^@NiC<9nN{$P?=`T<Wpu`ZLp$3j*vZI}ay5V2Pj44S|DwSETZyE*>6UV_tD9`x?c`(jmzQ=^zC} zV?Y3=PWzu&NwQSDBM=~l`~+H@gl|#s6F7mRd+{R%=6`5Th68j)*xN^w?3q? zy+i>-@E_sKJxdz;EFPH)xo$J1&Gr8-K<+Kk6rgo9eY){e)y*n>_okUUwF`b+LEHmH z^*@2mT=cb^YFu(`2{5E`6uujWp)P~*=*JTEEI4o!62e8A`6#w0n);X$aP@~olr8Fbg33BS?Fs! zIgu`-45L?gqsmh}!kdYPu=z(^G)KgQM2O&_?PkR<+i?d;!gU%C4%YiO7yPs9pR?0& z9iE*GVld4W?}^(Kcuh9+lulv2d*29__08{$ixY>bQ`PzC_pafpN-gsB6;~ckY)lY_ z;7eQcL)zIcSK2+7vh>Sd%=(ywhfbio)OXF*FWJs%bPU%1jgQA#KgoxZf!;b4S*9lcYZC&x`ju zoQ~spQqD%gjes$4uog+0)zyhIegs&7i>>B3JPG$%7(jxi6dV-- zxvD&iaEk|6nth64fGLji=xqO-elDKjh~)7e{{e?3R^!inbtV&o#~Ujl}v;KTI^aT)D(t>RL2#;!ft8 z)nRzJ{o`rv%m>R|y{DVgG7By@PF*e&jKDAP=UI7tE}+5BP1!CV98Emq&h zUJ=4d#HY`OlFuo9v3T#;Zy@E=ZH%rq(0e|{82Sl4?vVq)R;#CZ@)>L}eoCdg+h(Xn zT(o0vZrj$qcK-@0a{2qXxM<1>vUM`<;R1>h)xpFU4~NqiTRS!5Mfmt?X@RrHDlL$| zze2Hh(>DMzZq{tX>)dq$$7XYYA|U-&yUiBdb=>AUyrlTbx9r%D`7K>Pq`@jyBQ4h# zejepy`HvcE))&c+++qMlK1P6`Zw$Ne6-QX*G<2&u1D|%vJLXD+kIzzvpkBgrcAjFFY2|ZdAZPbgi7AVx95>HxXw8k(z<^e zZFkoci%~*9AX+t(_=MB%2dFEX)y?=?YB$21Ru?Mdo^-MeW*WVi>wdZI&P*FH)XB}p z=uR_5ty*GuR@0(KE6DJlul}BKPn4jbP;xFrD2=wt9bc__Si>ZGWA<8wjCU{-1k2mE zyM-MLik#7le;NaI&u&p^N|!C0dVvq*J#w==IId3ZYbGMvKgwW&Yt%FAMl{YjG#w*2jph`Z$4e z=h}!3^kQDva|J>04q5I;Fz@loMCBKYtfkw1Tde?L`;#8#e5@DGX}VaYI${}2m_^!; zmf$(Xa0Wix+;6kH>2|kmok~jh^u$$nJVD6G?f|~5KXI>4vz2VODc#4eqb7fI?77^CJ@dZOj9aPNm7x6|l42w@Q0e zRzdJz3R;-^Q;&`3Gz`r@&?f0;iwOMirX2VnFtc`XyyIN8+}XVN^HxIk^qn0UwP)DN zRV@~W9g`?B88yxbX(N$!Yhfyyka!+qEb>%2%T5dat2gS{w4N_H)rtS`6R5Q2@Pe$2 z3q4%&AclIRapEf>({$3&E3}7EC)iqV@588;{M%%#yx?$nJWEBJApchV|7!2Oqnb>+ zwecWm6lp3jbfSO=h*CroIwC|Y^deQHNE0ccgM^M^2u(yVgr?Ga?^QyRA|SmPAoSi# z{2piKozWTRocCSd`K|T+*6|OMhY)%0=PrBid*9c-E*dz|4|!`zTE;QRtYg!INiCH5;V!#gl7105D6r;u za*Nc`3J@uS-M1UO43{X>0_HI&w@D)uYv#4X&f39lFR&ebkZsvj!I^5e>I%O9yhD4bnm9(VkS-ieQr~GL6cSH;=m-mre$7 z(Y+Q!lW>~76Ww~RGqsmjz3#wof2e(bw~R6F^wM}$5R4;CzpJTEw3tFjfs{Kfq`eGz zbc8t_s-GKL?y_-R+0!@9t@sP*_+s|K>T}{@@{UHUyJ?XMizOXgIvyn4A*0=%q0e>n z3FC{o_aBwDy0E&R%{>m4--nZhoIaflrV7g3^^tRvPfmiTTz@pg$4D-DhvF#23kq@A znAN*~&9?+dcPd?z<5(6HNyAedW{b zErRPuFe%FNVAy?oSjW4oR&5LCqUyAA2W>91ymetz_NdS2Qj~_ER+|B$=W~@p$)~{d zg=Ixpzt51*pNciRJ9))k`xj|Ow$ssuyN#2CyQK0-HQZmF2g0cc!0wB@&={0g(XwDE zuItx+>HZS7&ML3K^-TF*M4UdpI@786+Q~CFH&dnN9&Q-mry0M*2%h)k#@F(g-JLAH#=|sDV+WQ zd(<5~cc$!vRko#LlpH61Da%XSW+nIb-E7(tnT?TuMj!5TL7nQD67y@uN$jCg&Wr%` z-FysCKl+dd)c%p~X|t+3IxvNik+G4QF0Da%$Mwo`-`;Lah8%TZgyJDG`_<3~&kOu9 zhd0gZCXK}-YFJM&inE}p4FXbJ&M!@`v5U?S+)afN6o;u?aNuIlb~BlA`^M{Nk+5Uo zh^c3{S**bplX#9D`Sl(G6nCT&4Q-G<=LLk&$3Ud4@6HHgeS2XWD;4y z02^0}y}zv|L&(0aN=cR2&8Ly7Z?<>o0-!KC7=aN++MV;shFD7xvHC)u!}$(=iWRQr zz5KCsIlzfcE<469S|1J9yWB#8&m{}VF3k!uSmbG~iko&&-L_EF-}nL&X4dW#k&BUg zW^yXfu>3(&4HV3!i0I4i4w@3-D}9_y`J@_>V&|3hOV*K4(DG0cL3ITBq{ed5+k%3!1C#Rf~L~+U?+IIG5Ve!edb;VWT)O#T`k^Hd>h9w!OMZ zNY0ilZ1qqnTIYW$UCMKTzzCs{A>?qgqb1UlI*kQ&>j0d}g<3L0A6k=B+Sorq%2wge zr!p!PZ(V+ww<+SF8&K-Qqc?@+wamQ$h74F<+#)Tc~S z5eq3bo^*v@w^}!~B=CUb(^?df7_rolwAA)u>uA}cAJV#5cqA(PjS1hGy6+Vv&qR=L= zCY%&+7#cY!?nFRS1?{nC+?A6vch|h~*ztC-1wfxPH6X2OTOQIPP;p_tFKCOB2u2dCoz&DMPws}= zg5kwYmG-Y!y4N#BzHKlPyPF1TzGH1yLl)Mvb+nXhTVx6^7yCgM2(M8p9%izB4Z(dJQ63rFzvlo?vkG1nR1TYR{59Y_5k@tDG7 zjgcIHDu6?{^>5q!=G$S|1Uty`ywPs>Ot(TueDyQWnR(z`_4Hw< z7XRwG!%XX|$!u1B+?a76T*5Mn-AK+6$fbOTJ~R!`N@rKQC{%fGFNW<%HxXySCeL)I zlmHv{ROVa#${Rs&# z4$_foSZ(Xrl)J(`3`-?Zs~{3RU9t>DHnh(X)QG1?bxzeli~&Jxf3=}h{70+oGiG=9 zA1b|CT>zhDDBV3t;YM@MIA?LltlrIL%ep|BWlC$B%s0R$Isndc+HP@P%}nw1(n!_f z7tr-bvvvAI#Us@-2zI*5gBLz~+2#q;&qw4lu)28+?0LCsDNUqH2_C^2;AdH+`*r{mR>YQ$$v@16#gPT1u`Ws!w7zn857bw{<D4a>d+jn8Qc>d%!-p1)TQPo>8;v#`HEFHlc$As$|`!2n8|P&f9j6?eDm z?9-Td)!>wK6hzGfR2)Q-#Wi5!+2q^&Ch$J9dZpktx$Pq^PYq0c87A5{<^`7wV^t&@`{9ZKf)5je3|S;w#& zNK2{cSEDWuHh$DLp78OahB3doBo8F!IY#piI3|9{4a?4YDy$IU?L%9A5fM_^<559^ zy(z8-xTOPE0AmXR@>b6kGm=DCZmVYmYO2J#aHVO=+tdw7T^gB&_;S8#?%<6#W-Z|= zW!+g++)1*Y*1hO$ud3261k}-V7%ED!xNBbXJ2+#VDa~yb;WqP?gZi$cU|HML?pBiVehPDg{&13r?%}LsB5#o9=5|rM;ao1 z)M73s+#*b*A$rgkLxEKUv8&q6&U@eO+IaghQP;egH@f!GnP&ce>if6eem<1gJgE(N z`q*j6J5*FOq8Z{q*RpG-)mΞG2rQe;!a^!bA++#Yexq{!Z-XdO;X)AUeKnjCM=I zm+p`HTR$#p$%WJZ8W=bkk(o|A^_(Zrv6ua~ToeXXn@Xn?BFz{b&n zE|2`tcPSpxpoRu~;aEWD=)>EHDJgDNWvr57dITB+g6fPr>L0<&8k(qEg7wMNwB`{&@t!QBVEu7n65ETS_44Xfnf%Y!PBZ zZ>0%9PY1-7&y&7w`{OU5NPpDx#;E$f)3RsstUU!rq^C}h`qs7|Uy>Ko9F1JPbnm9F zKUHN*aCTqzwj%fu#p(wHQ^Dz4KCVWOuHd29b~A$QiY_>}R6WZ#@goImytwobHr?SH z%giL_8W&E>6i3d8j!)vf5Fy$Xf{J@X(0i`Zb`C=sZgEK$ z(jxMRO{q8w1GAMnp~tK_w&x%iyYN=;I1l!wzIU1~W^U#-wt$a*@T>f*Mla)OMhdSN zr>e$9BM0q8(W9R;HK=KjxPr0GMx{ftp4NxQ;_9Ej)?R#;Cm&4aCx8gQZ#lX4p;2)7 z311o@AjJcuQS6a@^~jl1eeqi1=6@Ex$^9-MqP<7VE4z4Fzxtd=J8Tk5XHU|oKnlgf z#FdY-pK30JrF9BeupPwM>a}ZMKvr4gLrUeV>L1SW z-R5J-w*`#@Lg#4$0!a`%?^%7R??l7nsijxq8my3~u7xHfMVX7;2ezgHs?^YJP*^(@ zIyX<-C#MH(_t9 zeN$P1>xBd9OA1;;Ww4oE-*fRNHWRgl=v~(abNO+*u=4%*NjI!LNo}_Hs@D72>}Nq8 zf;Zr!5Z7dgZ~IM^4u;*5rUw|RUzEBhdrWj))C4~Ue!CpAh_f%Z&YW3y8 zOUL<9z((|v0=Zzn$!7EB`KqAKg_ycgX6IV-L^)1}mJ~1}jz#O#IJ-ZP?7nmP^3{T* zqcrv@c9@9H9B~RDm^f{#)n)!I#qa+k^cnwAwF_TRulO$_FB;bs4gJzhsYxY+j`R7> z*pk$O8HNVCbkx#$ZDembn%m3Xat;(%}~iJEMG`T)>L1%#?AyenksG$ETOf}DEIoxh{7rE z#0!EQ{7$VOtrtRVOnStxmIM(p#bHkphby+iC|_ePJiJbRW(}=(&CtykCo%sqC6nWs zU73RR#uYSI<1Ck1XWc4Wz$m2X)U~C_T|J5=k{tPuaFu38b^|w-C!CfsmM3LsAEmCP z=T90ttF4=)uz)}iW3+&~4zIC(%G!X)^c|~0Hr?|T?bPoLC}M~rn1{C$$F4H)9)%pF zF`#MjtnCUCE;AndTwNip71D2y_*>ULr!b5NcWRM0|7_hDWZh&y!bvl1=;Mx!6@XtYxIH2l%TfC5y2sG4(By=t0V$g^m91b0$f!)` z!q#Ga;<3eF_+p|!$% zV(TV)Aq6uWjhUXTD^;S~xiFV^vV?`R1#Cb9Ss987m0s?UhBjKICk8ok-5sHdRZw$= zpS4MyOYzqkVO%M(o)LBA1QR5Oq@^M)U68j+id-LGiq)Rt1>ITH&>N?~@8eMJ;R+(f za_Z^&SHiUxet!edD;EnT9FC9D-Rpf0%8K4#TC4~`ipkmtREZ-RK#z;aCOzFLQbD)D1}Ew z>Jo?#^pb-PXdShW4pW^rCCvtfx>&b1L7WNkEXE?eUD|4?ypLzv|ED?tfxWVl+85>| zpv}R}Ts2FHB7nlWLt0rT&1R!S3&_v9gyn#!IZ$Xgf8km`!WKY$Ayxg$KIm~<3ONnPgKb(%%P?jgX zFsvv`Uw;Y*X20Z0I`lRXlY9Dwx{hM~%X6wh&lURD4vl4cHnrut8%a}0oJ22;By+G! zx~*dfQvS}8Y~^Jbfr?;bNbp+*8kzZ;hmDdIgk-vGIXXeAH|jb%)`xn$Myxke3JQky zN&y63T@iDIdYr$IoT)S;G)v%-W-(&A+QIP_l#LdNaE&PSym$% zVEBp?nR0LR7|(O^$+w1{sBOVY6N;eVxW`s~Nujq$Q^{zK0~MieG*;D&*O+2}4vyVv zF6rq#U#3S8=a@K?^s*$nxZ}JGBpk%e9pR(E!5J67bhm?U2f1(04!QbClOnlDngiTV zC|0c45WAwqoOw;sGx@hyx;MdUcV*1a1xHG1IC-ER&v`zIB=rK3QP?$7u<@>#^sQ## zh4krnb83}&z*EWqu$E!TUSS^RDrcT6q&lr|UZ;83Xc$PVX&82cMUW0zO7l4PElUHz+2kQMJ5G zb3^Dw)>33864dB?B-h9ux3oEU%+}ssbdXQ$S%k+YttHDP1yy-l zkZ~D2(sDOztp6 z#_eLF{NxT_w(33&3{R6k9M749%fr~~K%}H>k?ajp)E()&lGm38s-=WbW{)KS4^hs< zt9dpJ+r?%7+Z!Tg1vvy!v36uQ!307xB5))(RS`H@?`}*)O!6vq{rVhHDYU%ErlT#1 zaVVq$o{-fTMCX)-c$2+zB&%1^A@U1|^h~|*=uHNL#8l<-TVXHfOJXzNfCi(uyV~k~ zUu5CUQm>~=v>~rKNzu_9p>QJ@0HEvcQqX*1)>g35AE~1fC)C|-jDD`#8|L(in;-&&T8~Nr&s?Cw+jo~UDt=05 z_D%SPV1?EMpqtX<;WeavPY62zLa`fTM?}{<*JA{G9hxdaxb!a6{o>FxX;+W(0z!Hd zgm=*Lg=F$2!Kpl}Hrp)xSNGRsbMfOQ6C=pvfe-cWL5Q*|UBl4KFQd#(^zNqq&1dzz z(XTj9S8O#wApk0ob&59i(~C2@$z2hO1@SQ>lBh|HWenE%oR|ZD4{JxkB+c=QLSSSl zfq^4ts60qtvL9}qFd3|(3}f;3Zf-$GOTeWfEmUr4*jUp=Nk{4q$(eSp?OtKMyM!#D zFm4-W4wQ!CZKyHEKyW%|Ro?k{=`ro|62C`+J{iX!0Ve?r_*7V?4)5G&R=I~SSA)6ZK3#ffMOw;Qc$EI3!)2;4@RA6JhbB+Vti zX06s8$qiJ|%gecm*!Qg?tw-TjjBT13oT2E~wRPv6uy8x9%!6L5)FhhjsgLcoPc7DF z&5Xl$qLGt2yRwXtJ%*cg2MuU<8j`*Jpr(%^t_LiVADo%5a6QwK4Hd>7bD2bqM{;n6 zA~X*)0K|mE^}*IDKK8bn^`0eD3AZ!~3TJ|^{s;5v)Q>2g%1vZKQcUtKLCfu4V&JJ% zkK1UuwM>;kEf5ccf}X|D{mRAS@RQ{g{=@guee|Egc73V*Haobx z$(S};cs04M^ULTQI&&GRpX;H^?z7F}`~0>p<5YuE+s8?2Q`O%wbD6fEC_L0WE;V|7 zu--mFcBG!nc|PuS@(4KtMbAV*l-Qsspo|H%=4#(US5G?bX`~heKy?|>SJcqa8lcaa zDso06BW=3nfOaCSAKiE5H(3Ft%K+vO_o8}*`jDY8lln8f*Yn{Esb}mOyRVSc8#~L3 zY&_~h(XV}^`c=YaT<2hP=hIg{@_1W0T^R9YZSGFq4p8#IAl^&;$%(_4ot>GiDEuxf z#JW=HT;+=ObWCj>{h&P4IbCci$fKUEgoQ{qJ9sShF!hKY{wR(k88VUEjECR{v%54D zgWio`y+-N)g&e=X?~MPoL;erm2RKe2$si%4kzpibOQM~-KpNU7$tvd@4UyDcv+F%E zxiMFPPX&H%W6*M@*!UZH(NZVK_oJqp7Ofb=IMso7u#wJ zRKJRqIA@>FJn_*jJDQ-8AgZLX4!g{}Bax-Me|<>Oemu{|-f6>h;{nuqjfXh4K{eJHp+DPYDfqL202 zk;0kONR4FP!osCHX_+vM%xpx52mfc}4m@gKa##CmF7JDL5UfKc{2FNhb3V34<#XH_ zfM@Y~^}rTyN2&M2lU~w|qA2eYRPGSU`B>$Vn+@?v{~|Iv7pvp$f>>XhpMSd_^T$;* zlWEGzX1sheO=DX>fjjDv8S6Tb^m|x=Zye>(ca3NzlA<|k&O7to*J+@r>^=| zUoExmWo#C&Mz1KQ*7gbb8M0$!W*+`9R>(msfH z{?k@oWrn`n=qIg06g88J`@ZFo6mU$Sy&36TDM!g3g?EJay(*^FvU~DH&Iw83T#edP z0)hpG6u!Q*O^oe#ov#3E!nWpAs4L?ni|@{(~P9MWNU4axPGXB z@U^=8OWYh#;1_V9eq}znB3j{e;P9E;hm;nP*`f>e@@ zH{Oof!y?`ss5pi4x1^v}ZXIjduI1+Fp>jvz!BssM>4{f;l*;C0X5&(t#L-Ee>v~G> zmAD^05kDM8x<8~sES58LR7nMu-{tKYlx5*Z;h1=EchbD<)bwRvikvI8>F$h~W64dW zYxTqil1_|h9I!20xMXlRwdA3)T#kCz03`)>;ex@X=ZkHKkUIHR>Fzru0@Z*VK z47O`r`zQrf79PUzqNu=7);y~;^f5&5O!b+s@1JxoH!L`gJv%fmxUW))>oK`JDPxnM zgMU`i_m;?GB84WA3Qyr4kayS80HVu)1zcPCxRadtCh;7!QG&{K?s(Q5P6=J>k@A8U zUE^-d-Lu-WW;IxE+H%s$(=0(TQuIDKw32k9Xjs8X27jm%F-(;q*o_79gKcoSVVTE8 za~yKyN%6`cMnZh*g=~3R{Lut!pvE*P_t%u~?;?1=Udy^V@Sl43XoBt)9zgu|^r(_H zMMzhyk_F%&98Qqsn`%*ZGnev$@0gLY^>)w3Q5c6%ioKNL8I0rI_i^Q9S1I@cQXC9w zgqrgkWOy_h?KoXH>u#UZL^|+}wi|`G@ z?y^b~ILEb8``GbF@YQ#6Jq$u1(#xc_3-)$R+u~k=-A6Uw^}c28Jnuvcpl;bjqi()0 znA4`gV>$I`1UvK)UbgNgBti3rJKkoz0hiRVZNXuHfRm4uPKwc4u1cS_nfaHi#EOfC zSLfi-0*zw+QZ9IK_Q+yS*vI_B%R%J7(65H$DoQ{O3vUSG+YH+oNa~%3Hm4M}nmd+S zr=FW#Mkh$)SgbohPVIs!s>RpJS#_DZdb+x>aQo4Us@~A5FW`8;@@h7)cc6;dl0W%l@kTRJ@Y6 z#+%TU6jetP{9+dj9xm(w=mNv~PEbwvHAy*03UqA*x0pZL^ogPp# zKrx==rQ!V*)jbY?nXRU?&sg9U%VLIkGyrfkY`+{mS`n&6#)gmCGpa}@K9m9mTe5&8 zWa7SG{+!oc`#XY!rASGOTE<<)t3VxSGhXZ_q%Uh`kc^3U*QqOww2visGVJBA)cDXD zXePNy_eEa)Ci3{N@?G`{-0`%aJ)ovXz~$Y^nZ$hWPqNi*59KM2kthoZ2|2UvGECa@ zbyjc#XAn+fo6FQhuL6?Hf4?Bb+NiWp1ACw6MvF}UeQvAZ5(CU>#3Fi=3LO-BBgOeb zFzAsnbRguzem+u*#q`t+oC){TQ ziczq%MD95tL{vEYd;7_p>09mJ!DxlB30@F9HXs!U9K?X~8gV1wu*-r-mmsGap)2$v zW*~HM0B(NuMw%C9g7!j3*3r9iw69BE{~8_t--euY2Fr>;>ui>Mi|yA^9+_ncQNO*H z7-LO&6$Jpf;MPb2>i+hkR9!awTMMt2lF(e)54-k5b%S3EtNy!E_HTZF{BL{b`|z%A z1z8HyBKnJ@EQ=j0AvSH3;R+uN64RpxN64q0ilx)aUPb|l^*b$$_Ec1GjuH+sPu3D3 zu}&LdF>>N+Y-d0I6e#GcKVkq;d67HPs?zkL&ff&l!=S8+pk_d%U;_xOD$}2{a zJV(lNt{KA`-SFa{-y{YZ0$mE>nHx0h!3)rvXwK(&-CPoq8QE>3C~*(_HBfF z1g+-6Ok+RAg*EGvGS0KIkGsdxHM+QezM=|*Xy zHb07jO<13jR$bBlb-Bscmj^)hBm8T<=8=Wp>owoROp8=Mb=pI=0;u^e>eiw3HBq*K zNyE<-+q$dPjk#-0{Yp#REtO^Hzbc;`4u{(wK__F5*pK8{Y00dRZ8wP5;MiP8>ciS? zE6b4dqLZWs{z*G-ln^7jugWJE-OS=V%t%Qkj=Dqj3gNmQqlARp)QT@#4G1UVJw(Ij zPwP!z;aKt!udl%wfejFVV#K_G@4MMk7SHo&$*J`mC4e>3=+gW-v&$e>R4_R=-5Hq5 z1^>=eCXrR|g!Bp$AV#8WvUXTN%N@}T&0v&d94zI$;&s}EqJ(WYRVw;CaLU1T>+}fK zG*^hv;>F!l0npmZQ5{v(t#R>e!%dJ@{ut*pE2>no47~l*;mCHOBN!Aq zdh>@u&y&|QGd``l@^V44Uwt$!I_*5XgBXA;vJ4!_H#p?M{ z_CpeLQk`$6IJMLcfLCJ!rf?rno;Y(_?ErxPvULJK0%m99lx7w0;CqB+x_Fi9vlqTO zRf>Jgwv|v$0-$Qk%1Q@$ro5!W1nO@DD1CgpB_sQMb&BphcTkaY`i2Vkw>$@3tH+Ie z_j1R3y_jb*b*aX|ne9g%uc)_+cbQX5f{;u(G=;*;t% zis}Om_LXQ$o&iz4GKjJ1KSRcd0;lAo(lSUgY+CjEcAqyDG=PZyiv;zp@w zWJ-o738WCk$2}r|IV9xFyAGsz_-^+L)|eciOUeAdO-O!wO&6TGQ#1zOHF;FM zeP;Sk^#$&uyC=908=_aJGJD6D>9 zD;j}*U1p3vyg6_1EMbRt>{dPA!DHI+-+KDf*j2YHIR&$>`QDue zbarVIt9im9(K}7}_&FCC*z1W^SHXR9-C6c4R#C+LwUIqGUtct+X+EYeu~Nr@gZk>D zf8%8EJKCNrbK{=emKkp^_JkfEuFoZ$T&^XXW*Z6FzFCfbsoWTeoI#SYbhVd+W zDC0;(H~5`G##o`sbahK@LSd@aiR8M+Ll?bxb_MJiypB(j_Vv9*RIlV`R+n-gu2moC zbBzY`7e#GdfBP2Xk-E-iN{JR7XS2f@41enI+vr%BH^*~O$WQM&VTz#~Jx@lTh&d$1 zym=GeeLEmP>fqwM&5{C;$<6)(`UU>oPxsi*RO6?l=7WIkiIV;oP#}=p9Aw|avlD%I zAMl314&GX03owYlmxw564$#$0+TOdsa>QM5BMV)6GMJ@4O-|e{6ou0Fi7gK*fk}{v zKT(pntFt;?;ZSl_{${wE7o3b_8*K+r(Zg7I@z)rdTa)OXGvR{y3-WVcmHYbSPCT8X zQj})k2*d1ay6l8dQDD`p45TRw?aITomW|(0>tS6Ori<&xsNhp42S8@_PG+$Qio!ln z>zefrhDLxB?5Vp#`eenC3ZXe;_0lB{1x1xY|y_%`O`pGeLyRoa55JPD9sK zWnay+8$ullKU?k{fr)r;wR5?_Oy}wDt94_@RWaYLGD9;k#F=rN=7K-`Lom_ zCoz;$;W)&jB|b~hQ!gBbhi+uV?Pz}*8;&6E-X~rv+gs~6Ir#kU&FiIg3PPyOx^!`HrOZkBeJf&h&UOy-2&`%96K%C4w&9~L{Y$1njQ#SU@H1`m3 zEo1R|t1pD8orA&}?MuYN`e4o6u#fp}@e0D9=HBJZh28?Vf`Xg%@DQG+CV+A4W&4bN zVq0l_T26w6u6PQKb-QAE z)^!`>5pj>4Qyd)BeYj*xZWZRYIfHSK?tY5Z${ zY0_7Z&xl}}2DESP&o3NjWTl?51vSx?%iT$QlTowAkEqpR(!9@%XWWgzP`RO#yu)2d zKSf;!jCzD$`%a^z7J(EU++!;M=9MZpDAoH^ISv)MZmNglUaGTbR@6|40C zhf|Ca!hou9gIKWCRK#}b3;|FT-jz`DSP>93;P)s}@mwBmXBu!HrJi)_rHf41dC6+w zd;>tC%h%YU0fCsXrX~WbOQz2F3qAel`U@rH5v5onkp;zpp zF{CJemeP3?wTCe`sl;7ZV)^QMt2W$Y@i&uZ>0wRtUG{?Ap>RsQ5p=X<4xv@kiTmP{ zcE#Il$86oON|kQM0$1kv?kK?4*?rMZslmyb1PK?&TH*Wy`}b8u8{@9GzR5~j=}-yw z`tCUbO)3ZUqKitm_`VsG5jw-yb>)8G))xDfxJslJ`(@8(O*8Ii!>TqHwRy^zb5W|BrBiRn@a`5rNf0lgrnYM?zW`%PY$g*J!F8qUpKOk zQEKCifz8TV&j+Ur!Kc0bgwEg!&x=yz)0qeNXp1BaDsTX0NoYQ@&*BRx0-#2Ukh_>` zdFj&}lggDLSqCY13EZRYv<5M#+cUO&1MSr#Gxzm(?WTfwlUb(n6psnVRfgzIYRPZA z0f)$tAm|#rog9Pci?YG_*mcJs1I15n{j#sodV;GRu9}eN`3QS&yO|U$p?F-wHSH~J zTx?^3sJ>+Pf*mJg$IGD7M&SYyjGCiD15Go>1;gA@UN;)ra8ZDQUL)K2!xQi_aELAWX8v{mqWohvsfWG`$D)?X5u?rRPU=L zm!jkZJ#!S39G~x6SzHtZLsOrChuFH0Yi{`i7F8T>E8a71mgHSC-<2cW7p}x_5W#6A zt>FdnInDv`?J+7Dai1vDi{Q^EGeYE60R*?+kxO5aa)mL9#uj^UZl`*Lc*l2t!vh8-5qS`!OL{u;K8-_ zofKW@WKers>d4h0Rh0k~fjwoKqy4JTQn%#A(_Aii^#IhUzw9o$0 z=X9+uuir1e(UY_B@2}M!$h)c9z(O)ZBC$S;lemj8xV#d$HOhtZkCc~uw8)1U$3q(x z$f%9`QFH6|`{lu`{D@IWlmy1l>(&bnj)c);@bQ~_ObPESnIc2)O?%xG^m0ylw0ZRP zMNy#MKLUlpT8_<>1wPGXZEQ+XO(q3%hu$;H9A7`Lu%-ftaaotwoC)LyFDG&}l@Ao|!2 zk|>b?xE?`Z^K`C+(x!e8ozES2Q5Fh1Y62qp0y@H-${p^ur`Z=6rJA$0I4UA|43sbQ zQlqJf!LvRY-2Lw81I4@Q5&8LR%>9dezB{jzq6XYb&&oG$F>)y>smgF}@*Z`Lq@0Q| zI2$0%$YAJ8L~``7$vJ2QitC(q60A6tmU)|F}C0WiuakxO7Yib}Zi?PG`Yw zYhH*SQNK4NL>l;didB@ovUaf;h4u@{H1QDp7{oU!us_Dj=0>I4?_(?60YQs3v-@9i zOx1iM<0aS5q1HrLTCD+>HX8{DW8oIx!FQh4wkL~q@%zTlt+SpXUI&nA`pHBkedN=} zHc8em?b6RG-U}-cKHX7B>UFH!T~$-;b-&C^wg%aKpFDqYQau4rJU=v3j-1i zU2_|n^#0CIgaH!DbJkE^8L>P8$$h5|%aN?7tcTP8Z4H+W>7}fl_$(+HJ zx@m0RY>N_g1^5px_96=wb(Ahaw_3Dl-o1z35PRC(%Ch#v|K9=!eRIn9$3f>epZ)hI ze}{1k>08;tHkfjc%+is1`fR={BTLdRr-FDG`>TAx_8NzEo)5JE2IO~nL@WeKESyu`fItIG?q?)%l5)jOZC&ywaArw`v4(?~@T-%KlBrG9bfwmNSR zE61g2m45QO7Py@cNiTlA6^4=~-rtLehW1OUZO-E|-5hCo^Y!m(vq>CAWFwt7i@$)F zy1TAC(XSXQKpBAn!pj~^b7SpVT(*IPRd-5)#$TE+?VV(4O;=m?Svjthy$tr~8o;t3 z=DE$D>BdjnYmt?4F@%lS+*e(`2b_opTlAanl@?=K1fgpOVf$E5sNTZKN)8HB*d| zUF+(4v^+Q4{ctHnN1O8+RhK_;d*Z{d&$skluT8xRPJPV-5Ygb5UDj|*rF!pN!DicK z>w7=y; z9}AfP27~R>lm72Jn275oHe--)T@R%Y#B4J?g3agwk{o!ht^B{Vbu>8j`GsgH{Icsh zc&S9M3dU`=?S|Ov`@w98C5EIwccG9KjuUQYFU3zY!?-PgRG;(eG%zI%{?>--u1z}| zlBW+5)2{W~;vV&8oQtsgOGNR$WEFT}oD)4f1ZgrqHgX7HMH>s2H=gL}))+BjcCogH z9qa-F&0>mL`_&;Lvpp({e;JDpNco;mdQK~f_D5qeyy_I3`X=q7qt-3>{_~k^u7WfsH)Q=j_y~-Ano>~7~=9Q#=@;1O+=z=I;Hp^ZE zx*)_#a^d?0v=ajF{WS4DzK#7-_kP#`hd69xJHKxin2*1W*$ayp`2tha9YOldQ3QCT zX{3{ooGkgm(oMdAEA+ZB{Z>ElY4cFeuPlLc8^4X+6w|}7Oh)4~6mpf$nA&aoYYwp4 z*^akN*s#nKCN!w`l|?MTr%s!&+4+u4w@O-fZD0^x<)hzN$=_?JKV_p&5O^{iJVNE> zhM1L4eq(iAn~X!y#ySxAG`3RF&24?&Ap7@4pz_Xwsq3YnK!a|dYa6>WhqEjei`i32 zon`8LDRaC{cjy7|DYuOp7F+RE>fyJCdbNXq_YO`R?QdYeir@cAQFeA@JGXmR)9epp z+;5)r>w0YSfB`1a)@Q+p`nBC*Gw}?XW@*2F_8?vOkFi;}^4n8SOa7Bhj{egWZZZ9~ zB-h!g%=gOmAmt3c)5A!6q#xc-tZGXX$=mj)b#tfuy=TxrHp|*^|1wwE4}Kq7!GE%} zKWMJ#j}7?4KUZmGK#;_*6A^a<@HXq79|fPX10W<-1UECd#k107Go#~QuA?vKUw!+J zCiw?VxcW~P`A5AF91xQJ+O;j|OvvSC_EN&M*e=){K%Kd-Oy^7e;TR3-f1en}50d7l zM-dkq@U3g`CD&avQD#t}dh`JHqc(p58P5T{Ywc1WD~NHWUqD*77<(RzIwp-gU6Hlp#lHVu>IJ6|F9SS(I|i43sk=j9Kc}}+&LG=X|}b)6CuQ80xp-&y~z6@i*x9f~nBY3}nVDNP%pZ9QvB0J#2Jr)M~Ca!S6dlU z-%RzppI!rj(>nX9nZ2@MXaS?|)F2W-Bbx;RYuN1z=r4;n_O}-NgIWGd=l=R&k{o~+ zE3q>d2DcUvCy~cHsDR*Zlc=G4=c7o{MWY8#i?h~WNiNAR1xiT3HnO!69aM9<~tKy=1;14T~ zCQC@TZYKTH?S6BmKlTCzKlB)pfBJ?WdI9Z~>5%lox|6w2C9QGW+&hX;+45!M*}n0j6Cc>Mto(j4rtugGSyEcT*akX};*`F6(Z9#HKO^j)5%!;c z8z2k)8DamnP5l{R|BSGIM%aJLW&9xi`x#;Xu`Bo)VgJ_=cIp*61) zMyvjrgx;?~=JWyBOyX^I6oSIG#50VH#7l#@y-xl!0vih`-zmt^k^Zkad;NKS{U71h de$I>k4CnW=zkc@D&pGgO4*dUh4oH0&_&?1aeFy*m literal 0 HcmV?d00001 diff --git a/docs/source/tutorials/qaoa_nae3sat.ipynb b/docs/source/tutorials/qaoa_nae3sat.ipynb new file mode 100644 index 00000000..21d979bb --- /dev/null +++ b/docs/source/tutorials/qaoa_nae3sat.ipynb @@ -0,0 +1,1070 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dc0db886", + "metadata": {}, + "source": [ + "# Quantum Approximation Optimization Algorithm (QAOA) for Not-all-equal 3-satisfiability (NAE3SAT)" + ] + }, + { + "cell_type": "markdown", + "id": "aecf6615", + "metadata": {}, + "source": [ + "## Overview" + ] + }, + { + "cell_type": "markdown", + "id": "b533d43e", + "metadata": {}, + "source": [ + "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In QAOA, the parameterized quantum circuit is regarded as an oracle, we sample the circuit to obtain the gradient of the parameters, and update them through the classical optimizer. Before this tutorial, there was already a tutorial of [QAOA for Max-Cut](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html). In this tutorial, we will focus on another combinatorial optimization problem - Not-all-equal 3-satisfiability (NAE3SAT), and discuss the performance of QAOA in different hardness cases.\n" + ] + }, + { + "cell_type": "markdown", + "id": "16ad937f", + "metadata": {}, + "source": [ + "## Not-all-equal 3-satisfiability (NAE3SAT)" + ] + }, + { + "cell_type": "markdown", + "id": "c2321b00", + "metadata": {}, + "source": [ + "[Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) is a variant of 3-satisfiability (3-SAT) and 3-SAT is a subset of [Boolean satisfiability problem (SAT)](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem). SAT is, given a Boolean expression, to check whether it is satisfiable, where the Boolean expression is a disjunction of clauses (or a single clause) and each clause is a disjunction of literals (or a single literal). Here is an example of Boolean expression of SAT,\n", + "$$\n", + "\\begin{equation}\n", + " (x_1\\lor x_2\\lor\\cdots\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor\\cdots\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor\\cdots\\lor \\lnot x_n),\n", + "\\end{equation}\n", + "$$\n", + "where $(x_i\\lor x_j\\lor\\cdots\\lor x_k)$ is a clause and $x_i$ is a literal. SAT with $k$ literals in each clause is called $k$-SAT, thus in 3-SAT, there are only three literals in each clause, for example\n", + "$$\n", + "\\begin{equation}\n", + " (x_1\\lor x_2\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor \\lnot x_n).\n", + "\\end{equation}\n", + "$$\n", + "When $k$ is not less than 3, SAT is NP-complete. On the other hand, NAE3SAT requires the three literals in each clause are not all equal to each other, in other words, at least one is true, and at least one is false. It is different from 3-SAT, which requires at least one literal is true in each clause. However, NAE3SAT is still NP-complete, [which can be proven by a reduction from 3-SAT](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability).\n" + ] + }, + { + "cell_type": "markdown", + "id": "4d28f719", + "metadata": {}, + "source": [ + "Now we use the spin model to represent a NAE3SAT. Let the set of clauses in the NAE3SAT be $\\mathcal{C}$. In each clause, there are three literals and each literal is represented by a spin. Spins up ($s=1$, $\\text{bit}=0$) and down ($s=-1$, $\\text{bit}=1$) represent false and true respectively. For the clause $(s_i,\\ s_j,\\ s_k)\\in\\mathcal{C}$, $s_i,\\ s_j,\\ s_k$ cannot be 1 or -1 at the same time. The Hamiltonian of the NAE3SAT is as follows\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " H_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $H_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT." + ] + }, + { + "cell_type": "markdown", + "id": "871bff2e", + "metadata": {}, + "source": [ + "## QAOA for NAE3SAT" + ] + }, + { + "cell_type": "markdown", + "id": "598dc69e", + "metadata": {}, + "source": [ + "QAOA utilizes a parameterized quantum circuit ([PQC](https://tensorcircuit.readthedocs.io/en/latest/textbook/chap5.html?highlight=变分)) to generate a quantum state that represents a potential solution. The initial state, denoted as $|s\\rangle$, is a uniform superposition over computational basis states.\n", + "$$\n", + "\\begin{equation}\n", + " |s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle\n", + "\\end{equation}\n", + "$$\n", + "This state is then evolved by a unitary operator that consists of $p$ layers, denoted as\n", + "$$\n", + "\\begin{equation}\n", + " U(\\boldsymbol{\\beta}, \\boldsymbol{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", + "\\end{equation}\n", + "$$\n", + "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ is the driving layer and $V_{j}= e^{-i \\beta_{j} H_m}$ is the mixing layer. $H_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $H_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." + ] + }, + { + "cell_type": "markdown", + "id": "949be36e", + "metadata": {}, + "source": [ + "Begin with a set of initial $\\boldsymbol{\\gamma}$ and $\\boldsymbol{\\beta}$, the quantum state is obtained from the PQC and then the expectation value of $H_C$ is calculated. A classical optimizer is then used to vary the parameters until a lower expectation value is found. This process is iterated a certain number of times until the expectation value of $H_C$ is approximated to 0. Then we perform projective measurement on the quantum state output by PQC, and obtain a bit string, which is very likely to be the solution of NAE3SAT. Since NAE3SAT is an NP-complete problem, we can verify whether the solution is correct in polynomial time on classical computer. Even if this bit string is not the correct solution, we can repeat the projective measurement and verify the obtained solution until we get the correct solution.\n", + "\n", + "For other details of QAOA, such as the selection of $p$ and the overall algorithm loop, please refer to [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028) or the tutorial of [QAOA for Max-Cut](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html)." + ] + }, + { + "cell_type": "markdown", + "id": "940fa22b", + "metadata": {}, + "source": [ + "### The code" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b0def04d", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:02:33.234006600Z", + "start_time": "2023-06-30T02:02:33.229847200Z" + } + }, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import optax\n", + "import tensorflow as tf\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from IPython.display import clear_output\n", + "import random\n", + "\n", + "K = tc.set_backend('jax')\n", + "\n", + "nlayers = 30 # the number of layers\n", + "ncircuits = 6 # six circuits with different initial parameters are going to be optimized at the same time" + ] + }, + { + "cell_type": "markdown", + "id": "6e407437", + "metadata": {}, + "source": [ + "#### Define the Graph" + ] + }, + { + "cell_type": "markdown", + "id": "c82972a4", + "metadata": {}, + "source": [ + "The graph of NAE3SAT is constructed by the set $\\mathcal{C}$ of clauses. When a clause is violated, the energy will increase by 4, so the upper bound of $H_C$ will not exceed $4|\\mathcal{C}|$. In practice, we multiply $H_C$ by a normalization factor $1/(4|\\mathcal{C}|)$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f1532831", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:02:33.397944100Z", + "start_time": "2023-06-30T02:02:33.231412200Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# a easy graph instance\n", + "easy_clauses = [[4, 7, 6], [0, 5, 9], [2, 6, 9], [2, 6, 7], [3, 1, 9], [5, 9, 11], [4, 8, 9], [5, 1, 9], [3, 8, 6], [2, 8, 10], [5, 6, 8], [2, 9, 6], [2, 6, 8], [5, 3, 9], [4, 11, 7], [3, 11, 10], [5, 10, 7], [3, 9, 8], [3, 6, 9], [2, 4, 7], [4, 0, 6], [3, 4, 6], [3, 11, 6], [4, 5, 6], [4, 0, 10], [5, 4, 10], [3, 7, 9], [0, 11, 6], [5, 11, 9], [3, 5, 9], [3, 4, 7], [3, 4, 7], [3, 0, 7], [1, 7, 8], [0, 3, 10], [0, 8, 9], [5, 7, 8], [2, 9, 6], [0, 8, 6], [4, 6, 8], [3, 2, 9], [4, 3, 8], [0, 2, 8], [4, 5, 10], [2, 4, 8], [5, 8, 9], [4, 8, 9], [3, 5, 11], [5, 4, 10], [2, 7, 9], [3, 0, 7], [2, 8, 6], [5, 3, 6], [0, 6, 10], [3, 2, 8], [4, 6, 9], [3, 2, 6], [1, 5, 6], [2, 8, 11], [2, 10, 8], [2, 0, 6], [2, 6, 9], [0, 8, 7], [0, 10, 8], [3, 5, 7], [2, 10, 8], [5, 7, 9], [0, 1, 6], [0, 3, 8], [0, 6, 9], [0, 5, 11], [1, 2, 10]]\n", + "factor = 1 / len(easy_clauses) / 4\n", + "\n", + "# convert to a NetworkX graph\n", + "easy_graph = nx.Graph()\n", + "for i, j, k in easy_clauses:\n", + " easy_graph.add_edge(i, j, weight=0)\n", + " easy_graph.add_edge(j, k, weight=0)\n", + " easy_graph.add_edge(k, i, weight=0)\n", + "for i, j, k in easy_clauses:\n", + " easy_graph[i][j]['weight'] += 1\n", + " easy_graph[j][k]['weight'] += 1\n", + " easy_graph[k][i]['weight'] += 1\n", + "pos_easy = nx.spring_layout(easy_graph)\n", + "nx.draw_networkx(easy_graph, with_labels=True, pos=pos_easy)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "c944f6dd", + "metadata": {}, + "source": [ + "#### Parameterized Quantum Circuit (PQC)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "055d1257", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:02:33.427591300Z", + "start_time": "2023-06-30T02:02:33.396852700Z" + } + }, + "outputs": [], + "source": [ + "def QAOAansatz(params, g, each=1, return_circuit=False):\n", + " n = g.number_of_nodes() # the number of nodes\n", + "\n", + " # PQC loop\n", + " def pqc_loop(s_, params_):\n", + " c_ = tc.Circuit(n, inputs=s_)\n", + " for j in range(each):\n", + " # driving layer\n", + " for a, b in g.edges:\n", + " c_.RZZ(a, b, theta=g[a][b]['weight'] * params_[2 * j] * factor)\n", + " # mixing layer\n", + " for i in range(n):\n", + " c_.RX(i, theta=params_[2 * j + 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(n)\n", + " for i in range(n):\n", + " c0.H(i)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, K.reshape(params, [nlayers // each, 2 * each]), s0)\n", + " c = tc.Circuit(n, inputs=s)\n", + "\n", + " # whether to return the circuit\n", + " if return_circuit is True:\n", + " return c\n", + "\n", + " # calculate the loss function\n", + " loss = 0.25\n", + " for a, b in g.edges:\n", + " loss += c.expectation_ps(z=[a, b]) * g[a][b]['weight'] * factor\n", + "\n", + " return K.real(loss)" + ] + }, + { + "cell_type": "markdown", + "id": "5b159920", + "metadata": {}, + "source": [ + "#### Optimization" + ] + }, + { + "cell_type": "markdown", + "id": "6d07ee61", + "metadata": {}, + "source": [ + "Here, several circuits with different initial parameters are optimized/trained at the same time.\n", + "\n", + "Optimizers are used to find the minimum value." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "690b8b67", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "backend = type(K).__name__\n", + "# use vvag to get the losses and gradients with different random circuit instances\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "\n", + "params_easy = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", + "if backend == 'JaxBackend':\n", + " opt = K.optimizer(optax.adam(1e-2))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(2000):\n", + " loss, grads = QAOA_vvag(params_easy, easy_graph)\n", + " params_easy = opt.update(grads, params_easy) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "98a6b152", + "metadata": {}, + "source": [ + "#### Results" + ] + }, + { + "cell_type": "markdown", + "id": "fc1c257d", + "metadata": {}, + "source": [ + "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we can also use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8c5df93e", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:09.636366200Z", + "start_time": "2023-06-30T02:28:26.850918300Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #0\n", + "measurement prob: 0.244925856590271\n", + "output: 111111000000\n", + "cost: 0.021371711045503616\n", + "max prob: 0.24492625892162323\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #1\n", + "measurement prob: 0.2965589463710785\n", + "output: 000000111111\n", + "cost: 0.013323463499546051\n", + "max prob: 0.2965589165687561\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #2\n", + "measurement prob: 0.05372887849807739\n", + "output: 111111000001\n", + "cost: 0.018687034025788307\n", + "max prob: 0.26440468430519104\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #3\n", + "measurement prob: 0.2904357314109802\n", + "output: 000000111111\n", + "cost: 0.014396688900887966\n", + "max prob: 0.2904358506202698\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #4\n", + "measurement prob: 0.2968122959136963\n", + "output: 000000111111\n", + "cost: 0.01325833611190319\n", + "max prob: 0.29681235551834106\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #5\n", + "measurement prob: 0.28433939814567566\n", + "output: 000000111111\n", + "cost: 0.015517047606408596\n", + "max prob: 0.2843400239944458\n", + "bit strings: ['111111000000']\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVgVWxfG3xMcOhREMQBBBAywA+xW7Nar18TuuHbH1Wt3d1+7WzHADiywRWwRAUHyzPv9weV8InWAQ4jze5554Mzs2XvNidnvrL322hKShIiIiIiIiMhvizSrDRARERERERHJWkQxICIiIiIi8psjigEREREREZHfHFEMiIiIiIiI/OaIYkBEREREROQ3RxQDIiIiIiIivzmiGBAREREREfnNkatTSBAEvHv3DoaGhpBIJBltk4iIiIiIiIgGIIlv374hf/78kEqTfv5XSwy8e/cOhQoV0phxIiIiIiIiIpmHv78/ChYsmORxtcSAoaGhqjIjIyPNWCYiIiIiIiKSoYSEhKBQoUKqfjwp1BIDcUMDRkZGohgQERERERH5xUhpiF8MIBQREREREfnNEcWAiIiIiIjIb44oBkRERERERH5zRDEgIiIiIiLymyOKARERERERkd8cUQyIiIiIiIj85ohiQERERERE5DdHFAMiIiIiIiK/OaIYEBERERER+c0RxYCIiIiIiMhvjigGREREREREfnNEMSAiIiIiIvKbI4oBERERERGR3xxRDIiIiIiIiPzmiGJARERERETkN0cUAyIiIiIiIr858qw2QEQkywgNBXx9ge/fAS0twMYGyJs3q60SERERyXREMSDye/HsGbByJXDgAPDiBUDGP25uDtSuDfTpA1StCkgkWWKmiIiISGYiDhOI/B58+AC0agXY2QELFwLPnycUAgDw6ROwezdQvTrg5ARcv57ppoqIiIhkNqIYEMn57NsH2NsDhw7FvlYqky8fExP718cHqFQJGDcOEISMtVFEREQkCxHFgEjOZv16oHVr4Nu3/3fy6qJUxnoPZs4EunYVBYGIiEiORRQDIjmXY8eAnj1jO/TEhgRSw9atwKhRmrFLREREJJshigGRnElgINClS5IBgKEAJgFoACA3AAmAjcnVRwLz5gGXLmnYUBEREZGsRxQDIjmT0aOBr1+TdO0HAJgKwAeAs7p1SqWxAiOlmAMRERGRXwxRDIjkPL58ATZuTLbTtgDwHoAfgDnq1qtUAi9fxg4/iIiIiOQgRDEgkvNIQQgAgDaAfGmpWyYDli5Ny5kiIiIi2RZRDIjkPE6fTn/AYFIolcCFC6mfmSAiIiKSjRHFgEjOggRu3Mg4MQAAkZGxaYxFREREcgiiGBDJWYSExM4kyGiePMn4NkREREQyCVEMiOQsIiNzVjsiIiIimYAoBkRyFjo6OasdERERkUxAFAMiOQsjI8DMLOPbcXDI+DZEREREMglRDIjkPCpUyNilh3V0gKJFM65+ERERkUxGntUGiIhonAYNgOPHUyy2FEAQgHf/vT4M4M1//w8EYJzIOYJUCtSuDalMpgFDRURERLIHEjLlOVghISEwNjZGcHAwjIyMMsMuEZG0ExQEWFgAERHJFrNGbAbCxHj53/HE6JI3L8qOHYvu3bvDwMAgrVaKiIiIZDjq9t/iMIFIzsPEBOjVK3YtgWR4BYBJbNaJnSCTIdzaGspatTBs2DBYWlpi3Lhx+PDhgwaNFxEREcl8RDEgkjOZNg3Ilw9MQRCkCkGA7r//Yuv27Xj+/Dm6dOmCRYsWwcrKCu7u7vAVExGJiIj8oohiQCRnYmSEqwMGQCkISHzdwtRzrkoVsFw5AICVlRUWLFgAf39/TJkyBUeOHIGjoyOaNm2KS5cuQY3RNxEREZFsgygGRHIkmzZtQpUJE7CgXDlIpNIUhwxSYo+5OWpfuoRevXoh5od1CXLlyoXRo0fj1atXWL9+PZ4/f45q1aqhUqVK2LNnD5TicsciIiK/AKIYEMlRkMQ///yDrl27olu3bhh65Qokx48DpqZQpnK6IWUyRAOYY2aGNp8+oWXLltiwYQNat26N8PDweGW1tbXRrVs33L9/H0eOHIGuri7atGkDe3t7LF++HN+/f9fgVYqIiIhoFlEMiOQYBEHAiBEjMGrUKIwfPx6rV6+GXC4H6tXDw337sImEIJGk7CWQx864lVSsiDvr12PUly+oXbs29u3bhwEDBuDUqVOoV68evn79muBUqVQKNzc3eHh44Pr16yhbtiwGDhwIS0tLTJo0CZ8+fcqISxcRERFJH1SD4OBgAmBwcLA6xUVEMp3IyEj+8ccflEgkXLx4cYLjDRs2pJ2dHaP8/MgpU/jV1pYRsWsbqrYYgOGFCpF9+pB37qjOHT9+PKVSKZs3b06ZTMZ58+YxV65cLFGiBN++fZuibS9evODAgQOpp6dHHR0d9u7dm0+ePNHk5YuIiIgkirr9tygGRH55vn37xvr161NLS4s7d+5McPzs2bMEwN27d6v2TZ8+nbpyOf+sXJm8c4eh165RH+CWLVsSnB8dHc3KlSvTysqKDRo0oJ6eHnft2sWCBQvSysqKvr6+atkZEBDA6dOn09zcnBKJhC1atKCnp2faL1xEREQkBdTtv8VhApFfmoCAANSuXRuenp44duwY2rVrF++4IAj466+/ULFiRbRq1Uq139vbGzIdHWgVKwaUKgX9ChVgUqBAotMD5XI5tm/fjq9fv8LAwAAlS5bEwIEDsX37dujr68PV1RXXr19P0VZTU1OMGzcOfn5+WLVqFR49egRXV1e4urpi//79YrChiIhIliGKAZFfFj8/P1SpUgUvX76Eh4cH6tSpk6DMrl27cOvWLcyZMweSHwII7969i5iYGFhbW6v22dvbJ5krwNraGqtXr8aePXvwxx9/wNjYGN27d8f+/fthb2+PmjVr4sSJE2rZraOjA3d3dzx69AgHDx6EVCpFy5Yt4ejoiFWrViUIThQRERHJcDTpZhARySzu37/P/Pnzs3DhwkmOv0dERLBw4cJs2rRpvP2hoaGUSCQEwM2bN6v29+vXj8WLF0+23e7du1NfX59nzpxh3rx5WaFCBX769Ilubm6Uy+XcunVrmq7nypUrbNWqFSUSCfPkycMpU6bw8+fPaapLREREJA4xZkAkx3Lp0iWamJjQ2dmZ7969S7LcwoULKZVK+fDhw3j7r1y5oso8fPHiRdX+xYsXU6FQMCYmJsk6Q0NDWbRoUZYuXZpXrlyhgYEB3dzc+P37d3bt2pUAOH/+/DRf29OnT9m3b1/q6OhQV1eX/fv357Nnz9Jcn4iIyO+NKAZEciQHDx6kjo4Oq1evzqCgoCTLBQUF0dTUlO7u7gmOrVy5klKplADo5+en2n/q1CkCSLHzvX37NhUKBYcNG8aTJ09SLpezZ8+eVCqVHDVqFAHwr7/+oiAIab7OT58+cfLkyTQzM6NUKmXr1q157dq1NNcnIiLyeyKKAZEcx9q1aymVStmyZUuGh4cnW3bMmDHU1dVNdOpfnz59aGFhQblczujoaNX+169fEwCPHDmSoi3z588nAB4/fpwbN24kAE6ePJkkuWDBAgJgly5dGBUVlcqrjE9YWBhXrFjBIkWKEACrVavGQ4cOUalUpqteERGR3wNRDIjkGARB4MyZMwmAvXv3TtaNT5L+/v7U0dHh+PHjEz1euXJlFitWjNbW1vH2K5VK6unpce7cuSnapFQq2bBhQ5qbm/PDhw+cMWMGAXDt2rUkyW3btlEul7NRo0YMDQ1V80qTJiYmhvv27WPlypUJgA4ODlyzZk2KokhEROT3RhQDIjkCpVLJQYMGEQAnTZqkluu9e/fuNDMzS/T7qlQqqa+vT2dnZ9aoUSPB8dKlS7Nnz55q2fbx40fmzZuX9evXZ0xMDPv27UuZTKbyLJw8eZL6+vqsVKkSAwIC1KpTHS5fvsxmzZpRIpEwb968nDFjBr98+aKx+kVERHIOohgQ+eWJjIxk+/btKZFIuHz5crXOuX//PqVSaaJZCMnYAL24J+suXbokON6hQwdWrVpVbRtPnjxJAJw7dy5jYmLYvHlz6unpqcb3r127RjMzMzo6OvL169dq16sOvr6+7NWrF7W1tamvr89Bgwbx5cuXGm1DRETk10YUAyK/NCEhIaxTpw4VCkW8zIEp4ebmRltbW0ZGRiZ6fPfu3QRAc3NzTpw4McHxKVOmME+ePKmydcSIEdTS0uLNmzf5/ft3uri40MzMjE+fPiUZ22lbWVmxYMGCCWY2aIKPHz9ywoQJzJ07N6VSKdu1a8ebN29qvB0REZFfDzEDocgvy6dPn1CrVi1cu3YNJ06cQOvWrdU6z8PDA0ePHsXMmTOhUCgSLePt7Y28efPi06dP8RIOxeHg4IDPnz/jy5cvats7Y8YMODk5oUOHDlAqlTh06BBMTU1Rv359fPz4Efb29vDy8kKuXLlQpUoVXLlyRe261cHc3BxTp07F69evsWjRIly/fh3lypVDrVq1cOzYMZDUaHsiIiI5D1EMiGQrXr58iSpVqsDf3x8XLlxAzZo11TpPEASMHDkS5cuXR5s2bZIs5+3tjaJFiwIArKysEhy3t7cHADx+/FhtmxUKBXbs2IF3795h4MCBMDU1xYkTJ/D9+3c0btwYoaGhyJ8/Py5evIgSJUqgdu3aOHLkiNr1q4u+vj4GDBiAp0+f4t9//0VoaCjc3NxQsmRJbNy4EVFRURpvU0REJGcgigGRbIO3tzdcXFwgCAI8PT1RunRptc/dvXs3bt68mSDtcGJtWFhYAECingE7OztIJJIk0xInhZ2dHZYvX46NGzdix44dsLa2xrFjx+Dr64u2bdsiOjoaJiYmOHnyJOrXr4/mzZtj48aNqWpDXWQyGdq0aYNr167hwoULKFy4MLp164bChQtj9uzZCAoKypB2RUREfmE0OeYgIpJWPDw8aGRkxNKlS/PDhw+pOjcyMpI2NjZs3LhxsuW+fPlCAOzZsyclEkmScQXW1tb866+/UmUDGTsFsmPHjjQyMuLz589JxiYyksvl7N69u2omRHR0NN3d3QmAs2bNSldyInV5+PAhe/ToQYVCQQMDAw4dOjRewiUREZGciRhAKPLLsG/fPmpra7NWrVpp+o4tXryYUqmUDx48SLbc+fPnCYC9evViwYIFkyzXoEGDBOsZqEtwcDALFy7MihUrqhIObd68mQDiBSwKgsAJEyYQAIcOHZppSYTevXvHMWPG0MTEhDKZjH/88Qfv3LmTKW2LiIhkPqIYEPklWLVqFaVSKdu0acOIiIhUnx8cHEwzMzP26NEjxbILFy6ktrY2O3bsSFdX1yTLDRkyhEWLFk21LXFcvXqVcrmcY8eOVe2bNWsWAXDVqlXxyi5dupQSiYQdO3ZM0lOREXz79o0LFy6klZUVAbBOnTo8efJkpngpREREMg9RDIhkawRB4NSpUwmA/fv3TzGrYFKMGzeOurq6fPPmTYplu3XrxrJly7Jq1ars2LFjkuVWrFhBmUyWrs555syZlEgkPHv2LMnY6x0wYAClUikPHToUr+y///5LhULBevXq8du3b2luMy1ER0dzx44dLFOmDAHQycmJmzdvTncaZRERkeyBKAZEsi0xMTHs378/AXDatGlpfhp98+YNdXV1OWbMGLXKly5dmt27d2ehQoXiPbX/TNxwwqNHj9JkFxl7jbVq1WL+/PlVSxHHxMSwRYsW1NXV5ZUrV+KVP3v2LA0NDVm+fHl++vQpze2mFUEQePbsWTZs2JAAWLBgQc6dO1f8zYuI/OKIYkAkWxIREcE2bdpQKpVy9erV6aqrZ8+eNDU1TXb1wjiioqKoUCg4f/58SqXSBO76H3n//j0BcP/+/emy7+3btzQ1NWWTJk1Uguf79+90dXWlmZkZHz9+HK/8rVu3aG5uzqJFi2ZpJsH79++zS5cu1NLSopGREUeOHKmW50VERCT7ISYdEsl2hISEoFGjRjh06BD27NkDd3f3NNf16NEjrF+/HhMmTICxsXGK5R8/foyoqChYWFhAEIREpxXGkTdvXhgbG6d6euHP5M+fHxs2bMDhw4exfPlyAICuri4OHToEMzMzNGjQAB8/flSVL1OmDDw9PRETEwMXFxfcu3cvXe2nlRIlSmDjxo14+fIl+vTpg1WrVsHa2hpdunTB/fv3s8QmERGRjEUUAyKZwsePH1GjRg3cunULp06dQosWLdJV3+jRo2FtbY2+ffuqVd7b2xsAYGBgACDxhENxSCQSODg4pFsMAECTJk0wYMAADB8+XNW5586dGydOnEBERAQaNWqEb9++qcoXKVIEnp6eyJs3L6pVq4ZLly6l24a0UqBAAcyePRv+/v6YPXs2zp07BycnJzRs2BBnz54VMxuKiOQgRDEgkuE8f/4crq6ueP/+PS5evIhq1aqlq76LFy/i8OHDmDFjRpJph3/m7t27sLKyQkBAAADA0tIy2fL29vYaEQMAMGfOHBQtWhQdOnTA9+/fAcSKkePHj+Pp06do06YNoqOjVeXz5cuHCxcuoGzZsqhbty4OHDigETvSipGREYYNG4YXL15gy5YteP/+PerUqYNy5cphx44diImJyVL7RERE0o8oBkQylDt37sDV1RVSqRReXl5wcnJKV30k8ddff6FcuXJo27at2ud5e3vD2dkZfn5+yJs3L3R1dZMtH+cZ0MTTr46ODnbu3ImXL19i2LBhqv3Ozs7Yv38/zp07B3d393htGRkZ4dixY2jSpAlatWqFNWvWpNuO9KKlpYVOnTrhzp07OHXqFExNTdGxY0fY2tpi4cKF8TwcIiIivxiaDEAQEfmRc+fO0dDQkOXKldNYhHzcqoPnzp1L1Xnm5uacMGECu3XrxooVK6ZYft++fQSQ6myIybFq1SoC4N69e+Pt37ZtGwFw3LhxCc6JiYlhv3790j3zIqO4e/cuO3XqRLlcThMTE44ePZrv3r3LarNERET+Q5xNIJKl7N69mwqFgnXr1mVISIhG6oyKimKRIkXYqFGjVJ0XNztg7969rFmzJtu2bZviOY8ePSIAenh4pNXcBAiCwJYtWzJXrlx8/fp1vGP//PMPAXDFihWJnqeJnAwZyevXrzl8+HAaGhpSoVCwe/fuGbJcs4iISOoQxYBIlrF8+XJKJBJ26NBBo1n14rL13bt3L1XnHT9+nAD47Nkz2tjYcOTIkSmeExkZSZlMxpUrV6bV3ET58uULCxUqxKpVq8br1AVB4KBBgyiVSnngwIFEz43L1ti2bds0ZWvMDL5+/crZs2czf/78BEA3Nzd6eHhkO4+GiMjvgigGRDIdQRA4ceJEAuCgQYM0mm8/ODiYefLkYdeuXVN97qxZs2hgYMCoqCjK5XIuW7ZMrfPs7Ow4ZMiQVLeXEhcvXqRUKuWUKVPi7Y+JiWHr1q2po6NDLy+vRM9N7zoOmUVkZCQ3btzIEiVKEADLly/PXbt2MTo6OqtNExH5rRDFgEimEhMTw969exMA//77b40/CU6YMIE6OjoJ3Ovq0KFDB7q4uNDf358AeOTIEbXOa9KkCRs0aJDq9tRh0qRJlEqlvHz5crz94eHhrFq1KnPnzk1fX99Ez71w4QKNjY3TtMJjZiMIAo8fP85atWoRAAsXLszFixczNDQ0q00TEfktEMWASKYRHh7Oli1bUiqVct26dRqv/927d9TT0+OoUaPSdH6xYsXYr18/Xrp0iQBSXN0wjpEjR7Jw4cJpajMloqOj6erqSktLSwYGBsY7FhgYyGLFitHa2jrJYDxvb2/my5ePtra2fPbsWYbYqGlu3rzJ9u3bUyaTMXfu3Bw/fny2FzMiIr86YgZCkUwhODgYDRs2xLFjx7B//350795d421MnjwZOjo6GD16dKrPDQ8Ph6+vr2paIZB8wqEfcXBwwKtXrxAeHp7qdlNCLpdj27ZtCAkJQe/eveNNK8yVKxeOHz+OqKgouLm5JTplz8nJCV5eXpBKpXB1dcWdO3c0bqOmKVu2LHbs2IFnz56hc+fOWLBgAaysrNCrVy88fvw4q80TEfmtEcWASJp5//49qlevjrt37+L06dNo2rSpxtvw8fHB2rVrMX78eJiYmKT6/IcPH0IQBDg7O+PVq1cwNTVVZSFMCQcHB5DE06dPU92uOlhZWWHNmjXYvXs31q9fH++YpaUljh8/jufPn6N169aIiopKcH7hwoXh6emJQoUKoXr16jh//nyG2KlprK2tsXDhQvj7+2PSpEk4fPgwHBwc0KxZM1y+fFnMbCgikhVo0s0g8vvw9OlTFi5cmPnz5+f9+/czrJ1mzZrR2to6zdHza9eupUQiYWhoKN3d3VmmTBm1zw0ICCAA7tq1K01tq4u7uzv19PTo4+OT4Ni5c+eopaXFzp07JxmH8e3bN9arV48KhYL//vtvhtqaEURERHDdunV0dHQkAFaqVIl79+7NllMoRUR+NcRhApEM49atW3BxcYFCoYCXlxdKlCiRIe1cvnwZBw8exIwZM6CtrZ2mOry9vVG0aFHo6+vDz89P7SECADA1NYWZmZnG0hInxYIFC2BpaYn27dsjIiIi3rGaNWti8+bN2LJlC8aNG5fo+QYGBjh8+DBatWqFdu3aqRZF+lXQ1tZG9+7d8eDBAxw+fBja2tpo1aoVHBwcsGLFClUKZxERkQxEk8pCJOdz+vRpGhgYsEKFCvz8+XOGtSMIAitVqsQyZcqka4pitWrVVEmGihYtyqFDh6bq/CpVqrBjx45pbl9d7t69S4VCwcGDByd6fN68eQTApUuXJlmHUqnk4MGDCYATJkz4pef2X7t2TbXUtZmZGSdNmqSxLJYiIr8T4mwCEY2za9cuamlpsUGDBhk+NWzv3r0EwDNnzqS5DkEQaGxszBkzZlAQBOro6HDhwoWpqqNnz56pGlpID4sWLUp26uOQIUMokUi4b9++JOsQBIF///03AbBXr16/vKv9+fPnHDBgAHV1damjo8O+ffvy6dOnWW2WiMgvgygGRDTKkiVLKJFI2KlTJ0ZFRWVoW1FRUbSzs2P9+vXTVc/Lly9VnWtcSuKksvslxdy5c6mnp6fRBEpJIQgC3dzcaGZmluiUQqVSybZt21JHRydBfoKfWb9+PWUyGVu0aMHw8PCMMjnTCAgI4NSpU5knTx5KJBK2bNmSV65cyWqzRESyPaIYENEIgiBw/PjxBMBhw4ZlSqcYl8747t276arnwIEDBMA3b97w6tWrBMA7d+6kqo7Dhw8TQJqSHaWFT58+0cLCgnXq1En0vQ4PD2f16tWZK1cuPnr0KNm6Dh8+TF1dXVarVo1fv37NIIszl+/fv3PVqlUsWrQoAdDV1ZUHDhzIlO+liMiviCgGRNJNdHQ0e/bsSQD8559/MqXNkJAQmpub888//0x3XVOmTKGpqSkFQeDOnTsJINWd4tOnTwmAp06dSrc96nLmzBlKJBLOnj070eNfv35l8eLFaWlpybdv3yZbl6enJ3PlysWSJUumWPZXQqlU8sCBA3R1dSUA2tvbc/Xq1TnCCyIioknE2QQi6SI8PBxt2rTBhg0bsHHjRowcOTJT2p03bx6Cg4Mxbdq0dNd19+5dODs7QyKRwM/PD0ZGRqnOVWBtbQ2FQpGpSXFq166Nv/76C+PGjcONGzcSHDcxMcGJEycgCAIaNWqEkJCQJOtycXHBpUuXEBgYCFdXVzx58iQjTc80pFKpKi+Bl5cXihcvjt69e8PKygrTp0/Hly9fstpEEZFfClEMiCQgKCgI9evXx8mTJ3Hw4EF06dIlU9r98OED5s6di0GDBsHS0jLd9Xl7e8PZ2RkAUj2tMA65XA47O7sMn174M9OmTUOZMmXQoUOHRDMQFixYEMePH8erV6/QsmXLRJMSxVG8eHF4eXlBR0cHrq6uiQqMX5nKlStj7969ePz4MVq2bIkZM2bA0tISAwcOxIsXL7LaPBGRXwJRDIjE4927d6hWrRoePHiAs2fPws3NLdPanjJlChQKBcaMGZPuukJCQvDixQuUKlUKAPDq1StYW1unqS4HB4dMFwNaWlrYvn07Pn36hP79+ydapkSJEjh48CAuXbqE7t27QxCEJOuztLTE5cuXUaRIEdSsWROnT5/OKNOzDDs7O6xYsQKvX7/GyJEjsWPHDtjZ2aFt27Y5TgCJiGgaUQyIqHjy5AlcXFzw9etXXL58GZUrV860th8/fow1a9Zg3LhxyJUrV7rru3//PgCk2zMAAPb29pkuBgDA1tYWK1aswJYtW7B169ZEy1SvXh1btmzBtm3bMHbs2GTrMzU1xZkzZ1C9enW4ublhx44dGWF2lpMnTx5MnjwZr1+/xtKlS3H79m1UqFABNWrUwJEjR5IVTSIivy2aDEAQ+XW5fv06zczM6OjomGmR8z/SokULWlpaaiwAbOnSpdTS0mJkZCQFQaC+vj7nzp2bpro2b95MAAwJCdGIbamlc+fONDAwSHZ1wgULFhAAFy9enGJ9UVFR/PPPPwkg1XkXfkViYmK4Z88eVqxYkQDo6OjIdevWpTnFtYjIr4Q4m0BEbU6ePEl9fX1WrlyZX758yfT2PT09CYBbtmzRWJ3u7u50cnIi+f81Bnbv3p2muq5fv04AvHnzpsbsSw0hISEsUqQIy5cvz8jIyCTLDR8+nBKJhHv27EmxTkEQOHLkSALg6NGjf+lsheoiCAIvXbrEpk2bEgDz5cvHmTNnJlhCWkQkJyGKARG12LZtG+VyOd3c3BgWFpbp7QuCQBcXF5YqVUqjc8UrVKigmp548+ZNAuCNGzfSVFfc93/r1q0asy+1XL9+nXK5nKNGjUqyjFKpZPv27amtrc2LFy+qVe/cuXMJgN26dWN0dLSmzM32+Pr60t3dndra2tTX1+eQIUP46tWrrDZLRETjiGJAJEUWLlxIAOzSpUuGZxVMiv3792t8Hn9MTAx1dXU5b948kv9PbZye3Pb58+fn+PHjNWVimvjnn38IgKdPn06yTEREBGvWrEkTExM+fPhQrXq3bNlCuVzOxo0bZ4kgzEo+fPjA8ePHM1euXJTJZOzQoQNv3bqV1WaJiGgMUQyIJIkgCBw9ejQB8K+//soyF3F0dDTt7e1Zt25djdbr4+MTb12DefPmUU9PL13XWbNmTbZu3VpTJqYJpVLJunXrMl++fMkKm6CgIJYsWZKFChXimzdv1Kr7+PHj1NPTo6ura5YMFWU1oaGhXLx4Ma2trQmAtWrV4vHjx3+L4RORnI2YdEgkUWJiYtCjRw/MmjUL8+bNw+zZsyGRSLLElnXr1uHJkyeYPXu2Ruv19vYGkHAmQXqu08HBIVMTDyWGVCrFpk2boFQq0a1bN5BMtJyxsTGOHz8OAGjUqBGCg4NTrLtBgwY4d+4cfH19UbVqVbx580ajtmd39PX1MXDgQDx9+hS7du1CSEgIGjZsCCcnJ2zatCnZPA4iIjkBUQz8Rnz//h0tWrTAli1bsGXLFgwbNizLbAkNDcWkSZPwxx9/oHTp0hqt29vbGwUKFICZmRmA9E0rjMPBwQFPnjyBUqnUhIlpxsLCAhs3bsTRo0exZMmSJMsVKFAAx48fx+vXr9GiRQtERkamWHfFihVx+fJlhIaGwsXFBT4+Ppo0/ZdALpejbdu2uH79Ojw8PGBlZYWuXbvCxsYGc+bMUUtYiYj8kmjSzSCSffny5QtdXV2pp6fH48ePZ7U5nDJlChUKRYYEbTVq1IiNGjVSvXZ2dmafPn3SVefJkycJgM+fP0+veRph8ODBVCgUKS68dPHiRWpra7NDhw5qB2i+efOGJUqUYO7cucWVAUk+ePCA3bt3p0KhoKGhIYcPH54l029FRNKCGDMgosLf35/Fixenqakpr169mtXm8MOHD9TX1+fw4cMzpP78+fNzzJgxqtcmJib8+++/01Wnn58fAfDo0aPpNU8jREREsFSpUnRwcGBoaGiyZXfv3k2JRMIRI0aoXX9gYCCrVKlCXV3dbHPNWc27d+84evRoGhsbUy6Xs1OnTuleWVNEJKMRxYAISfLRo0csVKgQLS0t6ePjk9XmkCT79etHExOTDAlU+/z5MwFw586dJGOD6QBwx44d6apXqVTGm6GQHfDx8aGenh579uyZYtnFixcTABcsWKB2/d+/f2fTpk0pk8m4adOmdFiaswgJCeGCBQtoaWlJAKxXrx5PnTolBhuKZEtEMSDCq1evMnfu3CxRooTaUeUZzePHjymXyzNsSeQzZ84QgEr4eHt7EwC9vLzSXXepUqXYq1evdNejSdauXUsA/Pfff1MsO3LkSEokErXKxhEdHc0ePXoQAOfMmZMeU3McUVFR3L59O0uXLk0ALFWqFLdu3Zpl03RFRBJDFAO/OceOHVNNFctOGdZatWrFQoUKZdi68/PmzaOuri5jYmJIkgcPHiQAvnv3Lt11t2/fntWqVUt3PZpEEAS2adOGxsbGKcZfKJVKduzYkQqFgh4eHqlqY9y4cQTA4cOHazQ5VE5AEASeOXOGDRo0IAAWKlSI8+bNy7L01SIiPyKKgd+YzZs3Uy6Xs2nTpvz+/XtWm6PiypUrBJChLufOnTuzQoUKqteLFy+mQqHQSAc2efJkmpubp7seTfP161daWVnR1dU1xSyCkZGRrF27No2NjXn//v1UtbN48WJKJBJ26tRJfPpNgnv37vHPP/+kXC6nsbEx//rrL759+zarzRL5jRHFwG9KXHrZ7t27Z6v0soIgsEqVKnRyclI9tWcETk5OdHd3V70ePnw4ixQpopG6d+7cSQDZMinP5cuXKZVKOXHixBTLBgcH09nZmQULFqS/v3+q2tm5cye1tLTYoEGDFAMXf2f8/f05cuRIGhkZUUtLi127dk21+BIR0QSiGPjNUCqVHDFiBAFw7Nix2S6YKc5df+LEiQxrIzIyklpaWly6dKlqX6tWrVinTh2N1H/nzh2NxR9kBFOnTqVUKuWFCxdSLPv27VtaWlqyRIkS/Pr1a6raOX36NA0MDFihQgV+/vw5jdb+HgQFBXHOnDksUKAAAbBhw4Y8d+5ctvt9iuRcRDHwG/HjkrSLFi3KanMSEB0dTQcHB9auXTtDb4J3794lAF6+fFm1r1y5cuzRo4dG6g8LCyMAbtiwQSP1aZqYmBhWq1aNBQsWVMt78ejRI+bKlYvVq1dP9XK+N2/eZJ48eWhvby8u8KMGkZGR3Lx5M52cnAiAZcuW5Y4dO7KV904kZyKmI/5NCAsLQ/PmzbFjxw7s2LEDgwYNymqTErBhwwb4+vrin3/+ydDUx3fv3gUAODk5qfa9evUK1tbWGqlfT08PVlZW8PX11Uh9mkYmk2Hr1q0ICwuDu7t7kumK43B0dMThw4dx9epV/PnnnxAEQe22ypYtC09PT0RFRcHFxQUPHjxIr/k5GoVCgc6dO+Pu3bs4efIkcuXKhQ4dOqBIkSJYtGgRQkNDs9pEkd8dTSoLkcwlICCAlSpVor6+vkZX/dMkoaGhzJcvHzt27JjhbQ0dOpQ2Njbx2gbAzZs3a6yN+vXrs1mzZhqrLyPYt28fAXDlypVqld+7dy8lEgmHDRuW6rbevXtHZ2dnmpiY8NKlS6k+/3fmzp07/OOPPyiTyZgrVy6OHTuW79+/z2qzRHIY4jBBDsfPz48ODg40MzPjjRs3stqcJJk2bRoVCgVfvHiR4W3VqlWLLVq0UL1++PAhAfDixYsaa2Pw4MG0t7fXWH0ZRZ8+faijo8MHDx6oVX7JkiUEkKakSkFBQaxRowZ1dHR48ODBVJ//u+Pn58dhw4bRwMCACoWCPXr04KNHj7LaLJEcgigGcjAPHjxgwYIFaW1tzcePH2e1OUny8eNHGhoacujQoRneliAINDU15ZQpU1T7jh07RgD08/PTWDvLly+nXC7P9lPrwsLCWKxYMZYsWVLtnA5xy1qnJVtjeHg4W7VqRalUyrVr16b6fJHYKaKzZs2ihYUFAbBJkya8cOGCGGwoki5EMZBD8fT0ZK5cuejk5JTt5y8PGDCAxsbGDAgIyPC2/P39CYAHDhxQ7VuxYgXlcrlGg7TOnTtHAPT19dVYnRnFvXv3qK2tzQEDBqhVXhAEdu7cmQqFgufOnUt1ezExMezTpw8BcMaMGWInlkYiIyO5YcMGFi9enABYoUIF7t69O0On5IrkXEQxkAM5fPgwdXV1Wa1atVRPB8tsnj59SrlczlmzZmVKe0eOHCEAvnz5UrVv1KhRtLa21mg77969SyA6sjNLly4lAB46dCjR41+iong+MJAHP3/mkYAAXg8MZO369WlkZMR79+6luj1BEDh58mQC4MCBA8VshelAEAQePXqUNWvWJADa2Nhw6dKlDAsLy2rTRH4hRDGQw9iwYQNlMhlbtGiRYal8NUmbNm1YsGDBTMuAOGPGDBobG8d7Gm3fvj2rV6+u0XYEQaCRkVGmiZz0IggCmzZtSlNTU9X6FM++f+eIZ89Y0MuLOH8+wabl4UG99etp0r49n6Rx2uCKFSsokUjYrl27VE9bFEnIjRs32L59e0qlUpqamnLChAn8+PFjVpsl8gsgTi3MIZDE7Nmz0a1bN/To0QO7d++Gjo5OVpuVLNeuXcPu3bsxbdo06OrqZkqb3t7ecHZ2jjd1UZPTCuOQSCRwcHDIttMLf0YikWDdunXQ1tZGe3d3dHr4EEWuXcMCf3+8iYxM9JxoEhGFCyOod284PHyI5c+fpzhN8Wf69OmD3bt3Y//+/WjcuDG+ffumicv5bSlXrhx27NiB58+f448//sD8+fNhZWWFPn364MmTJ1ltnkgOQBQD2RhBEDB8+HCMHj0aEyZMwMqVKyGTybLarGQhib/++gslS5ZE586dM63du3fvwtnZOd4+Pz8/WFlZabwte3v7X0YMAICZmRmGbd2Ky717Y/unTwAAZQrnxGUcEHR00N/fHw29vREcE5Oqdlu1aoWTJ0/i+vXrqFmzJj7917ZI2rG2tsaiRYvw+vVrTJgwAQcOHICDgwNatGgBLy+vrDZP5BdGFAPZlKioKHTu3BkLFy7E0qVLMXXq1AxN2KMpjh49iosXL2L27NmZJlzCwsLw9OnTeGIgIiIC79+/17hnAAAcHBzw+PHjVD8tZxWHAwIwWiqFxMgITO13SBp7izgVGIhqd+4gKDo6VafXqFEDFy9exNu3b+Hq6ooXL16krn2RRMmdOzfGjh2LV69eYfXq1fD19YWrqytcXFywf/9+KJUpyT0RkfiIYiAbEhoaiqZNm2LPnj3YtWsX+vfvn9UmqUVMTAxGjRqFmjVrokGDBpnW7oMHD0Aynhjw9/cHgAzxDDg4OODr16/4/PmzxuvWNLe/fUOrhw+hJFMvBH6AUinuf/uGpg8eQEilCHJ2doanpycAwNXVVZUpUiT96OjooGfPnnj48CEOHToELS0ttGzZEo6Ojli5ciXCw8Oz2kSRXwRRDGQzPn/+jFq1asHLywvHjx9HmzZtstoktdm0aRMePXqU4WmHf8bb2xsymQzFixdX7Xv16hUAZJhnAEC2HyqIEgT84eMDgUSi3fesWUDNmklvP4kdSqW4FByMJW/fptoWGxsbeHp6okCBAqhevTo8PDzSdE0iiSOVStGkSRNcuHABV69ehbOzM/r37w8rKytMnToVAQEBWW2iSDZHFAPZCD8/P1SpUgV+fn7w8PBArVq1stoktfn+/TsmTpyI9u3bo1y5cpnatre3N+zt7eMFK/r5+UEikaBgwYIab8/W1hYymSzbi4EFb97g8ffvSccHNGkCjB0bfxszBtDRAaysgDx5Ej1txNOneJ9E8GFymJub4/z586hQoQLq16+PvXv3proOkZSpWLEidu/ejSdPnqBt27aYNWsWLC0t0b9/fzx//jyrzRPJpohiIJtw//59uLi4ICYmBp6enihTpkxWm5QqFi5ciM+fP2PGjBmZ3nZSwYP58+eHQqHQeHva2tooXLhwthYDMYKAhW/eJO4RiKN4caBu3fibhQUQEQHUqZNs3WP+c/unFkNDQxw9ehQtW7ZEmzZtsHLlyjTVI5Iytra2WLp0KV6/fo3Ro0dj9+7dsLOzQ+vWrXHt2rWsNk8kmyGKgWzApUuXULVqVZibm8PT0xNFihTJapNSxefPnzFr1iz069cPNjY2mdq2IAi4d+9eAjGQEdMKfyQuiDC7ciwwEB+iolJ/4pkzgESSrBiATIbNwcG4k8axf4VCgW3btmHAgAHo27cvpkyZ8ssEY/6KmJmZYeLEifDz88OKFStw7949VKpUCdWqVcPhw4dTtVqlSM5FFANZzMGDB1GvXj2UKVMGFy5cQL58+bLapFQzffp0SCQSjB8/PtPbfvnyJUJDQ1GqVKl4+zNqWmEc2T3XwPmgIGilNm4jJgbw8Ij1GKTwPWSuXKjfvTv8/PzSZJ9UKsWiRYswc+ZMTJ48Gf369RMj4DMYXV1d9O7dG76+vqoZB02bNkXx4sWxdu1aREREZLWJIlmIKAaykLVr16Jly5Zo3Lgxjh07BiMjo6w2KdU8f/4cK1aswOjRo2FmZpbp7Xt7ewNAlngGXr58mW1voNdCQhCd2qftGzeAkJDkvQI/Ym+Phg0bIjAwMPUGIjYh0pgxY7B27VqsXr0abdu2zbbvZ05CKpWiefPm8PT0hKenJxwdHdGrVy9YW1tjxowZaf48RX5tRDGQBZDEzJkz4e7ujt69e2Pnzp3ZPqtgUowbNw7m5uYYPHhwlrR/9+5dmJubx/OoREdH4+3btxnuGSCJp0+fZlgb6eFpWqaUnTkDyOVAjRopFpVLJOgwYgQ+ffqEpk2bpmsKW48ePbB//34cO3YMDRs2RHBwcJrrEkkdLi4u2LdvH3x9fdGiRQtMnz4dhQoVwqBBg/Dy5cusNk8kExHFQCYjCAIGDx6McePGYcqUKVi2bFm2zyqYFDdu3MCuXbswdepU6OnpZYkNcWmIf+TNmzcQBCFDPQP29vYAsu/0wujUjgOHhwNeXkD58oCxcYrFJQCMcufGkSNHcPv2bXTq1Cldbv6mTZvi9OnTuHv3LqpXr47379+nuS6R1FO0aFGsWLECfn5+GDFiBLZv344iRYqgffv2uHXrVlabJ5IJiGIgE4mMjETHjh2xbNkyrFy5EhMnTvwlsgomRlza4eLFi6NLly5ZZoe3t3ei8QJAxiQcisPMzAympqbZNohQO7Xfq8uXU5xF8CNKQcC7ly9hZWWFHTt24MCBAxgyZEi6AgGrVKmCS5cu4fPnz3B1dc22XpecjLm5OaZMmYLXr19jyZIluHHjBsqVK4eaNWvi2LFjYrBhDkYUA5nEt2/f0LhxY+zfvx+7d+9G7969s9qkdHH8+HF4eHhg1qxZWebZCAoKgp+fX6LTCgHA0tIyQ9vPDkGEJPHixQvs378fkydPRsuWLWFra4tP164BqblxnzkD6OoCLi5qFRckEqyfOBH58+dH165dYW1tjaVLl6Jx48Y4evQoXrx4kaaOo0SJEvDy8oJCoYCrq6v4VJpF6OnpoV+/fnjy5Al2796N79+/w83NDSVLlsSGDRsQmYY8EyLZG3lWG/A78OnTJzRq1AhPnz7FyZMnUUONMdnsjFKpxKhRo1C9enW4ubllmR3JBQ/mzZs3w1dMdHBwyNTUumFhYXjw4AG8vb1V271791QrApqZmcHZ2RnNmzfHkyJFcFwqTXFBIgBAUBBw6xZQq1ZswiE1ObdqFYKePIGPjw8ePXqE79+/49ixYzh27BiA2FS5Dg4OcHR0jLfZ2dklm//BysoKly9fhpubG2rUqIH9+/ejjrpBjSIaRSaToXXr1mjVqhUuX76MuXPnonv37hg3bhwGDx6M3r17w8TEJKvNFNEAohjIYF6+fIl69eohNDQUFy9eTNBx/Yps3rwZDx48wLVr17J0mMPb2xsKhUI1fh9HRk8rjMPBwQE7d+4ESY2+DyTh7+8fr9P39vbGs2fPQBJSqRT29vZwdnZG48aN4ezsDGdnZ1hYWKjsuBQUhCPqCpXz5wGlUu0hAgmAorq6qFGsGCTFi6NFixYqu7t3746tW7diypQp0NXVVQmFkydPqqLUZTIZbG1tUaxYsXgiwcHBAQYGBgBihc25c+fQunVrNGrUCFu2bEG7du1S9T6KaA6JRIKqVauiatWq8PX1xbx58zBx4kRMnz4d7u7uGDJkSIZ74kQyFgnVGOQLCQmBsbExgoODf8npb1mFt7c3GjRoAAMDA5w8eTLTE/JkBOHh4bCzs4Orqyt27dqVpbb06NEDd+/eTeBKrlWrFvLkyZPh9h0+fBhNmzaFv79/mtMeh4eH49GjRwme9r9+/QoAMDExUXX2cVuxYsVS9HqQRFEvLzyLiopNIpQc/fsD798Du3cDagz5SAAstbNDvwIFEhyLjo5G06ZN4enpiYsXL6riOUji8+fP8PHxSbC9efNGdX6hQoXg6OioEgp2dnZYsWIF9uzZg0WLFmHgwIEp2ieSOXz48AFLly7F8uXLERISgnbt2mHkyJEJYnhEshZ1+29RDGQQFy5cQNOmTWFnZ4djx47B3Nw8q03SCLNmzcKECRPg4+OT5ZkSy5UrBycnJ6xfvz7efltbW7Rq1Qr//PNPhrb/9OlTFC1aFGfOnEHt2rWTLUsS79+/T/C0/+TJEyiVSkgkEtjZ2cHJySlex1+oUKFUex1CQ0MxadIkLHj0CBw1Kj2XmBBBgIlMBj9XVxjJE3cshoaGokaNGnj79i2uXLmS4qyOkJAQ+Pr6JhAJz58/V8Ud6OrqIjw8HKVLl8aff/6pEgsFCxb8ZYNwcwqhoaFYv349FixYgFevXqFOnToYOXIk6tatK3422QBRDGQh+/btQ8eOHVGlShXs378fhoaGWW2SRggICICtrS26dOmCxYsXZ6ktMTExMDAwwOzZs+PlOFAqldDR0cGiRYvQr1+/DLdBT08PCxYsiLfMdFRUFB49eoR79+7F6/jjVo4zNDRM0OmXKFEC+vr66bJHqVRi/fr1GDFiBEJCQqCtowOrf//FC0NDxKSr5vgopk/H/BYt0LdvX0iliccgf/z4ES4uLtDS0oKnpydMTU1T3U5ERASePn2qEgf79++Ht7c3pFKpSiQYGBio4hJ+HHawsbGBPAmxIpIxxMTEYO/evZgzZw5u3boFJycnjBgxAu3atcuQNUJE1EMUA1nEqlWr0K9fP7Rp0wabNm2CtrZ2VpukMYYOHYp169bh+fPnyJPEinaZxcOHD1GiRAmcP38+XkDmmzdvUKhQIRw5ciRTghsdHBzg4OCAKlWqqDp9Hx8fxMTEdr82NjaqDj9OAFhbWyfZiaaVs2fPok+fPnj27BkAoGPHjliyZAnC9PRQ+uZNBMXEqBdMmAwSEpLTp2G6di0+f/6MOnXqYP369ShUqFCi5Z8+fQoXFxeV90QTAZ2bN29G9+7dUaNGDfTp0wcvXryI500ICQkBELv+gZ2dXbyYhGLFiqFo0aIZHlj6u0MSFy5cwJw5c3Ds2DEUKFAAQ4YMQa9evcT+IwsQxUAmQxLTpk3DpEmTMHDgQCxcuFDjN/ys5OXLl7C3t8fEiROzZA2Cn9m+fTv++OMPBAYGIleuXKr9ly9fRtWqVfHgwQMUL15cY+1FR0fj8ePHqjH9uI7/w4cPAGKnYpUsWTLe037JkiUz/Pfi6+uLgQMH4syZMwCAYsWKYfPmzShbtqyqzL3QUFS7fRvB0dFqxQQkhgRACzMzjIqKQpsWLRAcHAwtLS1ER0djyZIl6NSpU6Iu4evXr6NmzZqoV68e9uzZo5FpqMeOHUObNm1QpkwZHDp0SPX5xw3FxAUt/igSPn78GHsdEgkKFy6cYIaDo6OjGBWfATx8+BDz5s3D1q1bVWsjDBo0KEOWFhdJHFEMZCJKpRKDBg3C8uXLMWPGDIwZMybHjZV17NgRHh4eePr0abrd2Zpg1KhR2LlzZ4KFcrZt24ZOnTrh27dvqsj01BIYGJhgbP/hw4eI+m8VQEtLS1WH//DhQ1y5cgVv3rzJ1HwLnz9/xsSJE7F69WqQhIGBAebPn4/u3bsnEKGRkZGo0KIFfNu0QVThwqlrSKmEVCbDaEtLTLG2hlwqxadPn9CmTRt4eXmhTJkyuH79Olq2bImVK1cm6jE6evQomjVrht69e2Pp0qUa+W1cvXoVbm5uyJ8/P06cOIECiQQz/sjXr19VwuBHofDq1StVGQsLi0RFQr58+XLc7zmzeffuHRYvXoyVK1ciLCwMHTt2xPDhw+Hk5JTVpuV41O6/qQbBwcEEwODgYHWK/1ZERESwdevWlEqlXLNmTVabkyHcvHmTALh69eqsNkVFvXr12KRJkwT7Z8yYwdy5c6tVR0xMDH18fLhz506OGTOGjRo1YsGCBQmAAKitrc2yZcuye/fuXLRoET08PBgYGBivjk2bNhEAv337ppHrSonw8HDOnj2b+vr6lEqlBMBevXrxy5cvSZ4zYMAAKhQKXr1+nXP8/Ghy8SJx/jwl584R588nvp0+HVtmxQq6z52boM6oqCj279+fAFi3bl2amprS3NycBw4cSNSGNWvWEABnzpypsffi0aNHLFSoEC0tLenj45OmOsLCwnj79m1u27aN48ePZ8uWLeno6Ei5XK76HpiYmLBy5crs3r0758yZwyNHjvD58+dUKpUau5bfhZCQEM6fP5+FChUiANavX59nzpyhIAhZbVqORd3+WxQD6SA4OJg1a9akjo5OkjfBXx1BEFirVi06OjoyOjo6q81RkTdvXo4fPz7Bfnd3d5YpUybB/qCgIF68eJFLlixhz549Wb58eerq6qpu+Pnz52fDhg05evRo7tixg48ePVLreq9du0YAvHXrlkauKykEQeDOnTtZqFAhSiQSAmCZMmV48+bNZM/bsWMHAXD58uWqfWs3bybq1GGdq1eZ9/LleCJA7uHBYleuUDp0KIevXMlhw4bRwMCAnz59SrT+NWvWUEtLixUqVGC9evUIgF26dGFQUFCCspMmTSIAbtq0KX1vxg/4+/uzWLFiNDU15dWrVzVWb1RUFH18fLhv3z7OmDGDnTp1YpkyZainp6f6zujo6LBUqVLs0KEDp06dyt27d/PBgweMjIzUmB05laioKG7bto2lSpUiAJYuXZrbtm1jVFRUVpuW4xDFQAbz/v17lipVisbGxrx48WJWm5NhHD9+nAB48ODBrDZFxYcPHwiAu3fvTnCsbt26rFu3Lvfs2cMJEyawadOmtLKyUt3AtbS0WKpUKf7555+cN28ez5w5w8+fP6fZlqCgIALgtm3b0nNJyeLl5cWKFSsSAOVyOU1MTLhu3boUn0wfPXpEfX19duzYMd6TV926dVmtWjXV6y9RUXz5/Tv9w8MZ8V+dbm5urFq1KgMCAmhkZMTBgwcna1++fPlYoEABTpgwgYaGhixUqBDPnj0br5wgCOzRowflcjlPnjyZhncicb58+UIXFxfq6enx+PHjGqs3MZRKJV+9esXjx49z/vz5dHd3Z5UqVZg7d27Vd0wmk7Fo0aJs3rw5x4wZw82bN/PGjRuZ5j36lRAEgadPn2b9+vUJgJaWllywYAFDQkKy2rQcgygGMpBnz57RxsaGFhYWvHfvXlabk2HExMTQycmJVatWzVZuvJMnTxIA79y5Q09PT65YsYJ9+vRh5cqVVU/NAGhubs66detyxIgR3LJlC+/du5chTx4WFhacMGGCxut98eIF27Ztq3oKlUgk7N+/f4KhisQIDQ1lsWLF6OjoGK8TevPmDSUSCdeuXZvs+evXr6dEIuH79+85bdo0KhQKvnz5Msnyb968YYUKFaijo8P58+ezRo0aBMBBgwYxLCxMVS46OpqNGjWigYGBRr0pYWFhbNy4MeVyObds2aKxetVFEAR+/PiRHh4eXLFiBQcNGsS6devGG3YCwEKFCrF+/focMmQIV61axYsXL6ZLjOYkvL292blzZ5XgHT16NN++fZvVZv3yiGIgg7h9+zbNzc1ZtGjRZG+OOYGNGzcSAK9cuZKldgiCwJcvX/LAgQOcMmUKS5QoEa/Tl8lkLFGiBDt27Ei5XM4+ffrw/fv3mWZfjRo12KZNG43V9/XrV44cOZIKhUI1lFGpUiXevn1brfMFQeAff/xBfX19Pnr0KN6xf/75hzo6Oom68X8kICCAMpmMK1as4Ldv35g3b1526dIl2XPCw8PZtWtXAuDQoUM5b9486ujosGjRovFc+KGhoSxfvjzz5s3LFy9eqHVN6hAdHc3u3bsTAOfNm6exetNLcHAwr127xo0bN3LUqFFs2rQp7ezsVDEfAGhmZsaqVauyd+/eXLhwIU+ePMnXr19nKxGeWbx+/ZojRoygoaEhtbS02K1bNz58+DCrzfplEcVABnD27FkaGhqyfPnySY6h5hS+f//OQoUKsXXr1pnablhYGK9du8bVq1dzwIABrFq1Ko2NjVU3zdy5czNv3ry0sLDghg0bePv2bUZERJCMHboBkOnxG3369KGTk1O664mKiuLSpUtpampKhUJBhUJBMzMzrl+/PlXBaitXriQAbt++Pd5+QRBYokQJtmvXTq16ateuzTp16pAkly5dSolEwvv37yd7jiAIXLRoEWUyGevWrcsrV66wfPnylEqlHDdunGo8/ePHjyxSpAiLFi2q0SdjQRA4ZswYAuDIkSOzdWcaERHB+/fvc9euXZw8eTLbtWtHJycnamtrq77vBgYGLFeuHDt37sy///6bBw4c4OPHj7NV/E5GERQUxDlz5rBAgQIEQDc3N54/fz5bf6bZEVEMaJh///2XCoWC9erV+y3G/mbPnk25XM4nT55kSP2CINDf359HjhzhjBkz2LZtW9rb26uelqRSKR0cHNiuXTvOnDmTR48epb+/PwVBYPHixdmnT58EdV69elU1fJCZLFy4kDo6OoyJiUnT+YIg8PDhw7S3t6dEIqGJiUmqhgR+5ObNm1QoFOzfv3+CY3fu3CEAHjlyRK26li9fTplMxi9fvjAyMpI2NjZs2rSpWueePXuWpqamtLGx4Z07dzh16lTK5XKWKlVKJSiePXvGPHnysFKlSvGGEjTBwoULCYB//vnnLxeUFhMTw2fPnvHw4cOcPXs2u3btyooVK9LIyEglEhQKBYsXL87WrVtzwoQJ3L59O+/evcvv379ntfkaJzIykps2bWLJkiUJgOXKleOuXbt+C0GkCUQxoEGWLVtGiUTCjh07/haRwgEBATQ2Nma/fv00Ul94eDhv3brF9evXc/DgwaxZs2a8gCtjY2NWrVqVAwYM4Jo1a3j9+vUkO4fw8HDKZDKuXLkywbFdu3YRQKo70PRy4sQJAkiTy/vOnTusVasWATBv3rwEwMqVK6s9JPAjgYGBtLa2Zvny5VXekh8ZOnQozc3N1e4c379/T4lEwg0bNpAkt23bRgC8fPmyWue/ePGCTk5O1NfX5969e3nr1i0WK1aMCoWC//zzD2NiYnj9+nXq6emxadOmGr+5b9++nVpaWmzUqBFDQ0M1WndWIAgC3759yzNnznDJkiXs27cva9SoofreAKBEIqGNjQ3d3Nw4YsQIrlu3jl5eXvz69WtWm59uBEHgiRMnWLt2bQJg4cKFuXjx4hzx2WYkohjQAIIgcMKECQTAIUOG/DbziuOmk3348CHV575//54nTpzg7Nmz2bFjRxYvXpwymUx1oypSpAhbtWrFqVOn8uDBg3z16lWq3H5xOQ8Si2OYPXs2jYyMMt2N+OrVKwLgsWPH1D7n7du37NatGyUSCc3Nzamjo0MzMzNu2LAhTd8zpVLJxo0bM1euXHz16lWC49HR0cybN2+yswISo0qVKmzcuLGqDWdnZ1apUkXt9zg0NJRt2rQhAE6cOJFhYWEcPnw4JRIJq1SpwmfPnvHo0aOUyWTs3bu3xj+7kydPUl9fn5UqVWJAQIBG685OBAYG0tPTk2vXruXw4cPZsGFDWltbx4utsbCwYK1atdi/f38uXbqUZ8+e5bt3735Jt/utW7fYsWNHymQy5sqVi+PGjUvT/ep3QBQD6SQmJoa9evUiAM6aNeuX/MGkhZcvX1KhUHDKlCnJlouMjKS3tzc3b97M4cOHs06dOjQ3N4831uni4sI+ffpwxYoV9PLy0sjwyrp16yiRSBJ9GujXrx9LliyZ7jZSi1KppK6uLufPn59i2dDQUE6ePJl6eno0NjZmvnz5KJFIOGDAgHQ9vc2aNYsAePTo0USPHzt2LE35EObPn0+FQqH67cfVo+5QAxkrqmfOnEmJRMKmTZsyODiYFy5cYOHChamvr88VK1Zw7dq1BMDp06enyj51uHHjBs3MzOjg4EA/Pz+N15+d+TmpUqtWrXJUUqVXr15x6NChNDAwoLa2Nt3d3dOcgColwmJi6BkUxKVv3nDqy5ec9vIlV759y+vBwQxP4xBhZiCKgXQQHh7OFi1aUCaTcf369VltTqbyxx9/MF++fPE67k+fPvHMmTOcN28e//zzTzo7O1NLS0t1M7G2tmazZs04ceJE7t27l8+ePcuwG8mgQYNoZ2eX6LFGjRolmpUwM3B2dmbv3r2TPB4TE8P169czf/78VCgUdHBwIAC6uLikO8bh/PnzqgC9pGjfvj2LFSuWalEb5/WIC0YUBIHVqlVjyZIlU/0ZHzlyhEZGRnR0dOSTJ08YEhKiEtwNGjTgiBEjCEA1LKFJHj9+TGtraxYsWJAPHjzQeP2/GoklVSpbtiz19fV/yaRKgYGB/Pvvv5kvXz4CYNOmTXnp0qV0P8QJgsDzgYFsff8+Zf8l5pKcP08tDw/KPTwo+W+flocHOz96xKvZsI8UxUAa+fr1K6tVq0ZdXV0ePnw4q83JVK5fv04A7NGjB0eNGsUGDRrQwsJCdXPQ1dVlhQoV6O7uziVLlvDixYspTlHTNNWrV09yGl/x4sU5YMCATLUnjnbt2rF69eqJHjt79qwq05qzszP19PSYJ08ebty4Md2i6d27d8ybNy9r1aqVZABjcHAwdXR0OGvWrDS1Ua5cuXizSry8vAggTfP5fX19aW9vT2NjY1WCoKNHj9LCwoLGxsasVasWZTJZqoZc1OXt27d0cnJirly56OnpqfH6cwJKpZJ+fn4JkiqZmprGm8prb2+fLZMqRUREcP369SxWrJhqSu6ePXvSFNz7Ojycde7ejc3MmVTa7p+yd+L8eba+f5+fspFgEsVAGnj37t1vc7MIDAzk+fPnuXDhQnbv3p1ly5aNN++5YMGCdHNz49ixY7lr1y76+vqmOVpeUwiCQGNj40RdyYIgUF9fn3MTyaOfGUyaNIl58+aNt8/Hx4dNmjQhABYrVozW1taUSqUcOHCgRgK6oqOjWb16dVpYWCQ7Xho3tOLv75+mdv7++2/q6enFC+ps1qwZra2t0/SUGBQURDc3N0okEs6ePZuCIDAgIIDt2rVTjW3r6enxxo0babI3OeLEvo6ODg8dOqTx+nMynz594oULF36JpEpKpZJHjhxRJb+ytbXlsmXL1J61cvjzZ+pfuKCWCPh5k50/z1yXLvFiNgnaFMVAKnny5Amtra1ZoECBHOVGjImJ4ePHj/nvv/9y3LhxbNy4sWqRECB2MZ4yZcqo8spPmzYt2UVvspI4l3ViHpuAgIAkUxRnBnFrAHz9+pWfP39m//79KZPJWKhQIVauXJkA6OrqqtFpj6NHj6ZMJksxHXaNGjVYu3btNLfz+PFjAuC+fftU+x48eECpVMolS5akqc6YmBiOHTuWANihQwfVTXrnzp3MlSsXtbS0aGJiwufPn6fZ7qT4nYcBM4KQkBBev36dmzZtypZJlW7cuMG2bdtSKpXSzMyMkyZNSjZPzP5Pnyj9bzggtUIgbpOeP0+FhwfPZ/LMpsRQt//OGUsYv34NXL8O3L4NfP4MkEDu3EDp0kCFCoCtbbKn37x5E40aNYKpqSlOnjwJS0vLTDJcs4SEhODevXvxlt598OABvn//DgDIly+faunduM3e3h5SqRRlypSBgYEBLl26lG2Xaz106BCaNWuG169fo1ChQvGO3bp1C+XKlcONGzdQrly5TLftzp07KFOmDAYMGIAtW7aAJKpUqQIPDw8YGBhgzpw56Ny5s8be27j3Ys6cORgxYkSS5fz8/GBtbY1Nmzbhzz//THN7JUuWhLOzM7Zu3ara161bNxw7dgzPnz9P83LRu3fvRteuXWFvb4/9+/fDysoK79+/R+fOnXH27FkYGRnhzp07sLGxSbPtiaFUKtGvXz+sXr0af//9N0aNGpVtv/e/KpGRkXj69GmCpaMfP36MyMhIAICBgQEcHBzg6OiIYsWKqZaNtrGxgVwu16g9L1++xIIFC7Bu3ToIgoCuXbti2LBhsLOzU5V5GBaG0jdvIoZEih1jCkgB6Eql8KlQAYV0dNJZW9rJ+UsYx8SQu3aRVaqQsd0/qaVFyuWxm5bW//eXKUNu3Egm4tI8deoUDQwMWLFixV9m6pFSqeTz58+5b98+Tpo0ic2bN2fhwoVVKlxLS4tOTk7s3Lkz586dy9OnT/Pjx49J1rd582YCyPZDI1OnTmXu3LkTfZrYu3cvAWRJZkhBEFRLGUskEjZr1oxFihShVCrloEGDND7H+/nz5zQxMWHz5s1TfLKaMWMG9fT00j2eO2nSJBoZGcXLX/Dq1SsqFApOnTo1XXXfvXuX1tbWNDMzo4eHB8nY93TGjBmUSCRUKBQZsgCRIAicOHHibzd1OKv5ManSP//8w27dumVqUqWAgABOnz6d5ubmlEgkbNmyJb28vBitVLL0jRuxgYLHjhF//kmUL08YGsbaNWpU4p6AjRtjy+noxJatW5fYv18Va1Dn7t0snY2Ws4cJfHzI8uVjO3qZ7P+dflKbVBr7t1gx8odkLjt27KCWlhYbNmyYbRNXhIaG8sqVK1y5ciX79u1LFxcXGsZ9Of9zv9WuXZvDhg3jpk2bePfu3VSN44aHh9PS0pItWrTIwKvQDK1atWLNmjUTPTZ//nzq6upm+o/uypUrqmEAHR0dlSirUqUK7969q/H2wsPDWaZMGdrY2KQoMgRBoL29PTt16pTudu/du5doLoWhQ4fS0NAw3SLs8+fPrFWrFuVyOZcuXar6HA8ePKhyNw8ePDhDMuzFJRXr0KFDtoyU/134OalSv379WLNmzQxLqhQeHs41a9bQ3t4+Nq5g8GDi3LnYDv6/YT/kzUv8F/ybqBj491/C2JjIn58YMIDo0SNWENjaEqdOqcrtz8L09TlXDOzaRSoUsU//KYmAnzeZLHZbuZKLFi0iAHbu3DlbpCsVBIGvXr3ioUOHOG3aNLZu3Zp2dnaqpCEymYzFihVjhw4dOGvWLB4/flwjCUPmzJlDmUxGX19fDV1JxmFra8shQ4YkemzQoEF0dHTMNFtevnypCnhzdnamu7s7ZTIZtbW1uXnz5gwTJb1796a2trZaGQrjZodoYrlgQRBoZ2fHHj16xNv/+fNnGhoacujQoeluIzo6moMHD1bNaInzQhw5coRSqVSVojojAgt3795NhULBunXrisvnZkN+TqrUqFEjFi5cOMWkSu/fv0/xt6hUKnng4EHq7tpFnD0b24GfPEns3Rv7/39rfSQqBpo2JbS1iZ07/79v7tzY8sOGqQIKa2ZyivQfyZliYOdOUiKJ3VIrBH7a+iB2IZOscA1+//6dN27c4Nq1azlw4EBWq1aNJiYmqi91rly5WKNGDQ4aNIjr1q3jzZs3GR4ernE7vnz5QhMTk0Tz/Gc3QkJCkp2D3qxZMzZo0CDD7QgKCuJff/1FbW1tWlhYcMSIEbS3t6dMJmOpUqVYtGjRDGs7bjhnzZo1apUfMGAALSwsNDYLZNSoUTQ1NU2QNnjq1KlUKBSJZj5MCxs3bqS2tjYrV67Md+/ekSQ3bNiguuHLZDJOmjRJ4yL+3LlzNDQ0ZLly5XL8QmQ5hcSSKhUrVixeHhR1kipdDw5OOiAwOTGQKxdRvXrC/YUKEWXKxNv3MovWjch5YuDBg1hvgAaEAAEKAJnBY+SCIPDNmzc8evQoZ86cyfbt29PR0VHl9pRIJCxatCjbtGnD6dOn8/Dhw5m6bOmIESOor6+fqcv9phVPT08CSS9C5OzsnKGiJjo6msuWLaOZmRn19PQ4dOhQtmjRQjUk4O3tzWXLllFLSytDPE3379+nnp4eu3Tpotb3IzIykmZmZhwxYoTGbIjzNJw9ezbe/m/fvtHc3Jxdu3bVWFvXrl1j/vz5mT9/ftXyx9OnTycANmnShDKZjGXLlk24tK0gkH5+5MGD5KZN5ObN5OnTpJozZG7fvs28efPSzs4uxy9RnpOJioqir69vskmVdHV1VUmVGqxdS0ncEIG6YuDff2P39+qV8Jy6dQkjo3j7tmdRumR1+2/NhmtmFDExQOfOsf8nMfkhEsBEAFsAfAXgBGA6gLpJVCmRyWLrfPAA0NVNt4mRkZHw8fGJF8nv7e2NL1++AACMjIzg5OSEWrVqYejQoXByckKJEiWgr6+f7rbTwuvXr7FkyRKMHj0a+fLlyxIbUoO3tzfkcjkcHR0TPe7n54f27dtrvF2SOHbsGEaMGIHHjx/jzz//RP78+bF48WIYGBhgy5Yt+OOPPyCRSBAQEIDo6Gi8fPkSRYsW1ZgN3759Q+vWrWFra4vly5erFfV+4sQJBAQEpGsGwc+UK1cOlpaW2LdvH2rVqqXab2BggAkTJmDw4MEYMWIEihcvnu62KlSogJs3b6JVq1aoVq0aVq1ahbFjx+LNmzdYs2YN5s6di1WrVqFMmTKYOXMmhtSrB+mqVcC2bcDXr4lXam0NuLsDPXsC5uaJFildujQ8PT1Rv359uLi44MSJE3Byckr39YhkLlpaWrC3t4e9vT1atGih2i8IAt68eRNvdoOPjw+uv3kDWlkBqZnBEBgY+9fUNOGx3LmBkBAgKgpQKKAlkeDmt2/okDdvOq8s4/g1xMD27cCdO8kW6QpgD4AhAOwAbATQCMB5AFUSO0GpBF6+BJYvB4YPT5U5Hz9+VHX2cVP5fHx8EBMTAwCwsbGBs7MzBg4cqJrCZ21tna2mLk2YMAEmJiYYnsprzyru3r0LR0dHaGtrJzgWHByMoKAgWFtba7RNb29vDB8+HGfPnkWtWrUwePBgLFy4EM+ePcPAgQMxefJkGBsbq8o7ODgAAHx9fTUmBkiiZ8+eePfuHW7evAk9PT21ztuyZQucnZ1RsmRJjdgBABKJBC1btsSuXbuwePFiSKVS1bFevXph3rx5GDduHA4cOKCR9iwsLHD+/HkMGDAA3bp1w507d7BgwQK8f/8e48aNw4kTJ3By2zZYDB8OKQDKZJAolUlX+OoVMGECMGlS7N8xYwAtrQTFbG1t4enpiYYNG6JatWo4ePAgqlevrpFrElEfQRCgVCrTvMXExCR5jCSKFi0KW1tbNGzYEOP09eGT2qmM/02PTOw7BIUi9u9/YkBJ4m1c+WzKryEGFi8GpFJAEBI9fB3ATgBzAMTNuP4TQAkAfwHwSqpeEliyBBg6NLb+n4iOjsbjx48TPO1//PgRAKCvr4+SJUvCxcUFffv2hbOzM0qUKJE9czH8gLe3N7Zs2YJly5bB0NAwq81RC29vbzg7Oyd6zM/PDwBgZWWlkbbevXuHCRMmYMOGDShatCjWrVuH48ePo2/fvqhatSp2796daCdrYWEBQ0ND+Pr6omnTphqxZdmyZfj333+xe/dutQXG169fcejQIfz9998aseFHWrVqhYULF+Lq1atwcXFR7VcoFJg2bRo6d+6MK1euoHLlyhppT1tbG6tXr0bp0qUxePBg3L9/Hxs3bkT79u2xoEkT7JZIYkWJICQvBOIQhNht8mRgzx7g0KFYj8FP5M2bFx4eHmjRogXq16+PHTt2xHvCTLzqtHdeyXVcv2udmcqSJUCJEqk7J+7BJDo64bGoqNi//4kCAohJwqudXcj+YsDXF7h1K9kiewDIAPT6YZ8OgB4AxgLwB1AokfMAAH5+wOXL+FK8eIJO/9GjR4j670O1srKCk5MT3N3dVU/7tra28Z6OfhVGjRoFOzs79OzZM6tNUQulUon79++jTZs2iR7XlBgICwvDvHnzMHv2bOjq6mLBggUICwvDwIEDYWRkhK1bt6Jjx45JengkEgkcHBzg6+ubLjviuHbtGoYNG4YhQ4agdevWap+3e/duxMTEoEOHDsmWS0vnZWxsjNy5c2PFihXQ1taOd6xAgQKwsbFB7969MXv27FTVr04n06ZNGxw4cAAlS5bEiBIlMDo4GACQJn8biZj79xFUtCh6ODjAXy5P0i6pVIqWLVvC0NAQWlpaSdqXHZBIJJDJZIlucrk8yWOp3bS1tTVeZ3L1KZVKhIeHq7bv37+rtrCwMISFhSE0NBShoaH49u2b6m9ISAiiE+usAejq6sLAwAA6Ojr4HBODCEFI9KEwSXLnjv3731BwPAIDASMjlRiQSSQw0nASJU2Tva0DgKtXUyxyB0BRAD8/j1f47+9dJC0GlAD+btIEE0JCAAA6OjooUaIEypYti+7du8PZ2RlOTk4wMTFJg/HZjzNnzuDkyZPYu3cvtBJzb2VDnj9/ju/fv6NkyZKIjo5OcBN+8OABFAoFBEGAv79/qp9ioqOjcerUKWzcuBEhISFwc3ODnZ0dZs+ejQ8fPqBevXpo1qwZIiIisHr16mTrioyMxOnTpzFu3Lh0PR1FRETg8uXL0NPTw507d1CtWjW163r//j20tLTg7OycbLn0sHXr1njZCH+mUaNGatWTXOeVWEdhYWEBozdvMNLLC1LEPgSkFTmAXDExWPvqFWa0aweljk6i7UqlUpw8eRLXr19HnTp1ULdu3UQ7rczqGJPbstNQ5M9ERETg69evqi0wMDDe6+SORSbhYtfT00OuXLlUm7m5Oezt7ePt09XVRWhoKL5+/YoPHz7A398fz58/x/Pnz/H582cAgPbz50Bqh9Ty5AFMTIDHjxMe8/WNl/lWIOGURfFh6pL9xcCtW7FjMkmoOwB4D8Aikf1x+96l0EST/PlRZNUqODs7w87OTmNpMDX9ZJTa7ec6o6OjMX/+fFhaWsLX1xfTp0/XSL0ZYevPdgNA/fr1E77JPwwf/ZyiOK0cPHgw3uuTJ0/i5MmTAFLuvMLDwxEaGopt27al+aYulUpx7949CIKAqlWrwtDQUO2OIiQkBMuXL0erVq1QunTpDOl4bt26hcGDB2Pr1q0oUaJEAts7duyI0NBQnD59GlpaWprtvGJioCxXDrh3D7JE3K43AGxCbKzQKwCmACohNpg4sUEWGYk8YWFYqKcHLFqUZLNTpkzBzJkzMX78eNjb22PRokWQydIjRX5NIiMj1e7Af94fERGRaJ26urrxOu9cuXKhSJEiyJ07d4L9cVvu3LlhYmISL4boy5cvqoBAHx8feHl54dGjR3j9+rWqTIECBeDo6IiaNWuiTp06qvivp/fuAa1apf4NqVYNOHkS+PTp/0Gpt24B/v7AD948AUDZbD4km/3XJmjbNnZsLxkzbQHYAzj20/4X/x1bgNjAwqS4qauLP62twdiplqpNEATV3x//VyqVCf7+/H96n7w0xY+dF0lERUXBwMBA5ebLqCcUTdZ35MgRXL16FbPmzcMdIyM80tPDc4UCH+VyCBIJIAhQfPkC11y5UJpETYkE+inU+fr1a8ybNw/nzp1DqVKlMGbMGNy5cweLFi2CoaEhpk+fjnbt2iWwNaXOa+/evWjdujU+ffqEPHnypOkzmz59OiZOnIgTJ06gXr16qTp3ypQpmDt3Lj5+/Kh2sGFqiY6ORr58+dCnTx/MmDEjwXEvLy+4urpi27Zt6Nixo2YbX74cGDAgyftBawCeANogdkbRBwBLAYQCuIrYOKIkuXsXSCIuJY41a9agT58+aNWqFbZs2ZJoQGt2Jzo6Wu0O/Octbp2Tn9HW1k6y806uU8+VKxd0UpG3nyTevn0br9OPmxkQ95QvlUphY2OjWuegWLFisLe3R1RUFLy8vHDq1Cl4enoiKioKRkZGIIlvSiWwf///A/+A2NehoUBAQGxsSdWqQNw6Bi1aAAYGsSLA3T32/1atgPBwYNeuWK/BihWq+vJoaeFt5crQyoJhZXX77+wvBtq0AfbuTVYMlACQF8DZn/Y/AlAcwEoAvZNp4hKAauk0E4j9Ev7c4f34N7FNS0srwSaXy6FQKKBQKFT74l7/vGlra0OhUEBHR0f1V1tbG9ra2qp9WlpaIImWLVvC0dERa9asSdBmXLnsGAPRsFkzPCtXDl9q1sTXmBjIAcQkUi5uv6FMhv4FCmCClRX0fnp6CwgIwNSpU7FixQoUKFAAs2fPhomJCQYNGoTnz59j8ODBmDRpUpq/5w8fPkSJEiVw8eJFVK1aNdXnnzlzBvXq1cOkSZMwadKkVJ1LEnZ2dqhatSo2bNiQ6rZTQ/fu3eHl5QUfH59EBVKzZs3w4MED+Pj4QPHjDTY9kEDRosDz50neD7wAlAPwY4tPAZRErFBIcmBDLge6dAHWrk3RjAMHDqB9+/ZwdXXF/v37syRgODo6GkFBQal6Mo/bwsLCEq1ToVCk2IEntV9XA9OzfyQmJgYvX75MsMiRr68vvn37BiBWgBQtWjTBIkd2dnbQ0dHBmzdvcPr0adUWEBAAXV1dWFpaIiQkBO/fv4eJiQlatWqF9u3bY3fBglj/4cP/7y3t2wP/BYsnYMcOIG5KdtystAcPYr9HlSoBffuqYgqkACZYWWFy4cIafY/UJeeIAXd3YOPG2FwDSVAXwFvEdv4/chZAHQCHADRJ4lwlgMMAfo4T1tHRgZmZGUxNTVVfeBMTExgbG8PIyAhGRkYwMDCAnp4eBEFAdHR0vC0qKkqtfakpm9T5mkQqlSYQCEkJh7TsS23ZVwoFBrx/D2X+/EAqXMpSAJY6Otjq6AhXY2NERkZiyZIlmD59Okhi3LhxaN68OcaOHYu9e/eievXqWLp0KUqkNqL4JyIjI6Gnp4eVK1fC3d09Vee+ffsWpUuXRunSpXHs2LFUu6HjnsjPnTuHmjVrpurc1HLkyBE0adIEDx48SDSvwIMHD+Dk5IQlS5agf//+mmn04kUgjVP8yv73N9lQZG3t2FVP1XDnXrx4EU2bNkXhwoVx/PjxNOXqiImJSdChqzueHhoammidWlpaaj+V/3xMV1c302MOIiIi8OTJkwTz/p88eaIK3jY0NIzX2cdthQsXjvcbCQsLw8WLF3Hq1CmcOnUKjx49gkQigZOTE/LkyYM3b97A19cXenp6aNasGTp06IB69eqpvDvPw8NR/Pp1RGow6l8CwEgmw5OKFWGuKVGcSnKOGFi2DBg4MFnPwEjEDgUEIn4Q4UwA4wC8RjIBhBIJFhkZYfh/kckAYGZmBnNzcxgYGKiih8PCwvDp0yd8+vQJP79lpqamyJcvX4pb7ty5Nf7kTRIxMTHJCocvX77Azc0NNWvWxLBhwzJFoKT2/ES/huXLA9OnAzJZ7JZa/huq0Z07F1GnT0OpjI2Gz5s3L0JCQvDp0yfIZDLY2tqiQIECGhM0I0eORMWKFdGjRw+1zwdip+35+/vj+vXryJ8/f6pvzH369MGxY8fw6tWrDPfwREZGIk+ePBgxYgQmTpyYaJkuXbrg5MmTePbsWZqXOI7HtGnAlCmqz1VdiNjff3EAJ1MqfP48UKOGWvXev39f1ZmsX78ehoaGqerYQ/4LWv4ZuVyeand73DE9Pb1sGUQYHBwMX1/feB2+j48PXr58CeG/mJ+8efMm6PAdHR2T/C0IgoC7d++qOv8413+hQoVQrVo16Orq4tGjR7hy5Qq0tLTQqFEjtG/fHo0bN04y2duiN28w5NkzjV77dkfHLE02lHPEwPXrQMWKyRa5htggoR/zDEQidvjAFLFjhcnxeN48WPTsqfqyPnz4UPU3btoaAFhbW8PBwQGFCxdGvnz5YGxsDIVCgaCgIHz48CHB9vOPXS6XI2/evPEEgoWFRaLCQZOZCUeNGoWlS5fi2bNnsLBILNQy64kLFIzbvIKD0dLPL3Zd8fTc3AQBIJF/yRI0zpsXgYGBOHPmDIKDg1GyZElVvgBNCBxNx4nIZDK1PSkymQzXr19HoUKFULx48Uzx2owfPx4vXrzAsWPHEi379u1bFCtWDBMmTMD48ePT/4Y0awYcOZJkvpGk2AqgM4B1ALonU45SKd4MGoTHbm5qR7oH//AQ8SMymSzZcfLkOnYDA4Ns2aGnBEl8+vQpQYfv4+ODd+/+H8ZtbW2daKefO26qXjLEuf5PnTqFM2fOICAgAPr6+qhZsyaqVq0KkvDw8MDp06cBALVr10aHDh3QvHnzFGeECYKAIUOHYknevLGu/nQKagmALvnyYb29fZZ+njlHDAgCULgw8ENEaGK0BbAfwFAARRAbUXwdsUMFycUDfEXsrAO9XLnQoUMHDB8+HDY2NqrjoaGh8PHxiScQHj16hFevXqnKWFlZoXjx4ihWrBiKFy+O4sWLw9HREVKpFB8/fkxUKLx//z7e65/d/QYGBmp5G8zNzZOdIujv7w87Ozv89ddfmDp1arLvYXYhNCYGxW7cwNvISCR623/8GFi3Dnj4MNZjVLw40Ls3UKRIovVJSOSSyeCyciWO7NiBGjVqYOnSpRpJm/sjgiAgJiYGI0aMwOHDh3Ht2jW1xISHhwdmzpyJrl27ol69emkSI8+ePcPFixdVT6rp8eBkBPr6+glERWpFysyDB5E/KChV7foCqIhYr8AlJD8VMQrAagAD/3stlUphYmKS4hi6VCrF7Nmz4e/vj7Vr18LNzQ2Ghoa/ZIeuDoIgwM/PL0GH7+Pjg6//pYKWy+Wws7NL0OHb29un6kEnLCwMFy5cUAmAONd/uXLlUK9ePVSvXh0BAQHYs2cPjh49isjISFStWhXt27dH69atYZ5E2umfiYiIQPv27XHw4EEoDA1R6uBBXAdSNTT5M3+Ym2OjgwPkWRyHlXPEAADMnQuMGpXsE0EEgAmIfQqIW5tgGoBEJqOpoEyGz507o39oKI4cOaKa+mJtbY0+ffqgR48eMDMzS/TcOJHwsyfhZ5Hwo0AoVqwYihUrlsBlSlI1BzalLS5i9kfMzMyS9DBs3rwZN27cwO3bt2FpaflL3KAGPX2KZW/fJi4EnjyJHTYyNweaNIn9Thw8CHz7FhvEY2mZeKVKJXQ8PbGhaFG0a9cuQ9+HtWvXonfv3ggLC0sxUvrp06eqG9u///6bZruaN2+Ot2/f4saNG2k6Pw51hp3itpCQEDRo0ABdunRBy5YtEy0bGBiIcePGoXLlyqhXr54qQcyPSWPCw8MRERGByMhI1d+oqKgEbd4KCYFtKsZzPwBwBRCNWO9g/hTKK2UyfG3WDKHz5iFXrlwwNDRUe7glNDQUrVq1goeHB7Zs2YK2bduqbWd2JSoqCs+ePUvQ4fv6+iI8PBxA7Dx/BweHeB1+sWLFYGtrm6Y8Jsm5/uvXr4+6deuiatWquH37Nnbs2IGDBw8iNDQUZcuWRYcOHdC2bdtUTzH+8uULGjVqhBs3bkBPTw9nz57F6fPnMcHXF9IuXSCRSKCuz08ukUAGYJaNDQYVLAhpNrjf5iwxEBIC2NvHTuNIpYswKQQAoRIJPFatQpOePaFUKnHw4EHMnj0bN2/eBElIJBKULVsWgwcPRsuWLdWaqhUWFpaoJ+Hly5eqMpaWlol6EtRJDRwdHY3Pnz8n6l34efs5yEhLSytZL0OcoMibN2+GTUtLiYCoKOS/cgXRSX0tR48GHj0CtmwB4tYF+PIldtGpcuWAZLwfEgCvKlWCZSqmMqWFy5cvo2rVqrh//36yAYnh4eGoVKkSwsPDcfPmzTT/tgICAmBhYYH58+dj4MCBKZ+QAiQRERGhyuiW3LZ+/XoEBQWhadOmSZb5/PmzqvNIDolEAgMDgyS3uWfPwjJucZgUCAZQA7HxQpcAFFPjnCgAD2vUgPPZs2mKuYiKikL37t2xfft2zQZOZjBhYWHw9fVN0Ok/e/ZMtd5K7ty5EzzlFytWDIUKFUp3fEpyrv969eqhXr16sLW1xcWLF7Fz507s3bsXgYGBcHR0RIcOHdC+fXvYxU35SyXPnz9HvXr14OfnByMjI3h4eCA0NBTVqlXDqFGj0HbMGIx/+RJHv3xB3FX+LAxkiI1LkQBolScPphcuDLssun8mRs4SA0BsYocGDTRa5YJy5TDs5k00a9YMy5cvR/78sc8OX758wapVq7BixQq8efMGQGxH2qBBAwwYMAC1atVKdWKiOJHwsyfhZ5GQmCchresH1K9fH48fP8amTZsQEBCQ5HDFx48fVT/6OIyMjNQapsiTJ4/GkjQBwJzXrzH6xYvEvQIA4OYWG1g4eXL8/WPGxCb7OHgwyVUoZQBGWVpixg/DQBnB58+fYW5ujj179qBVMolMevTogR07duDatWtpXlBIEAQsXLgQf/31Fzw9PaGtra1WJ57SllL8g0wmUz05BwYGwsnJCblz5060E9fS0sKcOXNQqlQpDBkyJN4xQ0ND1f+JRbOTxOvXr+Hl5QWbqVNR1tc3xUxpEQDqIXbmwBkA6q6SQAA9AbysWRMbNmxIU3prQRAwYsQILFiwAOPHj8fUqVOzjTfu56Q8cduPcVFxSXl+7PAdHR2RJ08ejV1HSq7/evXqoVKlStDS0sK1a9ewY8cO/Pvvv/jw4QMKFy6M9u3bo3379ihZsmS6bLp+/ToaNmyIb9++wdTUFB4eHsiTJw9Kly6NggUL4sKFC6p7m19EBHZ9+oSb377hekgIAmNiIAFgpqWFikZGqGBoiPbm5siXDfNO5DwxAADjxwOJJDlJLQQQ2rEjDLduxd59+9C/f39ERERgzpw56NmzZ7wv2L1797Bw4ULs2rVLlXDD0NAQHTt2RM+ePVG2bNl0fSHjVHlinoS4jyYuKOxHb4Kjo2Oyn8W5c+dQu3Zt7N69O8W89oIgIDAwUK1hii8/5eGWSCTIkydPigGRcQGXKb1XlW/fxtUkoqwBAPXqATVrxnb+PzJ5MnDhQuzsk2JJPwcW1dXF4xQCUtMLSZiZmWHYsGEYN26can9MTIwqh/qmTZswbtw4jB49GlWqVEmyU47Ls57UltSc8R/R1tZO9ok7ue3HzvrHTaFQQCKRIDg4GHny5MHcuXMxaNCgJG1YvHgxhg4divv376NYMp9PZGQk7ty5Ay8vL1y5cgVeXl6q4LOpefJg3OfPSO45VAmgJWITkB1E7MqlqeHaypVoM2MGgoKCsGjRInTt2jXVv2+SmDNnDkaNGgV3d3csX75co4I5pbbTkpTH0dERDg4OGXJ/T8n1X69ePdSqVQumpqYgiXv37mHnzp3YuXMnXr16BQsLC7Rt2xYdOnRAhQoVNCJKDh06hLZt24Ik8ufPj/Pnz8PKygqtWrXC+fPn4e3tDcukhhx/MXKmGCCBsWOBWbNiAztSOR9UQOz88216ephqYQGPS5dgYWGBwMBAjBgxAhs2bECNGjWwZs0aFPkpGC0qKgrHjh3DggULcOnSJVVHXbBgQfTs2ROdOnWC7Q+5qNNLnEhIzJPws0iIEwg/xiRUqFABcrkcV65c0eiTSVRUFD59+pRsMGTcvp9dw9ra2sl7GfLmRe3ISCS70GePHrGpqTds+P90w+jo2GGCjx9jRUEyc9GlAEKqVoV+ClMVo6Ki0tQ5x21Xr16FXC6HiYmJal9S6Vh/RE9PL1WddWhoKCZOnIhRo0ahQYMGCY7r6+tn+BoUbm5uCA0NxYULF5IsExkZCQcHB5QqVQr79+9X7f/48WO8jv/mzZuIjIyErq4uypcvDxcXF7i4uKBSpUrI8+1bbJBoMr/7IQAWITavSGKj9p2Su5D8+YHXrxEcGorBgwdj06ZNaNq0KVavXo28aZgatnHjRvTs2RNNmjTBjh07UpVpLyU0kZQnI0nM9W9gYICaNWuibt26qFevHooWLaq6Nz19+hQ7duzAzp074ePjg9y5c6N169Zo3749qlWrptHUz8uWLcPAgQOhUChgY2ODM2fOIH/+/Fi2bBkGDBiAffv2pbhC5a9EzhQDcezbF5uMKDhY/TnHcjmorY3RBgY4ZGKC4JAQ5M6dGx4eHqogwTNnzqBXr154//49pk6diqFDhyaq6D99+oTNmzdj2bJlePXqFSQSCUjC2dkZ7u7uaNu2bZpT0abE9+/fE3gSfhYJuXPnRmBgINq2bYt69eqpPAnGcWPsmQBJhIaGquVt+PjxY6xbOn9+YNu25Cs+dAhYsACoXz82QxgZGz9w6VJsYqqxY4G6dZOtovnx49D190+2M08pqj6l8e27d+8iODgYPXr0iPeULZVKMWbMGBgYGGDz5s0wNTVVHdfT00v1TW/8+PFYunQpPnz4kOE3+KRYt24d3N3d8f79+2Q7zU2bNqFr164YOXIk3r9/Dy8vL7x48QJArLCN6/hdXFzg7OycuIhp0AA8fRqSJGKHagBIWpLEegUTRSqNzWnxg8fpwIED6NWrF0hi5cqVyQ75JMWRI0fQtm1blCtXDocOHUr1gmeaTMqTkcS5/uOe/uMyU/7s+v8xG6W/vz927dqFHTt24Pbt2zAwMEDz5s3RoUMH1KlTR3OZK/9DEASMGjUKc+fOhba2NooXL46TJ0/CzMwMd+/eRcWKFeHu7o6lS5dqtN2sJmeLASA2X/ScOcCqVbGiQEsrtjP48XLiFjjS1we6dwdGjcL9wEBUrFgRDRs2xOXLl1GwYEGcO3dO1VGGhYVhwoQJWLRoEUqXLo21a9eiVKlSiZpAEnfu3MGaNWuwZcsWhIWFQSKRQCKRoHbt2ujatSuaNWum0ZwBSREnEry9vTF06FDo6OjAwMAAL168iOfFSMyTkJkiITEEQUBAQAAuvHmDtskNEcSxdm1s/u+4OAd7+9g4gq1bYxPTVKmS7On2K1bA4tMntV3iiW0pZWubM2cOpk6dipCQEFU5kmjdujXOnj2LW7dupduTJAgCbGxsUK9ePaxevTpddaWHgIAA5MuXD8uWLUPv3v9P/B0UFISrV6/Cy8sLXl5euHbtGkJDQyGRSOI99VeuXBkFCxZMsZ2goCBMq10b827f1uwFSCSxWQefPYvNKf8Dnz59Qp8+fbB//3506tQJS5YsSXWHfuXKFbi5uaFgwYI4ceKEKjbpRzIiKU9GIggC7ty5o3r6v3z5MqKjoxN1/f/Ip0+fsHv3buzcuROXL1+GtrY2GjdujPbt28PNzU3jaY3jiIiIwJ9//ondu3dDW1sb5cqVw9GjR2FsbKyajaCrq4urV69mmajOKNTuv6kGwcHBBMDg4GB1imcu4eHkvn3k6NFknTpkiRJk8eJkjRrkiBHkzp3kt2/xTtm4cSMBcMqUKcyVKxddXV0ZGhoar8y1a9dYokQJymQyjhkzhuHh4cmaERERwT179rBu3bqUSCSUSCQEQB0dHf7xxx88ceIEo6OjNX75P7NgwQJKpVI+fPiQJBkWFsbbt29zy5YtHDNmDJs2bUpbW1uVfQBYoEAB1qtXj0OHDuWaNWvo5eXFoKCgDLf1Zx6EhhLnz6u3HTpELF5MrFsX+7pjx9jr2bAhxXMvZ8K1HTx4kAD49u1b1b758+cTAA8cOKCRNjw8PAiAly5d0kh96aFmzZp0dXXl+vXr2bNnTxYrVkz1/cqTJw+bNWvG2bNnc9asWQTA48ePq123IAj8559/qKWlRQDcY2ZGQSolY6W/ZratW5Ntf9OmTTQyMmKBAgV48uTJVL8/Dx8+ZIECBViwYEFu3ryZy5Yt44ABA1i7dm3mz59f9V4BoLW1NRs2bMhhw4ZxzZo1vHz5Mr98+ZLqNjWNv78/169fz/bt29PMzIwAaGBgwCZNmnDx4sX09fWlIAgJzvv69SvXr1/PunXrUiqVUi6Xs2HDhty8eXOm9CkBAQF0dXWllpYWFQoF69SpE+9+36VLF+rr69PX1zfDbckK1O2/f30xkEZ69OhBHR0dbtmyhQYGBqxTp06CDj8yMpJTpkyhlpYWixYtyosXL6pV97t37/jPP//Q1taWACiXywmApqamHDRoEK9du5bojya9BAUF0dTUlD179kyx7Pfv33n79m1u3bqVY8aMYbNmzVikSJFERcKQIUO4Zs0aenp68uvXrxq3O47g6Gj1xcDPm4MDkScPcfZsimVX7dtHPz+/DPkM4nj8+DEB8OzZsyTJy5cvUy6Xc+TIkRpro0ePHixcuHCGXkdShIaG8vz585wxYwYbN25MfX19AqBEIqGTkxN79+7NTZs28enTp/HsEwSBrq6uLFWqFJVKZYrt3L59m1ZWVqqO599//yVDQsiiRUm5PP0iQCol27cn1XgPX79+zTp16hAA+/Xrl+ABIg6lUsmXL1/y6NGjnDt3Lnv06EEXFxcaGxurflsymYyOjo5s2bIlx40bx61bt/LWrVtJ1pkVhIaG8ujRoxw8eDAdHR1Vn2/58uU5btw4XrhwgZGRkUmeu3PnTjZr1owKhYISiYQ1atTgypUr+fnz50y7hufPn9Pe3p6GhoaUy+Vs2rRpvPv85s2bCYCbNm3KNJsyG1EMpMD379/p7OxMOzs7Hj16lDo6OmzSpAmjoqISlH348CErV65MAOzbt6/a74MgCLx27Rp79+5NAwMDAlA93dja2nLy5Ml8+vSpxq5pzJgx1NXVjfc0mlq+f//OO3fucOvWrRw7dqxKJEilUtWNLH/+/Kxbty6HDBnC1atXa0wkBAQE0OjIkdQLgQkTYm3r2zfFspJDh1TXYW5uTjc3N06ePJlHjx7lp0+f0n0NcURFRVFLS4vLli3jx48fWaBAAVatWjXR71da+P79O42MjDhx4kSN1JccgiDw1atX3LFjBwcOHMiyZctSJpMRAI2MjFivXj0OHz6cALhixYoU67t06RIBcPv27UmWCQsLY9u2bVWfVefOnRkREfH/Am/fkkWKkDJZ2oWAREI2a0Ym0aElhlKp5NKlS6mrq0tbW1tu3bqVe/bs4bRp09ixY0eWLl2aenp6Krv19PRYpkwZ/vHHH5w+fTo3btxIZ2dn6unppcnDkJEolUrevHmTM2fOZM2aNVX3KktLS/bs2ZP//vsvAwICkjw/IiKCBw8eZIcOHVTvQYUKFbhgwQK+efMmE68kluvXr9Pc3Jzm5uaUSqXs0KFDvN/f48ePqa+vz86dO2e6bZmJKAbU4OnTpzQyMmLr1q157NgxamlpsV27doyJiUlQNiYmhosWLaK+vj4LFizII0eOpKqt8PBw7tixg/Xq1VM9GcT92CpUqMDFixfz48ePab4Wf39/6ujocNy4cWmuIzniRMK2bds4duxYNm/enHZ2domKhMGDB3P16tW8fPmyWiIhIiKCc+fOpYmJCbXGjKE0uaf7hQuJMmWIXr2IESMINzdCKiUqVCDOnElWCMjPn2eL+/f57t07Hjx4kOPHj2f9+vWZO3du1TVYWVmxdevWnD17Ns+dO5eu77yjoyMHDBjAOnXq0NzcPF0i7Wd27txJAHzy5InG6owjMjKSV69e5fz589m6det4bmw7Ozt26dKFq1at4v379+P9VlxcXNikSRO12mjcuDFtbGwSfbLcsGGDqjOxsbHh/fv3E68kIIBs2fL/Hbu6IkAmi/UIjB9PqjF0Fxoayps3b3LLli0cO3YsW7RoQRsbm3hetNy5c9PV1ZU9e/bkvHnzeOzYMb569SpR70dYWBjd3Nwol8u5bds2td6vjCI51/+SJUuSdP3HER0dzdOnT7N79+40MTEhAJYsWZIzZszg8+fPM/FK4nPw4EHq6uqycOHCBMCePXvG+65GRESwVKlStLOzY0hISJbZmRmIYkBN9u7dSwBcuHAh9+3bR5lMxu7duyfpwnz16hXr169PAOzQoUOanib9/f05c+ZM1TCCrq4upVIpZTIZGzRowK1bt6baXdi9e3eamZll+mcUHh7Ou3fvctu2bRw3blyiIsHCwoJ16tTh4MGDuWrVKl6+fJmBgYEUBIG7d++mjY0NZTIZ+/bty6MvXiT/dL91K1GuHGFsTGhpEZaWhLs7ceqUWl6Ek4mMvQqCwOfPn3Pnzp0cPnw4q1WrFs/t7eDgwM6dO3PRokX08vLi9+/f1Xpv4joNqVTKc+fOafR9b9SoEStXrqyRuj58+MD9+/dz5MiRdHV1pba2NuPiXapVq8bRo0fz0KFDKX7X582bR21tbbVurvfu3aNEIuGyZctU+54+fcoSJUoQABUKBefPn6/eEMi//8Z6CYAkhw4EgEKcF6FqVfLWrQTVBAQE8NKlS1y9ejWHDh3KBg0aqIYofhw6q1OnDgcOHMglS5awZ8+elMvlLFmyJO/evZuyrf8RFRXFLl26EAAXLFig9nnpJT2u/ziUSiUvX77MAQMG0NzcXOXpHD9+PB88eJBJV5I0y5Yto1QqZfHixQmAQ4cOTfA9GjhwIBUKBW/fvp1FVmYeohhIBUOHDqVcLqeXlxe3bNlCiUTCQYMGJXkjEgSBmzdvZu7cuWlqasqtW7emadxWEAR6enqyZ8+eqmEEIyMjlXuxY8eOPHbsWIqBh/fv36dUKuXixYtTbUNGEScStm/fznHjxrFFixYsWrRoPJEQ5xmxtrbmxIkTOXv2bJYoWZJYtSrFp/xUb2fO0PjwYQaqOZwRExPDBw8ecMOGDezfvz8rVKhAhUKhigEpVaoU3d3duXr1at65cydR93+cm3vGjBkafW8/fPhAmUzG5cuXp/rcmJgY3r17l8uXL2enTp1oY2Oj+jwKFSrEdu3acdGiRbx+/XqKncLPvHz5kgC4c+dOtcp37tyZefPm5ZcvX9ivXz/Vk3bdunVTHzAnCOTZs2SvXqSTUzxREC6V0lMi4fUaNSg8eEB/f3+eOnWKixYtYp8+fVi9enXmyZNH9T5IpVIWKVKETZo04V9//cWNGzfy2rVrSd7/7t69y5IlS1JLS4szZ85UO1BYEASOGjWKADhq1KgMif340fVfo0aNVLv+f7T19u3bHDlyJC0tLVXCaNiwYbxx40aWxK38jFKp5MiRI1XeVgCcOHFiAtsOHDhAANnqfpmRiGIgFURFRbFy5cosWLAgP3/+zFWrVhEAx44dm+x5Hz9+ZLt27QiADRs2pJ+fX5ptCAsL45YtW1i7dm1VRxkXcJQnTx4OGDCAV69eTfRH5+bmRltb21TfvLMCX19fNmzYUHVdrq6uLFiwYLynL8Ny5dQKBEztplOpEs3Nzblx40a1gtd+JjIykjdv3uSKFSvYvXt3lixZUiVudHR0WLlyZQ4aNIhbtmzhuXPnVK5uTbshFyxYQC0tLbU6zK9fv/L48eOcMGECa9eurRKdcrmcFSpU4ODBg7lr1y6+fv1aI7aVLVuWbdq0Uavsy5cvKZVKqaOjQwA0MzPjmTNnNGJHdHg4n92+zXZubsxjasp8+fLRxMSEhoaGqu+ZtrY2S5YsybZt23Ly5MnctWsX7927l+LMocSIiIjg6NGjKZVKWbly5VQN38TNMunatatGZhyl1/X/Iz4+Ppw0aRKLFi3KuCDoPn368MKFC2n6DWUU4eHhqntx1apVCYBz5sxJUO7169fMlSsXmzVrli0ETGYgioFU8vr1a5qZmbF+/fpUKpWcN2+e2k91hw4dYoECBWhgYMClS5em+0fy6tUrTp06VTXeZWxsrLqJ2dracuLEiXz8+DFJ8vz58wTAXbt2pavNjCY4OJijR4+mtrY28+XLx7Vr19LLy0sVnV26dGkuX76c27dvZ7du3Yhu3Yhz5zQiAiTnz7P/48f09/dXPa27uLjwzp076b6u0NBQXrp0ifPnz2eHDh1YpEgRVWcT96TbtWtX7tmzh69evdLIDah06dJs2bJlgv2CINDX15fr16+nu7u7yk0aJ7yaNm3KWbNm8eLFi2oPdaSWGTNmUF9fP8X637x5Q1dXV5V9ffv2TVNwZXh4OL29vblz505OmjSJbdq0YYkSJVRenB/jWbS1tTlr1iweOnSIT58+TTQ2KL14enrS1taWenp6qboXbN26lXK5nI0bN2ZYWFiq2kzK9V+hQgW1Xf8/8urVK86aNYulSpVSeSu7dOnC48ePaywAVpN8+fKFVatWpba2NmvVqkWJRJJoIGt0dDRdXV1ZqFChbDFVM7MQxUAaOHnyJCUSCadNm0aSnDJlCgFw0aJFKZ4bFBTEPn36EABdXV3p4+OTbnuUSiUvXLjArl27qp4yLSwsqKurSwAsV64cCxUqxFKlSmVblRsdHc0VK1YwT5481NXV5YQJE3j16lU2a9aMAOjo6Mg9e/bEs3/16tWUyOVse+8eJekVA2fPUnv+fAb+8N09c+YMHR0dKZVK2b9/fwYGBmr0mt3d3VWxJ3HBZT/OYGjUqBEnTZrEI0eOpDpo9P79+wTA/fv3q6b3zZw5k40bN6apqamqIyhZsmSS0/syEl9fX5V9iREdHc3x48erptsWL16curq6HDFiRLL1BgcH8+rVq9ywYQNHjhzJxo0b09bWNt6wk7m5OWvUqMG+ffty8eLFPH36NBctWkQAqrwPmvhdpkRoaCj79etHAKxTp47aXpcTJ05QX1+flStXTraz0pTr/0fev3/PxYsXq2ZN6ejosE2bNty3b1+aPCWZxYsXL2hvb8/cuXOzdu3alEql3Lx5c6Jlx48fT5lMxsuXL2eylVmLKAbSyKRJkyiRSHjmzBkKgqAag1q3bp1a53t4eNDOzo4KhYLTpk3TmJL+9u0bN2zYwOrVq6t+rHEuQKlUyvr163Pz5s389lOCpaxCEAQeO3ZMlXzmzz//5MWLF9mxY0dKJBIWLlyYmzdvTvTprH///nR0dGSMIHDAkyfE+fOUpkEE4Px56k2ZQsjlNDc35+nTp1U3yaioKM6dO5cGBgY0MzPj2rVrNeL2jIvyjwuMy5cvHydOnMh3797x0KFDnDBhAhs0aKDquONu4q1ateKsWbN49uzZRBM+CYJAPz8/NmnShNra2ixTpkyC6X2TJ0/mqVOnsiRh1I8UL1480elaHh4etLCwUMXEbNq0iYIgcNKkSdTW1qafnx8/fPjA8+fPaywpz5kzZwiAd+/epVQq5Zo1azL68lWcPHmSBQoUoLGxMTdv3qyWILt27RrNzMzo6OgYT0S8fv2a69atY/v27VXfnR9d/48fP0614AsMDOSaNWtUnaiWlhYbN27MrVu3/hIR9jdu3KC5uTkLFy6smgq5d+/eRMueOXOGEomE06dPz2Qrsx5RDKSRmJgY1VSwN2/eUBAE9u3blxKJhDt27FCrju/fv3P06NGUyWR0cnLijRs3NGrjs2fPOG7cONXTlbm5Oa2trVUzEzp06MAjR45kmUvv3r17rFu3LgGwRo0aPHr0qOppOX/+/FyxYkWybktXV1e2b99e9frUly/M7+mpliiIO2549izbLVrEVq1axRsnBsC8efOyZs2aHDBgAGfOnKkaqqhYsWK6PisfHx8aGBiwQ4cOqhtz9erV2a5duwRlBUHgixcvuGvXLo4YMYLVq1dXjecDYNGiRdmgQQM2b96cNWvWVHWiccNGXbp04cqVK3nv3r0McXenh4kTJ9LY2Fj1GX/69ImNGzdW2d+uXTveu3dPlZSnc+fOlMvl8Vz7crlcI0l5Hjx4QAC8fPkyS5cuzS5dumTAFSdNYGAgO3XqRABs0aKFWrOPfH19aWlpSTMzM3bu3Fkjrv84vn37xm3btrFx48bU0tKiRCJhrVq1uGbNml/KdX748GHq6emxfPnyrFq1KnV1dXnixIlEy378+JH58uVjrVq1st1vJTMQxUA6+PjxI/Pnz88qVaowKiqKSqWSf/75J+VyOQ8ePKh2Pbdv32bp0qUplUo5fPjwVI8FJsfixYsplUq5du1adurUibq6upRIJLSzs1MF5JmZmbF///708vLKFDfx+/fv2bNnT0qlUtrZ2XHjxo0cNGgQFQoFTU1NOW/evBTHkpVKJQ0NDfn333/H2x+hVHLbhw8sdOhQvFiCn4cRSt+4wfXv3vH7Dz96pVLJWrVqEQCLFSvG8ePHs3Xr1nR0dFQJqrgOKM51/c8//9DDw0PtbGmhoaEsXrw4HR0d43lnevfuTWdn5xTP//DhA/fu3ctu3brRzs5O9dT/Y/xB3rx5CYCjR4/m7du3s+X4LUl6e3urhgr++usv1fuqp6dHe3v7RJPylC1blhKJhIsWLeKjR480dm1fvnwhAO7evZuDBg2ira2tRupNLXv27KGpqSnNzc0TTUf9s+s/7j2TSqVs0qRJmlz/cYSHh3Pfvn1s27ataoixcuXKXLRoEd+9e5feS8t0li9fTqlUSjc3N1asWJGGhoa8cOFComWVSiUbNGjAPHny/JLXqglEMZBOLl++TJlMpkofGx0dzVatWlGhUPD06dNq1xMVFcVZs2ZRR0eHNjY2qvS06SE4OJhmZmbs3r27al9QUBDXrFlDFxeX2Ih8Q0M6OzurpkzZ2NhwwoQJGZJ/OywsjNOmTaO+vj5z587Nv//+m6NGjaK+vj6NjIw4depUtd2Oz58/JwAeO3Ys0eNVq1Zlo1ateOnrV655+5ZL/P25+u1benz9yuBkIrGjoqJYtmxZAmDz5s1V4igyMpIPHjzgrl27OGHCBDo7O8cbh/5xLLp///5ctmxZApEgCAI7depEfX19Pnr0KF67CxYsoI6OTrwhiB+n93Xu3FmVbwKInd7Xtm1bLly4kNevX+e3b99469Ytrly5kkWKFKFCoVAJBR0dHVaqVIkDBw7k5s2b6ePjkyUR3okl5flRZMV5rFxcXJJMyhMREUErK6tEAyPTgyAIVCgUXLJkCf/9918CyLJO4cOHD2zatCkBsEuXLnzw4EGyrv8bN26onnpTm+QsKiqKJ06cYJcuXVTTlZ2dnTlr1iy+fPkyYy4wg1Eqlfzrr78IxCYRKlWqFHPlysXr168nec4///xDIHVrYeQ0RDGgAebOnUvg/wvLREZGsmHDhtTT00v14jCPHz9mtWrVCIA9evRIV/recePGUUdHh/7+/km2NWbMGBYoUIBAbFa98uXLq9zlZcuW5YIFC/j+/fs020DG/jg3b97MggULUktLiwMHDuT48eNpYmJCXV1djho1KtVPM/v27Uvyhh0cHEy5XJ6m+fVkrGixs7NTRfgn5S15//69yrVrY2PDHj16sHXr1ixWrFi8Ti5PnjysUaOGKo5j3LhxCdzAx48fJ4D/sXfWYVFtXx9fEzB0CoK0omAQYgAWYCHYnZgoYnCtays2Xgu781rYhV1YmNjYogI2gnTMzPm+f3Dn/BipmWFQ73vn8zznGT1zzj77DDNnr732Wt+FrVu3Ytq0aWjevLlUel+9evVkSu/LyMiAtrY2Zs+ejczMTFy9ehXh4eHo1asXe0+S+AEfHx+MHz8e+/btU1oGAyCbKE+lSpVgZmbG/t/Z2Rn37t2TqQ/btm0DEeHGjRtK6a8Ea2trTJ48Ge/fv2e9BL+CjIwMREZGsgV7Crr+p06disuXLxdy/WdlZaF9+/bg8XjYunVrie1LAo6Dg4PZeKKqVati+vTphYzUfxs5OTno0aMHOBwOQkND4ejoiIoVK+Lhw4fFnnPjxg3w+XyMHz/+J/b090NlDCgBhmHQoUMH6Ovrs9KaWVlZ8Pb2hp6eHu7cuSNXe2KxGGvXroWenh7MzMyKDXYpicTERGhqamLSpEmlHisSiXDq1Cn06NEDAoEAXC4XderUYQV0uFwuWrRoga1bt8odMBQVFcXOtDt27IipU6fC1NQUampqGDFihMKzr9DQUJiYmBQ5eBw6dAhEVCaZ0+TkZHb9fcyYMSUee/XqVTa9auDAgfjy5Qtyc3MRGxuLvXv3IjQ0FM2bNweHw5HyJhgaGsLBwQE1atRgFdokyzYF0/vkWTbavn07iKjYWV1ycjLOnj2LefPmoWPHjlLaDSYmJjJnMDAMo5Aoz40bN7By5UpWuVFieF68eFHmexSJRKhVqxa8vb2Vuqzl7u6OAQMGAAAqV66MP/74Q2ltl0RJUf89e/Zkg2tDQkJK/C4IhUIMHjwYRIS//vqrUOGn27dvY8yYMazxb2VlhT///BMxMTG/bZaRPHz79g1NmjSBhoYGVq1aBTs7O1hZWbHp1UWRkpICW1tbuLu7/7bLaT8LlTGgJFJSUlC5cmW4ubmxKTZpaWnw8PCAkZFR8brpJZCQkIC2bduCiNC5c2e5ZuiBgYEwNjaWO2I8OTkZa9asYZW5DA0N4ePjww7ompqa6N69O44ePVpiYNKLFy/QoUMHEOWnNo4fPx6WlpbgcrkYMGBAmV2Q7du3R/PmzYt8LygoCPb29mVqHwDev3/P6qhL0kiLQyQSYdWqVTAwMICBgQFWrlzJBiElJyfDxsYGDg4OCA0NhZeXVyFRm4JGgrGxMby8vBAcHIyVK1fiwoULMqcWtmjRAk2aNJHrPj9+/FhsBoOlpSVatmyJgIAABAYGomfPnqhfv75CojyPHj2Ci4sLO9MdOnQo0tPTYWlpiREjRsjV56P/FJIqLhhMEdq3bw8/Pz8AQN++feHm5qa0tn9EEvXfvXv3UqP+xWIxli5dCg0NDVSrVq1EjwjDMJj2T0GuMWPG4OHDh5g6dSqra2Fqaorhw4fj6tWrv5UYUFl58+YNHB0dYWxsjF27dsHCwgL29vZ4+/ZtsecwDIOuXbtCX18fcXFxP7G3vycqY0CJ3L17FwKBAEFBQey+5ORkuLq6wszMTKFiMQzDICIiAiYmJjAwMMCmTZtKteJjY2PB5XKxdOlSua/3Yzt//vkn6851dHREmzZt2KhlY2NjBAcH4+rVq2yfvn37hj/++AN8Ph9WVlYYPnw4+yDq3r270mIRbG1tMXbs2EL7GYaBra2t3INLcTx//pwNZFuxYkWpx3/58oXVDbCxsUHnzp2lStJK0vtCQ0Nx+vRp1ljLy8tDtWrV0KJFC8yYMQPdunVDzZo12VmixGPQpEkTBAcHY8WKFayRIPnsExMTFU6LKyjKM336dPj7+8PKyqpQgKLkHlxdXREYGIg9e/aUmqaanp6O4cOHs+JK1atXl9LnDwkJQaVKleQanBiGQYMGDVC7dm2lDWpDhw6Fq6srgHwNCy6Xq7TUufT0dERGRiIkJKRQ1H9xrv8fefr0KerVqwcul4spU6YUe/zr16+lsjL09fUxcOBAnDlzRinKhb8bt2/fRsWKFVG5cmUcPnwYJiYmqFmzZqlex7Vr14KI8stdq1AZA8pm/fr1ICJs376d3ff582c4OjrCysqqREu1JJKSktC3b18QEZo1a1aiC7xt27aws7OTLuVaBoRCISIjI9GlSxeoqamBz+fDx8dHys1sa2uL5s2bQ1dXFzo6OggICGCLybRp00YpKn4Svn//XugzlvD8+XMQEY4dO6a0692+fZsdlIu65o/V+yRu2ILbgAEDSk3v69atG7y9vaX25eXl4cmTJ9i/fz9mzpyJbt26oVatWlJGgrGxMZo0aQIPDw/w+XwcPXoUnz59KtJoVFSUJz4+HrGxsdi2bRtGjBgBd3d3tlARj8eDi4sLAgMDsW7dOjaDgWEY7N27lxVTEggEWL58eaHB+9KlSyAiREdHy/V3uXz5Mohkr3FQGjNnzoSZmRkA4MmTJyAinDlzRqG2SnL9Dx48GHv37lUoRU8oFGLWrFls3QuJx/H9+/cIDw+Hu7s7iPKzLxo0aAAej4cWLVr8NroiykaSOuju7o7IyEgYGBigbt26pcYgPXz4EBoaGlITt/86KmNAyTAMg4CAAGhpaUlV5kpMTISdnR3s7e3LFKV88uRJWFtbQ1NTE4sXLy40uEgerLJqHchLUlISVqxYATc3N3Yg8vT0ZNeAJUsJRPlSvvI+4GVBMggUFRS0bNkyqKmpKf3hd/bsWXC5XHA4HGzdupWt3teoUSOp6n2NGzfGhAkTcOTIEezfv5/V1NfT08PSpUtLnJlNnz6dHYxKIy8vD0+fPmWNhO7duxdabtDT00OVKlVQq1YtVKtWTcr9LzHgZBXlKYrc3Fw2g2HQoEFwdnZmPQnq6upSSwne3t7FlmYWiUQwNTUt0tNTGq1bt4a9vb1S1nvXrVsHLpcLkUgEhmFgbGyM6dOny3y+PK7/shITE4Nq1aqBx+OxZZLV1dXRvn177N69m9VZOHfuHHR0dFC/fn2Z01//LaxduxZcLhft27fH8ePHoa2tjUaNGpU6/mRkZKB69eqoVatWuclt/xtRGQPlQHG55HFxcbCwsEDNmjXL9MNMT09HSEgIW1JUMigyDAN3d3fUqVPnp6wH7ty5U0r1TWIEGBgYgM/ng8PhoFmzZtiyZYtSvxPLly+Hurp6kQOAv78/mjZtqrRrSdL71qxZwxY2kWwWFhZset/Nmzel3LYfP36EmZkZfHx88OnTJwwdOhQcDge1atUqNtd5165dICKZ4zzEYjHevHmD48ePY/To0exSTsFlCQ6HA4FAwLroJUZCgwYNEBQUhOXLl+P8+fP4+PGjUgYqiQdLcr2Cywy6urrw9vbGn3/+ib179+LNmzfsNYOCgmBnZyd3Hx48eFCsxry8SOIQJMZ6+/btS/wuyeL6V3ZQWmpqKv7++2/4+/uzvzFJNkBxZXZjYmJgamqKatWqKeyZ/J0Qi8WYOHEiiAgjR47EkSNHIBAI0LJlS5nEpgYNGgRNTU3Exsb+hN7+e1AZA+VEUSpzQL5qmKmpKerUqVNmOdjo6GhWEGfatGnsYKIMjYKSePfuHXr37g0igr29PerVq8cOMhK50nbt2iEkJAReXl7gcDishvnhw4fLXDVx0KBB7NpuQbKzs6GlpYW//vpL4bZTUlJw6tQpTJ8+nV32IPpfep+3tzf7/+K8HkKhEF5eXjA3N5cK+rxz5w7rxu3Vq1ehmXJMTAyICDdv3pTaL8lM2L9/P2bPno1evXqhdu3aUqI8fD4ffD4fPXv2xJw5c3DgwAEpUR6hUIhnz57hwIEDmDVrFnr06AEnJycpNT8jIyM0atSINRLOnTsnl5Fw/PhxNgODy+Vi/PjxyMrKQkpKCs6dO4ewsDB06tQJVlZWUnEQfn5+bIqmPNocEvr06QMzMzO5VQd/5NatWyAidlBduHAhtLS02M9QLBbj9u3bxbr+9+3bVy7qfFlZWdi/fz86d+7MVm5s1KgRVq5ciU+fPuHy5cuws7ODtrY21qxZU+Tf6+XLl6hcuTIqVapUYprd705OTg569uwJIsLixYsREREBPp+Pjh07yrQsKnlGbty48Sf09t+FyhgoR3bv3g0iKpTvfv/+fRgYGKBhw4ZlfoDl5ORg+vTp4PP5UFNTg4eHR5naK4nU1FRMmjQJGhoaMDY2Rt26ddlZye7duyEWi/H582eEh4fD2dkZRAQzMzMMHToUY8eOZfcZGRkhKCgIV65cUciDUbdu3SLlYs+ePQsikgpOKwmGYfD8+XNs2bKFrd4nmWlJ0vvCwsJw6dIlqZQuSbS2pqZmkbEQEonpojwAYrEYmzZtQoUKFaCjo4NFixaxg82nT59ARBgyZAgryuPo6CilWWBkZISGDRtKifK8evUKpqamCqXCSYyEgwcPYvbs2ejRowecnZ2ljARDQ0PWSFi2bBnOnTuHDx8+sIPOu3fv2HLTRPn6FKXNuj59+oRjx45h+vTp8PPzY/PdifJT3jp16oSwsDCcPXu2VK2NuLg4qKmpYd68eXLff0ESEhJARDh+/DgA4Pr16yAiTJ069ae4/guSl5eH48ePIyAggDVI3dzcsHDhwiJLoKelpWHIkCEgIrRq1QqJiYmFjvn48SNcXV2hr6+Py5cvK73P5U1ycjK8vLwgEAiwd+9ebN68GVwuF71795YpMPLly5fQ1dUtNEFTkY/KGChnhg8fDnV19UJa9jdu3ICOjg6aN2+ulGpfkydPZh+mI0eOVOqauVAoxNq1a2FqagqBQABnZ2dwuVxYWVlh48aNRf4QGYZBTEwMRo4cyQaQSdyno0aNYmeHNjY2mDRpklR8RWl90dDQQHh4eKH3xo0bBzMzs2J/6JmZmYiKiiqyel+tWrUwZMgQbN26FS9evCjxYcEwDPvg1dPTk6pwJ3E1L1iwoNjzk5KScOLECfj4+ICIoK2tzUoIF1yCaN68OUaOHInVq1cjKipKKnOgIBLBInn1LEpCKBTi+fPnrJHQs2fPQkaCgYEBbGxs2DgFDQ0NLFq0SCFdd4Zh0LlzZ1SqVAnjx4+Hj4+PVMxB1apV0atXL4SHh+Pq1auF8u1HjhwJfX39Ms3M8/LyQJSfzx8SEgIHB4ef4vqXIBKJcPHiRQwZMoT9zTg6OmLmzJkl5soX5MSJEzA3N4eBgQF27dpV6PuSmpoKHx8faGhoFCl3/Lvy5s0bVK9eHUZGRrh69SqWL18OIkJQUJBME4rc3FzUqVMHVapUUY1PxaAyBsqZnJwc1KtXD7a2toVK4EZFRUFDQwNt27Yt0wMmNTUVJiYm6NevH5YsWQItLS1YW1srRVrz5MmTbL17BwcHqKmpwdTUFMuWLZPZiMnJycH+/fvRunVr8Hg8CAQCdO/eHQsXLsTgwYNhaGgIIoKrqysWLlxY5KxGQmxsLIgIFy5cKPSek5MT6zGQVO/bvXs3Ro4cibp167IzbF1dXbRo0aJQep88iMVidOzYERwOBxUqVMCbN28QFxcHAwMDtG/fHmKxuEhRnoLiQhKDSnL/9erVg6urK9q0aSNXXyTCND9jtiMxEmbNmsX2WzJgFvQkNGzYEEOGDMHSpUtx9uxZvH//vtT+SQwpiQqeWCzG06dP8ffff2PkyJHw8PCQymBwdnbGoEGDsHbtWpw5cwZaWlqsLLis/Oj6l9yDxPVfo0YNtG7dWuHPqzQYhsGNGzcwatQodonF1tYWEydOxP379xX6m3779g09evQAEaFr166F4pOys7PRpUuXn16dUVHu3LkDMzMzVK5cGc+fP8fcuXNBRBg7dqzMn8+YMWOgpqam9GJw/59QGQM/gbdv38LQ0BBt27YtZMWePHkSampq6N69u8KVsqZNmwYNDQ1WpjYuLo6tsBcQEKBQ4ZKHDx+iZcuWrNtWIBDAwMAA8+bNK9PSxocPH7BgwQI24MrS0hLjx4/HqlWr0KVLFzbYrWnTpti0aVOhgVqy5vfjDDAuLg5EhD59+qBr165S6X329vbo27ev0qv35ebmstLRRkZGqFixInR0dFCnTp1iRXlCQ0MLifIwDINt27ahYsWK4P9TRlnWtNDU1FRoaGgUKthUXnz48AHdunVj783GxgYXL16EUCjEixcvcOjQIcyZMwe9evWCi4sLO3hLPAkNGjTA4MGDsXTpUpw5c0bKSMjOzoaOjk6JAk95eXm4e/cu1q1bh8DAQLi4uLBBijweDxwOB/3798e2bdvw5MmTImeNxUX9t2vXDpUqVULv3r3ZPk2ZMqVYpUtFYRgGDx8+xKRJk2BnZ8cup4WEhCi1WNiePXvY7+WPqbYikQjDhg0DEWHOnDm/rdtckiVQv359fPr0iQ0cnDFjhsx9joyMBBFhyZIl5dzbfzcqY+AnIflCFhXcdvDgQfB4PAwcOFDuNfQPHz5AS0sLEyZMkNrPMAw2b94MAwMDmJiYYPfu3TL9eD5+/IjBgweDw+HAyMgIWlpa0NbWxpQpU8pUJ+FHGIbBzZs3ERwczKr8NWzYEMuWLcPKlSvRtGlTNhK+S5cuOHToEHJycjBhwgRYWlri8+fPOHz4MMaPH49GjRqxwVwF0/sOHz4ss3JfaRQU5QkNDUXXrl1Rq1YtKbe5xK3br18//PXXXzh69Chevnwps/Hx/ft3dumgatWqMqnrbd68GRwOp8R6BcpAKBRi2bJl0NLSApfLBZ/Px4wZM0o1WkQiEV68eIHDhw9j7ty56NWrF1xdXYs1ElxdXVGlShW2LLgsZGZm4tq1a5g/fz7U1dWlsil0dXXRuHFjdOrUCa1atULlypVZr0xRrv+WLVtKFUGSLMHI6qYviZcvX2L27NmsvLChoSEGDx6M8+fPl1vJ3A8fPsDf3x9E+bVOCj6bGYbBrFmzQEQYMWLEb6dIuG7dOvB4PLRv3x7p6ekYMWIEGzgoK4mJiTA2NkabNm1+W4Pnd0FlDPxEJk2aVGxg2fbt28HhcBASEiLXl1ayvljcQP3x40d06dIFRPniP8UVLcrKysKcOXOgra0NTU1NaGtrQyAQYPTo0UobUIsjOzsbERER8PX1BYfDgaamJvr06YOIiAgsWLCAlbDV0tKClpYWG1EtWVvv1q0bXF1dUb169TJnKigiyhMSEsK+5+TkVKYskXPnzrFLBkT59RxKSgfz9vZGs2bNFL6eLFy/fp1dKiIiNGnSRCE1zYKIRCK8fPmSNRJ69+4NV1dXKTElfX19eHp6IjAwEOHh4Th9+nSpRsKSJUtYLYiBAweyOfgFDTZdXV00a9YM06ZNw9GjR6UyPvr27YsGDRqw/09NTQWXy8WmTZsUus+EhAQsWrSIDbbV1tZG7969cezYsTJ/V2WFYRhs2LABOjo6sLGxQVRUlNT7En2Fbt26KU2orCyIxWJMmjQJRIThw4cjNzcX/fv3B4fDwbp162RuRyQSwcvLC5UqVfp/p7FQHqiMgZ+IJOXMzMysyDoDEnnMyZMny9TekydPwOVyZXJ/HTx4EObm5tDV1cWaNWvYWYBYLMb27dthYWEBLpcLbW1t8Hg8DBkypFjDoTxJSEjAtGnTWDe/hoYGO/su+FCXSCE/evQIIpEIhoaGmDp1qkzXYBgGnz59wsWLF7Fq1SqMGDECzZo1k9JMkKzdlibK8/jxY2hpaaFz584wNTUFl8uFh4eHXMWFCpKYmAgiwpEjR7Br1y6Ym5tDU1MTs2fPLhSj8fbtWxBRqVXqFCUpKQmDBg1iZ9KGhobYsWNHuc6wvn//DnV1dfTr1w/z5s1D7969Ubt2bSkDsKCRsGTJEpw+fRo3b97Exo0b2bXwgq5/SdT/x48fERkZidDQUPj7+0sVVbK0tETHjh3RpEkTmJmZSRnXrq6ubAEjWfjy5QtWr17N6lIIBAJ06tQJe/fuVfh7oQzi4uLQpEkTcDgcjB49Wkpw58CBAxAIBGjWrJnSJJgVIScnB7169QIRYdGiRcjJyUHXrl3B4/GwY8cOudqaMWMGuFxuIeNHRdGojIGfTEExmqJcg4sXLwYRYe7cuaW21b59e9ja2spszaekpCAwMJCd3e3YsYMtQKSlpQUOh4PevXvj5cuXct+XovyY3lerVi120NfX14e1tTVrDEiKJ02ZMgVDhw5lI64ltQ9+rO5YUJRn0aJFGDRoEBo0aCAV+Mbn81G9enV06tQJU6ZMwY4dOxATEyNTXERaWhocHBzg5OSEzMxMxMbGQldXF1wuF82aNVNolsUwDHR0dNhshLS0NIwbNw58Ph9VqlSRqlc/d+5caGlpKf3hLRaLsWHDBhgYGLDr8YGBgYUCYMuLDh06FEqRlXgSjhw5gnnz5qFHjx6oUqVKodoJ2trasLa2ZteIExISijVeGIbB27dvsW/fPjaDoeDyhSSDoVGjRrC0tCxxIP/+/Tu2bNkCX19f8Hg88Hg8tGrVClu3bi2znogyEYvFWLx4MQQCAapXry4VUBcVFQU9PT24ubmVuzewKH5MHczKyoK/vz/U1dVx6NAhudqKiooCl8vFjBkzyqez/w9RGQO/gIsXL7LFRopi5syZIGNjjNi4ESeTknAhORmJOTlSD7UrV66AiOS2loH8evASwRpJhH3Hjh0VqqwoLwXT+9q2bVtsel/B/O3MzEzs2LGDLROsqamJ/v3749y5czh8+DC7BiuZzdevXx/Ozs5SojxaWlpwc3ND7969ixTlkReGYdCjRw/o6upKrSdHR0dDQ0ODlUlVpDBM3bp1MXDgQKl9sbGxaNq0KYgIbdu2xatXr+Do6IjevXsr1P/iuHfvHrtEweFw4OjoiKtXryr1GqUhKcNc0DMlifqfO3cuvLy8pAR/unfvjvHjx2PatGno06cP3NzcCikuenh4YNCgQVi8eDFOnTqF+Pj4Io0ESYDq2rVrMXLkSHh6erLX4nK5cHJywsCBA7FmzRpcvXoVO3fuRIcOHaCurg4OhwMvLy+sWbMGX758+ZkfmdzExsbCzc0NPB4PoaGh7O/g/v37MDMzg729fZlKgMvL27dvUaNGDRgZGeHKlStIS0uDj48PNDU15a4P8fXrV1SqVAleXl7lFovx/xGVMfCLCAsLAxHhxIkTAPIHl+vfvyPgyRNUuHIFdPFioc34yhX0jI3F5ZQUuHt4yF2xTVJRkMfjSa3NVqtWDTExMUq/x4LpfSEhIUWm902fPh2nTp2SKThx7ty50NDQQMeOHdmgw4L3UfD/kgf3lClT8OzZM6UHR61cuRJERVc8O3HiBBvZ3qdPH7mv3bt3bzRs2LDQfknhH0tLS/Y+jx49qvA9FOT79+8ICQlhgwPV1dUxf/78X1LjPSUlBWpqapg5c2axUf8rV64sUQ/iwIEDICLMnDkTYWFhCAgIgJubGyuZLfkOuru7Y+DAgVi8eDFOnjyJffv2gYiktCMkmSpBQUEYOHAg7OzspIwNbW1tNGzYEEuWLEFsbOy/ZgDKy8tDaGgoeDyelFBUXFwcqlatiooVKyq1wFhxxMTEwMzMDHZ2dnj27BmSk5Ph7u4OPT09XLlyRa62GIZB69atYWxsXGKKsorCqIyBX4RYLEabNm1gZGSEsy9fov6dO6CLF8GPiirSEJBs7Pvr1mGdjNKtubm5CA8Ph46ODrue6unpiaioKNy+fZstMCORj1WU3Nxc3Lx5E+Hh4UWm9wUEBGDNmjV48OBBiQ/MpKQkXLlyBevXr8fo0aPRqlUr2NjYSA36FhYWqFOnDqpVq8bua9y4Mf7++2+8evUKixcvZosp6evrIzAwEBcvXlSKUXDz5k2oqamVqPi3Y8cOtl/BwcFyrbPPnj0bxsbGxb6fnp7OLu/Y2Njg8OHDCq/jMwyDnTt3wsTEhHW5t2rV6pfUdy+o9S8pfMXlcuHu7o5p06bJJfjDMAw8PT3h5uYm9TcXi8V4/fo1jh49ivnz5yMgIAB16tSRMhKI8sssDxw4EIsWLUJkZCQqVKiAmjVrskZojRo1MGTIEEydOhV9+vRhBYokBouXlxfGjRuHPXv2IC4u7reOZL99+zYcHR0hEAiwePFiiMVifPnyBXXr1oWurm6Rmh7K4sSJE9DW1ka9evXw6dMnfP78GS4uLjAyMlJIRGvJkiUgIqnlNBWyoTIGfiFJSUkwHDwYnHPnwC/BAChq45w7B35UFOa/e1fimujBgwfZMsOSaPcTJ05InZOXl4c5c+ZAXV0dVatWlTng5sf0PkmQl4aGBho1aoTx48cXm97HMIxMojz29vZo27Ytxo8fDwsLC3Ts2FHq+yWZyS1atAheXl7sjC8wMBDXrl1DbGwspkyZAltbWzZQbPz48Xjw4IGcf618kpKSYG1tDQ8Pj1KjwZcuXcrey/jx42UeECT3VFwEdF5eHipUqICBAweyWhB+fn5yR/g/efKEFdrh8XgwNTXFvn37ftrAJRKJinT929jYoHHjxuBwOHj27JnC7UsqeO7Zs6fUYyVGwp49e0CUr/3v4OAgJQVNRKhUqRI6dOiARYsW4cSJE3hX4Pf3/ft3nD9/HvPnz0fnzp3Z2AVJwKuvry+mTp2KI0eOlKlyaXmQlZWF0aNHg8PhoEmTJoiLi0NaWhpatGgBdXV17Nu3T7aGxGLg+XMgMhI4cAA4fhx49Qoo4ju1fv168Hg8tG3bFhkZGUhISICDgwPMzMwUWrKUlBofPXq03OeqUBkDvwyGYTDx9Wu5DIDitj+KcJfevn2bnRkTEezs7LBv374SZ8ZPnz5Fw4YNQZSvj18w8EkkEuHBgwdYs2YNAgICUKVKFakHZNeuXREeHl6oep8kz/zIkSOYP38++vXrh/r168slygPkRxnz+fxCdR4CAwNRvXp19v+vXr3C9OnTWU9CtWrVMG/ePMTHx+PatWsIDg5mXc61atXC/Pnzi9R6LwqxWAw/Pz8YGxvLnNc/ZcoU9j7nzJkj0zmPHj0CERXrIpUo9T148IA1+CSBlpMnTy41+DEjIwMTJkxglwOI8vPMf0agW3x8PDZu3Ihu3bqV6Pr/8uULuFwu1q9fX6br+fv7y1zimGEY3Lt3D2pqamyQaaVKlTBw4EA2Pbdnz56oW7euVDyKpETwgAEDsHDhQpw4cQJv374FwzD4/Pkzjh8/jhkzZqB169ZSxq6FhQU6dOiAuXPn4syZMz8tQLMkLl68CBsbG+jo6GDDhg1sYaASK0OKxcDp00D79oC2NkBUeNPVBbp0AS5eBCMWs/Lpw4YNg0gkwqtXr2Brawtra2uFAphTU1NRpUoV1KlT56elbP5/Q2UM/CJWJiYqxRCQbAv/GdDi4+PRvn179oFTsWJFbN26VeZ1TLFYjFWrVkFbWxtGRkbo3r27VPU+Ho+HunXrIiQkBBEREezMSBZRHl1dXdSvX18hUZ67d++CiKQqBTIMA0tLS4waNarI+zh//jz69OkDTU1NcLlc+Pr6IiIiAqmpqTh69Ci6d+/OejOaNGmC9evXl/hAnj17NjgcjkxiQAX7OHjwYHZ5ZtmyZaWek52dDS6XW2xltS5dusDFxUVqX2ZmJqZNmwaBQAArKyvs37+/kIHIMAwOHToES0tLdknAxcUFt27dkvl+5CU9PR3Hjh1DSEgIHB0d5XL9+/j4wNfXt0zXv3//PhsQWBzPnz/HjBkzpPrn4uKCqKgo9rspkcE+d+4cgPzvV1xcHCIjI/HXX3+hX79+xRoJ/fv3x8KFC3H8+HG8efMGb9++xf79+zFhwgQ0bdoUenp6UstpPXv2xJIlS3DlypUyFzJThNTUVDaltHXr1khMTMQff/wBIkJoaKj09+rGDcDRMX/A5/OLNgQk2z/vvzUwgAsRFi5cCIZhEBsbC3Nzc1StWlUh8ayCwbyvXr1S4ifx30JlDPwCXmRmQlBSbMD27SAfH1CFCiCBAGRlBerfH3TyZPGxBBcvotfkyexDXl9fHytWrJDJSi6Y3jdkyBCp9D7J7GjKlCmIiorChw8f5BblOXv2rFyKckUhUdorWIBJ8oAurQZDamoqNmzYwHo9DAwMEBwcjJs3byI1NRXbtm1DixYtwOVyoa6ujg4dOmDfvn1SnomzZ8+Cw+EgNDRU7r6LRCJ06tSJdTlv3ry51HMqV66MsePGIVskQo5YzH52ycnJEAgEWLRoUZHnvXr1Cq1btwYRoUWLFmwg3OvXr1klOoFAAE1NTYSHhyuU7VASJbn+5S3zu2LFCvD5/DLPmHv16gVzc3Op1MB3795hwYIFqF27Nmuo9u3bFydOnECDBg3Qp08fqTbEYjGMjIxKTVWTpLNGRkZiwYIF6NevH+rVq8fGQEiMhHr16qF///5YsGABjh07hnPnzmHbtm0ICQmBp6cna6T+mMFw586dnzbzPXbsGCpWrAgjIyNERESwQc9BQUEQ5eUBU6cCHA7A45VsBPywCYkg5nKBefMQc+cOKlSoACcnpyK1V2Rh06ZNICLs3r1byZ/AfwtZx28OAFAppKWlkb6+PqWmppKenl5ph/9n8bl3j66mppKoqDe/fCEaNIhIW5uoXTsiXV2iJ0+ITp0iatCAaO7cohsViYiePyfNP/+kKVOm0OjRo0lLS6vIQ7OysujOnTsUHR3Nbt++fSMOh0M1atQgT09PqlWrFhkaGtLFixcpIiKCRCIR6ejo0Pfv39l2bGxsqEaNGlS9enWpzcjIqMyf0Y+MGjWKjh8/Ti9fvmT3hYeH0+TJkyk5OZk0NTVlaufFixe0bds22rZtG71//55q1KhB/fv3p4CAAAJAe/bsoZ07d9KdO3dIX1+fOnfuTL6+vjR8+HCqXbs2nTx5kng8ntz9z8nJIT8/P4qOjiahUEh79uyhrl27Sh0DgKLT0ijiyxf6OyaG0k1MCP9cS5fHIzcdHdKKi6NTY8bQ+xs3yNzcvNjrRUZG0h9//EHx8fHk4eFBt2/fJg6HQzk5OdS+fXtasWIFWVlZyX0fRZGQkEBnzpyhM2fO0Pnz5+nbt2+ko6NDTZs2pZYtW1LLli3J3t6eOByOXO2+f/+eLC0tadu2bdS3b1+F+xcXF0cODg40fvx4Mjc3p927d1N0dDRpaGhQmzZtqGfPnuTn58d+h7p160YpKSl09uxZqXbatWtH2dnZhfbLAsMwFB8fT0+ePKHY2Fip18zMTCIi0tbWpho1alCNGjXI0dGRtLW1KTMzk+Li4ujOnTv06NEjEolEpK6uTi4uLlSvXj12c3R0VOh7WRpJSUkUHBxM+/fvpx49elCDBg1o9KhRdNLamlq8fVvm9lepq9M2Z2c6dfq0Qs+NJ0+eUN26dalXr160cePGMvfnv4ys47fKGFASjzIyyPnOneIP2LGDaNMmos2biezs/rc/LIzozBmio0fzDYRiuOjgQN4/DBIJCQlSA//9+/dJJBKRtrY2ubq6krW1Neno6FBOTg69fv2anj59SikpKURExOfzqXLlypSdnU0JCQnk5ORE8+bNIx8fH9LW1i7TZyEPPj4+ZGxsTPv372f3+fr6EhHR6dOn5W5PLBbT+fPnacuWLXTo0CESiUTUqlUrGjBgALVt25bevHlDO3fupJ07d1JcXBxxuVwaOnQoDR48mFxcXOQe2Ijyfx/e3t707NkzysvLo6NHj5K/vz8RER1NSqJJcXH0JCuL+BwOiYr7uYnFRDwe+RgY0JIqVci1hO/CsWPHqH///pScnExEREZGRrR582Zq37693H0vSEZGBkVFRdHZs2fpzJkz9OzZM+JyuVSvXj128Hd3dyc1NbUyXYeIqEGDBmRqakqHDx9W6PyUlBQ6dOgQhYaGUmJiIvH5fPL19aUePXpQ+/btSbeIzy8kJIQuXLhAjx8/ltq/YMECmjVrFn3//p34fL5C/fkRhmEoISGhkIHw5MkTysjIIKJ8I6F69erk4OBA+vr6JBaL6cuXL/T06VN6/vw5ASAdHR1yc3OTMhDs7OwU+p7+CADavXs3DR8+nDQ1NWmngwP5REWVuV0JOfPmkcakSXKfl52dTfXr1yexWEy3b9/+qc+j/4+ojIGfzIgXL2jdhw9FewWIiNavJ9q9m+jwYSJ9fen9e/YQRUYSFTML5nM41MfEhIIzMqQG//fv3xMRUcWKFcnMzIzU1dUpPT2d4uPjKSsri4iItLS0yNHRsdAs397enn2oHz9+nIKDgyk5OZnmzp1LI0aMKJfZyI8AIGNjYxozZgxNnTqViPIfBEZGRjR37lwaM2ZMmdr//v07RURE0NatW+nmzZtkbGxMvXr1ogEDBtD27dtp+fLl1L59e7p8+TIlJSVRzZo1qXfv3tSrVy+ysbGR61qfP3+mhg0b0qdPn0gkEtH+U6dot6kp7fryhTiU70eWBcmnPs3WlqZYWxOfy2XfS0xMpNGjR9P+/ftJW1ubsrOzqXLlyvTq1Svy8fGhFStWUM2aNWXus1gspnv37rGzf4l3w8bGhh38mzZtWi4eocWLF9PUqVPp69evpKOjI9M5mZmZdPToUdq9ezedOnWKRCIRNWjQgG7fvk1BQUG0fPnyEs8PCwujRYsW0bdv36T2R0dHU8OGDen27dtUt25dhe9JFiRGQlGehIJGQrVq1cjExIR4PB6lpaXR27dv2d+7sbEx1a1bV8pAKMmbVBrv37+nsK5dadn161TUrz6KiHyKOfc6EXkU17CaGtHDh0SOjnL1Z+jQobRt2za6desWOTk5yXWuisLIPH4rc83hv4z99eslBwP+9Vf+2mKDBqANG0B79oCmTQNpa4O6dCk9mPCf1CgejwdjY2MYGRlJSbYaGRmhYcOGCAwMxOLFi3HixAm8efNG5vz7tLQ0DB8+HEQEDw8PVqikPHn37h2IpAV2Tp06BSJS+vVjY2Px559/wszMjP3MOnTogC9fviAvLw+RkZHo2bMnm5feuHFjrF27VuZ1cCB//d7MzAzalpbgbNsGbhkCRzkXL6Ljo0fIE4uRl5eHhQsXssWmiPILHkmEY06ePAl7e3vw+XyMGTOmxN/pu3fv2Kh/ieyzrII/ykQi+FNaemBOTg4OHz6M7t27s0F8Hh4eWLp0KZvGN3XqVGhoaJQqRrN582YQUSE56ZycHAgEAoSHh5fpnsqCRMjrxIkTWLRoEQYMGAB3d3ep7BxNTU3Y29vDxcUFjo6OrDYCFchgmDNnDk6fPi3X9xYMA8bVNX+9v4hYgIv/XCOECNt/2L6WFljYpIlcn8PevXtLDQxVIR+qmIGfSIZIRHpXr5Y++9u+nWjnTqLc3P/t69MnP5ZAFtq1Iws9vUKz/Bo1apCJiYlSXIdXr16lwMBAiouLoylTptCkSZNIXV29zO0WxbFjx6hdu3b07t07sra2JiJiZ77x8fFKuZ8fefbsGdWpU4cMDQ3p8+fPRETUpk0b6t+/P/n7+1NOTg4dPnyYdu7cSWfPniUej0d+fn7Up08fatOmTakxDDcePKCG9+4RY2VFVEbvCoeImhHRhxEj6OmTJ6ShoUF8Pp/mz59PQUFBUt6b3NxcWrx4Mc2ZM4f09fVp4cKF1Lt3b8rMzKSoqCg6c+YMnT17tlxd//Li5uZGVatWpT179kjtF4lEdOHCBYqIiKCDBw9SamoqOTs7U8+ePal79+5kV3CZjYhSU1OpSpUq1KlTJ1q/fn2x1zt16hT5+flJfd8kNGnShExNTaWWq34HABTrSUhPTyciInV1ddZ78/37d8rJySEioipVqkh5D9zc3Ip2uUdHEzVsWGwfoijfM7CPiLoochMPHhA5O5d62Js3b6h27drUsmVL2rNnT7n8/v+LqJYJfiKlxgtIOHs2f2vShEhPj+jGjfwAwpEjiTp2LPX0Hbq61NDYmHg8HnG5XJlfuQVczbKQk5NDc+bMob/++oscHR1p48aN5O7uLlcbsjBnzhxavHgxJScnsz/8GjVqUIMGDcolaCg7O5s8PT3ZQEuhUEi7d++mLVu20N27d8nExIT69OlDAwYMICcnJ/r06RMbeHj79m3S1dWlzp07U58+fcjb27vIpZQ/Xr6kFe/fl2wYvnhBtG0b0aNHRHl5RObmRG3aEHXuXOThmosXU3ZkJHXv3p3Cw8NLdAm/efOGAgMD6cKFC6Svr0+ZmZkkEonIxsaGfH19qUWLFuXm+peXuXPnUlhYGH39+pUEAgFFR0fT7t27ad++ffT161eyt7ennj17Uo8ePahGjRoltrVkyRIaP348xcbGkoODQ5HHPHjwgFxdXenGjRuFvs9TpkyhTZs20cePH/8VgxAASkxMLGQgPH78mF1u4PF4pKGhQTk5OSQWi4nL5ZK9vT01aNCA6tevT/Xq1SNnZ2dSDwzMX8IUFb3IGUX/MwZ8iUiTiGSOrODziYYMIVq1qsTDhEIhNW7cmD5//kz37t0jAwMDWa+gohRUxsBPJCY9nerGxJR80IULRAsW5HsHTEz+t/+vv4iioogiIqRjCYpi5EiiH4KfZEUe40HyKgloys3NJSMjIzI3Nyc+ny93O8W9XrlyhXJzc6lNmzbE5XIpKyuLduzYQX5+fuTg4KC060heN2/eTNeuXaOwsDCytbWVev/du3d0/vx5On/+PKWmplLVqlWpdevW1LJlSzIyMmIj60+ePEmJiYlkYmJCrVu3pvbt21OtWrWIx+PRPaGQOn/4UPIf4vZtoilTiOztiXx88uNEPnwgYhiioUMLH88wxMnNpV0cDvVo1arIJuPj49mgv3PnzlFycjJpaWkRl8ulzMxMCggIoKVLl5KhoaFC353y4unTp1SjRg3q0KEDxcTEUEJCAllaWlKPHj2oR48e5ObmJvPAnJOTQ9WqVSN3d3fat29fkcd8/vyZzMzM6PDhw4WCLU+ePEn+/v708uVLsre3L/O9/SokRsKPBsKjR4/YOCIOh0OSxz6Px6MPRGQqFhfbZhTlGwM6RJRB+XEtjYloIRHJFGFRtWq+AVwCEyZMoCVLltDVq1fLZeLxX0ZlDPxEnmRmUs3bt0s+6I8/8iPGV66U3n/lCtH06USLFhHVqVNiE5X/+os4L19SVlYWZWdnU3Z2NuUWXHIoBoFAUGhTV1eX2tTU1KQ2Pp9PfD6fuFwuvXjxgu7fv0+amprk7e1NVlZWJBaLiWEYqdei9pX0euvWLTIwMCBra2tiGIY+f/5MCQkJVL16deJwOHK39+MrwzClfjZKZe5covr182dDRZGZSRQQQFSrFtGMGUSyemwYhnT37SOD48dZT09OTg5lZ2dTVlYW5eXlEVF+sKi+vj4ZGBiQnp4e8Xg8+vjxI7179454PB5Vq1aNLC0ticfjKd3Qkuf18+fPdOfOHbp16xZ9/vyZ1NTUyNvbmxo1akTVq1dX2OA8evQohYaG0p49e8jV1bXQ+0REtra2FBYWRoMGDZJ6Pz09nczNzWnTpk00YMCAf4V3QB4A0Pv371kD4cGDB3Tnzh1KffWKEkp5hkQT0RIi8ieiCkT0hIgWEVHmP+/VLu3iXC5RaipRMYGikuWbBQsW0J9//infjakoFZUx8BPJEYtJ58oVKt62JqK+ffN/DKtXS++/eJFo1qx8D0H9+sWfD5DDmDG0cuFC8vDwYCOwxWIxZWZmUkZGBqWnp1NGRobUv0t7/XFfeno6iYpxF0rgcDikr69Penp6pKOjQ7q6ujK9Fvw3l8ulOnXq0KpVqygoKIi4XC516dKFPnz4QNHR0bJ98KWAfFEtunv3LjVq1Ih69uxJK1askNmY+PLlCx07dowOHjxIL1++JGNjY/L39yd/f3+ysbGh3NxcunXrFp05c4auPH9Oedu2lTzAHz1KFB5OtHUrkY0NUXY2kUBQulEAkFZODtVftIjiXr2ixMREYhiG9PT0yNramqysrKhSpUqkrq5e5L1kZGTQ3bt3KT4+noyMjMjFxYV0dHTKZGjJ+yoSiUgkEv18A01BOBzOLzOWyvuVw+Gw3gHzd+8o4Mdnkgy8IiJnImpCRKdkOeHxY6IiMl0+fvxILi4u5ObmRidOnJB7SVNF6aiMgZ+M061b9PgfN1yRTJ5MdOdOvtZAQVGYadPyA3j27CGqUKHY09W/fqW8bt2IKP9B5eTkRB4eHuTu7k4eHh7k6OiotB9Sbm5usQZEZGQkRUREEI/Ho5YtW5KlpSVlZmaWaGRI1jBLQktLi7Kzs8nQ0JDVR1DEyJC8CgQC4nA4lJqaSnXr1iUdHR2Kjo6WWcSoIADo3r17tHXrVtq5cyclJydT/fr1acCAAdSjRw8yMDCgZXFxNOrdO6KSZpShoUQxMUQzZxItW0aUkECkoUHUsiXR8OFEpQRqao0aRc0LpP3JK/hz8eJFGjFiBD179oyGDh1Ks2fPLtfYgY8fP9LevXspIiKCbty4QZqamtSuXTvq0aMHtWzZktTV1enu3bvk7u5Ohw4doqZNm5bZ6Lhw4QJNmjSJFi9eTG5uboXeDwkJoSpVqlBQUFCh87ds2UKxsbE0d+5cKSNGKBQWu0neL/gqEolILBaTUCgksVjM7pPsl2wF/1/Qu1bQs1Xw3z9uAAq9FrcRERX1qG9MRJcV/Pv2JKKDRJRFVGRKohR37xLVlvYhiMViatmyJeupMDU1VbAnKkpCZQz8ZCa+fk2LEhKK9w48eEA0Zkx+XECHDv8LILx5k6h1a6Jx44ptm09EIywtqeH9+9SjRw928L958ybFxsYSANLT06P69euTu7s7u5XXj+vDhw80fPhwOnz4MHXo0IFWrVpFlSpVKvZ4hmEoKytLymDYuXMnLVu2jLZs2UJ5eXn04MEDWrFiBfXp04f09PRK9WhIXOPFwefzSUdHh3Jzcyk3N5ecnJzI2NhYYSNDR0eHeDwe5ebmUmRkJG3ZsoVOnTpFfD6fOnbsSCmBgXSezy9eVIgoP2tEElPg50fk6kp0/z7RoUNETZvmG4YlsKZKFRpaRnVBoVBIK1eupNDQUBIIBBQWFkYDBw5UiiHJMAx9+vSJDhw4QPv27aOrV68Sn88nLy8v8vf3p8aNG5NAIJAaTPPy8qh3797k4uJCwcHBRQ608u47fvw4MQxDXl5ehY59/PgxASAbG5tC56enp1NaWhppa2tLDeblwY9Lcj8u0xW3vyz7itpvGh9PLSZPVugexlN+3EAqEZU6Kjx9WkhvYO7cuTRt2jQ6e/YsNWvWTKE+qCgdlTHwk3mTnU1Vbt4sOYr86dP8KPKXL4nS0vKjyFu2JOrZs9Q0tGh7e/K0tKQdO3ZQ3759aeTIkbR06VJKT0+nO3fu0M2bN+nGjRt08+ZNNmXOzs5Oynvg6upKAoFAKfcLgA4cOEAjRoygnJwcWrhwIQUGBso8Ux06dChdu3aNHj16RERE06dPp1WrVtGXL19kEjzKy8srdUnkxIkTFBkZSW3btqWKFSuWulxS2k9BU1NTymBQV1entLQ0+vDhA6UvWFC6uErv3vnGQLt2RKNH/2//kiVEx47lB5daWhZ5Kp+I2gI0tJQZqqz7UlNT6ebNm/TmzRsyNDQkJycn0tHRUahNySbDo0RuOByO3INcZmYm3b9/n2rXrk1WVlZSx928eZNSUlKoW7duhc7NysqiRYsWUf/+/cnNzU3pA69kn8RV/7MRiUT0/PlzevDgAT148IDu379Pr+7do5dfv5IipmAXIjpO+bEDJZ7P5+fHyxTwfF29epW8vb1p0qRJNHv2bAWurkJWVMbAL6DL48d0OCmp5NgBOeEyDHFiYkhz1iwaO3YsjRkzhnbv3k1Dhw6lyZMn09wfahoAoPj4eNYwuHHjBt29e5dyc3NJXV2dateuzXoOPDw8yixtmpycTOPGjaMtW7aQj48PrV+/XqZobE9PT6pSpQrt2LGDiIjc3d3Jzs6OIiIiFO5LQaKjo8nLy4tGjRpFCxcuLPV4hmEoOztb4XiLqAEDKM/MrOSLDBhA9PYt0dKlRC4u/9v/4AHRqFFEEycS/SPFXAiRiOj06fxA02LgcrlyD1yZmZn08uVLysjIIBsbG3J2diYdHZ1SzyfKrw3w8OFDevLkCQmFQqpSpQp5enpSgwYNyMTEROaB89GjR9SpUyc6dOgQeXl5FRo4FcHPz49ev35NsbGxUhoK06ZNo61bt1JCQkKR59na2lLnzp1p8eLFCl33dyE1NZUePnxI9+/fZwf+x48fswHH1tbW5OLiQq6urjR+/XrS+WcCURRficjkh30PiKgeEfkR0ZHSOuPqSnTvHvvf5ORkVi49KipKaRLQKopG1vFb9VdQIiurVqVzKSmUJhbLLD9bIgBp8Pl0vU8f+vvzZ5o/fz6tXLmSJk+eTPPnz6eJEyeSjo4OTSqg/83hcMjGxoZsbGyoe/fuRESsG15iHJw4cYKVbjUxMZEyDurVq0f6paU4FkCii9+zZ08aMmQIOTk50axZs2j06NHF/sgZhmEHAKL8oim3b9+moUWl1inAly9fqFu3buTh4UHz5s2T6Rwul0va2tqkra1NFStWlPuaTrdv0+N/CtMUS4UK+cbAjyl+kv//IyJTFHw+n7p160ZhI0cWO8gq6uoXiUS0Zs0amjZtGl29epXmzp1LQ4YMKTQQC4VCOnfuHEVERNChQ4coPT2dateuTXPmzKHu3bvLLeEsoXLlymRhYUEXLlygDh06KNTGj4SFhVHt2rVpy5YtNGTIEHa/ubk5ffr0iRiGKfLzatSoEV29elUpffgZAKC3b9+yA77k9e0/xYbU1dWpZs2a5OLiQgEBAeTi4kLOzs5SsSK5376ReM0a4hUzL+xO+doCDYjIlPKzCdYTkRYRzS+tgzweUdu2Uv0dOHAgZWRk0K5du1SGwG+EyjOgZA58/UpdYmOV1l6lLVvo6owZZGdnRwkJCTRr1izasmULmZubU+3atenYsWO0fPlyGjlypFztJiUl0a1bt1gD4datW/T9+3ficDhUvXp1KQOhZs2aMv1oMzMzadq0abRs2TKqXbs2bdq0iVwKzoD/4eXLl1StWjU6c+YMtWjRgiIiIqhnz56UmJhIFhYWct3Hj4jFYmrVqhU9fPiQ7t27V2IsgzLp+PgxHU1KohJj5TdsINq1i2jxYiI3t//tv3uXaOzYfP2B5s2LPJVHRHMrV6YJPyjnKZPPnz/TxIkTaevWreTm5kYrV64kd3d3unLlCu3evZv2799P3759IwcHB1YMqDiBH3kJCQmhgwcPUnx8vNICYXv16kWXLl2ily9fspU+Dx48SJ07d6avX79ShSICdteuXUsjR46k79+//3YFcrKzsyk2NlZq4H/48CGlpqYSEVGFChXI1dWVXFxc2Fm/o6NjieqSCQkJFNysGUUWqBr6I8uJaCflZxCkUb6XoBkRhRJRqT5ALpfo3Tt2+WvFihUUEhJSpNaDivJBtUzwC1n7/j0Fv3wpV4GagkjOm6SnR/u6d6fU1FQ6evQoeXjklwR58eIFTZs2jfbu3UuGhoaUkpJCGzZsoMDAQIX7zDAMvXjxQir24OHDhyQWi0lLS4vq1avHGgfu7u4lDrI3b96kwMBAevbsGY0fP56mTZtGGhoa7Pv79++nrl270ufPn8nU1JQGDBhAMTEx9PDhQ4X7LyE0NJTmzJlDZ86c+alBSXPfvaPQN29KXiJ6+TJfja1ZM6J/CjMREdHs2USXLuULT5WQUXLW2Zma/wTlwOjoaBowYAC9ePGCtLS0KCsri6ytralHjx7Us2dPhas7lsSlS5fI29ubrl+/zn7Py8rr16/J0dGR5syZQxMmTCAiouvXr1ODBg3o4cOHRRbBefz4MTk5OdGFCxfIx6e48jzlz+fPnwvN9p8/f05isZg4HA5Vq1aNHfAlr+bm5nL9XR48eED+/v75SzWVK5Pu5cv5WijKgscj6tEjv2IrEd27d488PDxkKiqlQnmojIFfzKGvX2ng8+eULhLJFUPAIyJtHo/WOzhQd1NTSkpKoo4dO9KdO3do+/bt1KXL/9TB7969S1OmTKFTp/IzfSdOnEjz5s1T2oM6KyuLYmJipAyExMREIiKysrKS8h64ubmxsy+i/KWJ+fPn05w5c6hy5cq0ceNGatSoERERTZ06lZV+BUAWFhbUu3dvmdb2S+LUqVPk7+9Ps2fPpilTppSpLXm58v07Nbl/v/QDFywgOnmSyNs7P27g/v18Q6BXL6LBg4s9jQfQR3d3MinwGSubx48f0+7duykiIoLi4uJIT0+PcnNzic/n07x582jYsGHl5tYVi8Vkbm5O/fv3pwULFiit3eHDh9OuXbsoLi6ODA0N6e3bt2RnZ0enT5+mli1bFjqeYRi2kua0UrI7lIFIJKIXL14UGvglQcA6Ojrk7OwsNfDXqlWrzF6LM2fOUJcuXahq1ap0/PhxqpCbS+KqVUlNKFQomLAQHE7+8tfz50QVKlB6ejrVqVOHdHR06Pr160oLZFZROqqqhb8Bn3Nz0Ss2FtyLF0utYMf7p1Jd18eP8aGIqmq9evUCEeGvv/4qVFXu4sWLMDExARGhVq1aiI6OLrd7SkxMxIEDB/Dnn3+iSZMmbCU5Ho8HNzc3BAcHY9u2bXj27BnEYjEeP34MDw8PEBGGDRuG1NRUtGnTBr6+vgCABw8egIhw9uzZMvXr3bt3MDY2hp+fn8yVGpVJdnY2jE6cAJ0/X3JFwrNnQf37gypWBPH5IAsL0PDhJVcwPHcONGECTE1NMWnSJLx580Zp/X716hXmzJmDWrVqgYhgYGCAQYMG4dy5cxAKhfj69SsGDx4MDocDZ2dnXLlyRWnX/pHBgwejcuXKSq2a+PHjR2hpaWHixIkA8v9ORIRt27YVe07r1q3RokULpfVBwvfv33H58mWsWLECgwYNQt26daGhocFWHrSyskLbtm0xdepU7N+/Hy9fviyX7/KmTZvA4/Hg7++P9PR0JCUloXnz5ujO4RRfgVDejcMBjh1jrxkQEABtbW08f/5c6fejomRkHb9VxsBPIDEnBzPevIFHTAw0Ll2SetALoqJQ784dTIuLQ3x2drFtMAyDadOmgYgwePBg5OXlSb2fl5eHBg0agMPhgIjQtm1bPHz4sLxvDUKhEPfu3cPatWvRv39/VK9enX24GRoawtfXF1OnTkVQUBC0tbVhaWkJExMTjB8/HgCwYMECaGlpIbuEey+N3NxcuLu7w9raGklJScq6NZk5e/YsqlWrBk6HDqALFxQuW1zStvvePYwcORJ6enrgcDjw9/fHsWPHIBKJ5O5vYmIiFi9ejHr16oGIoK2tjV69euHo0aPIzc0t8pybN2+yx/fp04ctH6xMJOWrJaWZlcWUKVOgqamJ9+/fAwAMDAwwf/78Yo8PCwuDjo4OhEKhQtdjGAZv3rzBoUOHMGPGDHTs2BF2dnbs70JNTQ2urq7o378/wsPDcfHiRflKDisIwzCYPn06iAhDhgxhf7u2traoUKECzp8/D6xZ87/BXBEjgMvNP/fvv9nrbtu2DUSEvwvsU/HzUBkDvykihsHb7Gw8z8zE2+xsCOW0/Ldu3Qo1NTW0aNEC379/l3ovNzcXrVq1grq6OipVqgQOh4PevXvj9evXyryFUklJScGZM2cwa9YstG7dGhUqVJCqyU5EsLOzw5kzZ+Dt7Q1/f/8yXS8kJARqamq4efOmku5ANt6/f48ePXqwAypxuTDavx88ZRoC587Bcf16XLt2DQzDICMjAxs3bkTdunXZ2eTs2bNLHZy/fv2KNWvWwMvLCxwOB+rq6ujQoQP27NmDjIwMme5XLBZjw4YNMDY2hq6uLpYsWVLIKC0Lubm5MDAwwNSpU5XWJpA/IzcyMkJQUBAAoHr16hg1alSxx1+5cgVEhJiYmFLbzs7Oxp07d7Bp0yaMHDkSTZo0gb6+Pvt9NzY2RrNmzTBmzBj8/fffePDgQbEGV3mSm5uLfv36gYgQFhYGhmGwc+dOaGpqws3NDW/fvv3fwYcOQaSvD6G8hgCPB5iYACdPsk09e/YM2tra6Nev30+/ZxX5qIyB/8dcuHABBgYGqFmzpvSPGEBWVha8vb2hq6uLiRMnwszMDHw+H8OGDSuX2ZwsMAyDV69eYefOnejQoQP7oJRstra2GD16NPbs2YO3b9/K5Sbes2cPiAgrV64sxzuQRigUIjw8HDo6Oqybt27durhx4wYeZ2RAPSoKHCUYAryLF6F38iSsHBxARKhWrRrmzZuHhIQEAMDt27cxaNAgaGpqgs/no0uXLjh37hz7+aWmpmLbtm1o1aoVeDweeDwefH19sWXLlkKGpDx8+/YNwcHB4HA4qFmzJi5evKiMjxUA0LdvX9SoUUNp7UlYtGgReDwenj9/Dh8fH3Tv3r3YY3NyciAQCLBs2TKp/Z8+fcLp06exYMEC9OrVCzVr1gSPxwMRgcPhoFq1aujWrRvmzp2L48ePIzExUalLHory/ft3NG/eHGpqati5cyeEQiFGjx4NIkJAQACysrIKndPP3x/7tLTA8Hj5s/3SvAFqasDgwUByMttGdnY2XFxc4ODggPT09J95yyoKoDIG/p/z9OlT2NnZoWLFirh165bUe2lpaXB3d4eRkRFu3bqF+fPnw8DAAJqampg4cSKSC/xgfzbh4eEQCAR49eoVXF1dQUQwMTGBlZUVaxyYmZmhffv2mDdvHi5cuIC0tLQi23r27Bl0dHTQs2fPn/bQvXr1KpycnMDhcKCmpgZjY2Ns3LhRam33eFIS+GU1CM6ehVpkJB4mJ0MsFuP8+fPo06cPNDU1weVy4evri4iICGRnZyMlJQXLly9HjRo1QEQwNzeHk5MTBAIBiAiNGzfG6tWr8fnzZ6V+FjExMfD09AQRoUePHkhMTCxzm0eOHAER4enTp0ro4f/Izs6GpaUlunXrhl69eqFJkybFHisSieDm5gZ3d3dMmDABvr6+MDMzY7+f2tra8PT0RHBwMNauXYsbN27I7F352SQkJMDJyQn6+vq4ePEivnz5Ah8fH/B4PCxbtqzI382FCxdARNi1axfw8SMwdy7g5QXo6kobAXp6QLNmwIIFwNevhdoZMWIEBAKB0pd9VMiHyhj4D/Dlyxd4enpCU1MTBw8elHovOTkZLi4uMDMzw4sXL5CSkoLJkydDS0sLBgYGmDdv3i95gPXv3x916tQBkP+wMDU1hbm5OXR0dDBv3jwcPnwYkydPRrNmzaCrqwsiApfLhZOTEwIDA7Fx40Y8evQIqampqFmzJqpXr/5TZh1fvnzBgAEDQETQ0NAAl8tFSEgIUlJSijz+7LdvMLxyRbElgwsXQNu2gW9jgy5dukjFBaSmpmLDhg1o2LAhG/A3ZMgQLF68GL169WKXYTgcDng8Hjp37ozo6OhyM5bEYjG2bNkCExMT6OjoYMGCBWVyg2dlZUFbWxtz5sxRYi/z2bRpE4gIvXv3RrVq1QDkf55XrlzBypUrERgYiHr16hUK6mvTpg2mTp2Kffv2lVtQX3lw//59WFhYwNraGo8fP0ZMTAysra1hYmKCqKioIs8RiURwdnaGp6dn4e8MwwCfPwPx8cCXL/n/L4aDBw/+dI+diqJRGQP/EbKystCtWzdwOBwsXrxY6gf8+fNnODo6wsrKCu/evQOQH109fPhwqKmpwczMDCtXrvypa5i1a9fGoEGDAABVq1ZFUFAQvn//jqCgIBARGjZsyM4KRSIRHj9+jI0bN2Lw4MFwdnYGl8sFEYHP54PL5WLw4ME4cuQIPn36VC79FYvFWLt2LfT19aGmpgYigpeXl0zBmV9yc9H18WPQxYvgR0WVagRIsk4mvHiBZq1aQVNTExwOByNGjCj0YBaJRNi6dStcXV3ZoFGBQABfX19cu3YNnz9/xvz589nANRcXF6xZs6ZYL0tZSUlJQUhICLhcLhwdHcuUHdKtWzfUrl1bib3LX6p6+fIlLCwsYGRkBD6fj8qVKxcK6uvXrx/Cw8Mxb948ENFPj7dRFmfOnIGuri5q166NDx8+4O+//4aGhgbq1q2L+Pj4Ys9bt24diKiQt1Ee3r59CwMDA3Ts2PG3WCb5r6MyBv5DiMViTJo0CUSE4OBgqSjoxMRE2NnZwd7eXipmIC4uDgEBAeBwOLCzs8P27dsVikyXh7y8PKirq2P58uV4/fo1iAiHDh1i34+KioK9vT3U1dUxZ86cIoPT0tPTMXbsWBAR6tSpI+W+tbW1Rffu3REeHo7o6OgyZSgAwJ07d9hAPS6XC3Nzc+zZs0fuB9zD9HQEP38OvcuXizUEKl27htC4OCT+k1aalpaGevXqsd6RefPmgWEYXL9+HSEhIex929nZYcKECVi7di26d+8OgUAAHo+H1q1bY//+/cjKysKpU6fQvn17cLlc6OjoICgoCPfv3y/TZ1McDx48QKNGjUBE6NKlS4kDT3FI4kAUHYizs7MRExODTZs2ISQkBE2aNIGBgUGhWJWRI0di27ZtRQb1JScng4iwdetWhfrwK9myZQv4fD78/PyQnJyMkJAQEBH69+9f4m/i+/fvMDExQd++fRW+tiSrydra+pcuR6r4Hypj4D/Ixo0bwefz0apVK6m/VVxcHCwsLFCzZs1CqXePHj1C+/btIdEoOHLkSLlZ8w8fPgQR4dKlS1i9ejX4fH6h71RWVhYmTJgAHo8HZ2dn3L59W+r9mJgYCAQCBAcHA8if8b179w579uzBmDFj0LBhQ9bNq6amhnr16mHEiBHYsWMHXr58KdO9paSkYNiwYWxcAJ/Px+TJk8u8rMIwDF5lZWH/ly/Y8P49Nn34gMikJHz8QVdCwtevX1GtWjXWIJBkZZibm2PUqFG4ceNGoftJSUnBmjVr4O7uDiKCkZERRo4ciZiYGMTHxyM0NBSVKlUCEcHDwwPbtm0rMoCsrPe5fft2mJmZQUtLC/PmzUNOMfdYFOnp6RAIBFi0aFGpx37+/BlnzpzBggUL0Lt3b9SqVatQUF/Xrl0xd+5cREZGIiEhAQ7/BGS+fPmyxLZr1aqFwMBAmfv9q2EYBjNmzIAk/fj9+/do0qQJ+Hw+Vq1aVep3f9y4cdDS0ipT7MfkyZPB4/Fw7do1hdtQoVxUxsB/lLNnz0JPTw/Ozs5Ss7KnT5/CxMQEderUKTKS/Pr16/D29gYRwdPTU6kR4hK2b98OIkJKSgrat2+Pxo0bF3tsTEwMateuDS6Xi7FjxyIzMxPJycmws7ND3bp1Sxxc8vLycOfOHaxcuRIBAQGoWrWqVKqXv78/Zs2ahdOnT0ut+TMMg7///htGRkbsgOLv71/qoFEePH/+HDNnzoS9vT07sEk8BLJ6cGJjYzF+/HjWi+Ds7IwlS5bg/fv3OHjwIFq0aAGJHsTo0aOVLgiTmpqKMWPGgMfjoWrVqjhZIOWsNNq1awdPT0/2/yKRCE+ePMHu3bsxceJEtGrVCubm5oWC+oYOHYq1a9fi+vXrxRpvmzdvBhFh9uzZJfZh6NChcHR0lLnPv5K8vDz0798fRIS5c+fi5s2bsLS0RMWKFXH58uVSz3/x4gXU1NRK/UxK4uzZs+BwOJg3b57CbahQPipj4D/M48ePYWNjA3Nzc6lc6fv378PAwAANGzYs8kHJMAxOnz6NOnXqgIjQsmVL3LlzR2n9GjduHGxtbZGbmwtdXV3MnTu3xOPz8vIwf/58CAQCVK5cGZ6enjA0NFRIgS8pKQknTpxAaGgoWrVqBUNDQ3YgcXR0RLt27dg1ZA6HA1tbWxw/flzBO1WM+Ph4LFy4EG5ubiAi6OjoICAgAGvWrIGBgQGMjY2hoaGB69evy9WuUCjE8ePH0aVLF6irq4PP56NDhw44fPgwnjx5gj///BPGxsYgIjRt2hR79+5Vqn7A48ePWUOzQ4cOpf790tLSMGXKFBARevXqhXr16rGBkUQES0tLtGnTBlOmTMG+ffvw4sULuYL6JEsAlSpVKlFYaOfOnSAifPnyRea2fwWpqalo0aIF1NTUsH37dmzZsgUCgQDu7u4yz/Lbt28Pa2trhb1Enz59QsWKFdG8efN/TYDlfwWVMfAf59OnT6hfvz60tLRw9OhRdv+NGzego6OD5s2bF7t+yDAM9u3bx7pTu3btimfPnpW5T82bN0f79u0RFRUFIpLZ0Hj+/DkbCNeiRYtiI/jlgWEYPH/+HOvWrWNTHAsGkzVs2BB//vkn9u/fr5SUueL4/PkzVq5cya6zCwQCdO7cGfv27ZN6MEdHR0NLSwtGRkYwNDRUOPUuKSkJK1asYA0+ExMTjB49Grdv38aOHTvYfpiZmWHKlCls4GlZYRgGu3fvRqVKlaChoYGZM2ciKysLb9++xZEjRzBz5kx06tQJVapUkfpbWFhYoF+/fliyZAnOnz+vFIVJhmGgrq4OIsKGDRuKPe7du3cgIhw+fLjM1ywvEhIS4OzsDH19fZw+fRrDhw8HESEwMFDmpZlz586BiBAREaFQH8RiMVq2bAlTU1N8/PhRoTZUlB8qY0AFMjMz0alTJ3A4HCkBlYsXL0JDQwPt2rUrcQYoFAqxadMmWFlZgcfjYdCgQQoFhAH5D2ATExNMnz4dkyZNgomJicwziKioKHC5XLRq1Qq6urowNzcvlEqpSH/2798PU1NT1gXfqVMnHDx4EIsWLULXrl2ltA8sLCzQqVMnLFiwAJcuXSpT/EBKSgo2b96MFi1agMvlgs/nw9/fH3///XeJv7ETJ06Az+fDwMAAVlZWrLyuojx48ACjR49m61q4ublhxYoVuHz5MoYPHw5dXV1wuVy0adMGx48fL1OAaU5ODmJiYrB69WrWEJFkhkhiG5o2bYrRo0dj27ZtuH//Plq0aAFvb+8y3WNx2NjYoHr16rCwsChxNmxlZYVx48aVSx/KyoMHD2BhYQErKytERUWhUaNGUFNTw7p162RuQygUolatWmjYsKHCsULz588HEeH06dMKna+ifFEZAyoA5Fvtf/75Jxs9LXmgnzhxAmpqaujRo0epD/ns7GyEh4ejQoUKEAgEGD16tNyu0w8fPoCIcODAAbi5uaF3794ynffx40eYmZnB29sbQqEQCQkJaNu2LYgInTt3Vmgm8vLlSzRt2lRqmeDSpUtFHitZX58wYQK8vLzyZYcpvzCTq6srhg4dii1btuDp06clGjcZGRnYvXs32rdvD3V1dXA4HHh7e2Pt2rX4WoRgS3Hs2LGDXUJwcnJSipckLy8Phw8fRocOHcDn86Guro4uXbpg3759WLNmDWrXrg0igo2NDebOnVtqGueXL19w9uxZLFy4EH369EGtWrXA5/PZJZiqVauiVatWrBegWbNmRcZlrF+/Hlwut1zc9B4eHujcuTP4fD4WLFhQ7HE9e/aEh4eH0q9fViSxQbVr18axY8dQqVIlmJmZyR24t2bNGhBRoUBdWYmOjgaPx8OECRMUOl9F+aMyBlRIsXbtWvB4PLRp04YV6Tlw4AB4PB4GDhwo0yw9LS0NM2fOhK6uLnR0dBAaGirzd+LkyZMgIty8eRNEshUtEQqF8Pb2hpmZmdSgzzAMIiIiYGJiAgMDA2zevFmmWU1WVhamTZsGPp8PDocDbW1trFy5Uq6CNEKhEPfv38e6deswcOBA1KhRg/Us6Ovro0WLFpg2bRoiIyORmJiII0eOoEePHmx1R3d3d4SHh5dp6WHp0qUgyq/z4OXlVeYUyoJ8/vwZ4eHhcHZ2ZpcLxo0bh4iICAwYMAAaGhrg8/no1q0bzp49iydPniAiIgITJ06En5+fVFCflpYWPDw8MHToUKxZswbXr1+XEoiSeGesrKwgEAgwbdo0ZGZmSvWFy+WW6MpXlA4dOqBVq1YIDg6GoaFhsUbVqlWroKamJtWvX40kdbBVq1ZYsWIF1NXV4enpKbenKCUlBRUqVFC4bkBKSgpsbGzg4eGh1BgTFcpFZQyoKMSpU6dYIRLJYLR9+3ZwOByEhITI7Cb8+vUrxo4dC4FAgAoVKmDJkiWlDkhhYWHQ1dVlK5jJIhI0adIk8Hi8YmftSUlJCAgIABGhefPmJealnzhxgi3eREQYOHCgXDPykvj+/TvOnj2LOXPmwN/fX6pQDVG+SmCbNm1w6NAhpQk8TZ48mY1v6Ny5s9I1IhiGwd27dzFy5EgYGRmBiFC9enV06tSpkEqfJBivdevWmDJlCvbu3Yvnz5/L3KeMjAxMnjwZ6urqsLGxwaFDh9jvopeXF1q1aqXUewOA4OBguLi44MOHD9DS0sKkSZOKPE5SYrs8smvkhWEYzJw5E0SEAQMGIDAwEESEoUOHKvS9GjNmDLS1tRVabmIYBp07d4aBgYFSS2qrUD4qY0BFkTx8+BBWVlawsLBghWfWrl0LIsLkyZPlais+Ph6BgYHg8XiwsrLCxo0bi51l9+jRAw0bNkSfPn1kUpc7duwYiAh//fVXqceePHkS1tbW0NLSwpIlS6QGoXfv3qFVq1bsoOXq6qrUDAkgfynm6tWrGD58OExNTUFEsLa2RocOHdCnTx+4u7uzAWsCgQAeHh4YNWoUdu/ejTdv3ii0VsswDAIDA8HlcsHhcDB8+HCl6ENIdBuOHDmCWbNmoVOnTlJKfQWzLVq3bg0vLy/w+XxoaGigf//+RWofyMqLFy/Yv1WrVq3w/PlzLF++HGpqakpZDinIzJkzUbFiRQD5hpWmpmaRhbxEIhH09fXLlHKnDPLy8lg57PHjx8PDwwPq6uoKe02eP38OPp+vsOyzZHlh//79Cp2v4uehMgZUFMuHDx9Qp04d6OjosOlzixYtYvPY5eX58+fo1q0biAgODg7Yu3dvoWWH6tWrIzg4GKamppg4cWKJ7cXFxcHAwADt2rWTOcgwLS0NI0eOBIfDQf369RETE4PZs2dDTU0NHA4H+vr62Lp1q9LSnhiGQUxMDP78809YW1uzQYZjxozB7du3Cw2IOTk5uHHjBpYtW4aePXtKDbCmpqZo164d5s6di/Pnz8ssGSwUCtGxY0dWJlneB3tOTg7u3r2LLVu24I8//oC3t7dUyqWRkRF8fHwwevRobN26Fffv38fbt2+xcOFCtiiSpaUl/vjjD4wZMwY2NjYgItSuXRvr1q1TqGYEwzA4fPgwbG1toa6uzkbHb9++Xe62SmL9+vXgcDgQCoVISUmBoaEhhg4dWuSxfn5+8PX1Ver15aFg6uD06dNhZmaGSpUq4caNGwq32bZtW9jY2CiUSvjgwQMp4S8VvzcqY0BFiWRkZLAStatWrQIAVr1s+fLlCrUZExPDzuzc3Nxw6tQpMAyDrKwscLlcNne8JJdrTk4O6tSpAzs7O4XkTKOjo9nBWTKLHTFihNK+u0+fPkVoaCiqVasGonxVwODgYFy6dEluQ+PLly84duwYpkyZgubNm0NPT4/tc82aNTFo0CCsX78eDx8+LNblnp2dDS8vL9Ztv3HjxmKvdfbsWSxatAh9+vSBk5NToaC+Ll26YM6cOTh27Bji4+NLnOEzDINbt24hODiYlfpt0KABQkJC0KpVK3C5XOjq6mLYsGEy1XH4kaysLEyfPh0CgQDq6uqoV6+eUpUxJZ4niYt8wYIF4PF4ePHiRaFj582bB11d3XKX6y6KxMREuLi4QE9PD6NGjYKamhoaNWpUphS+M2fOgIiwZ88euc/NyMiAo6MjnJ2dla5cqaJ8UBkDKkpFJBKxdc1Hjx4NoVCIcePGgYiwadMmhdu9dOkSGjRoACKCt7c3Wy0uODgYOjo6Ja5vBgcHQyAQSIklycrHjx/Rrl07KZd25cqVER0drfC9APmFV+bPn8/qEejp6aFfv344deqUUgOnxGIxYmNjsXnzZgwZMgQuLi5s+p2Ojg58fHwwceJEHD58WGow+P79O1xdXdkgxdWrVyMiIgKTJk2Cn58fKz9cMKgvKCgIa9asQXR0dJmrPmZnZyMiIoI1AjQ1NdGxY0f07t0bFStWZA2F7du3yx3s+OrVK1SvXp39Lj158qRMfZVw+/ZtEBH7PcvKyoKFhQW6d+9e6NjLly+DiH56Kd6HDx/C0tISlpaW6NSpE4gIw4cPL1PciVAoRM2aNdGoUSOFjKsBAwZAS0tLaX8HFeWPyhhQITMrV64El8tF+/btkZ6ejqFDh4LD4WD37t0Kt8kwDI4dOwYnJyd2IKpduzbatWtX7DmStLn169fLdS2hUIiFCxdCIBCAKF9yeP/+/Xjw4AHq1asHDoeDkSNHyjXoffz4EcuXL4enpycbud+tWzccPHhQqdH7pZGeno6oqCjMnz8fHTt2lIrWt7S0RNOmTdGpUyf4+vqy919QG6F169aYPHky9uzZI1dQn6IkJiYiLCyM9ZzY/FOGWWIcGhkZYezYsUXOwItDUtTK1NQUfD4f48aNK3P1xcTERBARIiMj2X0bNmyQMhAkZGdnQ11dHStWrCjTNeXh3Llz0NPTQ82aNVG7dm0IBAJs3ry5zO2uXr0aHA5HobgZye9TGf1Q8fNQGQMq5OL48ePQ0dFBnTp1kJiYiICAAPD5fCn1QkUQi8XseicRoV69ekVG/cfGxkJLSwt9+/aVa8YSHR0NW1tbNvd//PjxUu5LkUiEJUuWQFNTE9bW1iXq43/79g0bNmxAs2bNwOVyoaamhjZt2mDnzp3lVvpXFiRBfUePHsWsWbPg5+cnVa2x4MblcsHj8aClpYUTJ078shKyDMMgOjoagwcPZgst1a9fH76+vuyyQvPmzbF//36ZvCuurq7o0qULZs+eDU1NTVSqVAm7du1S+P7y8vLA4XCkllWEQiEcHBzQsmXLQsc3aNCgSK9BebBt2zbw+XzUr18fJiYmsLS0LFNJYQnJyckwNjbGgAED5D735cuX0NHRQe/evVVlif9lqIwBFXJz7949VtHs7t276NSpEwQCQZlq0wNA48aN2ZmhiYkJ+Hw+hg0bxkZvp6enw9HREbVq1ZJZ2S8pKQmdO3dmB0EvL68SU5xev36NZs2agYgQEBDAytqmp6dj586daNOmDdTU1MDlctGsWTNs2LAB3759K9N9K0JOTg7u3buHLVu2YNSoUYWC+gwNDeHj44NRo0Zh69atuHfvHtLT0xETE4NVq1ahTZs2Usp+BgYG8PPzw4wZM3Dq1KlfUlY2MzMTO3bsQLNmzVh9h8aNG6NmzZogyq/COG3atBLVLWfPng0dHR1kZ2fj7du36NixI/t3f/TokUL9MjExKZQlsH//fhARzp8/L7V//PjxqFSpUrkOhAzDYNasWSDKLxbG4/HQpEkTfP78WSntjx49Gjo6OkVmTZRETk4O3NzcYG9v/0uNYhWKoTIGVChEYmIiXF1doauri2PHjsHPzw9aWlq4evWqQu0xDAM9PT24u7vD3t4emZmZmD9/PgwMDKCpqYkJEyagU6dO0NHRkan+gVgsxrJly9iAuYoVK8pcDY9hGGzevBn6+vrQ09ODh4cHWwDH09MTy5cv/6na6l+/fsW5c+ewaNEiBAQESAX1ERHs7e3Z2bAsQX0SLl26BHV1dairq8PExATNmzeXMigcHBzQt29frFq1CjExMT9VMObt27eYNWsWm01haWmJevXqQUtLC1wuF+3atcPJkycLBWPGxsaCiKQ8VadOnUK1atXA4/EwatSoIqtxloSzszOGDRsmtY9hGNSrVw/169eX+qyPHj0KIkJcXJwCd106eXl5GDRoELucRkT4448/lPa3efbsGfh8vkLZQpLARWWn5Kr4OaiMARUKk5aWhtatW4PH42HFihXw9vaGnp6eQg+DuLg4dtAePnw4uz8lJYUVmiEi9OjRo1SvwJ07d9hBhM/nIzQ0VOZgqry8PJw6dQr9+vVj3dZE+UI6ZQ0wLA2RSIRnz55hz549mDx5Mvz9/WFhYSEV1Ofu7o6goCCsXr0a165dK/MM7PDhw+ByuVBXV0fjxo2RlZWFFy9e4O+//8bw4cNRp04d1vDQ1NREo0aNMHbsWOzbt09mo6MsMAyDS5cuYcCAAdDW1gaHw4GjoyObCWJnZ4ewsDCpWbGjo2MhtbycnByEhYVBS0sLFStWxN9//y1z31u2bIlOnToV2n/+/HkQ5UtnS0hKSgKRbMqZ8pKamgpfX1/w+XzY2tpCQ0ND6ddp06YNbG1t5Y53kRhBS5cuVWp/VPw8VMaAijIhFAoxYsQIdoZSv359GBkZleySffoU2LoVGDkS6N4d6NYNcS1bIogIbkQ49kP8wc2bN8Hn8+Hs7Aw1NTWYmZlh5cqVhQb479+/o2vXruzg2bJlS5lcnWKxGJcuXUJwcDAqVKgAIkK1atUQGhqKJ0+e4ODBgzAzM4Ouri7WrFmjFA2C9PR0REdHY/Xq1QgKCoK7uzsb5S8J6vP398ekSZOwZ88ePHv2rNyC+iRZHHw+H506dSp0naysLFy7dg2LFy9Gt27dpFIyK1WqhI4dO2L+/PmIiooqU2Gm0khPT8fWrVvh5eXFGkdVq1Zlyy336NEDUVFRmDx5MgwNDYucLcfHx7NaFw0bNmQFtUqiX79+8PT0LPK9Fi1awNHRUUpEq2bNmhgyZIjiN1oE79+/h4uLC7S1taGvrw9ra2uFMmlK4vTp0yAi7Nu3T67zEhISYGRkhLZt26riBP7FqIwBFUph2bJl4HA4aNu2LZycnGBmZiYdCS4UAtu2AW5uAFH+pqYGcLkAlwsRlwvxP/vFtrZAeDiQno6kpCRYW1vD3d0dubm5iIuLQ0BAADgcDuzs7LB9+3YIhUKsXr2adeVbWFgUK00sgWEY3L59G2PGjGFn31ZWVvjzzz9x9+7dQg+1lJQUVta1SZMmeP78uUyfC8MwiI+Px7FjxzB79mx06dIF9vb2rNwxn8+Hk5MTAgICsGjRIpw7d05p8sfyIKkox+FwMHTo0FIf6h8+fMChQ4cwceJEeHt7s4WZuFwuXFxcMGTIEGzevBmxsbHlUrf+9evXmD59OitgZGJiwhpykjLWBWfsP3Lu3DlUr14dXC4XI0aMKFG5cOLEibC1tS3yvTt37hTSbQgKCkKNGjUUvrcfefToEaysrGBgYAAul4umTZsqvSiTUChEjRo10LhxY7kGdKFQiMaNG8PCwkIpZaNV/DpUxoAKpXHkyBFoaWmhdu3aqFKlCqytrfPr3D96BLi65hsAXO7/jIHiNg4H4HDAWFpiQv36MDY2zm+nAI8ePUL79u1BROwSgpqaGubPn1/iDPrx48eYOnUq7O3t2TS0ESNG4OrVqzINWufPn0flypUhEAgQFhYmNfvMzc3FvXv3sHXrVowePRo+Pj6sXr8kqM/b2xujRo3Cli1bcPfuXZlryZc3DMNgzJgxbF9nzZol1/kikQgPHz7E+vXrMWjQINSsWZM1ePT09NC8eXNMmTIFx44dU+pAJhaLcf78eQQEBEBTUxNcLpeVepYU1youwj43NxcLFy6Ejo4OTExMsGnTpiK/A0uXLoWGhkaxg2S3bt1gaWnJZqds374dRKSUwfH8+fPQ09NjYznGjBkjV8EsWVm5ciU4HI7c3obp06eDy+Xi8uXLSu+Tip+LyhhQoVTu3LkDc3NzWFpawsLCAqMqVgTD5wN8fulGwA+bmMMBiPAiIAD44UGckZGBHj16SKXL1atXr0jVwtevX2Pu3LmsloG+vj4GDhyIs2fPKvRgzczMxLBhw8DhcNgcfckSRsGgvs6dO2P27Nk4evQo3r1799u7UMViMQICAtgsg7JWAUxNTcW5c+cwd+5ctG3blh2kifJFnnr27Illy5bhxo0bSjGKUlNTsXHjRjRs2JC9jsRj4ebmhg0bNhS5jPH+/Xv06tULRAQPD49CMS979uwBERXrPXjx4gV4PB4WLlwIAHjz5s3/ghiFQiA9HcjOLvQdLo2///4bampq0NXVhYaGBnbu3CnX+bLy7ds3GBkZYeDAgXKdd+HCBXA4HLkNRxW/JypjQIXSiY+Ph5OTE/praEBMxLr/y7TNmAEgfwa7bt06dknA2toaN27cwOnTp1GnTh02VuDkyZMIDw9H/fr12fXlHj164MiRI3INPGKxGM+fP8fevXsxefJktG7dWiqoTzL7dXFxQXh4uFKC+n4leXl58Pf3Z8s3HzlyRGltMwyDN2/eYPfu3Rg1ahRbREfi3XF3d0dISAh27dqF169fl8l4kgzgJiYmIMpXZpS8jhgxosiYlqioKNSqVYtdKpGkjEqUBUtS0wsKCsovcfzlC5g9e7BPUxNfDA2lPWHGxkCrVsD8+UAJ1TgZhsGcOXNAlF+wysbGplxVDf/44w/o6OjIlSHz5csXmJubw9vb+5fIL6tQPipjQEW5kH7zJoQcjnIMgX+2d6tWoWrVquxDcsmSJVIDxtevXzF48GDWUJCsr0ZERMgU2CYJ6luzZg2CgoLg4eHBziwlwXJ+fn6YNGkSIiIi8OzZM2RnZ2POnDlQV1dH1apVERUVVZ4f608hMzMTnp6ebNrhtWvXyu1aOTk5uHnzJpYvX45evXqhSpUq7OdtYmKCNm3aYM6cOTh79qxcKYFisRiVKlXCyJEjcfr0afTs2RPq6urgcDisAdKgQQPs3LlTyjjMy8vD0qVLoaenB2NjY6xbtw5Pnz4FEeHChQvFXu99fDzG8/lI19ICiCD6x6tV5BIYl5vvKevVC/ihLHDB1EEOh4NmzZqV61r806dPwefzERYWJvM5YrEYfn5+qFChgkJljVX8nqiMARXKRygE3NzA8HhFPhAfE6ELEeyIoEkEYyI0JsLRkpYMiPCZCAZE6NixIzv7Tk1Nxd9//w0/Pz/w+XxWDGjAgAGwsLAAj8fDoEGDpIRqGIZBQkICjh07hjlz5qBr166oWrVqoaC+Pn36YNGiRTh79myp69xPnz5l3dNBQUFy57L/bnz79g01atSAQCCAvr4+YmNjf9q1v3z5gsjISEybNg0tWrSAvr4+OzjWqFEDAwYMwLp163D//v0Sl3lGjBgBS0tL1mBMSUnB2rVrWW+RJGXSwMAA48aNw6tXr9hzP378iL59+6JgPn+xbvrnz4G6dcHIa+Dy+YCuLvBPpcW0tDS0aNGC/R7++eef5RIfUBB/f3/Y2dnJlUq4ePFiEBFbyVTF/w9UxoAK5bNzZ4kPweNE8CXCDCKsJ8LSf4wBIsK6Es4TEeFjYCCysrKwb98+dO7cmRUVatSoEVatWiWVb56dnY2FCxfC0NAQampqcHNzQ6NGjaSC+gwMDODt7Y0//vijzEF9YrEYK1euhI6ODiwsLJTqYv8VJCYmwtLSEgKBAJUqVUJCQsIv6YdYLMaTJ0+wZcsWBAUFwdXVFTwej40J8PLywoQJE3Dw4EGpmeqFCxdARLh582ahNp88eYLx48ezGQiSOAkvLy8cPHiQHYSvXr0KFxcXEBHc3d0LG4W3bwP6+kAxhm+p2z8ehNRx41CjRg1wuVwIBAJERESU50cKADh58iSICPv375f5nFu3bkFNTQ1jx44tx56p+BWojAEVysfDQ7asgR8GehciOJRyXJpAAMMCQWELFy5kZ/1JSUk4f/48lixZgr59+8LFxUUqqI/D4YDP58Pb2xu7d+8ut6C+d+/ewc/PD0SE7t27K00m9lfw7NkzGBkZQV1dHdWrV/8lMsVFkZGRgUuXLmHBggXo1KmTVMVFKysrdOnSBX/99Rf09fUxZsyYYtsRCoU4fvw4OnbsyMZJSDI/pk6disTERAiFQpiYmEAgEMDQ0BCrVq3KXyd/8aJshsAP2yjKT4t98OBBuX9+eXl5qF69Ory8vGT+DXz//h2VK1dGvXr1ylQRUcXvicoYUKFcXr9W+GHYhggVZThuV69eOH36NPbu3YspU6agdevWsLS0ZAcDTU1N1K9fH4MHD8aqVatw9epVpKWl4evXrxgzZgwEAgEqVKiAJUuWlFtlQYZhsGPHDhgbG8PIyAjbtm377bMJiuP27dvQ0tKCmpoaGjRo8NvWp09ISMD+/fsxbtw4NG7cmI0dkbj6hw0bhm3btuH58+dF/i2SkpKwYsUKthSyxID08fFBrVq10KlTJwwcOBBEhDqurkirUUPmLJk5/7RXs4RjhBwOvl+58lM+q+XLl4PD4cgcmMgwDLp37w49Pb0iC4ip+PejMgZUKJddu2Qe/DOI8JUIr4iwhAg8IvQq5RwhEcIKzPYlQX0TJ05EREQEnj59Wmp0c3x8PAIDA8Hj8WBlZYWNGzeW29rsly9f2LQ1X1/fEosk/c6cPXsWfD4fPB4P7du3/1dEkOfl5WHFihUgIrRt2xaOjo7s98bQ0BC+vr4IDQ3FiRMnChWbevjwIUaMGCElSa2mpobp06fjxIkTWGhpKXOMQAIRtIigXYoxwPB4gIsLUA4iTQX59u0bDA0NERgYKPM5krLNP2P5QsWvQWUMqFAu48blKwvK8JAMogIldSk/qDC5lHPERHjt4CBTUF9pPHv2jJWmdXBwwN69e8tFLQ8AIiMjYWlpCW1tbSxbtuxfMZj+yN69e8HhcMDhcDBkyJB/hacjNzcX+vr6mD59OoD88rynT5/GzJkz4e/vLxU/UrVqVQQEBGDlypW4c+cO8vLykJeXh8OHD0stQ6gR4ZuM33EQoTsRmhLBqxRjgN3OnCnXz2TkyJHQ1dXFpxLSGwvy+PFjaGpqYvDgweXaLxW/FlnHbw4AUCmkpaWRvr4+paamkp6eXmmHq/j/SP/+RDt2EInFpR76jIgSiegDEe0lInUiWkNEFUs576uVFR0NDSU1NTWFN3V1dfbfjx49omnTptHp06fJzc2N5s2bRy1btiQOh1PGD0OatLQ0mjRpEq1evZo8PDxo06ZNVKNGDaVeo7xZs2YNDRs2jIiIZs6cSdOnT//FPSqdgIAAunfvHj1+/LjQewDo9evXdPPmTbpx4wbdvHmT7t+/T0KhkDQ0NMjNzY08PDzo48ePdPz4cfrzzz/pzeLFtOn7d5mufZmImhLRPSIaSURJRFS4FwXg84n8/IiOHpX3NmXi6dOn5OTkRPPmzaPx48eXenxWVhbVr1+fiIhu3bpFWlpa5dIvFb8eWcdvlTGgQjb69SPauVMmY+BHWhLRdyK6SUQlDcP3iai2In0rAQ6HQzwejxiGIYZhSE1NjfT19UlbW7tMRkdRW2JiIh08eJCSk5PJz8+P2rRpQ5qamkprn8fjKd2QKcisWbMoNDSUiIjWrVtHQ4YMKbdrKYPDhw9Tx44d6dmzZ+Tg4FDq8Tk5OXTv3j3WOLhx4wa9e/eOiIgqVqxIOwUC8k5IIF4pj0QxEbkRkScRrSUib5LBGCAiUlMjyszMf1Uyfn5+9OLFC3ry5AkJBIJSjw8KCqLt27fT7du3qWbNmkrvj4rfB1nHb/5P7JOKfzNGRkRcrkLGQBciCiKiF0RU7CObwyHXZs1IfPo0iUQiEgqFlJeXR0KhUClbXl4ePXz4kE6ePEmfP38mQ0NDatSoERkYGJR4Xk5ODqWnp8t1HSKiyMhIioyMVPDDLh5ZPCKKbnw+n+rWrUt37tyhoKAgunHjBtWuXVvpRpOyDBtfX1/S1tamAwcO0OTJk0s9XkNDgzw9PcnT05PdFxERQT179qTOnTuT/datpRoCRPkGwDsiOidvh4VCothYIldXec8skZMnT9KpU6fo4MGDMhkCe/fupfXr19P69etVhoAKFpUxoEI2atfOf5gpQPY/r6klHcTnE9WtS1wul9TV1UldXZ20tbUVul5JiMViioiIoOnTp9PWrVupd+/eNHPmTKpcubJSr/PgwQMaNGgQ3b17l4YNG0YTJ04kdXV1pRk3imyyGDa5ubkkEAgoNzeXtmzZQjt27CCxWEwMwyj18yEq3rCRZzM2NqYlS5bQ27dvFTr/w4cPRERUpXJlss7JKbXP34hoOhFNIyITRW5aycaAUCikMWPGkI+PD3Xo0KHU4+Pi4mjw4MHUrVs3CgwMVFo/VPz7US0TqJCNp0+JSlkH/0JEpj/sExKRBxE9/ed9nZIaOHCAqFOnMnRSdvLy8mjjxo00e/Zs+vbtGw0ePJimTp1K5ubmSruGSCSi8PBwmj59Opmbm9P69eupefPmSmu/vMjLyyN/f3+KiooiTU1NunHjBlWvXv2XGjLFbe/fv2fXy7lcrkznFGXYCIiodFOAKJjyPQKxlB8LQyTHMgER0bp1REpcflm+fDmNHj2a7t69Sy4uLiUem5eXR40aNaKkpCS6d+8e6evrK60fKn5fZB6/lRmNqOL/MQwDODmVKDrU4Z/o6hlE2ECE2URw/CdSe3EpkdZpHA4WzZqFr1+//tTbysjIQFhYGAwMDKCpqYlJkyYpXYDn5cuX8Pb2BhFhwIABv43AT0mkpaXBzc0NfD4fZmZmUrLPvxNpaWkQCARYvHixzOeIxWLk5OQgPT0dSUlJ4PF4CJszp9RsgBf/ZMcsJ8KbAps7Ear98+9vpWUUbN6stHtPSkqCoaEhhgwZItPx48aNA5/PL1K5UcX/X1SphSqUz4YNJT7odhOhOeULDPGJYPjP/4+U8oBkeDyc+kcvXyAQoH///nLXXy8rycnJmDRpErS0tGBgYICwsDBkZmYqrX2GYbB+/Xro6+ujYsWK2Ldv32+fwvflyxdUqVIFfD4fVatWLZSz/7vQtm1bNGjQQOHzK1WqlJ+iWLFiid/TiwVSZovb/ijNGCihKJK8fnv3bQAAJuVJREFUjBgxAnp6ejIpYZ44cQJEhEWLFint+ir+HaiMARXKJzsbqFpVaTKtIMrXcNfTAz58wNevXzF//nxYW1uDiODp6YmdO3f+VInUjx8/Yvjw4VBTU4OZmRlWrVql1Ou/f/8eHTp0ABGhQ4cOv311uLdv36JixYrg8Xhwd3f/LVUKt27dCiJS+LOsU6dOfq59u3Yler6+EuFQEVtNIlj/8++HpX3flVTo6vHjx+DxeFi4cGGpx75//x4VKlSAn59fueltqPh9URkDKsqHmzfZIixK2/6p7iZBJBLh8OHDaN68OYgIFStWxLRp05CYmPjTbvP169fo06cPOBwOKleujO3btytNUIhhGOzbtw+mpqbQ19fHhg0bfmsvwePHj6Gnpwcul4s2bdqUe8U9efn27Rv4fD5WrVql0Plt2rRBmzZtgMWL5a69AZJRdIjDAWrWVMr9MgyDli1bokqVKqUW3xKJRPDx8YG5uXmZxbxU/DtRGQMqyo/ly5XnFQgKyo9HKIYnT55gxIgR0NHRAY/HQ9euXXHp0qWfNng+fPgQ7dq1AxGhVq1aOHr0qNKu/e3bN/Tv3x9EBB8fH7x8+VIp7ZYH0dHREAgEICIEBgb+dsZLixYt0LRpU4XODQwMRN26dYGvX2VW2VTIGFi9Win3GhkZCSLC4cOHSz121qxZ4HA4uKDE5QkV/y5UxoCK8iU8PP8hp8iSgcSzMHSozHrtqampWLlyJatD7+TkhHXr1iEjI6N87/MfoqOj2SBAT09PREVFKa3tM2fOwNbWFpqamli4cOFvN/OWcOLECbbEsEQG+Hdh7dq14PF4CgWgTps2DRYWFvn/6d9fuctgku+7ri6Qllbm+8zNzUW1atXQtGnTUg2yy5cvg8vlYtq0aWW+rop/LypjQEX5c/EiYG0tn2uVx8svD7trV4kegeJgGAbnzp1Dhw4dwOVyoa+vj9GjR/+UWTXDMDh9+jTq1KkDovwCRcoKdMzIyMCoUaPA4XBQp04d3L9/XyntKpvt27dDEiy3Zs2aX90dlk+fPoHD4WDjxo1yn7t69Wrw+fz89fRPnwADA+UvhW3ZopT7DA8PB5fLLbUcclJSEiwtLdG4cePf1rhU8XNQGQMqfg4ZGUBYGGBh8b/BvqBxwOH8rxysgQEwfnz+A1cJvH37FhMnToSxsTGICH5+fjh+/Hi5B0lJ1vwdHBxAROjatSuePXumlLZv3LiBmjVrgs/nY/LkyeVWirksLFmyBET5ZYAPHjz4q7vD0qRJE/j5+cl93sGDB0FE/1tT37NHeUYAjwf4+ytk+P7I169fYWBggKCgoBKPYxgG7dq1g5GRERISEsp8XRX/blTGgIqfi0iUnzYVFgZ06QI0bAh4egJt2wKhocCxY/nZCOVAdnY2tm7dys7Yq1SpgsWLF5d7Pr9QKMTGjRthaWkJHo+HQYMGKSUfPzc3FzNnzoSamhocHBxw5coVJfRWuUyYMAFEBD6fj8uXL//q7gAAli1bBjU1NXyXM2L/+vXrICLp2fZffynHEKhXTynLAwAwbNgw6OnplRoIuGzZMhARjh49qpTrqvh3ozIGVPznYBgG169fR+/evaGmpsaWZy3NpVpWsrOzsWTJElSoUAECgQBjxoxRinjS48eP4eHhASLCsGHDfqvfH8MwbPCjtrY2Hj169Ku7hPj4eBARduzYIdd5b9++BRHh9OnT0m+sXp0fUCjxbMkbE9O6tdIMgUePHoHL5ZaqExATEwN1dXX88ccfSrmuin8/KmNAxX+aT58+Yfbs2bCwsAARoXHjxti7dy/y8vLK7ZppaWmYMWMGdHV1oaurixkzZiCtjIOBSCTCsmXLoK2tDUtLS0RGRiqpt2VHKBSidevW4HA4qFChAt69e/eru4T69eujY8eOcp2TnZ0NIsLWrVsLv/nkSf7snqh0o4DD+Z9uxrZtSlkaAPINr+bNm8Pe3r5EzYu0tDTY29vDzc2t1JRDFf8dVMaAChUA8vLysG/fPnh5eYGIUKlSJcyaNQsfP34st2t+/foVY8aMgUAgQIUKFbBkyZIyr/2/efMGLVu2BBGhV69ev03OeHZ2Njw9PcHlcmFnZ/fLVQr/+usvaGpqyp1lYmhoiLCwsKLfZJj8YNkuXQANjeINAWdnYN06ID297DdSgKNHj4KIcOTIkWKPYRgGvXv3ho6ODl68eKHU66v4d6MyBlSo+IGHDx8iKCgIWlpaUFNTQ69evRAdHV1uOfPx8fEIDAwEj8eDlZUVNm7cWKbIboZhsG3bNhgZGaFChQrYsWPHb5Hv//37dzg6OoLL5cLNzU2pMs7y8vLlSxAR9u3bJ9d51atXl821LhLh3PLl6EaE1PBw4O+/gcuXlbYc8CO5ubmoWrUqmjdvXuLfesuWLQotkaj4/4/KGFChohhSUlIQHh4Oe3t7EBHc3NywefPmcpPaffbsGbp16wYigoODQ5nrEnz69Andu3cHEcHf3/+3KCL08eNHWFhYgMPhoGXLlr80nc3Z2Rk9e/aU65ymTZuiW7duMh27atWq/6UiljOLFy8Gl8vFw4cPiz3m6dOn0NLSwoABA8q9Pyr+faiMARUqSkEsFuPkyZPsureRkRHGjx+PN2/elMv1YmJi4OvrCyJCnTp1cPr06TIZBUeOHEGlSpWgo6ODlStX/nLd+VevXsHQ0BBEhL59+/4yr8XMmTOhq6sr17p579690bhxY5mOnTJlCqysrBTtnsx8+fIF+vr6CA4OLvaYrKwsODs7w8HB4acJcKn4d6EyBlSokINXr15h7NixMDAwAIfDQbt27XDmzJlyGdCioqLg6ekJIoK3tzeuX7+ucFvfv39HUFAQiAiNGjXC06dPldhT+bl37x40NTVBRJg0adIv6cPjx49BRDh27JjM54wdOxZVq1aV6diBAwfC3d1d0e7JzNChQ6Gvr19ifMiwYcMgEAjKPWNGxb8XlTGgQoUCZGZmYsOGDXB2dmbd+suXL1f6d59hGBw9ehROTk4gIrRr165M6XlRUVGwt7eHuro65syZU65ZE7L0hc/ng4iwcuXKn359hmHg4OCA/v37y3zOokWLoKOjI9OxrVq1kjtjQV4ePnwILpeLJUuWFHvM/v37QURYraSaByr+f6IyBlSoKAMMw+DKlSvo1q0b+Hw+dHR0MGzYMMTGxir1OiKRCDt27EDlypXB4XDQp08fvH79WqG2srKyMGHCBPB4PDg7O+P27dtK7as8HDx4EBwOB0SE/fv3//TrT548GUZGRjIbRTt37gQRIV2GTABnZ2cMHz68rF0sFoZh0KxZM1SrVq3YVMI3b95AX18fnTt3/i2CSFX8vqiMARUqlERiYiKmT5+OihUrgojQtGlTHDx4UKlBcrm5uVi1ahXMzMygpqaGYcOG4cOHDwq1FRMTA1dXV3C5XIwbN+6XRfevX78eRAQej4dLly791GvfuXMHRISzZ8/KdPz58+dBRDLVuKhQoQLmzJlT1i4Wy5EjR0pc5sjLy4OnpydsbGzKXWVTxb8flTGgQoWSyc3Nxa5du9CgQQMQEaysrDBv3jyl5vxnZGQgLCwMBgYG0NTUxKRJkxR64Ofl5SEsLAwCgQBVqlT5ZSVsZ8+eDSKChoZGiRHxyoZhGNja2mLo0KEyHf/kyRMQUanSyjk5OSAibN68WRndLLJ9e3t7tGjRotgZ/8SJE8Hj8RAdHV0ufVDx/wuVMaBCRTkSExODgQMHQkNDAwKBAP369VOqWz45ORmTJk2ClpYWDAwMEBYWptAM/9mzZ2jcuDGICIGBgUhJSVFaH2WBYRgMHz4cRARDQ8OfqlI4ZswYVKxYESKRqNRjk5OTQUTYu3dvicdJpItPnTqlrG5KsWjRIvB4PDx+/LjI90+fPg0iwvz588vl+ir+/6EyBlSo+AkkJSVhwYIFsLW1BRHB3d0d27dvV5oc7MePHzF8+HCoqanBzMwMq1atKlGStijEYjHWrFkDXV1dmJub//RKg2KxGJ07d2a9KUlJST/luteuXZNptg/kGy0CgQDLli0r8ThJUaPy8HJ8/vwZenp6xcYjfPz4EaampmjRosUvTyNV8e9BZQyoUPETEYlEOHr0KCsZbGJigilTpihNEOj169fo06cPOBwOKleujO3bt8s04y1IQkIC2rRpAyJCly5dylWS+Ufy8vLQpEkTEBFq1ar1U+IYxGIxzM3NMWrUKJmOt7W1xcSJE0s85sCBAyCicjFogoKCYGBgUGSRK7FYjObNm6NixYr4pKQS4Cr+G6iMARUqfhHPnj1DSEgIdHV1wePx0LlzZ1y8eFEpUd8PHz5Eu3bt2EH16NGjcrXLMAx2794NExMTGBoaYvPmzT8tGj0jI4NNpfT29v4pKoXDhg2DtbW1TPfo4eFRajriihUroK6urvTP7MGDB+ByuVi6dGmR74eFhYHD4cgcEKlChQSVMaBCxS8mLS0Nq1evRo0aNUBEqFmzJtasWSNT+lppREdHw9vbG0QET09PREVFyXX+169fERAQACJC8+bNFU5nlJdv377BxsYGRITu3buXuyEiyRK4detWqcd27NgRvr6+JR4zadIk2NraKqt7APINNB8fHzg4OBSZCnnt2jXweLxfJuKk4t+NyhhQoeI3gWEYXLhwAR07dgSXy4Wenh7++OMPPH/+vMztnj59GnXq1AERwdfXFzExMXK1cfLkSVhbW0NLSwtLliyRe+lBERITE2FsbAwiwpgxY8r1WkKhEMbGxpgwYUKpxw4bNgzOzs4lHtOvXz94enoqq3sAgEOHDoGIcPz48ULvJScnw9raGg0aNPilQlIq/r2ojAEVKn5D3r17h0mTJqFChQrsAH7s2LEyDcIMw2Dfvn1wcHAAEaFr16549uyZzOenpaVh5MiR4HA4qF+/fpmUEGXl2bNn0NbWBhGVqLKnDAYNGgR7e/tSvRCzZs2Cqalpice0aNECnTt3VlrfcnJyUKVKFfj6+hbqH8Mw6NixIwwMDPD27VulXVPFfwuVMaBCxW9MdnY2tm3bhrp164KIYGdnh4ULF+Lbt28KtykUCrFx40ZYWlqCx+Nh0KBBcgUwXrt2DdWrV4eamhqmT5+utIyI4rh16xbU1NRARNi9e3e5Xef48eMyZQBs2LABHA6nxFiGWrVqYeTIkUrr24IFC8Dj8YpUtly1ahWICAcOHFDa9VT891AZAypU/Eu4efMmAgICoK6uDg0NDQwaNAj37t1TuL3s7GwsWbIEFSpUgEAgwJgxY4qMUC+KnJwcTJs2DXw+H9WrVy93YZvTp0+Dy+WCy+WWmzBSTk4O9PT0EBoaWuJxkZGRICK8f/++2GOMjIwQFhamlH59+vQJurq6GDFiRKH37t27B4FAUK6yxyr+G6iMARUq/mV8/vwZc+fOhaWlJVuFMCIiQm5dAQmpqamYMWMGdHV1oaurixkzZiAtLU2mcx8+fIh69eqBw+EgJCREKUGPxbFjxw4QEdTV1XH//v1yuUbv3r1Rq1atEo+RSBjfuXOnyPezs7NBRNi2bZtS+jR48GAYGhoWSlNMT0+Hg4MDXFxckJ2drZRrqfjvojIGVKj4lyIUCnHgwAH4+PiAiGBubo4ZM2YoXKvg69evGDNmDAQCASpUqIAlS5bINMiIRCIsXrwYmpqasLGxKTfVPQBYvHgxiAi6urrlsj5+8OBBEFGJQZvv378vsSZAXFycXPUOSuLevXvgcDhFihz1798f2tracsV9qFBRHCpjQIWK/wc8fvwYwcHB0NbWBp/PR48ePXD16lWFUvLi4+MxaNAgcLlcWFlZYePGjTLl+r9+/RrNmjUDESEgIKDcFATHjRsHIkLFihVlXtaQlczMTGhpaZXo4hcKheBwONiwYUOR71+9ehVEVKxUsKwwDAMvLy84OjoWyhDYvn07iAhbt24t0zVUqJCgMgZUqPh/xPfv37Fs2TJUrVoVRARXV1ds3LhR4XoFXbt2BRHBwcEB+/btK9W4YBgGmzdvhoGBAUxMTBAREaF0jQCGYdCrVy8QEapWrYqMjAyltt+5c2fUrVu3xGNMTU0xa9asIt/bu3cviKjMlQIlKoYnTpyQ2v/8+XNoa2ujT58+qrLEKpSGyhhQoeL/IWKxGKdOnUKbNm3A4XBgaGiIcePGKSQadOfOHfj6+oKIUKdOHZw+fbrUQejDhw9snYG2bdsiISFB0VspEpFIhObNm4OI4OHhodTc+l27doGISlyGcHFxQXBwcJHvLVu2DBoaGmUaqHNycmBnZwc/P79C+2vXro2qVavKHNehQoUsyDp+c0mFChX/GrhcLvn6+tKxY8fo1atXNGjQINq0aRPZ29tT27Zt6fTp08QwjExt1alTh06dOkVRUVGkrq5Ovr6+1LRpU7px40ax55ibm9P+/fvpwIEDdPv2bapZsyatW7dO5muWBo/Ho8jISKpduzbduHGDunTpQgCU0nbr1q1JXV2dDh48WOwxZmZm9OnTpyLf+/DhA1WqVIk4HI7CfVi6dCnFx8fT4sWLpfaPHz+eYmNjac+ePaSrq6tw+ypUKIwyLQsVKlT8fDIzM7Fx40a4urqyLvalS5fi+/fvMrfBMAyOHDmCWrVqgYjQrl27UsWHkpOTMWjQIBARvLy8yqyoWJC0tDTY2dmBiDB06FCltdumTRs0bNiw2Pf79+8PDw+PIt8LCAhAo0aNFL72x48foauri5CQEKn9R44cARFh+fLlCretQkVxqJYJVKj4j8EwDK5evYoePXqAz+dDW1sbQ4cOlSvgTSQSYfv27bCzswOHw0FAQADi4uJKPOfcuXOoXLkyBAIBwsLClOba//LlC0xMTEBEmD17tlLa3Lx5MzgcTrGZGSXVHmjWrBm6deum8LUHDRoEIyMjKWGp+Ph4GBkZoV27dqo4ARXlgsoYUKHiP8yHDx8wY8YMmJmZgYjg4+ODAwcOyFwpMDc3F6tWrYKZmRnU1NQwfPjwEkseZ2ZmYuzYseByuahduzbu3r2rlPt48+YNK1u8ZcuWMreXlJQEHo+H1atXF/n+smXLIBAIihyYq1evLnM55B+5e/cuOBwOVqxYwe4TCoVo1KgRLC0tyy1DQ4UKlTGgQoUK5ObmIiIiAo0aNQIRwdLSEnPnzsXnz59lOj8jIwNhYWEwMDCAlpYWJk2ahJSUlGKPv3XrFpycnMDj8TBhwgRkZWWV+R4e/l979x8UdZ3/Afz5WXYXFlhQwBNRRpD8mVoHmsfFYOTVGV442uiZ2JRmcdU1jnRnpudlOg1qpk4HenLqdSFepyVzDl/TU0cDg0Tv26nfNBMtHIETI4RN0cPd5/cPcpMDdEEgbZ+PGQd57+fHe3eY/Tx3P+/3633kCK1WKw3D4AcffHDLx/vZz37GMWPGtPjYjWYMBAcHc+nSpW0+n8vlYmJiIgcPHtzkW5Pf/e53NJlMLCwsbPMxRTylMCAiTXzyySecOXMmbTYbrVYrn3jiCR44cMCjfb/++mvOnTuXNpuN3bp1Y0ZGRqvTGq9cucLFixfTarWyf//+/PDDD2+57/v27aPJZKLZbG61QqCn1qxZQx8fnxY/jRcUFBAAjx071qT94sWLBMCcnJw2n++9994jgCZFm/bs2UPDMDrs9odIaxQGRKRF1dXVXL58uXuA3siRI/mXv/zFo6qEFRUVfP7552k2mxkeHs7Vq1e3Wi752LFjvP/++wmAaWlpbRrQ2JItW7YQAG02203HMdxIZWUlDcPg+vXrmz128uRJAuCePXuatJeWlrbYfjP19fWMiopicnKyu+3cuXMMDw/ngw8+2CVLRot3UxgQkRu6evUq8/PzOXbsWAJgWFgYX3nlFZaVld1031OnTnHatGk0DIP9+vXjxo0b6XQ6m23ndDqZmZnJwMBA9u7dm9u2bbulPv/hD38gAHbv3v2WqhQmJCRw3LhxzdodDgcBcOPGjU3ar31jcPz48TadJyMjg2az2b2f0+nk2LFj2aNHj3aXlxZpC4UBEfHYiRMnOGvWLAYFBdFkMnHChAncs2fPTUe4HzlyhCkpKQTAYcOGcdu2bS3uU1ZWxkceeYQA+Mtf/tLjMQstmTdvHgEwMjKy3VUKV65cSavV2uJ7WmBgIJcvX96k7d13323ze2BFRQUDAwM5a9Ysd9sbb7xBAB0y9kHEEwoDItJmDoeDa9as4d13300AHDx4MLOysm5aFa+oqIijR48mAP70pz/lvn37mm3jcrm4ceNGhoaGMiQkhO+88067p9M99dRTBMDhw4e3aypjWVkZATA3N7fZY/379+dLL73UpG3FihUMCAhoU3+nT5/OkJAQ92DEjz/+mGazmb/97W/b3F+R9lIYEJF2c7lc3Lt3Lx977DH6+PjQbrfzxRdfvOFKei6Xizt27GBsbCwB8Oc//zn/+c9/NtuuqqqKjz/+uHub9qxS6HK53KWUx4wZ065QMXLkSE6cOLFZe2JiIqdOndqk7Te/+Q379+/v8bEPHTpEwzCYmZlJkqypqWFUVBTvu+++di9JLdIeCgMi0iHOnDnD+fPnuwsAPfTQQ9y2bVurg9+cTic3b97MAQMGEAAnT57cYnXC/Px89unThwEBAXzrrbfaPJiuoaGBcXFxBMBp06a1+XktWbKENput2ayIyZMn88EHH2zSlpqaysTERI+O63K5mJCQwCFDhrChoYEul4uTJk1iUFDQLQ18FGkPhQER6VCXL19mTk4OR40aRQCMiorismXLWi2Y09DQwHXr1rFPnz708fHhzJkzmy1sVFtby+eee44AGB8fz08//bRNfbp06RL79etHAHz55ZfbtO/nn39OAHz//febtM+aNYuDBw9u0paUlMQpU6Z4dNxrtQp27txJkly7di0BcPPmzW3qn0hHUBgQkU5TUlLCJ598kr6+vvTz8+OMGTNarTpYX1/PFStWMCwsjL6+vkxPT282E6CgoIADBgyg1Wrla6+91qav0i9cuOD+1uL6Cn+eGDZsWLNbAkuWLGH37t2btA0cOJDp6ek3Pd6lS5fYt29f/uIXvyBJHj16lH5+fkxLS2tTv0Q6isKAiHS6qqoqZmRkMDIy0j14cNOmTS1ezGtra7lw4ULa7Xba7XYuXLiwycDE+vp6zps3jz4+Phw6dKjHBZFIsry8nIGBgQTA9957z+P9Fi5cyKCgIF6+fNnd9vbbbxNAk7oLdru92QyDlrz++us0m808ceIEL168yCFDhnDo0KEdUolRpD0UBkSkyzQ0NDAvL49jxowhAPbs2ZO///3vWV5e3mzb8+fPMz09nb6+vgwLC+PKlSubXHg/+eQTxsbG0mQycfbs2R5PHzx27BitVitNJhP379/v0T5Hjx4lAObn57vbdu7cSQD84osvSDauoAiAmzZtuuGxysvLGRAQwNmzZ5Oku9pjW299iHQkhQER+V58+umnfP755xkQEECz2czJkyezoKCg2Yj/M2fO8Omnn6bJZGJkZCTXr1/vXkipoaGBy5Yto5+fH6Ojo7lr1y6Pzl1YWEiTyUSr1epRgSCXy8X+/ftzxowZ7rbDhw8TAIuLi0k21mAA0OJ0yes99dRTDA0NZU1NDf/6178SANetW+dRv0U6i8KAiHyvLly4wLfeess9q2D48OHMzs5u9kn/s88+46RJkwiAgwYN4pYtW9zB4eTJk3zggQcIgNOnT29xAaH/lpeXR8MwGBgYeMOVFq+ZO3cuQ0ND3UGkqqqKALh161aSjesiAGhxRsQ1Bw8eJACuXr2apaWltNvtnDJlipYllu+dwoCI3BacTif/8Y9/MCUlhYZhsFu3bkxPT2dpaWmT7Q4dOuSuHRAXF8edO3fS5XLR6XQyOzubQUFB7Nmzp0djAtasWUMA7NGjx00LJl27kO/evdvdX7PZzKysLJLkpk2bCKDV47hcLt5///0cOnQoL168yBEjRrBfv356v5TbgsKAiNx2Tp8+zTlz5jAkJISGYTA5OZnbt29vsq7Bvn37GB8fTwB84IEH3F/Xnz17luPHjycATpgwocXxCNdbsGABATAmJuaGVQpdLhf79u3L5557zt3Wu3dvLliwgCS5fPly2u32Vve/Vqp4165dTE9Pp8Vi4cGDBz16PUQ6m6fXbxNERLpIdHQ0li5dirNnz2L9+vWorKxEcnIyBg4ciJUrV+LChQsYPXo0PvroI/z973/HV199hfj4eIwfPx41NTXIy8vD5s2b8dFHH2HIkCFYt24dSLZ4rkWLFuHpp5/GqVOnkJCQ0Op2hmFg4sSJyMvLg8vlAgD06tULlZWVAICKigpERES0uG99fT3mzJmDlJQUXLlyBStWrMCSJUswYsSIDni1RLpQRyYLEZG2cLlcLCoq4tSpU2mxWOjv78+0tDQeOXKEZOPKijk5OYyOjqZhGHziiSd4+vRpVldXu9cnSEpK4smTJ1s9/rUFklJSUlrtR2FhIQG4ZyE8+uij7loBU6ZMYVJSUov7LV68mBaLhQUFBQwNDeW4ceM0TkBuK7pNICJ3lMrKSi5atIgREREEwNGjR3PLli38z3/+wytXrjArK4vh4eG0WCx84YUXWFlZyZ07dzIqKoo2m41vvPGGexDg9ZxOp7ts8fW3Av57m/DwcPe0wGeeeYZxcXEkG9cqSE1NbbZPeXk5/f39OXv2bI4ePZoRERG3tKyySGfQbQIRuaOEh4djwYIF+PLLL7F582aQxKRJkxAdHY1ly5bhscceQ2lpKRYtWoTc3FzExMRg3759KCwsRFpaGubMmYP4+HgcPny4yXFNJhOKi4sRHR2NNWvW4PXXX292bpPJhAkTJmDr1q0g2eQ2QWVlZYu3CV555RX4+/vDz88PhYWF2LRpE8LCwjrnxRHpbB2ZLEREOtLhw4f57LPP0maz0WKxMDU1lcXFxayurubcuXNps9nYrVs3ZmRkcO/evbz77rtpNps5f/78JoWMyMbiQWFhYQTADRs2NDvX7t27ichIzikqYnxeHpGZyXtKSmjKyuKoLVu4+uxZfv7tokYlJSUEwPT0dJpMJr766qtd8XKItJmn12+DbGVUzXXq6uoQHByM2tpaBAUFdXY+ERFpoqamBn/+85+RlZWF06dPIy4uDr/+9a+RmJiIN998E9nZ2QgLC8O8efNQVVWFpUuXIiYmBn/605+QkJDgPs65c+cQExODS5cuYfv27Rg7diwA4H+qq7GsrAwFdXUACR8ATsNw7+dDwmUYIICkbt3w71WrgJIS1NXV4a677sKePXvg4+PTtS+KiAc8vX4rDIjIHcPlcmHHjh3IzMzEBx98gNDQUMycORPjxo1DdnY2cnNzER0djWeffRZ5eXk4cOAAXnjhBWRkZMButwMATpw4geHDh8PpdGLnxx9jrc2GLefPNwYAD/pg+jYYhP7rX3CtWoUj+/ejT58+nfq8RdpLYUBEftBKS0uxevVqbNiwAQ6HA48++ijGjRuH/Px8bNu2DcOGDcOoUaOQm5uLsLAw/PGPf0RycjIAoKioCAmpqeCbb8InJMSjENCM04kQw0DxT36CAf7+HfrcRDqKwoCIeIWLFy8iNzcXmZmZOHr0KAYNGoTk5GSUlJRg//79iIuLg2EYOHToEFJTU7Fq1SrUBgTgx8XFcLhcgNnc7nP7AAi1WHAgNhZRNlvHPSmRDqIwICJehSQKCwuRmZmJrVu3wmazISkpCadOncKxY8cwdOhQlJWVwWqzITAnB+W+vrh687e/mzIDiLXbURQbC5/rxhmI3A48vX63PxKLiNxGDMNAYmIiEhMTcfbsWWRnZ2Pt2rWoqqrCsGHDUF1dDYfDgeBp01BmsQAkUF8PvPsucPw48NlngMMBvPwy8O3AQrfjx4EdOxp/nj4NOJ3A3r0AgKsAShwOrDp7Fi9FRnb9ExfpAKozICI/OH369MGiRYtw5swZ5ObmIiAgABUVFegeEYHa8eOBa5/ga2uBd94BzpwBYmJaP+CBA8D27Y37tVKa+LUvv8QlZ7tGH4h87xQGROQHy9fXF1OnTkVxcTEOHjyIgS++CFit320QEgK8/37jtwO/+lXrB0pJAfLzgbVrgbi4FjdxOJ14t6qqg5+BSNdQGBARrzBixAiYHn4YxvX39a3WxkBwMyEhgK/vDTcxAOScO3drnRT5nigMiIhXcJL432++wa0PGWwZARxyOFpdHVHkdqYwICJeobS+Hpe/XaK4s3zjdOKLy5c79RwinUFhQES8wtcNDV1ynpqrV7vkPCIdSWFARLxCV1UA0Juq3In0dysiXqHn9bMIOlEPi6VLziPSkRQGRMQrRPn5wd7JKwuGmM3ofZNZByK3I4UBEfEKhmFgVFBQp73p+QCIDwpqOnVR5A6hcsQi4jVmhIdjd01N08a8POCbb4Cvvmr8vagIOH++8f8TJgCBgcC//w3s2tXYduJE48+cnMafPXsCDz8MJ4AZvXp1+nMQ6QwKAyLiNSb26IGQkydRc/Xqd/UG/vY34PpiQYWFjf8A4KGHvgsDGzY0Pdi13++5B8bDD6OHxYKU0NDOfgoinUJhQES8hq/JhDdjYjD92qd7oLEU8c3ce697YaKWEMDKu+6C2aQ7r3Jn0l+uiHiVJ8PD8UhICDpqKKEPgJTQUDz+ox910BFFup7CgIh4FcMwkDN4MGJstlsOBD4ABvr74+1BgzRwUO5oCgMi4nVCLRYU/vjHGBoQ0O5iRAaAewID8eG996K7agvIHU5hQES80o+sVhyIi8P8vn1hAmD28JO92TDgA+DVqCh8HBuLsC4qZiTSmRQGRMRr+ZpMWBwdjaMjR+KZXr1g+3YAoA++u+ibDcP9RulvMiGtVy/838iReDUqChYNGJQfCIMerLdZV1eH4OBg1NbWIigoqCv6JSLS5RxXr6LE4cAhhwOfX7qEKy4XfE0mDPT3xwi7HffZ7Qg0axKW3Dk8vX7rr1pE5Ft2sxljunfHmO7dv++uiHQpfcclIiLi5RQGREREvJzCgIiIiJdTGBAREfFyCgMiIiJeTmFARETEyykMiIiIeDmFARERES+nMCAiIuLlFAZERES8nMKAiIiIl1MYEBER8XIKAyIiIl5OYUBERMTLKQyIiIh4OYUBERERL6cwICIi4uXMnmxEEgBQV1fXqZ0RERGRjnPtun3tOt4aj8KAw+EAAERGRt5it0RERKSrORwOBAcHt/q4wZvFBQAulwsVFRWw2+0wDKNDOygiIiKdgyQcDgciIiJgMrU+MsCjMCAiIiI/XBpAKCIi4uUUBkRERLycwoCIiIiXUxgQERHxcgoDIiIiXk5hQERExMspDIiIiHi5/wdZ0R/W4wbAzQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print QAOA results\n", + "for num_circuit in range(ncircuits):\n", + " print(f'Circuit #{num_circuit}')\n", + " c = QAOAansatz(params=params_easy[num_circuit], g=easy_graph, return_circuit=True)\n", + " loss = QAOAansatz(params=params_easy[num_circuit], g=easy_graph)\n", + "\n", + " # measurement output\n", + " m_out, m_prob = c.sample()\n", + " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", + " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", + "\n", + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + "\n", + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if m_out[i] == '0' else 'c' for i in easy_graph.nodes]\n", + "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "4ae99ab9", + "metadata": {}, + "source": [ + "## Classical Method" + ] + }, + { + "cell_type": "markdown", + "id": "720dd1a4", + "metadata": {}, + "source": [ + "Here we use two classical methods. The first is the brutal force method (BF), which is to check all bit string one-by-one and need exponential time, thus the obtained solution is guaranteed to be correct." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2115bb6d", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:09.636366200Z", + "start_time": "2023-06-30T02:29:09.635854Z" + } + }, + "outputs": [], + "source": [ + "def b2s(bit):\n", + " return 1 - 2 * int(bit)\n", + "\n", + "def energy(cfg, graph, normalize=True):\n", + " E = 0.25\n", + " for a, b in graph.edges:\n", + " E += cfg[a] * cfg[b] * graph[a][b]['weight'] * factor\n", + " return E if normalize else E / factor\n", + "\n", + "def brutal_force(graph):\n", + " num_nodes = graph.number_of_nodes()\n", + " min_cost, best_case = 1., []\n", + " for i in range(2 ** num_nodes):\n", + " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + "\n", + " cost = energy(list(map(b2s, case)), graph)\n", + "\n", + " gap = min_cost - cost\n", + " if gap > 1e-6:\n", + " min_cost = cost\n", + " best_case = [case]\n", + " elif abs(gap) < 1e-6:\n", + " best_case.append(case)\n", + "\n", + " return best_case, min_cost" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b0cdc04f", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:09.976150600Z", + "start_time": "2023-06-30T02:29:09.635854Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost: 0.000\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print BF results\n", + "bf_best_cases, bf_best = brutal_force(easy_graph)\n", + "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in easy_graph.nodes]\n", + "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "20324164", + "metadata": {}, + "source": [ + "Another method is the simulated annealing method (SA), which is an approximation method that can be done in polynomial time, so the obtained solution has only a certain probability of being correct." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e1551fb4", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:09.976664900Z", + "start_time": "2023-06-30T02:29:09.976150600Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "def sim_annealing(graph, t_max: int, T: float):\n", + " num_nodes = graph.number_of_nodes()\n", + " state = np.random.randint(0, 2, num_nodes)\n", + " next_state = state.copy()\n", + " E = energy(1 - 2 * state, graph, normalize=False)\n", + " t = 0\n", + " while t < t_max:\n", + " temper = (1 - t / t_max) * T\n", + " flip_idx = np.random.randint(num_nodes)\n", + " next_state[flip_idx] = 1 - next_state[flip_idx]\n", + " next_E = energy(1 - 2 * next_state, graph, normalize=False)\n", + " if next_E <= E or np.exp(-(next_E - E) / temper) > np.random.rand():\n", + " state[flip_idx] = 1 - state[flip_idx]\n", + " E = next_E\n", + " else:\n", + " next_state[flip_idx] = 1 - next_state[flip_idx]\n", + " t += 1\n", + " return ''.join(map(str, state.tolist())), E" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "04596ec1", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:53:56.645392800Z", + "start_time": "2023-06-30T02:53:52.616150200Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "output: 111111000000\n", + "cost: 0.000\n", + "prob: 0.880\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print SA results\n", + "sa_best_cases, sa_best, n_exp = [], float('inf'), 100\n", + "for _ in range(n_exp):\n", + " sa_case, sa_cost = sim_annealing(easy_graph, 200, 1)\n", + " gap = sa_best - sa_cost\n", + " if gap > 1e-6:\n", + " sa_best = sa_cost\n", + " sa_best_cases = [sa_case]\n", + " elif abs(gap) < 1e-6:\n", + " sa_best_cases.append(sa_case)\n", + "sa_prob = len(sa_best_cases) / n_exp\n", + "sa_best_cases = list(set(sa_best_cases))\n", + "print(f'output: {sa_case}\\ncost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if sa_case[i] == '0' else 'c' for i in easy_graph.nodes]\n", + "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "e9b8619b", + "metadata": {}, + "source": [ + "## Hard Problem" + ] + }, + { + "cell_type": "markdown", + "id": "9f8cb1da", + "metadata": {}, + "source": [ + "We call the above problem a easy problem, because the classical simulated annealing method has a high probability to obtain the correct solution. Now let's define another relatively hard problem." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b0a1f778", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:14.201998500Z", + "start_time": "2023-06-30T02:29:14.058753400Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# a hard graph instance\n", + "hard_clauses = [[4, 1, 7], [5, 11, 8], [4, 1, 8], [4, 11, 8], [4, 1, 10], [5, 11, 8], [4, 1, 8], [1, 11, 8], [4, 1, 7], [0, 11, 8], [4, 1, 10], [4, 11, 8], [5, 0, 10], [0, 6, 7], [5, 0, 11], [0, 6, 7], [5, 0, 9], [3, 6, 7], [5, 0, 8], [5, 6, 7], [5, 0, 10], [3, 6, 7], [5, 0, 10], [1, 6, 7], [2, 4, 6], [1, 8, 11], [2, 4, 6], [2, 8, 11], [2, 4, 9], [5, 8, 11], [2, 4, 10], [2, 8, 11], [2, 4, 10], [4, 8, 11], [2, 4, 8], [4, 8, 11], [3, 0, 9], [5, 11, 7], [3, 0, 10], [2, 11, 7], [3, 0, 9], [0, 11, 7], [3, 0, 9], [5, 11, 7], [3, 0, 10], [3, 11, 7], [3, 0, 7], [4, 11, 7], [5, 0, 10], [4, 0, 10], [2, 5, 6], [2, 11, 10], [2, 6, 10], [2, 4, 9], [0, 9, 10], [3, 0, 7], [2, 5, 6], [1, 10, 9], [1, 4, 11], [5, 10, 11], [0, 4, 8], [0, 9, 8], [2, 11, 10], [2, 8, 6], [3, 6, 7], [0, 8, 10], [4, 0, 9], [3, 5, 8], [5, 11, 10], [2, 11, 10], [4, 11, 8], [1, 3, 11]]\n", + "factor = 1 / len(hard_clauses) / 4\n", + "\n", + "# convert to a NetworkX graph\n", + "hard_graph = nx.Graph()\n", + "for i, j, k in hard_clauses:\n", + " hard_graph.add_edge(i, j, weight=0)\n", + " hard_graph.add_edge(j, k, weight=0)\n", + " hard_graph.add_edge(k, i, weight=0)\n", + "for i, j, k in hard_clauses:\n", + " hard_graph[i][j]['weight'] += 1\n", + " hard_graph[j][k]['weight'] += 1\n", + " hard_graph[k][i]['weight'] += 1\n", + "pos_hard = nx.spring_layout(hard_graph)\n", + "nx.draw_networkx(hard_graph, with_labels=True, pos=pos_hard)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "d37be898", + "metadata": {}, + "source": [ + "We first solve this problem by two classical methods." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f22b5956", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:29:14.525210200Z", + "start_time": "2023-06-30T02:29:14.223057500Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost: 0.000\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVhUWxfG35mhO6VNBBUTxVYM7G702t3d3d3dXdjd1/ba3XENREExEAQk5rzfH9yZT6RmYIbQ83ueecQ5Z++zp85ae6WEJCEiIiIiIiLyxyLN6AWIiIiIiIiIZCyiMiAiIiIiIvKHIyoDIiIiIiIifziiMiAiIiIiIvKHIyoDIiIiIiIifziiMiAiIiIiIvKHIyoDIiIiIiIifzg6qpwkCALev38PU1NTSCQSba9JRERERERERAOQRFhYGBwdHSGVJr3/V0kZeP/+PVxcXDS2OBEREREREZH04+3bt3B2dk7yuErKgKmpqXIyMzMzzaxMRERERERERKuEhobCxcVFKceTQiVlQOEaMDMzE5UBERERERGRLEZKLn4xgFBEREREROQPR1QGRERERERE/nBEZUBEREREROQPR1QGRERERERE/nBEZUBEREREROQPR1QGRERERERE/nBEZUBEREREROQPR1QGRERERERE/nBEZUBEREREROQPR1QGRERERERE/nBEZUBEREREROQPR1QGRERERERE/nBEZUBEREREROQPR1QGRERERERE/nBEZUBEREREROQPR1QGRERERERE/nB0MnoBIiIiIiIimoIk3vz4gXfR0ZCTMNfRQT4jI+hLxb1vcojKgIiIiIhIliZWEHDw82esDgzExW/fECqXxzuuI5GggJERWmTLhk4ODrDT08uglWZeJCSZ0kmhoaEwNzfHt2/fYGZmlh7rEhERERERSZF9wcHo+fw5AqOjIQMgT+ZcKQCpRIKejo6Ymjs3jGWydFplxqGq/BbtJiIiIiIiWY5wuRytHj1Co4cPERQdDSB5RQAABACxJBa/ewePa9dwLTRU6+vMKojKgIiISMYRGwvs3w/06gWUKAGYmgJ6eoCJCVCsGNC9O7BzJ/DfzV5EBADCYmNR9c4d7Pj4EQCQonn7FwQAAVFR8L5zB+dCQjS9vCyJ6CYQERFJf2JigAULgDlzgKAgQEcnTjH4FcXzNjZA//7A4MGAvn66L1ck80ASNe/dw99fv6ZoCUgJKQB9qRS3ihdHPmNjTSwv0yG6CURERDInDx4AXl7A0KFxigCQuCLw8/OfPgFjxgBFiwK3bqXLMkUyJyvev8eJ5BSBp0/jvlt16gC1awNDhgAvXiR6qgAgRhDQ9skTyFPeF//WiMqAiIhI+nH2LFCyJPDwIaDuzZcEnj8HypQBjhzRyvJEMjcfoqMx8N9/kz7h2TOgb18gMBBo1w5o2xYICIizKvn7JzokFsD1sDAse/dOK2vOKojKgIiISPpw/TpQqxYQFZW0JSAl5PI4F0PDhsD58xpdnkjmZ3VgIKIEIekT1q6NcyMtXgw0bw74+sb9LQjA6tXJzj377VsIf7B1QFQGREREtE9EBNCiRZwg/+Vmfh1AbwAeAIwBZAfQHMCzpOYi45SCFi2Ab9+0uGiRzIRAYsm7d0hGFQDu3wc8PQFz8/8/Z20NFCkCXLkCREYmOfRNVBT+/vpVY+vNaojKgIiIiPYZOxZ48yZOiP/CDAC7AVQFsABAVwDnAXgCeJDUfIIABAfH+YNF/gieR0YiMKWskpiYxANM9fXjjr16leRQHYkEp0RlQERERERLfP0KLFqUwCKgYCCANwAWAugMYDSAC4jz5U5Pbl65PM4s/P69Ztcrkim5GRaW8kkuLsDjx/GVzpgY4MmTuL+Dg5McGkvimirX+E0RlQERERHtsm5d3A05CcoC+LU4bF7EuQ0eqzL/qlWpXppI1uF5ZCR0JJLkT2rQAHj7Fpg1C3j9Os4SMG0a8Plz3PEULAtPIiI0s9gsiNibQERERLvs2qV25gABfECcQpAscjmwYwcwblwqFyciCAJiYmIQExOD6OhoREdHx/s7pf9r41hi54Y2b47Yhg0BXd2kX0z9+sDHj4CfH3D8eNxz7u5xgYSbNwOGhsm+F8kGJ/7miMqAiIiI9pDLgdu31R62BcA7ABNVOfnpU+DHD8DAQO3raBqSiI2N1Yjw05QQTelYbGozO35BKpVCT09P+dDV1U3078SOyWQy6OjoKB/S/zoMxsTEIDY2FhEREYj+/h1IyTIAAJ07xwWXvn4NGBsDuXP/33rk7JzsUIM/uLOhqAyIiIhoj9ev4wS1GjwB0AtAGQDtVBkgl+PWli34mjNnphCwmkJfXz9FIfrrMUNDQ5ibmyc7Tl1BrcoxhUBXEB0djQ8fPiAoKAiBgYEICgqK93dgYCBevnyJoKAgREVFxXvdJiYmsLe3h729PTw8PGBvbw8HBwc8cXTERh0VRZapKVCo0P//f+sWYGsLZM+e5BAJAA8jI3U+ot8KURkQERHRHmoGZAUBqAPAHMAuAKr2lOvXuTMuJnM8tcLP2NhYq0I0qf/LZDJIVNkFpyMk8e3bN6UgT0rIBwUF4bPCR/8fUqkU2bJlUwr2AgUKoEqVKnBwcFA+p1AATExMAAAfPnzAuXPncPbsWWzatAmPv30DtmxRf+GnT8cFEPboASSz85dJJPD6g8vti8qAiIiI9lB1JwfgG4BaAEIQl03gqMZlNm/dCnmpUokKWB0dnUwnWDMT0dHR+PjxYwKBnpiQ/3UXb2xsHE+g58+fP55wV/xra2sbz3KQGIGBgTh06JBSAXjyXwaAu7s7vL29MbpSJQyWShEolyftLrh7F9i4Ma7plZlZXGbB0aNxVS+bNEn2+rEkqltaqv7G/WaIyoCIiIjGCQkJwZ07d/Don3/QU4XzfwCoh7hCQ6cAFFDzejkqVEjRH/wn8fMu/lfB/quQT24Xb29vj/z586Ny5cqJCnnFLj41vH//HufOnVMK/6dPnwIA8uXLh0qVKmHcuHHw9vaGg4MD3r9/j0WLFuHriRNAmzZJKwM2NnG7fz+/uEJXDg5Ap05As2ZAMsqIBICroSG8LSxS/XqyOqIyICIikiY+fPiA27dv49atW8p/X758CQAwNDREYz092CeT0iUH0ALAZQD7ERcroBZWVoCTU+oWn8WIiYnBhw8fkt29Kx4/fonV+HkXrxDyv5roHRwcYGNjAx01LDqq8u7dO6XgP3fuHJ49i6sxmT9/flSpUgUTJkyAt7c37O3tlWMePHiAkSNHYsuWLTAwMECn3r2xXiZDuCAkrhA4OcWlFaoJAQx1cfmjLUiiMiAiIqISJOHv7x9P6N++fRvv/yv6Y25ujmLFiqFBgwbw9PREsWLF4O7uDp1OnYCtW5PsRzAIwAHEWQa+ANj8y/HWyS1KJgPKl1ctyjyTotjFp2SiDwoKwqdPn+KNlUgkyJYtm1Kg58uXL8EuXvF3WnbxqSEgICCe8H/+/DkAoECBAvDx8cHkyZNRsWJF2NnZxRtHEmfOnMHs2bNx9OhRODk5YerUqejSpQv09PTwaOFCnClVSmPr1JFIUMbMDB0dHDQ2Z1ZEQqacAKxqP2QREZHfA7lcjufPnyfY8X/9r1xrtmzZ4OnpqRT6np6eyJUrV+I7qwsXgIoVk7xWJQDnkllLijeow4fjWtVmMhS7eFWE/K+7eCMjIzg4OCQQ6L8KeVtbW63s4lPD27dvlcL/7Nmz+Pe/7oIeHh6oVKkSKlWqhIoVKyJbtmyJjo+JicHOnTsxe/Zs3L59G4ULF8aQIUPQvHlz6Onp4eHDh2jRogVe/Psv8u/YgXumpsn3KVABGQBjmQy3S5RA7hRqEGRVVJXfojIgIvKHEx0djUePHsUT+nfv3kV4eDgAIEeOHPGEfrFixeDg4KC6SZWMS/N68iTR3gSpRiqNKz/78mWyUeKahCRCQ0NVCrZLahef2K791+dMTU3T5fWkBX9//3jCX+EaKliwYDzhb2trm+w8YWFhWL16NebPnw9/f39Ur14dgwcPho+PDyQSCUhi5cqV6N+/P/LkyYPt27cjT/78qHf/Ps6EhKRaIZABMJLJcKpIEZT8jeWaqvI7c6iUIiIi6UJ4eDju3bsXb8f/4MEDREdHQyKRwN3dHcWKFUOjRo1QrFgxFCtWDFZWVmm7qEQCrFgBVKigmRehQBDi5tWAIvDzLj6p3bvi76R28QqB7u7unmREfWbZxaeGN2/exBP+r/5r+lOoUCHUqVNHKfxtbGxUmu/du3dYtGgRli9fjvDwcLRs2RKDBg1CkSJFlOd8/foVXbp0we7du9GtWzfMnTsXRv/VAjhcuDDqHDuGv42MICFBNVxFEgBuRkbYUaAACqaz+ySzIloGRER+U75+/Yo7d+7E2/E/ffoUgiBAV1cXHh4e8Xb8hQsX1qpfObhdO1hv3KiRhihyACecnVHu4cMk70m/7uKTE/LJ7eKT2r3/HFH/OwaevX79WunvP3v2LF6/fg0AKFKkCLy9vVGpUiVUqFBBZeGv4P79+5gzZw62bt0KQ0NDdOvWDX379oXzL9kgly5dQqtWrRAaGorVq1ejyS+pgR8+fICHhwc82rTB09q18UFXFzLEfTcSQ/EJ6UulGOLigtE5ckDvD6g4KLoJRP48SODsWeDMGeD69bgytdHRgJFRnJm6RAmgVi2gaNGMXqnGCQoKShDYp9i5GRoaomjRovHM/B4eHtBPrNWrlrhw4QIa1q2LXQAqhYVBomavgp+hVIoPBQrA49UrmFhbo0ePHoiJiUlUyCe3i09OyGf1Xby6kEwg/N+8eQOJRJJA+FtbW6dq/tOnT2P27Nk4duwYnJ2d0b9/f3Tu3Bnm5ubxzpXL5Zg+fTrGjRuH0qVLY8uWLciRI0eC+Zo0aYKLFy/iwYMHqF2nDlC0KNwGDMCFb98Q8Gs9BKkUnqamaJEtG9rY2cHsD/psRWVA5M9BLo8zF8+ZE+c/1tGJe+7nr7Yix1guB7y8gBEjgEaNMma9aUBx0/41sC8oKAgAYGFhEU/oe3p6ws3NLcWCL9pk37598PX1RdmyZbFv506YDR4MrF8POVSvMAgAAuLarO4E0AbAz7d7S0tLZM+ePUUh/7vu4tWFJF69ehVP+Pv7+0MikaBo0aKoVKkSvL29UaFChTS5iX4NCixSpIgyKFA3kYZD7969Q5s2bXD27FmMGjUK48aNS1Qp27ZtG1q1aoWdO3fC0dER5cqVw6FDh1CnTh0AwJeYGLyPisKqdeuwfskSfH38GNI/9HNXWX5TBb59+0YA/Pbtmyqni4ikH48ekSVKkAApkcT9m9JDKo37t1Ej8sOHjH4FSRIbG8tHjx5x8+bNHDRoECtXrkwLCwsiLsCe9vb2rF27NkeNGsXdu3fz5cuXFAQho5cdj2XLllEqlbJq1arcs2cPV61axWHDhrGZri4/S6UUAMam8HnJAQoAI/T0uKdZM65etYqHDx/mzZs3ee/ePZYrV476+vrcunVrRr/cTIsgCHzx4gVXr17N1q1b08XFhQAokUjo6enJgQMHcv/+/fzy5YtGrvft2zfOmTNHeZ0aNWrw5MmTyX4/Dx48SGtrazo6OvL06dNJnhcYGEgrKys2b96cJNm8eXPmzZuXcrk8wbmrV68mAEZHR6f9RWVRVJXfomVAJOty+jRQty4QE5NkDnuyyGRAtmxxrgU3N40vTx2io6Px8OHDBBH9Ef/1V8+VK1e8Hb8ioj8j4H+++OT88O/fv8fLly+V61cgkUigr6+PmJgYVCtbFs1jY1Hr+XPY/+ezp0QCSKUQ5PL/Ww3c3YE+feIqzyVy/4mKikKXLl2wadMmjB8/HmPHjv3jd/8k8e+//yqD/c6dO4eAgABIpVIUK1Ys3s7fQoNV9969e4cFCxZgxYoViIiIQKtWrTBo0CAULlw4yTFRUVEYOnQoFi5ciLp162LdunVJxiGQROPGjXHp0iU8fPgQP378QK5cuTBv3jz06dMnwfn79+9Hw4YNERQUlKCewZ+CmE0g8ntz6VJcbnlMTFxUeWqQy4Hg4Lgc+KtXgV/8ktoiPDwcd+/eTRDRHxMTA6lUCnd3d3h6eqJJkybw9PRE0aJFYZkONdNjY2NVjqiPjIyMN9bQ0DCeSV4ikSAiIgINGzZEp06d4OjoCHt7ezx+/Bg+Pj5Yvnw5unXrphxfMlcuOAQGYv+MGcCPH1i3aRP8DQww8fBhIIWbuL6+PjZs2AB3d3eMHj0aT58+xdq1a2GQCVoapxck8eLFC6XwP3v2LN6/fw+pVApPT0/4+vqiUqVKKF++fAIfvSa4d++eMijQyMgI3bt3R58+fRIEBf7K06dP4evri0ePHmHBggXo06dPsorctm3bsG/fPuzatQu2trYYPnw4jI2N0b59+0TPV6Q1BgcH/7HKgKqIlgGRrMe3b0C+fMDHjyopAlMAjAbgAeBBYifo6AClSgHnz2s8X/3r168J/PtPnz4FSejq6qJQoULxdvyFCxeGsbGxxq5PEmFhYSpH1P98O5BIJLC1tVUpot7U1BQSiQRRUVFo3bo19uzZg+XLl6NLly7K+aKiopSKzcWLF5U964E4ZSJHjhzK5jR9+vTBmTNn8OBBop9YkuzcuRNt27ZF0aJFsW/fvt9WAJDE8+fP4wn/wMBASKVSFC9eXJnnX65cOa0If8Ua/v77b8yePRvHjx+Hi4uLMigwJTlBEhs2bEDv3r3h5OSE7du3o1ixYsmOCQoKgoeHB6pVq4bt27cjIiICzs7OaNeuHebNm5fomGfPnsHd3R1nzpxBpUqVUvtSszSiZUDk92Xw4LgdvQqKQACAqQCSFa+xsXGWhqVLgd69U72swMDABBH9inQsY2NjFClSBD4+PhgyZAg8PT1RoEAB6OnppepasbGx8TrNJSfkU9rFV6hQIcmI+sSCvJIiNDQUDRs2xOXLl7F79240bNgw3vFZs2bhxYsXuHXrVjxFICQkBD9+/EDRn7I8smfPjjdv3oCkWib/Zs2aIUeOHKhfvz5KlSqFQ4cOoWDBgiqPz6yQxNOnT+Pl+QcFBUEmk6FEiRJo06aNUvhre8MWExMDPz8/zJ49G3fv3kXRokWxZcsWNGvWTKXvS2hoKLp3745t27ahQ4cOWLhwYYoprSTRvXt36OjoYPHixQCAzZs3IyQkJFH3gIKfLQMiySMqAyJZizdvgDVr4mcKJMNgAKURl3v8KYVzMWEC0LUrkIKA5n+R2L/u+D98+AAgLrK9WLFiaNq0qXLXnzdv3hQj+hW7+JRM9Ent4m1sbJQC3dXVNUkhr9jFa5KgoCDUqlULr169wokTJ1DhlwJDz58/x+TJkzFo0CAUKlQo3rFDhw4BAKpUqaJ8Lnv27Pj+/Tu+ffumtk+7ZMmSuHbtGurVq4eyZcvCz88PtWrVSt0LyyBI4smTJ/Gi/T98+ACZTAYvLy+0a9dOKfzTq1phaGgoVq1ahfnz5yMgIAA1a9bEnDlzUKVKFZW/T9evX4evry+Cg4OxdetWtGzZUqVxW7duxf79+7F7927Y2NiAJBYuXIj69esjd+7cSY4zNzeHTCZLUEdCJCGiMiCStVi5Ms6Ur0JZ2/MAdgG4DSDpvcNPfPoE7NsHNG+ufEoul+Pp06fxhP6dO3cQEhICAHBwcICnpye6dOmiNPXnyJEj3s3xZ198ckI+KCgoQcCdgYFBvBr1CgH/q9le3V28Jnnx4gWqV6+OqKgoXLhwIYGwJ4mePXvCwcEBY8eOTTD+5MmTABDPkpA9e3YAcSVvUxPglj17dly8eBGtWrVC3bp1MX/+/GR3kBkNSTx+/Die8P/48SN0dHTg5eWFjh07wtvbG2XLlk33UsUBAQFYsGABVq5cicjISGVQ4K+fc3IIgoA5c+Zg5MiRKFasGE6cOIE8efKoNDYwMBB9+vSBr68vGjduDAD4+++/8fDhQyxatCjZsVKpFDY2NqIyoAKiMiCStdiyRSVFQI44BaAzAFVvWZTJELJ8OXaHhiqF/927d5Vm9ty5c6NYsWIYMmQIihYtirx584KkUqD7+/vj6tWrCYR8cHAwfg3NUfjiHRwc4u3ifxXy2tjFa5KbN2+iVq1asLKywpkzZxIUhwHidnWnTp3CkSNHlKVkf+bWrVvQ09OL18DGxcUFQFzzm+Qi0ZPD1NQU+/btw5AhQ9C3b188ffoU8+fPzxTFhEji0aNH8aL9g4ODoaOjg5IlS6Jz585K4Z/e3QYV3L17F3PmzMG2bdtgbGyMHj16oE+fPnBSs130hw8f0K5dOxw/fhxDhw7FpEmTVHaPKdwDurq68QT//PnzUbhwYZXiAGxsbEQ3gQpk/K9CRERVQkLi3AQqsBzAGwCn1JheIpcj4swZdD17Fjlz5kTOnDlRr149pUD++vUrgoKCsGbNmmR38QpBXr58+USD7bJly5Zhu3hNcurUKTRq1AgFChTA4cOHE00H+/LlCwYOHIjmzZsnaap//fp1gjRJBwcHyGQy+Pv7p2mNMpkMc+fOhbu7O3r16oUXL17Az89Pa0F1SSEIQjzhf/78eQQHB0NXVxclS5ZE165dlcJfkwGk6kISp06dwuzZs3HixAm4uLhg5syZ6Ny5c6osEidOnECbNm0AAMePH0f16tXVGr9lyxYcOHAAe/bsUX6/nj9/jsOHD2P16tUqKcq2traiZUAVNFm0QEREq5w7p1JRoU8ArQDO/uk5b4AeqhQkAmjxX1EfxcPW1paFChVitWrV2LZtWw4dOpTz5s3jtm3beObMGT558oQhISGZruCPNtm2bRt1dXVZs2ZNfv/+PcnzunTpQjMzM75//z7R4z9+/CAA1qlTJ8GxHDlycPjw4Rpb88mTJ2lubs4CBQrw5cuXGps3MeRyOe/du8eFCxeycePGtLa2JgDq6uqyfPnyHD16NE+dOsXw8HCtrkNVoqOjuXHjRhYuXJgAWKxYMW7dujXVxXqioqI4ZMgQAmD16tUZFBSk9hzv37+npaUlW7ZsGe/5Pn360MbGhhERESrN07RpU/r4+Kh9/d8FVeW3qAyIZB0OHFBJmHcH6AowKpXKwKk1a3j9+nUGBAT80ZXLkmLBggUEwDZt2iT7/ly8eJEAuGTJkiTPOXz4MAFw+vTpCY5VqFCBrVq10siaFTx+/Ji5c+emra0tL126pLF55XI57969ywULFrBRo0a0srIiAOrp6bFChQocM2YM//7770wj/BWEhIRw1qxZdHZ2JgDWqlWLf//9d5oU2xcvXtDLy4s6OjqcOXNmopUBU0IQBNarV492dnb89OlTvPWamJhw1KhRKs/Vo0cPFi1aVO01/C6IyoDI78ehQykK8mcApQAXAnz106MUQLf//v6ckkLw9m1Gv9JMiSAIHDFiBAFw8ODByd7ko6Ki6OHhwZIlSzI2NjbJ83r37k0AfPLkSYJjf/31F8uXL6+Rtf9McHAwy5cvT319fW7ZsiVVc8jlct6+fZvz589nw4YN4wn/ihUrcuzYsTx9+rTKu9f0xt/fn4MHD6apqSl1dXXZvn173r9/P83zbtmyhaampsydOzevXbuW6nk2btxIANy7d2+85+fNm0cdHR2+e/dO5bnGjBlDJyenVK8lqyMqAyK/HzdvpqgMnPnFxJ/Yo19yc0ilZCa9gWckMTEx7NixIwFw9uzZKZ4/bdo0ymQy3r59O9nzvLy8KJPJEt2Jjhgxgjly5EjlipPnx48fbNu2LQFw7NixKe6EY2NjeevWLc6bN48NGjSgpaUlAVBfX5+VKlXiuHHjeObMmUwr/BXcuXOHrVu3po6ODs3NzTl8+HC1BGtShIWFsX379gTAVq1apUlWvHv3jhYWFgmsQrGxscydO3cCt0FKLFiwgPr6+n+UG+9nRGVA5PcjKorU0UlWGQgGuDeRhwfA7P/9fS85ZSB//ox+lZmO8PBw1qtXjzo6Oty0aVOK5//77780MDDgoEGDUjzXysqKdnZ2iR5bunQpZTJZspaFtCAIAqdOnUoA9PX1jSfIY2NjefPmTc6ZM4f169dXNojS19dn5cqVOX78eJ49e5aRkZFaWZsmEQSBx48fZ7Vq1QiA2bNn57x58xgaGqqR+W/fvk13d3caGxtz/fr1aRK6giCwbt26CdwDJLlv3z4C4JUrV9Sac+vWrQSgsdeb1RCVAZHfEy+v/3cdVOOhSsyAIJOR3bpl9CvMVHz+/Jlly5alkZERjx49muL5giCwRo0azJ49O8PCwpI9Vy6XUyKR0NvbO9Hjhw4dIgC+1bLbZufOnTQwMGChQoU4btw41q1bl+bm5gRAAwMDVqlShRMnTuS5c+eyhPBXEBUVxQ0bNrBQoUIEQE9PT27bto0xMTEamV8QBC5YsIB6enosVqxYoq4eddmwYQMBcN++fQmOVa5cmaVKlVJ7zhMnThCA1oNGMyuiMiDye7JyJQU1FQFVlQEC7OXlxf3792ttN5qVePv2LQsUKEBra2uVd2Pbt28nAB44cCDFcy9fvkwAHDFiRKLH7927RwAaDfRTEBMTw+vXr3PWrFmsU6cOjY2NCcS19C1VqhQnTZrE8+fP88ePHxq/trYJCQnhzJkz6eTkRACsXbs2T58+rVEzeXBwMOvWrRvnduvXTyPvk8I98NdffyU4dvfuXQLgtm3b1J739u3bBJCmGIasjKgMiPx2REdHc9ns2QxFXI97dRWClKwCn7NnZ6mSJQmAuXLl4uzZszXW3z2r8ejRI7q4uDB79uwq7/i+fv1Ke3t7Nm7cWKXzR40aRQD8559/Ej0eEhKSagHwKzExMbx27RpnzpzJ2rVr08zMjABoaGhIHx8fTp48mbt372bhwoVpamrKw4cPp/ma6Y2/vz8HDRqkDArs0KEDHzx4oPHrnD59mo6OjrS2tubBgwc1MqfCPWBvb8/Pnz8nON6pUyc6OTmlKrvn7du3BJAlP1NNICoDIr8NgiBw165dzJs3LyUSCdeXKaNRRYAAKZGQFy+SJK9evcrWrVtTV1eXRkZG7N69Ox8+fJjB70L68c8//9DKyooFCxZkQECAyuN69OhBExMTlc36lSpVokQiSdYKY2ZmxhkzZqi8BgUxMTG8evUqZ8yYwVq1atHU1JQAaGRkxGrVqnHKlCm8dOkSo6Ki4o0LCwtj3bp1KZVKuWDBgiwRdHbr1i3+9ddf1NHRoYWFBUeMGJFkXYe0EBMTw9GjR1MikbBSpUpqfTdSQuEe2L9/f4JjwcHBNDAw4JQpU1I1d2RkJAFww4YNaV1mlkRUBkR+Cy5evMjSpUtTkQN99+5dUhDIypVJmUwjikAsQP+mTRNcOzAwkBMmTKC9vT0BsGrVqr+9C+HQoUM0NDRkhQoV+PXrV5XHXb58mRKJhAsWLFB5jL29PS0tLZM9x8PDg717905xrujoaF6+fJnTp09nzZo1aWJiQgA0NjZm9erVOXXqVP7zzz8JhH9ixMbGcuDAgQTAnj17aszHrkkEQeCxY8dYtWpVAmCOHDk4f/58rQXJvX79mmXLlqVMJuPkyZM1+htQuAdat26d6PEpU6bQwMCAwcHBqb6GiYmJSlkwvyOiMiCSpXny5AkbNWpERTW0U6dOxT8hOJh0c0uzQiAHeNXKikY6Oty8eXOia4mKiuKWLVuUSsnv6kJYt24dZTIZGzZsqFaKXHR0NAsXLszixYurLCQEQaBMJmOJEiWSPa9WrVqsX79+otf8559/OG3aNNaoUUPp8zc2NmaNGjU4bdo0Xr58OU1Fo1asWEEdHR1Wr16dISEhqZ5Hk0RFRXH9+vXKoMDixYtz+/btWlVYdu3aRQsLC2bPnl3j8RuCILBOnTpJugeio6Pp6OjITp06pek6uXLl0mg1y6yEqAyIZEmCgoLYo0cPymQyZs+enZs3b066uM2HD6SnZ5yJX90Ygf/+3S2Vsk3z5soc6SlTpiRrGr527RrbtGmjdCF069ZNK37Z9EQQBE6fPp0A2LVrV7UFy6xZsyiVSnnjxg2Vxzx9+lS5806Obt26sWjRooyKiuKlS5c4ZcoUVq9eXSn8TUxMWKtWLU6fPp1XrlzReMXIU6dO0cLCggUKFOC///6r0bnV4evXr5wxYwYdHR2pKN985swZrboxIiIi2K1bNwJgkyZNtKL8rl+/PtmAU0Va4L1799J0HS8vrzQrFFkVURkQyVJ8//6dEydOpImJCS0sLDhr1izV0riio8mJE+PqD6hoJZADDJNIGLN2Lf3+i34fM2YMx40bp7JA/NWFUKVKFe7bty/LuRDkcjn79++vfA/UFS6vX7+mkZER+/Xrp9a4mTNnEkCSAWhRUVG8ePEifXx8lIoXAJqamrJ27dqcMWMGr169mi4m/MePHzNPnjy0sbHhxf/iStKLN2/ecMCAATQxMaGenh47duyYLvEr9+/fp4eHBw0MDLhixQqtKB0BAQE0NzdnmzZtkjynVKlSrFKlSpqvVbt2bTZo0CDN82RFRGVAJEsQExPDVatW0cHBgXp6ehw4cGCi5sIU+fdfcvBghv2nEAgAoyUSUlc37qFQBpycGNS/P7NJJFy4cCHJuGp5igCjtWvXUkdHh7Vr104xT56ME1pbt25VuhBy5szJWbNmZQkXQlRUFFu2bEmJRJJs/4CkUJh4nZyc1PZVK9LSFLX6f/z4wQsXLnDSpEn08fGhoaEhFXn+ADh58mReu3Ytw/z3wcHBrFChAvX09JJ0J2mSW7dusVWrVpTJZLS0tOTIkSO1EhT4K4IgcNmyZTQwMGDBggW1ZvUSBIG1a9emg4NDkr+VK1euJBlUqC5t27Zl2bJl0zxPVkRUBkQyNYIg8ODBgyxQoAAVJUzTWhTk27dvNJTJ6Dd0KCe7uPBY4cJkv37k8OHkhg3kw4fkfy6HDh060NbWlqGhoRQEgZ07d6auri7PnDnD48eP08TEhMWLF2dgYKDK1//VhdC1a1eN1HvXBqGhoaxWrRr19PS4c+fOVM2xa9cuAuCePXvUHps9e3YaGBhw4sSJrFKlilL4m5mZsW7dupw9ezavX7/O06dPEwAfPXqUqjVqkh8/frBdu3ZKK0pqGvAkhyAIPHr0KKtUqaJULBcsWKCSUqoJvnz5wiZNmhAAu3fvrtXSyuvWrUvWMkSSLVu2ZO7cuTVibRs4cCDd3NzSPE9WRFQGRDIt165do7e3NwGwcuXKavmak2Pnzp0EwFevXtHGxoaTJ09O8lx/f3/q6+tz/PjxJOMClapVq0YLCws+evSIt2/fpqOjI3PkyKG2IAoKCuLEiRPp4OCgdCHs3bs307gQPnz4wBIlStDU1JSnT59O1Rzfvn2jo6Mj69evr5IJOTIykufOneOECRNYuXJlKvpEmJubs169epwzZw5v3ryZ4D16+fIlAfD48eOpWqemEQRBaUlq3ry5RgRmVFQU161bx4IFCxIAS5QoQT8/v3S1gly4cIEuLi60sLDgrl27tHothXugbdu2yZ6jo6PDefPmaeSa06ZNSzFz5XdFVAZEMh3//vsvfX19CYAeHh48fPiwRn2R7du3p4eHB79//04A3LhxY7LnDxo0iCYmJvzw4QPJuCI3Hh4ezJUrFz98+EB/f38WLFiQlpaWPHfunNrriYqK4rZt21imTBnlTm/mzJmpc4NoiJcvX9LV1ZV2dna8detWqufp06cPjY2N+ebNm0SPR0ZG8syZMxw/fjwrVapEfX19AqCFhQWrV69ORWW8lBSkqKgoSiQSrlq1KtVr1Qa7du2ioaEhS5UqpZb16Ge+fv3K6dOnK4MC69aty7Nnz6ZrbYPY2FhOnDiRUqmU5cqVS/Lz1BSCILBWrVp0dHRM1pU2cuRImpiYaCyLY9WqVQSQKdNEtY2oDIhkGj59+sT+/ftTV1eXjo6OXLNmjcZ3yXK5nNmyZePQoUP5+PFjAkhRgH/69IlmZmbxgt9ev35Ne3t7li5dmhEREfz69SurVKlCPT29NFXCu379Otu2bUs9PT0aGhqyS5cuaY6QVpc7d+7Q3t6eefLkSVNk/LVr1yiRSDhnzhzlcxERETx9+jTHjRtHb29vpfC3tLRkgwYNOG/ePN6+fZuxsbHKG7OqRWAcHR05ZsyYVK9XW1y/fp0ODg7Mnj17XP0LFXn9+jX79++vDArs1KlThrhBAgIClIWfxowZky6Ccu3atQTAQ4cOJXlOREQEra2t2bdvX41dV9HkSKH4/0mIyoBIhhMREcEZM2bQ3NycpqamnDx5Mr9//66Va127dk2pABw7dkzpLkiJKVOmUE9PL965169fp6GhIZs2bUq5XM6oqCi2adOGADhz5sw07dw+fPjASZMmKV0IlStX5p49e7TuQjhz5gzNzMzo6enJoKCgVM8TExPDYsWKsXDhwjxx4gTHjBnDihUrUk9PjwBoZWXFRo0acf78+bxz506ifnWFdUjVIjKlS5dmu3btUr1mbfL27VsWLVqUJiYmKZa7vXnzJlu2bKkMChw1alSqrQpp5cCBA7S2tqaTkxPPnDmTLtd8+/YtzczMUvwsV69eTYlEwufPn2vs2hcvXiSALJ8GnBpEZUAkw5DL5dy4cSNdXFyoo6PD3r17a10jHzt2LC0sLBgTE8MVK1ZQKpWqlHP+/ft32tvbJ0hv2rdvHyUSCYcOHUoyzrw5evRoZW58WoV3dHQ0t2/fzrJlyyoryGnLhbBr1y7q6enRx8cn1RXqwsPDeerUKWUbXB0dHQKgtbU1GzduzAULFvDu3bsqBdW5u7tTX19f5Ws3b96clStXTtW604OwsDDWr18/0RLGgiDwyJEjyqDAXLlyceHChVpTilMiMjKSffv2JQDWq1cvTVX91EEQBNasWZOOjo7JVrYUBIGFChVi3bp1NXp9RV2Ls2fPanTerICoDIhkCCdOnGDRokWVhUqePXuWLtctXrw4fX19ScY1wHFxcVF57NKlSymRSBKYeufNm0cAXLFihfK5lStXUiaTsV69ehq7od+4cYPt2rXTigth2bJllEgk9PX1VakUr4Lv37/z5MmTHDVqFMuXL09dXV1l0F/u3Lm5aNEi3rt3L1UR9UZGRsyVK5fK5w8ePJiurq5qXyc9iY2N5eDBgwmAPXr0YFhYGNeuXUsPDw8CoJeXF3fs2JGhPusnT56waNGi1NPT48KFC9M1NmHNmjVUpVmQInvk5MmTGr3+58+fCSDVmTNZGVEZEElX7ty5owwMK1u2bJKd6LTB+/fvCYCbNm0iSbZu3ZrlypVTeXx0dDRdXV1Zp06deM8LgsBevXpRJpPx2LFjyucPHz5MY2Njenl5pcnk/isfPnzg5MmTlQFllSpV4p49e1IlQARBUBZR6tu3b4pC+/v37zxx4gRHjhzJsmXLKoW/jY0NmzZtysWLF7NKlSp0cHBIU1CXohOhOgVgFixYQH19fY2n8mmD+fPnUyqVKt0m9erV47lz5zK04ZEgCFy7di2NjIzo7u7O27dvp+v1/f39aWZmxvbt26d4bv369enh4aHx90sul1Mmk3HZsmUanTcrICoDIumCv78/27VrR4lEQjc3N+7Zsyfdb3xr1qyhRCJRmjwrVqzIVq1aqTXH9v8qEZ4/fz7e8zExMaxTpw5NTU3j7dZv3rxJe3t75sqVS+UWv6qicCGUK1eOAJg9e3bOmDFDZRdCbGyssozstGnTEv08wsLCePz4cY4YMYJlypRRmv1tbW3ZrFkzLlmyhA8fPlSOVQRg7dixI02vTVGbQJ2Usb179xKARhUvTfPq1Sv269ePxsbG1NHRoZ6eXpoDNTVBSEgIW7ZsSQDs2LFjursnBEFgjRo16OTklGLjqxcvXlAikXDlypVaWUu2bNk4ceJErcydmRGVARGtEhISwmHDhtHAwIDZsmXj0qVLNV4XXlUaN27MMmXKKP+fI0cOtZuSyOVyenp6smzZsgmEZ1hYGIsWLUoXFxe+e/dO+fyrV6+YP39+WllZaa1M7a8uhM6dOycbuR4ZGcnGjRtTJpNx7dq1yudDQ0N59OhRDh8+nKVLl1YK/2zZsrF58+ZcunQpHz16lKjiEBoaSmdnZ9auXTvNil6XLl0IQK3gsJs3bxIAr127lqZra4MbN27Q19eXMpmMVlZWHD16NAMDA/nkyRO6urrSxsaGFy5cyJC1Xb16lbly5aKpqSm3bt2aIWtYvXo1AfDIkSMpntu/f39aWVkpq1JqmgIFCmg0QyGrICoDIlohKiqK8+fPp7W1NY2MjDhmzBittU1VhR8/ftDExERZYCg2NjbV5sATJ04kWf40ICCATk5O9PT0jLe7+vLlizKVTpv+yF9dCN7e3ty9e3c8F8LXr19ZsWJFGhgY0M/Pj0eOHOGwYcNYqlQpymQyAqC9vT1btGjBZcuW8fHjxyoJ9wEDBtDQ0FCl7IyUKFq0KGUymVpKRXBwMAFovRiOqsjlch4+fJiVKlVSBgUuWrQowa7706dPykwLhQsrvdY3Y8YM6ujosGTJkhlmnVC4Bzp06JDiuaGhoTQzM9NqZ0Fvb2+2bNlSa/NnVkRlQESjCIJAPz8/5s6dm1KplF26dIm3S84oTp48SQC8c+cOybgbkCqBSokhCAKrVKlCDw+PRLMF7ty5QxMTE9arVy/e8R8/ftDX15cSiYRz585N/YtRgejoaPr5+cVzISg69uXMmZMGBgbMnz+/Uvg7ODjQ19eXy5cv55MnT9Te2d+6dYtSqZQzZszQyPrNzMzo4OCg1hhBEGhoaKj19zYlfvz4wTVr1ihLaJcsWZI7d+5MNrMkKipK2RFz9OjRWo97CAwMVGZ8DBs2LMOsdeq4B0hy4cKFlMlk9Pf319qamjRpwmrVqmlt/syKqAyIaIxz587Ry8tLWSUtM+Xq9u/fn87Ozkohl9Z8YkW9gnXr1iV6/MiRI5TJZAm69Mnlcg4bNowA2K9fP63XDQgJCeH8+fOV0eqKh6WlJVu1asUVK1bw6dOnaTLrx8bGskSJEixUqJBGhEpkZCQBsGrVqmqPdXd354ABA9K8htTw5csXTp06Vdmhsn79+jx//rzK7+3PLaI1VcI4MY4dO8Zs2bLRzs6OJ06c0Mo1VEVRWEoV94BcLqerqyubN2+u1TV1796dRYsW1eo1MiOiMiCSZh49esR69eop66WnV3ESdcibNy+7du2q/P+WLVsIIE2ui6ZNm9LFxSXJFspLly4lAGXXw1+PSaVSNmrUSKM3/a9fv/LgwYMcNGgQS5QoQalUqgz409PTo6mpKW1sbJQuhF27dqU5jW3RokUEoLHMEEXa2Lhx49Qe6+PjwyZNmmhkHaryc1Cgvr4+u3btysePH6d6vt27d9PQ0JAlS5bUaLGhqKgoZVpjjRo1MjzQ8s2bNzQ1NWXHjh1VOv/gwYMa/Z4lxejRo+ns7KzVa2RGRGVAJNW8f/+eXbt2pVQqZa5cubht27ZMmdalKCTys49fEw1Jnj59SplMlqxZetCgQZRKpTxw4ECCYwcPHqSRkRFLly7Njx8/pmoNX79+5YEDBzhw4EB6enoqhb+zszNbt27N1atXc+3atTQ2NmaZMmX4+fNnRkdHc8eOHSxfvjwB0MXFhdOmTUtVYZmAgACampqyW7duqVp/YigEVmoCATt27EgvLy+NrSU5rl+/zhYtWlAqldLKyopjxozRmIC9ceMGHRwc6OLiolYJ46R48eIFvby8qKury9mzZ2f471QQBFarVo3Ozs4qp6D6+PjQy8tL61lICxYsoIGBQYameWYEojIgojZhYWEcN24cjY2NaWVlxXnz5vHHjx8ZvawkmTt3LvX19eMFbnXv3p1FihRJ89xdu3altbV1kjc0uVzOxo0b08jIKNGui9euXWO2bNno6uqqUuT8ly9fuH//fg4YMIDFihWjRCJRCvQ2bdpwzZo1/Pfff5U3ss2bN1NHR4d16tRJNPr61q1b7NChA/X19WlgYMBOnTop4ypUoWnTprSzs0u2mYy6lCtXjhKJJFUWi/Hjx9POzk5ja/kVuVzOQ4cOKbtp5s6dm4sXL9ZKKt7bt29ZrFgxmpiYJFujPyU2b95MU1NT5smTh9evX9fgClPPypUrCSBeXY7kePDgAQFw8+bNWl7Z/62G6dUSOrMgKgMiKhMTE8Nly5bRzs6O+vr6HDp0qEpBPxlN1apVWbNmzXjP1apVi/Xr10/z3O/evaOBgQFHjx6d5Dnh4eEsWbIkHRwcEg18evnyJd3d3WljY8PLly/HO/b582fu27eP/fv3Z9GiRZXCP3v27Gzbti3Xrl3Lly9fJrqLmTt3LgGwffv2KfryP378yKlTp9LZ2ZkAWLFixRRdCIcOHSIAjaej2djY0MrKKlVjFQ1uknLdpJYfP35w9erVzJ8/PwGwVKlS3LVrl9ZjPsLCwtigQQNKpVLOmzdPrd1qWFgY27VrRwD866+/Ms19WeEe6NSpk8pjunbtSgcHB7WqY6YWRbaQJrJishKiMiCSIoIgcN++fXR3d6dEImHbtm213sJUU4SGhlJXV5eLFi2K97yHhwf79OmjkWsMGzaMRkZGyfp3g4KCmCNHDhYqVCjR38enT59Yrlw5pZLVr18/FilSRCn8c+TIwXbt2nHdunUp3qQEQeDQoUMJgMOHD1dLgMTExHDnzp2sUKFCsi6E79+/M0eOHKxevbpGzakxMTGUSCQsVapUqsafOnVK7foEyfH582dOmTKFdnZ2lEgkbNCgAS9cuJCuJmS5XM4hQ4YQALt3765SkOatW7fo5uZGY2Njrl+/PtOYvFPjHvj06RMNDQ3TrRDQrVu3Mm29Cm0iKgMiyXL58mWlb9nHxydNve0zgt27dxMAX758qXxOEASamJhw1qxZGrnGly9faGFhwZ49eyZ73sOHD2lubs4aNWoob+jBwcHcvXs3+/bty0KFCimj/a2trdm+fXuuX79erR1KdHQ027Ztq3b1vsS4ffs2O3bsqHQhdOzYUVmidsiQITQwMOCLFy/SdI1fUdyIf83CUBVFfMjp06fTtI6XL1+yT58+NDIyUgYFarqCpLqsXr2aOjo6rFatWpIWOUEQOG/ePOrp6bFYsWJ8+vRp+i4yBVasWKGWe4CMi+/R09NLt7bCb9++VTnD4XdCVAZEEuX58+ds2rQpAbBw4cI8fvx4Ri8pVXTo0IEFChSI99yXL180UjL3ZxTFW1Lake7atYtSqZQeHh7xhH/u3LnZoUMHrlu3Tll9b+DAgWoFen3//p21a9emrq6uRk33wcHB8VwIikDFSZMmaewaCiZNmkQAqf6+RUREEADXr1+fqvHXrl1j8+bNKZVKaW1tzbFjx2aq3vanT5+mpaUl8+XLl0AR+/jxI+vUqUMA7N+/f6aL43n9+jVNTEzYuXNnlcdER0fT2dlZpYJEmkLxHdqwYUO6XTMzICoDIvH4+PEj+/TpQx0dHTo7O3P9+vVa94tqC7lcTjs7Ow4ZMiTe87dv3yYAXrlyRWPXioiIoJOTU4LKZR8+fODOnTvZq1cvFixYMF6uv5eXFzdu3Jioy2XhwoWUSCRs1qyZSv7vT58+sVSpUjQ2Ntaa4hYTE0M/Pz+ampoSAJ2cnDh16lSNtrdVFMJJS0Cera2tWiZluVzOgwcPsmLFigTAPHnycMmSJVord5tWnj59SldXV1pbWytLGJ8+fZoODg60sbFJU7ChthAEgT4+PnRxcVFLPvj5+cUrFpZeGBsbc86cOel6zYxGVAZESMYFuU2dOpVmZmY0MzPj9OnTtVb0JL24fv06gYS9yffv308AGs3hJv9fQGXGjBns2bOnsgIdALq6urJz587ctGkT/f39OWrUKALJt0rdu3cvDQwMWK5cOX769CnJ8968ecN8+fLR1tZW69Hiy5YtIwCuWbOGHTt2pIGBAfX19dmhQweNuJCcnJxoYmKSpjmKFy+u0u4zMjKSq1atYr58+QiApUuX5u7du7OE8vvp0yd6e3tTT0+P9erVo0QiYZUqVTJFtc/EWL58eaosPmXLlqW3t7d2FpUMOXPm1GrJ48yIqAz84cTGxnLt2rV0cnKirq4u+/Xrp9GdXkYyfvx4mpubJwi4WrhwIfX09DSSax0UFEQ/Pz/26NFDGWkOgHnz5mWXLl24ZcsWBgQEJBgnl8vp6+tLAwODBBkEP3P58mXa2NjQ3d090drx9+/fp5OTE3PmzMlnz56l+fUkR2BgIM3NzeNFgQcHB3PatGlKF0L58uW5Y8eOVFUiFASBMpmMhQoVStM6GzVqxOrVqyd5/NOnT5w8ebIyKLBhw4ZaayClTZ4+fUpbW1sCcW2sM6qkcEq8evWKJiYm7NKli1rjFMr8nj17tLSypClRooRa7ozfAVEZ+EMRBIFHjx5V+q2bN2+u8WCwjKZEiRKJli4dPHgwXV1dUzVnYGAgt2/fzu7duyt3lADo5ubGrl27sn///ioHsEVGRrJcuXK0tbWNF+D4K8+fP6erqyuzZcsWL8L5woULtLCwYJEiRfj+/ftUvR518PX1pa2tbaItkmNiYrhr1y6lqd3Z2ZlTpkxRq5jSixcvlKmQaaFfv37Mnz9/guf//fdf9u7dm0ZGRjQwMGC3bt0yXYCdquzcuZPm5ubMnj07e/bsqXQpZTbXhiAIrFq1KrNnz662XGjdujVz5syZIZaaWrVqsWHDhul+3YxEVAb+QG7evMmqVasSACtUqKBR33lmITAwkAC4cePGBMeaNWvGKlWqqDTP+/fvuW3bNnbr1o3u7u5K4e/u7s5u3bpx27Zt8QSxIAgsWbIkS5YsqVI6V3BwMF1dXZkvX75kC/cEBwezTJkyNDIy4oEDB7h//34aGBiwUqVKKqdopYVjx44l+X7+yp07d9ipUyelC6F9+/YquRAUZY23bduWprXOnj2bxsbGyvf/6tWrbNasmTIocNy4cZkqKFAdwsPD2bVrVwJg06ZNlVkFe/bsoZGREb28vNJFMVQVhVtJ3R4I79+/p66ubob57du0acNy5cplyLUzClEZ+IN4/fo1W7duTQDMnz8/Dxw4kGnyjzXN2rVrKZFIEt2ZlixZMsno5Hfv3nHLli3s2rUr3dzclMI/f/787N69O7dv355irIGitr6qrXSfPXtGKysrVq5cOdmiKhEREWzUqBElEgklEgmbNGmi8eI6iREeHs5cuXKxSpUqan1fPn36xOnTp9PFxUXpQvDz80vSnN2oUSMCSLOg3rFjBwFwy5YtynoJrq6uXLZsWabbOavDvXv3WKBAARoaGnLlypUJPoubN2/S0dGRLi4u6R5wlxgK98DPPUFUZcyYMTQ2Ns6womYDBw6ku7t7hlw7oxCVgT+AL1++cPDgwdTT06O9vT1XrFiR5uY0mZ0mTZqwdOnSiR6zt7fn+PHjScbV1t+8eTO7dOnCvHnzKoV/gQIF2KNHD/r5+aWq3nyNGjXo7u6u8vt8/vx56unpsV27dkkKXEEQOHHiROUaBw8enC415keMGEE9Pb1Um9RjYmK4e/duZQlfJyenRF0IuXPnpr6+fprWGhkZyeHDhyvfozJlynDPnj1ZIigwKQRB4NKlS2lgYMCCBQvy4cOHSZ4bEBCgLGF88ODBdFxlfORyOatUqZIq90BkZCRtbW3Zq1cvLa0uZaZOnZrqKphZFVEZ+I358eMH58yZQ0tLSxobG3PChAl/RL3tqKgompqaJpoH/+zZM6V7xNXVVSk0PDw82KtXL+7YsUMjzWYUxXNWrVql8hhFTfTE0uLkcjl79+5NAJwwYQLnzp1LiURCX19freaTP3jwgDo6OpwwYYJG5rt79y47d+4cz4Vw8+ZNkqS+vn6qYzk+ffrESZMmMVu2bMqqjdOnT9fImjOSz58/Ky0mPXv2VCnD5/v372zYsCElEgnnzp2bIdY/RcfOkydPqj123bp1BJChRZ5WrVqV6v4YWRVRGfgNkcvl3Lp1K3PmzEmZTMbu3btrPI0uM6MoSXv79m36+/tz48aN7NixI3Pnzq0U/rly5WLv3r25c+dOrfmPfX196eTkpFaKpqLozs8NWX78+KEshLN8+XLl87t27aK+vj4rVqyo0UZBCuRyOcuVK0d3d3eNKxwKF0L27NmVNRcAqB209eLFC/bq1YuGhoY0MDBgjx49+OTJk0RLUGc1Lly4QBcXF1paWqodUS+Xy5Ulqbt27ZqumQYvX76ksbFxqjpZCoLAokWLslatWlpYmers3btXIy6rrISoDPxmnD59msWLFycANmjQIE191bMir1+/Zo0aNWhkZMRcuXIphX+hQoXYp08fjh07VqO165Pj+fPn1NHR4YwZM1QeIwgC27dvTz09PZ4/f57fvn1jlSpVqK+vn6hAuHjxIq2srJg/f36NN1ZR1E04c+aMRuf9GYULQZGZYW5uzsmTJ6eYhXDlyhU2bdqUUqmUNjY2HD9+fLwxuXPn5tChQ7W2bm0SGxvLCRMmUCqVsnz58mnqA7JmzRrq6OjQx8cnXfzvcrmclStXZo4cORgaGqr2+LNnz6pdrlgbXLhwgQCSdcn8bojKwG/C/fv3Wbt2bQJxHdXOnz+f0UtKF169esX169ezffv2zJkzp1L4W1lZsW/fvtyzZ0+8ugmKrnbpVaq1Z8+etLCwUGvnHhUVxcqVK9PCwoIFChSgubk5z507l+T5T58+Ze7cuWlvb680uaeVDx8+0NLSMs1pfqqi6KfQrFkzGhgYKOMnfm77LJfLuX//fmWvjLx583LZsmWJWl68vb3p6+ubLmvXJG/fvqW3tzelUinHjRunETP1mTNnkixhrGmWLFlCADx16lSqxjdq1Ij58+fP8MDmJ0+eJFqw7HdGVAayOAEBAezUqROlUinz5MnDnTt3ZvgPSVsIgsCXL19y3bp1bNeuHXPkyEEAlEgkLFKkCPv166e8Ge3bty/ROcaNG0d7e/t0W3NgYCCNjIzUrmZ28+ZN6urqUiaTqXRD+vDhA728vGhsbKyRBiutW7emtbV1uhWg8vDwoEwmo1wu56dPnzhjxgylC6FUqVLs3LmzMsCzXLly3Lt3b7JBgW3atGHZsmXTZe2aYv/+/bSysqKTk5PGhdCzZ8+YN29eWltba22joHAPdO/ePVXjX716RalUymXLlml4Zerz6dMntTKCfgdEZSCL8u3bN44aNYqGhoa0sbHhwoUL06XXd3oiCAL//fdfrl27lm3btlUKB4lEwqJFi7J///7ct29fvCI4io5tSQVKdujQIdXtcVPL6NGjaWhoqHKp2Js3bzJbtmzMlSsXraysWK5cOZVSCL9//8769etTJpNx5cqVqV7vyZMnCYDr1q1L9RzqYmxsTCcnp3jPBQYG0tfXl7q6ugRAAwMDdunSRSU/7qhRo+js7Kyt5WqUyMhIZXBo/fr1ky09nRY+f/7MSpUqUVdXV+NNeORyOStVqpRq9wBJDho0iBYWFmnqS6Ep5HJ5plFM0gtRGchiREdHc/HixbS1taWBgQFHjhyZLkVn0gNBEPjixQuuXr2abdq0UeanSyQSenp6csCAAdy/f3+yJncfHx/WqFEjyeNVqlRhs2bNtLH8JAkJCaG1tbVK+danTp2iiYkJvby8+PHjR165coUGBgb09fVVKY0wNjaWvXr1IgCOGjVKbStRZGQkXV1d6e3tnW4WJkUXSUUJ4efPn7Nnz540NDSkoaEhe/bsyUOHDrFLly40NDSknp4e27ZtG8+F8CsrVqygVCrN9NHgjx8/ZpEiRaivr89FixZp/T2Piopix44dCYAjR47UWGrq4sWLCYB///13qsaHhYXR3Nw8QVOxjMTW1lYrnTkzK6IykEUQBIG7d+9m3rx5KZFI2KFDB759+zajl5UmBEHg8+fPuWrVKrZu3VpZ314qlbJ48eIcNGgQDxw4oHLgU2hoKHV1dblw4cIkz3F1deXgwYM19ApUZ86cOZTJZMmmS/n5+VFXV5c1atSIZ9nYtWuXUrirgiAInDVrFgGwdevWalmMxowZQ11d3XQNPD106BABsFu3bmzSpAklEgltbW05YcKEBG6Kz58/c+bMmUoXUdmyZblt27YE0fJHjx4lgDQF32kTQRC4evVqGhkZMV++fOlaJEjx/ZBIJGzatGmaCzH9+++/NDIyYo8ePVI9x5IlSyiVSvn69es0rUWTFChQgP369cvoZaQbojKQBbh48SLLlClDAKxVqxbv3r2b0UtKFYIg8NmzZ1y5ciVbtWpFJycnpfAvUaIEBw8ezIMHD6Y66nnPnj0EkGhDHzLO9Kenp5essqAtIiMj6eLiwqZNmyZ6fNGiRZRIJPzrr78SFd4zZ85UdgtUle3bt1NPT4+VK1dW6T19/PgxdXV1OWbMGJWvkVbkcjlr1aoVr8fDihUrUkzHjI2N5d69e1m5cmUCoKOjIydNmqR0ITx8+JAAlC1+MxMhISFs0aIFAbBTp04ZZhbfu3cvjYyMWKJEiVSXMJbL5fT29mbOnDlTXcNELpfTzc0tyd9GRlGxYkW2atUqo5eRbojKQCbmyZMnyoIjxYoVS3WEbkYhCAKfPn3KFStWsGXLlnRwcFAKfy8vLw4ZMoSHDh3SmJujY8eOzJcvX5LH379/TwDcv3+/Rq6nLopiKj83GxIEQdnOeODAgUmabQVBYLdu3aijo6PW9+D8+fO0tLSkh4cH/f39kzxPEAR6e3vT1dU1XUocR0REcPny5fGqPu7cuTNVZut79+6xa9eu8VwIihS1LVu2aGH1qefKlSvMlSsXzczMuH379oxeDm/dukUnJyc6Ozvz9u3bao9X9JNQpTFXUhw5ciRTKm5NmjRJtvvl74aoDGRCgoKC2LNnT8pkMmbPnp2bN29Ol7KzaUUQBD558oTLly+nr68v7e3tCYAymYwlS5bk0KFDeeTIEa18P+RyOe3t7ZN1AVy5coUAMqxue2xsLD08PFi1alWScTn2nTp1IgDOmjUrxfExMTGsWbMmzc3N1cp/fvToEXPmzElHR8ckb/gKRSU1FePUITg4mBMmTKCtra2yv4KJiQltbGzSPPfnz585a9YspQtBJpPR19c3U7T2lcvlnD59OnV0dFiqVKlku1SmNwEBAfT09KSxsTEPHDig8rgXL17QyMiIPXv2TNP1a9SoQU9Pz0yXBdWtWzcWK1Yso5eRbojKQCbi+/fvnDhxIk1MTGhhYcFZs2alyy4ttQiCwEePHnHZsmVs0aIF7ezslDfhUqVKcdiwYTx69Giqo4vV4caNGykWyPHz8yMArVTrU5X9+/cTAA8ePKiM/Fcnsvvbt28sVKgQc+TIoVbZ5MDAQBYvXpwmJiYJCroEBwfT2tqarVu3Vnk+dXn27Bl79OihDArs1asXnz9/zvDwcKXvX1MoXAgmJiYEQAcHB06cOFEjZaZTQ2BgIH18fCiRSDh8+PBMoZz8yvfv39m4cWNKJBLOmTMnRcEsl8tZsWJF5sqVK00lzh8/fkwAGs9u0ASjR4+mi4tLRi8j3RCVgUxATEwMV61aRQcHB+rp6XHgwIGJ9ozPaARB4MOHD7l06VI2b96c2bJlIwDq6OiwdOnSHD58OI8dO5Yuwv9XJkyYQHNz82RvtLNmzaKpqWmG7kAULY6NjY1pZGTEw4cPqz2Hv78/HRwc6OXlpVbwV1hYGGvXrk2ZTBYv9qB9+/a0tLTUSunVf/75RylkbG1tOXHixHhBgRcvXlQ2XdI0devWZcWKFeO5ENq0aRPPTaNtjh49SltbW9rb26vdxje9kcvlHDZsmEoljBcuXKiR6pQ9evSgnZ1duhUBU4f58+fTwMAg01kstIWoDGQggiDw0KFD9PDwIAC2atUqU5kPBUHggwcPuHjxYjZr1iye8C9btixHjBjB48ePZ4rmRyVLlkwxZbB379708PBIpxUlztu3b5VlktOStnTz5k0aGxuzUaNGanXki4mJYdeuXQmAY8eOVbZbVqehUkooduZly5ZNMShw5MiRWnNP9OzZk4ULFyb5fxeCokpl6dKluXXrVq3V5oiKiuKgQYMIgDVr1sxSNe7Xrl1LXV1dVq1aNVErmsI9kNaugl++fKGRkRHHjRuXpnm0xebNmwkgU9Q9SA9EZSCDuH79OitVqkQArFy5crI50+mFXC7n/fv3uWjRIjZt2pS2trYEQF1dXZYrV44jR47kiRMnMt2PIygoiAC4fv36ZM+rX78+a9eunU6rSsijR4/o4uJCFxcXZbBeWkzGBw8epFQq5aBBg9QaJwgCp06dSgA0MzNj2bJlNRKTEhERwWXLlimDAitUqMD9+/cnO7eirbE27hnTpk2jhYVFvOdiY2O5b98+Vq1alQBob2/PCRMmaNSF8Pz5cxYvXpy6urqcM2dOloj3+ZWzZ8/SysqK7u7u8fp4aMo9QMZlyOjp6WXaJmrHjx8nAI33/MisiMpAOvPy5Uv6+voSiGube/jw4QwzQ8nlct67d48LFy5k48aNaWNjoxT+5cuX56hRo3jy5MlMJ/x/Zd26dZRIJCnuvooUKZLqUqlp5fLly7SysqKHhwffvn3Le/fuUSKRcOnSpWmaV2GuTc08TZo0IQCWKVMmTb/Zjx8/cvz48bSxsaFUKmXTpk155coVlcZmy5aNpqamqb52cihaQif12u7fv89u3brRyMiIurq6bN26dZpdCJs2baKJiQldXV15/fr1NM2V0Tx79oxubm60srJS9sZYsGCBRtwDMTExzJ49O9u2bauBlWqHmzdvEkCW/xxVRVQG0olPnz5xwIAB1NXVpaOjI9esWaOWeVcTyOVy3r17lwsWLGCjRo1obW2tFP4VKlTgmDFjeOrUqTQXIUlvmjZtqlKJYUtLS06bNi0dVhSfw4cP09DQkOXKlYtndm3Tpg3t7e3TrGz169ePUqlUrfiDp0+fUl9fn61ataK5uTkLFy7MgIAAta777Nkzdu/enQYGBjQ0NGTv3r3VaoQTHR2t7CuhDRSd5x48eJDseV++fOHs2bOV7ptSpUpxy5YtarkQwsLClM2WWrdunSFxM9rg8+fPrFy5MnV1dTljxgzl55xWFIW0NNVYSxv4+/sTAI8ePZrRS0kXRGVAy0RGRnLmzJk0NzenqakpJ0+enG47bblczjt37nD+/Pls2LAhraysCIB6enqsWLEix44dy7///jvLCf+fiYqKopmZGSdOnJjseaGhoRmSd75hwwbKZDLWr18/gc/81atX1NPT45QpU9J0jdjYWNavX58mJiYqpU0KgsAqVaowd+7cDA8P54MHD+ji4kJnZ2feu3cvxfGXLl1io0aNKJFImC1bNk6aNClV9fTv3LlDAOzSpYvaY1XhzZs3BKBy46bY2Fju378/ngth/PjxKZqxb968ybx589LY2JgbN27UxNIzFdHR0coUWAsLC40oOhUqVGD58uU1sDrtERERQQC/5WeaGKIyoCXkcjk3btzI7NmzU0dHh7169dJ6EFFsbCxv3brFefPmsUGDBrS0tCQA6uvr09vbm+PGjeOZM2dSrO6Wlfj7779V2mHcv3+fAHjx4sV0WZcgCMqqgZ07d06yRn6/fv1oZmaW5uY0379/p6enJ52cnFLc4W/atIlA/J7x7969Y9GiRWlmZpZoUaPY2Fju2bNHWQnT3d2dq1atSlPq64wZM5TFhrRBTEwMpVIply9frvbYBw8esHv37vFcCFevXo13jiAInDdvHnV1denp6clnz55paumZjnnz5in7hDRu3DhNGwiF+V1bn7smMTY25ty5czN6GemCqAxogZMnT7Jo0aIEwCZNmvDp06dauU5sbCxv3rzJuXPnsn79+rSwsFAK/0qVKnH8+PE8e/Zspq5VkFYGDhxIR0fHFOMuDh8+TADp0s9BLpdz4MCBBMDRo0cnu7YPHz7QxMRE7SDAxHj//j1dXFxYtGjRJHdvnz9/pq2tLX19fRMcCw0NZY0aNaijo6PM+w4PD+fSpUvp6upKAKxYsSIPHDigkaC42rVrE0CqS+GqgouLi8o9HRLjy5cvnDNnTjwXwubNmxkQEKBc/4ABAzJlapymePbsGQ0NDdmnTx/u27ePRkZGLF68uMpdOH9F0YE0szeRIskcOXJwxIgRGb2MdOHPUQa+fiVXrya7diWLFSMdHUkHB7JgQbJjR3LZMvLjxzRd4s6dO6xRo4ayiMo///yjmbX/R2xsLG/cuMHZs2ezXr16NDc3JxDX2rVKlSqcMGECz50791sL/19xd3dn586dUzxv6dKl1NHR0XqcRlRUFP/66y9KJBIuWrRIpTHjx4+nvr6+Rprq3Lt3j6ampqxdu3aiN9vOnTvT3Nw8SdP3zybhypUrK4MCmzVrpnJQoKq4uLhQX19fo3P+StmyZdmmTZs0zxMbG8sDBw7Qx8dHWVLbyMiImzdv1sAqMy9yuZzly5dnnjx5lO7NtJQwDgoKop6eHmfOnKmF1WqeEiVKaM2Nldn4/ZUBf3+yc2dSX5+USEgdHRKI/9DR+f+xv/4i1TT3+fv7s127dpRIJHRzc+OePXs0kiEQExPD69evc9asWaxbty7NzMyUwr9q1aqcOHEiz58//1vvSpLjxYsXBMC9e/emeO7w4cOZM2dOra4nLCyM1atXp56eHv38/FQeFxoaSltbW3bo0EEj6zh+/DhlMhl79eoV73t4/vx5Aki2R/vTp0/ZtWtX6ujoEAALFCiQbKfF1CKXyymTyZg3b16Nz/0zvr6+9Pb21shc0dHRHDFiBCUSCZ2cnGhgYEBdXV3+9ddfGleUMgsK94Aim0DBu3fvWLx4cRobG6vV62P8+PE0MjLK0Cqg6lCzZk02bNgwo5eRLvy+yoAgkGvWkMbGiSsAST10dOIUh3nzyBRMoSEhIRw+fDgNDAyYLVs2Ll26NE154zExMbx27RpnzpzJ2rVrK4W/oaEhfXx8OGnSJF64cOGPFf6/smDBAurp6amU79yyZUtWrFhRa2v5+PEjvby8aGpqmqqe7gsXLqRUKlWr50ByrFy5kgA4b948knEWiwIFCrB06dIJTPyCIPDixYts2LAhJRIJ7ezsOHnyZC5ZsoQ6OjqsWbOmxqPjnz17RgBs0aKFRuf9laFDhzJXrlxpnufVq1csXbo0ZTIZp06dytjYWH79+pVz5sxh7ty5CYAlS5bk5s2btVbIKL1RuAf69u2b6PHw8HBldcnZs2enuAH68eMH7ezsMiy9NzW0adMm0wc6aorfUxmQy8lu3VRXAJJ6NGtGJvLDjoqK4oIFC2htbU0jIyOOGTMmVTfLmJgYXr16lTNmzGCtWrVoampKADQyMmK1atU4ZcoUXrx48be5uWiaatWqqdxVrFy5choxFyfGq1evmDdvXmbLli3VqVJRUVHMmTOnRnchw4YNo0Qi4d69ezllyhTKZLJ47a9jY2O5a9culi5dmgCYL18+rl69Op6b6dSpUzQzM2PRokVT7SNODIWysnLlSo3NmRiLFy+mrq5ummIcduzYQXNzc+bIkSNR15/ChVCtWjUCoJ2dHceNG6fVWAhtExsby3LlysVzDySGXC7niBEjlFkhyW2GNm7cSAB89OiRNpasFQYMGEB3d/eMXka68HsqA717p10RAOJcB76+cVYGxu2g/Pz8mDt3bkqlUnbp0kWtG2R0dDSvXLnC6dOns2bNmspGKkZGRqxevTqnTp3KS5cuicJfBcLCwqinp8cFCxaodL6zs3OaAsmS4u7du3RwcGDu3LnVyrFPDEWUv6ZiTeRyOZs1a0Z9fX3q6+tzyJAhJON2dEuWLGGePHkIgN7e3jx48GCSAvPevXt0cnJi9uzZU8zZV5UWLVoQgNaCaxUcOHAg1UGK4eHh7NKlCwGwefPm/Pr1a4pjHj58yB49etDY2Ji6urps1apVlnQhzJ07lxKJhOfPn1fp/HXr1lFXV5dVqlRJ1AUgCAI9PT2zXEvgKVOm0NraOqOXkS78fsrAnj3JCvgwgGMB1gBoibg+6utSUgpWruS5c+dYsmRJAmDdunVVuilGR0fz8uXLnDZtGmvUqEFjY2MCoLGxMWvUqMFp06bx8uXLmbKLWWZn7969BKCSAI6OjqZUKtX4LvTs2bM0MzNjsWLFNFLOVi6Xs3DhwqxYsaLGqlKGh4fT3NycUqmUFy5c4JgxY2htbU2pVMrmzZurXHHv7du3LFSoEM3NzdNcfY4k8+bNS5lMpvVSvYpaBuoK5Hv37jF//vw0NDTkqlWr1P48vn79yrlz5ypdCF5eXty0aVOWcPE9ffqUBgYG7Nevn1rjzp07RysrK7q5ucUrYUz+vwCUqjUfMgsrV66kRCJJ9wJxGcHvpQx8/kxaWcXt6JMQ7K/+UwCyA6ykgjIgAIyUyegCsESJEsneCKOionjp0iVOnTqV1atXVwp/ExMT1qxZk9OnT+eVK1dE4a8BOnfurLL57tWrV/w1rz6t7N69m/r6+qxatapGv++KFMjUdDNMjG3btinjTiQSCY2MjNi3b99UNcQKCQmhj48P9fT00lS8SRAE6uvr09nZOdVzqMrnz58JgDt27FDpfEEQuGTJEurr67Nw4cJpNmnHxsby4MGDrF69OgEwW7ZsHDt2bKZ1IcTGxrJs2bJ0dXVNVS2B58+f093dnVZWVjx79qzy+aZNm9LNzS3L9WnYs2cPAfBjGjPNsgK/lzIweTIplSa7y/8BMPC/v6+raBmIAfikZs0EX+SoqChevHiRkydPZrVq1WhkZEQANDU1Za1atThjxgxevXo1S+TTZiUEQaCDgwMHDhyo0vnnzp0jAD5+/Fgj11++fLlyZ63pnZ4gCKxYsSILFy6cphunIAg8cuQI9fX1CYA2NjY0MDCgt7d3mpTRqKgotmvXjgA4bdq0VFkw3r59SwCsVatWqtehKoIg0NjYmLNnz07x3M+fP7NRo0YEwF69emk8RffRo0fs2bMnjY2NqaOjw5YtW/Ly5cuZqkXunDlzKJFIeOHChVTP8eXLF1apUoW6urpcu3Yt37x5Q5lMxsWLF2twpemDwqKRleIcUsvvowzExMTVDVAjJkBVZYAAaWLCH58/88KFC5w0aRJ9fHxoaGioFP61a9fmzJkzee3aNVH4axlFBbPTp0+rdL4icCmtZaAFQeCECRMIgL1799baLufy5csEkKoc9tjYWO7cuZOlSpWiIh9+zpw5/PHjB8+cOUNdXV126tQpTQJIEASOHTuWANi9e3e1v+87duwgAM6YMSPVa1CH/PnzJxkRr+D8+fN0dnampaWlSqmqaSEkJITz5s1Txmx4eXlx48aNGe5CePLkCQ0MDNi/f/80zxUdHa2MtyhVqhTNzMwyRatzdXn8+DETS638Hfl9lIFLl9QOEFRLGQDYTE+PQFzb17p163LWrFm8fv26KPzTmYkTJ9LMzEzlHe6kSZNoY2OTpmvGxsaye/fuBMApU6ZofTfXsGFD5sqVS+Vg0u/fv3Px4sVKH7WnpycBJAiw3LBhg3JXn1bWrFlDmUzGOnXqqHWj79y5M9OzG1yNGjWSzNKIjY3l+PHjKZVKWaFCBfr7+6fLmsi4GJFDhw7FcyGMGTNGo1kbqhIbG8syZcqk2j2QGIIgcNq0aQRAV1fXTN/9NDE+ffpEANy9e3dGL0Xr/D7KwIIFKboI0qIMxEgkvOzjwxs3bvwRwSSZmVKlSrFp06Yqn9+lSxcWL1481deLjIxk48aNKZVKuXr16lTPow4PHz6kVCrlwoULkz0vKCiIY8aMoZWVFaVSKVu0aMHLly+zYMGCLFGiRKLfVcWufvv27Wle57Fjx2hiYsLixYur3Je+cOHClEgk6VYpM6nP/+3bt6xYsSKlUinHjx+foUr948eP2atXr3guhH/++SfdXAizZ89Os3sgMZYtW6aMVUlLCeOMQi6Xp7q/RVbj91EGOnZUr7iQupYBiYSsWzf9X5dIPD58+ECJRMJ169apPKZ69eps1KhRqq4XEhJCb29vGhgYqFVpTRN06NCBtra2idawePz4Mbt06UJ9fX0aGxuzX79+fPXqFcm4BkBSqZS3bt1KdF5BENi6dWvq6+vz0qVLaV7n7du36eDgwJw5c6oUl2FsbJxmS406TJo0iba2tvGe27dvH62srOjs7JypTMAhISGcP3++0oVQokQJbtiwQasuBE26B35GEATmz5+fjRo14u3bt+ns7EwnJ6ckv5eZFVtbW06ePDmjl6F1fh9loEmTZLMINOEmYLly6f+6ROKxfv16SiQStVL58uXLl6ob3fv371mkSBFaWFhofMekCv7+/tTX1+f48eNJxt1cz58/z3r16lHRYnfq1Kn8/PmzcszLly9paGjIAQMGJDv3jx8/WLFiRdrY2KS5PgIZ1y7Yw8ODlpaWyeamK8yuFSpUSPM1VWX9+vUEwIiICEZGRrJ3794EwAYNGqS5W6S2ULgQFL1OtOVCULgH8ubNq/FW5sePHycAZVbB+/fvWaJECRoZGXHfvn0avZY2yZ8/v9ppllmR30cZaN5cq24CAnz0X+/2/fv388GDBwwJCUn/1/mH06xZM5YsWVLl8wVBoKGhodptSJ89e8acOXPSycmJ9+/fV3eZGmPQoEE0Njbm6tWrlXUuChQowLVr1ybYLQqCwNq1a9PFxUUlH/7nz5/p5uZGNze3eApFavn69SsrV65MPT29JF0Qx44dIwAOHz48zddTldOnT1OR4164cGHq6+tzyZIlmSqKPzmePHnC3r1708TEhDo6OvT19eWlS5c0sv5Zs2ZRIpFopbV37dq1WaRIkXjrDA8PZ9OmTSmRSDhr1qws8RlUqFCBf/31V0YvQ+v8PspAv36krq72YgYAbv7v/J8fOjo6tLa2Zv78+VmjRg326tWLS5Ys4eHDh3n37l1++fIlS3zhswLR0dE0MzPjhAkTVB4THBxMdQOArl+/TltbW+bLl08jnQRTy/fv3zl9+nRKJBIquggePnw4ySwGRZS+Oruu58+f08bGhhUrVtSIKToqKoqtW7cmgERv9orWzqnp35Banj9/TkWDr/z588cryZyVULgQFO2kixcvniYXwuPHj6mvr5+iFSk1PH36lAC4du3aBMfkcjlHjhxJAOzUqVOmr7jauHHjLFc5MTX8PsrAxo1azSYQpFJ+Hj2ap06d4uzZs9mhQwdWqFCBuXLlUpYVTuqhq6tLe3t7enp6snHjxhw+fDiXLl3KAwcO8Pbt2wwODhYVBhU4c+YMAfDGjRsqj7lx4wbViVw/ceIEjY2NWapUqQwzIQcFBXHUqFG0tLSkTCZj4cKFqaOjo4wJSIyQkBA6ODikqrfBpUuXqK+vz9atW2vkeygIgvJm37t373hBjIo+COnVtS4kJITNmjVTuiayYkT7r8jlch4+fJg1a9YkANra2nL06NEMCAhQeY7Y2FiWLl1aK+4BkuzduzdtbW2TDRLdsGEDdXV1WblyZY1YprRF165d6enpmdHL0Dq/jzLw/LnKSsAigJMA9vhPWDf+7/+TAIYkM25YxYrctm1boibYqKgovnjxgidPnuTy5cvZu3dvVqtWjW5ubsoGRCkpDE5OTixTpgxbtWrFYcOGcdGiRdy3bx9v3LjBoKCgLFe9S9MMGjSI9vb2ar0P6lQQ27p1K3V1dVm7du0MERqPHj1i586dlUGB/fv356tXr/j9+3fa29sn22ipV69eNDExSXVq3Pbt2wmA48aNS+XqE7JixQrKZDI2aNBAKXAsLS1pamqqsWskx+XLl5kzZ06amZnR3NxcGXvxO/GrC6FFixYquRBmzpypNffA169faWxszDFjxqR47vnz52ltbU03Nzc+U7N1fHoxatQouri4ZPQytM7vowyQZNmypEyWojKQIxmh/CqR8+UAX+vpsUD+/FSUdm3atCl37typslYdERHBx48f8+jRo1y6dCkHDRrEunXrMn/+/AmUBYlEQl1dXaV5+GeXhIuLC8uXL09fX18OHjyYCxYs4O7du3n16lW+e/fut057zJcvHzt16qTWmHnz5tHQ0DDFm6Oib3u7du3StVy0IAg8d+4c69atSwB0cHDgtGnTEuycly5dSolEkqiJ++rVq5RIJMp2xall6tSpBMANGzakaZ6fOXz4MI2NjVmyZEm+fPmSihoI2kQul3PatGmUyWQsXbo0X758SS8vL3bs2FGr181Ivn37xgULFjBv3rzK93j9+vWJ7swfPXpEfX19lSt4qsucOXOoq6urcsnlFy9eMF++fLS0tNRI3wtNo7iH/O78XsrA9u1quwpUeQgAx1lbEwDLlCnDjh07slixYgTimg75+vpy7969acqbDg0N5f3793ngwAEuWLCAAwYMYIMGDejh4ZHADSGTyWhkZEQjIyPKZLIEx1xcXFimTBk2b96cAwcO5Ny5c7ljxw7+888/9Pf3z5JFkv79918C4J49e9Qa179//2R7GAiCwGHDhhEAhw4dmm7umpiYGPr5+dHLy4sA6OHhwXXr1iXp/42Ojqarqyvr1KmTYJ6iRYuyWLFiaf5cBUFgp06dqKurq9Gb8o0bN2hnZ0cHBwcqqhZqi/fv37Nq1aqUSCQcMWKEUrFr0qQJfXx8tHbdzIJcLueRI0fiuRBGjRqldCHExsayVKlSdHNzY0REhMavHxsby5w5c6odcPflyxdWrVpVWcI4M7F582YC0Io7JTPxeykDcnlc+p+a9QaSe8QAfG9pybDPn7ljxw6WKFGCAFi4cGHOmjWLEyZMYOHChQnElSVu3bo1Dx48qPGgmC9fvvDWrVvcvXs358yZw969e7Nu3bosUKCAsiyy4qGvr09LS0va2trS0tKSev9VTlQ8pFIpHR0dWapUKTZp0oT9+vXjrFmzuG3bNl64cIGvXr3KdEE9CxcupK6ubqI598nRuHFjVqtWLdFj0dHRbN++PQGonW2QWsLCwrhw4ULmypWLAFilShUeOXJEJSVEYcr/OXVvzpw5lEqlGqvmFx0dTR8fH1pYWGislwMZ1yzKxsaGigqO2uDIkSO0tbWlvb09T506Fe/YgAED6ObmppXrZlaePn3KPn360NTUlDo6OmzevDl79OhBiUSikfoSiaHoJqpqN8yfiY6OZrdu3ZSKeWZxiyoyYF6/fp3RS9Eqv5cyQJIvXpAGBmrXHEjKIiCXSllKT48FChTgnTt3KAgCz5w5w1q1ahEAXVxcOG/ePF6/fp3jx49n/v9cCRYWFmzfvj2PHj2qdbOzIAj8+PEjr169Sj8/P06fPp3du3dnjRo16ObmlkAZMDY2VhaJyZkzJ+3t7ZVNln52Vdjb27NEiRJs2LAhe/fuzenTp3Pz5s08e/YsX7x4kW4V5Mi4wkGp2dkVL16cnTt3TvB8eHg469SpQx0dnVT1AFCXwMBAjhw5UhkU2LJlS7UCIcm4XZ+npyfLli1LQRD45s0bGhkZsU+fPhpda0hICAsUKMBcuXJptFtbxYoVlcrqrl27NDZvVFSUMkuhdu3aia553rx5NDAw+CMDdb99+8aFCxcyR44cVNQsWLdunVZ+v5UqVWKZMmVSPV4QBM6dO5cSiYSNGjXKFAGfil4o6v5esxq/nzJAkocPx8UOqFl34OeH/L/Ht6VL+fDhQxYpUoR6enqcM2eOUmO9e/cu27RpQx0dHVpYWHDkyJEMDAzk/fv3OXr0aKX/zsrKip07d+bJkyczxEQvl8v57t07Xrp0iZs3b+akSZPYqVMnVqlShblz56aOjk48RcDS0pK5c+dmoUKFWLRoURYsWJC5cuWimZlZvPMUZshixYqxXr167NGjB6dMmcINGzbw9OnTfPbsmUZMa2FhYdTT0+P8+fPVHmtra8tJkybFe+7Tp08sXbo0jY2NNdrWODEePXrETp06UU9PjyYmJhwwYECadhgnTpygIn2wXr16dHR01Mrv7fXr17Szs2Pp0qU1Zk62t7envr4+W7RooZEYBzKuHkTx4sWpq6vLuXPnJrmb3L17NwEwODg4zdfMisTExLBkyZJ0dnZW9kKwsbHhyJEj+fbtW41c4/bt2wRAPz+/NM914MABGhsb09PTU60sCW3w5s0bAuDRo0czdB3a5vdUBkjy6FHS2Dh1LgMdHcr19NjV3JzFixdnaGgof/z4wUGDBhEAq1WrFq8SmL+/PwcOHEgTExPq6+uza9eufPr0KQVB4O3btzl8+HClWdjW1pY9evTgmTNnMk2wX0xMDN+8ecOzZ89y3bp1HDduHNu2bcuKFSvSxcUlQSCjnZ0dCxYsyHLlyrFy5cqsXLkyy5Qpw/z589P6v9iKnx9WVlYsXLgwa9euza5du3LixIlct24dT548ycePH6dYIGffvn0EwOfPn6v1usLDw/lrQJy/vz/z589PGxubVJkyVUEQBJ49ezZeUOD06dP59etXjcxdpUoVuri4EIBGd9i/cu3aNRoaGrJZs2ZpNtn++PGDEomE7u7ulMvlyjiNfv36pfp3sHHjRpqYmNDV1TXFXdv169cJgDdv3kzVtbI606dPp1Qq5T///EMyzoXQt29fmpqaUiaTsXnz5rxw4UKaLCcdOnSgs7Ozxiyhd+7coYuLCx0dHTP0c1PcRzZt2pRha0gPfl9lgCT9/cnq1ZUCPkUlQJGJULo0+ewZb9++TTMzM1apUkUZ2HXy5Ek6ODjQ2to6QavTL1++cOrUqbSzs1OauS5fvkwy7iZ+/fp1Dh48mNmzZ1cKiT59+vDixYuZxj+WGD+nTa5atYojR45kq1atWKZMGWVQ2M8ZDzly5GDp0qVZq1YtNmnShM2bN1cW7vD09GS2bNkSKAzm5ub08PBgjRo12LlzZ44fP56rV6/msWPH2KRJE+bJk0ftG9WTJ08I/L8c6oMHD+jk5MQcOXLw6dOnGn+fYmJiuH37dmVcScGCBbl+/XqNx18o6i38Wt1NG+zdu5cSiYTDhg1L0zwKU2urVq2Uzy1ZsoRSqZSNGzdWy/oQGhrKNm3aEADbtGmjUhxJUFAQAWi9PXFm5OHDh9TT0+PgwYMTHPv27RsXLVpENzc3AmCxYsW4du1atV0IHz9+pL6+vka6Yf7M+/fv6eXlRSMjowz97IyMjNItriij+L2VAZIUBPLECbJBg/+7DWSyuGqFurrxUxGrVyf3748LRPyPs2fPUl9fn02bNlXuYIKDg9mwYUMCYNeuXRP4tSIjI7lq1SrlD6xChQo8ePCgUuALgsDLly+zf//+dHJyIgA6OztzwIABvHLlSpbza/6aNjl06FA2a9aMJUqUUAaN/Rzc6ObmRh8fH7Zs2ZLdunVjnz592Lt3b3bq1ImNGjWil5cXHRwcElgkTExMmC9fPlarVo0dOnTgmDFjuGLFCmW1x8+fP8d77xS10V++fMmLFy/SwsKChQsX1nh997CwMC5YsIA5c+YkAFatWpVHjx7V2ufYr18/ymQyOjo6pkvcxty5cwmAK1euTPUc8+fPJwCuWbMm3vMHDhygkZERy5Qpo5IJ/8aNG3R1daWJiQk3btyo8vXlcjn19fUTtHT+3YmJiaGXlxfd3d2TVbjkcjmPHj3K2rVrp8qFMGnSJBoaGmqlUNfPJYxnzpyZIffH7Nmzc+TIkel+3fTk91cGfubLF/LUKXLmTHLIEHLwYHLaNPLYMTKZG9G+ffsolUrZrVs35RdREASuXLmSRkZGdHNzS9RMKZfLuXfvXpYpU4ZA4jXl5XI5L1y4wN69e9POzo4AmCNHDg4ZMoQ3btzIcopBYvycNrlw4UIOGDCADRs2ZNGiRWlubh5P4BsZGbFAgQKsU6cOe/TowU6dOhGIK1s6ceJE9uvXj02bNmXp0qXp7OxMqVSaYLybmxurVKmifN+7du1KPT09enp68vnz5xp7T9+/f88RI0bQwsKCMpmMrVq10npHths3blAqlXLo0KGUyWTpslsRBIE9e/akTCbj8ePHUzVH/fr1CYAPHz5McOzatWvMli0b8+bNm2TTJLlcrsxfL168eKoK1Li6unLQoEFqj8vKTJs2jVKpVGmhVIVnz56xX79+ShdCs2bNeP78+SR/N1FRUXRwcGCXLl00tewEyOVyjh49mgDYsWPHdM92Kl68uFZfX2bgz1IG0sCaNWsIgKNHj473/JMnT1i8eHHq6Ohw+vTpSfo/L168qLwhOjo6cubMmQkaHcXGxvL06dPs3r27ckedJ08ejhgxQpnJ8Dvy9evXRNMmPTw8qKurG0/Ym5mZsUiRImzYsCH79+/PuXPncu3atdy0aRM3btzIefPmcdCgQWzRogWdnZ0TWBcU1ok8efLQ29ubf/31l7La4969e1Wq9vjw4UN27NhRGRQ4cODAdOlhEBsby+LFi7Nw4cKMjo5m165daW1tnS4Ns2JiYli7dm2ampqmqnFTjhw5KJPJkvx9/Pvvv3Rzc6OtrS2vXLkS79iHDx+U2TsDBw5MtSCoUqUKmzVrlqqxWZEHDx5QT0+PQ4YMSdX40NBQLlq0iO7u7gTAokWLcu3atQksDFu2bCEAPnjwQBPLTpaNGzdST0+PlSpVStcSxjVq1Eh1G/SsgqgMqMGMGTMIIIGpMSoqisOHD6dEImGlSpWSLQn76NEjduzYkbq6ujQzM+OQIUMSjZaNiYnhiRMn2LlzZ1pZWREA3d3dOWbMmHT50WUWSpUqxbp16yaaNunu7k59ff14gt7a2polSpRgkyZNlLEJNWvW5OnTp3n+/Hnu2bOHCxcu5NChQ9mqVStWrFiRuXLlSpB+qaury5w5cyqrPQ4aNIi9evVi8eLFCcS1D542bZpGggJVZcGCBZRIJMpdXkBAAA0MDBIoqNoiNDSURYsWpYuLS7LV5QRB4JvISF4KCeH5r195IySEUgMDZs+ePdn5P336xLJly9LQ0FDZbOnUqVO0t7enra0tjxw5kqb1t2/fnqVLl07THFmFmJgYlihRgvny5UuzK0kul/PYsWOsU6eO8jc2YsQI+vv7UxAEenl5pWtBJ0UJ47x582ol9icxWrduna5ttzMCURlQk8GDBxMAt2zZkuDYmTNn6OzsTEtLS+7YsSPZed69e8dhw4bRzMyMurq67NChQ6ImVDKuGMeRI0fYvn17pVndw8ODEyZM4JMnTzTyujIjHz9+pEQiSbYi2a9pk5MnT2bHjh3p7OycwCKgEOKlS5dmy5YtOWLECK5cuZInT57k06dP+fbtW968eZP79+/nkiVLOGLECP7111/Mnz9/AqUDiF/tsVmzZhwwYIDWqj2+ffuWJiYm7NGjR7znhw0bRiMjIwYGBmrkOikREBBAJycnFi9ePF6sTKwg8NCnT6x/7x4tL1wgzpyJ/zh1iiY7dnDiq1d8n0yXvYiICDZt2lSZtSORSOjj46NyadvkGDt2LB0dHdM8T1Zg6tSplEqlCawsaUXhQjAzM6NMJmPlypUJgAcOHNDodVLi5xLGp0+f1vr1+vfvz3z58mn9OhmJqAyoiSAIbNeuHXV0dBLdqXz58kXZJa1Dhw4pRjp/+/aNs2bNoqOjIwGwXr16yab4/PjxgwcOHGDr1q2VPQ2KFCnCKVOmJOlvzaps2LCBANQSdD9+/FDmsVtZWXHIkCHKtMn169cnmzYpkUjo7OzMChUq0NfXlzVq1FCmSpYvX56HDh1icHAw79y5w0OHDnH58uUcNWoU27Vrx6pVq9Ld3T1B8SZFtceSJUuycePGqa722LhxY9rb2yewRHz58oUWFhbs2bOnum9vqrlz5w5NTExYv359xsbG8sinT8z+zz/EmTOU/aoE/PKQ/ndOtydP+C0JRenFixfKLJUKFSpoTKFatWoVJRJJpquuqWnu379PPT09Dh06VGvXCA0N5eLFi+Pdg9asWaOVEsdJ8fXrV1arVo06OjoJAlM1zZQpU2hjY6PVa2Q0ojKQCmJiYli3bl0aGhoq83Z/RhAErl+/niYmJsyTJ49K2nlUVBTXrVvHAgUKEABLly7NPXv2JJuDHRERwT179tDX11cphIoXL84ZM2Yk2+42q9C8eXN6eXmpfH5oaCh9fHyop6fHHTt2UEdHh0uXLk12jCJt8tSpU1y1ahX79u3LAgUKJOj5oEibzJUrF6tUqcKOHTty0qRJ3LRpEy9evMiAgADK5XIKgsCvX7/y/v37PHr0KFeuXMmxY8eyY8eOrF69OgsUKJBo8SY7O7skqz2uWLGCQNLFXGbMmEEdHZ10VQYPHz5Mib4+PdavVwr55JSAXx+yM2foeOkSL/yi3Pj5+dHMzIw5c+bkgAEDKJFI2Lx5c41kTfycXfK7onAP5M+fX+uZJm/fvqVMJmOPHj1Yp04dSiQSWltbc/jw4anunqku0dHR7N69OwFwyJAhWkvRXrFiBSUSSaapDaMNRGUglURERLB8+fK0tLRM0of//PlzlipVijKZjJMmTVLpiySXy3no0CFl6VY3NzeuXLkyxR92eHg4d+zYwSZNmtDAwIAAWKpUKc6ZMyfdfpiaJDo6Wq22s0FBQfT09KSZmRnPnDnDt2/fEgAPHTqk0vgHDx6wQ4cO1NXVpampKQcNGkR/f39GRETwyZMnCdImvby8kkybrF69Ort168Zp06Zx+/btvHLlCj98+BDP2vPt2zc+evSIx48f55o1azhhwgR26dKFtWrVYqFChWhpaZlAYbCxsUm02uORI0doZ2eXrsFxEbGxdDt0iPj7b7WUgF+tBHpnz/L458/8/v07O3fuTABs3ry50gKyZ88eGhgYsHz58mkOGHv8+HG8uhO/I1OmTKFUKuXVq1e1fq0RI0bQ1NRUeb9//vw5+/fvr3QhNGnShOfOndN64LMgCJw/fz6lUikbNmyolRLGilbov3MFS1Xlt4QkkQKhoaEwNzfHt2/fYGZmltLpWZ6QkBB4e3vj8+fPuHTpEnLkyJHgnJiYGEyaNAlTpkxB2bJlsWnTJuTMmVOl+a9evYpZs2Zhz549yJYtG/r27YsePXrA0tIy2XHfv3/HwYMH4efnh6NHjyI6OhrlypVDixYt0LRpUzg4OKTm5aYr586dQ6VKlXD9+nWUKFEi2XNfvnyJ6tWrIzw8HMeOHUORIkXwzz//oFy5crh//z4KFiyY6DiSOHv2LGbNmoWjR4/CyckJ/fr1Q9euXWFubq7SOsPCwvDmzRu8evUKr1+/jvfvq1ev8O3bN+W5RkZGyJkzJ3LlypXg31y5csHCwgISiUR5fnh4OPr06YOtW7di8uTJiIqKQkBAgPLx9u1bfP78Od56zM3NkSNHDjg7O8d7uLi4KP82MTFR6bUlBUk0ffgQ+z59gpCmmQApABkAp8mT8eGff7Bo0SJ07Ngx3vtw5coV1KtXD9bW1jh69Chy5cqVqmuFh4fDxMQEGzduRJs2bdK48szHgwcP4OnpiYEDB2L69OlavVZERASyZ8+ONm3aYN68efGOhYWFYdOmTVi0aBGePHmCIkWKoE+fPmjVqhUMDQ21tqbDhw/D19cXefPmxcGDB+Hk5KSxuS9cuICKFSvi0aNHyJ8/v8bmzUyoLL81qVn8Trx//565cuWim5tbsk1dLly4wBw5ctDMzIxbt25V6xrPnj1jt27dqK+vT2NjYw4YMEDlVLaQkBBu3LiRderUoa6uLiUSCb29vbl06VJ++PBBrXWkJ0OGDKGdnV2KZr9bt27Rzs6Orq6u8cy/W7duTfK7GBMTw61bt9LT05NAXAfKjRs3asWXrEib3LNnD+fMmcM+ffoo0yZ/jS9QpE02aNCA/fv355AhQyiVStmvX78kY08iIiL4/PlzZdR93rx52atXLzZo0EClao+dOnXiuHHjlNUeHzx4wJCQkGR3c5uDgv6/wz9yhGjblvDyIv7zH2PYsMStAevXx51nYBB3brVqxN69xKlT1N+yhXeSCKAl43adrq6uzJYtW5o6NFpbW2uta2JGEh0dzeLFi7NAgQLpUohq5cqVlEgk/Pfff5M8RxAEnjhxgnXr1lXG8AwbNkyrabh3795VljDWZGOhR48eEYjfMfR3Q3QTaIDnz58rfb7JBQyGhITwr7/+IgC2bt1a7fzwoKAgjho1ihYWFtTR0WHr1q159+5dlcd/+fKFa9euZY0aNSiTySiVSlm1alWuXLlSK5XDkiM8NpYbAwPZ5ckTFr52jRYXLtDk/HnaXbzI6nfu0HroUNZPpHzqz5w+fZqmpqYsUaJEAsVm+vTptLCwiPdcaGgo582bpywHXa1aNR4/fjzD6jcouk1eu3aNfn5+nDFjRrxuk7/WSLC2tmbx4sXZtGlTDhkyhEuWLOGRI0f46NEjRkREcNeuXQSQILr6x48ffPnyJc+fP8+tW7dy5syZ7Nu3r0rVHn18fNi+fXtltUe/w4dpfOYMJQoBv21b3Bg7O6Jo0aSVgR07CHNzwtGR6N2b6NQpTiHIk4c4cYKSM2c4PQUh8fHjR5YuXZpGRkY8ePBgqt7zYsWKsVu3bqkam5mZPHlyurkHBEGgh4cH69evr/KYFy9ecMCAATQzM6NUKmWTJk149uxZrfz2AgMDWbJkSRoZGXHPnj0amTM4OJgAuHv3bo3MlxkRlQENoehjULVq1XgVBhNj8+bNyiCpixcvqn2tsLAwzp8/XynUFHn06vywgoODuXLlSlatWpVSqZQymYw1atTg2rVr+eXLF7XXpCohMTEc/OIFTc+fJ86coc7ZswkEh+TMGeLkSeLMGRa7fp17E7G47Nixg3p6eqxWrVqiCliPHj1YuHBhkv9P4zQ3N1cqUXfu3NHaa9QES5YsIQDu378/Xtpkp06dWLVq1US7Tdrb29PY2JhWVlYcPnw4V65cyRMnTvD58+cpWj2io6P55s0bXrp0iX5+fpwzZw779++fsNpjkybx4wSOHyd27477e/nypJWB+vUJfX1i+/b/Pzd7dtz5AwcSZ84w28WLjE7BEhQeHs5GjRpRKpVy2bJlar+v9evXZ61atdQel5m5d+8edXV1OXz48HS53qlTpwiAf//9t9pjw8LCuHTpUubLl09plVu1apVGupv+TEREBJs3b04AnD59epqVjtjYWEokEq5YsUJDK8x8iMqABkmsj0FSvHr1iuXKlaNUKuXYsWNTlT4VHR3NzZs3s3DhwspMAj8/P7Xn+vDhA5cuXUpvb29KJBLq6uqyTp063Lhxo0Y/y2OfP9P+0qUU089+DTLDmTNs/uABg/8TaIsXL6ZEImHLli2TFHJ16tSht7c327dvrwwKHDx4cJYIpnz37h3NzMzYtWvXZM+LjY1NkDZZo0YNZbDhz6Waf06bbNOmDceOHcu1a9fyzJkzfP36tUrfmejoaOa8ePH/VoFfH8kpA5aWhLd3wuddXAhPT+X/9yTjavv5dfft25cAOHz4cLUiyHv37k0PDw+Vz8/sREdH09PTkwUKFEhxE6Ip6tWrx4IFC6ZJwCpcCPXq1dOaC+HnEsYdOnRIsxvQxsaGkydP1tDqMh9iAKGG2bdvH5o0aYIuXbpg2bJl8QKhfiU2NhbTpk3DhAkT4OXlhc2bNyNPnjxqX5MkTp48iZkzZ+Lvv/9G7ty5MWjQILRv3x5GRkZqzfX+/Xvs3r0bfn5+uHTpEvT19VGzZk20aNEC9erVS3Xw2dJ379Dr+XNIgVQFnckAuOjro+7p01g8ejT69++POXPmQCqVxjuPJM6cOYMGDRrg+/fvcHJyQv/+/dGlSxeVgwIzmhYtWuDs2bN48uRJisGiiVGzZk28fv0at27dQmBgYKKBja9fv0ZgYKByjI6ODlxcXBINbMyZMyccHBwQGBMD58uXk77w06dA9+7AsGFAzZr/fz44GGjeHOjaFWjZMv6YqVOBq1eB/fshkcvh+vgxGrx5kyD40c7ODjKZLN7QefPmYeDAgWjVqhXWrl0LfX39FN+bWbNmYdKkSQgNDVXpvczsTJ48GePHj8fly5fh5eWl9eu9ePECbm5uWLVqFTp16qSROf/9918sXboUa9asQVhYGBo2bIi+ffuiYsWKyd4/VWXz5s3o1KkTypQpg927d8Pa2jpV8+TPnx81a9ZMEDD5u6Cq/BaVATVYu3YtOnXqhDFjxmDixIkpnn/lyhX89ddf+PjxIxYvXoy2bdum+kdw8+ZNzJo1Czt37oSVlRV69+6NXr16wcbGRu253r59i127dsHPzw9Xr16FgYEB6tSpgxYtWqBOnToqKxrrAgPR8elTta//KxJBAD9+xJj37zFhwIB471FMTAx27tyJ2bNn4/bt25BKpWjevDk2bNgAPT29NF87vTh69Chq166NLVu2oFWrVqma4/bt2/D09MSqVavQuXPnJM+LjIyEv79/oorCq1ev8OnTJ+W5enp6sK5fH4G9eiV94aSUAcXzI0YA1avHH7N8OeDnBxw/DujpwfTdO9iNH4+AgAD8+PFDeZpMJoOjo2OCLImAgAAsXrwYnp6eOHjwIGxtbZN9b/z8/ODr64uQkJAsoxwmxb1791CiRAkMHjwYU6dOTZdr9uvXD1u2bMHbt281nhnw/ft3ZRbC48ePUahQIfTt2xetWrVSe1PzK5cuXULDhg1hYWGBw4cPw83NTe05KlasiBw5cmDTpk1pWktmRVQGtMTMmTMxbNgwLFiwAH379k3x/LCwMPTt2xfr169H8+bNsXz58lTtChW8fPkS8+bNw5o1awAAnTp1wsCBA1OdlvX69Wvs3LkTfn5+uHnzJoyNjVGvXj00b94ctWrVgoGBQaLjnkVEoND164hO6usTEACsXQvcvw+EhQHZsgFVqwItWgCJzCklUd/WFns8PCCRSBAWFobVq1dj/vz58Pf3R/Xq1dG9e3c0btwY27dvR4sWLVL1ejOCiIgIeHh4wNXVFSdOnEjTrqhly5a4cOECnj9/nuqb9vfv3+NZFXZKpbiYPz/4izVGSVLKwL17QL9+wNixQOXK8cesXQts2gQcPAiYmMBUJkNohQogiS9fvsRLpfw5pVLxb0RERLzp7Ozs4qVW/pxS6ezsDH9/f3h7e+PevXsoVKhQqt6XzEBMTAxKlSqF6Oho3Lx5UyWrSFoJDQ2Fs7Mz+vTpgylTpmjtOiTx999/Y+HChTh06BAsLS3RuXNn9OzZM9H0bVV5+fIl6tati6CgIOzevRuVf/0upkDjxo0RERGBY8eOpXoNmRlV5bdOOq7pt2DIkCH4+PEj+vXrBxsbmxR3eaampli3bh1q1aqFbt26oUiRIti0aRO8vb1Tdf3cuXNj0aJFGDduHJYsWYJFixZh6dKlaNasGYYMGYLixYurNV/OnDkxZMgQDBkyBC9evFAqBo0bN4apqSkaNGiA5s2bo3r16sobE0m0e/IkabfAx49Ajx6AsTHQqBFgago8egSsXw88ewYkcsMRJBLs+/QJK54+xat167BixQqEh4ejZcuWGDx4MAoXLoy7d+8CQJpuHBnBxIkTERgYiJMnT6bZPDpp0iTkz58fixYtwtChQ5M9VxAEhIeHIzQ0FKGhoQgLC1P+/fNzSGHXnSQKQRUTk/BYdHTcv/9Zb6IFAZGRkTA0NIS1tTWsra1RpEiRRKcliW/fviEgIABXrlzBiBEj8P37dzg4OOD79+84deoUAgICEnUJNG7cGAULFkxgaXB2doaTk1OSym1mYfr06bh37x6uXLmSLooAAKxbtw6RkZHo2bOnVq8jkUjg4+MDHx8fvHz5EkuWLMGKFSswe/ZsNGjQAH379oW3t7fav5HcuXPjn3/+Ud6nli1blqzl7FdsbW1x8+ZNdV/Ob4eoDKiJRCLBzJkz8enTJ7Rr1w5WVlao+fNuKQmaN2+OMmXKoE2bNqhcuTKGDx+O8ePHp9rUbWNjg3HjxmHIkCFYv349Zs+ejRIlSqBq1aoYOnQoqlWrpvaPytXVFSNGjMCIESPw9OlT7NixA35+fti8eTPMzc3RqFEjtGjRAtLixXElOd/siRPA9+/AwoWAwmJRrx4gCHHHwsLiFIRfIdHj2jWYLl+O7t26oW/fvnB2dlYe9vf3B5C1lIH79+9jzpw5GDduHFxdXVUaExUVlaTgDg0NhZeXF8aOHYt///0XMTExCc5TnBsWFobkDH8GBgYwMzODvEkTUMW1xcPKKu7fXwokAQC+fAHMzJTKQFRYGIyMjGBqago7Oztky5YNdnZ2yT48PDxQsGBB1KtXD/Xq1cOpU6ewc+dO1KpVC0Dcjufdu3cICAjAmzdv0K1bN9jZ2SEqKgrnzp1DQEAAvn79Gm9ZNjY2CawKvz7SarpOLffu3cOkSZMwbNiwFAtyaQq5XI5FixahadOmGi3mkxK5c+fGnDlzMGHCBGzevBkLFy5E5cqVUahQIfTp0wd//fWXWp+DhYUFjhw5gr59+6JLly54+vQppk+fniAeJTFsbGwQHByclpfzWyC6CVJJTEwMGjdujNOnT+PUqVMoU6aMSuPkcjlmz56N0aNHo2jRotiyZUuq/Fy/Ehsbiz179mDmzJm4efMmihQpgqFDh6JZs2bQ1dVN09wPHz6En58f/Pz88OzZM+hOm4bYkiWTNiuvXAls2wbs2wf87L9duTLOj3zoEJCMifuomxtqOjomeH7x4sUYNGgQIiMjEwQYZjSCIOD79+/xhHFISAj69u2LsLAw5bqTEtw//z9asatOBKlUClNTU4SGhsLa2hp58+aFmZmZ8mFqahrv/0k9b2pqqvxeHPr0CfUePEj6xSXlJgDiLD9FigDjx8d/vm1bwMYGmDsXAOAuCBj9/j0+fPiQ6OPjx4+Qy+XxpjA0NFQqBjY2Nrh//z7evn2LFi1aoFGjRvEUBwsLC+TKlQstW7bEtGnTlHOEh4fj3bt3ShdEYo+fYygAwMrKKlllwcXFJc3VHn9F4R6IiYnBjRs30s0qcPDgQdSvXx+XL19G6dKl0+WaiUESp0+fxsKFC3Hw4EFYWFgoXQiqVnZVzLNo0SIMGDAA9erVw+bNm1P8rObPn49Ro0YhPDw8ja8icyLGDKQDkZGRqF69Oh4+fIgLFy7Aw8ND5bE3b95Eq1atEBAQgAULFqBTp04aibBVRN3PnDkTx48fR/bs2TFw4EB06tRJI+Vqb9y9i9JfvkBIThhfuxYnOMqWBTp0iNshPngQJxhq1QKSCVbTkUjQy9ER8/PmTXBs6NCh2LNnD168eJGm16GAZJK78OTM6kntwpPD0NBQJSGd0nNGRkaQSCQYM2YM5syZgxcvXsAxEcVJHQKjouCYmmwCAJg3Ly5IcOPGuLgQALh5Exg8GBgwAKhfH7oSCbo7OmJhIp+pAkEQ8OXLlyQVBcXfT548wffv3xOMV1jYTExMULp06XiKwq9WCGtr63jKZGRkpNLCkNTjw4cP8a5nbm6erLLg7OwMMzMzlX/TkyZNwoQJE3D16lW1XX1pwcfHB9+/f8eVK1fS7Zop8fLlSyxduhSrV69GWFgY6tevj759+6JSpUoqv5+KEsaurq44ePBgPAvjr2zevBlt2rRBeHh4hlmFtImoDKQTISEhqFixIr58+ZJkH4OkCA8Px4ABA7Bq1So0atQIq1atSnV6TGLcvXsXs2fPxrZt22BmZoZevXqhT58+yKa4aaeCm2FhKKGKf23TJmDLFiAq6v/PtW4NqJC2VMbMDP94eiZ4vkWLFggODsbJkyfj7cLVFdw//z8mMX/3f8hkslQL7piYGDRo0AD16tXD+vXroaOjWY/ct2/fkCdPHjRp0gQrVqxI83z5r17F08hIxLsZ7N0b5+759Ak4cACoUAFQCPRGjQATk7j4kC5d4v5u0gSIjIyz/tjaAsuWKd0EBwoWRL1UZL78CknMmjULw4YNUwoJhRKxYsUKfPr0CSVLloynQPwajCiTyWBra5usi0KhQNja2kJHRwdRUVF4//59soGPQUFB8dwyJiYmyfaScHZ2hqWlJe7fv48SJUpg6NChmDx5cprfI1W5f/8+ChcujK1bt6Llr6mhmYDw8HClC+HRo0coWLAg+vTpg9atW6sktO/fv4+6desiJiYGBw8eTFLJOnbsGGrVqoU3b94g2sYG18PCcPv7d3yNjYUEQDZdXXiamqKkqSmcM3nMSWKIykA6EhgYiHLlykFXVxcXL15MMQ3qV/bu3YvOnTvDwMAAGzZsgI+Pj0bX9+bNG8yfPx+rVq1CbGws2rdvj0GDBiFvMju1pFA5nfDkybhHxYpxloErV4Bjx4A+feIESTLoxMai1aZNCQT3y5cvQRKxsbHJjjc2NlZ7x53Y84aGhqm21vz11184ceIEnjx5olEF72fmzp2LoUOH4uHDh3B3d0/TXEvfvUPv58/jKwO+vsAvO2Il27YB9vZxf796BSxdGmf90dEBSpeOCyD9L6bASU8Pb8qUgUwDli8F27dvR7t27VChQgXs3r0b5ubmGDlyJLZu3YrXr1/HO/f79+9Juid+tUD8GpQokUhgbW2dYnyDnZ0dLC0t8fnz5ySVhYCAALx//x6C8P/QWwMDA5CEjo4OGjRogJw5cyZQIGxsbDRiNfyVLl264MiRI3j9+nWaXYnaRGHtXLhwIQ4cOAALCwt06tQJvXr1StGFEBQUhIYNG+LevXvYvHkzGjdunOCcyzduoOyYMXAbMQLP/vtsdCWSeL+F2P/EZGULC/RxckIDGxtItfCZaANRGUhnXrx4gfLly8PFxQWnT5+GaWIBcsnw/v17tGvXDqdOncKgQYMwZcoUjfsNv3z5guXLl2PBggUIDg5G48aNMWTIEJQqVUrlORYGBGDAixfJFxg6fRqYOTPOOvCzYjRjBnD2LLB9e/xYgkTI3r49jI2MYGxsDBMTE5iYmODUqVPw8PBAtWrVYGFhASsrK1hbW8PKygo2NjbIli0bLC0tM/zGduLECdSoUQMbNmxA27ZttXadHz9+wM3NDaVKlcLOnTvTNFdYbCxyXrmCr7GxSPGGoA4k6r99i10tW2r8czl//jwaNGgAZ2dnHDlyBIcOHUKfPn0QFRWlUuBYYkRGRsazKiT3+DU4EYgLZEtOYbC2toZMJkNUVBQ+ffqE1atX4/jx4/Dx8UFERAQCAgLw7t27eAqvvr4+nJycErUsKB7ZsmVTK47m06dPcHFxwejRozFq1KhUvVcZwatXr5QuhNDQUJVcCJGRkejQoQP8/Pww7X/snXVYFOvbx+9NFpbuFhVEMRAUUBEsDGzFDlTs7i5ssbtbj92tR0XFRMUWFQNbDCykd77vH5ydF2QXNoFzfvu5rr3OYXbmeZ5Zd2e+c+esWTR69Gh23xs/f1Lbe/foZUYGcYgI+dzgeUQkIaLqxsa0qUwZKqnFbo2aQicGCoHbt29TzZo1ycfHh44dO6b0zZxhGFq0aBGNHTuWPDw8aPv27Vppq5mamkpbtmyhefPmUVxcHAUGBtKoUaMoODg43wvK8nfvaOCfT5B/MngwkURCtGxZzu1RUVk56fPmEeXlF2UYMm/dmlJSUiglJUXh8yLKCrATiUSkr6/PvrL/ndd7+f0t7z2RSMReXFJSUqh8+fLk7OxMZ8+e1coTXXY2bdpE3bp1o+joaLUr1e37/JlaPXyooZURcSQSsvjxg762bUtlS5emlStXUvXq1TU2PhFRbGwsBQcHU2ZmJo0ePZoGDRpEb968ydNHrCnS09Pp06dPComHL1++5MrsEIvF9Pv3b3J0dCQfHx9WMFhZWbEpkGlpafT792/6/PlzrriG7IGmAoGAFQzyXra2tqxIklZIffPmjdKWzKLA79+/6a+//qIlS5bQw4cPWRdCx44dSSwW59qfYRiaMmUKTZ06lbp27UqrV6+m1Z8+0eBnz4hLWTd4ZeBzOMTncGiXhwc11YD7S5voxEAhceHCBapfvz41adKEdu7cqdITyp07d6hDhw708uVLWrBgAfXp00crNxWJREKHDx+miIgIun79OpUtW5ZGjhxJ7du3l5vyePDzZ2qR3w0jNDTLh7xiRc7tkZFEU6dmWQh8feUebicQ0Ht/fyL6/yC/2NhY8vb2pi1btpC3tzelpqayYiH7/yv7t7z3/oxszw+RSEQikYgyMzMpKSmJjfLXpgjh8XgkkUjI09OTbG1t6cyZM0qtOTsAaOHChTT861eioCAiNb9vHICQlkbuCxfSgsGDaerUqXT9+nXq2rUrzZkzR6M3oI8fP1KjRo3o8ePHlJycTJcvX6Zq1appbHxNkJmZSV++fGHFwfv372n8+PGUnp5ODRo0oM+fPyucWSGNaTAyMmJjUTIyMig5OZm+f/9Onz59YjMoZFV7tLe3p3v37lHJkiWpW7duOeIZ7OzsNB7fok2kLoSlS5fS4cOHydjYmHr06CHXhfDXX39RWFgYOQ4ZQi/+SVFVFc4/rwPlyhVpQaATA4WIMn0M5JGcnEyjRo2i5cuXU+PGjWn9+vVqBf7lBQC6dOkSzZkzh44ePcrW/e/Vq1euf++3qanklF/k8bhxRDdvEq1fT+Tk9P/bJ04kunIlK8BM3o9HIiG6coX8jh2jgIAACggIoOrVq9OdO3eoTp069PTpU5ViHZQlIyNDYeEgfUljM6pWrUqVK1dWWqDklVIoC4FAwMY1/Pjxg5ycnMjS0lJpS4hAIKBt27bRuXPnqFX79vSuVy+6RqSyu4BHREIul1YYGdGUf6q77d+/nx4+fEhjxowhoqziOj169NBYimhSUhK1bNmS/v77b+rTpw+tXLlSI+NqiylTptC0adMoOjqavP8IllU0s0L6+vN7IxQK2QBIMzMzEovFJBAIiMPhUEZGBj1//pzu379PTk5O9PXr1xwBllwul2xtbfMMfLS3ty+SpcD/dCE0adKEBg0aRLVq1cpxDV4SFUWDlRT78uAQkZDDoQc+PuRaRDMRdGKgkFG2j4E8jh49SmFhYcTlcmnTpk0KFThSh0ePHtG8efNo27ZtpK+vT3379qXBgweTnZ0dEWUJB8erV+l9Xjeuu3eJhg3Ligto3vz/AwivXydq1Cgr7UwOXCJqnpBAeocOUVRUFL19+5aIiBwcHOjdu3e0ceNGqlOnDjllFxlFAIZhqGbNmpSQkEB3795VqdKdRCKh1NRUpS0bycnJtHr1arb2hTwBI2+cXPB4RL17E7VqlVUoShnrFsOQwc+fFHDuHDn8k7d96tQp+vjxI7Vs2ZLKly9PJ06coKtXr5Kbmxv169ePypYtm6eA0dPTU0hQZ2ZmkoGBAWVkZFB4eDhNmjRJ624aVbhz5w75+PjQ2LFj1bo2EP1/tcb8AiPzyqywtLQkU1NTEovFJBQKicPhkEQioeTkZPr58yd9/fo1Vw6+jY1NnlkShVnt8U8XQtmyZdksBEZPj8pER9OH9PS8456ePiXavDmrnHp6OpGdHVHjxlkZM3/AJyJfY2OK8vIqkkGFOjFQBIiIiKAxY8bQkiVLaODAgSqP8/HjR+rWrRudPHmSBg0aRBEREVr/ob17944WL15Mq1atorS0NOrcuTONGDGCSpcuTVPj42lKfHzeP6bY2KwfU1wc0c+fWT+mevWyutvlcXPhAvTKx4ccDQ0JAL169YqioqJo0aJFdPfuXdZ8WqxYMdZyEBAQQKVLly7UC79U/J07d07p2uiaICoqigIDA5Xq2xAbG0uNGzemHz9+0NatW6lixYo5xML1lBSak5lJrzkc4gLEyPt8/7mEcBmGSt65Q8UvXKD0X7/YcZKTk+n9+/eUnJxMAoGAMjMz86yMKAtFrR2nTp0ioVBInz59ogoVKlCLFi3I0NBQaXeMSCRSOQgxL9LT08nX15cA0I0bNwr8Cfv8+fNUq1Ytmj17NpUqVSpPEfFn7QwOh0PGxsZkaGhIQqGQuFwuSSQSSklJoV+/fuUSGpaWlnLFQkFUewRA58+fZ7MQjI2NqeysWXS1dOm8r103bhCNH0/k6prVc0Nfn+j9+yxh3KeP3MN2e3hQay1Zb9VBJwaKAABo5MiRNH/+fLVzeQHQsmXLaOTIkeTm5kbbt28vkIYsP378oDVr1tDChQvpw4cP1LRpUwobOZJaSSRsuo2m4DAM4dw5KrZtG40fP566dOnCXiy7d+9ODx48oCNHjtClS5coKiqKoqKi6Pbt28QwDFlaWlL16tUpMDCQAgICqGLFigXm+/z8+TOVLl2aGjduTJs3by6QOWXRuHFjevLkCT169CjfyP1Tp05RmzZtyMnJiY4cOSK30RUAivrxg9Z9+EA7YmMpU1qC+B/0uVzyMjSkVlZW1NXWlszkzAuA5s2bR6NHj6bmzZvThg0bSCKR0JIlS2ju3LlkaGhIw4YNo8DAQIVdM7Leu3XrFgEgsVhM79+/J6FQSCKRSC03jDpxHX/+vXv3bvrrr79o69at5OXllWtfbWfCdOzYka5evUpxcXH5ih11MyukcTRcLpcYhmGtXtkxNjYmJyenHE2o/nwpm5kli/j4eFq2ciUtqFKFYGoqPybm92+izp2JypXLqqqpoBuLR0TVTEzoopeX2mvVNDoxUERgGIa6detG27dvpyNHjqht5n/w4AF16NCBnj59ShERETRo0KACeSJOS0uj7du309y5cyk2Npacxo2jNxoINMuOmMulgyYmtHbmTNqzZw85OzuzoqBhw4ZkZmaWK4Xu169fdPXqVVYcXL9+nVJTU8nQ0JCqVq3KWg78/Pw03ppVSpcuXejo0aP0+PHjQo3Mvn//Pnl6etKKFSuoj5wnGKmoHDJkCDVo0IAtSJUf0husyMqKLj58SJkAGfH55CISKVU/4PDhw9SxY0dydXWlw4cPk5OTE71+/ZqGDBlCBw4coLp169Ly5ctVjgvp06cPXb9+nW7fvk2RkZHUokULcnFxoWPHjpGtrS0rIFQJKlVVoCgDj8fTSHCprL+TkpKoSZMmNGbMGOrXrx/7nqJumLxQN7OCz+cTj8cjhmFyFQLT19cnW1tbcnBwoOLFi1Px4sVzWBqcnJwUqvZ4OjGR6t+7l/eJHD6cVVVz0yaiYsWyimjp6SksCl76+ZFLEUs31ImBIkT2PgZnz55VuwZ4amoqjR07lhYtWkQNGjSgjRs3kq20AIyWYRiGjh8/TrPnzaPLHTsSlSihnE85D9a7u1PYP7EJDx8+pGnTptHu3bvJycmJUlNTqUOHDrRw4cI8x0hLS6Nbt25RVFQUXbx4kS5fvkw/fvwggUBAlStXZsWBv7+/Wq2kpZw7d47q1KlD69evp7CwMLXHU5fQ0FD6+++/6dmzZ7lSrDIyMmjw4MG0cuVKGjp0KM2dO1dhU/j79+/JwcGB/P396dKlS2qt8d69e9SkSRNKT0+ngwcPsnUujh07RgMHDqR3797RmDFjaMyYMUoLuJkzZ9L8+fPp6z/Nkx48eEANGzYkAHT8+PECb28szYb58eMH1apViwDQjh07KDMzUyNZL/L+zl7YKD84HA77FK8NEfLn33w+n02XlBUU+eHDB3r37h1rcfjzXDgcTi4xIRAIyMzMjGxsbMjBwYFcXFzIzc2NSpUqRc7OzuTo6EhLf/yg6a9eUZ4lyyZPziqnPWUK0eLFRG/eZLVcr1cvq4x6Pm6dnR4e1LaIuQp0YqCIkZycTPXr16dHjx5RVFQUeXh4qD3mqVOnqGvXrpSZmUkbNmygJk2aaGClinP4yhVq9/UrpejrZ1WeU4ORTk4UUaJELnX/8OFDmjp1Ku3evZvMzMxo9uzZ1LVrV4V9rRKJhB48eMBaDqKioujDhw/E4XCoXLlyOeIOlO3alpqaSp6enmRjY0MXLlwoEsFq8fHxVKpUKQoPD6dx48ax2799+0Zt2rSh8+fP04oVK6hnz55KjXv06FFq0qQJjRo1iiIiItReZ0JCArVs2ZJu3bpFGzduZF1oycnJNHPmTJozZw45OzvTsmXLlLKmSevMJyUlsWLo/fv31KhRI3rx4gUdOHCAateurfb6lWXy5Mk0c+ZMunHjBlWsWFGrc0mrdGYXCt+/f6eaNWtSUFAQ9e3bVytWkbxKe8tCKBQqJDqkN3+p1SA9PZ1SU1NzlBj//ft3/iJoxoys6ph5PeV3754VH0CU1UelYkWiO3eySnPXrp2VESUHAYdDQx0dKaJkSaU+B22jEwNFEHX6GMjj8+fP1KNHDzp8+DD17duX5s2bV6DNNt6lpVGtGzcoLiNDaZcBj4gYIprs4kKTihWTezNNSEggW1tbql69Ol2+fJmcnJxo/PjxSokCKQDoxYsXOcRBXFwcEWW1Vc0uDtzc3PK8wYeHh9PMmTPpzp07GhF3mmLw4MG0adMmevHiBVlYWFBcXBw1btyYvnz5Qvv27aOaNWsqPebw4cNpwYIFdOLECY1ltKSmplKvXr1o69atNHHiRAoPD2dTDZ88eUL9+vWjc+fOUUhICC1atEihQkIXL16kGjVqUGxsLJUuXZrd/uvXL2rdujWdO3eO1q9fT507d9bIOSjC7du3ydfXl8aPH0/hf3Z3LCA2bNhAPXr0oCdPnmgtNVeaDaNpS0d+7ynMqlVE+ZXt7tgxSww0bZrVaEvKggVER45kVVWV8z3kE1FHGxvapIVCceqgEwNFFHX7GMgCAK1evZqGDRtGxYoVo+3bt5NXAQaypDMMzXj1ima8ekUMkG9JT84/+zjxeLSzQgWqlk9p4ujoaPLz86OYmBjS09OjadOm0a5du9QSBdn5+PEjG5R48eJFunv3LgEgGxsbql69OisOPD09WbP6kydPqEKFCjRy5MgCbS6jCJ8+faKSJUtS7969qWHDhtSqVSuysbGhI0eOkKurq0pjVqtWja5evUofP34kGxsbja0VAEVERNC4ceMoJCSENm/ezIpZALRz504aNmwYJSUl0ZQpU2jgwIF5BtnFx8dT8eLF6dSpU1SvXr0c72VkZFCfPn1ow4YNNH36dBo3bpzWrTnp6enk4+NDHA6HoqOjCyU/HwBVrFiRnJyc6OjRowU+vzaRumEUERKjTE3pdX5VYbt1I4qPJ1q0KKs1t5S7d4mGDCEaM4aofn2Zh/KIqIONDW35l4oBggL8+PEDRIQfP34osruOfIiLi4O1tTUqV66Mnz9/amzcR48eoWLFihAIBJg7dy4kEonGxlaEl8nJGPP8OUwvXgRFRma9/v4bnDNnQGfOsNt8o6Nh3Lw5uvfpo9C4e/bsARHh69ev7LaHDx+iXbt24HA4cHZ2xqpVq5CWlqaR8/j+/TuOHz+OsWPHonr16hAKhSAiGBkZoX79+pg2bRoqVqyI4sWLIzk5WSNzaprw8HDw+Xzw+XzUrVsX3759U2s8MzMziMVizSxOBgcOHICBgQEqVaqEt2/f5njv+/fvGDhwILhcLsqXL49Lly7JHSc9PR0cDgdr166V+T7DMJg6dSqICD179kRGRoZGz+NPJk6cCD6fj9u3b2t1nryIjIwEEeH06dOFtoaiQNCdO/9/XZL3qlwZRATavDnn9s2bs7b37y/3WMH58xj49Glhn2YuFL1/a6b8lw6lcHV1pZMnT9LTp0+pRYsWlJa9za8alClThq5du0ZDhgyhkSNHUr169ejdu3caGVsRXPT1aVaJEvSlenV65ONDG93cqFVSEpkdO0a0ejU5Ll5MG75+pSve3jTWz4+2bthA76X+uTx49eoVicXiHAF/Hh4etGPHDnrw4AFVq1aN+vbtS25ubrR69WqlU8j+xMTEhIKDg2nmzJkUFRVFP378oIsXL9KYMWOIw+HQjBkz6M6dO/T27VuqV68ejRs3jk6cOEE/fvxQa15NkZmZSQkJCZSZmUlubm50/PhxMjU1VXm8X79+0bdv36ikFn2hzZs3p8uXL1NCQgL5+PjQzZs32fdMTExoyZIlFB0dTSKRiKpXr07du3enL1++5BpHIBCQnZ0dvX79WuY8HA6HJk6cSJs2baKNGzdS06ZNKSkpSSvnFBMTQzNnzqQJEyZoPU4gLxYvXkweHh4a74b6b8Pb0JD4+VmCSpXK+u+f3y3p33n8jjIAqmhoqPoCCxtNKgsdynH+/Hno6emhdevWyMzM1OjYZ86cgb29PczNzbF//36Njq0s379/BxHBw8MDRISSJUti/vz5MDY2xogRI/I9fuDAgfDw8MhzH21aCrLz5csXWFhYoEGDBli8eDFCQkJgbW0NIgKXy0XFihUxcOBA7N69Gx8+fND4/Pnx/ft3BAcHg8fjoVWrVuByuXj48KFaY16+fBlEhO7du2tolfL58OED/Pz8IBKJsGvXrlzvZ2ZmYuXKlTA1NYW5uTnWrl2bywJWpUoVdOnSJd+5Tp8+DSMjI3h7e+P9+/eaOgUAQFpaGsqXL4+KFSsiPT1do2Mrw/Pnz8HhcLB69epCW0NRYU9CQv6WgTVrsiwAderk3F67NojHA+3Zk+fxd3/9KuzTzIWi92+dGChkDhw4AC6Xiz59+oBhGI2O/eXLF7Rs2RJEhB49euBXIX1RGYaBgYEBFixYgBs3bqBNmzbgcrnQ19eHUCjEs2fP8jy+WbNmCA4OVmiuhw8fon379uBwOHBycsLKlSuRmpqqidMAAISFhcHU1BQfP35ktzEMgydPnmDdunXo0qULSpQokXVBIYKrqyu6deuGDRs2IC4uTuP/xtl5/vw5PDw8YGJigtOnTyMtLQ0uLi5o3ry5WuPOmjULRIQdO3ZoaKV5k5KSgg4dOoCIEB4eLvMzS0hIQGhoKIgIVatWxZ07d9j32rRpg9q1ays01927d+Hg4IBixYqpLZqyM2HCBPD5/BzrKgyGDh0Kc3Nz/P79u1DXUdh8//4dEUuWgHPyZP6CIDg46/dbsyZo8GBQjRpZf3foIPcYTmQkSl27ptXft6roxMC/iHXr1oGIMGnSJI2PzTAM1q9fD7FYDDc3N0RHR2t8DkVwdXXNYQV49uwZunbtCiKCQCDAwIED8fLlS5nHVqxYEb1791ZqvkePHmlcFFy4cAFEpNBT1rt377Bz5070798fFSpUAIfDARHBzs4Obdq0wdKlS3Hnzh2NWYQuXLgACwsLlCxZErGxsez2rVu3gohw5coVlcdu0KABiAhxcXGaWKpCMAyD6dOng4jQtm1bubEZ58+fh4eHB3g8HoYOHYqfP39ixIgRcHV1VXiuN2/eoHz58jA1NcX58+fVXvvNmzfB4/EwZcoUtcdSh58/f8LY2BijR48u1HUUJvfu3UPv3r0hFovB5/PhtmQJePmJgb//BnXtCrKxAfH5IAeHPGMFpGJg2R+xLkUFnRj4lzF79mwQEZYsWaKV8Z8+fQofHx/w+XzMnDlT426J/AgICEDHjh1zbe/evTv09fVhZmYGHo+H9u3bIyYmJsc+5ubmmDlzpkrzakoUpKamonTp0qhWrZpKgZmJiYk4evQoRo8ejWrVqkEgEICIYGJigoYNG2LWrFm4dOmSSmvbsGEDBAIBatasiS9fvuR4TyKRoEKFCggMDFT5qcXR0RECgaDAA1IBYO/evdDX14ePjw/evXsnc5+0tDRERETAwMAA9vb26Nq1K4RCoVLr/f79O+rUqQOhUIjt27ervN7U1FSUK1cOXl5eheoeAIClS5eCx+Ph9evXhbqOgiY9PR27d+9GYGAgK8DDw8Px7t07vE5Jgf7586Bz5/K3ECj44kVGwvnKFSQV8DVVUXRi4F8GwzAYPnw4iEiti1FepKenY9y4ceBwOAgMDMSrV6+0Mo8s2rRpg1q1auXaHh8fDz6fj4iICCxduhQuLi4gItStWxenT5/Gz58/QUTYtm2bWvM/evQIHTp0UFkUTJs2DXw+H/fu3VNrHVKSk5Nx/vx5TJ06FXXr1oWhoSGICCKRCIGBgRg/fjxOnjyZZ7ZJZmYmRowYwUbGy4uROHbsGIgIx48fV3qdGRkZ4HK5KFGihNLHaopbt27BwcEBDg4OuHXrltz94uPj0axZM9ZFc/XqVaXmSUtLY10Ps2fPVkk8jR8/HgKBAHfv3lX6WE0ikUjg5uaGNm3aFOo6CpIPHz5gypQpsLe3BxEhICAAu3btyiHKrly5AvPOnTUmBKSv82pm62gTnRj4FyKRSBAaGgo+n48TJ05obZ7z58/DyckJJiYm2Llzp9bmyc6QIUNQunRpme+FhobC0dERaWlpyMjIwI4dO+Dl5QUiQunSpUFEiIyM1Mg6sosCR0dHrFixIl9REBcXBz09Pa2aWzMyMnDjxg0sWLAALVq0gKWlJRuUWKlSJQwZMgT79u1DQkICgCwTcNOmTcHlcrFw4cI8b1wMwyAwMBCenp5KP90/ePAARISWLVuqdX7q8v79e/j4+EBfXx979uzJc9+FCxeCiCAUChEeHo6UlBSF52EYBpMmTQIRoW/fvkqlHt64cQM8Hg9Tp05V+BhtIRWAly9fLuylaBWGYXDp0iW0a9cOAoEABgYG6NWrVy4xxjAM5s2bBz6fjypVq6LljRvgaEgITI+PL6SzVwydGPiXkp6ejsaNG8PAwEDpJxtlSExMRNu2bUFECA0N1fq/bUREBExMTGS+9/DhQxAR1q9fz25jGAZnzpyBt7c3iAiOjo5YvHgxkpKSNLIeRUUBwzAICgqCi4tLgQZhMQyD2NhYrFmzBp07d2YtJkSEEiVKwNzcHCKRCOvXr1foCfbq1asqWVik8SzLli1T9VQ0RnJyMvudnTZtmtzz/vz5MytgBAIBXF1dcerUKaXmWrduHXg8Hho3bqzQdy41NRVly5aFt7d3obsHAKBu3bqoXLlykQxo0wS/f//G2rVr4enpyQbqLly4UGY9ja9fv6JJkyYgIowcORLp6el49vIlRFOmqCwAuP/8N/zlyyL/GevEwL+Y379/o3r16jA3N9dohPOfMAyDLVu2wMjICCVKlNCq+JAGssm7oTZv3hylSpXKFcuwatUqcLlctG/fHjweD+bm5pg4cSL7hKwusbGxeYqCv/76S2UTu6Z58+YNwsPDoa+vz8YcEBEcHBzQrl07LF++HPfu3ZP79N+8eXMUL15cqZTL9u3bg4hyxXEUFgzDYMqUKSAitG/fXmZgIcMw0NfXx8KFC/Ho0SPUqlULRIQ2bdrkKmiUFydPnoShoSF8fHxyZI/IYty4cRAIBBpzI6mDVFxv3bq1sJeiceLi4jBs2DCYmpqCw+GgcePGOHnypNzv/JUrV+Ds7Axzc3McPXoUQFZ8SNmyZeFSvDjmPX4M/QsXwD9/XqkYAatLl3D48+eCPHWV0YmBfznfvn1D+fLl4eDgoHXf/vPnz1G1alU2AlobVdnOnDkDIpKbRnj9+nUQUS4T8NixY+Hs7Awgyyc8ePBgGBgYQCQSoW/fvhqLcI+NjUXHjh3B5XLh6OiI5cuX48OHD7C2ti4yftetW7dCKBSievXq+PTpE758+YJDhw5hxIgR8PPzA5/PBxHBzMwMTZo0wZw5c3D16lX25v/w4UNwuVylglTd3d3B4XC0UrNBHXbv3g19fX34+fnJrOfg7u6OoUOHAsgSB9u2bYONjQ0MDQ2xYMEChb/jMTExsLOzQ/HixfH48WOZ+0jdA9OmTVP9hDRI7969YWtrW+T+zVRFIpHg6NGjCP4n5c/c3BwjR47Eixcv5B6T3S1QtWpVNogyIyMD9evXh4mJCR49egQAiE9JQd8nTyA8e5atJPhnpoBULJhFRWHs8+dILALWH0XRiYH/AO/fv4eLiwvc3d3x6dMnrc6VkZGByZMng8vlolq1ann+0FRB+rQSFRUld586derA29s7h9mtQ4cOCAgIyLHfly9fMG3aNFhZWYHL5aJVq1YaS5nMLgrEYjFEIpHclMeCQiKRYNy4cSAidOnSRW6MQ1JSEs6ePYvw8HDUqVMHBgYGICLo6+ujVq1amDRpEurXrw9LS0uFymAzDAM9PT3Y2Nho+pQ0wo0bN2Bvbw9HR8dclougoCCEhITk2Pbt2zf0798fHA4Hnp6eCqdbvnr1CmXLloW5uXmu729Rcw98/foV+vr6hZ7WqAm+fv2KefPmsXU7vL29sWHDhnxLgMtyCwBZ3+c+ffqAz+fj7NmzuY7be+IEqE4d9IiJQUBMDEpcvAjasAGVz5/H2OfPceDTJ6QWQkaNuujEwH8EbfUxkMfly5fh4uICIyMjjZoZv337BiKSWVVOitR6cPLkSXZb9erV0alTJ5n7JycnY9WqVXB1dQURoWbNmjh+/LhGfHhS94DUfbB8+XKNFi9SlKSkJLRs2RIcDgcRERFKnVt6ejquX7+OefPmoWnTpjA3N8/hWhg2bBgOHDiAz3LMnW/fvgURKVzApzB4+/YtKlWqBAMDgxyVNsPCwuDj4yPzmBs3bqDyPzXoe/TokSsdUxbfvn1DzZo1oaenh927d7Pbx44dW2TcA0BWbI5QKNSYG60wiImJQffu3SESiSAUCtGpUydcvXpVoe++LLeAlPnz5+eKTcrOjRs3QERsxkp8fPx/oqeDTgz8h4iJiYGxsTGCgoIK5Ib0/ft3dO7cGUSEDh06qN3kBshS5SKRCIsWLcpzHx8fH9SoUYPd5uTkhHHjxuU5dmZmJvbu3QsfHx8QEcqVK4fNmzerbCZNT09HuXLl4Ovri4cPH6JTp07gcrlwcHAoUFHw5s0beHt7QywW4+DBg2qPJ5FI8ODBAwQFBYHP58PBwYEVB2XKlEHv3r2xbds21i118OBBtgpgUeb3799o1aoViAgzZ84EwzAIDw/P06KRmZmJFStWwMTEBBYWFli/fn2+mRapqalsZcR58+bh+vXr4HK5mD59uqZPSSUyMjLg5OSErl27FvZSlCYtLQ1//fUXqlWrxgYMz5gxQ2FRI88tIOXAgQPgcDgYM2aM3DGkN39psOmXL19ARNi3b5/qJ1YE0ImB/xiRkZFa62Mgj+3bt8PExATFihXDxYsX1R6vRIkSGDVqVJ777N+/n62YJ81xV7SuOsMwOH/+PBo1asReUObPn6+0RWXWrFng8Xg5Os09fvw4hyhYtmyZUilryhIdHQ07Ozs4OTlpvKTtly9fYGxsjMGDByM+Ph5bt25Fr169UKZMGVYcODs7o1SpUiAibNq0qchHTEskEjYlsFOnTli9ejWIKF/h9vHjR3Tq1AlEBH9//3yf8CUSCcaOHcv6ritVqqT1zoeKsnv3bhBRoXZIVJY3b95gwoQJsLGxYa1Q+/btU+ozlecWkHLz5k0YGBigVatWeQq+pKSkHBk3aWlpICJs3rxZtZMrIujEwH8QbfYxkEd8fDwCAgLA5XIxYcIEtfyi/v7+6Ny5c577SCQSlClTBk2aNGGVuio1F+7fv48uXbqAz+fDxMQEY8aMUagZzfPnz6Gvr4/hw4fLfL8gRMGuXbsgEonkBsdpgunTp0MoFOaKh/j06RMOHDiAYcOGsTEHRAQLCws0a9aMfSIuCv5xWezYsQN6enpsU6z8+l5IiYyMRJkyZcDj8TB8+PB8BWT9+vXZm1dRqfvv7++PwMDAwl5GvjAMg8jISISEhIDH48HQ0BD9+/dXKXMqu1vgyJEjud5//fo17Ozs4Ovrq1C7cX19/RzWS4FAUCTSatVBJwb+o2izj4E8MjMzMX36dPB4PPj6+qocwd+qVSsEBQXlu9+mTZvYJ1IiYqN+VeHNmzcYMWIEjIyMIBQK0aNHD7lR4QzDoEGDBnB2ds63qZM2RIHUvC11z2jT8pCUlARbW9s8xZmJiQmMjY1x+vRpTJw4ETVr1oRIJAIRQSwWo06dOpgyZQrOnTtXZG6IQFZmipWVFYgIa9euVfi4tLQ0zJo1C/r6+nBwcMDevXtlim6peyA0NBQGBgbw8/PTeoBvfty8ebPIm7R//fqFFStWoGzZsmxBsWXLlql0X/nTLSAr4+rnz5+oUKECihUrlm9qqBQnJyeMHz+e/dvc3ByzZ89Wen1FCZ0Y+A+j7T4G8rh+/TpKliwJsViMDRs2KG2dGDRoUL6tiIEsn72zszPrP9REoaFv375h9uzZsLW1BYfDQbNmzXJVZ9u1axeISOYThjyePHmCzp07g8vlwt7eHkuXLlXpJp6cnIx27dqBiDB9+vQCsfysWLECHA5HpmlcWga6cuXKObanpaXhypUriIiIQOPGjWFqagqirGZTVapUwciRI3H48GF8/fpV6+vPi6dPn4KIoKenh0OHDil17MuXL1mzc4MGDXJYF1JSUlCmTBlUrlyZrRppY2ODkiVL4unTp5o+DYWRFqYq6J4jihAbG4uBAwfC2NgYXC4XLVq0wNmzZ1X+jufnFgCy4ieCg4NhbGyMBw8eKDy2l5dXjqZozs7OOcTBvxGdGPgPwzAMhg0bptU+BvL49esXwsLCQERo3bq1Uhf9WbNmwczMTKF9ly5dCg6HA1NTU1WXKpPU1FSsW7eOLXPs7++PQ4cO4evXr7C1tVW57K46okCZUruaJD09Ha6urmjcuHGu96KiokBE6N+/f55jSCQS3Lt3D8uXL0e7du3YuvDSQM6+ffti+/btePPmjbZOQy6Wlpbw8PBQKRMDAA4dOgRnZ2eIRCJMnToVqampGD16NIRCYY4bzIsXL1C6dGlYWFio1R1SVT58+ACBQIB58+YV+NzyyMzMxMGDBxEUFAQigpWVFcaNG6d2zZSrV6/m6RYAsq6P/fv3B4/HUzoToF69ejmuAWXLlsXgwYPVWXKhoxMD/3Gy9zHInopXUOzZswdmZmZwdHTEuXPnFDpm8+bNICKFfHe/f/+GSCSCpaWlukuViUQiwaFDh+Dv7w8igqmpKUQiEZ4/f67WuMqKgpiYGDg6OsLe3h43b95Ua25V2Llzp8z6D9IqfwcOHFBqPIZh8Pz5c2zatAndu3dngxCJCC4uLujcuTPWrl2Lx48fa936UalSJXTv3h3jx4/Pt0aDPJKSkjBmzBjw+Xw4OTmBw+HI7KD59etXBAQEQCQS5UhxLAgmTZoEsViskawfdfn06RNmzZoFZ2dnEBH8/PywdetWtTNwFHELSFm8eDGIFGs1/icdOnTIEXfh5+eHsLAwldZcVNCJgf8B0tPT0ahRIxgYGODatWsFPv+bN29Qq1YtcDgcjB49Ot9UvtOnT4OIFC5o5ObmBi6Xq7UgOilr1qxhb1h2dnaYPXu22hfWJ0+eIDQ0NE9RsH//fhgYGKBSpUpKlcnVJBKJBN7e3qhWrVqOm7P0iU5e22Bl+PjxI/bu3YvBgwfD29sbXC4XRARra2u0bNkSCxcuxM2bNzUeld+iRQvUr18fALBt2zbo6enB399fpRz8mJgY6Ovrs2WNZX0uKSkpaNu2LTgcDhYvXqz2+hUhNTUV1tbW6NevX4HMJ4/r168jNDQUQqEQenp66Nq1K27cuKGRsRVxC0g5cuQIuFwuRowYodJcgwcPzuHKDAoKKjIVSFVFJwb+RyioPgbyyMzMREREBAQCAby9veUG5wFZEf5EindSK1WqFAQCQb7piOqQnp6OChUqoFKlSnjw4AF69OgBoVAIIyMjjBgxQm3z9tOnT3OIgiVLliA5ORkzZ84EEaFVq1aFHnx36tQpEFEO37qdnR1EIpFWnt5//PiBkydPYvz48QgMDISenh6ICIaGhqhXrx6mTZuG8+fPK2RByovBgwejTJky7N9Xr16FjY0NihUrpnSRoFGjRkEgEGDWrFmwtraGkZERFi1alEvASCQSjBo1CkSEoUOHKt0lUlmkQbZ5/e60RUpKCjZv3szW93BxcUFERITcIlaqoIhbQEpMTAzEYjFatGih8ucurWwqpXnz5ggODlZprKKCTgz8D5GYmIjy5cvD0dFR630M5HHz5k24u7tDX18fq1evlnkT+fr1q8z+A7JgGAYGBgaoVasWjIyMtGYCnTt3LrhcLlt1DMjy4Y8dOxYmJibg8/no0qUL7t+/r9Y82UWB9Alz3LhxWr9ZKALDMKhduzbKli2LzMxMpKeng8vlym05rWlSU1MRFRWFmTNnskFfRFktiKtVq4bRo0fj2LFjSn8H5s+fD7FYnOO7+OrVK3h6esLQ0FDhQNGrV6+Cy+Vi1qxZALJ+b3379gWHw0HFihVlNvhatmwZuFwuQkJC1BY18mAYBl5eXmjQoIFWxpdHfHw8xowZw7bZrl+/Pg4fPqzR4EVl3AJAViVKe3t7VK5cWS1xLW2MJv1ddu7cOVc59H8bOjHwP8a7d+/YPgaaVObKkJSUhN69e4OI0KxZs1zrkNa6VyQLQlr9a+3atdDT09NKlbf4+HgYGBhgyJAhMt//+fMn5s+fD0dHRxARGjVqhAsXLqj8tJyQkAAvLy9wuVxwOBzY2dlhyZIlWk0hVJTo6Gg2nVNqwWnfvn2hrCUzMxO3b9/GkiVL0Lp1a9ja2rKloT09PTFgwADs2rUr37oR0iI8fwa5/vr1C82aNQOHw8G8efPy/PdMSUlB6dKl4evrm8sKEB0djUqVKoHD4aBXr1655jl06BD09fVRrVo1rfwmL168mKt8t7ZgGAanT59Gs2bNwOVyYWJigiFDhuDJkycan0sZtwCQ9e/p5eUFJycnhWqJ5MXevXtBRGyJ6r59+6JixYpqjVnY6MTA/yDSPgY+Pj4F0sdAHgcPHoSFhQXs7OxyRfO6uLjkWRJUyq1bt0BEiI6ORt++fWFpaalRczrDMGjcuDEcHR3z/azS0tKwefNmlCtXDkQEX19f7N27V6knoXv37qFYsWKwsbHBtWvX8PTpU3Tp0gVcLhd2dnZYvHix1p4gFaVVq1ZwdnZmA7Dk1XAvaBiGQVxcHDZs2IBu3bqxvSiICCVLlkTXrl2xfv16PH36NMeN/dq1a3Ir8kkkEowZMwZEhG7dusmNdxk5ciSEQqFcF1xmZiaWLVsGY2NjWFpaYuPGjbnWYGVlBTc3N4ULIClKSEgISpcurdVAzO/fv2Px4sVwd3cHEaF8+fJYvXq1RtJ9ZaGMWwDI+vybNGkCIyMj3L17V+35L1y4kMPtMmrUKLi6uqo9bmGiEwP/o8TExMDIyKjA+hjI4/3796hXrx6ICMOGDWPXUrVqVXTp0iXf4w8cOAAiQkJCAl68eAEej6fRoKx9+/YpHS3PMAyOHz+OmjVrgojg6uqKVatW5XsTP3LkCAwNDeHp6ZnL3CkVBTwer9BFwZMnT8Dj8VChQoVC80Mryvv377Fr1y4MGDAAnp6e4HA4ICLY2tqiVatWWLx4MRuwevjwYbnjbNmyBUKhEAEBAbme3qXuAUWKznz48IHtW1C9evUcbqVnz57Bzc0NVlZWuH79unInmpgIxMUBz54B37+zm1++fAkul4sVK1YoN56C3L9/H3369IFYLAafz0ebNm1w8eJFrQkPZd0CUgYPHgwul4vjx49rZB1/dledOnVqke3aqSg6MfA/TGH0MZCFRCLBwoULIRQKUaFCBTx48AAtW7ZEvXr18j120aJFOQLYOnXqBCcnJ430aP/x4wfs7e3RtGlTlce4fv06WrVqBQ6HA2tra0yfPj2XmVh6gZMWOcqrqmFcXFyREAW9evUCl8sFj8crkgVs5PHt2zccO3YMY8aMgb+/P4RCIWs98PDwwMyZMxEVFSVTIF++fBlWVlYoXrw4Wz8gOTkZ7u7uMt0DeXH27Fm4u7uDz+dj5MiR7L/558+fUa1aNejr6+ddBCkjAzh4EGjVCnBwAIhyvpycgHbtsK5lS5iZmGj0CT09PR179uxBjRo1WGE1efJkjWSU5IWybgEpy5YtAxFh+fLlGltLQkJCjoeEhQsXQiwWa2z8wkAnBv7HkfYx6Nu3b6E3mblz5w48PDwgEokQGBiIcuXK5XvMsGHDUKpUKfbvBw8egIiwceNGtdczaNAgiMVijQRbxsXFoW/fvhCJRBCLxWzzn7S0NHTv3h1EhDFjxigcKBgXF4euXbsWmih48+YNiAjGxsYFNqc2SE5OxoULF2BmZobixYvDyMiIrUgYEBCAcePG4cSJE+w1LT4+HuXLl4eRkRGOHz+OESNGQE9PT6VS2KmpqZgxYwZEIhGcnJywf/9+MAyD5ORkhISEgMvl5q53zzDAtm2AnV3WTZ/Hyy0E/nkx/7yXaGQE7N2r9mf14cMHTJ06lS0YVb16dezcuVMjwjs/lHULSDl27Bi4XK7ceB9VycjIAIfDwZo1awAAa9euBREViUBfVdGJAR1sH4PJkycX9lKQnJyMAQMGsKVr86sVHhISkquPQdOmTVG6dGm1fpg3btwAh8PB/PnzVR5DFgkJCZg4cSLMzMzA5XJhbW0NPp+PTZs2qTRedlFga2uLRYsWFYgokIqBgqjvUBDUqFED7dq1Q0ZGBm7evImFCxeiZcuWbO8CLpcLLy8vDBo0CFu2bEG9evXYOgjq1qR/8eIF20GzUaNGeP78OSQSCYYOHco+BUskEuDzZ6Bx46ybPYcjVwTkEgXSfVu3BpTMtGAYBpcvX0b79u0hEAhgYGCAnj17arxDZl7zq+IWAIC7d+/C0NAQTZs21Yr1ytzcnC0sJS3KVZgxWOqiEwM6AGSVACYiLF26tLCXAgAYMmQIW5702LFjcvfz8fFB9+7dc2y7evUq1GnGkpGRAW9vb1SsWFFrbWdv3LgBCwsL9oZSr149nDlzRmXrTEGLgj179oCIIBKJ8i1F/G+gc+fOqFatWq7tDMPg8ePHWLt2LUJDQ1G8eHHWrSD9twsMDERsbKxaljWGYXDgwAE4OTlBJBJh2rRpSE1NxaJFi8DhcNC7aVNIXF3ztATk++LxgPLlgX8i4PPi9+/fWLduHSpWrMjGvSxYsACJiYkqn6OyqOoWALJiRZycnODl5ZVvMzFVcXd3x9ChQwEAR48eBRGpnaVQmOjEgA4A/9/HgMPhFHgfA1mcPHkSRIRatWqBiDBgwACZNzdra2tMmTIl1/aaNWuicuXKKl2gFy5cCA6Ho3wQl4KcOHECxsbGKFu2LJ4+fYrt27ezF11vb2/s2LFDZRFSUKKgV69e7L8Ln8/XeAR8QTN+/Hg4OjoqtO/bt2/RqFEjcLlc2NjYsOLA1tYWbdu2xbJly3D37l2VLFNJSUkYNWoU+Hw+3N3dcebMGRzcvh2POBxkqCoC/hQE3t6AHNP+s2fPMHz4cJiZmYHD4aBx48Y4ceJEgZu/VXULAFmfYaVKleDg4KDVip3ZW61Lswu0kUJZUOjEgA4WiUSCzp07F1ofg+zcvXsXRIQrV65g2bJlEIlEKFu2bI60oOTkZEhz3v9EGiGubAOS169fw9DQEAMGDFD7HP6EYRgsWbIEXC4XDRs2zPE7keZnS8v7uri4YOnSpSoHfj179gzdunVjRcHChQs1Kgq8vLzA4XCQmJgIBweHQqs1oClWr14NLperkAi7fPkyOBwO5syZAyDLL21sbAxTU1N4enqCz+dD2seiUaNGmD17Ni5fvqyUb/3BgwcIDAwEEeGYu/v/m/plvFKJMIoIdkQQEcGXCKfzEgQcDpCttblEIsGxY8fQsGFDcDgcmJmZYeTIkWr331AFddwCQFYKYfPmzSEWi2WmimqS7FUHpSnO2YuS/dvQiQEdOSjsPgZSPn/+nMPU/+DBA1SoUAFCoRALFy6ERCLBkydPQEQyGyAxDINKlSqhVq1aSs3bvHlz2NnZ4Xu29CxNkJ6ejr59+0KaQpmXDzMmJgbt27cHj8eDhYUFJk+ejE+fPqk0r7ZEgbGxMSwsLAD8f/BUTEyM2uMWFidOnAAR5XvzSU5ORqlSpVClSpUc/4YvXrxA2bJlYWxsjIMHD+LcuXOYMmUKgoKCIBaLWZdKjRo1MGHCBJw+fTpf8zXDMDg6aRIk+TzttyMCnwgjiLCaCFX/+TsqHwvB98uXMW/ePJQsWRJEBC8vL6xfv77Qyl6r4xaQMnz4cHC5XKWtCarQo0cPtnW3tBX2+fPntT6vttCJAR25+P37N/z9/QutjwGQdSEUCAQ5oqlTUlLYoKp69ephx44dICK5TzDSKmGKipqDBw9C0TLIypCYmIg6deqAz+dj7dq1Ch/34sULDBw4EAYGBhCJROjXr5/K5nhNigLp71zqY8/IyIC7uzvb7OffyJ954/IYNmwY9PT0EBsbm+u9Hz9+oGHDhuByuViyZAnrokpPT0d0dDTmz5+P5s2bw8LCAkQEHo+HypUrY+jQodi/f79swdemDZsVIOt1/R8Xxdxs21KIUPIfUSDvuEwOBxt4PAgEAnTs2BFXrlwp1GwiddwCUlatWgUiKrDmT2PHjoWLiwuArBgFIsLRo0cLZG5toBMDOmRSFPoYODs7Y9y4cbm2nzp1Cra2tjA0NAQRyTW/SiQSuLu7o1mzZvnO9fPnTzg6OqJhw4YavSg+efIEpUqVgrm5OSIjI1Ua48uXL5g6dSosLS3B5XLRpk0blTu9PXv2DGFhYWqJgsjISBBRjo5vUuGlaJvqosbPnz9BRPjrr7/k7nPp0iVwOBzMnTtX7j6ZmZkYNmwYiAi9e/eW+XTLMAwePXqEVatWoWPHjmwbXyJC6dKl0bNnT2zZsgWvoqPzFAIgwkgi8Ijw44/tM/8Z73Uex2bweEgoZB+3um4BKSdPngSPx9OKe08e0p4WQFapYyLCjh07Cmx+TaMTAzrkUth9DPz8/NCtWzeZ733+/BmlSpViL7ryfOsbNmwAEbFFYuQxdOhQ6Ovr4+XLl+oum+XMmTMwNTVF6dKlERcXp/Z4v3//xooVK1CiRAk2uPLEiRMqiZfnz5+zosDGxgYLFixQ2Dw8bty4XPEYDMPA19cXvr6+hV6vQlVMTU3ZJkN/8vv3b7i5uaFq1aoKpamtW7cOfD4ftWvXzlVkShavXr3Ctm3b0Lt3b3h4eID+Mf/nFxAYRIQyMraf+UcMHM5vjAIwp8tDE24BIKsKopGRERo2bKi17B9ZbNmyBUSE5ORkSCQSEJFSlr+ihk4M6MiTp0+fFlofg+bNm+fZaS00NBQlSpSAvr4+3N3dZQbvpKWlwdHRkY36lUVMTAy4XC4iIiI0sm4gy2TJ4/FQr149jXdSzMzMxJ49e1C5cmVI68Bv3bpVpYupKqJAWnnuz5vcuXPncsR5/NuoUKEC+vXrJ/O9oUOHQiQSKVV6+fz587CwsICrq6vSJZs/f/6MuKZNkcnl5nkzL0uE2jK2P/xHDKzKSwjw+UB4uFLr0hSacAsAWYWQnJ2d4enpWeDXp+PHj2dZX16/BgCIxWIsWLCgQNegSXRiQEe+FFYfg379+qFChQpy369Zsybatm2L2NhYeHt7QyAQICIiIlca1KJFi8Dj8fDixYtcY2RmZqJy5cooX768yk8m2cnIyMDgwYMhTbvT5pMKwzCIjIxEcHAwiAhOTk5YsGCBShdFZUSBtbU1DA0NZb5Xv359uLu7F+gTmqZo3LgxGjdunGt7VFQU27lQWZ49e4YyZcrAxMRE6cwWBAfnaxkoQYRgGduf/yMGFuZ1PJcLtG2r9Dmpg6bcAkCWtcbHxwd2dnZ48+aNBlepGNIOntLAWVtbW0ydOrXA16EpdGJAh0JI+xi0adOmwGrRT5s2DVZWVnLfL1GiBEaNGgUgywIwevRocDgc1K5dO8fFISkpCZaWljKf+pYuXQoOh4MrV66ovd7v37+jQYMG4PF4Gq2Drgj37t1DaGgo+Hw+TE1NMW7cOJUqAz5//hzdu3dnRcH8+fNziIL09HRwOByUL19e5vExMTH/WnOpLPH5+/dvuLq6KuwekEX270Wu8sJ5ERiYrxhQyzJABKjRd0NZNOUWALLigUJCQmBgYICbN29qcJWK8/LlSxARTp06BQBwdXXFyJEjC2UtmkAnBnQozP79+8HlctGvX78C8QuvX78e8gIEJRJJrmwDIMtU7eDgADMzM+zNVo992rRpEIlEOcobv337FkZGRujTp4/aa1XrCVCDvH79GsOGDYOhoSH09PTQq1cvlQqhSEUBn8+HtbU1Kwqk9R/kxXIAQLt27eDg4FDorZaVZfbs2TA1Nc2xbciQIUq7B2SRkZHBVtXs16+fQpYTpm5d7cYMcLlZJYoLAE25BaRIhf/Bgwc1sDrVkAYNSoNOvby80Ldv30Jbj7roxIAOpZDmlBdEH4M/fXLZeffuHYhI5oXl69evCAkJAREhLCwMv379QmJiIgwNDTFmzBh2v1atWsHGxkZtn/6FCxdY37CslLPCIDExETNnzoSNjQ04HA5atGiBq1evKj3On6KgWbNmOS6AsoiLiwOfz2eL8vxb+Ouvv3Jcvy5evKiye0Aeq1evBp/PR1BQEFval2EYvHv3DidPnsS8efPQtWtXVKpUCSt5PKTlIwZGkOxsghmUfzYB+Hxg7FiNnZssNOkWkCK9BhW2f55hGIhEIixatAgAEBAQgE6dOhXqmtRBJwZ0KE1B9TG4ffs2iEhmWeArV66AiHJUJMwOwzDYsGEDxGIxXF1dcf36dYwcORLGxsb4/v07W0tc3VSgDRs2QCAQoFatWgpFjRc0KSkpWLt2LZt5ERAQgMOHDytdXvbFixfo0aMHOBwOiAgTJkzIM9CwX79+MDMz03jwpDaJioqCNPNE6h6oVq2aRt1i3759w+LFi2FgYABTU1P4+PjA3Nwc0tRCAwMD+Pj4ICwsDCfbtQOTjxi4RrnrDKQSwZUIfvm5CIg00s1QHpp0C0g5c+YM+Hw++vTpUySyVhwdHTFhwgQAQMOGDdG8efNCXpHq6MSADqVhGAZDhw4Fh8PRal7tnz3DsyMtOJRfpcC4uDj4+vqCx+Nh9OjR0NPTQ3h4OIoVK4Z69eqpfEHJzMzEiBEjQETo2bOnRi502kQikeDAgQOoWrUqiAhlypTBhg0blA4IdXR0BJfLZS0F8+bNk5nW+eHDBxgYGOSwxBR1Xr16BSLCiRMnMHjwYIhEIpVrzaekpCAmJgZbtmzByJEjERwcDEdHR/amz+PxIBQKIRQK0a1bNxw8eJDtVsjy8qVC3QlbU1bFwZGUVYGw2j9/X8hPCPB4QD5dQVVF024BIKswlImJCerXr19kAlS9vLxYN2ObNm1Qp06dQl6R6ujEgA6VkPYxEAgEbACNNubg8/lYsWJFrvciIiJgYmKi0Djp6emYMGECuFwubG1tIRKJIBKJVK7m9/PnTzRp0gRcLhcLFy4sEk8oynDp0iU0bdoURAR7e3tEREQoVH5ZWhWyePHirKUgL1EwYcIE6Ovr4927d9o6FY2SkZEBLpeLESNGKNy+OjMzE0+ePMHevXsRHh6OkJAQuLu7sx0NpX0mGjdujLFjx+Kvv/7CvXv3kJqaim/fvqFevXrg8XhYtWqV7Anq18+3U2HKP+4CWyLoEcGHCCfzEwJ8vlbiBbThFgCyHgxcXFxQrly5InV/qVu3LkJCQgAA3bt3h5+fXyGvSHV0YkCHyhREH4PsZrjs9OvXT25EuzwuXrzI9qf39vZWaT3x8fEoX748jIyM8myt/G/g0aNHCAsLg0AggJGREUaOHJlnl7fXr1+DiHKYQvMSBd+/f4eFhQV69eql9XPRFNLgU39//xzuAYZh8PbtW5w4cQJz585FaGgovL29IRKJ2Ju+lZUVateujUGDBmHt2rW4evVqvtfCjIwMDBgwAESEgQMH5n7iPXkyf1O/qq9LlzT62WnDLQBk9YOoUqUKbGxsEB8fr5ExNUWHDh1Qo0YNAMDgwYPh4eFRuAtSA50Y0KEW2fsYPHr0SOPj+/j4oHv37rm2y8sJzwuJRAIfHx8IBAIQETp27KjUd/Xy5cuwtrZG8eLF861o+G/i3bt3GD16NIyNjSEQCNCtWzeZPSm2b98OImIDprLz8uVL9OzZE3w+H1ZWVpg7dy6SkpIwf/588Hg8taPxCwo7OztwuVz89ddfWL58Ofr27Yvq1avD1NSUvemLxWL4+fmhe/fuWLRoEc6cOYOEhAS15l2xYoX8IlVt2+ZrHVDqxeMBPXuqtd4/0YZbAMj6zbZp0wb6+vqIjo7W2LiaYtCgQawAmDBhApydnQt5RaqjEwM61EabfQyaNm2Khg0b5tpevnx5udXi5LFy5UoQZbU8lnaRK168OC5fvpzvsVu3boVQKET16tVV7iBY1Pnx4wfmzp0LBwcHEBEaN26Mixcvsm6Qbt26gYhw//59uWP8KQpmzpwJBwcHtC6gFDZlSE5Oxq1bt7Bp0yaMGDECvr6+7A2fiMDn81GuXDm0b98eM2bMwKFDh/DixQulgy8V5e+//5ZdvvrzZ2RaWiJDA0Igk8MB4+wMaOgarS23gJRx48aBw+EU2aqW06ZNg7W1NYCs1FQzM7NCXpHq6MSADo0g7WNQunRpjfYx6NOnDypWrJhru4mJiVLlgz98+AATExP06NEDQJZlQVpMhsvlYvLkyTKDkiQSCVuLv0uXLgVagbGwSEtLw6ZNm9ga+VWqVMH+/ftRvnx5cLlchYK3sosCIyMjEBEuXrxYAKvPTUZGBmJjY7Fnzx5MmjQJLVu2RKlSpXL59Q0MDGBoaAhLS0vcv39fbgMsbfLkyRO4ubnlaGz16tUr1HN0RCKXm2/jorxeEi4XH4gwq0cPjcS5aMstIGXjxo0goiKdorpy5UrweDxIJBIsX74cAoGgsJekMjoxoENjSPsY+Pr65turXVGmTJkCGxubHNu+f/8OZdMC27VrBysrKzb97/LlyyAi7N27F1OmTAGPx0PVqlVztENOSkpCy5YtweFwEBER8a8LFFQXiUSCo0ePIjAwEEQEDocDY2NjpKSkKDyGVBQQEQQCAebMmSO3qZS6MAyD169f4/jx44iIiEDnzp1RsWJF6OnpsTd9a2tr1KlTB4MHD8a6detw7do1/Pr1CwMHDoS+vj4mTZoEgUCgtad/Rcje8nr27NkoXrw4XFxc8DYyEihbVqEMg1wvDgfw9sb6iROhiToh2nILSImMjIRAIEDPnj2L9O9uz549kPbp2Lx5M/LqolrU0YkBHRpF2segbt26GnmKXrt2LTgcTo6n0Xv37oGIFC4hfPLkSRARtm7dmmN7YGAg22XvypUrKF68OIyMjLB582a8fv0aXl5eEIvFhVrlrKhw5swZ9oZqY2ODGTNmsEVzFGHNmjWQptRZWVmpLQq+fv2KCxcuYNmyZejTpw/8/f1hYmLCrtHQ0BBVqlRBz549sXjxYpw9e1auX//8+fMgIixcuBCHDx8GEeH9+/cqr00TpKeno1OnTiAiGBsb/79ITUsDJk8GhEIwHA4k+QkADgcQiYBZs4B/fkPSOiGzZ89Wel3adgsAwOPHj2FmZoagoKAin7Ir/e48fvwY+/fvBxHhy5cvhb0sldCJAR0aJzIyEkKhEG3btlW7YIu0OFD2KPcjR47k2iaP379/o3jx4qhTp06uJ4wTJ06AiHDmzBkAWd/fLl26sPEEDg4OuHPnjlrr/6/w999/Q1pKt3fv3tDT04NYLMaQIUMUuiEwDINq1aqhbNmyOWIK8hMFv3//xo0bN7Bx40YMGzYM9erVg729PXvTFwgEKF++PDp06ICZM2fiyJEjePnypcJP9klJSShRogSqV68OiUSCO3fugIi0lh2jKPHx8ShevDgsLCzA4/EQHBycM/3z61ecrFcPD+S5Dvh8wMsLWLIEkJE2OmnSJBARFi9erPCatO0WALK6NZYsWRIeHh7/ioJVDx48ABHh0qVLOH36NIioyGU8KIpODOjQCprqY3Dr1i0QEW7cuMFuk/rmFLngjx07Fnp6ejKLxzAMAy8vrxyFQnbu3AmBQAAejwd7e3tcuHBB5bX/l5AWWIqKigIAfPz4ERMmTICZmRl4PB46deoktxqklIsXL4KIsHPnTsTHx6N3794QCASwtLTE7NmzcfPmTezevRsTJ05EixYt4OrqylY85HA4KFmyJJo1a4bx48dj586dePDggdo3pAEDBkBfX58N2Pv69SuICLt371ZrXHWIj4+Hi4sLihcvjlevXuHUqVMwMTGBh4dHDjeWp6cnOnToAKSkADduZKUhnjoF3LwJ5GOVYxiG/Tdds2ZNvmvStlsAyCrU5O/vDysrK5kdRosi0sJoBw8exNWrV/MNsC3K6MSADq2hiT4GHz58ABHh0KFD7LZRo0ahePHi+R774MED8Pl8TJkyRe4+u3fvhrTkcXh4OIgIHTp0wJMnTxAYGAgOh4Nx48YVeXOltvH39wcR5SpB/OvXLyxatAjOzs4gIjRo0ADnzp2TKwAbNmyIYsWK4eDBg5g9ezaaN28OCwuLHFH81tbWCAoKwtChQ7F+/XpER0drJc4gMjISf6ZKMgwDsVis0X4EyvDy5Uu4uLigRIkSOSwusbGxcHV1hYWFBS5cuIAXL16oLVoYhkH//v3B4XByudCy76Ntt4B0ng4dOkAkEqnUQ6OwyMjIAFFWl8779++DiP5V68+OTgzo0CozZ84EESnXujUbmZmZ4HK5OSq0tW3bFjVr1szzOIlEAn9/f7i7u+cZu5CZmQlXV1c2nW769OnsjSwzMxMzZ84En8+Hj48Pnj59qtI5/BewtLTMs+Jjeno6tm3bBk9PTxARKlWqhHXr1uHMmTNYunQpevXqhWrVqsHQ0JC96RsZGaFq1aro1asXwsPD0aRJE9ZSEBERobEgVFn8+vULxYsXR0BAQC4LU5kyZTB48GCtzS2Ply9folixYihRooTM5lxfv35FrVq1IBAI0K5dO+jp6eHnz59qzSmRSNC9e3dwudxcwqIg3AJSpG6LwrTIqIq5uTlmzZqF+Ph4EFGhdi1VB50Y0KFVNNHHwN7eHpMmTWL/rlq1Krp06ZLnMVKrhDQ9Sx7v37+Hi4sLG0Ami+joaLi5uUEsFmPdunVFOrpZG6SlpYHD4aBSpUoy309KSkJ0dDQ2bNiAIUOGwNvbG0KhkL3p8/l8lC9fHh07dsTs2bNRq1YtWFlZybzZ/+k+0JYo6N+/fw73QHbq16+PFi1aaHzOvJAKgZIlS8oUAlLS09PRq1cvEBGKFy+ukSZKmZmZ6NChA/h8Pg4fPgzg/90CZmZm7DZtsWXLFhARZs6cqdV5tEWpUqUwbNgwfPnyBUSE/fv3F/aSVEInBnRoHXX7GFSqVAk9s1VMs7e3x8SJE+Xun5CQADMzM3Tt2jXPcWNiYuDg4AB7e3tYWVnlKTB+/fqFHj16gIjQsmXLf23EsCrExMSAKKsh08OHD7Fz505MmDABzZo1Q8mSJXP49V1dXdG8eXNMnDgRs2bNQnBwMDgcDiwtLREeHo7Pnz/j5cuXEAgEmDFjhtw5X716hT59+uSIKdCUKDh37lyewXM9e/aUK3y0wYsXL+Ds7IySJUvizZs3+e6fkJAADocDDoeDRo0aaeR6m5GRgZYtW0IoFKJXr17g8/moUqWK1twCUi5cuACBQICwsLB/rcj29/dHaGgo0tLSQETYvHlzYS9JJXRiQEeBIO1jIBaLlY7Uzl56WPqUum7dOrn7d+rUCRYWFnkWP9q3bx8MDAxQuXJlvHv3DgsWLACfz883Enjfvn0wNzeHvb09m4XwX4NhGMTHx+PIkSOYNWsWKlasyD7hS5/27ezsUK9ePQwbNgwbN27EjRs35Pr1X7x4wQbq6evrY8CAAejSpQuMjY3zFVXZRYGFhYXaouDXr19wcXFBYGCg3ADUadOmwcrKSuU5lOH58+dwdnaGq6urQkIAyGqbLbW0GRsbo1y5cnj58qXaa/nw4QOsra1BRGjXrp3W42SePn0Kc3Nz1KpV61+bmw8AzZo1Q3BwMABAIBBg+fLlhbwi1dCJAR0Fhqp9DHr16sU2Fnr+/HmefjlpCtzGjRtlvs8wDBvH0Lp1azYg7tevXzA3N8eAAQPyXc/bt29Rp04dcDgcjBw58l9dlfDTp084d+4cFi9ejJ49e6JKlSpsxUBpjruZmRmICLNmzcL58+dVtop8/vwZ4eHhsLCwYNsgd+rUSaFjNSUK+vXrBwMDgzw7VkrLVScnJys9vjI8f/4cTk5OcHV1VShNVkqTJk1QvXp1AFltfUuUKAFLS0s200MVpG4BU1NTeHp6wtDQUKuBcF++fIGbmxtKly6tVL2Kokj37t3h4+MDADAzM1OpfkNRQCcGdBQoiYmJKFeuHBwdHfP0jWZn8uTJsLOzA/D/EeCyUgVTUlLg6uqKGjVqyDQ5pqSksIVcJk2alOvJcMqUKRCJRAo1nZFIJJg3bx4EAgG8vLwQGxur0LkUFr9+/cL169exbt06DBkyBHXq1IGNjQ1709fT00PFihXRqVMnRERE4NixY3j9+jUYhoGzszP09fU1tpbfv39j+fLlrMjw9/fHyZMnFTITv3r1Cn379lVJFJw9exZEhCVLluS5n9SNIOs7pimePXsGJycnuLm5KSUEfv36BT09vRzZDp8/f0aNGjUgFAqxadMmpdaRPVtA6hZISkpC9erVYWJiglu3bik1niKkpqYiMDAQlpaWKrcRL0qMGTMGLi4uAABnZ2eZXVb/DejEgI4CR9k+BqtXrwaXy0VmZmaeT20TJ06EQCCQeWP++PEjqlatCj09PWzfvl3mPF+/foWhoSHGjRun8LnExMSgdOnS0NfXx8qVKwvd75meno779+9jx44dGDduHJo2bYoSJUqwN30OhwM3Nze0bNkSkyZNwp49exAbGyu33wDDMODz+XB3d9f4WhMTE2FkZMSmFnp6emLbtm0Kmaf/FAWzZs3KM7Je6h6oUaNGvvUpnj17lqMYlaZ59uwZHB0dlRYCQJabiohy3UTT0tLQvXt3EBFGjRqlUGBhXtkCP378gK+vLywsLDSaN88wDDp37gyhUIhLGm6hXFjMmzcPhoaGAAAPD49CyUTRBDoxoKNQULSPgYRhsOrIEVD16lj2+DFar1gBs2rVkPzHxS42NhYCgUBmYOHdu3fh7OwMGxubfOMVhg8fDhMTE6W+w79//0bfvn1BRGjSpEmBdDWUSCR48eIFDh8+jBkzZqB9+/YoV64c256ZiGBvb4/69etj+PDh2LRpE27evJmrTkB+SNOl2rZtq5XzWLJkCTgcDjZs2IAGDRqAiODs7IxFixYp9MSvqCjo27cvDAwMchTtkUdqaiqICBs2bFDpnPIiLi4Ojo6OKFWqFN69e6f08Z06dUL58uVlvscwDBYsWAAul4umTZvmKY4UyRZITExExYoVYWNjozErydSpU0FEcgX5vxFpT4KUlBS2tfW/EZ0Y0FFo3Lp1i+1jkD2AiGEYXP7+HR0ePoThxYugyMhcL25kJHxu3sTG9+/xOyMDNWrUgKura64mOocPH4ahoSE8PT0Vcku8e/cOQqFQJb/f4cOHYWlpCVtbW5w8eVLp4+WRkJCAs2fPYtGiRejRowf8/Pxy5OubmJigevXq6Nu3L5YvX44LFy6wDZnURdo5TpEqdaqQmpoKFxcXNG/eHABw584ddOrUCXw+H2ZmZhg/fjw+fvyY7zivX7+WKwqk7oGlS5cqvC5bW1uEh4erdlJyUFcIpKenw9TUNM9MGiCrhLeRkREqVKiQKyBWllsgLz59+gQPDw84ODioXRVw+/btICJMnTpVrXGKGseOHQMR4c2bN6hTpw7atGlT2EtSCZ0Y0FGonDt3Lkcfg6e/f6ParVugyEjwz5+XKQSyCwKKjIT4zBlQrVo4/fff7LjSix6Hw0GzZs2UCjbr2bMnbGxsVAog+/DhA+rXrw8iwpAhQ5Tq8Pfz509cvXoVa9euxaBBg1C7dm02ulvq1/fy8kJoaCjmzJmDEydO4M2bN1p1TXTs2FGmWVqTbN26FUQ5G0+9evUKQ4cOhVgshp6eHnr37q1Q0afXr1+jX79+EAqFMDc3x+TJk+Hk5ISaNWsq1YnQ19cXYWFhKp2PLOLi4uDg4IBSpUqp3ARJ2iwqJiYm330fPHiA4sWLw9ramv1cVS0i9P79e7i6usLFxUXhOJ8/uXTpEoRCIUJDQwvdlaZpoqOjQUS4ffs2mjdvjoYNGxb2klRCJwZ0FDr79u0Dl8tFrblzoXf+PPh5CACZr7NnQZGRCLl/H78zM5GWloawsDAQEcaMGaN0O9q4uDhwuVyVU4QkEgkWL14MPT09lC9fPpfPNS0tDffu3cP27dsxduxYNGnShC18RETgcrlwd3dHSEgIJk+ejL179+Lx48caKTCjLB4eHuDz+Vq9gEskElSoUAGBgYG55klMTMSMGTNgbW0NDoeDli1bKpSaKhUFXC4XRIQRI0YoVa0vJCQEQUFBSp+LLJ4+fQoHBwe4u7ur1Q1xwIABcHZ2Vvjf4tOnT6hevTqEQiEmT56sVhGhV69eoVixYnBzc8OHDx+UOvbZs2ewtLREYGDgvzrzRh7S0tCnT59Gp06dEBAQUNhLUglF798cAKB8+PnzJ5mYmNCPHz/I2Ng4v9116GBps2cP7bGyUmsMLhFVNjAgwbhxdCMqitauXUuhoaEqjdW+fXu6du0axcXFEZ/PV2mMu3fvUps2bejFixdUv359MjIyovv379OTJ08oMzOTiIgcHR2pXLlyVL58efa/pUuXJn19fZXm1DRisZjMzc3pzZs3Wp3n+PHj1KhRIzp+/DgFBwfnej81NZW2bt1Kc+fOpbi4OAoMDKRRo0ZRcHAwcblcmWOePXuWgoKCKCAggK5fv06GhoY0YsQIGjBgABkZGeW5nmHDhtGxY8foyZMnap1XXFwc1axZk4yNjencuXNkZ2en0jgAyNnZmVq2bEmLFy9W+LjU1FQKDAykGzdukL29PV2+fJlcXFxUWsOLFy8oICCAzMzM6Pz582RpaZnvMd++faOqVasSwzB09epVsrCwUGnuokxSUhIZGRnR9u3bKSoqiq5du0YxMTGFvSylUfT+LfvXpkOHBtj/+bPaQoCIiCGi6KQkulG3Lp09e1ZlIUBENGbMGIqPj6edO3fmuy8ASkhIoDNnztCiRYuoe/fu5OfnR/7+/vT06VPKzMykY8eO0alTp8jHx4eWLFlCUVFRlJiYSG/evKETJ07QnDlzKDQ0lLy8vIqMEPj+/TslJydT2bJltT5XcHAwBQYG0tixY4lhmFzvi0Qi6tmzJ8XGxtL+/fspLS2NGjduTBUqVKDNmzdTenp6jv1//fpF3bt3p5o1a9L58+fp+fPn1L59ewoPDycXFxeaNWsW/fr1S+56nJ2d6c2bN6TAM5Bcnj59ygqByMhIlYUAEdGtW7fo7du31Lx5c4WPSUxMpDZt2tCNGzeoRo0a9OHDBxo2bBglJSWptIYSJUrQ2bNn6fPnz1S3bl369u1bnvunp6dTy5Yt6fPnz3Ts2LH/pBAgyhLMenp69PnzZzI0NMzze/WfQJNmBh06pHxKS4NZVBQ4kZGg48dBoaEgHx+QtPDN6NG53QIrVoCaNgW5uYF4vKz9/thnuwJBZ/nRsGFDlC1bNoeb4cePH7hy5QrWrFmDgQMHolatWrC0tGRN/CKRCJUqVUKXLl0wb948nDx5Eu/evcOxY8dgY2MDKysrHD16VO21FQTSwKi8ygZrkitXroCIsG3btnz3ZRgGFy9eZH3gDg4OmDt3Lnvt6d27N8Rica6gtzdv3qB///5sTMGMGTNkXq+kKXyKpL7K4smTJ7Czs0OZMmWUNqvLYvz48TA3N5ebAvonsrIFpMG0FStWVNn3DwD37t2Dubk5/Pz85LpeGIZB165dIRQKcfHiRZXn+rfg6OiIiRMnYurUqbC1tS3s5aiELmZAR6HSLTYWPOlNfMeOrJuqjQ3onxK4MsVAly4gPh9UqhTIySmXGOBERsI0KgpJavjYU1NT2Uj6kJAQNGrUCMWKFcvh1y9dujRatWqFKVOmYN++fXj69Gmefv2EhAQ0btwYRIT+/ftrvcKdugwcOBBEhJs3bxbYnM2aNUPx4sWVKk/78OFDdOvWDQKBAMbGxmjbti2IKM+Yj/xEwY0bN0BEKhXdefz4MSsEFMmEUAQPD498m3MB+WcL3Lt3D8WKFVMozTYvbt68CRMTEwQEBMhMV5VW+ZTXGvm/RsWKFdGnTx8sWLAAYrG4sJejEjoxoKPQ+JyWBkH2jIFTp0D79mX9/6pV8sXAvn2gkyez/r95c5mWAYqMxFoF0rckEgmePXuGAwcOYNq0aWjTpg0bNCe98QuFQjRs2BCjRo3C1q1bcfv2baWyBLLDMAxWrFgBkUiEMmXK4Pbt2yqNUxD4+fmBw+FovUZ9dh4+fAgul5tvlUBZvH37FoMGDWKb+HTr1i3fstfyREFCQgKICAcOHFBqDVIh4OHhoTEh8OTJE4XWomi2QEJCAqpVq5ZnAS5FuHLlCsRiMYKCgnL8Hnbt2sVW+fxfISgoCK1atWK7pSobtFwUUPT+rYsZ0KFxtiQkkCS7T1YoJDI3z/9Ac3MiPb08d+ES0fJ379i/AdCHDx/o77//pgULFlBYWBj5+PiQkZERubq6UosWLWjhwoWUkJBAtWrVomXLltGlS5do9+7dlJ6eTiNGjKCIiAjq1KkTVaxYkUQikUrnzOFwqG/fvnTr1i0SCoXk5+dHCxYskOknL2zi4uLI3NycBAJBgc3p4eFBXbp0oWnTpinte3VwcKDU1FQyMDCg0aNH06lTp8jDw4OaNWtGly9flnmMo6MjLVu2jJ4/f04dOnSgKVOmkIuLC61Zs4aEQiG9fv1a4fkfP35MNWvWJDMzMzp37hzZ2NgotX55HDp0iPT19alevXpy97l27Rp5eXnRpUuX6PDhwzRnzhy5/27W1tZ07tw5atu2LXXo0IEmTpyo0vevatWqdPToUbp06RK1atWK0tPT6dq1axQaGkodOnSg8PBwpcf8t2JlZcXGDBAR/f79u5BXpEU0qSx06ACAJvfusbUCcr3ysgxkf+VhGaBz59BryBDUqFGDLXlLRNDX10flypXRtWtXzJ8/H6dOncL79+9lpmwxDANPT0/UrVtX4+efmpqK4cOHg4gQFBSkUiEabSFtx1q1atUCn/v169fQ09PDlClTlDru9OnTICKsWLECQNbnu2HDBpQpU4Y9lwMHDuT51PbmzRsMGDAAQqEQXC4X1atXV+h6FhsbC1tbW5QtW1ah3hbKULVqVbYo058oW0Toz2Nnz54NDoeDkJAQuV0n8+PkyZMQCoVo0KABLC0t4e/vr7Ll7N/KwIEDUbZsWRw9ehREpFYKaWGhswzoKDSu//xJWn0e5nDo1LNnZGNjQ4MHD6YDBw5QXFwc/fr1i27cuEEbN26kYcOGUb169cjOzo44HI6MITg0duxY+vvvv+nWrVsaXZ6enh7NmzeP/v77b3r48CGVL1+eDh48qNE5VOXevXtERFSlSpUCn9vJyYkGDBhAc+fOpc+fPyt0zM+fP6l79+5Uu3Zt6t27NxFlfb7dunWjBw8e0JEjR4jP51OLFi3Iw8OD1q1bR6mpqbnGcXR0pKVLl9Lz58/J3t6erly5Qi4uLjRjxgz6+fOnzLljY2OpZs2aZGlpSefOnSNra2vVT/4PPnz4QNeuXZOZRZCYmEjNmjWjESNG0JAhQ+jixYvk7Oys8NgcDodGjx5N+/fvp5MnT1JgYCC9fftW6TXWr1+fNm7cSCdPnqTU1FTat2+fypazfytWVlb05csX1jKgasbGvwGdGNChUTIYhj5lZGh9nilr19KuXbto4sSJ1Lx5c3J1dSUej6fUGK1atSJXV1eaNWuWVtYYFBRE9+/fp8DAQGrRogX17t270M2Mx48fJyKiBg0aFMr8Y8eOJS6XSzNmzFBo/xEjRtC3b99o/fr1ueoOcLlcaty4MV28eJGuXLlCHh4e1KtXLzbFUFaKnKOjIwUFBVHFihWpU6dONG3aNJmi4NGjR1SrVi2ysrLSuBAgIjpy5Ai7/uz86RaYO3euyu6c5s2b0+XLl+nz58/k6+tLN27cUOr4jIwM2rBhA4nFYkpOTqYJEyYUSbeXNrG0tKQvX76QWCwmIvpPpxfqxIAOjZKhRv62UvNo4KLE4/Fo1KhRtH//fnr8+LEGVpUbCwsL2r9/P61Zs4a2bdtG3t7eGrdEKMOlS5eIKMsvXBhYWFjQqFGjaOXKlRQfH5/nvqdPn6a1a9fS3Llz8y2oU7VqVfbfsVmzZjRlyhRydnam4cOH5yqs5OzsTB8/fqQlS5bQ8+fPc4iC6dOnU3R0NNWuXZv1wVtpoFbGnxw4cIACAwPZHH0AtGDBAgoICCB7e3u6c+cONWnSRO15PD09KTo6mooVK0aBgYG0a9cuhY4DQP369aOLFy/S0aNHaePGjbR+/XoaMmSIWjUa/m1YWVmRRCJhz1lnGdChQ0H0uNwC+VIZKGkFkEdoaCjZ2dnRnDlzNDKeLDgcDvXs2ZNiYmLIyMiIqlSpQhERESSRSLQ2pzwePXpEhoaG+Vbq0yZDhgwhc3Nzmjx5stx9fvz4QT169KA6deqw7gFFKFWqFK1evZri4+Np0KBBtGHDBipRogSFhobS/fv3iSjLXfHhwwdKT08nBweHXKJA6kI5ePCgVoTAz58/6ezZs6yLQOoWGD58uEpugfywtbWlyMhICgkJoXbt2lF4eHi+N/S5c+fSunXraO3atVSzZk0KDQ2lVatW0dKlS2nMmDH/M4JAWo0xLS2NiHSWAR06FIbH4VCJAqi09/zsWXr27JnaFyU9PT0aNmwYbd26VakIc1Vwd3enK1eu0IgRI2js2LEUFBSk9XLA2QFAHz9+VLlsraYQi8U0adIk2rp1K3uD/pPs7gFZMR/5YWtrSzNmzKDXr1/T3Llz6fz581ShQgVq2LAhffv2jQDQu2xZKQ4ODtS7d28yMjIic3Nz+v79O1WuXJmmT59OP378UPlcZXHixAnKyMig5s2ba9QtkBcikYi2bt1KM2bMoClTplC7du0oOTlZ5r779u2j0aNH0/jx46lLly7s9l69etGiRYtozpw5NHXqVI2vsSgiFYPSOBSdZUCHDiWoamxMmnlul0NmJk3q0oXc3NzIzs6OQkJCaOHChRQdHU0ZKsQr9OrVi4yMjGj+/PlaWGxOhEIhzZo1i86dO0fPnj2jChUq0J49e7Q+LxFRfHw8SSQS8vb2LpD58qJHjx5UsmRJGjduXK73Tp06RevWraN58+ZRsWLF1JrHyMiIhgwZQs+fP6etW7fS27dvadSoUUREtGXLFtY68/DhQ6pVqxY5ODjQ48eP6cWLF9S5c2eaPn06ubi40LRp0zQmCg4cOEBeXl60d+9ejbsF8oLD4dC4ceNo3759dPToUapRowa9f/8+xz7R0dHUqVMnatu2rcwb/uDBg2nWrFkUHh6uVWtaUUFqGZBaBP7LlgFdaqEOjbMzISF3OuCgQaCwsKxyw0SggICsv8PCQEeO/H+lQum2f9LG2L/Hjs1qb3zuHIJv38a3b99w/PhxjBs3DjVq1IBIJGLTC2vWrIkJEybg5MmT+P79u0Jrnjx5MvT19fHp0yctfzr/T2JiIlq3bg0iQteuXZXqvqcKK1euBBFhy5YtWp1HUXbu3AkiQlRUFLvt+/fvcHR0RFBQkFY6KjIMg4MHD7LpqCVLlsSECRNgZWUFT0/PXGWK3717h0GDBkFPTw+mpqaYOnWqwt8pWaSmpsLQ0BDu7u5s18WCLP4kJSYmBo6OjrC3t2crUcbHx8PGxgZVqlTJt4rmxIkTQUQqFZH6N5GRkQEiwrp16yAWi7Fw4cLCXpLS6CoQ6ig00iQSWERF5RQDNjbsBTjXa8eOrH0WLpS/j6cnO5ZJnTqYNm0avn79+v9zpqXh6tWrmDdvHpo3bw4rKysQETgcDjw9PdGvXz9s375dbr72ly9fIBaLMWHChIL6mABk3Zw2bdoEQ0NDlChRQq1SsvnRpk2bIpUrLZFI4O3tjWrVqrE3/u7du8PIyAjx8fFandvCwgL9+vVD/fr1QUTg8XgYM2YMvnz5InN/TYmCBQsWgIhgbGysUsthTfL+/Xv4+vpCX18fmzdvRrly5VC8eHGF6ikwDIMRI0aAiLBmzZoCWG3hYWZmhlmzZsHW1hZTp04t7OUojU4M6ChUIl69ympSpMEXLzIS7lFR6NO3L0QiEcRiMYYMGSLzBs8wDJ48eYINGzYgLCyMfRIjIjg5OaFdu3ZYtmwZ7ty5w/YdGDp0KExNTQvle/7s2TP4+fmBx+Nh2rRpefZCUJVSpUpBKBRqfFx1OHXqFIgIhw4dwokTJ0BEWL16tdbn9fLyQqtWrWBpaYkyZcogLCwM+vr6MDAwwMCBA/Hy5UuZx7179w6DBw9WWhQwDIP58+eDy+VCT09P62JHUZKTk9meD3p6enj48KHCxzIMg/79+4PD4fynexW4ublh+PDhcHV1xahRowp7OUqjEwM6CpUMiQReN26Ar2ExcOfXLwBZddgnTpwIMzMz8Hg8dOrUCXfv3s1zTZ8+fcKBAwcwYsQIVKlSBQKBgH1Kq1+/PoYPHw4ej4fp06cXxEeUi/T0dEycOJGtkCfvhqQq+vr6KF68uEbHVBeGYVC7dm2ULl0ajo6OqFu3rlbcA39So0YNCAQCeHl5sdaAT58+YfLkybCwsACPx0P79u0RExMj8/g/RcGUKVPkioLsvQUMDAwwZMgQrZ2XsjAMg969e4PL5YKI0K5dO6UabUkkEoSFhYHL5WLPnj1aXGnhUa1aNYSGhqJixYro27dvYS9HaXRiQEeh8ygpCYYXL8ovTazka56M9qy/fv3CokWL4OzsDCJCcHAwIiMjFbqhJCcn48KFC5g5cyYaNmwIU1NT1npQqVIlDBkyBHv37tVIq1pliIqKQrFixWBsbIy//vpLI2MmJiaCiNC0aVONjKdJoqOj2TbRypTdVZW7d+9CJBJBJBLlcDVJSUpKwtKlS+Hi4sKWlD59+rTM75RUFIhEIpmiIHvL4Tlz5uSKkShs5s+fz/rE9+zZA319ffj6+irlSsrMzESHDh3A5/Nx5MgRLa62cGjatCkaNmyIgIAAdO7cubCXozQ6MaCjSHDl+3cYXrz4/+2MlX2dOweKjETf6Og8b/Dp6enYunUrypcvDyKCj48P9u7dq5S5XSKR4MiRIyAi+Pr6sjcDaaBZly5dsGbNGjx69EjrT6/fv39Hx44dQUTo2LGjWkFrALB//34QEebPn6+hFWoOqXvA3Nxc67Xv79y5AwsLCzg4OMDIyCjPfTMyMrBz5054e3uDiFCxYkVs374dGRkZufZ9//59DlEQHh6O6dOn5+gtMGrUKFhbW2vFBaQKBw4cAIfDwejRo9ltN2/ehL29PRwdHeVaRWSRkZGBli1bQigU4vTp09pYbqHRvXt3+Pr6Ijg4WG4viaKMTgzoKDI8SEpChehopWMI+JGRMLhwAfZhYXBzc0NiYmK+czEMgxMnTqBWrVogIri6umLVqlVK3WRat26N4sWLIyMjA2/fvsWuXbswaNAgeHt7s+ZUc3NzNGnSBLNnz8alS5eQmpqqzkckl23btsHY2BjFihVT64myd+/eIKJ8W/8WNNLsAX9/f3C5XCxYsEBrc0mFgLe3N9atWwciUtjff+bMGdSrVw9EhGLFimHx4sUyGwC9f/8effr0Yb8n1apVw6dPn8AwDNzc3NCjRw9tnJrS3Lx5EwYGBmjVqlWuBk/v3r1D5cqVYWBggH379ik8ZlpaGho2bAh9fX1cuHBB00suNEaPHo3ixYujTZs2CAoKKuzlKI1ODOgoUqRLJJgZHw/Tf7IM5FkKOP+8x42MRMj9+3idkoJnz57B3NwcQUFBMp/K5HH9+nW0atUKHA4H1tbWmDFjhkKCIiYmBkQk00T/8+dP/P333wgPD0dQUBDEYjGICEKhEP7+/hg9ejQOHz4sNypdFV6+fMneLCdOnKhSKppUyBS1fuxhYWEwMjLCq1ev0LNnT1hYWKhtBZHF7du3YW5ujkqVKiExMRFXrlwBEeHevXtKj9OxY0fweDyYm5tj4sSJOaLvpW4BExMTNG3aFCKRCCYmJujfvz+ICEePHtX0qSnN69evYWdnB19fX7nxAb9//2azT2bMmKGwJSwlJQV16tSBoaEhrl69qsllFxrz5s2DkZERwsLC4OfnV9jLURqdGNBRJEmVSLD1wwe0efAAzleu5BACRhcvovbt25j68iXe/PEkf/bsWfB4PAwePFjpOZ8+fYrevXtDT08PYrEYQ4cOxWsZ8QfZadCgAcqXL5/vRTAjIwO3bt3C4sWL0aZNG9jb27OuhTJlyqBnz57YtGkTnj17ppZrISMjA9OmTQOPx4Ofnx+ePXum1PGmpqawsbFReX5tcPz4cRAR1q5dCwB4+/YtRCKRxtM7pUKgcuXKrBh8+/atWjfn+Ph4DB48GAYGBhCJROjduzfGjh2bq+Xw+/fvMWTIEPD5fBARJkyYgG/fvmnq1JTm58+fqFChAooVK4aPHz/muS/DMJg8eTLrqlLUupaUlITq1avDxMQEt27d0sSyC5VNmzaBiNC/f3+ULVu2sJejNDoxoONfQUpmJr6kp+NHRka+N8tly5axwU6q8PHjR4wfPx6mpqbg8/kIDQ3F/fv3Ze574cIFEJHSAVEMw+Dly5fYunUr+vTpg3LlyrHiwMbGBiEhIVi4cCGio6NVesK/du0aSpQoAUNDQ2zatEkhgZGWlgYiQo0aNZSeT1t8+/YNDg4OqF+/fo5zGD16NAwMDPK9USlKTExMLiEAZAW98fl8rFixQq3xv379inHjxkEoFIKIUKpUKVy5ciXXfhUqVICbmxtrKQgPDy9wUZCRkYHg4GAYGxvL/d7LYufOnRCJRKhSpYrC/y4/fvyAj48PLCwslJqrKHLs2DEQEQYOHAhnZ+fCXo7S6MSAjv8c0jQogUCglv/858+fWLBgARwdHUFEaNSoES5cuJDjpsQwDKpVq4aqVauqHSyYmJiIY8eOYezYsQgMDGSrJRoYGKBWrVqYOHEiTp48qfDv6+fPn+jatSuICG3atMnX9SE1iY8ZM0at89Ak3bp1g7GxcS4LTWJiIkxNTdG/f3+154iJiYGZmRkqV64s88ZbrFgxjB07Vq05smcL9OvXD66uriAi1KxZE8eOHQPDMHj9+jXrdvrw4QOGDh3KioLJkycXmCgYMGAAeDweTp06pfSx0dHRsLOzg5OTE+7cuaPQMV+/foWnpydsbGzw5MkTpecsKly/fh1EhEGDBsHc3Lywl6M0OjGg4z9JWloaAgMDYWVlpXbhlvT0dGzZsoV9evfz88O+ffvYaG9pZsH58+c1sXQWabXEuXPnolmzZrC0tAQRgcvlwtPTE/3798eOHTvydWXs2rULpqamcHR0RGRkpNz9xo8fDyLCxYsXNXoeqiJ90pJn4YmIiACfz1faFZKdW7duwczMDD4+PnJvtgEBAejYsaNK40uLCP3pFsjMzMS+ffvg6+sLIkK5cuXQuXNnCASCHLEQBS0KFi9eDCLCqlWrVB7jzZs38PLyglgsxsGDBxU65tOnTyhTpgwcHR3x4sULlecuTJ4/fw4iwoABAyAQCAp7OUqjEwM6/rN8/vwZLi4u8PT0lBnRrSwMw+DYsWOoUaMGa+pds2YNkpOTUb58edSvX18Dq857/sePH2P9+vXo1q0bSpUqxboWnJ2d0b59eyxfvjxHtUQpr1+/Ro0aNcDhcDBmzBikpaXlGr9mzZogIq1lPCjDt2/fYG9vjwYNGsi1uCQnJ8Pe3h7t27dXaQ6pEPD19c3zBtuxY0cEBAQoPX72IkLyegswDIMLFy6gUaNGbHW/efPm5bqGFoQoOHLkCLhcLoYPH672WElJSQgJCQGHw8Hs2bMVspq9f/8erq6ucHFxwZs3b9ReQ0Hz8+dPEBH69OkDIpL5GyvK6MSAjv809+7dg1gsRkhIiEYj5K9du4aWLVuCw+HA1taWLdVa0IFQCQkJOHDgAIYPHy6zWuK0adMQGRmJ379/IzMzE7Nnzwafz0elSpXw+PHjHGPZ2dnBxMSkQNcvj65du8LY2Djfm8KaNWtARErlugNZKXOmpqbw9fXNNyth7NixKFasmFLjZ3cLKNJbIDExETwe+WgP/gAAQCpJREFUj/03NDExwZgxY3IV9fnw4QOGDRsGfX19GBsbY9KkSQplvuRHTEwMxGIxmjdvrrH6BhKJBBMmTAARITQ0VCGR+erVKxQrVgylSpUq8CJe6sIwDIRCIbp37w4i0mimUEGgEwM6/vMcOHAARITw8HCNj/3kyRP07NkTAoEAHA4HpUqVKtSnmt+/f+P8+fOYMWMGgoODYWJiAiICn8+Hr68vhg4dijlz5qBEiRIwMDDAmjVrwDAMGIYBj8eDl5dXoa1dytGjR0FEWL9+fb77ZmRkwN3dHQ0aNFB4/Bs3bsDU1BR+fn4KpSeuXLkSPB5PoZukPLdAfmzduhVEhHfv3uHNmzcYMWIEjIyMIBQK0aNHj1zCTZOi4O3bt7C3t0elSpU0YkH7k7/++gt6enrw9/dXqLnRs2fPYG9vj7Jly+bqDlnUcXBwYIuAFZW+EoqiEwM6/ieYPn06iAh79+7VyvgfPnxAgwYN2Btv165d8eDBA63MpQwSiQT37t3DypUr0bFjxxzVEo2NjUFE8PLywq5du0BE6NmzZ6GuNzExEfb29ggODlY4IHPv3r0gojzjIaRIhUCVKlUUrlMgFSf5ibyvX7+i6T+tt5VtOdyyZctcuenfvn3D7NmzYWdnBw6Hg2bNmuHy5cs59lFXFPz69QteXl5wcnLSapfKa9euwcbGBsWKFVOoZkNsbCysra3h5eWlEctHQeHp6YkWLVqAiP512RE6MaDjfwKGYdC2bVsYGBjg9u3bWpkjJSUFNjY28PX1hYODA4gIjRs3xsWLFwukqY6ivHnzBjt37sTAgQNRvHhxVhwQESpXroyIiAhcvny5UGIHunTpAhMTE6WsKwzDwNfXF76+vnl+ztHR0TAxMUGVKlWUukbdu3cPRCQzFVCKsm6B7CQnJ8PAwACzZs2S+X5qairWr1+P0qVLg4jg7++PQ4cO5XB7ffz4EcOHD1dKFGRmZqJJkyYwMjLKt3mXJnj16hU8PT1haGio0Gd07949mJubw8/PDz9//tT6+jRBUFAQW4Hy31ZMSScGdPzP8Pv3b1SqVAlOTk4ay0//kzlz5kAgEOD58+fYtGkTPDw8QESoWrUqDhw4UOQq+wFZrg6plcDR0ZGtlqinp4fq1atj9OjROHLkiMxmPZpE+gS+YcMGpY89d+4ciEhuWdzr16/DxMQEVatWVfr69P37dxARdu7cmes9Vd0C2Tl8+DCICLGxsXnuJ5FIcOjQIfj7+4OIULp0aaxbty6HaPtTFEycOFGuKBg8eDC4XC6OHz+u9JpV5devX2jevDk4HA7mzp2br0i+efMmjI2NERAQgN+/fxfQKlWnXbt2qFKlCogIf//9d2EvRyl0YkDH/xRv3ryBjY0N/P39tfLk+/PnT5iamrLtZyUSCY4ePYqAgAAQEdzd3bF27doiEbGfnRIlSkAgEEAoFKJChQrYvXs3Fi9ejNatW8POzo61HHh4eKBnz57YvHkznj9/rjGLR2JiIuzs7NCwYUOVx6xfvz7c3d1zlaK+fv06jI2NUa1aNZWvTcbGxpgzZ06Obeq4BbITFhaG0qVLK3XM5cuX2ZuqnZ0dZs+enSO7QJYoyC7mpIW5li1bptKa1UEikWDs2LEgInTr1i3f38Lly5chFosRFBSk9QZV6jJw4ECUKVMGRIT9+/cX9nKUQicGdPzPcfXqVQiFQoSFhWnFfD9hwgQYGBjkCn66cuUKWrRowWYgzJ49Wyv19VVBT08PpUqVwu3bt1GmTBmIRCIsX76cDS588eIFtmzZgt69e6Ns2bKsOLC1tUWrVq2wcOFC3LhxQ6meENkJDQ2FiYkJ3r59q/I5SHtFSMsWA1m+aqkQUMfUXK5cOQwYMID9Wx23QHYyMjJgaWmpcqGn2NhY9OjRA0KhEEZGRhg+fHgOF4ssUbBr1y5wuVyVSnZrki1btkAoFCIgIACfPn3Kc9/IyEiIRCI0atSoSKfsTZkyBTY2NiAibNmypbCXoxQ6MaDjfxJpHfFFixZpfOzPnz/DwMAAkyZNkvn+48ePc1zAR44cqdZNUF2+fPkCIkKrVq0AZLlTpA1zGjVqJDMC/OvXrzh69CjGjh2LgIAA6OnpsdUSa9eujYkTJ+LUqVMKXQukZvKNGzeqfS7t2rWDg4MDkpOTWSHg7++vts85ODgYTZs2zeUWUDdiXFrO+tq1a2qN8/79e4wdOxYmJibg8/no0qVLjgC2jx8/YsSIEWxVSzc3t3xvwAXB5cuXYW1tDRcXl3wD7k6ePAmhUIiQkBCVRae2WbFiBXg8Hvh8PpYvX17Yy1EKnRjQ8T/L8OHDweVyVSq7mh+DBw+GmZlZnjeh9+/fY/To0TA2NoZAIEC3bt0KpXXw9u3bQUS56u8fOXIEVlZWsLa2ztevnJqaiitXrmDOnDlo1qwZLCws2GqJFStWxIABA7Bjx45cgYFS90CjRo00YqWJi4sDn89H//79NSYEgKzWzuXLl9eIWyA7Q4cOhb29vcZiSX7+/In58+ezJbQbNmyI8+fPg2EYvH//Hvb29rC2toa+vj6MjIwwYcIErceC5Ed8fDzKly8PIyMjHDt2LM99Dx06BD6fj44dO2qsHoIm2b17N4gIJiYmiIiIKOzlKIVODOj4nyUzMxMNGjSAqampxmuiv379GgKBAPPmzct33x8/fmDu3LlsJ8OmTZvi0qVLGl1PXnTr1k1uXvTHjx8RHBzMNmBR1GcrrZa4bt06dOvWDW5ubjmqJXbo0AHLly9H48aNYWxsrFHLSMuWLUFEqFKlisai0Hv37g0ul6u2WyA7DMPAxcUFffv21ch42UlLS8tRQrtSpUooUaIEHBwc8PbtWyQkJGDEiBFFRhT8/PkTTZs2BZfLxYIFC/IUhlI3R48ePYpcQK40kNXOzk7jXTW1jU4M6Pif5tu3b3B3d4e7u7vGy7t269YNdnZ2CgcLpqWlYcOGDWwAUrVq1XKlkGmDChUqgM/ny70AMwyDJUuWQE9PD+XKlVMoT1wWHz9+xP79+zFs2DD4+fmBx+OBiKCvr48GDRpg+vTpbLVEVbly5QoMDQ3B5XIxdOhQlceRInULSNeqScvNnTt3QERasUxJYRgGR44cYftaODk5YeXKlUhOTgaQVcFy5MiRMDAwKHRRkJmZiVGjRoGI0KNHjzxjAzZv3swK1KKUtnv//n0QEVxcXNgg4n8LOjGg43+ep0+fwtTUFA0aNNCo6fHx48fgcDhYvXq1UsdJJBIcPnw4RwrZ+vXrtZaBYGxsDAcHh3z3u3//PsqXLw89PT0sWrRILZHy9etX2NjYoEqVKpg2bZrMaonDhg3Dvn37FE4DvXz5MoyMjBAQEIBRo0ZBX18f7969U2uNUrdAu3btFEr/U4bw8HCYmJhoPSBO6g6bP38+WrduDS6XCysrK0ybNo298f8pCsaPH19oomDjxo0QCASoUaNGnhUIV61aBSLCqFGjiowg+PDhAxuT0b1798JejlLoxIAOHQBOnz6tsSYt2QkJCUHJkiVVDni6dOkSmjVrBiKCvb095syZo9EMhNTUVBARgoKCFNo/JSUFQ4YMARGhfv36Klet69SpE0xNTXPcrDMzM3H37l2sWLECHTp0QLFixVjXgqurK7p27Yp169YhNjY218X/8uXLMDQ0RGBgIH79+oXv37/DwsICvXr1Uml9f2YLvHz5UuNP8Z6enujQoYPGxpOF9Ia5ePFidltcXBz69u0LkUgEsViMQYMG4eXLlwBki4LCqLEfFRUFS0tLlChRAg8fPpS738KFC7VWalwV0tPTQUQoU6YM2rZtW9jLUQqdGNCh4x8WLVoEIsKmTZs0NubNmzdBRNixY4da4zx69AhhYWEQCAQwNjbGqFGjNFI+VurjVPZievLkSdja2sLS0hKHDh1S6thDhw6BiLB58+Z895VWSxwwYAC8vLzA5XJBRLC0tETTpk0xZ84crFy5EmKxmBUCUqTmfWXiQeRlC6Snp4PD4eRIW1SHFy9egIiwe/dujYwni5MnT4LH4+VIicxOQkICJk2aBHNzc/B4PHTo0IGtzlkURMGLFy9Qrlw5GBsb48SJE3L3mzlzJoioyATsmZqawsPDAw0bNizspSiFTgzo0PEPDMOge/fuEAqFeZaeVZZ69erB09NTI6bMd+/eYdSoUTA2NmY7pKljuh4xYgSICDdu3FD62E+fPrFm9D59+ijk6//69StsbW3RuHFjlT6PHz9+4PTp05g0aRJq167NpspxOBxUrVoVY8aMwdGjR5GYmIiUlBQ4OTmhdevWCo2dXxEhe3t7uemiyrJw4ULo6elprczu/fv3YWRkhODg4HytUklJSViyZAlrialXrx7OnDkDhmGQkJCAUaNGwcDAAIaGhhg3blyBioIfP36gUaNG4HK5WLx4sdzvzMSJE0FEWLJkSYGtTR5ubm4oU6YMAgMDC3spSqETAzp0ZCM1NRX+/v6wsbHRWPfByMhIEFG+aVPK8P37d0RERLBNbJo3b66SgKlevTo4HI7KsRIMw2DVqlXQ19dH6dKl820l3LFjx1zuAVWJioqCgYEBvL29ERERgVatWsHW1pZ1LZQtWxY1atQAEeHAgQN5ig9FighVqVIFXbt2VXvdABAYGIhGjRppZKw/+fDhA5ydnVGhQgWlxEZGRga2b98OLy8vtoHVjh07kJGRgU+fPhWaKMjMzMTw4cNBROjVq5fMlE6GYdh91qxZUyDrkkfVqlVRqlSpItEBVBl0YkCHjj9ISEiAk5MTvL29NVIPnWEYVKlSBdWrV9fA6nKSmpqKdevWwd3dHUSE6tWr48iRIwoH91lbW8Pc3FztdTx69AgVK1aEQCDA3LlzZc5/8OBBjVVmu3jxIsRiMWrVqpWj7S7DMHj+/Dm2bNmCXr165aiWaGdnh9atW2PRokW4efMmMjIylCoi1KZNG9SuXVvttX/69AlcLldjLofs/P79G76+vrCzs8Pr169VGoNhGPz999+oW7cuGxm/dOlSJCUlFaooWL9+PQQCAWrVqiUzuJFhGPTr1w8cDgdbt24tkDXJomnTpihRogTc3NwKbQ2qoBMDOnTI4Pbt2zAwMEDbtm01Yt6X+skvXryogdXlRiKR4ODBg6hatSrbQ2Djxo15RqozDAMulwtfX1+NrCE1NRUjR44EEaFOnTo5agd8+fIFNjY2aNKkidqf54ULF1ghoIhY27p1K4gIbdu2RfXq1dlqiWKxmE25a9WqVb7R8yNGjICrq6taaweADRs2gMPhaLxZlkQiQUhICAwMDHDz5k2NjBkTE4P27duDx+PBwsICkyZNwqdPn/Dp0yeMHj0aYrG4QEXBhQsXYGFhAVdXV5nuMYlEgrCwMHC5XOzZs0fr65FFWFgYHBwcYGtrWyjzq4pODOjQIYe9e/eCiDB9+nS1x5JIJChbtiyCg4M1sLK8iYqKQpMmTUBEcHBwwLx582T+Jh89esTmamuSM2fOwN7eHubm5mwXwQ4dOsDMzEztoEepEKhdu7bCVhuGYVCtWjVUqlQJEokEqampWL16NUxNTSEQCGBkZMRWS/Ty8sKAAQOwc+fOXG4iaa0Fdes+NGnSRCtWotGjR4PD4eDgwYMaH/vly5cYNGgQDAwMIBKJ0K9fPzx79iyXKBg7dmye6YCa4Pnz5/Dw8ICJiQlOnz6d6/3MzEy0b98efD4fR44c0epaZDFq1ChYWFjA0NCwwOdWB50Y0KEjD8LDw1mfs7pIn1ClEdva5uHDh+jatSsEAgFMTEwwZswYfPjwgX0/IiJC47EMUr58+cJWAqxTpw6ISG3T7YULF2BgYIA6deoo7b65ePEi24ZY6hbw8/NDfHw8GIZBbGws1q5di65du8LV1ZV1LRQrVgwdO3bEihUr2GwTdZ7of/36BT09PYUqUyrD2rVrQUSYP3++Rsf9ky9fvmDq1KmwtLQEl8tF69atcePGjQIXBd+/f0dwcDB4PJ7Mzovp6elo0aIFhEKhTMGgTebOncsGtha1Col5oRMDOnTkgdT0KhaLVa68JyUjIwMuLi4Fnn/85s0bjBgxAkZGRhAKhejZsyeePHmCRo0agYjYanSahmEYLF68GBwOB2KxGNevX1d5rPPnz6ssBKTUrVsXYrEYRIThw4fn6UL5+PEj9u3bh2HDhsHX1xd8Pp8VCNWqVcP06dNx/vx5pdeyb98+EBGePXum0jnI4syZM+Dz+ejTp0+BFd9JTk7GypUrUbJkSRARatWqhRMnTiAhIaHAREFmZiZb86Jfv365AgvT0tLQsGFD6Ovr48KFC1pZgyw2btzIfleyp7oWdXRiQIeOfEhKSoKnpydcXFzU7vS2YsUKcLlcxMXFaWh1ivPt2zfMmjULNjY24HA40NfXh76+vlbnbN++PUxMTODp6Qk+n4+ZM2cqnbkQGRkJAwMDBAUFqSwErl69Cjs7OxCRSr0Afv/+zQZAenl5wdjYmK2W6Ofnh+HDh2P//v0yOzxmp3PnzihfvrxK5yCLhw8fwsTEBPXr1y+UTn6ZmZnYs2cPfHx8QEQoX748tmzZgvfv32PMmDEQi8UQi8UYM2aM1kTBmjVrwOfzUadOHSQmJuZ4Lzk5GbVr14ahoSGuXr2qlfn/5OjRo6wY0EQtkIJCJwZ06FCA+Ph4WFlZITAwUK3ysSkpKbCxsUHPnj01uDrl1yA1KxMRAgMDcfToUY0/Ve7fvx9EhG3btiE9PR3jxo0Dh8NBYGAgXr16pdAY2YWAKhaM7NkCfn5+aNGiBWxtbXNkICgzlr6+PhYuXMhWS1y+fDk6dOgAZ2dn9vN0c3NDt27dsG7dOjx+/Jj9XNPT02FqaoqJEycqPbcsEhIS4OLignLlyhX6NZdhGERGRqJhw4ZsD4QFCxbg5cuXBSIKIiMjYW5ujlKlSuUqMpWUlITq1avDxMQEt27d0vjcf3Lt2jX2u/D06VOtz6cpdGJAhw4FiYqKgkAgQO/evdW6cc6ePRtCoVCjnfqUJSEhgRUCfn5+ICKUK1cOmzdv1kit/M+fP8Pa2hrNmjXL8VlduHABTk5OMDExwc6dO/Mc49y5c9DX10fdunVVEgLZiwhJ3QIvXryAQCDAjBkzlB4PANzd3eU2QHr9+jV27NiB/v37o2LFijmqJTZr1gy9evUCEeHatWsqzZ2d5ORkVKlSBTY2NnmmQxYG9+7dQ2hoKPh8PkxNTTFu3Dg8ePBA66IgLi4OpUuXhqmpKc6cOZPjvR8/fsDHxwcWFha4f/++Ruf9k+fPn7NioCDEh6bQiQEdOpRg3bp1ICIsX75c5TF+/PgBExMTDBs2TIMrUw6pX3PDhg1gGAYXLlxgYwgcHR2xYMECtarjtWvXDubm5jkCFqUkJiaibdu2ICKEhobKvF6cPXsW+vr6qFevnkpCIK8iQoMGDYKxsbFKqXB169ZFSEiIQvv++PEDp06dwsSJE1G7dm027kAkEiEgIABjx45lqyUqg0QiQZs2baCvr69WHIa2ef36NYYPHw5DQ0M2VuXq1asYO3YsDA0NtSIKvn37hnr16oHH42HlypU53vv69Ss8PT1hY2Oj8Zbl2ZHeB4moQGMV1EUnBnToUJLBgweDx+Ph7NmzKo8xbtw4iMXiQmkCA2RVAiSiXD7u+/fvo0uXLjme6pSNnpcGyf31119y92EYBlu2bIGRkRFKlCiRo3rimTNnoK+vj/r16ystBP50C8h6ak5ISIChoSFGjBih1NhAVg65KnUZGIaBg4MD2rZti4ULFyIkJCRXtcTevXtj69atePHiRZ6Wp/Hjx4OIsHfvXqXXURj8GavSokULnDhxIocoGD16tNrxOFIyMjIwcOBAEBEGDBiQI5bi06dPKFOmDBwdHfHixQuNzPcnDMNAKBRqLVNHW+jEgA4dSpKRkYG6devC3Nxc5ajwhIQEiESiQuu25uHhAaFQKPf9169fY9iwYTA0NISenh569+6tkP9T6h5o3ry5Qq6U58+fo2rVquDxeJgyZQpOnToFkUiE+vXrIyUlRalzkuUWkEd4eDj09PSUrtIXHh6uUjGZGzdugIhw7tw5dhvDMHj27Bk2b96Mnj17wsPDgxUH9vb2aN26NRYvXsxWSwT+36JTVJryKIM0VqVUqVJstcxt27ZhzJgxWhEFK1euBI/HQ7169fDt2zd2+/v37+Hq6goXFxeNlRz/E2mwan6usKKETgzo0KECiYmJcHNzg4eHh8rf94EDB8Lc3LxQ0o8MDQ1RrFixfPdLTEzEjBkzYG1tDQ6Hg5CQEERHR8vdv23btnLdA/LIyMjA5MmTweFwwOVyUaNGDaWFgCK9BbLz8+dPWFlZISwsTKl5NmzYACJCamqqUseNHz8e5ubm+Ub8f/nyBUeOHMHo0aPh7+/PPmGKxWJ4e3uDy+UiODj4X32N/bNaZpkyZbBkyRKMGjVK46LgzJkzMDMzg7u7e44MnlevXqFYsWIoVaqUUt9VRfH09AQRYd26dRofW1voxIAOHSoSGxsLY2NjNG7cWKVGP69evQKfz8eCBQu0sDr5JCcng4iUarGakpKC1atXswV5atasiePHj+d4+pdWbNy+fbvSazp9+jSEQiH09fVhaGiIrVu3KmRZUMQtII8lS5aAy+Xi4cOHCh9z5swZleoEeHh4oEuXLkodA2R97pcuXcKIESMgEAggEAjYaone3t4YOHAgdu3aVajBqOpw6dIl1ppjZ2eHSZMmsXEGYrEYo0aNUlsUPHnyBKVKlYKZmVkOy8yzZ89gb2+PsmXLajyYsU6dOuDxeFi4cKFGx9UmOjGgQ4caHD9+HFwuF2PGjFHp+C5dusDBwUHpJ011OHHiBIgIs2fPVvrYzMxM7N27N0de+datW/Hu3TtYWVmhRYsWSmdaSF0DDRs2REJCAjp37gwiQvv27XOYd/9EGbeALFJTU+Hi4oLmzZsrfMzTp09zmfvz48mTJ2pVsfz8+TNKliwJDw8PfP36FY8ePcLatWvRpUuXHNUSXVxc0LFjR6xcuRL379//V1W/e/ToEds+3MjICAMGDMDAgQNhaGgIAwMDtUVBYmIigoKCwOfzsXr1anZ7bGwsrK2t4eXlpXQgZ160bdsWAoEA06ZN09iY2kYnBnToUJN58+ax+fTK8ujRI3A4HK10sJPHoEGDQER49OiRymMwDIPz588jODgYRAR9fX2IxWI8f/5cqXFOnToFPT09NGzYMIcg2r59O0xMTODs7CyzuZOybgF5SEtEK1qQRmpV2bRpk8JzzJkzB/r6+ioVTEpJSYG/vz+srKzkBrx9+PABe/fuxdChQ+Hj48NmLZiamqJhw4aYMWMGLly4oLVKk5rk3bt3GD16NIyNjSEQCNC+fXv06tVLI6IgPT0d/fr1AxFh8ODBrMvm7t27MDc3h5+fn1oZNNkZMGAAhEIhRo0apZHxCgKdGNChQ00YhkFoaCj09PTy9KfLo0WLFnBzc1PJ1aAKfn5+4HK5GisyJBVDXC4XZmZmmDBhQr6V+ID/FwKNGjWSaRmJj49HQEAAuFwuJkyYgPT0dLXcArKQSCSoUKECatSoofDnYWVlpdQTX9WqVZWyPkhhGAYdOnSAnp6eUtXzkpKScO7cOUybNg3169dnqyUKBAJUqVIFw4cPx4EDBzQWqKcNfvz4gXnz5sHBwQFEhHr16qFz586sKBg5cqRC3zFZLFu2DDweDw0aNMD3798BADdv3oSxsTECAwM10rY8PDwcfD4f/fr1U3usgkInBnTo0AApKSmoUqUK7Ozs8O7dO6WOjY6OBhFh165dWlpdTiwsLGBtba2RsT59+gQrKyu0bNkS8fHxGDJkCMRiMUQiEfr27SvXt37y5Eno6emhcePGebpIMjMzMX36dPB4PHh7e7NNj1RxC8jj2LFjICIcP35cof0rVaqkcAXJ9+/fg8PhKGVJkDJp0iSNfC8yMzNx584dLFu2DO3bt4eTkxPrWihVqhTCwsKwfv16PHnypMB6GyhKWloaNm3ahLJly4KIUKlSJYSEhKgtCk6fPg0TExOUKVOG/Y5evnwZYrEY/9fefYdHWWZtAL/fqekxmZCARIEAhiZIKAv4iQQpSjGEGoSAFBcVBBvYuFhAFmFZBQOouCoovSihRES6+gmsoIRiAiiI8pFKljQISWbu749xZkkyNR1yftf1XkDeOgFyzvuU8/Tu3dvtAaylLV++nIqicPTo0RW6TnWSZECISpKSksLQ0FB26tTJ7SbZRx55hA888ECV/zA2Go1UFIUPPvhgpVxv2LBhNBgMJWoRXL16lfPmzWO9evVKrGxnsWvXLpcSgVt99NFH1ubvqVOnVur3yWQysXv37mzXrp1L/ezR0dHs27evS9desWIF1Wq12/UkPvvsMwIod6VEZy5dusR169Zx8uTJbNeuHRVFIQDWq1ePgwYN4qJFi3j48OFKS7gqymg0cufOnXz44YcJgGFhYXzsscfo6+tb7qQgKSmJzZo1o8Fg4MGDB0mayxp7eHhwwIABFfrsGzduJAD279+/3NeobpIMCFGJjh07Rk9PT44aNcqtgLVv3z4C4K5du6rw6ciffvqJAMpVcKe0TZs2OZxLXXplu549e3LevHnU6/UcOHCgS4nArd0CHTt25PDhwwmAQ4cO5dWrVyv8GSy+//57l8d9TJs2jS1btnTpuo8++igjIyPdepZDhw5Rq9XyySefrLY39WvXrvGrr77izJkzGRkZSU9PT2u1xO7du/O1115jQkJCpQ6yK68jR45wyJAhVBSFQUFB7NGjR7lbCq5evcrIyEhqtVrrNMCvvvqKOp2OQ4cOLffiT/v377eucHm7kGRAiEq2YcMGt0frm0wmdu7cmd27d6/CJyPnzJlDADxw4ECFrpOWlsagoCAOGTLEacAqLi7mpk2brCPf/fz8uGrVKqc/aO3NFti8eTMDAgLYsGFDt0b1OxMVFcUmTZo4fSN8++236e3t7fRzZ2dnU6vV8t1333X5Gc6dO8fAwEBGRkbW6Ft5YWEh//3vf/Odd97hkCFDGBISQgBUFIVt2rTh008/zdWrV/PixYs11rVw7tw5Tpo0iXq9nl5eXuzcubM1KXj55ZddTgoKCws5adIkAuCLL77I4uJixsfHU6PRcPTo0eUay3Py5ElrZcnbhSQDQlSBN954g4qicMeOHS6fs3XrVgLgd999V2XP1bt3bwIos/a7u4YOHVqme8CRhIQE6nQ6duvWzfoMjRo14rvvvmtzBcEjR46wUaNGDAgI4LZt28rs/+OPPxgZGUlFUThjxoxKCZxnzpyhSqXi0qVLHR5naRFx1jJhSQpdHeSYmZnJ5s2bMzw8vFa8gd/KUi1x1apVfOqpp9iyZcsS1RKHDx/OuLg4Hj9+vNqXUk5NTeXMmTMZEBBAlUrFNm3a0Nvb262kwGQyWetO9OvXj9nZ2dywYQNVKhUnTpzodsKTkpJCALz33nvL+7GqnSQDQlQBo9HIqKgo+vr68vTp0y6f06pVqyrtZwwNDaWfn1+FrmHpD3W11OrOnTup0+kYFRVlDdonTpzgqFGjqFarGRgYyFmzZjE9Pd2t2QLFxcVcuHAhtVotIyIimJSUVKHPRZLjxo1jcHCww6qQliVqT5w44fBaMTExjIiIcOm+BQUF7N69O4OCgspd4rq6ZWZmcvv27ZwxY0aJaok+Pj7s1asXZ8+ezT179lRbhc3c3FwuWbLEupx0WFgYvby83EoKdu3aRT8/P7Zu3ZoXLlzgqlWrCIDPPfecWwlBYWEhAdBgMFTkI1UrSQaEqCI5OTls06YNw8LCXB5A9umnnxIAExMTq+SZtFot27VrV+7z3ekeIMkdO3ZQp9Nx0KBBNt/ef/vtN06dOpVeXl7U6/Vs3Lix27MFjh07xvDwcHp6enLFihUVarb+/fffqdfrOWfOHLvHXLlyhQAc1jcoKCigr68v586d6/SeJpOJsbGx1Ol0VdoqVNUs1RIXLFjAgQMHMjAwkACsM0GmTp3KTZs2uT3bxl2FhYVcu3attSRwgwYN6OnpSU9PT7700ktOW7N+/vlnhoWFMSgoiN9++y0/+OADAuCMGTPc+rfl4eFBT0/Pin6caiPJgBBV6MKFCwwKCmLPnj1dapovLCxko0aNOHLkyEp/lsuXLxOA2/X4LUwmE4cMGcKgoCCX3rJ27NhBrVbL6Ohop4F99+7dvOuuu6goChVF4YgRI9xaCz4vL8/a7xsVFVWh8rKWcrj25uEbjUZqtVouW7bM7jUsVR5Pnjzp9H5z584tdxnn2sxoNPLMmTP88MMPOWbMGOtAUgBs0qQJR48ezQ8++KDKqiWaTCbu3r3bOh31rrvusgZoZ0lBZmYmH374YWq1Wq5cuZKLFy8mALcWFrPMprldSDIgRBU7ePAgNRoNp0yZ4tLxy5Yto0qlqvTm4vfff58AuH79+nKdb+kDd2Xe+/bt262JgKMkqHS3QFJSEpcvX84mTZoQAHv16sWvv/7a5Tey+Ph4GgwG1q9fn7t373b5s90qMzOTfn5+nDZtmt1jwsLCHFaXmzRpEps2ber0udetW0cALrUg3Aks1RKff/55durUiWq1ukS1xPnz5/Obb76p9GqJx48fZ0xMDBVFoaenJ/V6vdOk4ObNm5w4cSIBcPr06Zw3b57rK0YWFPDx0FA+ArBw1y4yMZGs4DidqibJgBDVwNLUeGtddHuuX7/O4OBgTpo0qVKfwTItz1J1zR2pqak0GAwcOnSo02O3bdtGrVbLwYMHO0wEHK0tUFRUxA0bNjAiIoIA2L59e65fv96lwWlXrlxhnz59CIAvvPBCuQrIzJs3jzqdjhcvXrS5v0ePHoyJibG5z2g0sn79+nzppZcc3uO7776jTqdjbGxsrSv2U13y8vK4b98+zp07l3369KGvr6+1WmLXrl358ssvMz4+vtKqJV64cIFTpkyhh4cHNRoNdTodPTw87CYFJpOJixcvpkql4sCBAzl9+nQCYFxcXNmLZ2WR77xDPvAAqdGQQMlNqyU7dSLff5+spLLHlUmSASGqyeTJk6nRaKwFThyZP38+dTodr1y5Umn3Dw8Pp4eHh9vnmUwmDh482KXugfj4eGq1Wg4ZMsRhIuBstsCt9967d681uDdu3JhLly61OQPhVkajkYsXL6ZOp2Pbtm1dHsRpkZeXx/r163PMmDE298fGxtot3GSpWfDtt9/avf4vv/zCoKAgdu/evVoXqartiouL+dNPP3HZsmWMiYlhaGiotWshPDyc48eP5yeffMJz585VKIHKyMjgnDlzrOMatFot9Xo9X3zxRZtLGickJNDX15dt2rThU089RQD/XU/k5k1y9mxSrycVxbyVTgQsm2W/l5c5caimEuSukGRAiGpSWFjIyMhIGgwGu4vOWFy7do1+fn6VUhzIwsvLi02bNnX7vPXr1xMAN23a5PA4SyIwdOhQu4lARdYW+Omnnzhy5Eiq1WoaDAb+7W9/czo2IDExka1ataKHhweXLl3qVgB57733qCiKzX7/N954g/fcc4/N82bMmMHg4GC789OzsrIYHh7O5s2bu12ZsC66dOkS165dy2effZZt27YtUS0xOjqa//znP3nkyJFyTS/Nz8/n8uXL2ahRI+tgR71ezxdeeKFMUnD69Gk2adLEWn5bURTGL1pEtm7tOAFwtHXpQtaS5aclGRCiGmVmZrJp06a8//77na6Q9uqrr9LHx6dS5pzn5+cTAKOjo906z9I9MGzYMIfHWRKBYcOG2U0EKrrksMWFCxf43HPPWUeIT5kyxWFydf36dU6ZMoUA2K9fP5drIxQWFrJZs2YcMGBAmX0rVqygSqUq021hMpnYvHlzTpw40eY1b968ycjISAYGBvLcuXMuPYco6dq1a9y1axdnzpzJHj16lKiW+PDDD/P111/nl19+6XD569KKioq4ceNG6wwElUpFnU7H559/vkRSkJGRwYceeoharZaxERHMBGhUqcqXCADm7oTQULKCC25VBkkGhKhmp0+fpq+vLwcNGuRwFHVqaio9PDwqZXDZF198QQBuVcMzmUyMjo5mvXr1HPbZbt26lRqNxmEi4Gq3gDsyMjI4e/ZsGgwGqlQqxsTE8Mcff7R7fEJCAoODgxkcHMyEhASX7mEZNFm6yd8yW+DSpUslvn7mzBkC4M6dO8tcy2Qycdy4cdRqtTx06JBL9xfOFRYW8ujRo3z77bc5ePBgBgcHW6sl3n///XzmmWe4Zs0a/vbbb05bhkwmE/fv32+dgaAoCrVaLSdPnmxNCm7evMmpI0cyFWBReZOA0glB06akk66vqibJgBA1YMeOHVQUhTNnznR43LPPPkuDweC0j9yZp59+mgDsDoizxTLSffPmzXaP+eKLLxwmApW95LAt+fn5XLZsmbVGQe/evblnzx6bP/hTU1PZr18/AuCUKVOcjlo3Go1s3749u3XrVuJ6lqBfOkn4+9//Th8fH5uDFufPn08AXL16dTk/qXCFyWTi+fPnuXLlSk6cOJEtWrSwjjto2LAhR4wYwbi4OP74448OSw0nJiZy+PDh1m4JjUbDSZMmMSUlhaZhw+y2CJwGOBRgE4CeAA0AHwK43VFCoFKRzz1Xjd+lsiQZEKKGLFiwgM4q+V28eJFqtZpLliyp0L06dOhAjUbj8vEpKSkMDAzk8OHD7R7z+eefU6PRcPjw4TZH+VdWt4CrioqKuH79erZv354AGBERwQ0bNthsyl+2bBk9PDzYqlUrp5UEd+/eTUuRoYybN7ns8mXGJCYSn31Gr3376P/NN2z0/fcceuoUG778MvvZqONgqdo4a9asSv3MwjUZGRnctm0bZ8yYwW7dupWolti7d2/Onj2be/futVkt8dKlS3zmmWeo1WoJgP2ddAskAOwLcDbADwEu+TMZAMAVzloJ/v3vGvjumEkyIEQNMZlMHDVqFD09PR0W2ImNjWVoaGiFgmlAQAAbNGjg8nMNGjTIYffAli1bqNFoOGLECJuJQFV0C7jKZDLx66+/Zq9evWgpS7t8+XLm5+eXOO706dNs27YtdTod33nnHbtdNiaTiV2jo+m/YAG1Bw9SOXCAmoMHiQMHSmyqAweIvXuJ/fvZLzGRx/8cE3L48GHq9Xo+8cQTdXYKYW1z48YNfvvtt3zrrbc4YMAABgQEWAcQdujQgdOmTStTLTErK4szZ87kfpXK7e6BYoDtAIY76y4YNarGvieSDAhRg65fv85OnToxNDTU5pQm0hy0APDjjz8u1z2MRiMVRXF5Kd21a9cSALds2WJz/5YtW6hWqxkTE2PzrbuquwXcYSk2o1KpGBQUxDlz5pQYwV9QUMAXXnjB2r1QulSuyWTiB//3f9QfOEDs2VMmAbC3qf9MDiYfP86g+vX54IMPlqvegagelmqJK1as4JgxYxgWFmbtWmjSpAljY2P5wQcf8NyXX5Z7bMAAgCGujB+ooRkmkgwIUcMuX77MBg0asEuXLnbnnEdFRfG+++4r13Kqlnnvb7zxhtNjLd0DI0aMsLl/8+bNVKvVHDlyZJlEoLq7Bdzx66+/cvLkyfT09KSXlxenTp1aYvzE7t27Wb9+fRoMBm7dupUkaTSZ+FRysssJgM1t3z56LF/Oiy7OYBC1x5UrV7h582ZOmzaNHTt2pFqt5gSAJheDfx7ADIC/AHwHoBrgE66cW80taRaSDAhRCxw9epR6vZ5jx4612ZRsWSnP0WA+e15//XUC4JEjRxweZzKZGBUVxeDgYJvz9zdt2kS1Ws0nnniiTCJQk90C7khPT+esWbMYGBho/SyWMQMZGRmMiooiAP71r3/lM2fOVCwRuKX7oNeJEyyqgvr7ovrk5ubyj4EDWeziVMJJf7YsAKAK5kGFWa60DNTQuBJJBoSoJdasWUMAfPvtt23uj4yMZEREhNv9zj169KCiKE4Xg7Hc//PPPy+zb+PGjTYTgdrWLeCqvLw8xsXFWYvN9O3bl/v27aPRaOSKFSuo69HDfoDv29f6Q97mtmlTmXOUAwf41m3yvREO9OzpcrdAEsA9AD8F2B9gNMBUZ+ep1WQVLFLmClfjt0KScCInJwf+/v7Izs6Gn5+fs8OFEKW8+uqrWLRoEXbu3InHHnusxL49e/agT58+2L17N/r06ePyNe+++24UFBQgKyvL7jEpKSlo3bo1+vbti/Xr15fYt3HjRowaNQoxMTH49NNPoVarAQBZWVkYN24ctm/fjpdeegnz58+HTqdz49PWvOLiYmzatAn/+Mc/kJiYiI4dO+LZV17BS/Xq4T9GI6BSlT3pzBngypWSXyOBxYuBkBBg1Sqb99IoCk527IiW3t6V/0GEW4qKipCXl2fd8vPzS/zZ1nbt2jW8npCAVteuleuefQBcA3AUgGLvIEUBBg8Gtmwp1z0qwtX4LcmAENXAaDRi0KBB+Oabb3D06FG0aNHCuo8kOnfuDB8fHxw4cMDla2o0GrRv3x4//PCDzf0kMWjQIBw5cgRnzpxBUFCQdZ8lERg5ciRWrVplTQSOHj2KESNGICcnB6tWrcLjjz9ezk9cO5DEnj17sHDhQuwPDgaeesp2ImDPqVPA1KnAhAnA6NE2D9EAGBUSglUtW1bOQ9cBJHHjxo0ygdmV4O1oKywsdHpvtVoNlUoFkjCZTDCZTPgaQC84COYOfAhgEoBkAOH2bwrExABr1pTjDhXjavzWVOMzCVFnqdVqrF27Fl27dsXjjz+Oo0ePIiAgAACgKApee+01DBkyBIcPH0bXrl2dXu/ixYswGo3o2LGj3WPWrl2L7du344svviiRCGzYsAGjRo3CqFGjsHLlSqjVapDEkiVLMGPGDHTo0AGHDh1Co0aNKv7Ba5iiKOjTpw969e6Nht98g1STyb0L7N1rfqvr1cvuIcUA1qWn4+1mzWDQaiv2wLVQcXGxzSBd0cDt7D1Uo9HAx8cHPj4+8Pb2hpeXF7RaLTQaDRRFgUajga+vLzw8PODj44Pr168jPz8fOTk5uHnzZolrqdVq1KtXD/Xr10dISEiJrX79+gjfsgXcuRNKcbHb358bf/6a7ezAWp4sSjIgRDXx8/PD9u3b0alTJ4wYMQJffvklNBrzf8FBgwahRYsWeOutt7B9+3an19q2bRsA4NFHH7W5PyUlBVOnTsXIkSMRHR1t/bolERg9ejQ++eQTqNXqO6JbwJkTeXlIJc2B3VXFxcDBg0Dr1kD9+g4PLSLx5dWriHVyXFUiiZs3b9oMvBUJ3AUFBU7v7enpaQ3cpbegoCCbX/f29oZKpUJhYSEKCgpw/fp15ObmIicnB//5z3+QmZmJtLQ0pKWl4dKlS2WeQ6PRWAN6o0aNygT5W4N9YGAgVI5ahIqLgfh4h58xHUBwqa8VAfgMgCeAVo5ONhqBDh0cXr+mSTIgRDVq2rQptmzZgj59+mD69OlYvHgxAEClUuGVV17BuHHjcPr0abRp08bhdQ4dOgQANscYkMSkSZOg0+mwdOlS69fXr1+P0aNHl0gEbu0W2LZt223fLWDPsdxc90/64QcgJ8dhq4CFVlFwPDfX5WTAZDLZDdAVCdxGo9HhfVUqFXx9feHt7V0mOAcGBuLee++1G9TtbV5eXtZuJpK4du2aNYinpaUhNTXV+vukpKQS+0q/wWu12hKBvHXr1ujZs6fNIB8QEOA4wLvjkUfM3UcOWo4mAcgB0B1AQwCpANbC3D3wNgAfR9f38AC6daucZ60ikgwIUc169uyJd999F1OmTMH999+P8ePHAwCeeOIJzJo1CwsWLMAaJ32Lp06dgpeXFzw9PcvsW7NmDXbs2IGtW7fCYDAAANatW4fY2FjExsbi448/hkqlwuLFi++4bgF7TuXnQ6soKHI+ROq/9u4FNBqgRw+nhxaZTIg/cwb6jz5yKWhfv37d6TUtzd+2AndoaKjbQdvHxwd6vR6KO60jMAf4rKwsawA/e/aszUCflpaG9PT0Mv32er2+RBBv27at9Y29dIC/66673H6+ShEaCgwcCCQkmFsJbBgB4GMA7wO4CsAXQAcACwE4TKE1GuDJJ4FaPt5OBhAKUQNI4plnnsEnn3yCAwcO4MEHHwQAxMXF4cUXX8T58+fRpEkTu+d7enqicePGSEpKKvH1K1euoHXr1ujXrx/Wrl0LwDx2YMyYMRgzZgw++ugjZGdn3/HdAqWNSUrCurQ0OH5vvsWNG+bR3+3bA/Pnu3SK5tIlNJ43r1xB2lYTuqULqSqYTCZkZWWVCealt9TUVKSnp6O4VID08PCwGcxLN8+HhITAz8+vZgK8u/73f4H/+Z/Kv65abR6IWkNjBmQAoRC1mKIoiIuLQ1JSEgYPHowffvgB9957LyZOnIg333wTixYtwnvvvWfz3JycHBQUFKBdu3Ylvm7pHtDr9YiLiwNgbiUYO3Ysxo4di3/96184duxYnegWKM3txuTvvgMKClzqIrC4v3Vr/Hj+vLt3qjRGoxFXr161+9Ze+g2+dJeCl5dXiUDeqVMnu4He19f39gjw7njwQeDpp4EPP3TYXeAWRQFmzqz1gwcBSQaEqDE6nQ5btmxB586dERUVhe+++w7e3t54/vnn8eabb2LWzJmof/YscPgwcOwY8PvvgNGI60VFWATgAR8fIDsb8PcHAKxevRo7d+5EfHw8DAZDmUQgLi7uju8WuHHjBs6dO4fk5GScPXsWycnJSE5OxqlOnWAcNszcZOuKvXsBT0+X+3lVABp7eJT/we0wGo3IyMiw+9Z+658zMjJgKhXEfHx8SgTxLl262G2i9/Fx2OtdNyxaZP67/+03u90FLlOrzS1Lr79eKY9W1aSbQIgadvLkSXTr1g2PPfYYNm7ciJz0dCxq3Bgv6/UIyMkx/1AhrW8rhHkUsw4wD0waMwZpY8eiRf/+6N+/P9asWYPVq1dj7NixGDduHBYuXIgJEybcMd0CJJGWlmYN9LcG/kuXLlmnrAUHByM8PBwtWrRA0V/+glVNm7p2g2vXgKFDgZ49Xf5BrgYwt0kTvO5CglVcXIz09HSnzfNpaWnIzMwsMwXPz8/Ppeb5kJAQeHl5ufaZxX9dvgw89JD51/ImBGq1uTXg4EHgz3E7NUWKDglxG4mPj0d0dDQ+mjgREw4ehOmXXwC41rxNjQZFJhPe9PbGCxcuYOeXX+LJJ5/E+PHjMWHCBIwcOfK2LCJUWFiIX3/91WbQz842z+pWq9Vo1qwZWrRoYQ38lt8HBgZar5V68ybuPnwYLg0f3LoViIsDFi4EOnd2+Xk3NmyIZrm5Tpvor169WibA+/v72wzmtjZbg0ZFJUtLA2JjgT173DtPUcyJ+7Bh5u6Gu+6qksdzhyQDQtxmdkRHo398PKBSQVXOPsvf27dH+E8/YdSECWjVqhVeeeUVdOjQARs3bqy13QJZWVklAr4l6P/666/Wfm1/f3+0bNmyTNAPCwtzuZVjwMmT2J2VBafvepMnAykpwObN5jc8Z0wmID0deOLPtev+FBAQ4PCt3bIFBwfDowq6GEQFkcDKlcCrrwIZGeZ/C/amblr2hYaay1cPHVq9z+qAJANC3E5WrwbGjAFRvpKoFkYAiaGhmNuuHbYlJNSabgGj0YjffvutTNBPTk5GZmYmAPOgysaNG1sD/a2BPzg4uMID1nZnZeHRkycr4+OUoJAYlpWFMbeMsA8ODq7x77moJEVFwLZt5lLCR46YWw1u1bCheWzJ2LHAo4+6lkBWI0kGhLhdJCUB7dqZf+hUAhOAuZ6eiNiwodq7BXJycnD27NkSg/eSk5Nx/vx56/xzb2/vEm/3lq1Zs2blagK/ceOGSyPoU9PSkDN9OvCXv7g+kNAJNYDmXl440bEj9JVVAEfUbhkZQFaWuUsgKAi4pTuqNpJkQIjbgdEIdOkCnDhhc7DSQQCRdk49DKCLnX3UaKAkJgKtHBZJLReTyYTLly+XGbGfnJyMK7es+hcaGmoz6Dds2NDpW35+fr5LI+jT0tKQW6q6oKIoqFevns3meX2DBni9YUPcUBRUxuQxNYAjERHoKD8XRS0ldQaEuB3s2GGeNujEVACdSn2tmYPjFQCYOxfYsKHcj3brNL1bA//Zs2etFfT0ej3uu+8+hIeHY/z48daAf99998HX19d6LZLIy8tDWloavv/+e6eBPj8/v8SzqFQqBAcHW4N7WFgYunbtarMvPigoyFoe15aO2dl4JDERRSaT60WISrGkMp+2bCmJgLgjSMuAEDXpkUeAQ4fsDkw6CHPLwGYAbg9J0miAP/5wuMiOO9P0SvfjW0bsZ2ZmOq1kl5aWVqYEr1qtRnBwsNPR8yEhITAYDA4DvLuOZGdjwKlTuFZc7HZCoFEUaBQFn7ZogeHBpZeuEaJ2kZYBIWq7jAxg/36XD8+FeXU0l//TGo3A558Dkye7PE2vadOmaNasGXr16gWDwQBfX19oNBrk/jllLiUlBSdOnLAG+NIryWm12hJv8C1atECPHj1sBninK8lVoS7+/jj3l7/gufPnsS49HRpFQbGzJXVhXq64i68vPm3ZEmEyxU/cQaRlQIia8tVXwGOPOTzkIMwtAz4A8mDuo34IwCIAHZ1c3qhS4UDDhnhGr8eFCxes1em8vLxQr149+Pv7Q6fTWZe+zc7ORnp6epmV5HQ6nUsFbiwryd1uZWp/yMnBe1euYF1aGgpJKDC//QOAkYQJ5noP/Q0GTGnYEL0CAqC6zT6jqLukZUCI2u7ECcdzl2GuMjgEQD8AQQB+BvBPmBOC7wG0d3B5tcmEuy9fxgVFKVGm9vr160hNTQVJlxab8ff3v+0CvDs6+flhpZ8f3m/eHKfy8/FjXh7SCgtBAAEaDdr7+OABHx/4VuHCQULUNPnXLURNycoyr6HuIBno9udm8TjMYwfaAngNwFdObnGPlxfiFi4sE+Rvm5XkqpGHWo1Ofn7oJK2fog6SZECImlLOYNwMQBSAL2AuMuRoWJ2vvz8mT55crvsIIeoOqZIhRE0JCXHYKuDIPQAKAeQ7OzAkpFzXF0LULZIMCFFTIiLKvW76BQAeMA8stEujMVfbE0IIJyQZEKKmREQ4rWOeYeNriQC2A+gDJ/+BjUa3Vt0TQtRdMmZAiJri5wdERwPx8XbXTR8Bc22BbgCCYZ5N8CEALwALnF1frweGDKm0xxVC3LmkZUCImjR5st1EAAAGAcgE8A6AZwFsBDAYwDEALR1dV602r6ImI+OFEC6QokNC1CQSGDgQ2L3bYVLgFkUBfHyA5GTg7rsr55pCiNuSq/FbWgaEqEmKAvzrX4CXl7nmQGUggWXLJBEQQrhMkgEhalqDBuZxA2p15SQEU6cCsbEVv44Qos6QZECI2iAyEti1C/D0NE8JdJcliZg+HViypNwFjYQQdZMkA0LUFo88Avz8M9Cjh/nPri7Zq1IB9eoBCQnAP/4hiYAQwm2SDAhRm9x7L/D118C2bebWAgut1pwcqNXm31s0bgwsWgScPQv061ftjyuEuDNInQEhahtFAR5/3Lz98Qdw9Chw/DiQkmIuJOTnBzzwANChg/nXyhp4KISosyQZEKI2u+ce8zZ0aE0/iRDiDiavFEIIIUQdJ8mAEEIIUcdJMiCEEELUcZIMCCGEEHWcJANCCCFEHSfJgBBCCFHHSTIghBBC1HGSDAghhBB1nCQDQgghRB0nyYAQQghRx0kyIIQQQtRxkgwIIYQQdZwkA0IIIUQdJ8mAEEIIUcdJMiCEEELUcZIMCCGEEHWcJANCCCFEHadx5SCSAICcnJwqfRghhBBCVB5L3LbEcXtcSgZyc3MBAPfcc08FH0sIIYQQ1S03Nxf+/v529yt0li4AMJlMuHLlCnx9faEoSqU+oBBCCCGqBknk5ubi7rvvhkplf2SAS8mAEEIIIe5cMoBQCCGEqOMkGRBCCCHqOEkGhBBCiDpOkgEhhBCijpNkQAghhKjjJBkQQggh6jhJBoQQQog67v8BJ17KTEdKtLMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print BF results\n", + "bf_best_cases, bf_best = brutal_force(hard_graph)\n", + "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "9df75fbc", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:53:22.166071800Z", + "start_time": "2023-06-30T02:53:18.629941Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "output: 111000010001\n", + "cost: 0.000\n", + "prob: 0.090\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print SA results\n", + "sa_best_cases, sa_best, n_exp = [], float('inf'), 100\n", + "for _ in range(n_exp):\n", + " sa_case, sa_cost = sim_annealing(hard_graph, 200, 1)\n", + " gap = sa_best - sa_cost\n", + " if gap > 1e-6:\n", + " sa_best = sa_cost\n", + " sa_best_cases = [sa_case]\n", + " elif abs(gap) < 1e-6:\n", + " sa_best_cases.append(sa_case)\n", + "sa_prob = len(sa_best_cases) / n_exp\n", + "sa_best_cases = list(set(sa_best_cases))\n", + "print(f'output: {sa_case}\\ncost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if sa_case[i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "c4f3a812", + "metadata": {}, + "source": [ + "We found that the probability of SA getting the correct solution on the hard problem is much lower than that on the easy problem. This is because the energy landscape is different for the easy and hard problem, as shown in the following figure.\n", + "\n", + "\n", + "\n", + "The global minimum is located in a large and smooth neighborhood for a simpler problem and a narrow region for a harder problem. It is worth noting that when the system size is relatively small, most of the randomly generated problems are easy, and hard problems need to be constructed with special methods, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." + ] + }, + { + "cell_type": "markdown", + "id": "99ee9bf8", + "metadata": {}, + "source": [ + "Now we use QAOA to solve this hard problem." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1f6ba479", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "backend = type(K).__name__\n", + "# use vvag to get the losses and gradients with different random circuit instances\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "\n", + "params_hard = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", + "if backend == 'JaxBackend':\n", + " opt = K.optimizer(optax.adam(1e-2))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(2000):\n", + " loss, grads = QAOA_vvag(params_hard, hard_graph)\n", + " params_hard = opt.update(grads, params_hard) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "a6b7606f", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:52:31.104782900Z", + "start_time": "2023-06-30T02:51:56.848514800Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #0\n", + "measurement prob: 0.011892922222614288\n", + "output: 100111100001\n", + "cost: 0.03514176607131958\n", + "max prob: 0.03562089055776596\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #1\n", + "measurement prob: 0.021911870688199997\n", + "output: 111100100001\n", + "cost: 0.029562288895249367\n", + "max prob: 0.04285888373851776\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #2\n", + "measurement prob: 0.016403989866375923\n", + "output: 111000011000\n", + "cost: 0.03551255911588669\n", + "max prob: 0.034648310393095016\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #3\n", + "measurement prob: 0.006490767467767\n", + "output: 000110011110\n", + "cost: 0.029899753630161285\n", + "max prob: 0.042506810277700424\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #4\n", + "measurement prob: 0.025229839608073235\n", + "output: 100110100001\n", + "cost: 0.03145389258861542\n", + "max prob: 0.04125567898154259\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #5\n", + "measurement prob: 0.02942775934934616\n", + "output: 000111011110\n", + "cost: 0.03618713840842247\n", + "max prob: 0.035310640931129456\n", + "bit strings: ['000000111111']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print QAOA results\n", + "for num_circuit in range(ncircuits):\n", + " print(f'Circuit #{num_circuit}')\n", + " c = QAOAansatz(params=params_hard[num_circuit], g=hard_graph, return_circuit=True)\n", + " loss = QAOAansatz(params=params_hard[num_circuit], g=hard_graph)\n", + "\n", + " # measurement output\n", + " m_out, m_prob = c.sample()\n", + " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", + " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", + "\n", + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "id": "565dd4a7", + "metadata": {}, + "source": [ + "The probability of QAOA getting the correct solution is also very low. A very simple trick can be adopted to improve the performance of QAOA, namely quantum dropout, please refer to following tutorials or [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "89ed16e3", + "metadata": { + "ExecuteTime": { + "end_time": "2023-06-30T02:52:31.105332Z", + "start_time": "2023-06-30T02:52:31.104219200Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OS info: Linux-5.4.119-1-tlinux4-0010.2-x86_64-with-glibc2.28\n", + "Python version: 3.10.11\n", + "Numpy version: 1.23.5\n", + "Scipy version: 1.11.0\n", + "Pandas version: 2.0.2\n", + "TensorNetwork version: 0.4.6\n", + "Cotengra is not installed\n", + "TensorFlow version: 2.12.0\n", + "TensorFlow GPU: []\n", + "TensorFlow CUDA infos: {'cpu_compiler': '/dt9/usr/bin/gcc', 'cuda_compute_capabilities': ['sm_35', 'sm_50', 'sm_60', 'sm_70', 'sm_75', 'compute_80'], 'cuda_version': '11.8', 'cudnn_version': '8', 'is_cuda_build': True, 'is_rocm_build': False, 'is_tensorrt_build': True}\n", + "Jax version: 0.4.13\n", + "Jax installation doesn't support GPU\n", + "JaxLib version: 0.4.13\n", + "PyTorch version: 2.0.1\n", + "PyTorch GPU support: False\n", + "PyTorch GPUs: []\n", + "Cupy is not installed\n", + "Qiskit version: 0.24.1\n", + "Cirq version: 1.1.0\n", + "TensorCircuit version 0.10.0\n" + ] + } + ], + "source": [ + "tc.about()" + ] + } + ], + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/tutorials/qaoa_quantum_dropout.ipynb b/docs/source/tutorials/qaoa_quantum_dropout.ipynb new file mode 100644 index 00000000..008ca304 --- /dev/null +++ b/docs/source/tutorials/qaoa_quantum_dropout.ipynb @@ -0,0 +1,1040 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Quantum Dropout for QAOA" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Overview" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In the previous tutorial, we introduced solving the [Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) by QAOA and the dilemma of QAOA on the hard problem. In this tutorial, we will introduce a simple trick to alleviate this dilemma, namely quantum dropout, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more details.\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## NAE3SAT and Hard Problem" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's briefly review the NAE3SAT and the difference between the easy and hard problem.\n", + "\n", + "Let the set of clauses in the NAE3SAT be $\\mathcal{C}$. In each clause, there are three literals and each literal is represented by a spin. Spins up ($s=1$, $\\text{bit}=0$) and down ($s=-1$, $\\text{bit}=1$) represent false and true respectively. NAE3SAT requires the three spins in each clause are not all equal to each other, in other words, at least one is up, and at least one is down. The Hamiltonian of the NAE3SAT is as follows\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $H_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT.\n", + "\n", + "The difference between the easy and hard problem is the energy landscape, as shown in the following figure.\n", + "\n", + "\n", + "\n", + "The global minimum is located in a large and smooth neighborhood for a simpler problem and a narrow region for a harder problem. It is worth noting that when the system size is relatively small, most of the randomly generated problems are easy, and hard problems need to be constructed with special methods, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Quantum Dropout" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "The algorithm is shown in the following figure.\n", + "\n", + "\n", + "\n", + "We first implement the classical algorithm that can be done in polynomial time, such as simulated annealing method (SA). If the result is satisfactory, we stop the procedure since there is no point in a quantum solver. Otherwise, these failed classical results, typically low-lying excited states (local minima), offer insights as we prepare quantum dropout for QAOA: whether a clause should be kept or available for quantum dropout to underweight the distracting local minima and enhance the chances to locate the true ground state. Specifically, the clauses violated by low-lying excited states should be all kept, and the other clauses can be randomly discarded at the ratio $R$.\n", + "\n", + "Finally, we optimize the PQC with respect to the original cost function $H_C$ with a complete set of clauses to ensure the uniqueness of the global minimum. The current procedure does not incur obvious overhead to the conventional QAOA since the preliminary approaches and the quantum-dropout controls are both inexpensive on a classical computer." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "### The code" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 175, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import optax\n", + "import jax.numpy as jnp\n", + "import tensorflow as tf\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from functools import partial\n", + "from IPython.display import clear_output\n", + "import random\n", + "\n", + "K = tc.set_backend('jax')\n", + "\n", + "nlayers = 30 # the number of layers\n", + "ncircuits = 6 # six circuits with different initial parameters are going to be optimized at the same time\n", + "R = 0.5 # dropout ratio, 0 means no dropout, 1 means all dropout" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.070466200Z", + "start_time": "2023-06-30T07:04:52.893906200Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We use the same NAE3SAT as the previous tutorial." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 176, + "outputs": [], + "source": [ + "# a hard graph instance\n", + "hard_clauses = [[4, 1, 7], [5, 11, 8], [4, 1, 8], [4, 11, 8], [4, 1, 10], [5, 11, 8], [4, 1, 8], [1, 11, 8], [4, 1, 7], [0, 11, 8], [4, 1, 10], [4, 11, 8], [5, 0, 10], [0, 6, 7], [5, 0, 11], [0, 6, 7], [5, 0, 9], [3, 6, 7], [5, 0, 8], [5, 6, 7], [5, 0, 10], [3, 6, 7], [5, 0, 10], [1, 6, 7], [2, 4, 6], [1, 8, 11], [2, 4, 6], [2, 8, 11], [2, 4, 9], [5, 8, 11], [2, 4, 10], [2, 8, 11], [2, 4, 10], [4, 8, 11], [2, 4, 8], [4, 8, 11], [3, 0, 9], [5, 11, 7], [3, 0, 10], [2, 11, 7], [3, 0, 9], [0, 11, 7], [3, 0, 9], [5, 11, 7], [3, 0, 10], [3, 11, 7], [3, 0, 7], [4, 11, 7], [5, 0, 10], [4, 0, 10], [2, 5, 6], [2, 11, 10], [2, 6, 10], [2, 4, 9], [0, 9, 10], [3, 0, 7], [2, 5, 6], [1, 10, 9], [1, 4, 11], [5, 10, 11], [0, 4, 8], [0, 9, 8], [2, 11, 10], [2, 8, 6], [3, 6, 7], [0, 8, 10], [4, 0, 9], [3, 5, 8], [5, 11, 10], [2, 11, 10], [4, 11, 8], [1, 3, 11]]\n", + "cost_factor = 1 / len(hard_clauses) / 4" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.085860400Z", + "start_time": "2023-06-30T07:04:52.913910400Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 177, + "outputs": [], + "source": [ + "# convert to a NetworkX graph\n", + "def construct_graph(clauses):\n", + " graph = nx.Graph()\n", + " for i, j, k in clauses:\n", + " graph.add_edge(i, j, weight=0)\n", + " graph.add_edge(j, k, weight=0)\n", + " graph.add_edge(k, i, weight=0)\n", + " for i, j, k in clauses:\n", + " graph[i][j]['weight'] += 1\n", + " graph[j][k]['weight'] += 1\n", + " graph[k][i]['weight'] += 1\n", + " return graph" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.090006Z", + "start_time": "2023-06-30T07:04:52.919783900Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 178, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVhU3/PH3xt0h5SEBQYg2N3YjShiYyEqtmJ3i/FBDMQuDGzsFjuxRVBpQQGlc3d+f/hjvyC1wC6gntfz7KN77zlz5u6y98ydMzOHQ0QEBoPBYDAY/yzc8laAwWAwGAxG+cKMAQaDwWAw/nGYMcBgMBgMxj8OMwYYDAaDwfjHYcYAg8FgMBj/OMwYYDAYDAbjH4cZAwwGg8Fg/OPwxWkkFAoRGRkJFRUVcDgcaevEYDAYDAZDAhAREhMTYWBgAC634Od/sYyByMhIGBkZSUw5BoPBYDAYZUdYWBgMDQ0LPC+WMaCioiISpqqqKhnNGAwGg8FgSJWEhAQYGRmJ5vGCEMsYyF4aUFVVZcYAg8FgMBh/GEUt8bMAQgaDwWAw/nGYMcBgMBgMxj8OMwYYDAaDwfjHYcYAg8FgMBj/OMwYYDAYDAbjH4cZAwwGg8Fg/OMwY4DBYDAYjH8cZgwwGAwGg/GPw4wBBoPBYDD+cZgxwGAwGAzGPw4zBhgMBoPB+MdhxgCDwWAwGP84zBhgMBgMBuMfhxkDDAaDwWD84zBjgMFgMBiMfxxmDDAYDAaD8Y/DL28FGAzG30VyehaCY5ORkSWELJ+LKlpKUJJjtxoGoyLDfqEMBqPUBEYn4tCjUNwM+IbQuBRQjnMcAMaaimhXUweDmxjDVFelvNRkMBgFwCEiKqpRQkIC1NTUEB8fD1VV1bLQi8Fg/AGExaVg7qnX8AuKAY/LgUBY8O0k+3yrGtpY2dcSRpqKZagpg/FvIu78zWIGGAxGiTjyJBQ2G2/j/udYACjUEMh5/v7nWNhsvI0jT0KlriODwRAPtkzAYDCKjcfNQLhd+ViivgIhQSAkzD75GjFJ6ZjYzlTC2jEYjOLCPAMMBqNYHHkSWmJD4HfcrnzEUeYhYDDKHeYZYDAYYhMWl4JFZ98WeF6YkYqERyeRHhmAjK8fIUxLgla3KVCua1Ngn4Vn36J5dW0WQ8BglCPMM8BgMMRm7qnXyCokNkCYkoD4e97IjA2DjE5VsWRmCQlzT72WlIoMBqMEMM8Ag8EQi8DoRPgFxRTahqesCcOJB8BT1kD610BE7ZtapFyBkOAXFIOgb4moocPSDhmM8oB5BhgMhlgcehQKHpdTaBsOXwY8ZY1iy+ZxOTj4kMUOMBjlBTMGGAyGWNwM+FZk+mBJEQgJNz9+k4psBoNRNMwYYDAYRZKUnoXQuBSpjhEam4Lk9CypjsFgMPKHGQMMBqNIQmKTIR2fwP8gAMGxyVIehcFg5AczBhgMRpFkZAn/qnEYDEZumDHAYDCKRJZfNreKshqHwWDkhv3yGAxGkVTRUkLheQSlh/P/4zAYjLKHGQMMBqNIlOT4MJZyhUBjLUUoybHSJwxGecB+eQwGo0iysrJgxEtACHEBTuHPEAnPzkGYlgxBUhwAIDXoMbISfxUrUm3QE1z5vE//PC4H7cx0JK84g8EQC2YMMBiMAomLi4OXlxe2bNmCqBTAYMy2IvskPDoFQcL/agakfLwPfLwPAFA2b5evMSAQEoY0NZac4gwGo1gwY4DBYOThzZs3cHd3x8GDByEUCjFo0CC4uLhgw/MM3P8cW2jxIcPxu4s1Fo/LQfNqWqwUMYNRjrCYAQaDAQAQCAQ4e/YsOnToAEtLS5w/fx7z5s1DWFgYdu/ejXr16mFlX0vwiyhJXByICBwSYmVfS4nJZDAYxYcZAwzGP058fDw2btwIMzMz9O7dGykpKfD29kZwcDDmzZuHSpUqidoaaSpiSS9ziY3N4XAQfd4dC6dPQEqKdCscMhiMgmHGAIPxjxIQEICJEyeicuXKcHV1RbNmzfDo0SM8ePAAAwcOhIyMTL79utVUh/zHqwB+PdmXhpmdamLbzGE4duwYmjZtioCAgFLJYzAYJYMZAwzGP4RQKMSlS5fQtWtX1KpVC8ePH8f06dMREhKCgwcPonHjxoX2z8zMhJ2dHaKu70WdpBegrAxAKCimEgJAkInlPWtjQrsaGDJkCB4/fozMzEw0bNgQx44dK8UVMhiMksCMAQbjHyAxMRFbtmxBnTp10LVrV3z79g379u1DaGgolixZAn19/SJlEBHGjh2LW7duYe3atbi8dRG+7poAK30FAChye2P6f6PB2kAR3/dOwnMfD9E5c3NzPHnyBL169YK9vT1cXFyQnp5eiitmMBjFgRkDDMZfzOfPnzFt2jQYGhpi8uTJsLKywt27d/H06VMMGzYMcnJyYstasmQJ9u7dCy8vL/z3338AgDEOfXFmSkdcndIaQ5uYwERLMU+lQg4AE00FCN7fRPvUezg92QbL50zFxo0bce3aNVE7ZWVlHDx4ENu2bcOOHTvQqlUrhISESOBTYDAYRUJiEB8fTwAoPj5enOYMBqMcEQqFdO3aNerVqxdxOBzS0tKiOXPmUGhoaIll7t69mwDQypUrafHixcThcEhDQ4N+/PiRp21SWiZNWexGeuZN6U3ET0pKyyQiIldXV1JXV6eUlBQSCATUoUMHqly5MsXGxuaR8eTJE6pSpQppaGiQr69vifVmMP51xJ2/mTHAYPwlJCcnk6enJ5mbmxMAsrS0pJ07d1JKSkqp5F6+fJn4fD45OTnRixcviMvlEgDas2dPgX1Wr15NWlpauY4FBQURANq7dy8REYWFhZG6ujrZ29uTUCjMIyMuLo569epFAGjOnDmUmZlZqutgMP5FmDHAYPwjhISE0KxZs0hDQ4M4HA716dOHbty4ke8EW1xevHhBysrK1L17d0pJSSErKyuSk5OjZs2akUAgKLCfm5sbqaqq5jnesWNHatasmej9kSNHCAAdPHgwXzlCoZDWrl1LPB6P2rRpQ5GRkaW+JgbjX4IZAwzGX4xQKKQ7d+5Qv379iMvlkpqaGk2fPp0+f/4ssTFCQkJIX1+fGjRoQImJibR06VLicDjE5XLpxYsXhfbdtGkTKSoq5jnu4+NDAOjVq1eiY4MHDyZVVVUKDg4uUN6dO3dIX1+fdHV16ebNmyW9JAbjn0Pc+ZsFEDIYfxBpaWnYu3cvGjRogNatW+PNmzfYvHkzwsPD4ebmhqpVq0pknJ8/f6Jbt26Qk5ODr68vPn/+jKVLl0JGRgbjx4+HtbV1of1lZGSQlZWV53ivXr2gq6sLT09P0TEPDw+oqalh+PDhEAjyT1Ns1aoV/P39YWFhgQ4dOmDlypUQCoWlukYGg/E/mDHAYPwBREZGYsGCBTA2NoajoyP09fVx6dIlvHv3DuPHj4eysrLExkpPT4etrS0iIyNx8eJFaGlpwdHREUpKSlBTU8OyZcuKlMHn85GZmZnnuIyMDEaOHIkDBw6IKg6qq6tj//79uHPnDjZs2FCgTB0dHVy+fBnz5s3D/Pnz0bNnT8TGxpb8QhkMxv+QpJuBwWBIlocPH5KDgwPx+XxSVlYmFxcXCggIkNp4QqGQBg8eTHJycnTnzh0iIlq+fLkoaDA7+K8osrMP8osr+Pz5M3E4HNq9e3eu4zNnziQZGRny9/cvUv7FixdJS0uLjI2N6eHDh2LpxGD8i7CYAQbjDyU9PZ0OHTpEjRs3JgBUvXp12rRpE/38+VPqY8+dO5cA0NGjR4mI6PXr18Tn80lbW5uaN29eaNBgTvbv308AKC0tLd/znTt3piZNmuQ6lpaWRlZWVmRubk6pqalFjhEaGkrNmjUjGRkZcnd3l0jAJIPxt8GMAQbjDyM6OpqWLl1K+vr6BIBsbGzo3LlzlJWVVSbje3p6EgByc3MjIqLMzExq0KAB6erqihU0mBNvb28CQElJSfmeP3nyJAHI4wV4/fo1ycnJ0ZQpU8QaJz09naZOnUoAqH///uwexWD8BjMGGIw/hGfPntHw4cNJVlaWFBQUyMnJid6+fVumOvj6+hKXyyUXFxfRE/bKlSuJw+GQoqIiubi4FEve8ePHCUC+RYmIiDIyMkhfX5+cnZ3znNu4cSMBoKtXr4o9no+PD6mqqpKpqSm9fPmyWLoyGH8zzBhgMCowmZmZdOzYMWrZsiUBIGNjY1q7dm2+1fikzZMnT0hRUZH69Okj8kK8efOGZGVlqU6dOqSjo1PgpF4Qp0+fJgD0/fv3AtvMnz+fVFRUKDExMdfx7OqEBgYGxfo8AgMDycrKiuTl5fPEIzAY/yostZDBqIDExsZizZo1qFatGgYMGAAej4cTJ07g06dPmDlzJjQ1NctUny9fvqB79+6oW7cuDh06BB6Ph6ysLDg6OkJPTw/v3r3D2rVroa6uXiy5fD4fAPLNKMhm9OjRSEpKwtGjR3Md53K52Lt3L1JSUuDs7Cz2Nsk1atTAgwcPMGTIEIwcORIjR44UZSwwGIwikKRlwWAw8ufVq1c0ZswYUlBQIDk5ORo5cmSx1uClQWxsLNWsWZOqV69O3759Ex1fvXo1cTgcqlKlCrVo0ULsoMGcXL58mQAUuR9C165dqVGjRvmeO3r0KAGgAwcOFHv8vXv3koKCAtWtW5c+fvxY7P4Mxt8CWyZgMMqZrKwsOn36NLVv354AkIGBAa1YsSLXxFtepKamUsuWLUlbWzvXZPn27VuSlZWltm3bEpfLFSvNLz+uX79OAOjTp0+FtsteTnj+/Hm+54cMGVJkdcKCePXqFdWsWZNUVFTo+PHjxe7PYPwNsGUCBqOc+PnzJzZs2ABTU1P06dMHqampOHLkCIKDgzF37lxUqlSpXPUTCoUYPnw4nj59inPnzsHU1BQARMsDRkZGePr0KSZMmAArK6sSjZG9TJBfFcKcdO/eHZUrV85VkTAnHh4eUFdXx7BhwwqsTlgQlpaWePLkCbp164b+/ftj8uTJyMjIKJYMBuOfQZKWBYPxL/P+/XsaP348KSkpkYyMDA0ZMoQeP35c3mrlYcaMGcThcOjkyZO5jq9du5Y4HA7Z2NiUKGgwJ/fv3ycAYmVFLFy4kJSVlSkhISHf87du3SIOh0Nr1qwpkS5CoZA8PDxIRkaGmjRpQiEhISWSw2D8ibBlAgajDBAIBHThwgXq3LkzASAdHR1atGgRff36tbxVy5fNmzcTAHJ3d891/P379yQnJ0f9+/cnALRv375SjfP48eN86wjkR2hoKHG5XPL09CywzaxZs0hGRqZUcRaPHj0iExMT0tTUpAsXLpRYDoPxJ8GMAQZDiiQkJNDmzZvJzMyMAFCDBg1o//79BVbcqwicOnWKOBwOTZs2LdfxrKwsatq0KZmamlKtWrWoRYsWpa7m9+LFCwJAT58+Fat9jx49qEGDBgWez65OWKdOHUpJSSmxXrGxsdS9e3cCQHPnzqXMzMwSy2Iw/gSYMcBgSIGgoCCaMmUKqaqqEo/HowEDBtC9e/cqfCncBw8ekLy8PPXv3z9PdoCbmxtxOBwaP358qYIGc/L69WsCQA8ePBCr/dmzZ4s0Ht68eUNycnI0efLkUukmEAho1apVxOVyqV27dhXWi8NgSAJmDDAYEkIoFNK1a9eoZ8+exOFwSEtLi+bMmVNk2lxFITAwkLS1talFixZ5av5/+PCB5OXlacyYMaSkpESTJk2SyJgfPnwgAOTn5ydW+8zMTDI0NKQxY8YU2m7Tpk0EgK5cuVJqHW/dukV6enqkp6dHt27dKrU8BqMiwrIJGIxSkpKSgh07dsDS0hI2NjYIDg6Gl5cXwsLCsHLlShgZGZW3ikXy/ft3dO3aFVpaWjhz5gzk5eVF5wQCAUaOHAlDQ0P8+PEDSkpKWLJkiUTGFafo0O/tR48ejcOHDyMhIaHAdi4uLrCxscGIESMQFxdXKh3btGmDFy9eoHbt2mjfvj1Wr14NoVBYKpkMxh+LJC0LBuNvIDg4mGbNmkUaGhrE5XKpT58+dPPmzQq/FPA7ycnJ1LRpU9LR0aHPnz/nOb9hwwbicDiivQBKGzSYk5CQkGI/wYeFhRGXy6Vt27YV2i48PJw0NDSof//+EvlOsrKyaN68eQSAevToUS4loRkMacGWCRiMYiAUCun27dvUr18/4nK5pKamRtOnT893Ev0TyMrKor59+5KioiI9efIkz/mPHz+SvLw8TZw4kWrXrk0tW7aUqLETERFBAOj8+fPF6terVy+ytrYuUpfs6oT79+8vjZq5OH/+PGlqapKJiUmFTAllMEoCWyZgMMQgLS0Ne/bsQf369dGmTRu8ffsWHh4eCA8Ph5ubG6pWrVreKhYbIsK0adNw5swZHD16FA0bNsx1XiAQwNHREZUrV4a+vj4CAgLg4eEBDocjMR3ELTr0O05OTvD398fTp08LbTdgwAAMHToUEydOREhISIn1zEm3bt3w4sUL6OnpoUWLFvDw8BB7XwQG449HkpYFg/GnEBERQfPmzSNtbW0CQN27d6fLly//cUsB+bF+/XoCUKC7PTsI7/jx4xINGsxJXFwcAaATJ04Uq19WVhYZGxvTqFGjimz78+dPMjExodatW4t2W5QE6enpNGnSJAJA9vb2BRZDYjD+BNgyAYORDw8ePKCBAwcSn88nFRUVmjRp0l+1kc2xY8cIAM2ePTvf84GBgaSgoEAuLi5kb29Purq6pao0WBAJCQkEgI4cOVLsvkuXLiVFRUX6+fNnkW1v375NHA6HVq9eXRI1C+XYsWOkoqJCNWvWpNevX0tcPoNRFjBjgMH4f9LT0+ngwYPUuHFjAkA1atSg//7776/7e/bz8yM5OTkaNGhQvjsNCgQCatWqFVWrVo3OnTsn8aDBnKSmphIAOnjwYLH7RkREEI/Hoy1btojVPrs6YUGbHZWGgIAAqlu3LikoKNDevXslLp/BkDbMGGD880RFRdGSJUtIT0+PAFDHjh3J19e3RFvyVnQ+fPhAmpqa1LZt2wKrILq7u4si/KURNJiTzMxMAkB79uwpUf8+ffpQ3bp1xdIvLS2NrK2tS12dsCCSk5PJ0dGRANCoUaOkMgaDIS2YMcD4Z3n27BkNGzaMZGVlSVFRkcaNGyfWhjl/KlFRUVS1alWqU6dOgS7/oKAgUlRUpAkTJtDatWuJx+PRy5cvpaaTUCgkAOTl5VWi/hcvXixWBcPs6oTSiH/IZvfu3SQvL09WVlZ/1dIS4++GGQOMf4rMzEw6duwYtWjRggCQiYkJrVu3juLi4spbNamSlJREDRs2JH19/QJ34xMIBNS2bVuqUqUKffjwgZSUlEpd0lcc+Hw+bd26tUR9BQIBmZiY0IgRI8TuI8nqhAXx8uVLMjU1JRUVFfLx8ZHaOAyGpGDGAOOfICYmhlatWkWGhoYEgNq0aUMnT56UaHR5RSUzM5N69OhBysrKha6Xb9myhQDQ9evXRUGD4gTnlRYFBYU8uyMWh+XLl5OCgoLYAY4CgYA6duxIBgYGUi0cFB8fL9rdccqUKZSeni61sRiM0sKMAcZfzatXr2j06NEkLy9PcnJyNHLkSIlssPOnIBQKady4ccTj8ejSpUsFtvv8+TMpKSmRs7MzXbt2TeKFegpDRUWF1q9fX+L+kZGRxOfzafPmzWL3ya5OaGdnJ9U0UaFQSO7u7iQjI0PNmjX7Y/apYPx7MGOA8deRlZVFp0+fpnbt2hEAqly5Mq1YsYK+f/9e3qqVOatWrSIAtGvXrgLbCAQCateuHZmYmFBMTAzVqlVLqkGDv6OhoUFr1qwplQxbW1uysLAols7Z6ZXSypTIycOHD8nY2Ji0tLTo4sWLUh+PwSguzBhg/DX8+PGD1q9fT1WrViUA1Lx5czpy5AhlZGSUt2rlwqFDhwgALVy4sNB227ZtIwB07dq1Mgka/B0dHR1asWJFqWRcvnyZANC9e/eK1W/o0KGkoqJCX758KdX44hATE0Ndu3YlDodDCxYs+CeWqBh/DswYYPzxvH//nsaPH09KSkokIyNDQ4YM+edrxt+8eZNkZGRo+PDhhT4tf/nyhZSVlcnJyYnCwsLKLGgwJwYGBrR48eJSyRAIBFStWjUaNmxYsfplVyds1apVmUzOAoGAVqxYQVwulzp06EBRUVFSH5PBEAdmDDD+SAQCAZ0/f546d+5MAEhXV5cWLVpEX79+LW/Vyp03b96Qmpoa2djYFBq0JhQKqUOHDmRsbEzx8fE0YMCAMgsazImJiQnNnz+/1HJWrVpF8vLyxc4MuXPnDnE4HFq1alWpdRCXGzdukK6uLunr69OdO3fKbFwGoyCYMcD4o0hISCB3d3cyNTUlANSgQQPav39/gQV0/jUiIiLIyMiI6tatW+Tv0NPTU5RiV9ZBgzmpXr06ubq6llrO169fic/n03///Vfsvq6urlKrTlgQkZGR1KZNG+LxeLRmzZq/Yr8Lxp8LMwYYfwRBQUE0efJkUlFRIR6PR/b29nTv3j12A81BQkICWVtbk6GhIYWHhxfaNjg4mJSVlWnMmDGUnp5e5kGDOalVqxZNnz5dIrLs7OyoTp06xb6O9PR0sra2ptq1a5dp5cDMzEyaM2cOAaBevXr99fUuGBUXZgwwKixCoZCuXr1KPXr0IA6HQ1paWjR37lwKCwsrb9UqHBkZGdS5c2dSVVWlV69eFdpWKBRSx44dycjIiOLj42nNmjVlHjSYEwsLC4lVBLx69SoBID8/v2L3ffv2LcnLy0u1OmFBnDt3jjQ0NKhKlSr09OnTMh+fwWDGAKPCkZSURNu3b6c6deoQAKpbty7t2rWL1XovAKFQSCNHjiQZGRm6du1ake29vLwIAF26dEkUNDhlypQy0DR/6tWrR+PHj5eILIFAQNWrV6chQ4aUqP9///1HAOjy5csS0ac4fPnyhRo1akSysrK0detW5vVilCnMGGBUGIKDg2nmzJmkoaFBXC6X+vbtS7du3WI3xSJYsmSJ2Ov9ISEhpKKiQqNGjSIiKregwZw0atSIxowZIzF5a9asITk5OYqJiSl23+zqhPr6+iXqX1rS0tJo4sSJBIAcHBwoMTGxzHVg/JswY4CRh6S0THoT8ZOeh8TRm4iflJSWKbWxhEIh3b59m2xtbYnL5ZK6ujrNmDGjTPK+/wb27t1LAGj58uVFthUKhdS5c2cyNDSknz9/ilzqBw4cKANNC6ZZs2bk6OgoMXnR0dEkIyNDGzZsKFH/iIgI0tTUpH79+pWbIXrkyBFSVlamWrVq0Zs3b8pFB8a/hbjzN4eICEWQkJAANTU1xMfHQ1VVtajmjApEYHQiDj0Kxc2AbwiNS0HOL5sDwFhTEe1q6mBwE2OY6qqUery0tDR4e3vjv//+w8uXL1G7dm1MmjQJQ4cOhZKSUqnl/wtcvXoV3bp1w4gRI7Bjxw5wOJxC2+/evRujRo3ChQsX0KFDB9StWxc6Ojq4fft2kX2lSZs2bWBiYoL9+/dLTKa9vT1evXqFd+/elejafHx80L9/f+zduxfDhw+XmF7FISAgAHZ2dvj8+TO2b9+OoUOHlosejH8DcedvbhnqxChDwuJSMHTXI3TcdAcHHoUg5DdDAAAIQEhcCg48CkHHTXcwdNcjhMWllGi8iIgIzJ8/H0ZGRhg1ahSMjIxw5coVvH37FuPGjWOGgJi8fPkS/fr1Q8eOHbFt27YiJ7zw8HBMnToVjo6O6Nq1KzZt2oSgoCBs2bKlXA0BAODz+cjMzJSoTCcnJ3z48AF+fn4l6m9nZ4dhw4bBxcUFX758kahu4lKzZk08evQI/fv3x7Bhw+Dk5IS0tLRy0YXByIZ5Bv5CjjwJxaKzb5ElJAiERX69InhcDvhcDpb0MsfARsZFticiPHz4EO7u7vDx8YGCggIcHR3h4uKCGjVqlOYS/knCw8PRtGlT6Orq4vbt21BWVi60PRGhe/fuePnyJd6+fYvExETUrl0bY8aMwcaNG8tI64Lp0qULVFRUcPz4cYnJJCLUrFkTjRo1wqFDh0okIz4+HlZWVjAyMsKtW7fA4/Ekpl9xICLs3r0bEydORO3atXH8+HFUr169XHRh/L0wz8A/isfNQMw++RrpWcJiGQIAIBAS0rOEmH3yNTxuBhbYLiMjA4cOHUKTJk3QvHlzPH36FOvXr0d4eDj+++8/ZgiUgPj4eHTt2hV8Ph/nz58v0hAAgH379uHixYvYsWMH1NXVMX36dKioqGDx4sXSV1gMpOEZ4HA4GDt2LHx8fBATE1MiGWpqajhw4ADu3buHdevWSVS/4sDhcDBq1Cg8fPgQiYmJaNCgAU6dOlVu+jD+bZgx8Bdx5Eko3K58FKtt/P2jCFndA5E7x+d73u3KRxx9EprrWHR0NJYuXQoTExMMGTIEGhoa8PX1RUBAACZNmsS8RiUkIyMD/fr1Q3h4OC5evAg9Pb0i+0RERGDKlCkYPnw4unfvjmvXruH48eNYt24d1NTUykDropGRkUFWVpbE5Y4YMQLAL2OopLRq1Qqurq5YsGABnj9/LiHNSoaVlRWePn0KGxsb2NraYvr06RI3ohiMomDLBH8JYXEpsNl4G+lZwiLbZiXEINLLCQAHfDUdGIzemm87OT4X16a2wbcv7+Hu7o4jR46Az+dj+PDhmDhxIurUqSPhq/j3ICIMHz4cR48exdWrV9G6dWux+vTs2RPPnz/H27dvoaSkVGGCBnPSv39/JCQk4PLlyxKXPWjQIDx79gwfPnwo8fVmZGSgadOmSEtLw7Nnz6CgoCBhLYsHEcHd3R0zZsxA48aNcfToURgaGparTow/H7ZM8I8x99RrZIm5LPDj5i7IGdSErF7h7vzMLAFs5u5Cw4YNcefOHaxcuRLh4eHYunUrMwQkxMKFC3HgwAHs27dPLEMAAA4cOIDz58/D09MTGhoa2LhxY4UJGsyJtDwDwK9Awo8fP+L27dslliErK4uDBw/iy5cvcHV1laB2JYPD4WDy5Mm4c+cOQkNDUa9ePVy5cqW81WL8IzBj4C8gMDoRfkExYsUIpIW+QcqHe9DoMLbItkJwkK5RDdsOn0JQUBCmT58ODQ0NSajMAODl5YXly5djzZo1GDhwoFh9IiMjMXnyZAwdOhQ9e/ZEWFgYli1bBhcXF1haWkpZ4+IhjZiBbFq3bo2aNWvC09OzVHLq1KmDtWvXYvPmzVLxYJSEZs2a4cWLF2jQoAG6dOmCxYsXQyAQlLdajL8cZgz8BRx6FAoet+gnQhIKEHd1O5StOkFWp4pYsnlcDqKUTMst4vpv5eLFi3B2dsb48eMxc+ZMsfoQEZycnCAvL49NmzYBQIULGswJn8+XmmcgO5DwxIkT+P79e6lkTZgwAZ06dYKjoyNiY2MlpGHp0NbWxoULF7B06VIsW7YMXbp0wbdv38pbLcZfDDMG/gJuBnwTyyuQ9OIishK+Q721+EVOBELCzY/sJiRJnj17hv79+6N79+5wd3cX27V/6NAh+Pr6wtPTE5qamrh69SqOHz8ONze3ChM0mBNpLhMAwPDhw8HlcrF3795SyeFyudizZw/S09Ph5OQEMcKoygQul4v58+fj6tWrePXqFerVq4e7d++Wt1qMvxRmDPzhJKVnIVSMQkGC1AT89DsE9eb24CkWb+IIjU1Bcrr0bur/EsHBwejRowfMzc3h7e0ttsfl69evmDRpEgYPHoxevXohIyMDLi4uaN26NQYNGiRlrUuGNJcJAEBLSwt2dnbYsWMHhMKiA2cLw8DAAJ6enjhx4oREKyZKgvbt2+PFixeoXr062rZtCzc3twpjsDD+Hpgx8IcTEpucp7Jgfvy8cwBcBWWoNOxZ7DEIQHBscrH7MXLz48cPdOvWDYqKijh37hwUFRXF6kdEGDduHGRlZfHff/8BQIUNGsyJtD0DwK9AwqCgINy8ebPUsuzs7DB8+PByrU5YEAYGBrhx4wZmzJiBmTNnom/fvvj582d5q8X4i2DGwB9OhhiphJlxEUjyvwyVBr0gSIxD1s9oZP2MBgkyQUIBsn5GQ5CaWOpxGAWTnp6OPn364Nu3b7h48SJ0dHTE7uvt7Y2zZ89i+/bt0NLSQlhYGJYuXYpJkybBwsJCilqXDml7BgCgZcuWqF27dqkDCbNxd3eHlpYWhg4dWuGC9vh8PlavXo0zZ87g9u3bqF+/frnXSGD8PTBj4A9Hll/0VyhIjAVIiB/XPBGxfZTolREZgKy4CERsH4X4e96Fyrh35za+fPnC3JMlQCgUYvjw4Xj8+DHOnj0LMzMzsftGRUXBxcUFDg4O6NOnDwBg2rRpUFVVrZBBgzkpC89AdiDhqVOnEB0dXWp5qqqq2L9/Px48eIC1a9dKQEPJ06tXLzx//hyamppo3rw5PD092e+SUWr45a0Ao3RU0VICByh0qUCmkgkq2c7Lc/znnQMQZqRC02Ys+Or6BfYnIkwa6QCXzDSoqanBysoK9erVg7W1NaytrVGnTh3IysqW/mL+UubMmYNjx47h+PHjaN68udj9iAjOzs7g8/lwd3cH8GtHQx8fHxw8eLDCFwArC88AAAwbNgyzZ8/G3r17JVIvILs64cKFC9G5c2fUr19fAlpKlqpVq+LevXuYNm0axo0bBz8/P2zfvl2sMtYMRn6wCoR/AW3W3URICXYbjDo0G8LUhAIrEGajKEjGyuaykJGRwcuXL+Hv7w9/f38EBv7av0BGRgbm5uawtrYWGQlWVlYVMsK9rNmyZQsmTpyIjRs3YsqUKcXqe+TIETg4OODEiROwtbVFeno66tatCz09Pdy6davCxgpks3TpUnh6eiIiIkLqYw0bNgz37t1DYGAguNzSOzwzMjLQrFkzpKSk4NmzZ2LHd5QH3t7eGDNmDIyNjeHj48MKgjFywSoQ/kO0q6kjVp2BksAhIZICH6Fv375wdnbGjx8/MHv2bAQEBCAhIQF3797Fxo0b0aBBA7x+/RozZ85EmzZtoK6ujurVq6Nfv35YtmwZfH19ER4e/k+5M8+ePYtJkyZhypQpxTYEoqOjMXHiRNjb28PW1hbAr6DBT58+VeigwZyUlWcA+BVI+PnzZ1y/fl0i8rKrEwYHB1eI6oSF4eDggKdPn4LL5ZZqN0fGvw3zDPwFBEYnouOmO1KTf2VyK0QHvoS3tzeOHz+OmJgY1KxZEwMHDoSDgwNq1qwpapuZmYkPHz6IvAf+/v548eIFfvz4AeBXOlhOD4K1tTVq1qwJPv/vWrF6/Pgx2rZti27duuHYsWPFelolItjZ2cHPzw9v375FpUqVEBYWhlq1asHJyQkbNmyQouaSY926dVi1ahXi4uKkPhYRwdLSErVq1YKPj4/E5Hp4eMDFxQUXL15Ely5dJCZXGiQnJ8PZ2RkHDhyAk5MTNm3aBHl5+fJWi1HOiDt/M2PgL2Horke4/zm22NsWFwYJsqCYFAHf6Z1F+6xnZmbi+vXr8Pb2xqlTp5CYmIh69erBwcEB9vb2MDY2ziuHCGFhYSLDINtICA4OBgDIy8vD0tJSZBzUq1cPlpaWf+z656dPn9CsWTOYmpri2rVrxd4A59ixY7C3t8fx48dhZ2cH4NemP3fv3kVAQMAf8xvcuHEjFi5ciMTEwjNVJMXmzZsxbdo0hIWFibXzozgQEbp27YqXL1/i9evX0NbWlohcaUFE2LlzJ1xcXGBubo7jx4+jWrVq5a0WoxxhxsA/RnF2LRQLIgizMpB8fA5SvoVi8eLFmDZtGmRkZERNUlNTceHCBXh7e8PX1xfp6elo2bIlBg4ciP79+xeZPvfjxw9RDEK2kfDu3TtkZWWBw+HA1NQ0lwehXr160NXVlcz1SYmYmBhRkOD9+/eLPXl8+/YN5ubmaNeuHY4dOwbgV9Bgp06dcOjQoQpbYCg/Nm/ejFmzZiE1NbVMxvvx4wcMDAywcOFCzJkzR2JyIyMjYWlpibZt28LHx+ePWKJ58eIF+vfvj5iYGOzbtw+9e/cub5UY5QQzBv5BjjwJxeyTryUmr6EwACfWTke1atUQHBwMS0tL7Ny5Ew0bNszTNiEhAWfOnIG3t7dop7UOHTrAwcEBffv2FTuYMD09He/evcvlQfD39xc9Xerp6eVZZqhRo4ZEgsZKS2pqKjp06ICgoCA8ePBA5E0pDgMGDMDNmzfx9u1b6OjoiIIG9fX1cfPmzT9iIspm+/btcHFxKbO4AQAYMWIE7ty5g6CgIIn+TZw4cQJ2dnbYs2cPRowYITG50iQ+Ph6Ojo44deoUZsyYgZUrV+Yy5hn/BswY+EfZcPkd3G99AYiAUkwc2pEP8GDnIly+fBnDhg2DnJwcVFVVERQUhMmTJ2PZsmVQUlLKt29MTAx8fHzg7e0NPz8/yMrKolu3bnBwcECPHj2K7TYXCoX48uVLnmWG7Ch1JSUlWFlZ5fIgWFhYlOl6qUAgwIABA3Dx4kXcunULjRs3LraM48ePY8CAAThy5Ajs7e0BAKtXr8b8+fPh7+9foQsM5cfOnTsxZswYCIXCMjNiHjx4gObNm+PSpUvo3LmzRGU7OjrCx8cHL1++/GNc70SEjRs3wtXVFU2bNsWRI0dQuXLl8laLUYYwY+AfZcyYMTjh/xXancdDQChWDAGPywGfy4GDKRcrR/eEg4MD9u7di9DQUNjb2+PZs2fo2rUrrl69Cj09PWzfvr3IG254eDiOHj0Kb29vPHv2DMrKyujduzccHBzQqVOnUj2pfP/+PU+gYkBAAIRCIXg8HmrVqpXLg2BtbQ0tLa0Sj1cYU6dOhbu7O06dOoVevXoVu//3799hbm6OVq1aiVzRoaGhqF27NsaNG4f169dLQWvpsm/fPowYMQKZmZllFiBKRLCyskKNGjVw8uRJicpOSEiAlZUVKleujNu3b/9RO3nev38fAwYMQEZGBg4fPgwbG5vyVolRRog9f5MYxMfHEwCKj48XpzmjnDh06BABoF27dlFobDIN2fmQTGb7UrW558lktm+Br+zzQ3Y+pNDYZCIi8vb2JgA0e/ZsIiJKT0+nKVOmEADq1KkTtWnThgDQ4MGD6du3b2Lp9/HjR1q6dCnVrl2bAJCmpiaNHTuWbt68SQKBQCKfQXJyMj169Ii2b99O48aNo6ZNm5KioiLhV10mMjIyop49e9KCBQvo5MmT9PnzZxIKhaUac+PGjQSAtmzZUmIZ9vb2pKmpSVFRUaJj/fr1I319/T/2d3fw4EECQCkpKWU6roeHB/F4PIqIiJC4bD8/P+JyubRixQqJy5Y23759o06dOhGHw6HFixdTVlZWeavEKAPEnb+ZMfCXEBAQQMrKyjRkyJBck9vHqARadOYNtVh9lYxdz+U2BFzPUet1N2jRmTcUGJ2QR+aGDRsIALm7u4uOnTx5ktTU1Khq1aq0aNEi0tTUJC0tLdq3b5/Yk6pQKCR/f39ydXUlExMTAkAGBgY0depUevz4cakn59/Jysqi9+/fk7e3N7m6ulKnTp2oUqVKIgNBTU2N2rRpQ5MnT6Y9e/aQv78/paeniyXbx8eHOBwOzZo1q8T6+fj4EAA6fPiw6Njly5cJAB06dKjEcsubo0ePEgBKSMj7tyVNfv78SQoKCrRs2TKpyJ87dy7x+Xx6+vSpVORLk6ysLFqyZAlxOBzq1KmT2IY848+FGQP/EKmpqWRlZUU1a9akxMTEfNs8fvyYODLy5HP9IT0PiaNxc5aTUdUaRcqePn06cTgcOnbsmOjYp0+fqEGDBiQrK0urVq0iBwcHAkAdO3akT58+FUt3oVBI9+7do4kTJ5KOjg4BoOrVq9O8efPozZs3xZJV3HEjIyPp/PnztGLFCurfvz+ZmpqKDAQZGRmytramESNG0H///Ue3b9+mnz9/5pJx7949kpOTo4EDB5bYs/H9+3fS0dGhPn36iIygtLQ0MjMzozZt2kjcMCpLTpw4QQAoNja2zMd2dHQkExMTqTz9pqenU/369alWrVqUnJwscfllwZUrV6hSpUpUuXJlunfvXnmrw5AizBj4hxg3bhzJy8vTy5cvC2xz7NixXDfmvXv3EoAib2YCgYAGDRpEsrKydPPmTdHxtLQ0mjhxIgGgAQMGkI+PDxkbG5OCggKtXbuWMjMzi30dmZmZdPXqVRo5ciSpqakRALK0tKSVK1fS58+fiy2vJCQkJNDdu3fJw8ODRo0aJTJ6so2EatWqka2tLU2aNIlUVFSoSZMmlJqaWuLxHBwcSENDg75+/So6tnLlSuLxeFI1hsqCs2fPEgCKjo4u87EfPnxIAOjChQtSkf/u3TuSl5enCRMmSEV+WRAeHk4tWrQgPp9P69ev/6MNT0bBMGPgHyHbFevp6Vlou3Xr1pGysrLoB3/v3j0CQK9evSpyjPT0dLKxsSE1NbU87Y8dO0YqKipkampK9+/fpylTphCXy6V69erRs2fPSnxdaWlpdPr0abK3tycFBQUCQE2bNqX//vsv18RZFmRkZNCrV69o//79NG3aNGrRogVxuVyRgaClpUUdOnSgGTNm0MGDB+nNmzdiGUMnT54kAHTw4EHRsZCQEFJUVKRp06ZJ85LKhAsXLhAACg8PL/OxhUIhWVlZUe/evaU2xubNmwkAXbx4UWpjSJuMjAyaMWMGAaC+ffvSjx8/ylslhoRhxsA/QGBgIKmoqNDAgQOLtOonTJhAFhYWovffv38nAOTj4yPWWPHx8WRtbU0GBgYUEhKS69zHjx/J2tqa5OTkaMeOHfTo0SOqW7cucblcmj59OiUlJRX/4nKQmJhIhw4doh49epCMjAxxuVxq3749eXl5UVxcXKlkF5ekpCRq1KgR6enp0b179+j06dO0ePFi6tOnD1WpUkVkIMjLy1OjRo1ozJgxtHXrVrp//36uJZyYmBjS1dWlXr165fru/vSgwZxcuXKFAFBwcHC5jL9161bi8XhSM0aEQiF16dKF9PT06Pv371IZo6w4ffo0qampUbVq1ej58+flrQ5DgjBj4C8nLS2N6tevTzVq1BDre+nevTv16NFD9F4oFJK6ujqtXLlS7DG/fv1KVatWpdq1a+dZB05NTSUnJydRhkFcXBytWrWK5OXlqWrVqnT58mXxL64QYmNjycvLi9q3b08cDodkZGSoZ8+edPjw4VIbHUWRlZVFvXr1IiUlpQK9HnFxcXTz5k3auHEjDRs2jOrWrUt8Pp8AEIfDoZo1a5K9vT1ZW1uTsrJyrqWd7KDBnIGEfzI3b94kABQUFFQu48fHx5OSkhItWbJEamNERkaSlpYW9e3b9493s3/69Inq1atHcnJy5Onp+cdfD+MXzBj4y5k4cSLJysqKbcVbWFjQxIkTcx1r3LgxOTo6FmvcgIAA0tbWpubNm+ebMnb48GFSUlKiWrVq0evXrykwMJDat29PAGjo0KESfYKKjIykTZs2UZMmTQgAKSoq0sCBA+nMmTOUlpYmsXGIfhlP48ePJx6PV+x16LS0NHr27Bnt2rWLXFxcqE6dOiIPAgDS09OjTp06kaamJtWpU4c+fPggsVTL8sTPz48A0Pv378tNh9GjR5ORkZFU0+iyAyV3794ttTHKipxG/dChQ6VuYDOkDzMG/mKybz4eHh5itRcKhaSsrEzr1q3LdXzIkCHUokWLYo//8OFDUlRUpN69e+e7Nv7+/XuysLAgBQUF2r17NwmFQtq9ezdpaGiQtrY2HThwQOJPHZ8+faIVK1aQpaUlASB1dXUaOXIkXb16VSITwZo1awgAeXl5lUpObGws6enpUffu3SkwMJB8fHxo3rx5VLNmzVwGgpKSEjVv3pzGjx9PO3bsoCdPnpQqULE8yA7ie/36dbnp8PjxYwJAvr6+Uh3H0dGRlJWVi51NU1E5ePAgKSoqkrm5ebkac4zSw4yBv5TPnz+Tmpoa2dnZiT2hxsTEEAA6fvx4ruNLliwhHR2dEunh6+tLPB6PnJyc8tUjOTmZRo4cSQBoxIgRlJycTFFRUTRw4EACQJ07d5ZahsCbN29o3rx5VK1aNQJAurq65OLiQvfv3y+REZJdgGn+/Pml1m3o0KGkrq6eqyBOSEgIKSgo0PTp0yk6OpquXLlCa9eupUGDBlHt2rVFwYo8Ho/Mzc1pyJAh5ObmRteuXaOYmJhS6yQtnj59SgDKdQ1aKBRSvXr1qGfPnlIdJyEhgapWrUotWrQoUSZNReTt27dUu3ZtUlJS+muWrv5FmDHwF5Kenk6NGjWiqlWr5sl5L4xnz54RAHry5Emu49mTXEkjiHfv3k0AaOnSpQW22bdvn+gJ4927d0REdP78eTIyMiJFRUVyc3OT2s1TKBTSo0ePaMqUKaSvr08AqEqVKjR79mx6+fKlWIbBrVu3SFZWloYOHVpqb0Z2qt3evXtzHe/Xrx8ZGBgUWJxH3KqKCxculFhVRUnw8uVLAkCPHz8uVz22b99OXC6XQkNDpTrO3bt3icvl0vLly6U6TlmSmJhIgwcPJgDk7Ows8eU3hvRhxsBfyNSpU0lGRibPpF4U2csKv1cbyzYSSnOzXr58eZHu8+wnDEVFRTpw4AAR/XqSmjRpEnE4HGrQoIHUnx6zsrLoxo0bNHbsWNLU1CQAVLt2bVq6dCkFBgYWqLe6ujp16NBB7IqEBREXF0f6+vrUrVu3XBP1pUuXShQ0mLOq4qxZsyRaVVFSvH37lgCUe1GbhIQEUlZWpkWLFkl9rOzqhMX9jVZkhEIhbdu2jWRlZalhw4ZlVvODIRmYMfCXcebMGQJAmzZtKnbf9evXk6KiYp6nxYSEhFKXvM0ZWHfu3LkC2yUlJdHQoUMJAI0ePVoUfPjw4UOytLQkHo9HM2fOLJOKbunp6eTr60uDBw8mJSUlAkANGzak9evXi9LQIiMjydjYmCwsLIrlhSmI4cOHk5qaWq40t7S0NDI1NaW2bdtK5Ek+v6qKNWrUyFNV0dHRscCqipLk48ePBIBu374ttTHEZezYsVS5cmWpu/DT09OpQYMGVLNmzT+2OmFBPH36lKpWrUrq6up09uzZ8laHISbMGPiLCA4OJg0NjVwla4vDpEmTqE6dOvme09PTK/UTU1ZWFvXt25cUFBTowYMHBbYTCoW0c+dOkpeXp7p161JAQAAR/Sp8smLFCpKTk6Nq1arR1atXS6VPcUhOTqajR49Snz59SFZWljgcDrVs2ZKMjIxIX19fIq5lX1/ffKPNV6xYQXw+X+qVBrOrKm7evLnQqopLly6lc+fOUVhYmESMk8+fPxMAunbtmgSuonRke8HOnDkj9bHev39PCgoKNH78eKmPVdbExcVR7969CQDNmjXrr4mP+JthxsBfQkZGBjVt2pRMTExKXGCnV69e1LVr13zPtWrVihwcHEqjIhERpaSkUMuWLUlLS4s+fPhQaNuXL1+SmZkZKSsr05EjR0THAwICqG3btgSAhg0bVubBcT9+/CAvLy/S1tYWBex169aNDhw4UOLNdn78+EEGBgbUpUuXXBNszqDB8uD3qort2rUjDQ0NkYGgra1NNjY2xa6qmJPQ0FACQJcuXZLSVRSPBg0aULdu3cpkLA8PD6mWQy5PhEIhrVu3jng8HrVq1Uoqu0MyJAczBv4SZs6cSXw+v9An7qKoW7cuOTs753tu1KhR1LBhwxLLzklcXBzVqVOHTExMKDIystC2CQkJog2OnJ2dRWlz2d4DdXV10tbWpoMHD5ZZMJxQKKTRo0cTn8+nY8eOkYeHB7Vo0UJUUdDOzo5OnDhRrBQ/R0dHUlVVzeNhsLW1LTRosDwQCoUUEhKSq6pi9q6S4lRV/J2vX7+WSVqfuOzYsYM4HE6eCprS4G+qTlgQfn5+ZGBgQDo6OnT9+vXyVodRAMwY+AvIdi//Xh+guKipqdGaNWvyPbdmzRpSVVWV2IQbGhpKlStXJisrqyLXo4VCIW3fvp3k5OSoXr16uSrVff36lQYMGEAAqEuXLvTlyxeJ6FcYy5YtyzfaPzg4mNasWUPW1tYEgFRVVWn48OF06dKlQp+Ws2vz79y5M9fx7KBBb29vqVyHpBG3quKqVavo4sWLFBUVRUT/K3l96tSp8r2A/ycxMZFUVFRowYIFZTJednXCki7v/QlER0eTjY0NcblcWrZs2V9RLOtvgxkDfzhhYWGkpaVF3bt3L9UP7MePHwQglzs+J9mb5WTfwCXB69evSV1dndq3by9WKtLz58+pevXqpKqqmmevhHPnzpGhoSEpKirShg0bpFZJbt++fQSgyNK179+/p0WLFpGZmRkBoEqVKtH48ePpzp07ub6nnz9/UuXKlalTp065JoLsoMF27dr90RPE71UVW7ZsSSoqKrmqKnbo0IEA0NSpUykgIKBCTBTjxo0jAwODMlvrzv597dq1q0zGKw+ysrJo4cKFxOFwqEuXLn+tJ+RPhRkDfzCZmZnUsmVLMjQ0LPW6+YsXLwgAPXz4MN/zb968IQDk5+dXqnF+5/bt2yQnJ0cDBw4UaxL4+fMn2dnZEQCaNGlSrjS4hIQEcnFxIQ6HQw0bNiR/f3+J6nrt2jXi8/k0atQosSdooVBIz549oxkzZpChoaEo33/GjBn07NkzGjlyJKmoqORxSZdV0GB5IBAIKCgoSFRVsXPnzgVWVfTy8iqXqorZv4ey9Fb8bdUJC+Ly5cukra1NhoaGdP/+/fJWh/H/MGPgD2bu3LnE4/Ho7t27pZZ1+vTpQp/8U1NTicPhSOXJxcfHhzgcDk2dOlWs9kKhkDZv3kwyMjLUqFGjPEsDDx48IAsLC+LxeOTq6prv3ghERElpmfQm4ic9D4mjNxE/KSmt4KfAV69ekaqqKnXu3JkyMjLEvracCAQCunPnDjk7O4uCDwFQjx49cgVTBgcHk4KCAs2YMaNE4/xppKeni8pmZ1dVdHBwKPeqio0bN6YuXbpIdYycJCQkULVq1ah58+Z/ffR9WFgYNW/enPh8Pm3cuPGP9n79LTBj4A/l8uXLxOFwaNWqVRKRt2nTJpKXly/0R2liYkKzZ8+WyHi/kx1V7ebmJnafJ0+eUJUqVUhdXZ1Onz6d61x6ejotW7aMZGVlqXr16qK0tY9RCbTozBtqvfYGVZntSyY5XlVm+1LrtTdo0Zk39DHqfwF7YWFhVLlyZbK2tpZYIF9MTAxpa2uTvr4+KSsrEwCqV68erV27lrp06VLhggaliUAgKNBFnpycTA8fPsxVVVFBQaFMqiru2rWLOBxOmcShZHPv3r2/rjphQWRkZNC0adMIAPXr10+qtSwYRcOMgT+QiIgIqlSpEnXp0kVi66tTpkyhmjVrFtqmY8eOZGtrK5Hx8mPu3LnFLm6UM5952rRpeZ7aP3z4QK1btya+mi5ZT91JJrN9qdrc87mMgN9f2eeH7HxIb0OiqW7dumRsbCzR1KixY8eSsrIyBQcHU2pqKp04cYLs7OxIRkaGAJCZmRl5eHhQdHS0xMasyHC5XPL09BSrbVlVVUxKSiJVVVWaN29esfuWhnnz5v111QkL48SJE6Sqqko1atSQ+NIeQ3zEnb85REQogoSEBKipqSE+Ph6qqqpFNWeUAIFAABsbG3z8+BH+/v6oVKmSROTa2toiJSUFly5dKrDNhAkTcOfOHbx+/VoiY/4OEWHkyJE4dOgQLly4ABsbG7H7bdq0CbNmzUKjRo1w9OhRGBkZic57PwrBgjOvkSkQgsPlia0Pj8uBMCsTyXf24ObOFTA3Ny/2NeXHtWvX0LFjR2zfvh1OTk6i4+np6ahTpw7k5ORgYmKCa9eugYjQoUMHODg4oG/fvlBTU5OIDhUNOTk5bNiwARMmTChRfyJCVFQUXrx4AX9/f/j7++PFixcICgoCAMjIyMDc3Bz16tWDtbU1rK2tYWVlVeTnOWHCBJw8eRKhoaGQkZEpkW7FJTMzE82aNUNSUhKeP38ORUXFMhm3PAkKCkL//v3x4cMHeHh4YOTIkeBwOOWt1j+FuPM3twx1YhTC0qVLcefOHXh7e0vMEACA4OBgmJiYFNrGzMwMQUFBEAqFEhs3JxwOBzt27ICNjQ369u2LFy9eiN1v6tSp8PPzQ0REBKytrXHhwgUAgMfNQMw5/QZZxCmWIQAAAiFByOFBse0Y3PwmW+zryY/ExESMGjUK7du3x9ixY3OdW79+PUJDQ+Hj44OLFy/i69ev2LJlC9LT0zFy5Ejo6urC1tYWx44dQ0pKikT0qSjw+XxkZWWVuD+Hw4G+vj66deuGuXPn4tixYwgMDERCQgLu3r2LDRs2oEGDBnj16hVmzpyJNm3aQF1dHdWrV0e/fv2wbNky+Pr6Ijw8HDmfe5ycnBAVFYVz585J4jLFQkZGBgcPHkRoaChmzpxZZuOWJzVq1MD9+/cxdOhQjB49Go6Ojn/d3/jfAvMMVACuX7+Ojh07YunSpZg/f75EZWtqamLmzJmYM2dOgW0uXryIbt26ISQkBMbGxhIdPydJSUlo3749QkND8eDBA1StWlXsvnFxcRg+fDh8fX1h57oBTzhmEtNrja0l7BuV7rqdnZ1x4MABvHnzBlWqVBEdDwkJQe3atTFhwgSsW7cuT7/w8HAcO3YM3t7eePr0KZSVldG7d284ODigU6dOZfbUKi3U1dWxYMECTJ8+XepjZWZm4sOHDyLvQbYn4cePHwAAbW1tkffA2toa69atg46ODq5cuSJ13XKydetWTJgwAefPn0e3bt3KdOzy5MCBAxg3bhyqVasGHx8f1KxZs7xV+icQd/5mxkA5ExUVBWtra1hYWODy5cvg8Yr3lFsY2d/b4cOH4eDgUGC7oKAgmJqa4urVq2K78EvK9+/f0bx5c3A4HNy7d69YXhChUIiFa/7DgVgTcPiyQD7uxsy4CPz0O4j08HcQpiaBp1oJSnXaQLVJX3Bl5POVK8fn4trUNjDSLJnb9vr167CxscHWrVvh7Oyc65ytrS0ePXqEDx8+QEVFpVA5gYGBOHLkCLy9vfH+/XtoamrCzs4ODg4OaNWqlUT/NsoKbW1tzJgxA7Nnzy6X8YkIYWFheZYZQkJCRG0sLS3RtGlT0VJD3bp1oaSkJFWdunfvjufPn+P169cS9QRWdN6+fQs7OzuEh4dj586dsLe3L2+V/nrYMsEfgEAgwJAhQwAAhw4dkvjNPvuGV9QyQZUqVcDn8xEYGCjR8fOjUqVKuHz5MuLj49GjRw8kJyeL3ZfL5SJEpzl4snL5GgJZCd8RtW8a0iMCoFK/BzRsxkCuci3E3z2EmDN5n8pF/YSEuadKFi+RvTzQrl27XHECAHDp0iWcOnUKGzZsKNIQAABTU1MsWLAAb9++hb+/P8aOHYvLly+jXbt2MDY2xrRp0/D48WOIYb9XGGRkZEq1TFBaOBwOjI2N0bt3byxatAinTp1CcHAw4uLicPHiRcjLy4OI8OjRI0yaNAnNmzeHiooKatWqhYEDB2L16tW4fPkyoqOjJarT7t27IRAIMHbs2D/q+ywt5ubmePLkCXr27ImBAwfCxcUF6enp5a0WAwC/vBX4l1m1ahVu3LiBq1evQldXV+Lyg4ODASCX2zo/+Hw+qlevjo8fP0pch/yoVq0aLly4gLZt22LAgAE4ffq0WO7wwOhE+AXFFHg++c1NCNOToT9kLWQr/TKAVKy7ACRE8psbEKQlgSevnKefQEjwC4pB0LdE1NApetLOyezZsxETE4ObN2+Cy/2fbZ2eng4XFxe0b98eAwYMKJZMDocDKysrWFlZYeXKlXj48CG8vb1x+PBhbNy4EdWrV8fAgQPh4OAgseBHacHn85GZmVneauRBQ0MDXbp0wejRo3Hs2DGEhYWBiESGWLYH4cKFC0hMTAQA6OnpwdraOlewYo0aNXJ97+Kip6cHLy8v9O3bF3v27MHIkSMlfYkVFmVlZRw6dAitWrXClClT8OjRIxw/frzIhxaGdGGegXLi9u3bWLRoERYsWIAOHTpIZYyQkBDIyspCT0+vyLampqZl4hnIpkGDBjh58iSuXLmCcePGifV0dOhRKHjcgiORhRm/ApN4Suq5jvOUNQEOFxxuwbYvj8vBwYeh4in//9y8eRNbt27FmjVr8sQ/uLm5ITg4GJs3by5V9DSHw0GzZs3g7u6O8PBwXL16FW3atIGHhwcsLCxQt25drFq1Cl++fCnxGNKkvD0DReHk5IRv377h7NmzkJOTQ/369TFy5Ei4u7vDz88PP3/+RFBQEI4fP45Ro0aBx+Nh//79sLe3R82aNaGqqooWLVpgwoQJ2LlzJ54+fYq0tDSxxu7Tpw9GjhyJSZMm4dOnT1K+0ooFh8OBs7Mz7t27h+/fv6NevXo4f/58eav1T8NiBsqB79+/w9raGmZmZrh27ZrU1oJnzJiBM2fOiDXJT58+HefOnSsz70A2Bw8exNChQzF//nwsW7as0LZt1t1ESFzBkcipn5/h27FFUKjRBOqtBoOroIL0iPeIveQBZcuO0LQZU6h8Ey1F3J7RTiy9k5KSULduXRgbG+PGjRu5ng6zgwYnTpyItWvXiiWvuKSnp+PSpUs4cuQIzp49i5SUFDRt2hQDBw7EgAEDoK+vL5Vxi4uZmRn69Okjtc9BErRo0QKKioq4evWq2H2+ffuGly9f5gpWDAgIgFAoBI/HQ61atXJ5EKytraGlpZVHTmJiIqytraGrq4s7d+6Az//3nLU/fvzA8OHDce7cOcyePRvLli37Jz8HaSHu/M0+8TJGKBRi6NChyMzMlEqcQE6Cg4OLXCLIxtTUFJ8/f0ZmZmaZRrAPGTIEX79+xaxZs2BgYJAnAC+bpPQshBZiCACAQrUGUGs1BAkPjuNr0CPRcdXm9tBoPbRIXUJjU5CcngUluaJ/FnPmzEF0dDSuXr2ax008depUaGpqYsGCBUXKKSlycnLo3bs3evfujaSkJJw7dw7e3t6YOXMmpk2bhrZt28LBwQH9+vWDhoaG1PQojOT0LHC1jPFNoIi3kfGooqUk1mdb1jg5OWH48OEICgpCjRo1xOqjo6ODjh07omPHjqJjKSkpeP36da5lhhMnTiA1NRUAYGRklGeZoUqVKjhw4ABatWqF1atXSzyb6E9AQ0MDp0+fhpubG+bOnYsHDx7A29u7whi0/wrMM1DGrF69GnPnzsWlS5fQqVMnqY7VqFEjWFtbw8vLq8i2N27cQIcOHfDx40eYmppKVa/fISJMnToV7u7u8PHxga2tbZ42byPj0X3z3SJlJb25ieS3N6FYszl4CqpI+fQEya+uQaPjWKg26Flk//MuLWFuUHjBmtu3b6Nt27Zwd3eHi4tLrnPZaZpHjhwpl0jpuLg4nDx5Et7e3rh58yb4fD66dOkCBwcH9OrVS6pR8sCvuI5Dj0JxM+AbQuNSkPPmwgFgrKmIdjV1MLiJMUx1ixefIS1SU1NRuXJljBkzBmvWrJGobIFAgMDAwDzZDN+/fwcAqKmpwdraGqmpqXj69Cn279+P/v37Q1ZWMvUv/jTu3LmDgQMHQigUwtvbG+3aieepYxQMSy2sgNy9exdt27aFq6srVqxYIfXxKlWqhClTpmDevHlFtg0PD4eRkRF8fX3RvXt3qev2O0KhEA4ODjhz5gyuXr2KVq1a5Tr/IvQH+m67X6iM5He3EXvBHQZjPcFX1RYdjzm/CSkf/FB5/B7wFAr/+z3l3Bz1jAt+kk5OTkbdunVRuXJl3Lp1K0/QoIWFBYyNjXHt2rVyr7T29etXHDt2DEeOHMHDhw+hqKiIXr16wcHBAZ07d4acnJzExgqLS8HcU6/hFxQDHpcDgbDg20r2+VY1tLGyr2WJUzolyZQpU3D48GGEh4dLfSImInz9+jWXcfDixQtR3ACfz4eFhUWxqyr+LURHR2PQoEG4desWli1bhtmzZ5coSJPxC2YMVDBiY2NFbsHsJzZpkpycDGVlZRw4cECUvlgYQqEQysrKWLFiBaZOnSpV3QoiPT0dXbt2xYsXL3D37t1ckfLieAaiDroCJITe0NxphCkB9/H91EroDFwOhSrWhcr4fmAajFW4MDIygqGhYZ7Xli1bsH//frx+/TqPS3nFihVYvHgxXr16hdq1axfv4qXMly9fRDUMXr9+DXV1ddja2sLBwQHt2rUr1XLVkSehWHT2LbKEVKgR8Ds8Lgd8LgdLepljYCmLPpWWd+/ewdzcHEePHi129oekeP78OZo3b45GjRqhZs2a8Pf3x+vXr5GRkQHgVxZOtnGQbShUrly53I1OaSAQCLB48WIsX74c3bp1w/79+/ONuWAUDTMGKhBCoRC9evXCw4cP4e/vD0NDQ6mPmX1z8/PzQ8uWLcXqY2VlhRYtWmDr1q1S1q5g4uPj0bp1a8TFxeHBgweizyo5PQsWiy+jsD/WiB1O4MorQ3/Y+lzHk9/7IebMGugMWAKFag0KFkCEiP8GQlleBlZWVkhPT0d4eDgiIyNzlWqWkZFBlSpVchkJCgoKWL58OQYOHIh169ZBW1u7wj7NvH37Ft7e3vD29sbnz5+hq6uLAQMGwMHBAU2bNi3W5OJxMxBuV0ofdDqjkxkmtivb5anfadWqFWRlZXH9+vVy02Hbtm0YP368qDphcasq1qtXD2ZmZn9NAN6lS5cwZMgQKCkp4dixY2jSpEl5q/THwYyBCoSbmxtmzpxZpuVHL1y4gO7duyMsLExs46N///748eMHrl27JmXtCicyMhLNmzeHsrIy/Pz8RAFwrdfeQOiP1AL7fTu+BKnBL2AwagtkNCv/7/iJ5UgNeozK4/eAr1Lw04WJliK2d9fDmDFjcO/ePYwePRpr166FiooKgoOD0bZtW6ioqMDJyQkREREIDw8XvUJCQnKlR8rKyqJy5cr5eheyX7q6uuVaVZCI8OTJExw5cgRHjx5FZGQkqlSpIqphYGlpWahhcORJKGaflNzmVpIoC10asjNbyiNuJhsiQo8ePfDs2bMCqxMSEUJDQ0WGwe9VFeXl5WFpaZlrmUHaVRWlSVhYGAYMGIBnz57Bzc0NLi4uf6U3RFowY6CC8PDhQ7Rq1QpTp04t0/SqrVu3YvLkyUhLSxN7wpk7d65oI5Xy5sOHD2jRogUsLCywY8cO7N+/H/tep4BXu12BGxOlhb5BtPdccBVUodKg+68AwqDHSPv8DMpWnaDVdVKB4/G4HAxtYoLFvcwhFAqxY8cOuLq6QkFBAZs3b8a9e/fg6emJV69e5ZkosoMGPT090aBBg1xGQnh4OMLCwkT/z1ltjcfjwcDAoFCDQV9fv0yyOwQCAfz8/ODt7Q0fHx/ExcWhdu3acHBwgIODQ54lkbC4FNhsvI3UlGQkPDqJ9MgAZHz9CGFaErS6TYFy3dxlrdMjA5D0+joyIgOQ8T0YEApgMts3V5vSloUuLWlpaahcuTJGjhyZ7z4SZUVUVBQsLS3RokULnDp1SuyJ78ePH3j58mUuD8K7d++QlZUFDocDMzOzPMsM0ih2Jg0yMjLg6uqKTZs2oX///ti5c2ex56Lk9CwExyYjI0sIWT63wma3SBpmDFQAfvz4gXr16sHAwAC3b98u05Q9V1dX+Pj4FKuYyd69e0W7iikoKEhRu6IRCoXYtGkTZs6cCaFQCFVVVdiOGI+bioUveaRHBuDn3cPIjP4MQWoi+Oq6ULboANWm/Yrc3fDa1Na5KhBGRETAxcUFp06dAgAsXLgQS5YsydUnLS0NFhYWoq2JC7txExFiY2PzGAu/Gw45d3XjcrnQ09Mr1GAwMDCQaDBgRkYGrl69Cm9vb5w+fRrJyclo2LAhHBwcYG9vj8qVK2Porke4/zkW6XFRiNg+CjzVSuCr6yE99HW+xsBPv0OIf3AcsjpVIMxIRVZcRB5jgMfloHk1LRwYVX6u4GnTpuHAgQMIDw+X6GdaXE6fPo2+ffti586dGDVqVInlpKWl4d27d7k8CC9fvsxVVTGnB6FevXqoXr16hV3iOnHiBBwdHaGnpwcfHx/UrVu30PZ/YnaLpGHGQDlDROjbty/u3LkDf39/qe4GmB/29vaIiYkp1vrnvXv30LJlS7x69QqWlpZS1K5gYmJisHv3bnh6euLz58+oWrUqgoODMXr0aHh6emLY7se4/zm2WIFqRUGCLKSHvcZggx+YP39+rrz8lJQU1KhRAzExMZCVlcXq1avh7Ows8rYsX74cS5YskVjQIBEhPj6+UIMhPDwc8fHxufrp6OgUajBUrlwZiorFf+JOSUmBr68vjhw5gvPnzyMzMxNNO/dFpPWv8rmUlQlhWhJ4yhpI/xqIqH1T8zUGBMk/wJFVBFdGDnFXtiHx+fk8xkA2vxtlZcmHDx9Qu3btIjf3KgtGjx6NI0eO4OXLl6hevbrE5AqFQnz58iVPumNkZCQAQElJCVZWVrk8CBYWFpCXz3+jr7ImMDAQdnZ2+PjxI7Zu3QpHR8c8bf707BZJwoyBcua///7DlClTcObMGfTq1avMx2/SpAnMzc2xe/dusft8//4dOjo6OHHiRL65/tKCiPDgwQNs27YNx48fBwAMGDAA48ePR5MmTbBz506MHTsWK1euxBCnybDZeBvpWcIipIoPlwQI2z4WgoRvUFZWxuLFizFhwgTIyclh+vTp2Lp1K/z8/LBr1y5s374dTZs2hZeXF5SVlVG7dm1MmjRJ4vnpRZGYmJgnbuH3V2xsbK4+mpqahRoMhoaGhW6oFB8fj1OnTmGTXwR+aFvm8bQUZgzkpDBjIOdyTXnRpk0bcDgc3Lp1q9x0AP5XnVBHRwd+fn5SDwrMrqqY00jIWVWxdu3auTwIVlZW5Rbhn5qaChcXF+zatQuOjo7w8PAQGbt/Q3aLJGHGQDny5MkTtGjRAhMnTsSGDRvKRQc9PT2MHz8eCxcuFLsPEUFTUxOurq5lsuVsUlISDh06hG3btuHly5eoVq0axo0bB0dHR2hra+dqu2TJEixevBh79uyBvHl7iQeu1ZSJw5gxY/D06VNwOBwYGhrC0dERS5cuhZubG6ZPnw4A8PPzw9ixY/Hp0ydUq1YNiYmJCAgIgLJy3g2QypvU1NQiDYbfd+NTVVUt0mDovdM/32qQkjAGgOKVhZYGhw8fxuDBg/HhwwfUrFmz3PQAgAcPHqBly5ZYvHixVCtaFkR+VRVfvXpVZFXFsgrw27dvH5ydnVGjRg34+PjgSgTnr8lukRTMGCgnfv78ifr160NbWxt3794tl0piqampUFRUxL59+zBs2LBi9W3cuDEsLCyK5VEoLm/fvsW2bduwf/9+JCcno0ePHhg/fjw6duxY4FolEcHJyQm7d+/GuXPn8Em+Ril/9ASAg5mdamJCu1/BcUKhEPv378e0adOQkJAAgUAARUVFnDx5Ep07dxb1TE9Ph6Ojo6hk6pEjR9C6detS6FJ+ZGRkIDIyslCD4evXr6LUSo6sAoymHsv3Zi8pY4AD4M3izuUW3JWeno7KlStj+PDhWL9+fdEdpMzChQuxcuVK3L9/H40bNy5vdcSuqpjTSKhdu7bU7oWvX7+GnZ0d4tRrQan9WInJLe/sFknBjIFygIjQv39/XLt2DS9evMizk11Zkb3ueevWLbRp06ZYfYcMGYKQkBD4+flJVKeMjAycOnUKW7duxZ07d6Cjo4MxY8Zg7NixYsdTZGVloV+/frh27Rpu3ryJzxw9LDr7FukZmUARwYG5ICFIkIVZHapgQpd6eU7/+PEDHTp0wIsXLyAvL4+0tDR07twZa9asgZWVlShosFKlSuBwOHjw4AHGjBmDtWvXQl1dXXw9/hCysrIQFRWF8PBwPPoYgY3v8187lpQxAAD/ddWDRWV1KCoqil5lGYA7Y8YM7NmzBxEREeW+Vp6ZmYkWLVrg58+fePHiRYVMEcyvqqK/vz+CgoIA/Eq1NTc3z1UTQZJVFd+HfUM3jwcQcnh5DNUY341IflNw7FTlCXvBV9HOc7y8s1skBduoqBzYunUrTpw4gRMnTpSbIQD82qAIgNibFOXEzMysWLu3FUVoaCh27NiBnTt3Ijo6Gm3atMGRI0fQt2/fYj8p8Pl8eHt7w8bGBt27d8f9+/exo48xBqw7CYWq9YsMFAIJAQ4XTatq4OHmKTh4VwZjO9zJM8l8+PABL1++xJQpU/Dw4UM8fPgQ9+/fR7169TB06FBUqlQJoaGh8PX1hZmZGbZv347Zs2fj3Llz8PDwgK2t7V+VB83n80VLBHIGP7DxfeFloSXBgIGDkPE1t+eHx+PlMg4UFBRyvRf3WFFtZGVlMXbsWKxfvx4nTpzA4MGDpX69hSEjI4MDBw6gXr16mDFjBrZt21au+uQHh8OBgYEBDAwMctVSSUxMFO3umG0kHDp0KE9VxZzLDCWpqrjyyhdw+TKgfH7/KvW6QD5P5VFC3OUt4Kvp5msIAECWkDD31OtyzW4pS5gxICGeP3+OadOmYeLEiWUafJcfISEh4PF4qFy5ctGNf8PU1BTfvn1DfHx8ia12oVCIK1euYNu2bfD19YWSkhKGDx+OcePG5SoxXBIUFRVx7tw5tGzZEp07d4a1tTW+nTqFlVv2IN2wEW5+/IbQ2LwpROr8TIQ+ugzfTbPQrE5VPLTyQKtWrbBgwQKsXr1a1DY1NRWOjo5o1KgR3NzcwOFwsH//fsycORMZGRk4ceIEkpOT0bhxY+jp6YHL5WL8+PHo1asXJk6cCDs7O/Tu3Rtbtmwp0edfUcnKysLHjx9x/cErANKP9N+/Zzd0ZDOQkpKClJQUpKamiv6f3/vsY7Gxsfm2SU5OhkAgEGtsLpcLBQUFyMjIYNSoUVixYoXEDI2cx+Tl5cWe9GrWrIkNGzbA2dkZPXr0KJf9Q0qCiooKWrZsmasKan5VFTds2FDiqoqB0YnwC4opUAe5yrUhVzl3pk9a2FtQZjqU6rQtsJ9ASPALikHQt8Ryy24pS5gxIAESEhJgb28PCwsLuLm5lbc6CA4OhqGhYYmij83MzAD8St9p2LBhsfrGxMRgz5492L59Oz5//gwrKyts27YNgwYNkmiAnZaWFi5duoSmTZvi1KlTkJeXxxRHeygoKGAxzPMtLpKZmgR9fQf4+VZFszqz0LRpU6xYsQKurq5o166dKCZg8eLFCA4OxosXL0TpgyNGjEDv3r2xYMECbNmyBRwOB69evUK1atUwf/58TJgwAYaGhjh16hROnjyJiRMnonbt2li9ejXGjRtXYXO2CyIxMRGvXr2Cv7+/6Knu9evXSEtLA0dGHkbTjkvV88EB0KNtE4nHDGRmZhZoROT3/uHDhzh69CgaNWoERUXFXG3i4+MLlJP91FvkdXI4IkNBHCNCXl4epqamsLe3x7x586Crqyt2v4r0NygjIwNLS0tYWlpi6NBfW4vnV1Xx+PHjovtpYVUVDz0KLdor+BvJ724D4ECpTuHLqDwuBwcfhpZrdktZwWIGSgkRYdCgQTh//jyeP38u9n7o0sTBwQFfv34tUWpU9nd96NAhDBo0qMj2RIRHjx5h69atOHbsGIhIlBZY3Dr3xWX8+PHYtm0bDA0N8enTpyKXHQYPHoxnz57h/fv34HA4EAqF6NatG54/f46XL18iNDQUzZs3x4oVK/LNpsgu8WxmZoaPHz+iRo0a+PLlC4yMjLB8+XI4ODiAy+Xi58+fcHV1xY4dO9C8eXN4eXmhTp060voYSgwRISIiItekn3OdV0ZGBnXq1Mn1lFa3bl303fUSIX9xNkE26enpMDQ0xJAhQ7Bx40ax+2VlZYkMA3E9GuK2SUpKQlRUlOjvV1zk5eUl5tEo6L2CgoLEy2uLU1WReixGuoz4T+4kyEK4xzDIaBlCb0jRVWEryt9jSWEBhGXEjh074OTkVK67nf1O8+bNYWZmhr1795aov56eHpydnbFo0aIC2yQlJeHw4cPYtm0b/P39UbVqVVFaYH711CVNRkYGdHR0EB8fDxkZGQwYMAD79+8v9Ano+vXrsLGxwb1799C8eXMAv3KrraysULt2bXz9+hXKysp48OBBHq9KdtBglSpVcPnyZezfvx+zZs1CSkoKqlWrhjdv3qBevXpYt24dOnToAODX3uxjx47F58+fMWfOHMydO7fcqtplZmYiICAg15OXv7+/qBaBurp6rkm/sAjwxWff4sCjENGTWMKzcxCmJUOQFIekFxegaNYcMrrVAACqDXqCK6+ErPhvSHpzAwCQ+ukJMiIDoNbq126afDUdKFu0B1Ax6gzkZNasWdi5cyciIiLKvSpnNmfOnEGfPn3g6emJwYMHF8vQKImBkp1GKA5ycnJSMTRyHuNyufj48SP8/f3x5MUrXFSyAYrx0JES9BjffZZCs9N4qNQveq+Y8s5uKS0sgLAMePXqFSZPnoxx48ZVGEMA+LVM0LFjxxL3z37yzY93796J0gKTkpLQvXt3rFy5Ep07dy5TV+TRo0cRHx+Ppk2bYurUqRg4cCAMDAwK3f+hXbt2MDExwe7du0XGgI6ODg4ePAgbGxvweDz4+/vnu7yybt06UdAgj8eDo6Mj+vTpgwULFmDbtm2oWrUqMjIyYGNjgy5dumDNmjVo3bo1/P39sXLlSqxatQrHjh2Dl5eX2LtIlpT4+HiRmz/79ebNG5H7umrVqrC2tsakSZNEUd3GxsZie3Hs6uli74Ng0fuER6cgSPgmep/y8T7w8VeQobJ5u1/GwM8oxPsdzK3n/7+XM7IQGQMCIWFI04qTzjV27FisW7cOPj4+Ipd2edO7d2+MHj0a06ZNQ/v27aXujRQKhUhPT5eIofHz5098/fq1wH5iPJsC+OW1UlRUhGJlM8j2Kt69LvndbYDLh2Jt8X6HBCA4NhnmBpLJfKioMM9ACUlKSkLDhg0hJyeHR48elXv6UTZpaWlQUFDA7t278y3TKQ6jRo3Cq1ev8OTJEwC/nsJPnz6NrVu34vbt29DR0cHo0aMxduxYmJiYSFJ9sSAi1K5dGwEBATh+/Djs7Ozg7u6OyZMnY+PGjZgyZUqBfZcsWQI3NzeRFwD4VSSqcePG4HK5uHPnDlq0aJGrT3BwMGrXro3JkyfnCjbM5vnz55gwYYJoU6qIiAh8+fIFw4YNw9KlS2FsbIw3b95gzJgxePjwIZycnLBmzZpSp1UREcLCwnJN+i9fvsTnz58B/ErnsrCwEE342W7+0qQ/nj9/HpMnT0ZSoxFQMLECcSRnAFaEvQnyw8bGBmlpabh79255qyIiKSkJ1tbWonomf8OWxUQkMjqKMjR+/vyJb9++IehHFh6ri58+LcxIRfjmIZA3rgud/gV7Pn/nlHNz1DPWKLphBYR5BqQIEcHZ2Rnh4eF49uxZhTEEgF/bfQIlSyvMxszMDCdOnEBoaCi8vLzg5eWF6OhotG7dGt7e3rC1tS2XYkrZ3Lp1CwEBAdDU1ETv3r0BAJMmTUJERASmTp0KfX192Nvb59t3xIgRWLJkCXx8fDBixAikp6djxIgRqF+/PhQUFODg4AB/f39oamqK+kyZMgXa2tqYP39+vjLr16+Pe/fuYe/evXB1dUVaWhr69euHixcv4siRI5g8eTLmzJmDu3fvYtu2bZgzZw7Onj0rSkMUh4yMDLx//z7XpJ9zX3tNTU3Uq1cPffr0Ebn5a9WqJbHc/M+fP2Py5Mnw9fVFx44dMXdabzidDZdYWWgigjArCzPbirfddlni5OSEAQMG4O3bt6XOhpEUysrKOHDgAFq2bImVK1cWq9JoRSUzMxMxMTGIiopCdHQ0oqKiRK+c76Ojo5GQkAAAkNGpCoOR4hsDKR8f/soiMG9bLN1k+RUnAFNaMGOgBOzZswcHDx7EwYMHy71c6e9k1xgo6RO7UChEcnIy4uPjUbVqVSgpKWHYsGEYN24cLCwsJKhpyVm7dq0opS/nZLdq1SpERkZi2LBh0NHRQbt2eYN+TExMYGNjg927d2PEiBFYunQpAgMD8ezZM9G6+ciRI0Vbx54/fx5nzpzBsWPHCs2I4HK5GDlyZK6lg1q1aqFbt27w8PDAzp07MW/ePEyYMAG9e/fGhAkT0K9fP/Tt2xceHh4wMDAQycoOmsoZ1Pf27VtkZmYCAKpXrw5ra2tMmzatVLnZ4pCamorVq1djzZo10NHRgY+Pj6iOwhKoSawsNIfDQarfPvQ6OhknTpxAgwYNJCJXEvTu3Rs6Ojrw9PSEu7t7easjolmzZpg/fz6WLl2KLl26VIjqhL8jEAhEE3x+k3rOCT8uLi5P/0qVKkFXVxd6enowMTERpfRmv1Q1K8H+eDjEzSNIfncLHFkFKJiK733iAKiiVfEKPUkatkxQTN6+fYtGjRph0KBB2LlzZ3mrkwcvLy+MGzcOqampxXp6j42NFaUFZm97PGPGDCxcuLDQzWvKmoCAANSqVQscDgchISEwMjLKdT4jIwM9e/bEw4cPcefOHVhZWeWRceTIETg4OMDHxwf29vZYvHix6Kn/7Nmz6N27N9zd3TFmzBiYm5ujWrVquHLlSrEm25xLB7a2tlBSUsLhw4dhZGSEFStWwN7eHidOnMCECROQnJyM9u3bg8fj4eXLlwgJCQHwKxjL0tIyV1CfpaVlmfwGiQhnzpzB1KlTERkZiZkzZ2LOnDl5qt953AyUSC34mZ1qomd1WfTr1w+vX7/Gli1bSrV1r6SZPXs2PD09ERERUaLdH6VFeVQnJCL8+PGjwEk95/vv37/nyXpQV1cXTfDZr5zvs/9fqVIlsTxbbdbdzDe75XcEKfEI9xgGpdqtod1zutjXy7IJSiDsbyc5ORmNGjUCj8fDo0ePKtRNIZv58+dj//79CA0NLbJtdlrgtm3bcPToUVE55VGjRqF9+/alijuQFuPGjcOuXbvQpUsXnDt3Lt82iYmJaNeuHSIjI3H//v08SyZpaWnQ19cHn8+HkZERHj16lOumM3nyZGzfvh0jR47Erl278OrVK9SqVavYugqFQtHSQXp6Ovr16yd60ldWVgYRITk5WdReXV0dtra26NChA6ytrQsttCJNAgMDMWnSJFy6dAldu3bFf//9B1PTgjdtKe0ucUt7mYtqwKelpWHy5MnYsWMHxowZA3d39wqxDPfp0yfUqFEDe/fuxfDhw8tbnVx8/PhRVB1z+/btJZJBREhMTCzwyf33/2d7qbJRVFSEvr5+vpN6zve6uroS/z5/z24piIRn5/Djqid0BiyBQjXxPE8VLbulJLCYASng4uKCkJAQPH36tEIaAsCvZYKilgiSk5Ph7e2NrVu3ivZQWLJkCUaOHClKCzQ2Ni4wo6C8iI2Nxd69e5GVlYXx48cX2E5FRQXnz59H8+bN0aVLF9y7dy/XVqvy8vKoUaMGnj59isuXL+d5+li7di1u3LgBT09PTJ48udiGQGxsbC4Xf6VKlfDhwwdRqmelSpUgFAoRGxuLBg0aYPXq1eDz+XBycsLBgwdhbGyMfv36lbkhkJycjJUrV8LNzQ0GBgY4ffo0evXqVaRHZGAjY7Sorl3s/eObV9PKs3+8vLw8PD090aRJE4wfPx4vXryAj49PuQSq5qR69ero2LEjPD09K5wxYGZmhvXr14uqE/bo0UN0LjU1tVDXfM73v6cQysrK5prU69WrV+BTfHnu2jmwkWGu7JaCSH57C1xF9XxKExdMRctukSbMGBCTAwcOYM+ePdi7dy9q165ddIdyIjg4uMB9Ed6/fy9KC0xISED37t2xfPlydO7cOU+xEDMzMwQGBpaFymLj6emJzMxMGBsb59pFMD90dXVx6dIltGjRAj179sS1a9dEBtzz58/x/PlzAMDXr1/z9JWTk4OOjg7evn2LqKgoEFG+E6JQKMSXL1/yBPVlB3EqKCigbt26aN26NVxcXCAvL4+tW7fi6dOnGDx4MNq1a4c1a9agU6dOGDZsGHx9fbFv3z4sX74cR48ehZeXV57MBmlARDhx4gSmTZuGb9++Yc6cOXB1dS1WXr2RpiIOjGqCwOhEHHoUij2XHwMqlXJ9bhwAxlqKaGemgyFNjQst8Tpy5EhYW1vD1tYWDRo0gLe3d6nSZSWBk5MT7Ozs8Pr1a1haWpabHhkZGfj27VuuiTw2NhZVqlSBnZ0d6tevj9jYWERFRYkC7bLh8XjQ0dERTeQ1a9ZEmzZt8n2KV1dXr/B7bNy4cQPTpk1Daq1+UKhiDRSS3aI/rHg7UGZnt/wLpYgBtkwgFh8+fEDDhg1hZ2dX4kI+ZYWRkRFGjBiBZcuWAfi1ppidFnjr1i1UqlRJlBZYWMbBhAkT4Ofnh1evXpWR5oWTnp4OY2NjxMbGisoIi8OTJ0/Qtm1bdOjQASdPnoRQKETDhg3B5XJBRKhRowZOnDiRq8/58+fRo0cPTJo0Ce7u7tizZw8GDhyIN2/e5Jr0X758icTERAC/CjXlTOGztraGqalpHiNLKBRiz549cHV1RWZmJhYtWgQZGRksX74c8fHxmDx5Mnr16oXp06fj0aNHcHZ2xqpVqyS2u9vvvH//HpMmTcK1a9fQs2dPbNq0CdWqVSuVzJ8/f0JDQwMcGXkcvXADNcxqicpCF7dwS2xsLAYPHowrV65g+fLlmD17drmV1s02RPv16wcPDw+Jys4OtBPnKT67UFROtLW1oa2tjU+fPkFHRwf29vb5uu21tLQkXiWwPPj48SNmzpyJs2fPolmzZnBduhbTrv9AFnEkZsD8a7sWMmOgCFJTU9GkSRNkZWXhyZMnFXL70GwyMjIgLy8PLy8vdO7cGTt27ICXlxeioqLQqlUrODs7w9bWVqwqeJs2bcKcOXOQnJxcIeqa79+/H8OHDwefz0dERAR0dHTE7nvp0iX07NkTjo6O0NPTw6pVq/DkyRP4+flh2rRpiIyMFC2PpKWloVatWtDU1ISDgwO2b9+OL1++iMq/crlc1KxZM9ekb2VlBT09vWJdT1xcHObPn4/t27fDwsIC69atw/379+Hm5gZ5eXnMnTsXHA4HixYtgqqqKrZs2YI+ffoUa4zCSExMxLJly7Bx40aYmJjgv//+k9jmN35+fmjdujUAICoqCrq6uqWSJxAIsGTJEixbtgy9evXCvn37ym2r6Hnz5sHDwwORkZFF3guyA+2KSpOLiorCt2/f8gTaqampFRpgl/3KGWiXHQCbHXPxtxEXF4elS5eKNgJbs2YNevXqBScnJ5x6GQ2tbpMkNtYaW0tRLMufDDMGJMTYsWNx4MABPHnypMKk1hVEYGAgzMzM0KJFCzx48ACKioqitMDiujWz6/CHhobmidgva4gI1tbWCAoKQu/evXH48OFiy9i3bx9GjBgBLpeLBQsWYPHixfj+/TsqV64MBwcHGBoawt/fH35+fqKnfSUlJZibm+Pjx49QVlbGoUOH0LBhQ4nGizx79gwTJkzAo0ePMHToUEyfPh3btm3Dzp07YWRkhGnTpuHy5cs4f/48bG1tsXnz5lxpiMWFiHDkyBHMmDEDP378wNy5czFjxgyJBnVt2bIFkyZNgoyMDFJSUiRmTPr6+mLIkCGoVKkSTp48WS6u+s+fP6N69epYtWoVWrZsWeQkn1+gXWEBdjn/X9LvZMyYMfD29oa/v3+F2CtFEmRmZmLr1q1YsmQJMjMzMXfuXEyZMgXx8fHo27cvXrx4gd27d+MNVcbhN0kAUbFKFP/OzE41MaHd3/HZMWNAAnh7e2PQoEHw8vLC6NGjy1udAskOrNu4cSMiIiJQs2ZNTJkyBYMHDy5xWmBQUBBMTU1x7do1Ua398uLGjRsiHW7fvi166iwOP3/+RI0aNRAbG4tWrVohKysLr169EkXzGxgYwMzMDH5+fujZsyfWrl2L6tWrg8vl4tWrV2jcuDFGjRqFLVu2SPTagLxLB0uXLkWHDh2wYMECnD59GvXr10fXrl3h5eWF9PR0rFmzBmPGjCn2JPvmzRu4uLjg1q1bsLW1xYYNG6QSmOfk5IRTp05BTU1N4nEnnz59gq2tLYKCguDl5SXWZlrikB1oV9hTfPb7lJTcaWwyMjJFpsllv8oi0O5vqk5IRDh37hxmzpyJoKAgjBo1CsuWLYOuri5evHiBXr16QSAQ4PTp0zAyMkLjxo2h3qAbMiz7SCS75W9A7PmbxCA+Pp4AUHx8vDjN/woCAgJIWVmZBg0aREKhsLzVyYNQKKRHjx7R8OHDSV5enmRlZalJkyYEgFJTU0stPzMzk/h8Pm3dulUC2paO7t27k6qqKpmbm4v1XURFRdGlS5do9erVNHDgQKpVqxZxOBwCIPq3TZs2tG7dOlq5ciUBoEePHlGvXr3I0NCQkpKS8sjctm0bASAfHx9pXCIREcXGxtK4ceOIw+FQ3bp16c6dO+Tn50dNmzYlANShQwfq06cPAaBWrVrR+/fvxZL78+dPmjp1KvF4PDIzM6PLly9L7RqIiJo2bUomJibUvn17qchPTk6mIUOGEABycXGh9PT0fNtlZGRQeHg4PX36lM6fP0+7du2iFStWkIuLCw0YMIBat25NZmZmpKamRvhVgl704nK5pKenR9bW1tSlSxcaPnw4ubq60saNG2natGkEgE6ePElxcXEV8v7w4MED4vF4tHjx4vJWpcT4+/tT+/btCQDZ2NjQy5cvRed8fHxIUVGRGjRoQOHh4ZSamkpNmjQhAwMDioiIoNDYZBqy8yGZzPalanPPk8ls3wJf2eeH7HxIobHJ5XjF0kHc+ZsZA/mQmppKVlZWZGZmRgkJCeWtTi6SkpLIy8uL6tevTwCoSpUqtGrVKoqOjqYFCxaQgYGBxMYyMzOjqVOnSkxeSfjw4YPo5rx58+Zc57Kysuj9+/fk7e1Nrq6u1KVLF9LT0xPd0FVUVKhly5Y0cOBA4nK5NGrUKEpMTCQ7OzuSl5ene/fuUVZWFhkaGlKXLl0IAB0/fjxfPYRCIdnZ2ZGamhp9+fJFqtf85MkTaty4MQGgoUOHUmRkJPn4+JCpqSlxOBzq3LkzmZiYkKysLC1durTAyVAoFNL+/ftJV1eXlJSUaPXq1QW2lRQCgYCUlJTI2NiYRowYIXH5WVlZFB0dTf7+/jRx4kTi8XhUpUoVGjt2LA0ePJg6dOhA5ubmpKWllWeCB0BaWlpkbm5OHTp0oMGDB9O0adNo7dq1tH//frp8+TK9fPmSoqOjKSsrq0AdMjIySF9fn5ydnSV+fZJk4cKFxOPx6OHDh+WtSrH4+vUrjRo1ijgcDtWsWZPOnTsnMriEQiEtWbKEAJC9vT0lJyeTUCikoUOHkry8PD1+/DiXrI9RCbTozBtqve4GVfndEHA9R63X3aBFZ95QYHTFus9LEmYMlAJnZ2eSk5Mjf3//8lZFxPv372nSpEmkpqZGHA6HunfvTr6+vrluWsOGDaPmzZtLbMzu3btT9+7dJSavJIwbN46UlJRIUVGRrly5Qtu2bSMnJydq0qQJKSgoiG7yRkZG1LNnT5o/fz75+PhQUFAQCQQCysjIIGtra7K0tBRNhKmpqdS6dWvS1NSkd+/e0ezZs4nD4VD79u0Lfcr78eMHValShZo2bUoZGRlSvW6BQEBeXl6kpaVFqqqq9N9//1FKSgpt2bKFKlWqRPLy8tS0aVPi8Xhkbm5O9+/fz9Xf39+fWrZsSQBowIABFBYWJlV9swkMDBRNugsXLhSrj1AopLi4OHr37h3duHGDvL29aePGjeTq6krDhw+nLl26kLW1Nenp6RGPx8szwXM4HOLxeFS3bl0aMGAAubi40IoVK2jXrl10/vx5evr0KYWHh0v0O5s/fz6pqKhQYmKixGRKmoyMDGrcuDGZmprm6+2qaKSkpNCKFStIWVmZNDU1yd3dPdd3lpycTAMGDCAAtGzZMtFvde3atQSADh8+XKj8pLRMehPxk56HxFGvYeOpZdsOUr2eigIzBkrI0aNHCQBt27atvFWhjIwMOn78OLVr144AUKVKlWj27Nn0+fPnfNu3bt2aBg0aJLHxp06dSqamphKTJw5CoZAiIiLowoULNG/ePOJyucTlckU3fj6fT3Xr1qWhQ4fS+vXr6fr16xQTE1OgvKVLlxKPx6OnT5/mOv7jxw+ysLAgY2NjGj16NAGgtWvXFqnfgwcPiM/nk6ura6mvVRxiYmJyLR34+flRQkICLVy4kBQVFUlNTY2MjIwIAE2YMIFCQkLIxcWFuFwu1a5dm65du1YmemZz4sQJ0QTt4eFBgYGB5OfnR8ePHycPDw+aP38+jR49mnr27EmNGjUiIyMjkpWVzTPBKygoUNWqValZs2bUt29fcnZ2psWLF9P27dvp9OnT9ODBA/ry5QulpKRQVFQUtW3blng8Hm3YsKFM3PbBwcHE4XDIy8tL6mOVho8fP5KioiI5OTmVtyoFIhQK6dChQ2RkZER8Pp+mTp1KcXFxudqEh4dTgwYNSFFRkU6cOCE67uvrSxwOh+bOnVusMefNm0eGhoYS0b+iw4yBEhAUFESqqqo0YMCAcl0HDAsLo4ULF5K+vj4BoBYtWtChQ4coLS2t0H7GxsY0Z84ciemxbds24vP5UnsKzszMpLdv39KhQ4do5syZ1LFjR6pUqZJoQpCTkxOt8S9cuJCeP39e5GeQk5cvX5KMjAzNmzcv3/NhYWGkp6dHHA6HjIyMqF27dmLJXbNmDQGgS5cuia1LaXny5Ak1atSIANCwYcMoKiqKIiMjycnJiXg8HmlqahKPxyMOh0Py8vLk5uYmle8tNTWVgoOD6eHDh3T69Gny9PSkJUuWkLOzM/Xt25cMDQ1zGW85XzIyMmRkZEQNGzakHj160OjRo2nevHm0efNmOn78OPn5+dHHjx8pISGh2L+/zMxMmjFjhsgTUhZP7F27dqWGDRtKfZzSsn37dgJAZ8+eLW9V8nD//n1RrFOfPn3o48ePedo8evSI9PX1ycjIiF68eCE6/vbtW1JRUaHevXuTQCAo1rg7d+4kDodTrPvJnwozBopJWloaNWjQgKpXr14u1ykQCOjKlSvUt29f4vF4pKysTM7OzrmCZgojMzOTeDweeXp6Skyna9euEYB8f6DFJSEhge7evUseHh40evRoatiwIcnLy4smChMTE+rduzctWrSITp06RR8+fCA9PT0yMjKiRo0aFXu8jIwMql+/Ppmbmxf6g2/btq1obRIAffr0qUjZAoGAOnfuTJUqVaLIyMhi61ZSfl86cHd3p8zMTPLx8SENDQ3RhAuA7OzsxNYtIyODIiIi6NmzZ6JAu5UrV9KkSZNowIAB1KZNG6pZs2aRgXadO3cmY2Nj0tXVJQC0bt06unHjBr19+5ZiY2PLxMA+fvw4KSsrU506dejDhw9SHev06dMEgJ49eybVcUqLUCikHj16kI6ODkVHR5e3OkT0y7Nib29PAMja2ppu3LiRb7tDhw6RnJwcNWvWjKKiokTHY2JiqHr16mRhYVGiuK7r169L7N5W0WHGQDGZNGkSycrKlvkPOzY2ltavX0+mpqYEgCwsLGjr1q3F/gP/8uULAZBopHhoaCgBoPPnz4vdRygUUlhYGJ07d46WLVtG/fr1oxo1auR6OrS2tqYRI0bQpk2b6NatW3lcgkREe/fuFbmbd+/eXWzdly9fTjwej548eVJgm3PnzonWH+Xk5Ar1IvxOdHQ06enpUYcOHQoNNpMGMTEx5OTkRBwORxQoZ2lpSZs3bxZlHsjKypKioiItXLiQLl26RPv376d169bR9OnTRYF2FhYWpK2tXWigXfv27WnQoEGiQLt9+/aJAu2ioqLyXHv16tVFwZjltU797t07qlWrFqmoqORyKUuazMxMqly5coV2wWcTFRVFlSpVop49e5ar1zM+Pp7mzJlDcnJypKenR7t378739yMQCGjOnDkiT1hOgz4jI4PatWtH2traBS6ZFsXnz58lfr+sqDBjoBicPHmSAOSJVpcmjx8/phEjRpC8vDzJyMiQg4MD+fn5lfiHevPmTQIg0achgUBACgoKtHHjxnzPZ2Rk0KtXr2j//v00bdo06tChQ64obg0NDWrXrh1NnTqV9u7dS/7+/mJFswuFQqpbty5Vq1aN1NXVKTm5eOk+r1+/JhkZmUKXTFJSUqhq1arUsWNHEgqFdOrUKQJAysrKlJmZKdY4165dIw6HQytWrCiWfiUlO9Du7du3NH36dFJQUBAto1SvXp3atWtH1tbWpK6unu8Er6qqSmZmZtS6dWvq37+/KNBu586d5OvrS0+fPqWwsLASZxwkJCQQAOrXrx9paWlJ+OqLr4udnR0BIFdXV7G/0+KycOFCUlZWrnBZR/lx9uxZAiBR76G4ZGVl0Y4dO0hHR4fk5eVpwYIFBS7lJCQkUO/evYnD4dC6devy3BPHjx9PfD6fbt26VWJ9sj2p27dvL7GMPwVmDIjJly9fSF1dnWxtbaVuMScnJ9OuXbuoQYMGItf4ypUrc7m/Skr2k3RKSooENP0flpaW5OzsTD9//qTbt2+Tu7s7jRw5kurXr58r8KtatWpka2tLS5YsoTNnzlBISEiJP89sF56amhpNnjy5WH0zMzOpQYMGVKdOnUKXBxYvXkwyMjK5jCdXV1cCQKNGjRJ7vPnz5xOPx6O7d+8WS8+cJCYmUmBgIN29e5d8fHzIw8ODFixYQGPGjBEF2hkbG+cbaCcnJ0daWlrE5/OJz+dTixYtaMGCBbRlyxYaM2YMKSsrE4fDIS6XS3PnzpVqauH9+/dFxkC9evWkNo64CIVCcnNzIx6PR+3bt5eKizw0NJS4XG65TLAlYcyYMaSoqFim7vGrV6+SpaUlAaAhQ4ZQaGhogW2/fPlClpaWpKKiQufOnctzPrvehyQ+76pVq5ZZIHB5wowBMUhPT6fGjRtTlSpV6MePH1Ib58OHDzR58mRSV1cnDodD3bp1o3PnzknUvbx48WLS09MrtRyhUEghISF05swZWrJkCRkYGORK4ZOVlaUGDRrQyJEjyd3dne7cuUM/f/6UwBX8j+7du4si5N+9e1esvitXriQul0uPHj0qsM2nT59IXl4+j+dAKBSKAhj3798v1niZmZnUsmVLMjIyotjYWNHx7EC7R48e0ZkzZ0SBduPHjydbW1tq3rw5Va9enZSUlPINtDM0NBQF2o0aNYqmTp1KzZo1Iw6HQ6ampuTt7Z0r0C7n0kHdunVFxklCQgLNnj1bFEugp6dHt2/fLtZnKi7bt28nHo9HnTt3pt69e0tljJJw8+ZN0tHRIUNDQ6nk3Pfo0YPq168vcbnSIDExkWrUqEFNmjSRmrckm/fv31OPHj1EQdCF/SaJiPz8/EhbW5uqVq1Kb968yXP+5s2bxOfzycXFRSL6tW/fnvr37y8RWRUZZgyIwbRp00hGRqbIP9KSkJGRQT4+PqIKWtra2uTq6lriNa6iGDFiBDVp0qRYfdLT08nf35/27t1LU6ZMobZt2+ZyMWtpaZGJiQmpqKjQgQMH6PXr11LPr3///j0BIDMzM2rbtm2x+r5584ZkZWWLtPZ79uxJRkZG+a5pu7m5EZfLJR6Pl2c9MTMzUxRod+HCBdq9ezetXLmSRo4cSbKysqSlpUVmZmb5uum5XC7p6uqSlZUVde7cmYYNG0azZs2iDRs20OHDh+n69ev5BtplZWXR1q1bSUNDg9TV1cnDw6NQI/Lx48fUsGFDAkDDhw8XeZ0iIyOpX79+In06d+4scSNu/PjxVKdOHTI3N6eJEydKVHZpCQ8Pp2bNmpGMjAxt27ZNol7AbPd7YfEpFYmHDx9KtTphTEwMubi4EJ/PpypVqtCxY8eK/Lx37dpFMjIy1KZNG/r+/Xue858+fSJNTU2ysbGRmBEzatSoPyIbpLQwY6AIsn/AGzZskKjc8PBwWrRoUa60wIMHD0o9haVdu3Zkb29f4Pm4uDi6efMmbdy4kYYPH05WVlaip0UAVKNGDbKzs6Ply5eTr68vhYeHk1AopN27d0tl+aEgnJycRHEHR48eFbtfZmYmNWrUiGrVqlVoOebsoMHsssICgYC+fftGr169oqtXr5KHhwdxuVxRql7jxo3JwsKCKlWqJFqfz/nS1NSkOnXqiNygbdu2pTVr1tC+ffvo0qVL5O/vn2+gnTjcv3+f6tWrJ1q6+Pbtm1j9srKyyNPTkzQ1NUlNTU2UdUD0K57CwsJC5IFYvnx5sfUqiJYtW5KDgwOpqKiIVbOhrElPT6eJEyeKDCVJ/U1nZmaSoaEhjRkzRiLyyoJFixZJvDpheno6bdiwgdTV1UlFRYVWr15dZGn0rKwsUXnnMWPG5LuMFR8fT+bm5lSjRo1c3rfSsnz58nKPbSkLmDFQCCEhIaShoUG9evWSyBOCQCCgq1evkq2tLfF4PFJSUqJx48aJnRYoCbLXv4RCIX3+/JlOnjxJCxcupN69e5OJiYlo8pKXl6dGjRrRmDFjaMuWLXTv3r1Cg5/u3r1LAOj169dSv4bv37+TvLw8NWnShHR1dYu1vr169Wricrn04MEDEgqF9OPHD3r//j3dvHmTjhw5Qps2baIZM2aQsrIyaWtrU7169UhfXz/finZ8Pp9kZWVJRUWF5OTkaOjQobR8+XLauXMnnTt3jp48eZJvoN3kyZMlkpESHR1NI0aMIADUoEGDEt+wY2JiaOzYscThcMjKyipXXMPRo0dFqYJ6enoFpnaJi1AoJFVVVVq0aBEBoCNHjpRKnjQ5cOAAKSgokLW1tVippOKwePFiUlJS+mPukdnVCWvUqFHqmgzZAbg1atQgLpdLTk5OYsVn/Pz5k7p06UJcLpfc3d3zvRdnZWVRjx49SFVVVey9OMTl0KFDBOCPCP4sDf+kMZCz3OSbiJ+UlJbXnZSRkUHNmzcnY2PjUluZcXFxtGHDBjIzMyMAZG5uTlu2bCmzzyktLY2ePXtGXl5exOFwqEaNGrlywStVqkSdOnWiWbNm0eHDh+nt27fFdrFFR0cTAKmmaGWTneKnoqKSb0WxpKQkCgoKort379KJEydoy5YttGDBArKzsyMOh0P6+vpkbGxMcnJyeSZ4eXl5UcyGjY0NjRs3jhYtWkTbtm2jU6dO0f379+nz58+UnJxMvr6+BICuXbtGZmZmVKNGDbFubmlpaVS/fn0yNTUt0Q0mMzOT3N3dSU1NjTQ1NWn79u0SiSt59OiRaOlgxIgRomsRCAQ0efJkkUHUvHlzCgkJKdEYwcHBBIC2bNlCAPKUR65ovHz5kqpXr04aGhrFSp0tiLCwMOJyuRWicqm4ZFcnHDt2bIllPH/+nNq2bUsAqFOnTmI/NAQGBlKtWrVITU2t0PQ+V1dX4nK5dOHChRLrWBAPHjwgAGX60FYe/DPGgGgjirV5N6KoMtuXWq/9tRHFx6hfN2dXV1fi8/mlulk9fvyYHB0dSUFBgWRkZGjgwIF0584dqWYjxMTE0PXr12n9+vU0dOhQsrS0JD6fL8rFB0CtW7emVatW0YULFygyMlIi+giFQlJTU6PVq1dL4CrykpaWRiEhIeTn50caGhqizXiGDBlC/fr1oxYtWhQYaMfn88nQ0JAUFRVJSUmJhg8fTnPnziV3d3c6duwY3blzhwICAig+Pp6CgoJITk5OrAqNmZmZpK+vTxMmTKDPnz+Tnp4eNWzYUKwnqI8fP5KysjINGTKkWJ//nTt3qG7dusThcMjJyanQEssl4felg82bN4sMw69fv4qqwHG5XBo7dmyxA2rPnDlDAERZLeHh4RLVXxr8+PGDevToQRwOhxYtWlTsKna/06tXL7K2tq6QuxgWhKenJwGgM2fOFKtfZGQkOTo6EofDodq1a9OFCxfEvu7r16+ThoYGmZmZFZoKfeDAAQJAbm5uxdJNXKKioggAnTp1SiryKwp/vTFQki0qu6z2Jb6abonWM7PTArOfsIyNjWnFihUSSQvMiUAgoKCgIPLx8aH58+dTjx49yNDQUDQBKioqUtOmTcnJyYm2bdtGDx48oMuXL5co8l5cGjVqRCNHjhS7fWZmJkVGRtLz589FgXarVq2iyZMnk729PbVt25Zq1apVYD68rKws1a1blzp16iQKtFu/fj0dOnSIrl+/Tm/evKGYmBgSCAS0du1a4nA4RRp3PXr0KDBoMD9mz55N6urqlJqaSs+fPycVFRXq0qWLWAGUBw8eJAC0Z8+eIttGRkaKtuNt0qSJ1IPQci4dWFtb071790TnTp8+LfpOFBQUyM3NTexYl2XLlpGGhgZt2bKF+Hx+mRdiKikCgYCWLVsmyvIpjbfw/PnzBEAqAcnSIrs6YaVKlcS6lyUnJ9PSpUtJSUmJtLS0yMPDo1hBxVu3biUej0cdO3bMt9hYNg8fPiQ5OTkaMWKE1IwroVBIioqKEo8bq2j81caA9+MQMpt/oUgj4PeX8awzVGXWaTr8MFjssQICAmjKlCkiF3PXrl3p7NmzErnZpaSk0JMnT8jLy4smTJhALVq0IGVlZdGkqKenR126dKHZs2fTkSNH6MOHD/mOu3//fgKkV/Ft0KBB1KJFC/r+/Tu9fv2arl69SgcOHCA3NzeaMWMGDRkyhGxsbMjS0rLIQLt27dqRg4MDTZ06lVavXk179+6lixcvkpmZmaj2vq+vr1h6vX//nuTk5Gj69OmFtssOFi3OUkdAQAABIG9vbyL6VWBIRkaGhg0bJtbNydHRkRQVFQtc58zIyKD169eTiooKaWtr065du0r9ZFocClo6SE5OJmdnZ9F3aGBgQIcPHy5St/79+1ObNm1o9uzZVKVKlbK4BIly6dIl0tTUpKpVq9Lz589LJCMrK4uMjY2LZThXBLKrE/bo0aPAv22BQEAHDx4kQ0NDkpGRoenTpxfLe5SRkUHjx48nADRp0qRClyvDw8NJX1+fmjdvLvXA6zp16kgsVbGiIu78zSEiQhEkJCRATU0N8fHxUFVVLaq5VPG4GQi3Kx9LLWdGJzNMbGea77msrCycPXsWW7duxfXr16GlpYVRo0bByckJ1apVK9F4379/h7+/v+j18uVLfPjwAQKBAFwuFzVr1oS1tbXoZWVlBV1dXbFkL1++HO7u7vj27VuxdCIixMfHIzo6GlFRUYiKisr1/+z3gYGBSExMzNNfRUUFenp60NXVhZ6enuiV872uri50dHQgJydXoB7Xr1+HjY0NunTpgvfv3+PTp0/g8XiF6i4QCNCyZUvExcXB398fCgoK+bZLTU2Fubk5TE1NcenSJXA4HLE/n1atWkFBQQFXrlwBAHh7e2PQoEGYM2cOVq5cWWjf5ORkNGzYELKysnj48GEu/W7evImJEyfiw4cPcHZ2xrJly6ChoSG2XpJCIBBg586dmDt3LoRCIZYvX45x48aBx+PhxYsXGDJkCN69ewcAqFevHtzc3NC+fft8ZdWqVQudO3dGTEwMwsLCcOfOnbK8FIkQHByMfv364d27d9i+fTuGDx9ebBnLli3D6tWrERkZCTU1NSloKR3OnTuHXr16wdPTE2PHjs117t69e5g2bRoeP34MW1tbrF27FtWrVxdbdlxcHPr37487d+5gy5YteeTnJCUlBW3atEF0dDSePHki9j2wpPTo0QMcDgfnzp2T6jjlidjztyQtC2nj/Tgk3yd+veEbSKV+d5LRNiaOjBzxVCuRYq2WZDDWs1BPwZHHuYOlIv6PvbOOiqp73/41M3RLGqQiFlKiYouFBXY32KJiISqI3Yqd2I/d3d0t2GJgIth0zVzvH74zX5EaYIjn+flZa9aCmX32vs/E2fe588MHTpo0iSVLliQA1qhRg5s3b842PeZ3xGIxnz17xh07dnDcuHFs3ry5bD4A1NTUZM2aNTl48GCuXr2aN2/ezHG53T/x8vJK08wnNjaWL1++5JUrV2SBdhMnTmT//v3p4eHB6tWr08LCItNAO0tLS7q4uLBVq1YcMGAA27ZtSwDcvHlzmkA7RdG8eXNWrFiR6urqcpf2nT9/PgUCQbaV/wIDA6msrMxnz57lWK5169ZRIBAwPPx/lqT58+cTkK90dUhICFVVVTl48GCSv4LMpM1ZatasmaYDW2Hy+fNn9uvXL53rICUlhfPmzaOqqqqs+mGzZs0YGhqa5vi4uDgKhUIGBwezTp067NatW2GchkJISEigp6cnAXDgwIE5vjP98OEDRSIRly1blk8S5h/9+/enhoaG7Lfy6tUrdujQgQDo5OSUq2JVjx8/prW1NfX19Xnu3Lksx0okEnbu3JkaGhq5ts7kFG9vb1aqVKlA1ios/nNugrdf42jjfzTDTV2jXE2KNItRu4o79ZsNpW6d7hRq6lGgrMYSXkszVQZs/I/yzZdYnj59mu3atZOlBfbv31+uC3VcXByvX7/OVatWcdCgQaxRo0aaQLdSpUqxRYsWnDBhAnft2sXnz5/n2hQsDbS7efMmDx48yNWrV3Pq1KkcMmQIjYyMaGBgQGtr6zRuBulDSUmJpUqVYpUqVdi8eXN6enrKAu127NjBCxcu8NmzZ/zx40eGZsJbt27lW1GVx48fEwC7du1KJSUlRkREZHvMs2fPqKamxhEjRmQ57uXLl1RVVc1xr3MpMTEx1NLS4uTJk9M8P3LkSAoEAu7atSvbOaTlU7t3705NTU2amJhw48aNRTLI7Pr167JS2X369JG5Dl69esXGjRsTgKy8cZ8+ffju3TuS//t+3Lx5kxYWFgpto11YrFmzhioqKqxWrVqW5XMzonXr1rSzsyuSn3FWSKsTVqlShaNHj6aKigpLlizJDRs25Oq6dezYMero6LBSpUpypXBOmzaNAOT6XSmKBQsWUEND41/3WeWE/5yboMfaG7j66ivEkvTiJr5/AtUS1hCIlGXPpXz7gI9rvaFZvhYM3UdnOKcABCKfI3z9KFSsWBGDBw9G9+7dMzTvffr0CSEhIWlM/c+fP4dEIoFIJEKFChXSmPjt7e1hZGSU5Tmlpqbi8+fP6czzGZnqv3//nlZ2gQBGRkYoXrw4wsLCYGVlhRYtWmRoti9WrBiEQqE8b3OG/Pz5E3p6eti6dSu6dOmS63kyYsCAAThw4AD09PRgb2+PHTt2ZDleLBbLzIghISHQ0NDIdKy7uztCQkLw5MkTaGpq5kq+vn374syZM3j58qXsPZRIJOjevTv27t2LkydPom7dupkef/LkSbRr1w6xsbHo06cPgoKCirT5WOo6GDduHEjKXAdCoRBbtmyBj48P4uPjoaSkhJSUFPj4+KBkyZIYPnw4fv78iWLFimHp0qUYOHBgYZ9Knrl16xbat2+P+Ph47NixI1MXyZ8cP34czZo1w7Vr1+Di4pLPUiqO1NRU+Pv7Y/bs2VBSUsKECRMwZsyYHP92SGLRokUYNWoUmjdvji1btmS7b+zfvx9t2rRBYGAgJk2alIezyBnSdT99+pTvLonCQt79+1+hDIRFxqDxwpz7ICPWDwcAlOizKMtxM+tooHOz+hAIBBCLxQgLC0uz6d+/fx+RkZEAfvnJpRu+dPOvVKkS1NTUAPzaKL59+5bppv77358/f8afb3+xYsUy9L3/+b+hoSGUlJQgkUigpqaGoKAgDBkyJMfvkbyYmJhg8ODBCAwMVNicX758gZmZGbp27Yp169bh3LlzqF+/fpbHLFy4ECNHjsSFCxdQp06dTMdJfaB79uxB27Ztcy3j1atXUatWLZw+fRoNGzaUPZ+cnIzmzZvj9u3buHTpEipXrpzmuLdv32LkyJHYs2cPatasifDwcJibm+PixYtQVlb+c5kix5cvXzBu3DgEBwfD0dERy5YtQ40aNfDlyxeMHDkSmzdvhqWlJSIjI0ES2trauHbtGqytrXHkyBE0b968sE9BIXz58gVdu3bFmTNnMHPmTIwZMybbuBOJRILSpUvD1dUV69evLyBJ88bJkycxatQoPHz4EPb29njw4AGuXLmSY2UmOTkZgwcPxtq1a+Hr64sZM2ZkG/8TGhqKmjVrolmzZtixY0eeblxySkhICBwcHP51iltO+E8pA5MOPsLmG28ytApkBkl8WN4byobmMOk0NdNxQgHgqBkDw7fncP/+fTx48AAJCQkAAHNzc9ldvo2NDUqUKAGRSCS7m89og4+MjERqamqaNbS0tLIMsJP+nV2gXUZ8+PABpqamOHz4MFq0aJGjY3NCnTp1YG5uji1btihszmnTpmHGjBlo0qQJnj17hsePH2d5oQ0LC4O9vT369++PhQsXZjpOGjRoY2ODY8eO5Sho8E9IokKFCqhSpUq6c4+Ojka9evXw+fNnXLt2DWZmZkhKSsK8efMwffp06OnpYf78+ejcuTNu3ryJ2rVrY9SoUZg1a1au5Slobty4gSFDhuDOnTvw9PTErFmzYGRkhJMnT2LgwIH4+PEjVFRUEBMTg5IlS+Ljx48ICQmBnZ1dYYuuMMRiMSZOnIgZM2agTZs22LBhQ7bXwenTp2P69On4+PEj9PT0CkbQXPDkyROMHj0aR48eRZ06dbBgwQI4ODigdu3a+PLlC+7fvw8tLS255vr8+TPatWuHGzduYM2aNejZs6dcx1StWhXFihXD5cuXc23Byy3SvS0/rJ5Fhf+UMlBv7jm8+Rafo2NiH57D18PzYdBsGLTsm2Q5NuX7Rygfn47ixYtDV1cXKioqEIvFae7wExMT0xyjqqqa6Qb/+/8mJib5+gW/cuUKateujQcPHsDW1jbf1vHy8sKDBw9w8+ZNhcyXlJQECwsLuLm5YevWrZg3bx6GDx+e6XiJRIJ69eohIiICISEhWb6nkyZNwowZM/Dw4UPY2NjkWdY5c+Zg4sSJiIiISBf1HxERgZo1a0JdXR2TJk3ChAkTEB4eDh8fH0ycOBHa2tqysXPnzoWvry+OHz8ONze3PMtVUIjFYqxZswbjx48HSUyfPh0DBgxAYmIiAgMDMX/+fBgaGsLQ0BBPnz6Fg4MDFixYAFdX18IWXaEcOHAAPXv2RPHixbF3715UqlQp07EREREwNzdHUFAQvL29C1BK+fjy5QsmTZqElStXwsLCAnPmzEHbtm1linNYWBgcHBzQrVs3rF69Otv5QkND4eHhgYSEBOzfvx81atTI9pjk5GQ0atQIz549w61bt2Bubp7n88oNBgYGGDVqFMaPH18o6+c3/5lsgpjElHSVBbN7lOy3ggJVDaqWKk9z3wPZ1x8Ye4gCZTUqKSmxZMmSdHJykgXajRs3josWLeKOHTt4/vx5Pn36NNNAu8KgoOprz5w5k7q6ugo77/Xr1xMAfXx8qK6unmUBEpJctGgRAWQb0SytNJjboMGM+PjxI0UiEZcvX57h69IaBPj/jYoePXqU4TixWEw3NzcaGRnx48ePCpOvoPj8+TP79u1LAHR0dOTVq1f5/v17AmDp0qUpEAiopKQkq1/QvHnzdJkH/3aeP39OW1tbampqZtt/oW3btrS1tS0y1wryVyDyvHnzqKurSx0dHc6dOzfTjInVq1fLVZ1w//791NTUpIODg9zlrCUSCfv27UsVFZU0ha8KA2dnZ3p5eRWqDPnJfyab4OGHHzlSBEy9N1NJrzhFOkYsNWSj3MddfhReoEVfFMX06dMLpPPWnj17CEDuznlZIZFIWLlyZTZv3pzm5ubs06dPluPDwsKorq4uV3GQli1b0tzcXOEFmNzd3dO1O42Pj+ekSZOopqZGY2NjqqiosFWrVlkWpIqMjGTx4sXZsGHDf02Vvj+5du0anZycZPXoATAsLIy1atWiQCCgubk5x48fT2tr63SZB/8FYmNj2bVrVwLgiBEjMq3AJ60MWtibHfnrN7dnzx6WKVOGQqGQgwYNyva3LJFI6OHhkWl1QolEwhkzZlAgELBt27Y5+s1JlXt5qnTmNx06dGCDBg0KW4x8Q979u+AiNXJJcqpE7rGSxDhE7gyEJDEOxh0nQ0nbQO5jNbR0CjRwRVGEh4fDwsIi39cpW/ZXgabnz/Ne8OnMmTN48OABatWqhbdv32LQoEGZjpVIJPDy8kKJEiUwc+bMLOc9dOgQDh8+jIULFyrcNePl5YXbt28jNDRUtlalSpUwffp0+Pj44OXLl9i7dy8OHz4Mb2/vdIGhUoyNjfHPP//g7Nmz/6rYgd9xcXHBzZs3sXz5cly6dAkAcOLECejr66NevXooV64cZsyYAScnJ0yfPh2HDx9G2bJlMW7cOPz8+bOQpc87mpqa+Oeff7B48WIsWbIEDRs2xKdPn9KNa9SoEUqXLo1Vq1YVgpT/4+7du3B1dUW7du1gY2OD0NBQLF++PNtsJ4FAgDVr1kAgEMDLyyvNdzoxMRE9evTA+PHj4e/vj127dsn9mzt16hRGjBiBkSNHonfv3nk5NYVgZWWF169fF7YYhU6R3/1UlOQTkanJiNo9BanfP8C4w0SoGObM/zRz+lQsXrwYFy5cwI8fP3IhaeHw5s0bWFpa5vs61tbWABSjDAQFBcHe3h5Xr16Fk5MTnJ2dMx27fPlyXLx4EWvXrs3yYpOQkIBhw4bBzc0NrVu3zrOMf9K8eXMYGxtjwYIFaNmyJTw8PFC2bFk8ePAAM2fOhJaWFlq0aIHVq1dj5cqVmD59eqZzNWzYEBMmTEBgYCAuX76scFkLApFIhEGDBqFp06YwNjaGt7c3Tp8+jWLFiuHEiRPYtGkTzpw5g3nz5mHKlCkYNWoUFi9ejDJlymDRokVISkoq7FPIEwKBAEOHDsX58+fx4sULODk54cqVK2nGCIVC9OvXDzt37kyXGlwQfPjwAb1794azszM+f/6M48eP4+jRo1nGOvyJsbEx1q5diyNHjshiByIiIlCvXj3s2bMH27dvx5QpU+S+kXr+/Dk6duyIJk2aYM6cObk6L0VjZWWFt2/fpgv8/r9GkVcGLA00kV0sOCVifN4/G0kfn8KotR9US1XI2SIkXty7Bl9fX9SvXx/FihWDhYUFPDw8EBAQgN27dyMsLAwSifxWioIiPDy8QJQBdXV1mJubIywsLE/zPHnyBEePHkWPHj1w9OhRDBo0KNNo/1evXmHs2LEYMmRItimH0hKwS5YsyVP2QGakpKSgdOnS2LhxI0JDQ7F3714cP34c5cqVSzPO09MTU6dORUBAANatW5fpfIGBgahRowa6du2Kb9++KVzeguL58+do164drl27huTkZOzbtw/9+vWTlZZu1qwZBg0ahBs3buDUqVNo27YtRo4ciQoVKmD79u1F8jeVE2rVqoW7d+/C2toa9evXx+LFi9PcQffp0wepqanYtGlTgckUFxeHyZMnw8bGBkeOHMHy5csREhKS66DVli1bYsCAARg5ciT27t2LqlWr4v3797h06RI6deok9zw/fvyAh4cHihcvju3bt2ebclhQWFlZQSwW4/3794UtSqFS5JUBTVUlmOtnXlgGAL6fXYuEFzegXroKxAmxiH14Ls0jOywMNHD35jXExMTg4cOH2LJlCzp37ozk5GQEBwejQ4cOsLGxgY6ODmrUqIGBAwdixYoVuHr1aoY1+wsKiUSCN2/eFIibAPjlKsirZWDhwoUoUaIEPn/+DG1t7UzTeaTuAWNj42zN6S9fvsTs2bMxZswYmTtDUZDEvn37ULFiRdy5cwcAMHPmTLRp0yZTpWPChAkYOHAg+vfvjyNHjmQ4RklJCVu3bkVcXBw8PT0zdSsUZZKSkvD06VPY2dnB1tYWYrEYvXr1wp49e1CuXDns3r0bGzduxPHjx/HixQs0atQI1tbWuHfvHmxtbdGlSxdUr14d585l/xstyhQvXhxnzpzB0KFDMXz4cHTv3h1xcXEAftXnaN26NVatWpXvn7FEIsGmTZtkbpohQ4bgxYsXGDhwIJSUlPI09/z586Gjo4MOHTqgRIkSuHXrVpYWvT9JTU1F586dERUVhYMHDxapwltWVlYA8NdVoMgAhPwi8MDDLDsUqprZZtgKV/rIrpOhaasRnDJlSqalcCMjI3ny5EnOnTuX3bt3Z+XKlamkpCSbv0yZMmzbti0nT57M/fv38/Xr1wUSQRwREZGrXuS5ZdCgQaxcuXKuj4+KiqKamhonT55MY2Njent7Zzp22bJlBMAzZ85kOadEIpEFIiqyXwL5q+yxNECuRYsWDAsLo4uLC5s1a5btsampqWzdujXV1dV5/fr1TMcdOHCAALh48WJFil4g3Lt3jwB49epVWVnpCxcuMCoqil5eXrKa9tevX2dsbCxHjhxJoVBIBwcH3r59mxcuXGC1atX+U5kH27dvp6amJm1tbfn8+XOS5KlTpwiAly5dyrd1L168KMviaN++vVzlf+VFLBYzMDCQACgQCHJVbnrEiBEUiUQ8deqUwuRSFImJiRQIBAwODi5sUfKF/0w2AUk+/xSdo4yCnD66DhxJDQ0NKisrs3Pnzrx06VK2m3liYiLv3bvHDRs2cMSIEWzQoAENDAxkCoKuri7r1KlDb29vrlmzhjdv3mR8fLxC35dr164RAENCQhQ6b2YEBQVRXV0911kXU6ZMobq6OoODgwmADx8+zHDcq1evqKmpyUGDBmU7p3Qz3bt3b65kyojY2Fj6+flRWVmZVlZWPHjwoOy11atXUygUyhUdHx8fz1q1atHAwCDLRknDhw+niooK79y5oxD5C4qNGzfK0lqPHz9OAHz9+rXs9atXr9LR0ZEA6OXlxaioKN66dYsODg4UCoUcOXIkY2JiuGvXrv9U5sHDhw9pY2NDHR0d7t+/n2KxmGXKlGH37t0VvtbLly/Zrl07AqCzs7PCFY7Y2Fi2b9+eADh9+nROmjSJIpGIV69elXuOtWvXFnmF19TUlBMmTChsMfKF/5QyQJLdg69naR3IzcPc9wBNe8zmtm3b+O3bNwYFBbFs2bIEQDs7O65evTpH6TISiYTv37/nkSNHOGPGDHbq1Inly5enUCgkAAqFQpYvX56dOnXijBkzeOTIEb5//z7XVoRt27YRAH/8+JGr43PK4cOHCSDHjVvIX93gjI2NOXDgQNavX5916tTJcJxYLKarqystLCyyrZ0QHx9PS0tLNm3aVCGWGIlEwh07dtDU1FRmwfhTgfv58yc1NDTk7q749etXVqhQgZaWlpnWFkhMTKSTkxPLli2b7/UiFMmoUaNYunRpkr8a+wgEgnRpdqmpqVy+fDn19PRYrFgxrlixggkJCZw9e7asQ+bx48eZlJTEJUuW0MjIiGpqahw3blyBfa/zg58/f7JNmzYEwPHjx3PmzJlUVVXlly9fFDL/jx8/OGbMGKqoqLBUqVLctGmTwlOj3759S0dHR2pqasqU7ZSUFLq4uLBMmTKMiYnJdo7Lly9TWVmZ/fr1K1L1Fv6kTp067Nq1a2GLkS/855SBrLoW5vZRdsIRtuzUS9aa9fXr1xSLxTxx4gQ9PDwoFAqpq6tLHx8fmckvN8TFxfHmzZtcs2YNvb29WadOHero6MisCAYGBmzQoAFHjBjBDRs28N69e3K1Tp01axb19PRyLVdOef78uVym+4xYt24dAfDIkSMEwK1bt2Y4Ttrl7/Tp09nOOXHiRKqoqOTps5Hy+PFjNmzYkADYqlUrvnr1KtOxvXr1YpkyZeS+uL1584alSpWig4NDpr+h58+fU0tLi927dy/SF83fadSoEVu3bk2SDAgIYKlSpTIdGxUVJWsNLHUdvHjxQvaed+vWjVFRUfz58yf9/f2prq5OAwMDLly4kElJSQV1SgpFIpFw9uzZFAqFrFevHpWUlLhgwYI8zZmSksLly5fT0NCQGhoanDx5ssLdY+Qvq6OJiQnNzc15//79NK+FhYVRU1OTffv2zXKON2/e0NjYmHXr1i3yn2HPnj1Zo0aNwhYjX/jPKQMkue3mG4UqA9tv/qqWdfDgQZqZmVFDQ4Nz585lSkoKSfL169ccO3aszPzfpEkTHjhwQCHFYiQSCV+/fs39+/dz8uTJbNu2LcuUKZOm7XDlypXZvXt3zp07lydPnpS1lJUycOBAOjg45FkWeUlOTqZIJOKKFStydJy0yFDLli05fPhwGhkZZajsvH79mlpaWuzfv3+2c0orDebVtBcdHc3Ro0dTSUmJ1tbWPHr0aLbHXLhwgQB4/vx5udd58OABdXV12bBhw0wvjP/880+RKcQiD8bGxpw4cSLJXwqSPBfT310Hffv2ZVRUFDds2EB9fX0aGBjI2jt/+PCBffv2pVAoZOnSpblt27Z/ZVEwkjxz5oxs8zY3N8+1snfs2DFWrFiRAoGAvXv35vv37xUs6S82bdpEVVVV1qpVK901R0p21QljYmJob29PS0tLfv78OV/kVCSBgYEsXrx4YYuRL/wnlQGSXHL2uUIUgaVnw9LMGx0dzeHDh1MoFNLR0ZG3bt2SvZaQkMCNGzfKgp0sLCw4a9asfPmSR0dH88qVK1y+fDkHDBhAFxcXampqypSE4sWL083Njb6+vrSzs6Orq6tMeSkIypYtyxEjRuToGGkA1dGjR6mnp8exY8emGyORSNiwYUOamZll+z1TRNCgRCLhli1bWKJECaqrq3P69OlyWWOkx1pbW7Nnz545WvP8+fNUVVVlly5dMt3Y+vTpQw0NDT558iRHcxc0nz59IgDu3r2bJOnq6spOnTrJdWxqaiqXLVuWxnXw8eNHWVW/xo0bywLgHj16RHd3d5lP/OzZs/l2TvnJ27dvWb58eQLg6NGjc3Tsw4cP2bRpUwJgvXr18i22RCwWc+zYsQTA3r17Z/l7kFYnNDQ0TBd4LRaL2bZtW2ppaf1rgkKl8S/5YWUpbP6zygD5y0Jg4380xzEEpccfoY3/UZlFICN+D3AaPnx4Oh/uzZs32atXL6qqqlJVVZU9e/bkzZs38/V8xWIxnz9/zl27dtHf35/u7u40NzeXKQiqqqp0cnJinz59uHDhQp47dy7bWv+5pUWLFmzZsmWOjmnWrBkdHBy4du1aCgSCDCOdV61aRQA8ceJEtvPlNWgwNDSUdevWJQC2a9dO7nrqvzN9+nSqq6vn+Dexe/duCgQCjho1KsPXY2NjWb58edrZ2Sk84FSRnDx5kgBkLpoyZcrkeJOLjIxknz59CIBVqlThjRs3ePToUVpYWFBdXT2Nle7PzIMHDx4o/Jzym4SEBOrq6soCKhMSErIcHxUVxUGDBlEkErFMmTLcu3dvvrmQoqOj6e7uToFAwHnz5sm1TmRkJI2Njdm8efM04ydOnEiBQMD9+/fni6z5wcWLFwkg074i/2b+08oA+SuGoHvwddkmn5USYOV3iBZ+h9k9+Drffs1e80tJSeHcuXOpoaFBMzOzNNHkUj5//szZs2fT0tKSAFi1alVu2LAh2x+4opBIJFRTU+OQIUO4aNEienp6skqVKlRVVZUpCWZmZmzZsiUnTJjAnTt38tmzZ3l2cfj4+NDGxkbu8Y8ePSIAbtq0iVWrVmXTpk3TjQkPD6eWlla2Pkgyb0GDP3784PDhwykSiViuXDmePHkyR8f/zrt37ygUCrl69eocH7tkyRIC4Pz58zN8PSQkhKqqqhw8eHCu5ctv5s2bRw0NDYrFYorFYqqoqOQ6Wvzq1at0cHCgQCBg3759+fr1a/r4+FAoFNLJyUl2JyyRSLhz505ZfX1PT89/XebB3LlzKRKJqKamxipVqqTJvpCSmJjIOXPmUEdHh7q6upw/f36++txfvXpFW1tb6ujo8MiRIzk6VhpULHUd7ty5U5Z58G/i3bt3BMDDhw8XtigK5z+vDEh5/imagQcesu7cs+m6G1r6Haal9wbWGraQYZE5j9J+9eqVzDzXrl07fvjwId2Y1NRUHjx4kG5ubrJgQF9f3wx/5IokMjIyw7vjlJQUPn78mNu2baOfnx+bNWvGkiVLyhQEDQ0NVq9enf379+fSpUt56dKlHH2uy5cvp5KSktyuiX79+rFEiRKyNMg/fYwSiYSNGzemqampXNHjuQkaFIvF3LBhA42NjampqcnZs2cr5OLarFkzuri45OrYcePGyRVIKTXDFzV69uzJ6tWrk/xfvYu83AmmpqZy6dKlMtfBypUree3aNdrZ2VEkEnH06NEyE64088DQ0PBfl3nw+fNnqqiocMSIEbSysqK+vj6PHz9O8tdvYdeuXbSysqJIJKK3t3e++9svXLhAQ0NDlilTJtd3xQMHDqSGhgb37t1LdXV1dunS5V8TBCtFqtAuWbKksEVROP9nlIHfiU1M4cMPP3j3zTc+/PCDsYkpHDNmDI2NjXMdfCSRSLht2zYaGxtTR0eHy5cvz3Su58+fc8SIEdTT06NAIKC7uzuPHz+eL4FPN2/eJADevXtXrvFRUVE8ffo058+fz549e9Le3l7WdhcArays2Lp1awYGBnLv3r18+fJlhj/o06dPE/+/S508a6qqqnL69Ons27cvzczM0lkm1qxZQwA8duxYtvOFhYVRVVWV/v7+cp0z+aswTs2aNQmAnTt3Vuid5K5du3JtWpRIJOzVqxeVlZUzzJyQSCRs3749dXV1812xzA0ODg7s168fyZx/F7Pid9eBs7Mzr1y5wpkzZ1JNTY1WVlZprDk/f/7khAkT/nWZB126dKGNjQ2/fPnCZs2aUSAQcODAgaxVq5aswNXjx4/zXY7g4GAqKyvT1dU1TymPsbGxtLKyorKyMqtUqVKk3VtZUbZsWY4cObKwxVA4/yeVgYyQ+oKyqgInD1+/fpX1cq9Zs2aWPsvY2FiuWbOG9vb2BMCyZcsyKCiI379/z5MMvyM1x+UlNiApKYkhISHctGkTR40axUaNGtHIyEimIGhra7NWrVocPHgwV61axevXr/Pp06eyFMHskBYZevXqFTU0NDhlypQ0r79584ba2tr09PTMdi6JRMJmzZrRwsJCriCfb9++cciQIRQKhaxYsWK+BJ4lJSXR0NAwx75yKcnJyWzatCm1tbV57969dK9///6dlpaWdHFxybRNbmGQnJyc5i5q9+7dBKCwHHqSvHLlisx10K9fP964cYMNGjQgAPbo0SPNHfP79+/TZB5s3769SGcenD9/ngB49uxZvnnzhnZ2drLfmyKLZ2VGSkoKfXx8CIADBw7M83crISGBtra/qsAOHz5cMUIWAk2aNJGlyv6X+KsM/H9SUlJYrFixHN1NZsXFixdZvnx5Kikpcfz48VlqwRKJhJcvX2aXLl2orKxMDQ0N9uvXL13ebm6YM2cOtbW1FW6Ok0gk/PjxI48dO8ZZs2axS5curFixIkUikawcqUAgoIODA6dNm8ZDhw7x7du36eSQFhkaNGgQlyxZQpFIlKbojkQioZubG0uVKiWXkrR//34C4L59+7IcJxaLGRwcTENDQ2pra3PBggX5upH6+PjQ2Ng412vExMTQ2dmZxYsXz7C2wfXr16mkpJRhBkZh8eDBA1npYZJcsGABNTQ0FP5dlLoOdHV1qa+vzxUrVjA4OJjFihWjoaEhN2/enGbNPzMPzp07p1B5FIVEImHZsmVZqVIlqqury0pz6+npsUyZMvlaUfT79+90c3OjSCTismXL8jyfRCJhz549qaqqyn79+lEoFOaoOmFRYuDAgbS3ty9sMRTOX2XgN7p166bQDzkxMZGTJk2iiooKra2t5SqQExERwalTp7JUqVIEwFq1anHbtm25NmsOGTIkT30CckpCQgJv377NtWvX0sDAgCVLlqSenp7MiqCvr8/69etz+PDhXLdunayW+dOnT1mxYkW2a9cuzXzSEqXyWBji4uJoYWHBZs2aZbnh3Lp1i9WrVycAdu/ePdOKf4okNDRULiUlKyIjI2ltbc2yZctm6COeM2cOAch8y4XNli1b0lilfHx8WK5cuXxbLzIykr1795Zt8seOHWPnzp0JgG5ubumUqPPnz7Nq1aoyk3tRyjyQxq9Ii44NGzZMdl19+fIlHRwcqK6uzs2bNyt87WfPnrFcuXLU09NTWI+AuXPnEgC3bNmSpjrhv6mSppTZs2dTR0fnXxfvkB1/lYHfkJbtzU0Z3ax48uSJLEWtZ8+ecgX7pKSkcPfu3XR1dSUAmpiYMCAgIMcFRFq0aEF3d/fcip4n2rZty0aNGlEikfDNmzc8ePAgp06dyvbt27Ns2bIUCAQyK4KVlRUBsF+/fjx+/DgjIiL47t076ujosHfv3nKtFxAQQBUVlUzjFL58+cIBAwZQIBDQzs6OFy9eVOTpZouzs3OeP4sXL17Q2NiY1atXT1cCWywW083NjUZGRgWi4GTH2LFjaW5uLvu/bdu2bNy4cb6v+6frYOvWrTQ3N6eGhgbnzZuXJqi1KGYenD9/nk5OTrIqlyoqKpwzZ06aMXFxcezV61dVVG9vb4XFQJw6dYp6enosV66cQip2kuSRI0coEAjo5+cne+7FixfU1NSkl5eXQtYoSKSu169fvxa2KArlrzLwG9+/f6eSkhKXL1+u8LmlZulixYqlqaAmD48ePeKQIUOopaVFkUjEdu3a8ezZs3IdX6lSpSy7/uUnfn5+tLCwyPR1aR2AESNG0NrammpqatTS0pJZEVRUVKiqqkpvb29u3ryZoaGhmZrZw8LCqKKikqGbJzU1lStXrqS+vj51dXW5ePHiAi3AJGX58uXp3CC54fbt29TS0mKLFi3SnUdkZCSLFy/Ohg0bKqQCZl5o1qxZmloTzs7OBXbxT0lJ4ZIlS2Sug0WLFnHo0KEUCASsUqVKuiDGpKQkLl68uFAzD8LCwmR9CqpVq8YrV66Q/GWxtLa2ThffIJFIuGLFCiorK7NGjRp5qjQokUi4dOlSikQiurm5KSxu6fHjx9TR0aG7u3s6+aVBwXmxlhUGt27dIgDevn27sEVRKH+VgT9wdXVl8+bN823+T58+sUuXLgTAhg0byhVtL+Xnz59cunQpK1SoQACsWLEily1blqmpTSKRUEtLi/PmzVOU+DlCWjwos3iJpk2b0sHBgZ8+faKysjLnz59PsVjMFy9ecMiQIQRAFxcXWY0GqYLg4ODAXr16ccGCBTxz5gw/f/6cadDg9evXWaVKFVm1tE+fPhXEqWfI9+/fqaamxtmzZ+d5rhMnTlBJSYmenp7plMLTp09TIBBw2rRpeV4nL5QqVYrjx4+X/W9sbMzJkycXqAyfPn2SuQ6qVq3K9evXs3LlyhSJRPT19U33ffkz82DRokX5nnnw/ft3jho1isrKyjQzM+OWLVvSbJzS4ObM3IzXr1+nqakpjY2NcxX/kJyczIEDBxIAfXx8FKYof/36lWXKlGGlSpUyvEZJJBK2atUqw+qERZkvX74QAHft2lXYoiiUv8rAH8yfP5+qqqo56kKYG44dO0ZLS0uqqalx+vTpObrgSCQSnj17lu3ataNIJKK2tjaHDBmSLs1I+qUtrBz0S5cuEUCGvtjfiwzNmjWLqqqqMrPb+/fvqaurm6aM748fP3jx4kUuWbKEffv2ZdWqVamuri5TEqTV6caNG8ft27fzypUrsk3A0dGxyAQrde3aleXKlVOIv3Hz5s0EwICAgHSv+fv7UyQSKbxVrbxIv3vbt28n+SuWBCi8fgqXL1+mvb29rGCRv78/VVVVWbp06Qz94hllHijaR5ySksKlS5fSwMCAmpqanDp1aoYZMBKJhBUqVGCHDh0ynSsyMpKurq4UiURyVwYkf31O9evXp7KyMtesWZPrc/mT5ORkNmzYkAYGBhlWEpUSFRVFExOTdNUJizISiYQ6OjoKUeqLEn+VgT+QdtwriBKZsbGxHDNmDEUiEW1tbXO1Yb17947+/v40MTEhADZo0IB79uxhSkoKb9++XajmrMwKHpH/KzKUkJBAKysr2cYvkUjYokULlihRItt0yNTUVN69e5eGhoYsXbo0mzdvLgu8lD4sLCzo5eXFJUuW8OLFi4VedObMmTMEIDMB55XZs2enqewmJSUlhbVr16aZmVmh+DbPnj1LADIFNSwsjEDuOlkqij9dB1OmTGG9evUIgL169cow5fHhw4ds2bKlzLKgiMwDiUTCI0eOsEKFChQIBPT09MzWdRQUFEQlJaUsLVspKSmyngHt27fPNjjv0aNHLF26NA0NDWUZH4piyJAhVFJSkqtJl7Q6YX64Z/MLe3t7Dhw4sLDFUCh/lYEMsLGxkavkraK4d+8eq1atSoFAwEGDBuVqw0pKSuLWrVtlBUlMTU1l7ojC6gYm1aBnzZqV5nlpkaEZM2bw6NGjBMBr166R/F8jkIxKO2fE70GDly9fpoODA4FfdemnTp3K3r1709HRkSoqKjIFwdLSkq1ateLEiRO5Z88evnjxosDyzcViMS0tLeWqmSAPEolE1jjrT9/r27dvqa+vz1atWhX4XdfChQupqqoqMzlLlaCcuMXyi0+fPsmC76pWrcoJEyZQT0+PRkZG3LJlS4bvlaIyDx48eMDGjRsTAF1dXTOsG5ERX79+paqqarrfUkbs2bOH2traLF++fKZFiY4cOUJtbW3a2tpm2YY7N6xcuZIAuHLlSrmPGThwINXV1fn06VOFypJftG7dmm5uboUthkL5qwxkwKhRo1i8ePECLUiSmprKRYsWUUtLiyVKlODu3btzfQG/d+8e+/btK6sc2LVrV165cqVQzHDOzs7pNr7JkydTQ0ODX79+pYeHBx0cHGTtaPX09Ni9e3e55pYGDY4YMYI9e/aUXdxv3LiRbmxycjIfPHjAf/75h2PGjGGTJk1k1hQA1NLSYo0aNThw4ECuWLGCV69eZUxMjELegz+ZPHkyNTU1FTa/WCxmx44dqaamls4tIA3SzG0/gNzi6elJJycn2f/r168ngALrySEPv7sOevTowVatWhEAmzZtmmE1R4lEwh07dqTJPJA3aC8yMpIDBgygUChk2bJleeDAgRz/Hnv06MHSpUvLdV2SpupqaWml8W1LJBLOmzdPVvlU0al9586do5KSEocMGZKj42JjY2ljY0NnZ+ciVTgrM0aMGJGj3iv/Bv4qAxlw7tw5AkjTnrigePv2LT08PAiA7u7ueUpz7NevH01MTGhtbU0AdHBw4Jo1awq0/WaXLl1Yp04d2f/SIkODBw/mmzdvKBQKuXLlSkokErZs2ZImJiZymbWlxYiKFStGHR0dGhgYcPXq1TlW4D59+sQTJ05wzpw57NatG21tbdMUTrK2tma7du04ZcoUHjhwgOHh4XlWqsLDwykQCLhu3bo8zfM7iYmJrF+/PvX09NKVPR4+fDhVVFTyraVtRjg7O7NPnz6y/ydPnkxjY+MCW19eUlJSuHjxYuro6FBfX5/e3t4sVaoUNTQ0uGDBggwzMn7PPFBXV+f48eMzteYlJCRw1qxZ1NbWpp6eHoOCgnIdkHj58mUCkLtxVkxMDDt27EjgVzvk2NhYWRyNn5+fwrNNXr58SQMDAzZo0CBXG/rNmzeppKSksMJv+cnixYupoqJSpCtY5pS/ykAGJCcnU09PjxMnTiyU9SUSCffs2cOSJUtSU1OTCxcuzNUP18PDg82bN6dYLOaxY8fYsmVLCgQC6unpceTIkQVisg0MDKRJKXNZL4jpyzdSqKLOZ8+eMSAggNra2oyOjpYFw8kbqzF9+nTZhj1o0CCF+sUTExN59+5drl+/nj4+PnR1daW+vr7MiqCnp8e6dety6NChDA4O5q1bt3JcZ71x48asXbu2wmQmfwVZ2tnZ0czMLE2ufGJiIp2cnFi2bNkCKfKSmppKNTU1BgUFyZ7z8vKis7Nzvq+dWz59+iSzLlWpUoUdO3akQCCgs7NzppVAs8o8kFoRLC0tqaSkxGHDhuW5DLNEImGlSpXSFebK7pgFCxZQJBJRR0eHysrK3LRpU57kyIjo6Gja2tqyTJkyefotTpkyhUKhUGExNfnFoUOHCKDQa1Iokr/KQCZ06dIljZmzMPjx4wcHDx4suyjltMGLnZ1duva2r169oq+vLw0MDGQm0cOHDyv8LkHaJdJx4gGajz2Utl302EOsM+cMTVuNYPchY/jx40cWK1aMXbt2zXbeDx8+yO529PT0Ciw4UiKR8N27dzx8+DCnT5/Ojh07sly5crLCSUKhkBUqVGDnzp05c+ZMHj16lB8+fMjUiiAtcPXs2TOFyvnhwweam5vT1tY2Ta748+fPqaWlxe7du+e7u0jal+L3YMEmTZqwbdu2+bquIrh06RLt7OwoEAjYunVrli9fniKRiGPHjs1U4Xv//j29vLxkmQfTpk2TNb1yd3dXqB988eLFVFJSylEq3v3792lsbEyhUEgjIyOFZ9akpqbS3d2dOjo6eW6clJKSwho1arB06dJFujqhNBuqoAuX5Sd/lYFMkJZSzUshD0Vx9epVmflaau6TBx0dnXSVy6TEx8dzw4YNdHZ2JvCrG+GcOXPyfPfy9mscuwdfp4XfYZYefyStEvDHw9z3AC38DrOS9wqalK6Y5drJycmcN28etbS0qKGhQZFIpPCNNDfExcXxxo0bXL16NYcMGcLatWvLSsgCoKGhIRs2bMiRI0dy48aNvH//PpOSkpiQkMBixYqlqcqmKB4/fkx9fX3WrVs3jY9e+p3O7/S+HTt2EACjoqJkz5UvX54+Pj75uq6iSElJ4aJFi2Tup9atW1NFRYVlypTJMhvi1KlTsmwWdXX1fKnv8e3bN1k6sjzs27ePmpqadHR05M2bN1mzZk0qKytz2bJlClMK/fz8KBAI5CoZLg8vXryglpZWka5OGBcXRwDcuHFjYYuiMP4qA5nw9etXikSiHEXE5ifJycmyFq2WlpbZtvL9/v07AXDHjh3Zzn3jxg1ZExE1NTX27t07V/ES226+oY3/0WyVgHRKwZj9LDPuELfdfJPhvGfOnGGFChUoFArZo0cPKisrZ5hbX1SQSCR89eoV9+3bx0mTJrFNmzYsXbq0TEFQVlamnZ0dy5UrR21tbR4/fjzNxqkIrly5QjU1NbZv3z6N1adPnz7U0NDgkydPFLre70yYMIElSpSQ/S+RSGQ++H8TERERMteBnZ2drERwnz590pjCY2Ji6O/vTzU1NZqYmHD06NEyJbtFixZ8+PChQuXq1asXLS0ts/RXSyQSmSutXbt2shuIpKQkDhs2jMCvro55jR/6559/CIBz587N0zx/EhwcXOSrE5qYmHDSpEmFLYbC+KsMZEHdunXTlFMtCrx48YKNGjUiAHbu3DnTvON79+4RQIaR9ZkRFRXFmTNn0sLCggBYvXp1btq0Sa4I8CVnn+dIAcjsseTs/+qhv3v3TuYSqF27Nu/du8dmzZrR0tKyQIMgFcXPnz95+fJlLlu2jP3795e1c5U+SpQowaZNm3Ls2LHcunUrHz16lKdqcAcOHKBQKKS3t7fsLjA2Npbly5ennZ1dvvWTd3d3T5N29W+v2Hbx4kVWrlyZAoGA9erVo46ODo2NjbllyxauXbuWJUqUoKqqKsePHy8zbUtjBkqXLk2hUEgvLy+FWRmvXr1KIPOGVPHx8bK04sDAwAyVhi1btlBDQ4N2dnZ88eJFruS4ceMGVVVV2bNnz3zpitq6desiXZ3QxcWFvXr1KmwxFMZfZSAL5s6dSzU1tSK38UgkEm7evJmGhobU09PjmjVr0v3g9+3bRwCMjIzM8fypqak8cOAAmzRpIjN1+/n5MTw8PMPx226+UYgiIH1svvqSM2fOpIaGBosXLy5rQSs9p4IoCFVQ2Nvbs1GjRty5cycnTJjAli1b0szMTKYgqKmpsUqVKvT09OSiRYt4/vz5bIsx/c6qVasIgDNnzpQ9FxISQlVVVQ4aNCg/TokWFhb09fWV/X/37t0cK6ZFjd9dB8WKFaONjY3sM/Lw8Mj0t5GTzAN5kUgkrFy5Mtu0aZPutQ8fPsiqc+7cuTPLeUJDQ2ltbU1dXV0eOnQoRzK8f/+eJUqUoIuLS76li0qrE2bXhbSw+DNT6t/OX2UgC548eUIAOf6hFBSfP3+WpQrVqVMnTfDOwoULqa6unucf0bNnzzh8+HDq6upSKBSyVatWPHnypEz5ePs1jjb+R2k2chd1a3WhmpUThWq/mg0ZNPfJcLMv2XcF1aycKFBWo1BNi5qVXGk6bMv/xozZRxX9EhwxYoTsuxQXF0dzc/N/VdlSeZAGhP2ptH39+pXnzp3jwoUL2adPHzo5OVFVVVW2AZmbm9Pd3Z3+/v7ctWsXnz9/nqnZWNomesOGDbLnVqxYQUDxpap//PhBAPznn39kz+3fv58AiuwdXk64cuWKTFlTU1Ojnp6eXBk/P3784Pjx4xXW80DaVOjDhw+y527dusWSJUuyVKlScqeRfv/+XZbKHBAQIFcgcXx8PJ2dnWlqaprvn+mRI0eKbHXCCRMm0NTUtLDFUBh/lYEskEgktLa2Zv/+/QtblCw5c+YMra2tqayszMDAQCYmJtLHx4fly5dX2BqxsbFctWoV7ezsCIA2NjZcuHAhO628zNLjj7DUwLUEQJGOEVXNK2eqDJQavIFCdR0q6ZVgsUb9qVe3J4VqWlQ2tqL5mH3/P9vgIFstTNuURVpLPrcmzaLKly9fqKKiwvnz52c7NiUlhQ8fPuSWLVvo6+tLNzc3lihRQqYgaGpq0sXFhQMGDODy5ct55coVRkdHUyKRsF+/fhSJRLJYE4lEwvbt21NXVzfDAju5RdqPIjQ0VPbcfyEn+9u3bxwxYgSVlZVpbm7OwMBAmeugUqVKBH51GgwJCclynj8zD3bs2JEr5fbHjx/U0NDg1KlTSZLbt2+nmpoaq1evnuOumGKxmNOnT6dAIKCbm1uWgbwSiYRdunShurp6gdWtGDRoUJGsThgcHEyBQMDExMTCFkUh/FUGsmHEiBEsWbJkkb8bjY+P54QJE6ikpMRy5cqxdu3abNq0qcLXkUgkvHTpEjt37kw1E8v/BQGO3kdT78208DvM4r2CMlUGtBybU6CkylKD1smeM+48jQCo39Q7zdiwyF/+1+fPn1NFRaVIBw3mhY4dO7JixYq5/o5FRkby1KlTnDdvHnv06EE7OzsqKSnJlIQyZcqwTZs2LFeuHFVVVblv3z5KJBJ+//6dlpaWdHFxUVjVt2XLllFZWTnNXe+YMWNYpkwZhcxf0CQnJ3Px4sXU19enlpYWZ8yYIYu1SElJ4cKFC6mjo0NdXV2WLFmSIpGI48aNyzYe48+eB/LU8P8TT09PmpmZcfz48QTAbt265clkf+LECRoYGNDS0jLTjV4alJidC0KRxMXFFcnqhNIS28+fP89+8L+Av8pANkg/8IKs3pYXHj58KMtxLl++fL42qRm97QYt/Q6l2/CzUgaEGnrUKF873fNK+qWoZmEv+7/0+CMMPPCQEomETZs2/dcGDcrD8ePHFe5TT0pK4v3797lx40aOHDmSDRs2pKGhYZryy7Vr12b79u1lWRqKeH/79+9POzu7NM916tSJrq6ueZ67IJFIJDx06JCslkTfvn0zNYlHRESwR48eBH71BFFSUqK1tTXPnj2b7Trnzp2T9Txo2bJljjIPpJVSBQIBZ86cqZAblvDwcDo7O1NVVTVdhUypu6cwirHdunWryFUnfPXqFQHwxIkThS2KQpB3/xbi/yh16tSBjo4ODh06VNiiyEWlSpVw6dIlaGhoIDw8HBUqVMDWrVtBUuFr3XwXB0Ig9/jUmC+QxP+ASnHrdK+plrBBcuQr2f9iCXHueRQOHDiA48ePY9GiRdDQ0FCI3EWNRo0awczMDOvWrVPYnCoqKrC3t0fPnj0xf/58nD59GlFRUXjw4AFKlSoFFRUVGBoa4tGjRyCJzZs3Q1tbG+XLl0enTp0wY8YMHDlyBO/fv8/Rdyc0NBR2dnZpnnv79i3Mzc0Vdm75TWhoKJo0aQJ3d3eYmpri3r17WLNmDYoXL57h+OLFi2PTpk24cOECihUrBrFYjLi4ODRo0ABeXl749u1bpmvVr18fN27cwI4dO/D48WPY2dmhb9+++PDhQ5Yyvn37Fj4+PhAKhahatSr8/PwgEMj/W8wMCwsLXLp0CT179oSnpycGDBiApKQkPHjwAN26dUO7du0QGBiY53VyirOzMwIDAzFjxgxcvXq1wNfPCDMzM4hEIrx69Sr7wf8h/s8qA8rKymjatCkOHz5c2KLITUxMDOLj47FgwQLUq1cP3bp1Q7NmzfD69WuFrRGblIq33+JzdIw49jsAQKSln+41kVYxSBJjwNQU2XNvv8Zj+ChftGjRAu7u7nkTuAgjEonQu3dvbNu2DfHxOXtPc4JAIICtrS2uXLkCVVVVvHv3Djdu3EBMTAxcXFygoaGBWrVq4dOnT5gzZw5atmwJMzMzGBkZoUGDBhgxYgQ2bNiAe/fuISkpKd38EokEDx48yFAZMDMzy7fzUhSRkZHo378/HB0d8e7dOxw6dAinTp2Cvb29XMfXrVsXd+/eRVBQEGJjY6GlpYVt27ahfPny2LlzZ6ZKlUAgQMeOHfHkyRMEBQXhwIEDKFu2LCZMmICfP3+mG3/16lVUrVoVP378gJ+fH+7cuZOt8pAT1NTUsHr1agQHB2Pjxo2oUaMGmjdvDmtra2zcuBFCYeFsB35+fqhevTp69OiBmJiYQpHhd5SUlGBmZqbQ6+q/gf+zygAAuLu74/bt2/j48WNhiyIXb968AQA4ODhg586dOHToEB4/foxKlSph7ty5SElJyWYGOdb4Goec2hqY+msDEYiU070mEKmkGQP8smd/TRZi0aJFCrnrKcr07t0b0dHR2LNnT76vZWFhgWPHjiEsLAzt27eHsrIyDhw4AC0tLbx58wZnz57F9+/fER4ejgMHDmD48OHQ19fH4cOH0adPHzg5OUFLSwuVK1dG9+7dMXfuXJw8eRK3bt1CXFxcms0zJSUFHz9+LNKWgcTERMycORPW1tbYs2cPFi5ciAcPHqBly5Y5/t4pKSlh+PDhePbsGVq3bo2EhASIxWJ06tQJHh4eePfuXabHqqioYNiwYXjx4gVGjBiBoKAgWFtbY8mSJUhOTgYAbNy4Ea6urrCxscGtW7cwduxYqKmpYe3atXl6DzLCy8sL58+fx+PHj/HhwweMGTMGmpqaCl9HXpSUlLB582ZERUXBx8en0OT4ndKlS/9VBv4v0axZMwiFQhw9erSwRZELqTJgaWkJAGjZsiUeP36MgQMHws/PD1WrVsWtW7fytEZyqiTHxwiUVAEAFKdXRihOTjNGikut2nj27Blu376Nt2/fIjExMRfSFn1Kly4NV1dXhboKssLe3h779+/H+fPn4eXlBUNDQ/zzzz84e/YsZs2aBYFAAAsLC3h4eCAgIAC7d+9GWFgYYmJicPXqVSxZsgS1a9fGq1evMHnyZLi5ucHFxQUAMGPGDPj6+mLLli04e/YsSBZJZYAktm/fjvLly2PixIno27cvwsLCMHToUCgrp1dYc0KJEiWwefNmXLhwASVLloRAIMC5c+dQoUIFLFmyBGKxONNjdXV1MX36dISFhaFVq1bw8fFBxYoV4eHhgd69e6N79+44c+YMjIyMoKOjgy5duiA4ODjLOXMDSaxbtw5isRhVq1ZFz549MXPmTEgkOf/tK4oyZcpg0aJFWLduHfbt21dockixsrL6P6cM/J8NIJRSu3Ztenh4FLYYcrF48WKqqqpmmMp1+/ZtOjo6UiAQcNiwYbluBvLww49MiwZlFkBYasiGXw2G6vdOd4xmJVcK1bTTPa9sbJWmSh8Aamtrs0yZMqxZsyZbt27N/v3709/fn4sXL+b27dt59uxZPnz4kFFRUQpvwJSfSDs3FmT65Pbt2wlAViTI39+fIpGIly5dknsOsVjMsLAwduzYkRoaGvTw8JBVsZQ+KlSowN69ezMoKIhnz57N18BWebh27RpdXFwIgK1atcrXPhfJyckMCgqitrY21dTUZGmIv6dfZiersbGxrL7EuXPn0rx+69atfKmHsnjxYgLgunXrmJqaSn9/f9n7ldfCSXlBWp3QwMAgx2mUimbatGk0MDAoVBkUhbz7t1IB6x5FDnd3d0yePBkJCQlQV1cvbHGyJDw8HObm5hn69qpUqYKbN29i8eLFCAgIwN69e7Fs2TJ4eHjkaA1LA00IgBy5CpS0DSHU0EXypxfpXkuKeA4VE6s0z5FE6vcIFCtWDObm5ihbtixsbGygra2Nb9++ISoqClFRUbhz5w4iIyMRFRUlM6dKEQqFMDQ0hImJCYyNjbN9aGlp5eh9UCRt27bFkCFDsGHDBkydOrVA1uzUqRM+ffoEHx8flCpVCoGBgTh//jy6du2K+/fvQ18/fXzHnwiFQlhbWyMlJQU1atTAgQMHAAA/fvzA/PnzMW3aNFStWhUPHz7E9u3bZdYdU1NT2Nvbp3lYW1tDJBLl2/m+ffsWfn5+2LZtGxwcHHDmzBk0aNAg39YDfsUd+fj4oFOnTvD19cU///yDBw8ewNHREX5+fvD394eamlqGx7569QpeXl5ITEzE7NmzsWvXLri6uqJly5aYNWsWKlWqhCpVqsDR0RGrVq1Cy5YtFSLz6dOnMWLECIwYMQJ9+vQBAEydOhXVqlVDjx49ULVqVezduxe2trYKWS8nCAQCrF69GpUrV4aXlxeOHDlSaG5EKysrfP36FdHR0dDR0SkUGQoaAZl9SHF0dDR0dXXx8+fP/9wbI/W5HzlyBM2bNy9scbKkffv2iI6OxsmTJ7McFx4ejiFDhuDo0aNo27YtFi9ejFKlSsm9Tr255/AmgyDCpIgwfNo4AgbNfaBl1yjNa19PLEPcg7Mo2X8llHSMAAAJ4fcRtd0f+m6Doe34v/dWi/HQvbQQz549w7dv39IEYBUrVgxly5aVBTe5uLhAW1sb0dHRMiUho4dUaYiKisLXr1/Tya6hoSGX0mBsbAxDQ8M8m5P/ZODAgThy5AjCw8PzdVP8E19fX8ybNw/bt29HjRo14ODggNq1a2P//v1yX2itra3h4eGBBQsWyJ6bOXMm5s2bJ3uvU1NTERYWhpCQkDQPaTyOhoYGbG1t0ygIdnZ2eb6exMTEYNasWViwYAH09PQwffp09OrVq0DfYykXL17E4MGD8ejRIwiFQlhZWWHt2rWoV69emnHnz59H+/btUaxYMRw8eBAVKlSARCLBrl27MH78eISHh6NPnz6YPHkyDh8+jMGDByM8PDzPwZphYWGoVq0aqlevjsOHD0NJKe294IsXL9C2bVu8fPkSwcHB6NKlS57Wyy3Hjh1D8+bNsWzZMgwePLhQZLh27Rpq1qyJ+/fvyx1oWlSRd//+P68MkIS1tTXc3NywfPnywhYnS5ydneHk5ITVq1dnO5Ykdu3ahWHDhiE+Ph4zZ87EwIED5bpITjr4CJtvvIFY8uurEX3nECSJcRDHfkPsvaPQsKkJZZPSAACdKu4QqmkiNfozItYPh1BVE9rOHmBKAqJv7IVI2xAlegVBoPRrcxUJgB4ulpjkUQnAr0C0O3fu4NChQ7h06RKePn2KL1++pFEQtLW1UaZMGbi4uMDNzQ01atSAiYlJpvKnpqbiy5cvcikPkZGRSEhISDeHgYGBXIqDiYkJdHR0st1Yb926hWrVquH48eNwc3PL9jNQFBKJBL169cLOnTtx/PhxxMTEoFWrVli8eDGGDh2a7fGxsbHQ1tbG+vXr0bt3b9nzgwYNwrVr13D//v0sj//y5Us6BeHx48eyYFcrK6t0VgRLS8tsI9vFYjE2bNgAf39//PjxA6NHj8bYsWML1QIE/Po+L126FAEBAUhKSkJqaiq8vLwwd+5cFCtWDKtXr8aQIUNQt25d7Nq1K52FJjk5GStXrsSUKVMQHx+PIUOGYMWKFRg9ejQmTZqUa7l+/vwJFxcXkMT169ehp6eX4bj4+Hj0798fW7ZswfDhwzF37lyFK8byMGTIEKxbtw737t1D+fLlC3z9yMhIFC9eHPv27UPr1q0LfH1F8lcZyAHDhw/Hvn378ObNmyId3W5oaIgRI0ZgwoQJch/z/ft3+Pn5YfXq1XBxcZGZ4bIiLDIGjRdelP3/frknxNFRGY4tNXAtlPR+bczJn9/g+9lgJL1/DIFQCerWVVGsgRdEmsXSHHN6RF1YG2tnun5ycjLu37+Po0eP4sKFC3j8+DE+f/6cRkHQ0NCAlZUVqlatiiZNmsDFxQWWlpa5+vzi4uLksjhERUXh8+fP6QKtVFRUslUajIyM0L17d1SqVKlAMgt+Jzk5Ge7u7rh+/TouXbqEdevWYcWKFbh27RqcnJyyPPb69euoUaMG7ty5k2ZsixYtIBKJcPDgwVzJ8/TpU4SGhqZREqKifn3HtLW1YWdnl0ZBsLW1lUW8nz17FiNHjkRISAi6deuGGTNmFLlAxoiICIwePRpbt26FSCSCjo4OqlevjuPHj2Pw4MFYuHBhlpvsz58/MWfOHJk1RlVVFR8/fsxVTQ6xWIyWLVvi+vXruHHjBmxsbLIcTxLLly+Hj48Pqlevjl27dqFEiRI5XjcvxMfHy7Jbrl69ChUVlQJdnyS0tLQwbdo0jBgxokDXVjR/lYEccPr0aTRu3Bj37t2Dg4NDYYuTIdI7tH/++QfdunXL8fGXL19G//79ERYWhjFjxiAgICDLGIkea2/g6quvMuuAIhAJgZqlDbHZq3qOj01OTkZoaChOnDiB8+fP48GDB4iKikqjIKioqMDCwgJVq1ZFo0aNUK1aNZQrVy6dOTQvSCSSNHENWSkOUVFRiI6OTjeHjo5OtrEO0teLFSumkPzvmJgY1K9fH58+fcK5c+fQpUsXxMTE4M6dO9DWzlwxW716NQYPHozY2Ng0/u/KlSujXr16WLp0aZ5lk/Lp06d0VoSnT59CLBbLsiCSkpIQERGB8uXLY/bs2XB3dy/SCvyFCxfQt29fvHjxK56mYsWKOHHiBExNTeU6/v379/D29saBAwdQvHhxLFq0CB06dEB8shjhX+OQnCqBipIQlgaa0FTN+Hs+evRoLFy4EMeOHUPjxo3llv3q1avo0KEDJBIJdu7ciTp16sh9rCK4ffs2atSogbFjx2LatGkFujbwq9Bbw4YNsXjx4gJfW5H8VQZyQHJyMgwNDeHr6wt/f//CFidDHj16BFtbW1y+fBm1atXK1RxJSUmYM2cOpk2bBjMzM6xcuRKNGjXKcOy7b/FoFHQBSblINcwIklARCXB2lCvM9BVTcVBaQe3MmTM4d+4cQkJCEBkZmUZBEIlEMDMzg5OTE1xdXVGtWjVUrly5wIJFExMT8fnzZ0RFRSEsLAzdunVDy5YtYWNjk6Hy8GetCJFIBCMjI7kUB2Nj4yzvHCMjI1GzZk2oqKhg48aNaNiwIVq3bo1NmzZluqF6e3vj3LlzePToUZrndXV1MWHCBPj6+ub9TcqCxMREXLt2DTNmzMCZM2egqqoKkUiEuLg4AL9iTH6PQbC3t0elSpUyDdwraJ4/f46WLVvi/fv3kEgkSElJgYqKCubMmYMhQ4bIrejZ2tric7ISUiyqo1jF2hBrpHUvCACY62vAtZwxulU3R1mTXwrehg0b0KdPHyxatAjDhg3LsfyfPn1C586dcfnyZcybNw/Dhw8vUOVr+vTpmDhxIi5evJjr615ukdaj+LdUqc2Mv8pADunQoQPevn2LGzduFLYoGXLkyBHZRSUnwYAZ8ezZMwwYMAAXLlxAjx49MH/+fBgZGaUbt/3WW/jtfZCntX7n2/ElmOHVEkOGDMm3C0piYiJCQ0Nx6dIlnDlzBiEhIYiIiEijIAgEApQoUQKOjo6oV68eqlatCgcHh0z9qIqkXbt2ePHiBe7fv5/uPSCJnz9/ymVxiIqKyrAcrqamZpaKQ0pKCnx8fFCmTBkMHDgQ/fr1SxcP8Dt169ZFqVKlsG3bNtlzP3/+hJ6eHrZt24bOnTsr9P35nZSUFCxfvhyTJ09GamoqJkyYgOHDh0NVVRXv379PZ0UICwsDSYhEIpQrVy5dLELx4sULdCM7deoUOnbsiOLFi+PQoUPQ0NCAj48Pdu3aBQCws7PD1q1bUalSpSznefctHj2XHsPrBDUIQUiyKBUuEgoglhB1rA3RziIZnVo0Qs+ePbF69epcn3tqair8/Pwwf/58dOrUCcHBwQUWm5Gamop69eohIiIC9+/fL9D9Z+jQoTh79mw6Rfjfxl9lIIds2rQJvXr1wqdPn7IMTisspD68xMREhZiNSWLDhg0YNWoUhEIh5s2bh169eqW7YARsv4LNIT/wK9kw5xcTkhAIBBjZqCzCj6xEUFAQvLy8sGzZMqiqqmY/gQJISEhAaGgorl69irNnz+LevXsZlnk1NDSEvb096tatC2dnZzg6OircVypV6v70weeGlJSUdIGSmSkOkZGRGRZ2UlVVRXJyMqpWrQpLS8t0ykOPHj0wcOBATJw4Edra2hAIBHj48CEqV66MK1euoGbNmnk6h4wgiUOHDmHMmDF48eIF+vXrh8mTJ2f7u4yLi8PDhw/TKAihoaGyErdGRkbpFIQKFSooPECOJJYuXYoRI0agSZMm2LZtG3R1dWWvX7hwAX369MHr168hFAoxcuRITJ06NUNrxvZbbxF48BFSxRKIc+CxEwmA1JRkGISfwfUtCxTic9+1axf69OkDS0tL7N27N9vYA0Xx6tUr2Nvbo0OHDgVWvAsAFixYgICAAMTGxhZpV1R2/FUGcsjnz59hYmKC4OBgeHp6FrY46fD19cXevXtlvkdFERUVhZEjR2LLli1wdXXFypUr0/zI+/btixMvYqBRpzeSUlIBgfyKCCViKAkFmNHWHp2q/grw2rhxI/r37w9nZ2fs2bMn0yYx+U18fDxCQkJw48YNnDt3LtM68Do6OqhcuTJq1aoly+awsrLKtUKWmpoKc3NztG3bVqH+9uwgmSZQ8tixY5g6dSocHR3x+vVrSCQSODo6ypSLL1++pAuUVFVVhbGxMVRVVfHixQu0b98eVlZW6VwV0oDJ3GxA9+/fx6hRo3D27Fk0btwY8+fPzzbgNSskEgnCw8PTWRGk1eWUlZVRsWLFdEqCoaFhrtZLTk7G0KFDsXr1aowaNQqzZ8/OMIMnJSUFQUFBCAgIQHJyMooXL47t27enSUNcei4M804+z92JAwAJCAQY3cQG3q5lcz/Pbzx58gRt2rTBx48fsXHjRrRp00Yh82bH+vXr4enpiT179qBt27YFsub+/fvRpk2bInuDKC9/lYFcUKtWLZiYmGDv3r2FLUo6OnbsiG/fvuH06dP5Mv/JkycxcOBAfPz4Ef7+/vD19cX3799hYWGByZMno26zNmgzYyfUrBxlpsjMkL3+6QlOTfdE2ZJp/Zs3btxAmzZtIBKJsG/fPjg7O+fLOeWUuLg43L9/H7dv38b58+dx+/ZtvH//Pt04dXV1VKxYETVr1pQVhsnJHeb48eOxYsUKREREFKpvW+pPHjRoENatWwdPT09Zeq1YLMa2bdvQo0cPbN++HSRlisSFCxdw+fJluLi4yOIhMmowo6enl22Mg/SRkJCAwMBArFu3DuXKlcP8+fPRrFmzfLsji46OTpfN8ODBA1maacmSJdMpCDY2Nlmm5n758gXt27fH1atXsWrVKllRn6z4+PEj+vfvjyNHjgD4VaBq7dq1OB4WrVAX3ey2lWUKeV6Jjo6Wbcx+fn6YOnWqQoN0M4Ik2rVrh4sXL+LBgwcFkt0QEhICBwcHXLt2TVaS+9/IX2UgF8ycORPTp0/Hly9fikwAkpTq1avD1tY2XxqXSImPj8eUKVMwb948lCtXDtWrV8eOHTvw/v17+Pv7Y+fOnTh96xH2hX7GuedRePs1Pk2lQgEAcwMNmImisWO6N/auX55pV8KPHz+iTZs2CA0NRXBwcK4yJAqC2NhY3Lt3D3fu3MHly5dx48YNmYIgEAhksQhKSkooV64catSoAScnJzg6OsLOzi7DgL6wsDDY2Nhg69athVbYRcrMmTMxfvx4dOvWDVu2bMHu3bvRrl07AL+Ct+bPn4+vX79CIBAgLikV4V/jsGjJMpw4egSPb16QRbAnJCTIFIPMXBW/P1JTU9PJIhAIULJkSVSoUAEmJiZZZlzkRwCoWCzGixcv0lkRpJ+3mppahoWT9PT08OjRI7i7uyM2NhZ79+5F7dq1c7T22bNn0a1bN3z69AlaxS1g0mcpUpm5IpT06QV+Xt6KpPePwdQUKOmZQMuhKXScM644qqokxOkR9RQWvEsS8+fPx9ixY+Hq6opt27ZlGHekSL58+YLKlSvDwcEBR48ezXfTvXTfKwq/07zwVxnIBVJf6LFjx9C0adPCFicNJiYm8Pb2RkBAQL6vFRISgr59++L27duwtbXF7t27YW9vj4CAgDQ1DqSbw+/pTUhNQsWKFWFnZ5dtFG5iYiIGDBiATZs2YcyYMZg5c2ahVI7LKTExMbh37x5u376N69ev49q1a2kUBOB/sRJWVlaoXr06nJyc4OTkBAcHB+jr66Nu3bpQVVXFqVOnCvNUQBJDhw7F8uXLUaNGDTx69Aj379+HpaUlOnXqhHfRqWgyaArOPYvC228ZKH8ZRLDLs+b379+xbt06zJkzB9++fUO9evXg7OyMmJiYdIrD9+/f082hpaWVrbVB+jAwMMjT9+rr16/prAiPHj2Slcg2NjbG169fYWBggEmTJqFx48YoXbp0jl1JKSkpmDp1KlY/V4GqeWUIRBnfbSe8vouo3VOgYlIGmuXrQKCihtQfnwBKUMw1YxenSChAzdIGuUrrzYpz586hU6dOUFVVxZ49e1CtWjWFzv8n0uqES5cuxZAhQ/J1LeBX8bGRI0fmqLZLUeOvMpALSMLKygotW7YsUH9udsTHx0NTUxObNm1Cjx49CmTN1atXY+DAgVBXV4dAIIBEIsGHDx9QrFixLI+bMGEC5s+fj8ePH6N06dLZrkMSixYtwqhRo+Dm5oatW7cWSFS/ovn586fMgnDjxo00CoJ0U5D64EuWLAkTExPcu3cPa9asQdOmTVGqVKlCC1KStuI9cuQIihUrBgsLC2w5cByNxq2FxLic3G6hOtaGmNGmcrZ3n9euXcOIESNk7qI5c+bA2to60/HJycn48uWLXBaHyMhIJCUlpTleIBDA0NBQLsVB2sciu88iJSUFT58+xYwZM7B9+3YYGRlBIBDICidJW0H/bkWoXLlytlH4fxb8+hNJUjw+rO4P1VIVYNRmHAQ5iOEBsi/4lRvev3+PDh064O7du1i8eDH69++fr99lb29vrF27Fnfv3kWFChXybR3gV9VXBwcHBAcH5+s6+clfZSCXDB06FAcPHkR4eHiRiSB9+vQpKlSogAsXLqBu3br5vh5J2NraomzZspg2bRocHR2RmpqKFi1aYNmyZbCwsMjwuOfPn8PW1hbjx4/PcenUU6dOoVOnTjAyMsKBAwcKpQSpovnx4wfu3r2LO3fu4ObNm7hx44as771IJErTmlZfXx9VqlSRuRgcHR1hbW2tkMwReUhMTISbm9uv8sJlasKgySCIJcz07jQjREIBlIQCTPaohM4Z+KfDw8Ph5+eHHTt2wMnJCQsWLEhXtz+vkERsbKxcioM0UPLPS6Camlq2ioOuri7mzZuH3bt3Y/z48Zg6dSqEQiEiIyPTZDKEhITgyZMnSE1NhUAgQJkyZdLFIpibm8uuNX+WAv+TmHtH8e3EcpTsuwLKhmaQJCdCoKwil1JAiRjmSeHY4dseJUuWzPub/RvJyckYOXIkli1bht69e2P58uX5VssjPj4eVapUgYaGBq5du5av1Qk7duyIr1+/4syZM/m2Rn7zVxnIJSdPnoSbmxtCQ0PzFMWsSI4fP45mzZrhzZs3BVJ29cSJE2jatCkuXLiACxcuYMaMGVixYoWsDvzUqVMxdOjQNEFDJNG0aVOEhYXh0aNHuboQvHjxAq1atcL79++xbdu2It84Kjd8//4dd+/exe3bt7Fy5Uq8e/dOphQoKSlBJBLJ7mw1NTXh4OAAR0dHmZJQsWLFfLv4ff/+HdU9JyK5fFOZmyO3/B7BHh0djZkzZyIoKAgGBgaYMWMGevToUWCKTlaIxeJs+1j8/oiNjU03R7FixbJUHPT09BATE4OPHz8iLCxMpiRImzzp6enJCiZd0m2I76mZK2Cf981AQvh9GLUZj28nVyD12wcIlNWgaesK/Yb9IFDK+rsh+fkJXzYMxciRI+Hr66vw6/nmzZsxYMAAlC9fHnv27IGVlVX2B+WCO3fuwMXFBb6+vpg+fXq+rAEAY8eOxa5du/Dq1at8WyO/+asM5JKkpCQYGhpi3LhxGD9+fGGLAwBYuXIlhg4dioSEhHyP2gUANzc3fP36FefOnYOlpSW6du2KJUuWIDo6GhMmTMCyZcvg6OiINWvWyHLl9+7di3bt2uHQoUN5arcaHR2NHj164NChQ5g5cyZ8fX2LjIVG0Vy9ehW1atXCnj17oK2tjdu3b8vcDFIXg7KyMpSVlREfHy/739bWVmY9cHR0hL29vUKKwCi6yNTM1raIDT0Jf39/xMTEYMyYMfD19ZX1GPg3cvXqVbRv3x5JSUmYMGEC9PT0MnVXfP78OY31B/j1+UkrSurq6kIkEiE5ORnR0dH4/D0ayl2XZPl9/7jWG6k/IgAAWnZNoGZeGYlvHyDmziFoVKgLo1ZZV4QUAGiPa1i6cD60tLQQGBiI/v37K1TBDAkJQdu2bfH9+3ds2bIFzZo1U9jcvzNjxgwEBATka3XClStXwtvbG4mJiQVy7c0P/ioDeaBdu3aIiIjA1atXC1sUAMC4ceOwfft2WW50fiINotyyZQsiIyPh6+uLly9fprFI3LhxA/369cOjR4/g4+MDX19fVK1aFfb29gop3SmRSBAYGIhp06ahS5cuCA4OzlWDlqIOSVSsWBFOTk7YsmVLmte+fPmCO3fu4M6dO7h9+zZu3bolUxBUVFSgqqqKuLg4SCQSCAQC2NjYpFEQHB0dc5Qrn135aaam4MelfxD36BwkibFQNrKEXt0eULdyzHxScQo+rB6ILh5NMGPGDLnr8RdV9uzZg549e6JChQrYv39/tucjkUjw/ft3uSwOkZGRiFfVR0nPJVnO+WFlX6T++AQtx2YwcPtfAN3X40sRe/84SvZfBWX9rCuUHhlaG7qSGAQGBmL9+vUoU6YMZsyYgfbt2ytM8f7+/Tt69OiBo0ePYtKkSfD391e4JUgsFqNevXr4+PFjvlUnlFpJX716lW9WjvzmrzKQB9avXw8vLy98+vQJxsbGhS0OunTpImswk994eXnhxIkTePr0KcqVKwc3N7cMq36lpKRgwYIFmDRpkmxjevbsmVxBg/Kya9cu9O7dG+XLl8f+/fvz3M+9KDJ37lwEBAQgIiIi2+DMz58/y5QD6UNaKElVVRXq6uqIj4+XRbmbmprKFAOpm8HMzCzDC352jak+H5iD+GdXoOPcCkr6JRH34DSSIsJg0mUG1MwyKacrEcOuuBoOjmiSg3ek6EES06ZNw8SJE9GxY0esX79ebuWUJOLj4/Hz509ER0fj58+fmf4dHgPcM8q4V4iUj8GDkfLlLUy6zoKaua3s+cS3DxG51Q8GLUZAq3LDLOfYN6gmHM1/fdcePHgAPz8/HD16FNWrV8ecOXMUFpckkUgwffp0BAYGolmzZvjnn3+y/Y7nlNevX8POzg7t27fH+vXrFTo38CsOqly5cjhz5gwaNGig8PkLgr/KQB6IjIxEiRIlsG7dukxrthckNWrUQPny5fPly/47kZGRMDc3x9SpU6Gnp4eBAwfiyZMnKFeuXKbHnD59Gk2aNAFJdOzYEYsWLVJoVcH79++jdevWSEhIwJ49e3Kcv13U+fTpE0xNTbF48WIMHjw4x8dHRkbKFIQ7d+7g1q1biIj4ZUZWU1ODpqYmEhISZG4GfX39dBYEgV5JNF18OdM1kj4+w6dNo6Dn6gnd6r+qvzE1GR+Dh0CkqYviPeZlKWN+RLAXBKmpqYiMjMTAgQNx+PBheHp6onXr1oiOjk6zmWe30f/pKvgdLS0t6OrqQkdHBxqlbPDFuV+WMkVuD0Bi+D2U7LcSygb/s0ykfH2Hj2sGoVjDftCp2irLOY4MrY1KJXXTPHfu3DmMGTMGd+7cgbu7O2bNmoWKFSvK8S5lz/Hjx9G1a1cUK1YMe/bsUXhn2PysTpiUlAR1dXWsWbMGXl5eCp27oPirDOQRFxcXmJqaYvfu3YUtCkqWLIn+/fvnOEI/pwQGBmL+/Pl4/fo1XFxcUKVKFezcuTPT8b8HDQYEBMDX1xepqamYPXs2+vbtqzCz4OfPn9GhQwdcvXoVy5YtQ79+WV8w/220atUKHz58wO3btxUyX0RERDoXQ2RkJABAQ0MDWlpaSEpKws+fPwEARk2HQMOuCSDMOBf/+7l1iL65H2Y+2yFU/d8d8c9rO/HjwiaUGrweSjoZF5wRCQXoUd0CkzyybsajSEgiMTExy01anjt1aWfEDM9LJIKurq7soaOjk+3ff/6vra2dpv5BXFIqbCedQFYX5O/nNyD6+m4Yd54OdUt72fMJ4SGI2j4Bhu6joVmpfqbHCwA8nOSWYbtjaavi8ePH482bN/D09MTkyZMVknnw+vVrtGvXDk+ePMGqVavQs2fPPM8phSTat28va22u6EwJMzMz9OrVq1DaKCsCeffvf2dERAEg1Y6TkpIKrKFORiQmJiIiIgKWlpb5uk5CQgJWrFiBPn364NSpU3j16lW2itDevXtx8uRJWdCgh4cHxowZIysktHr1aoXcXRgZGeHUqVPw8fFB//79ERISgqCgIIU3mCkspHecISEhsLe3z/6AbChRogRatmyZJpDz48ePMuuB1MUgRdXSMVNFAACSI19BWb9UGkUAAFRK2Mhez0wZEEuIc8+jMAnyKQMSiQQxMTG53sClf//ZCvp3NDQ0Mty0TU1NZX///PkT69evh0gkwrRp01ClSpU0x0jrbygSTVUlmOtr4M23+MzHlK+D6Ou7ERt6Mo0yEBt6EhCKoGqedQaUuYFGhooA8KseRufOndGmTRusXLkSU6dOxZYtWzBq1CiMGTMmTzeCVlZWuHLlCoYMGYJevXrh+vXrCAoKUsi1VSAQYNWqVahcuTI8PT1x7NgxhX42VlZWBRKvVdj8tQxkQmhoKOzt7XHy5Ek0bty40OSQ+qzOnTuH+vXr59s6wcHB6N+/P54+fYp27drBzMwMR48ezXR8XFwcKlSoAAcHBxw8eDDNa+fPn8eAAQPw+vVr+Pn5Yfz48Qor77x69Wp4e3ujZs2a2LVrV76XQC0IUlJSYGpqii5dumDhwoUFsiZJfPjwAVdu3sHYWyJk1ZHyY/BgiDT1YNJlRprnk7+8RUTwYOi7DYG2Y1YR44S3yWskxPzIdjPPqMeBFKFQmKs78D/vxrNTIrdt2wZPT084ODhg3759BdpMK7s6AwDw5egixIWegkb5OlAzt0Xi2weIf3oZOjU6oFi9XpkeJxQAPV0s5bbS/Pz5E7Nnz0ZQUBC0tbUxceLEPGcekERwcDC8vb3h6OiI3bt3KyywVJqCvWTJEnh7eytkTgDo1asXwsLCikxAeU756ybIIyRhYWGB1q1bY/HixYUmx6lTp9CkSZN8jWYliUqVKqFcuXLo06cPWrVqhUuXLmXpnx8/fjyCgoLw+PHjDOVKTEzEjBkzMGvWLFhZWWHVqlUKU2YuX76Mtm3bQkNDAwcOHFDI3XRhM2bMGKxfvx4fPnwoUEvUo48/0WJJ5vECwK8IdiX9UjDpODnN8yk/PuHjyr5y+am/bhkNzeTvudrApX9ramrma5qpRCLBxIkTMX36dPTo0QOrV68u8B4lt8M+oP26+1mOoTgVP6/tRGzoaYhjv0FJ1wjaTi2z/QwAwOjWSozp3wNt27aVO1Xu/fv3mDhxIjZs2KCwzINbt26hXbt2SExMxI4dO+Dq6prruX5n6NChCA4OVmh1wkmTJmHlypX49OmTQuYraP4qAwpgyJAhOHbsGF6+fFloue5r1qzBwIEDkZiYmG9mcalGfeHCBYwZMwaqqqq4eDHzkqjPnj1D5cqVMWHCBAQGBmY59+PHj9G/f39cuXIFffr0wdy5c2FgYJBnmd++fYvWrVvj2bNn2LhxI9q3b5/nOQuTJ0+eoGLFiti1a1eBnsu9t9/RZkXWdzx5twwA85uWQKtadkU2Vzs2NhY9evTAgQMHMGvWLIwZM6ZAf/OpqalYvXo1Jk6cCBW3kVA1twOzsNbkFJFQgLLaEiSfXIBz587BzMwMQ4cORd++feWO8Fd05sHnz5/RpUsXnDt3DrNmzcLo0aPz/J7nR3XCjRs3onfv3oiLi/tXpjjLu38XfgmwIkzLli3x+vVrPH78uNBkCA8Ph6mpab76xxcsWABnZ2ekpKTg5s2bWRZbIolhw4bBzMwMvr5ZFzgBgIoVK+LixYtYtWoV9u7diwoVKmDLli3pSsDmFHNzc1y+fBkeHh7o0KEDJk6cKKv9/2+kQoUKqFGjRr52pcwIFaXsLwEiLX2IY9M3CxLHfpO9nh1dOraHtrY2qlevjoEDB2LVqlW4efOmrGVwYfLmzRvUqlULp0+fxoEDBwq80NXp06fh6OgIb29veHh44FBAV6goKbZhl5JQgDX9G+Ds2bO4f/8+GjVqBH9/f5iammLIkCF4/vx5tnNUrlwZR44cwZkzZ5Camop69eqhVatWePLkSa5kMjIywokTJzB27Fj4+vqiffv2iI6OztVcUjQ0NLBlyxaEhoYqLOBami4dHh6ukPmKKn+VgSxwdXWFhoYGDh8+XGgyvHnzJtNeAIrgwYMHOHXqFEaOHImZM2fC0dERbm5umY6XBg0uXrxY7pLDQqEQ/fv3x5MnT+Dq6oru3bvLCnnkBQ0NDWzduhUzZ87EtGnT0KZNmzxfTAoTT09PnDhxQta/oCCwNNDM9v5Txbg0Ur59gCQpbWBb8sdfG4iKSda1JUgi9XsEVFRU8P79e+zZsweDBg1C9erVZQ19evbsiaCgIJw/fx4/fvzIwxnljCtXrqBq1aqIiYnBtWvXMm25nR+EhYXBw8MDjRs3hq6uLm7duoV169ahSnlLTFZw9sUUj0qyBlL29vZYt24d3r59C19fX+zevRvlypVDy5YtcebMmWwV9QYNGuDmzZvYtm0bHjx4AFtbW/Tv3x8fP37MsVwikQgzZszAvn37cPr0aVSrVi3PN19OTk6YPHkyZs+ejcuXs3aByYPUDfpfDyL8qwxkgZqaGho3bqyQqnq5JTw8PF8zCYKCgmBqagpzc3OcOXMG48ePz/SuKC4uDj4+PnB3d0eLFi1yvFaJEiWwY8cOHDlyBM+ePYOtrS1mz56dZeR3dggEAvj5+eHQoUM4f/48atSogZcvX+Z6vsKkY8eOUFdXx6ZNmwpsTWkEe1ZolK8FUIKY+8dlzzE1BbEPTkGlZLlMMwmklNJVwc6tmzF06FA4OTlBTU1NtuGIRCJERUXhxIkT8PX1haurK4oVK4bSpUujffv2mD59Oo4ePSqrnaBINmzYAFdXV1SoUAE3b96Era1t9gcpgJ8/f2L06NGoVKkSQkJCsH37dly6dAlVqlSRjelc1Ryjm9goZL0xTcqhUwaNo0xMTBAYGIi3b99i/fr1ePfuHRo1agQ7OzusXbs2S6uNNPPgyZMnmD9/Pvbs2QNra2sEBATkSiFv3bo1bt26BSUlJVSrVi3LlGZ5GDt2LGrUqIEePXrk+QahZMmSUFFR+c8rA39jBrJh7dq16N+/PyIjI3NU3lVRmJqawtPTE1OmTFH43L8XGbp69SqePn2KR48eZdr7fdy4cVi4cGGmQYM5IS4uDoGBgQgKCoKtrS1Wr16N6tXz1mv96dOnaNWqFT5//owdO3YUahZIbunduzcuXbqEsLCwAmnk8/z5c/RdcQJvVCwgyCK98PP+WYh/fg06VVtBqVhJxD04g6SI5zDpPD1NJbw/yazOwNevX2Xd/e7fv4/79+/j8ePHsu5+urq6UFZWRkxMDBITEwEAxsbGabo6Ojk5wcrKKsfvk1gsxtixYzF//nz07dsXy5Yty9fOd7+vGxwcjICAAMTFxcHPzw+jR4/O0sK2/dZbBB58hFQJs8ww+BNpB8kpHpUyVAQygiTOnz+PhQsX4tChQzAwMMCgQYMwaNAglChRIstjf/z4gdmzZ2PhwoV5yjyIi4tD3759sX37dowcORKzZ8/OdZzJ69evYW9vj7Zt22LDhg25mkOKjY0NWrZsiQULFuRpnsLgb8yAgmjRogUkEgmOHTtW4GsnJyfj48eP+eYmWL58OZSVlVGrVi0cOHAAfn5+mSoCz549w/z58zFu3DiFZDVoampi3rx5uHXrFpSVlVGjRg0MHTo0T1p8+fLlcePGDVSvXh1NmzZFUFBQnmMTChpPT0+8evUKly5dytd1rly5gtatW6N8+fJ4cWx9looAABi2HAkd51aIe3gO306tAiWpMG4/MUtFAPhVZ6C7S/rNyMDAAA0aNMCIESOwceNGhISEIDY2Fvfu3cP69evRu3dvVKpUKc1GGRMTg1u3bmHx4sXo2LEjrK2toaenh3r16sHHxwcbN25EaGholpamnz9/wsPDA0FBQVi0aBFWr15dIIrAuXPn4OTkhIEDB6Jp06Z4/vw5AgICsnW1da5qjtMj6qFm6V9BtyJh1k4d6es1Sxvg9Ih6cisCwC8rm6urKw4cOIDnz5+jS5cuWLBgASwsLNCrVy/cu3cv02P19PQwc+ZMPH/+HC1btsSwYcNQqVIl7N69O0e/QU1NTWzduhWLFi3C4sWL0ahRo1xH8VtZWWHx4sXYuHEj9uzZk6s5fp/rr2UA/7ctAwBQrVo1WFpa5tl0lVNevnwJa2trnD59Gg0bZl1vPKckJCTA3NwcXbp0wbdv33Dp0iW8ePEiw0BFknBzc8PLly/x6NEjhadbpaamYsmSJQgICICenh6WLl2K1q1b53o+sViMcePGYe7cuejVqxdWrlxZ4CliuYUkbGxsULNmTWzcuFGhc4vFYhw8eBBz587FtWvXUL58eYwePRrdu3dH33/uZ9mbIDeIhALULG2AzV65t/iQxLt379JYEEJCQmSuIJFIBG1tbYjFYlmNAhUVFVSuXDmNFcHOzg4fP36Eh4cHPn78iJ07d6JJk/zvmfDy5UuMGTMG+/btQ40aNbBw4UJUq1YtV3OFRcZgy423OPc8Cm+/xqepVCjAr4JCrjbG6O5irrDyzz9+/MC6deuwePFivHnzBnXr1sWIESPg7u6e6Y0DkD7zYO7cuahTp06O1r58+TI6dOgAoVCIXbt2oWbNmjmWX1HVCQcNGoRr167h/v37uTq+MJF7/6Yc/Pz5kwD48+dPeYb/55gyZQp1dHSYlJRUoOuePn2aAPjixQuFz7169WoKBAKePXuWQqGQS5YsyXTsrl27CICHDx9WuBy/Ex4ezhYtWhAAW7duzXfv3uVpvn/++YdqamqsXr06P3z4oCAp858ZM2ZQXV1dYb+3+Ph4rlixgmXLliUA1q1bl4cOHaJYLJaNefs1jjYTjtB87CFa+B1WyMPG/yjffo1TyDn8yc+fP3n58mUuXbqUffv2ZdWqVammpkYABEBNTU3q6OhQIBAQAAUCAQUCAbW1tTlmzBiePn2aX79+zRfZpPL5+vpSRUWFpqam3LJlCyUSicLmj01M4cMPP3j3zTc+/PCDsYkpCps7I1JSUrh7927WqlWLAGhlZcWgoKBsv6NnzpxhlSpVCIAeHh58/Phxjtb9+PEja9euTSUlJS5ZsiRX7+Hnz59ZokQJNmnSJM13PifMnj2bOjo6Cv0MCwp59++/yoAc3L17lwB4+vTpAl03ODiYAoFA4UqIWCxmhQoV2KZNGw4YMIDGxsaMj4/PcGxsbCxNTU3p4eGhUBkyQyKRcOfOnSxevDi1tbW5ZMkSpqam5nq+W7dusVSpUixRogSvX7+uQEnzj/fv31MoFHLVqlV5mufz58+cNGkSDQ0NKRQK2aFDB964cSPT8QEbjitMEbDwO8ztN9/kSf6ckpKSwsePH3Pr1q309fWlm5sbTUxMZAqCQCCglpYWlZSUZM+ZmZmxdevWnDx5Mg8ePMh3797l6YKfmprK4OBgmpiYUF1dnYGBgYyNjVXgWRY+N2/eZLdu3aikpERtbW36+Pjw5cuXmY4Xi8XcunUrraysKBQK2a9fvxwp58nJyfTx8SEAduvWLVfv5/HjxwmAixcvzvGxJLlz504CyFcFMr/4qwwoEIlEwlKlStHHx6dA1w0ICGCpUqUUPu/Ro0cJgPv27aOKigpnzpyZ6Vg/Pz+qqanx1atXCpcjK75//84BAwYQAKtXr86QkJBczxUREcEaNWpQVVWVGzduVKCU+Ufz5s1ZvXr1XB0bFhbGQYMGUV1dnerq6vT29pbLujR//nwa1u2mEEVg6dmwXMmuSJKTkzlkyBDZXemMGTPYpUsXVqhQgUKhUKYgaGpqUkVFRaYg6Ovrs3Hjxhw7diy3b9/OZ8+eyXVHeeHCBTo6OhIAu3btyrdv3xbAWRYeHz584Pjx46mvr0+hUMg2bdrwwoULmSpTiYmJDAoKor6+PjU0NOjv75+jPWXbtm3U0NBg5cqVGRaW8++Xt7c31dTU+OjRoxwfe+vWLQLgrVu3cnxsYfNXGVAwAwYMYJkyZQrUTNSjRw/WqlVL4fM2btyYzs7OHDlyJHV1dfnjx48Mxz19+pTKysqcPHmywmWQl8uXL7NixYoUiUQcO3Ys4+JyZ3ZOTEykl5cXAXDEiBFMSclfs2pe2b17NwHw4cOHch9z7do1tm3blgKBgEZGRpwyZQq/fPki9/E9e/ZktWrVuO3mG9r4H2Xp8UdypACUHn+ENv5HC9wikBFfv35lw4YNqaSkxJUrV6Z7PT4+njdv3uSaNWs4ZMgQ1qpVi1paWjKFQFVVNY3bQUNDgzVr1qS3tzfXrl3Lu3fvyix2r169Yvv27QmAVatW5dWrVwv6dAuVuLg4rlq1ihUqVCAAOjk5cdOmTZlaNL9//y67yTAyMuLSpUuZnJws11oPHz5k2bJlqaury4MHD+ZYzgoVKtDR0THH1tYvX74QAHfu3Jmj44oCf5UBBXP48GECyLHPKy/UqVOH3bp1U+icoaGhBMBVq1ZRU1OTEyZMyHCcRCJh48aNWbp0aSYkJChUhpySlJTEadOmUVVVlVZWVjxx4kSu5pFIJFyyZAlFIhEbN27Mb9++KVhSxZGUlERDQ0OOGjUqy3FisZj79+9n7dq1CYA2NjZctWpVpm6frHBwcGDfvn1J/ooh6B58nRZ+h2nueyBbJcDC7zC7B1/PtxiBnPDkyRNaW1tTX1+f586dk/s4sVjMFy9ecM+ePQwICKC7uztNTU1lCoFIJEqjIIhEIhoZGVEoFFJXVzfHd7r/NSQSCU+cOMFmzZoRAIsXL84pU6YwKioqw/Fv375lnz59KBAIaG1tzV27dsl1s/Xjxw+2bt2aADhhwoQcuRHv3LlDJSUljhs3Tu5jyF/npq2tzdmzZ+fouKLAX2VAwcTHx1NdXZ1z5swpsDXNzc05fvx4hc7Zp08fmpqa0t/fn+rq6pn+UAsqaDAnPHv2jK6urjLfYWRkZK7mOXPmDA0MDGhtbZ0rk2FB4ePjQyMjowzvmhISErh69WqWK1eOAFirVi3u378/1wFSycnJVFFRSedTbe/lTetO41h37lla/qEEWPodZt25Zxl44CHDIqNzta6iOXbsGHV1dVmxYkWFBd5+/fqV586dY1BQEHv16sXKlSvL3AxSpUAaqCgNruvYsSNnz57NkydP8vPnzwqR49/E48ePOXDgQKqrq1NVVZVeXl588OBBhmNDQkJkCkT16tV58eLFbOeXSCScNWsWhUIhmzRpkiML2IwZMygQCORa53fs7e05cODAHB1TFPirDOQD7u7urFOnToGslZycTKFQyNWrVytszoiICKqoqHDKlCksVqwYhw8fnuG4mJiYAg0azAkSiYTr16+nvr4+9fX1XixOvwAAPytJREFUuW7duly5bl69esXKlStTS0uLBw4cyAdJ847UirNv3z7Zc1++fOHUqVNpbGxMgUDAtm3bKsQs/fDhQwLghQsXZM+JxWIaGxvT19eXZMFHsOcEiUTCoKAgCoVCNm/ePN+uVZcuXZJFx7u5uXH+/PkcMWIE69evT11dXZlCoKSkRJFIJPvf2NiYLVq04MSJE7l//36+efPmXxmZnlO+fPnCmTNnslSpUgTARo0a8fDhwxkqrWfOnKGTk1OOMg9Onz5NQ0NDWlhYyO3PT01NZe3atWlhYZGj70nr1q3p5uYm9/iiwl9lIB9YvXo1hUJhgUSUvnr1igB48uRJhc0ZEBBATU1NTpkyhcrKypkGOBVW0GBOiIqKYo8ePQiA9evX57Nnz3I8R0xMDNu0aUOBQMBp06YVyYtz1apV6e7uzpcvX9Lb25saGhpUU1PjoEGD+Pz5c4Wts3XrVgJI4zq5efNmOgWhKJKUlMS+ffsSAEePHp2n7JPMePPmDTt16kQArFKlCi9dupRujEQi4bt373jo0CFOnTqV7dq1o4WFRZpsht8VBG1tbdatW5ejR4/mli1b+Pjx43yRvSiQnJzMrVu3smrVqjJ31rJly9JlBkgzDywtLSkUCtm/f39+/Pgxy7nfvHnDqlWrUlVVlcHBwXLJ8+rVK2pra7NXr15yn8OIESNoY2Mj9/iiwl9lIB/48OEDAfCff/7J97XOnTtHALna5DIiPj6eBgYGHDx4MIsXL04vL68Mxz158oTKysqcMmWKQtbNb06ePMnSpUtTRUWFkydPZmJiYo6OF4vFnDx5MgGwQ4cORS4NbOzYsRQIBBQKhTQ0NOSkSZMyde3kBT8/P5qZmaV5btKkSdTV1ZU7uKswiIqKYp06daiiosL169crfP7Y2FgGBARQTU2NxYsX57p163LsiomOjuaVK1e4fPly9uvXjw4ODmmyF35XEFRUVOjg4MBBgwZxzZo1vH37do6/00UZiUTCq1evskOHDhQKhdTT06Ovr2+6G5PExEQuWLBAlnkQEBDA6OjMXVGJiYmy7KO+ffvKFee0YcMGAuCuXbvkkn3x4sVUUVHJtSuusPirDOQTVapUYefOnfN9nfXr1xOAwoL3Vq1aRYFAwKlTp1IoFGZ4VymRSNioUSOWKVOm0IMGc0JcXBz9/PyopKTEChUqZHjXlh179+6lpqYm7e3t+fr1a8ULmQPEYjEPHTrEunXryu4oW7dunetMCnlo1qwZW7Rokea5atWqsUOHDvm2Zl4JDQ2lpaUljY2NefnyZYXOLRaLuWnTJpYsWZKqqqocN25clptRTklNTeWTJ0+4fft2+vn5sWHDhjQwMJApBb/HJAiFQlpbW7Nbt25cuHAhL168+J+4FoeHh3PMmDHU1dWlSCRip06deO3atTRjvn//zrFjx8qdebBu3TqqqqqySpUqDA8Pz3J9iUTCdu3aUV9fX666B4cOHSKAPBdDK2j+KgP5RGBgYIHcLQUGBrJEiRIKmUtaZKhVq1a0tLRkp06dMhwnLaxx5MgRhaxb0ISGhtLFxYUA2L9//xxnC4SGhtLKyoqGhoY8f/58PkmZOYmJiQwODpalaLm4uHDPnj3s0qULbWxs8tWNUapUqTQR1pGRkRQIBNywYUO+rZkXDhw4QC0tLdrb22d70c8p165dY7Vq1QiA7dq1K1B3WWRkJE+ePMk5c+awY8eOLF26dBrF4PdAxRIlStDd3Z0zZszgsWPH+OnTpwKTU5HExMRw6dKlsgqZ1atX57Zt29JcY9++fcvevXtTIBCwbNmyWWYe3Llzh5aWltTX18828+jLly9yVyd89OgRAeQ48LCw+asM5BO3b98mAJ49ezZf1+nduzddXFwUMpe0yJC/vz8B8P79++nGSIMGW7VqpZA1C4vU1FQuW7aM2traNDEx4fbt23O0iX758oUNGjSgkpISly9fno+S/o9v375xxowZLF68OAUCAVu1apXmTvfMmTMEoPC7XynSHOpt27bJntu4cSMBFLkNRhpFLhAI2KZNG8bExChs7rdv37Jr164EQAcHh0JRCDMiISGBt2/fZnBwMAcPHkwnJyeqq6tnqCDo6emxbt26HD9+PPfs2cNXr14VyViYjJBaxBo2bEgANDU15axZs9LEaP2eeeDi4pLpxvz161c2bdpUFg+U1UZ/4sQJuaoTxsXFEcC/pnCZlL/KQD4hkUhYsmRJjhw5Ml/XqV+/vsLcEY0aNaKzszMrVqyYzhQsRWqKK2wTuaJ4//4927ZtSwBs3rx5ju4eU1JSOHz4cALggAED8q0nRXh4OIcPH05NTU2qqqqyf//+fPr0abpxYrGYlpaW9PT0zBc5pPEpv6dZduzYkc7OzvmyXm5JSEhg9+7dZYqtony3cXFxnDRpEtXV1WlsbMw1a9YU+UA+iUTCV69ece/evQwICGCjRo1oZGQkUwp+f6irq9PBwYGDBw/m5s2b+fDhwyJfdCs0NJSenp5UVVWlhoYGBw0axCdPnsheP336tCzzoFWrVhlmHqSmpjIwMJAA6O7uzu/fv2e63tChQ+WqTmhiYsJJkybl+rwKg7/KQD7Sr18/li1bNl/XsLS0pJ+fX57nCQkJIQCOHDmSADJMQ3vy5AmVlJT+NUGDOWH//v0sVaoUNTQ0OH/+/BxdBNetW0cVFRXWrl071zUNMuLOnTvs3LkzRSIR9fX16e/vn+0d+OTJk6mpqanQO2EpixYtoqqqquy9SUlJoa6uLgMDAxW+Vm6JiIhg9erVqaamlsaCkRckEgm3bNlCU1NTqqio0NfX919/jfv27RvPnz/PhQsXslOnTixTpkyaAMXfUx/Lli3Lrl27csWKFbxx40auClXlN5GRkZw8ebKsx0SzZs148uRJSiQSuTMPDh8+TD09PVpbWzM0NDTDdeLj41mhQgU6ODhkqfy7uLiwZ8+eCju/guCvMpCPHDx4UKGR/n+SkpJCJSUlrlixIs9z9e7dm6ampqxSpQrr16+f7vV/a9BgToiOjuawYcMoEAjo5OTE27dvy33s1atXaWJiQjMzM965cyfXMkgkEh49epQNGjSQFaZZsmSJ3NkLb968oUAg4Lp163ItQ2Z4eXnRyclJ9v/FixcJIMumRgXJnTt3aGpqyhIlSvDmzZsKmfPGjRusUaMGgV8dMvOjM2hRITk5maGhody0aRO9vb3p5ORETU3NdAqCQCBgqVKl2KJFC86ZM4fnzp3L8m66IElMTOTGjRvp4OBAAKxUqRLXrFnD+Ph4uTIPXrx4QXt7e6qrq2eaDXbnzh0qKytneRPWpUuXAqs1oyj+KgP5SFxcHNXU1Dhv3rx8mf/NmzcEwGPHjuVpno8fP1JZWZn9+vXLtGaBNGjw6NGjeVrr38CNGzdob29PoVBIHx8fue+y3717R2dnZ6qrq+f4rjQpKYnr16+nra0tgV+163fu3JkrM3STJk3ypVdF1apV2bt3b9n/Y8eOpZGRUZFIodq5cyfV1dXp7OzM9+/f53m+9+/fy+pTVK5cmWfOnFGAlP8+JBIJ379/z8OHD3PSpEls2LBhmg6Pvz/09fVZu3Zt+vn58ciRI9nm/ee33OfPn2fr1q0pEAhoYGDACRMm8OPHj7LMA1VV1QwzD+Li4mSf/dChQzO0AMycOZMCgSDT2hrjx4+nqalpvp1ffvBXGchnWrRokeGdtiK4cOECAaTxkeUGf39/amlpsXbt2nR2dk4XSBQTE8NSpUr964MGc0JycjJnz55NdXV1mpub89ChQ3IdFx8fL/NX+/n5ZbuZf//+nbNnz2bJkiUJgC1btsyyo5s8bN++nQAyjCvILampqVRXV+eCBQtkz1WuXLnQTaFisZiTJk0iAHbu3DnPJuz4+HhOnTqVGhoaNDQ05MqVK4t8XEBhEBMTw6tXr3Lp0qXs0KEDra2t07R8lj40NTXp4ODAAQMGcPv27QwLCytw5fHFixccPnw4tbS0qKyszO7du/P27dt88+YNe/XqJcs82L17t+x3J5FIuHz5ciorK7NmzZrpUgpTU1NZp04dWlhYZNjALTg4mEIVdd57/blIVuLMiL/KQD6zYsUKikSifGl2s2nTJgLIU165tMhQhw4dCIB79+5NN+a/FjSYE169ekU3NzdZsSF57nYkEgnnzZtHoVDIFi1aZHixePv2LUeOHEltbW2qqKjQy8tLYc2tEhISWKxYMY4dO1Yh85G/OlMC4OnTp0n+kh8At2/frrA1ckpcXJzse5vXypASiYQ7duyghYUFlZSUOHLkyCJj+v63kJqayqdPn3L79u2ybAZtbe10CoKysjKtra3ZqVMnrlq1iiEhIQVSsOrHjx9csGABLS0tCYB16tThnj17ePfuXTZt2lSWefB7/ZFr166xVKlSNDExSZc18vr1a2pra6dRiJ9/imbggYd0nnyE5mMPpe/RMedXj47nn4pGj47f+asM5DPv3r1Ll46lKKZMmUJjY+M8zSEtMtSgQQNWqFAhndb++PFjKikpcerUqXla59+MRCLh1q1baWRkRF1dXa5YsUKuu5vjx49TV1eX5cuXl8WN3Lt3j926daOSkhL19PQ4fvz4fDGnent7s3jx4gqLBpe6iaRVDVeuXJlvSq48vHv3jk5OTtTQ0MhQgc0Jt2/flnVzdHd3z7cYn/+rREVF8dSpUwwMDGSDBg1oYmKSJs1RWjCpZMmSdHNz4/Tp03n16tV8K56VmprKvXv3sk6dOgRAS0tLLliwgPv3788w8yAyMpKurq4UiUScP39+GqVTmlq7cvMuWffO7Fp6F7XunVL+KgMFgKOjI7t27arweT09PVmtWrVcHy8Wi1m+fHlZsNqmTZvSvC6RSNiwYcP/dNBgTvj69Su9vLwIgDVr1uTDhw+zPebZs2csV64cNTQ06OjoSAC0sLDgokWL8iXiX8rdu3cJQG73Rnb4+/unKW7l4eFRaAFS169fZ/HixWlmZsZ79+7lep6IiAhZa9xKlSoptL/HX7ImISGBd+7c4dKlS9muXTuWKVOGysrKGcYh1KhRg6NGjeLx48cV3u/l9u3b7N69O5WVlamtrc1hw4bJrAe/Zx6kpKTQ19eXANixY0fZb1cikbCe5ziaj97L0uMyVwAyUwps/I9y2803Cj2n3CLv/i0gSWRDdHQ0dHV18fPnT+jo6GQ3/P8MEydOxNKlSxEVFQUlJSWFzduoUSPo6+tj586duTr+6NGjaNGiBRo2bIiXL1/i+fPnUFZWlr2+c+dOdOrUCUePHkWzZs0UJfa/ngsXLmDAgAF49eoVfH194e/vDzU1tXTjUlJSsH37dsyePRuPHj0CAHTt2hUbNmxI8z7nF46OjrCyssLevXvzPFerVq2QlJSE48ePIykpCfr6+ggICICfn58CJJWff/75B3379kWVKlWwd+9emJiY5HiOxMREBAUFYcaMGVBVVcWUKVPQv39/hf42/5JzSOLNmze4desWzpw5gxs3buDVq1eIjo5OM05TUxOlS5eGs7MzmjRpgtq1a6NUqVIQCAS5Xvvjx49YsWIFVqxYgW/fvqFly5YwMzPD1q1bkZycjNGjR2P06NE4efIkevfuDTMzM+zduxenI0SYd/I5SOZp/dFNbODtWjbXxysCefdvYQHK9J/D3d0d379/x9WrVxU6b3h4OCwtLXN9/IIFC2BnZ4dz587B19c3zQYVGxuLkSNHonXr1n8VgT+oV68eQkJCMH78eMyZMweVK1fG2bNnZa9HR0dj3rx5KF26NHr27Alzc3OcOnUKfn5+2Lp1Kzw9PZGQkJDvcnp5eeHQoUOIiorK81yhoaGws7MD8EsZio+PR4sWLfI8r7xIJBKMGzcOPXr0QOfOnXH27NkcKwIksWfPHlSsWBETJ06El5cXwsLCMHjw4L+KQBFAIBDA0tISHTp0wMqVK3Hv3j38/PkT379/x9mzZzFhwgTUr18fWlpaePToEdavX48uXbrAzMwMampqKFOmDNq2bYslS5bg2bNnkEgkcq9dsmRJTJ06Fe/evcPq1avx6tUrLF++HGZmZqhfvz5mzZoFa2trREZGyq7jdXqNxbyTz2Wy54V5J59jx623eZqjwFCkmeH/GmKxmMWLF+fo0aMVOqeysjKXLVuWq+Pv379PADIf3p9uAF9fX6qrq/+fDBrMCY8fP5b5Htu3b09vb2/q6OhQWVmZvXv35oMHD9KM3759uywFLr8bmXz9+pUqKip5Tm398eMHAXDz5s0kyeHDh9PU1LTAytdGR0fTw8ODAoGAc+fOzdW69+7dY7169WSVJvOagfOXwkVaE2HhwoVs3bq1rCMp/ohDKFGiBBs0aMCJEyfy2rVrclcJlUgkPHnyJJs3b04ANDIyktUuKFu2LBet3UJL3/3pggQt/A6zhNcyapSrRSVdEwqUVClU16GqaSUatQvI0m1g43+0UGMI/roJCoi+ffviypUrePLkiULm+/DhA0xNTXH48OFc3aH16dMHJ0+exOfPnzF9+nSMGTNG9tqTJ09gZ2eHwMBA+Pv7K0Te/zIhISEYNGgQrl27BoFAgObNm2PlypUwNTXNcPy9e/fQqlUrJCcnY+/evahZs2a+yda5c2c8ePAADx8+zPXdy+XLl1GnTh2EhITAzs4ONjY2cHV1xapVqxQsbXrCw8Ph4eGB8PBwbNu2Lcff9cjISPj7+2Pt2rUoV64cgoKC0LRp03yS9i+FCUlERETg4sWLOHXqFG7fvo3Xr18jJiYmzbhixYrB2toa1apVQ9OmTWXWhsx49uwZFi1ahI0bNyI1NRVGRkZIqT0A6hb2gFCUbnzCy1uIvn0IqqXKQ6SlD6YkIf7ZVSS9fwT9pt7Qdsj4+ycSClCztAE2e1XP2xuRS+Tdv/8qA3lk//79aNOmDcLCwmBtbZ3n+a5cuYLatWvj4cOHqFSpUo6OjYiIgIWFBVxcXPDgwQO8ffsW2traAH79oBo3bow3b97gwYMHGfrC//LrfTp79izmzZuH48ePw8zMDJ6ennj48CH27NmDRo0aYeXKlShTpkyGx0dFRaF9+/a4ceMGVqxYAU9Pz3yR8+TJk3Bzc8P169dRvXruLjLLly/H8OHDERcXhzdv3sDGxgYHDhyAh4eHgqVNy6VLl9C2bVvo6Ojg4MGDOfqeJyUlYfHixZg6dSqUlJQwadIkDBo0qEBiNf5StIiLi8PNmzdx7NgxXL9+Hc+ePcOXL1/SuBE0NDRgYWEBR0dHNGzYEC1atEjnhvr27RuCg4OxZNNuiNwDcyQDJWJEbPABU1NQqv/KLMeeHlEX1sbaOZpfEfyNGSggGjduDFVVVRw+fFgh84WHhwMALCwscnzs8uXLoaKigjt37mDYsGEyRQAAdu3ahTNnzmDJkiV/FYEMSElJwdatW1GlShU0atQIERER+Oeff/Dy5UtMmjQJu3fvxtGjRxEWFgZbW1vMnDkTKSkp6eYxNjbG6dOn0adPH3h5eWHYsGEZjssrDRs2hJmZGdatW5frOUJDQ1GhQgWoqKjg6NGjUFFRQYMGDRQoZXrWrl2Lhg0bolKlSrhx44bcigDJ/9fencdFVe4PHP/MgICgIEKA4Az7OoiakmZXy5+GNwXMpVyyLEvTcgmVXFpUyjIhMXdbXNPUa264lkt1vRZqJiCioMgmAgIKAyjbnN8fXuZeLjsOLvC8Xy//iHPmmTOJc77neb7f78OePXtQqVTMmTOHsWPHkpCQwNSpU0Ug0EKZmJjQt29fFi9ezG+//UZmZialpaVcuHCBxYsX4+/vj5WVFVevXmXr1q28+eab2NjYYGhoiIODA4MGDWLRokVkZmYSHBzM659+h5w6n40rkcn10G9riaa4oNbz9OQyvv/j0c4dEDMDOjBw4ECKi4s5duzYfY/12WefER4ezs2bNxv0uqKiIpRKJc7OzsTGxpKcnIyFhQVwL2nQw8MDX19fdu/efd/X2Jyo1Wq+++47wsPDSUlJwc/Pj+DgYPr161ft9HthYSHz588nPDwcLy8vvv76a3r27Fnt2GvWrGHKlCn06dOHHTt2aP8+dOXjjz9m6dKlZGRkYGxs3ODX9+rVC2dnZzZv3oyfnx9wb8ahKZSVlfH+++8THh7OhAkTWL58OQYGBvV6bXR0NEFBQRw/fhw/Pz+WLFnS4FkzoWXLysri0KFDHDt2jHPnzpGcnExBwX9u4HK5HLuJ3yA3rTt5VVNyF6msGE1xEXcSIrl1Yh3Gnr15IjC41tfZWxjz68y+9/1ZGkrMDDxA/v7+/Pbbb+Tl5d33WElJSY2aFdi8eTO5ubnExcXx9ttvV7rxfPLJJ+Tm5hIeHn7f19dcpKenM2fOHJRKJcHBwdpKgiNHjtC/f/8a1+FNTEwIDQ3lzJkzGBgY0KtXL959991q/+4nTpzIsWPHiI6OxtfXl5iYGJ1+htdffx21Ws2PP/7Y4NdqNBpiYmLw8fGhoKCAX3/9tcmqCPLy8ggICGDZsmUsX76cNWvW1CsQuHnzJhMnTqRr166kpaWxf/9+Dh8+LAIBocGsrKwYO3YsmzZt4sKFC6jVau7cucPhw4eZNm0a3Z/+G7K2VvUa69bxb0lb9grpa8ffCwTcnqa936Q6X5eSU0Rhcdn9fpQmI4IBHfD396esrIwjR47c91iNKSvUaDSEh4ejUqkoLi5m+vTp2mNxcXEsWbKEDz744L7KFZuLixcvMm7cOBwcHFi5ciVvvfUWiYmJbNq0SVtiVx9du3YlMjKS8PBwNm7ciJeXF7t27eJ/J9r69OnD2bNnMTU15emnn9bpzIyTkxP/93//16ilgqSkJAoKCvDx8eH48eOUlJQwcOBAnV1bhYSEBHr27Mkff/zBoUOHmDx5cp0JjyUlJSxZsgRXV1e2bdtGWFgYMTExDBo06L5LvQShgpGREQMGDGDp0qWs27Gv3r9bpr6DsRr5KRaDgmjt1A1J0kB53UuBEpCUU3ifV910RDCgA0qlEh8fHyIiIu57rOTk5AbftA8dOsTly5e5fv06r7/+OnZ2dsC9ddbJkyfj4ODAzJkz7/vaHleSJPHLL78waNAgVCoVP/30E5999hmpqamEhoaiUCgaNa6enh7Tpk3j4sWLdOvWjWHDhvHiiy+Smppa6Tx7e3v+9a9/MWjQIIYOHcqCBQsaVCtdm3HjxvHLL79w9erVBr0uKioKAB8fHw4cOICLiwuurrptjnLs2DF69OiBRqMhMjKS559/vtbzJUkiIiICb29vgoODGT16NFeuXCEoKKjeSwqC0FCSJJGcer3e57eyUNDaoQttOvXD6qV5SCV3ydoZUuVBoDolZbr5d98URDCgIwEBARw8eJDy8vJGj6HRaEhOTm7wMkF4eDj29vbk5eXx/vvva3/+j3/8g+PHj7N8+XIMDQ0bfV2Pq7KyMrZv385TTz1F3759SU1NZePGjSQmJjJz5kzMzMx08j5KpZK9e/eyc+dOzpw5g5eXF8uWLav0u2BiYsK2bdtYuHAhCxYsYPjw4ZXWLBtr6NChmJmZsX79+ga9Ljo6GktLS6ytrbUdK3Vp1apVDBgwAF9fXyIjI3Fzc6v1/NjYWAYMGEBgYCBKpZLz58+zatUqLC0tdXpdQstTWFjIyZMnWb58OZMmTcLPzw8vLy+srKwwMjJCLpfzYqB/o8c39niGkhsJlOXWHVAY6D+6t1zRnktH/P39WbhwIb///jt/+9vfGjVGZmYmxcXFDZoZiIqK4tixY1haWjJy5EhtyZtarSYoKIghQ4a0uPrrgoIC1q1bR3h4OElJSfTv35/Dhw/j5+fXZNPMMpmMYcOG0b9/f+bMmcN7773H999/zzfffEPnzp2158ydO5dOnTrxyiuv8PTTT7N3716cnJwa/b6tW7dm1KhRbNiwgQULFqCnV7U+ujoVnQdjY2NJS0vT2RJBaWkp06ZNY/Xq1UybNo2wsLBauwBmZ2czb9481q5di6OjI3v37iUgIEAsBwj1otFoSEpK4s8//yQ6OprLly+TnJxMRkYGt27dorCwsMosnEwmw8jICDMzM9zd3VEoFDi6ehCBBDT8904qLb53LcW1LwHIAAcLkwaP/6CIYEBHnnrqKaysrNi/f3+jg4Hk5GSABgUD4eHhtG/fnuzs7Er95D/55BNu3brVopIGMzIyWLFiBatWrSI/P58RI0awa9cuunbt+sCuwczMjFWrVjFmzBgmTJhAt27dmD59OvPnz9dm/AcEBPDHH38wePBgfH19+cc//nFfJX3jxo1jzZo1/Pzzz/UO/KKjowkICODAgQMYGxvz7LPPNvr9K+Tm5vLSSy/x22+/8fXXXzN+/Pgazy0tLWXVqlXMnz8fjUbDokWLmDJlSoucwRJqlp+fT1RUFH/99RcXL14kMTGRtLQ0bt68SX5+PiUlJVVeo6+vj4mJCU888QSdO3fG0dERDw8POnfuTPfu3bGysqo22IwOPUFyblGN11JeeBs9k3aVfiaVl1F44TgyfUNaWSpr/SxKC2NMDB/dW+6je2WPGblczqBBg4iIiGDRokWNGqOhPQZu3LjBli1bMDc3JzAwkE6dOgH3kuTCw8OZP39+oyoTHjeXLl3iyy+/ZNOmTRgYGDB+/Hjee+89lMra/3E2pV69enHu3DnCwsIICQlh586drF69mgEDBgDg5eXF6dOnGTlyJH5+foSHh9crua463bt3x9vbm3Xr1tUrGCgoKODq1av4+Piwbt06+vfvf9834bi4OAICArh9+zZHjx6tNbg4ePAg06dPJz4+nvHjx/PJJ59gZVW/TG6h+SgtLSUpKYlz584RExNT5am+qKio1qd6Dw8PlEolLi4uqFQqunXrhpeXV6N/l/u6W7E5MplyTfVr/zmHVyCVFGGo8EavrQXlBbcovPgLZTlpmP/fm8gNWtc4tp5cRl+3R/t3XAQDOuTv78/69etJTExs1NRvUlIS5ubm9e7lsHLlSvT19bl58yZz5swB7iXDTJkypdknDUqSxMmTJwkNDSUiIoIOHToQEhLC22+/Tbt27R725QFgYGDA3Llzeemll5g4cSJ///vfGTVqFOHh4VhbW2Nubs6BAweYPXs2U6dO1a6TN/TLTCaTMW7cOGbNmkV2dnad6+yxsbFIkoSDgwOnTp1i5cqV9/MxOXToECNHjkShUHDmzBkcHR2rPS8uLo7p06dz+PBhnnvuObZv365dQhGaF0mSyMnJ4eLFi9U+1avV6lqf6q2srLC1ta30VP/kk09iY2PTZEtIr/RQsuH3pBqPm3j2piD6Z9R/HURzR43coDUGNi6YP/cGxq61dwEt10iM6fnwHk7qQwQDOvT8889jYGDA/v37mTp1aoNf35BKgqKiIlatWoWpqSm9evXSNr7ZsWMHx48f59ChQ81yyrW8vJzdu3cTGhrK6dOnUalU2l3OHtXP6+rqytGjR9m8eTPTp0/H09OT0NBQxo0bh76+PmFhYfj4+DBhwgTi4uLYtWsXNjY2DXqPMWPGMGvWLLZu3Vrn7150dDRyuZzU1FTKy8sbnS8gSRLh4eEEBwczcOBAtmzZUm0gm5uby4IFC1i5ciVKpZIff/yRIUOGiLyAx9jdu3dJSkri/PnzREdHEx8fX+WpvrrseiMjI9q1a1fpqd7b25snn3wSDw8PWreu+em6qblat6W3iyWnEnOqnR0w8XoWE6+GL6dV7E3wMFoRN4ToQKhjAwYMQKPR8PPPPzf4tS+88AJGRkb1qkVfu3YtkyZNQpIkjh49Sr9+/VCr1Xh4eNCjRw+d7HX/KCkqKmL9+vUsWbKExMREnnvuOYKDg3nhhRceq5tKdnY2M2bMYNOmTfTp04e1a9fi4eEBwOnTp7U3yd27d+Pr69ugsYcPH05CQgLnz5+v9f/J5MmTOX78OL6+vvz1119ER0c3+HMUFxczadIk1q9fz6xZs1i4cGGV5MWysjLWrFnDvHnzKCkp4cMPP2TatGmiHfYjTqPRkJWVxaVLl/jrr7+Ii4vj6tWrXL9+XftUX12LbT09Pdq0aYOFhUWVp/ouXbrQoUMH5PJHN5seIDW3iP7hv1KswxJAQ305R4OeRdG+4V1CdaG+928xM6BjAQEBTJ8+nfz8/AYHTklJSfVa861oMmRhYaFtPAPNM2kwKyuLlStXsnLlSm7dusVLL73E9u3b6d69+8O+tEaxtLRk48aNvPbaa0ycOJHOnTszd+5cZs+ezVNPPcXZs2cZOnQovXv35ttvv2XMmDH1HnvcuHEMGjSIc+fO0a1btxrPi46OplOnThw6dKhRGyllZWUxdOhQzpw5w6ZNm3j11VernPPTTz8RFBREXFwcb7zxBgsXLmzwbIfQNAoKCkhKSiI6OpqYmJgqT/V37typ8anezMwMT09PFAoFLi4udOrUia5du+Lq6lppL5THlaK9MQsCVczepbtuoSGBqocWCDSECAZ0zN/fnylTpvDTTz8xfPjwer9OkqR6LxNUNBmCexu/yGQybdLgggULmkXSYHx8PEuWLGHjxo3I5XLeeust3nvvvRrXox83/fr1Izo6mk8//ZRPP/2Ubdu28fXXX9O7d29OnDjBpEmTePXVV4mKimLRokX1Khn08/PD1taWdevW1RgMSJJEdHQ0KpWKmzdvNri/QEUVQnFxMb/88gtPP/10peOXL19m5syZ7N+/n969e3P27FmefPLJBr2H0HhlZWWkp6eTkJBAdHQ0sbGx2rX67Oxs1Go1ZWVVW+LK5XLatGmDtbU1dnZ22qf6Ll26oFKpsLOzq7VEtDkZ6asku6CYsJ/i73usYD93Rvg+2rkCFcQyQRPo1KkT3bp1Y8OGDfV+TVZWFtbW1uzevZsXX3yx1nP79evHn3/+iUKhICoqCplMRr9+/UhLSyMmJuaRXTuvj1OnThEaGsrevXuxsrJi6tSpTJw4kfbt2z/sS2syFy5cYMKECfz++++89dZbLF68mHbt2rFs2TJmzJjB888/z9atWzE3N69zrLlz57J69WrS09OrXX9NSUnB3t6eUaNGcfDgQbKzs+v9Jb9nzx7GjBmDq6sre/furVStcfv2bUJCQli+fDl2dnaEhoYyfPjwx2oJ51EnSRK3bt0iJSWF2NjYShn4mZmZ2qf66hgaGtKuXTusrKxQKpW4urri7e1Nly5dcHJyol27duLv6n9sO5PCvH2xlGmkGisMqqMnl6EvlxESqHokAgGxTPAQBQQE8M0331BeXl7vJjAVZYV1zQycP3+e48ePA/e6vMnlcrZv386JEyce26TB8vJy9u3bR2hoKL///jseHh58/fXXjBkzpkWsL3t7e3Py5EnWrl3L7Nmz2bdvH1999RVTp05FpVLx8ssv06NHD/bt26fNL6jJG2+8weeff86ePXsYNWpUleMV+QEVHf/qEwhIksTnn3/OBx98wLBhw9i4cSMmJveap5SVlfHtt9/y0UcfcefOHRYsWEBQUNBDTQR7XBUXF5OWlkZiYiJRUVGV1uornuqr63Aql8sxMTHBxsZGu1bv6elJ586d8fDwoGPHjo/l98LDNtJXyTPOlszdHcM/r2SjJ5fVGhRUHO/lZMFnQzo9FksDlUj1kJeXJwFSXl5efU5v8f71r39JgHTq1Kl6v2b79u0SIN26davW81577TXJ2NhYcnJykkpLS6X8/HzJ1tZWGjp06H1e9YNXVFQkrV69WnJ1dZUAqU+fPtK+ffuk8vLyh31pD83169elYcOGSYD097//XUpMTJSuXLkiqVQqydTUVIqIiKhzjN69e0v9+/fX/nfB3VLpwvXb0rnkXCko5EvJtP0TEiBt3LixzrGKioqk0aNHS4D08ccfV/q7OXr0qOTt7S0B0tixY6Xr16837kO3AOXl5VJGRoZ0+vRpaePGjVJwcLA0ePBgqUuXLpKNjY1kZGQkcW8vmyp/DAwMJCsrK8nb21saNGiQNG3aNOnbb7+VIiMjpczMTEmj0Tzsj9fsxWfkS/P2XpD6hB6XHGbvl+z/64/D7P1Sn9Dj0ry9F6SEzPyHfalV1Pf+LWYGmkCPHj2wtLQkIiKiyppqTZKTkzE1Na21Rv7GjRts3bqV8vJyZs2ahb6+PiEhIY9d0mB2djYrV65kxYoV5ObmMnToUDZv3kyPHrXX6rYEtra27Ny5k4iICN59911UKhUhISH885//5I033iAwMJCFCxcye/bsGqd133zzTcbP/JjpW37nz/S7pOQW8Z/nGXfMx6+jze0bXDD0JCFTjat19YlfN27c4MUXXyQ6Oppt27YxYsQIAK5cucKMGTPYt28fvXr14vTp0w2ufGhuCgoKSE1N5dq1a8TGxlaqq8/JyUGtVle7OZVMJqv0VO/k5ISHhwc+Pj64ubmhUCi0nSuFh8fVui3zA1XMR0VhcRlJOYWUlGkw0JfjYGHySHcWrC+RM9BExo4dq+2sVR/vvvsuJ0+e1O4mV50PP/yQL774AktLS5KSkrh69SqdO3dmwYIFzJ07V1eX3mSuXLlCeHi4dlOdcePGERQUpN1PQahMrVbz0UcfsXz5cnx8fFizZg0HDx4kJCSEESNGsG7duio3itTcImbtPM+pa7eQISHV0mu9Ylqzt4tllWnNP//8k8GDByNJEnv37qV79+7k5eXx6aef8tVXX2FjY8PixYsZMWJEs19rLisr48aNG6SmphIfH8+FCxe0GfgVa/XVNdABaNWqFWZmZtjY2KBQKHBzc8Pb2xsvLy8cHBywtrau91KiIDRGfe/fIhhoIjt37uSll17i2rVr9aoQGDRoEPr6+uzdu7fa40VFRdja2qJWqwkNDSUoKOixSRqMjIwkNDSUXbt2YWlpyZQpU3jnnXewsLB42Jf2WDh79izjx48nOjqaKVOm0L17d95++23c3d3Zs2ePNpHvfhOeFgSqGOmrZMeOHbz++ut4e3uzZ88erK2tWbduHR988AGFhYXMmjWLmTNnNosnVkmSyMvLIyUlheTkZGJjY4mLiyMxMVG7Vl9QUFDj9rQmJiZYWlpWeap3cnJCqVSK70vhoRMJhA+Zn58frVq1Yv/+/UyePLnO85OTk2vdrGbTpk3k5eXRrl07JkyYoE0aPHz48CMZCGg0Gvbv309oaCgnT57Ezc2NNWvW8Oqrr4rksgbq3r07Z86cYenSpcybN49du3bx+eefEx4eTvfu3fnxxx+JKrNpdClU+b+Dh9m7Yti+9yB7Fk5i9OjRfPvtt0RGRjJw4ECioqIYM2YMn3/+OR07dtTxJ2w6JSUlpKWlkZKSwtWrV4mNja3yVF9dqR3ca6Jjbm6OQqFAqVTi5uaGSqXC09MTpVKJra0trVq1esCfSBCahpgZaELPP/88enp6HD58uNbzJEmibdu2hISEMH369CrHNRoNrq6uJCUlMW/ePIKCgvDw8KBnz578+OOPTXX5jXL37l02b97Ml19+yeXLl3nmmWeYOXMmgYGBj3z3scfBtWvXeOeddzh8+DD+/v73+r8Xt6Od37s6e49njVL5eMzzvP/+++zatYsePXqwdOlSbcvrR4UkSdy8eVP7VH/58mVtBn56ejrZ2dkUFta8rayxsbH2qd7R0REvLy+8vLy0T/Xm5ubNfglEaP7EzMAjICAggODgYNRqda3duXJycigsLKxxOeHgwYMkJiZibGzM5MmTH8mkwZycHFavXs3y5cu5efMmQ4YMYf369fVOoBTqx9HRkYMHD7J9+3amTZtGSau2mI9+H40kVblx3U2OJvOH6nNJbF4Nw9CuujJFiZN3benU8znaG0p8//33jBo16qEEcoWFhaSmplZKzIuPjyclJYXMzExu375dbakd3Cu3a9euHUqlslJdvaurK0qlEoVC8UjOqAnCwyKCgSbk7+/PtGnTOHr0KEOGDKnxvOTkZKDmrYu/+OIL9PT0ePfdd7lx4wZLly4lJCTkoW7RW+HatWuEh4fz3XffodFoeP3115k+fTqurq4P+9KaLZlMpt36uP/CveQgq/UJtm23AAw6uFX6mb55h5pGp0wDncd/wdEPBmv7CehaeXk5GRkZpKSkkJKSQnx8PHFxcVy7dk27Vl9TAx2A1q1b06FDB2xtbXF2dsbDwwMvLy/s7e1RKpU17lkvCEL1RDDQhJycnPDy8iIiIqLWYKC2hkPnz5/n5MmTtGrVivfee49XXnkFR0fHapcTHqSzZ88SGhrKzp07MTc3Jzg4mHfeeUfsS/8A5ZS2ItfAqpZ6gXsMFSpMPP5W73Flcj1uSGbcKNTg0shYoCIpLyUlhaSkJOLi4khISNA+1efl5VVbagf3gh0zMzPtjd3V1RWVSoWTkxP29vYoFIomC1IEoaUSwUAT8/f3Z8OGDWg0mhqnWpOSkmjTpk21LXdDQ0ORy+WMGzeO3377jV9++eWhJQ1qNBoOHTpEaGgov/76K87OzqxYsYKxY8c2i8zyx82WyJQ6u6JV0BQXIWtliExevzI2PbmM7/9IYX6gqsqxkpISrl+/rr3ZJyYmVsnAr6nUDu61xrWxscHOzg4nJyc8PT1xd3dHqVRib2+PjY2NKLcThAdMBANNLCAggMWLF3PmzJkam+pUbFD0v9Oa6enpbNu2DbjXh2DAgAEMGzaMAQMGNPl1/7fi4mK2bNnCl19+ycWLF+nRowc7d+7kxRdfFF/aD9GJy1n1CgRyDn6FVHIHZHIMFSrM+47DsEPtyzjlGon9565hfu0oly5dqvRUn5+fX+trzczMcHBwwN7eHldXVzw9PXF0dNSu35uZmTXocwqC0PREMNDEevbsSfv27YmIiKgxGEhKSqo2X2DZsmVIksTLL7/Mxo0bycvLY8mSJU19yVq3bt1izZo1LFu2jIyMDAIDA1m7di3PPPOMWI99yAqKy0jJLar9JL1WGLv3orVTd+TGZpRmp5B/ejeZW2ZhMyYUA5vamz3dvAtBwbORSu9qf6avr69dq694qndxcdFO6dvZ2YlyO0F4DIlgoInp6+szcOBA9u/fz6efflrtOUlJSfTp06fSzwoLC1mxYgWSJDF69GiGDRv2wJIGk5OTWbp0Kd988w1lZWW89tprzJgxA3d39yZ/b6F+knMKqWtOwKijJ0YdPf/zA9ceGHs8w43vpnDr141Yjwip9fUymYw5ny3B16WD9mbfvn17EQgKQjMkgoEHICAggO+//56UlJQqN3NJkrTLBP9tw4YNFBYW4ufnR3h4OE5OTk2eNHju3DnCwsLYsWMHZmZmBAUFMXnyZKytrZv0fYX6yc/P167T/x5/A7Bp8BitzG1p7dqDovhTSJryOnMIhr88kq7KurdOFgTh8SaCgQegYqvYAwcOMGnSpErHbt++TX5+fqVlAo1Go51F6N27Nx999BFHjhxpkqRBSZI4cuQIoaGhHD9+HEdHR5YuXcobb7whMrYfoNLSUm1SXmpqKgkJCVy6dKlSqV1xcbH2/FZWjtiOW96o99I3tYTyMqTSYmSGtSd+GuiLRlGC0BKIYOABMDMzo0+fPkRERFQJBqorKzxw4AAZGRl069aNVatWMWzYMPz8/HR6TSUlJfzwww+EhYVx4cIFfH192bFjB0OGDKnXHvdC/UmSRE5ODqmpqdq2uBcvXuTq1aukpaWRlZVVZ1JemzZtsLOzQ6FQ4OzsjJO7J9/ckqDOwsKqym5nINM3QGZgVOt5MsDBQgSEgtASiG/9B8Tf3585c+ZQWFhY6Ym7ouHQfwcDH374IQDOzs7ExcXpNGkwLy+PtWvX8tVXX5Geno6/vz8rVqygT58+Yi24ke7cuaPtf1/RKa8i+z4jI6PW/vdwr4GOQqGotNmNs7MzCoUChUKBnZ0dBgYGVV73U+gJkmtJIiwvykPPuHLmfklmIkUJp2nt1A2ZrPanfqWFcbPYmlUQhLqJf+kPSEBAANOnT+fo0aMMHjxY+/OkpCRat26NpaUlcG/dPjo6Gnt7e3bu3MnChQt1kjSYmpqqTQosLi5mzJgxzJgxAy8vr/seuznTaDRkZmZqm+dUtMS9du0a6enp5OTk1Nopz8DAAEtLS2xsbHBwcMDNzQ13d3dt85yOHTs2ukdDX3crNkcm11heeHPPF8hbGWBo5/nvaoJUCqIOI2tliPlzr9c6tp5cRl830UBKEFoKEQw8IC4uLri7uxMREcHgwYMpLC4jKaeQc8m5KH16UVRSjomhPnPmzAHuTQu7uLjcd9JgVFQUYWFhbNu2jTZt2jB58mSmTJlChw41taNtWdRqtXajm7i4OO1GN2lpady8eRO1Wl1jp7yKXe0qauhdXFy0G91U3OibcmOvV3oo2fB7Uo3Hjd16Uhj7C/mn96ApKULP2Axjt16Y/W0Urcxtax27XCMxpufDb3ctCMKDIYKBB+jZgBEciFfTJ/QEqblF90rDjHpA3x54zz+CrZkBlzSOtHf0IjY2liNHjlQ7PVwXSZI4evQooaGh/Pzzz9jb2xMWFsabb75JmzZtdP65HlWlpaWkp6drd7S7cOECV65cISUlhaysLG7fvl1jpzy5XE7btm1xcnKiY8eO2tbSbm5u2o1uHvaudq7WbentYsmpxJxqZwdMuwdi2j2wwePqyWX0crLAxarmzbUEQWheRDDwAKTmFjF3dwz/1H8KPY/yapvFSMD1vBLaPDkQWfcA7Iqu49m9/v3k4d7Nb/v27YSFhREVFcWTTz7JDz/8wPDhw5tdUqAkSeTm5pKamsrly5eJiYkhPj6epKQkMjIyyM3NrXX72jZt2mBjY6Pdvtbd3R2VSoWDgwMKhYInnnjisdhy+bMhnegf/mu9OhHWl75cxmdDOulsPEEQHn3N6w7xCNp2JoV5+2Ip+/eXdV113RXHC03s6B/+KwsCVYz0rX26Nj8/n2+++YalS5eSlpbGCy+8wJIlS+jbt+9jmxR49+5d0tLSuHLlClFRUVXK7NRqdY3b1xoZGWFubo6bmxv29va4uLjg7e2Nm5sbCoUCGxubZhMcKdobsyBQxexdMTobMyRQhaK92GtCEFqS5vGN+IhacSKBsJ/iG/XacgnKyzTM3hVDdkExk/tW7SV//fp1li1bxpo1a7hz5w6jR49m5syZeHt73++lNymNRkNWVhaJiYlERUVpy+xSU1PJysoiLy+vUk39fzMwMMDMzAx3d3dtmZ2XlxcqlQp7e/saM++bs5G+SrILihv9u/bfgv3cGVFH8CkIQvMjgoEmsu1Mik6+nAHCforniTaG2i/pmJgYvvzyS7Zu3Urr1q2ZOHEiU6dOxc7OTifvd78KCgq4du0aMTExxMTEkJCQQHJysrbMrqioCEmqOq2tr69P27ZtteV0jo6OeHh44OPjg7Oz831l3jd3k/u6YtnGUDsL1ZBlAz25DH25jJBAlQgEBKGFEsFAE0jNLWLevthqjxVnXOH2r5sovh4HgKGtB+Z938DA2qnWMT/eFwtZ8WxY8SWHDx9GoVCwaNEi3nrrrSbNWP9fZWVlXL9+nZiYGKKjo7l8+XKlMruCgoJqa+rlcjkmJiZVyux8fHzw9PREoVA80M/RHI30VfKMs+W9/JQr2XVub1xxvJeTBZ8N6SSWBgShBZNJ1T2i/Y/8/HzMzMzIy8sTX9j18Op3kdVmeBdnXCHz+/fRa2tJ2y5/R0JCfe4gmrtqOry2hFYWHWseVFPOneQoOlz6keDgYF5++WWd7w4nSRK3bt0iNjaWv/76S7tHfUWZXX5+frXT9zKZjNatW9OuXTusrKy0ZXYqlQofHx+cnJweeuZ9S5OQqWZLZAon4rNIySmqtKmRjHsNhfq6WTGmp1JUDQhCM1bf+7cIBnQsIVPN80t/q/ZY1j/mU3z9ErZvf41e63v/H8sKckn/+m1aO3TliaFz6xz/5/f64GrduC/v4uJiLl++zLlz54iNjdWW2WVmZnL79u0ap+8NDQ0xNTXliSeewM7ODmdnZzw8POjcuTOenp6PTeZ9S1XR06KkTIOBvhwHCxPRWVAQWoj63r/FN4KObYlMqXF69m5qLK2dumkDAQD9Nu0xUnhTdPU0mpI7yA1a1zi2nlzGlsgU5geqqhyTJImUlBT+/PPPSmV2N27c0JbZVTd9r6+vX6nMzsHBAXd3d3x8fOjcuTO2trbNJvO+pTIx1Edla1b3iYIgtFjiW17HTlzOqnGdViovRaZfNdNd1soQyssovZmMoZ1HjWOXayR2R8aTvv8rEhMTK5XZVTd9X7FOX1Fmp1QqcXV1pVOnTnTt2hVnZ+cWl3kvCIIgVCWCAR0qKC6rtqFQhVbtO1KcfrnSPvJSeSnF6ZcBKFPnUNcmxbfLW/Hths1QVoyRkZG2zK5jx47aMrsuXbrQqVMnsQWxIAiCUC8iGNCh5JxCakvAaPvkQHKPrCLn4DJMew4DSUPeqe2UF9wCQCqrvjXuf5PJZJyMukwvT1ECJgiCIOiGCAZ0qKSs+g1tKrTtOpCy/GzyI3dReOEYAAY2rpj2HEb+qe3I69hfvkJrE5H9LQiCIOiOCAZ0yEC/7ox682dfw7THUEpvJiM3NMHAyoFbv24EQL99/ZoG1ed9BEEQBKG+RDCgQw4WJsig1qUCAD2jNugp/lMRcDfpPHptLWvvM/Bvsn+/jyAIgiDoinjE1CETQ32UDeziVhj3GyU3EjDtHohMVvdfh9LCWNSIC4IgCDol7io61tfdis2RydX3GUi5QN6/fsDIsSvy1qaUpF+iIPooRk7daOs7uM6x9eQy+rpZNcVlC4IgCC2YCAZ07JUeSjb8nlTtMb22FiCXkx+5C03JHfTbWdOuz6uYPvVinVsbw70+A2N6iioCQRAEQbdEMKBjrtZt6e1iWe3eBK3MO2A94pNGjasnl9HLyUL0kRcEQRB0TuQMNIHPhnRCX67bTXn05TI+G9JJp2MKgiAIAohgoEko2huzoJr9A+5HSKBKbDErCIIgNAkRDDSRkb5KZvq56WSsYD93RviKXAFBEAShaYicgSY0ua8rlm0MmbcvljKNVOMGRtXRk8vQl8sICVSJQEAQBEFoUmJmoImN9FVyNOhZejlZAPdu8rWpON7LyYKjQc+KQEAQBEFocmJm4AFQtDdm85s9SMhUsyUyhRPxWaTkFFXqVCjjXkOhvm5WjOmpFFUDgiAIwgMjkySpzrnr/Px8zMzMyMvLw9TU9EFcV7NXWFxGUk4hJWUaDPTlOFiYiM6CgiAIgk7V9/4t7j4PiYmhPipbs4d9GYIgCIIgcgYEQRAEoaUTwYAgCIIgtHAiGBAEQRCEFk4EA4IgCILQwolgQBAEQRBaOBEMCIIgCEILJ4IBQRAEQWjhRDAgCIIgCC2cCAYEQRAEoYUTwYAgCIIgtHAiGBAEQRCEFk4EA4IgCILQwolgQBAEQRBaOBEMCIIgCEILJ4IBQRAEQWjhRDAgCIIgCC2cfn1OkiQJgPz8/Ca9GEEQBEEQdKfivl1xH69JvYIBtVoNgEKhuM/LEgRBEAThQVOr1ZiZmdV4XCbVFS4AGo2G9PR02rZti0wm0+kFCoIgCILQNCRJQq1WY2tri1xec2ZAvYIBQRAEQRCaL5FAKAiCIAgtnAgGBEEQBKGFE8GAIAiCILRwIhgQBEEQhBZOBAOCIAiC0MKJYEAQBEEQWjgRDAiCIAhCC/f/wSXSYro4GqkAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot original hard graph\n", + "hard_graph = construct_graph(hard_clauses)\n", + "pos = nx.spring_layout(hard_graph)\n", + "nx.draw_networkx(hard_graph, with_labels=True, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.098283300Z", + "start_time": "2023-06-30T07:04:52.932252Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We first use the brutal force method (BF) to obtain the true solution." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 179, + "outputs": [], + "source": [ + "def b2s(bit):\n", + " return 1 - 2 * int(bit)\n", + "\n", + "def energy(cfg, graph, n_cls, normalize=True):\n", + " factor = 1 / n_cls / 4\n", + " E = 0.25\n", + " for a, b in graph.edges:\n", + " E += cfg[a] * cfg[b] * graph[a][b]['weight'] * factor\n", + " return E if normalize else E / factor\n", + "\n", + "def brutal_force(graph):\n", + " num_nodes, n_cls = graph.number_of_nodes(), len(hard_clauses)\n", + " min_cost, best_case = 1., []\n", + " for i in range(2 ** num_nodes):\n", + " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + "\n", + " cost = energy(list(map(b2s, case)), graph, n_cls)\n", + "\n", + " gap = min_cost - cost\n", + " if gap > 1e-6:\n", + " min_cost = cost\n", + " best_case = [case]\n", + " elif abs(gap) < 1e-6:\n", + " best_case.append(case)\n", + "\n", + " return best_case, min_cost" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.178133800Z", + "start_time": "2023-06-30T07:04:53.126416600Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 180, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost: 0.000\n", + "bit string: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print BF results\n", + "bf_best_cases, bf_best = brutal_force(hard_graph)\n", + "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.442102700Z", + "start_time": "2023-06-30T07:04:53.126416600Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Then we start to execute the algorithm loop shown in the figure above. The algorithm starts from the classical method - SA." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 181, + "outputs": [], + "source": [ + "def sim_annealing(graph, t_max: int, T: float):\n", + " num_nodes, num_cls = graph.number_of_nodes(), len(hard_clauses)\n", + " state = np.random.randint(0, 2, num_nodes)\n", + " next_state = state.copy()\n", + " E = energy(1 - 2 * state, graph, num_cls, normalize=False)\n", + " t = 0\n", + " while t < t_max:\n", + " temper = (1 - t / t_max) * T\n", + " flip_idx = np.random.randint(num_nodes)\n", + " next_state[flip_idx] = 1 - next_state[flip_idx]\n", + " next_E = energy(1 - 2 * next_state, graph, num_cls, normalize=False)\n", + " if next_E <= E or np.exp(-(next_E - E) / temper) > np.random.rand():\n", + " state[flip_idx] = 1 - state[flip_idx]\n", + " E = next_E\n", + " else:\n", + " next_state[flip_idx] = 1 - next_state[flip_idx]\n", + " t += 1\n", + " return tuple(state), E" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:53.444340600Z", + "start_time": "2023-06-30T07:04:53.442102700Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 182, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of low-lying excited states: 21\n" + ] + } + ], + "source": [ + "# obtain the low-lying excited states\n", + "ll_excited, n_exp = set(), 100\n", + "for _ in range(n_exp):\n", + " sa_case, sa_cost = sim_annealing(hard_graph, 200, 1)\n", + " if sa_cost > 1e-6:\n", + " ll_excited.add(sa_case)\n", + "print(f'number of low-lying excited states: {len(ll_excited)}')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:56.794388500Z", + "start_time": "2023-06-30T07:04:53.442661600Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 183, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of clauses should be kept: 12\n", + "number of clauses can be discarded: 60\n", + "number of clauses after dropout: 42\n" + ] + } + ], + "source": [ + "# obtain the clauses violated by low-lying excited states and the clauses can be discarded\n", + "def get_clauses(ll_exc_st, clauses):\n", + " kept, drop = [], []\n", + " for cls in clauses:\n", + " violated = False\n", + " for state in ll_exc_st:\n", + " if sum(state[i] for i in cls) in [0, 3]:\n", + " kept.append(cls)\n", + " violated = True\n", + " break\n", + " if not violated:\n", + " drop.append(cls)\n", + " return kept, drop\n", + "\n", + "kept_clauses, drop_clauses = get_clauses(ll_excited, hard_clauses)\n", + "num_selected = int((1 - R) * len(drop_clauses))\n", + "num_after_drop = len(kept_clauses) + num_selected\n", + "driving_factor = 1 / num_after_drop / 4\n", + "print(f'number of clauses should be kept: {len(kept_clauses)}')\n", + "print(f'number of clauses can be discarded: {len(drop_clauses)}')\n", + "print(f'number of clauses after dropout: {num_after_drop}')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:56.798234600Z", + "start_time": "2023-06-30T07:04:56.794388500Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "There are two ways of quantum dropout. One isotropic or uniform, i.e., $\\hat H_{C_1} = \\hat H_{C_2} = \\cdots = \\hat H_{C_p}$. The other is random or different, i.e., $\\hat H_{C_i}\\neq\\hat H_{C_j}$ if $i\\neq j$." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "### Isotropic Quantum Dropout" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 184, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get the graph after dropout\n", + "iso_clauses = kept_clauses + random.sample(drop_clauses, num_selected)\n", + "iso_graph = construct_graph(iso_clauses)\n", + "nx.draw_networkx(iso_graph, with_labels=True, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:56.975607Z", + "start_time": "2023-06-30T07:04:56.798234600Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The PQC is similar to the regular QAOA, but the cost Hamiltonian is the original Hamiltonian but the driving Hamiltonian is the one after dropout." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 185, + "outputs": [], + "source": [ + "def QAOAansatz_iso(params, g, each=1, return_circuit=False):\n", + " n = g.number_of_nodes() # the number of nodes\n", + "\n", + " # PQC loop\n", + " def pqc_loop(s_, params_):\n", + " c_ = tc.Circuit(n, inputs=s_)\n", + " for j in range(each):\n", + " # driving layer\n", + " for a, b in g.edges:\n", + " c_.RZZ(a, b, theta=g[a][b]['weight'] * params_[2 * j] * driving_factor)\n", + " # mixing layer\n", + " for i in range(n):\n", + " c_.RX(i, theta=params_[2 * j + 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(n)\n", + " for i in range(n):\n", + " c0.H(i)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, K.reshape(params, [nlayers // each, 2 * each]), s0)\n", + " c = tc.Circuit(n, inputs=s)\n", + "\n", + " # whether to return the circuit\n", + " if return_circuit is True:\n", + " return c\n", + "\n", + " # calculate the loss function\n", + " loss = 0.25\n", + " for a, b in hard_graph.edges:\n", + " loss += c.expectation_ps(z=[a, b]) * hard_graph[a][b]['weight'] * cost_factor\n", + "\n", + " return K.real(loss)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:04:56.978247300Z", + "start_time": "2023-06-30T07:04:56.976145900Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Here, several circuits with different initial parameters are optimized/trained at the same time." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 186, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "backend = type(K).__name__\n", + "# use vvag to get the losses and gradients with different random circuit instances\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz_iso, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "\n", + "params_iso = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", + "if backend == 'JaxBackend':\n", + " opt = K.optimizer(optax.adam(1e-2))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(2000):\n", + " loss, grads = QAOA_vvag(params_iso, iso_graph)\n", + " params_iso = opt.update(grads, params_iso) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", + " plt.show()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we can also use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 187, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #0\n", + "measurement prob: 0.018767010420560837\n", + "output: 111000100101\n", + "cost: 0.04574383422732353\n", + "max prob: 0.04061311483383179\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #1\n", + "measurement prob: 0.01276576891541481\n", + "output: 111001011000\n", + "cost: 0.04524344578385353\n", + "max prob: 0.04112391918897629\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #2\n", + "measurement prob: 0.0424429252743721\n", + "output: 000111011110\n", + "cost: 0.03893017768859863\n", + "max prob: 0.048920851200819016\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #3\n", + "measurement prob: 0.0024669470731168985\n", + "output: 011101011100\n", + "cost: 0.03952330723404884\n", + "max prob: 0.04860881343483925\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #4\n", + "measurement prob: 0.018215017393231392\n", + "output: 000111000101\n", + "cost: 0.045170776546001434\n", + "max prob: 0.04154610633850098\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #5\n", + "measurement prob: 0.03104996867477894\n", + "output: 111000011000\n", + "cost: 0.041469376534223557\n", + "max prob: 0.04604189097881317\n", + "bit strings: ['111111000000']\n", + "\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print QAOA results\n", + "for num_circuit in range(ncircuits):\n", + " print(f'Circuit #{num_circuit}')\n", + " c = QAOAansatz_iso(params=params_iso[num_circuit], g=iso_graph, return_circuit=True)\n", + " loss = QAOAansatz_iso(params=params_iso[num_circuit], g=iso_graph)\n", + "\n", + " # measurement output\n", + " m_out, m_prob = c.sample()\n", + " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", + " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", + "\n", + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:26:06.999371800Z", + "start_time": "2023-06-30T07:25:37.198477Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "On average, QAOA with isotropic quantum dropout improves the probability of correct solution (max prob) by nearly 0.01 compared to regular QAOA.\n", + "\n", + "It should be noted that isotropic quantum dropout will lead to more ground state degeneracy, so it does not necessarily lead to better results than conventional QAOA. However, it has a high upper limit, which means that it is possible to get much better results, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more analysis and details." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "### Random Quantum Dropout" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Because the dropout of each layer is different, we need to generate $\\text{nlayers}$ graphs after dropout. In order to perform just-in-time (JIT) compilation more conveniently, here we only save the weights in the order of the edges of the original $\\text{hard\\_graph}$, instead of saving each graph after dropout." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 188, + "outputs": [], + "source": [ + "def graph_weights(graph):\n", + " gw = []\n", + " for a, b in hard_graph.edges:\n", + " gw.append(graph[a].get(b, default={'weight': 0})['weight'])\n", + " return jnp.asarray(gw)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:26:07.002622300Z", + "start_time": "2023-06-30T07:26:06.999371800Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 189, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get the graph after dropout\n", + "rnd_graphs_w = []\n", + "for _ in range(nlayers):\n", + " rnd_clauses = kept_clauses + random.sample(drop_clauses, num_selected)\n", + " rnd_graph = construct_graph(rnd_clauses)\n", + " rnd_graphs_w.append(graph_weights(rnd_graph))\n", + "rnd_graphs_w = jnp.stack(rnd_graphs_w, axis=0)\n", + "nx.draw_networkx(rnd_graph, with_labels=True, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:26:07.185324Z", + "start_time": "2023-06-30T07:26:06.999940800Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The ansatz needs to accept $\\text{nlayers}$ weights of graphs as inputs." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 190, + "outputs": [], + "source": [ + "def QAOAansatz_rnd(params, g, each=1, return_circuit=False):\n", + " n = hard_graph.number_of_nodes() # the number of nodes\n", + " rep = nlayers // each\n", + " g = g.reshape(rep, each, g.shape[-1]) * driving_factor\n", + "\n", + " # PQC loop\n", + " def pqc_loop(s_, pkg):\n", + " params_, g_ = pkg\n", + " c_ = tc.Circuit(n, inputs=s_)\n", + " for j in range(each):\n", + " # driving layer\n", + " for i, (a, b) in enumerate(hard_graph.edges):\n", + " c_.RZZ(a, b, theta=g_[j][i] * params_[2 * j])\n", + " # mixing layer\n", + " for i in range(n):\n", + " c_.RX(i, theta=params_[2 * j + 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(n)\n", + " for i in range(n):\n", + " c0.H(i)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, [K.reshape(params, [rep, 2 * each]), g], s0)\n", + " c = tc.Circuit(n, inputs=s)\n", + "\n", + " # whether to return the circuit\n", + " if return_circuit is True:\n", + " return c\n", + "\n", + " # calculate the loss function\n", + " loss = 0.25\n", + " for a, b in hard_graph.edges:\n", + " loss += c.expectation_ps(z=[a, b]) * hard_graph[a][b]['weight'] * cost_factor\n", + "\n", + " return K.real(loss)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:26:07.283590400Z", + "start_time": "2023-06-30T07:26:07.174051300Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Then, we perform the optimization step, and also optimize several circuits in parallel. Since graph weights Jax arrays are non-hashable static arguments and not supported when using vmap, we use $\\text{partial}$ to wrap the ansatz and accept the graph weights input." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 191, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "backend = type(K).__name__\n", + "# use vvag to get the losses and gradients with different random circuit instances\n", + "QAOA_vvag = K.jit(K.vvag(partial(QAOAansatz_rnd, g=rnd_graphs_w), argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "\n", + "params_rnd = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", + "if backend == 'JaxBackend':\n", + " opt = K.optimizer(optax.adam(1e-2))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", + "\n", + "list_of_loss = [[] for i in range(ncircuits)]\n", + "\n", + "for i in range(2000):\n", + " loss, grads = QAOA_vvag(params_rnd)\n", + " params_rnd = opt.update(grads, params_rnd) # gradient descent\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " for index in range(ncircuits):\n", + " plt.plot(range(i + 1), list_of_loss[index])\n", + " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " plt.legend(legend)\n", + " plt.show()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 192, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit #0\n", + "measurement prob: 0.02918497659265995\n", + "output: 111000011000\n", + "cost: 0.03293716907501221\n", + "max prob: 0.06192261725664139\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #1\n", + "measurement prob: 0.0033539484720677137\n", + "output: 111010100001\n", + "cost: 0.03257792443037033\n", + "max prob: 0.06247476115822792\n", + "bit strings: ['000000111111']\n", + "\n", + "Circuit #2\n", + "measurement prob: 0.0022312484215945005\n", + "output: 101110000001\n", + "cost: 0.033498045057058334\n", + "max prob: 0.062363043427467346\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #3\n", + "measurement prob: 0.02523483708500862\n", + "output: 111000100101\n", + "cost: 0.037150800228118896\n", + "max prob: 0.052470263093709946\n", + "bit strings: ['000000111111', '111111000000']\n", + "\n", + "Circuit #4\n", + "measurement prob: 0.034201640635728836\n", + "output: 111000100001\n", + "cost: 0.034923672676086426\n", + "max prob: 0.05888247489929199\n", + "bit strings: ['111111000000']\n", + "\n", + "Circuit #5\n", + "measurement prob: 0.03789209946990013\n", + "output: 000111011110\n", + "cost: 0.0331316813826561\n", + "max prob: 0.06241282820701599\n", + "bit strings: ['111111000000']\n", + "\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print QAOA results\n", + "for num_circuit in range(ncircuits):\n", + " print(f'Circuit #{num_circuit}')\n", + " c = QAOAansatz_rnd(params=params_rnd[num_circuit], g=rnd_graphs_w, return_circuit=True)\n", + " loss = QAOAansatz_rnd(params=params_rnd[num_circuit], g=rnd_graphs_w)\n", + "\n", + " # measurement output\n", + " m_out, m_prob = c.sample()\n", + " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", + " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", + "\n", + " # find the states with max probabilities\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", + "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:49:27.992557200Z", + "start_time": "2023-06-30T07:48:48.070158100Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "On average, QAOA with random quantum dropout improves the probability of correct solution (max prob) by more than 0.02 compared to regular QAOA.\n", + "\n", + "Compared with isotropic quantum dropout, the standard deviation of the probability of correct solution obtained by random quantum dropout is smaller, but the upper limit is lower. From the physical picture, QAOA after random quantum dropout works like a quantum interferometer. QAOA circuits with different dropouts over driving layers may work through a focusing effect on the true ground state: different clause sets lead to different energy landscapes and minima, whose configurations receive constructive interference and enhanced amplitudes. Being the only common minimum of all $\\hat{H}_{C_i}$ irrespective of the dropouts, the true ground state remains stand-out through all driving layers. Please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more analysis and details." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 193, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OS info: Linux-5.4.119-1-tlinux4-0010.2-x86_64-with-glibc2.28\n", + "Python version: 3.10.11\n", + "Numpy version: 1.23.5\n", + "Scipy version: 1.11.0\n", + "Pandas version: 2.0.2\n", + "TensorNetwork version: 0.4.6\n", + "Cotengra is not installed\n", + "TensorFlow version: 2.12.0\n", + "TensorFlow GPU: []\n", + "TensorFlow CUDA infos: {'cpu_compiler': '/dt9/usr/bin/gcc', 'cuda_compute_capabilities': ['sm_35', 'sm_50', 'sm_60', 'sm_70', 'sm_75', 'compute_80'], 'cuda_version': '11.8', 'cudnn_version': '8', 'is_cuda_build': True, 'is_rocm_build': False, 'is_tensorrt_build': True}\n", + "Jax version: 0.4.13\n", + "Jax installation doesn't support GPU\n", + "JaxLib version: 0.4.13\n", + "PyTorch version: 2.0.1\n", + "PyTorch GPU support: False\n", + "PyTorch GPUs: []\n", + "Cupy is not installed\n", + "Qiskit version: 0.24.1\n", + "Cirq version: 1.1.0\n", + "TensorCircuit version 0.10.0\n" + ] + } + ], + "source": [ + "tc.about()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-06-30T07:49:27.995399900Z", + "start_time": "2023-06-30T07:49:27.993157500Z" + } + } + } + ], + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From b1165919df6788a5eed9b82d6b2f9945ea8570fa Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 3 Jul 2023 18:00:08 +0800 Subject: [PATCH 513/725] fix compiler bug --- tensorcircuit/compiler/simple_compiler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/compiler/simple_compiler.py b/tensorcircuit/compiler/simple_compiler.py index f1641594..868a678e 100644 --- a/tensorcircuit/compiler/simple_compiler.py +++ b/tensorcircuit/compiler/simple_compiler.py @@ -289,7 +289,7 @@ def simple_compile( ) c = replace_r(circuit, **compiled_options) - c = replace_u(circuit, **compiled_options) + c = replace_u(c, **compiled_options) qir = c.to_qir() len0 = len(qir) qir = merge(qir, **compiled_options) From dc6d6c512ac586314c12c54a8e5c4356fa635bef Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 3 Jul 2023 18:10:45 +0800 Subject: [PATCH 514/725] Revert templates.rst to commit afc36a163bf0a22ac572e589d2e56c5131d74d17 --- docs/source/api/templates.rst | 2 -- .../{tutorials/figs => statics}/landscape.jpg | Bin docs/source/{tutorials/figs => statics}/qd_alg.jpg | Bin 3 files changed, 2 deletions(-) rename docs/source/{tutorials/figs => statics}/landscape.jpg (100%) rename docs/source/{tutorials/figs => statics}/qd_alg.jpg (100%) diff --git a/docs/source/api/templates.rst b/docs/source/api/templates.rst index d76ab744..897ff36c 100644 --- a/docs/source/api/templates.rst +++ b/docs/source/api/templates.rst @@ -1,10 +1,8 @@ tensorcircuit.templates ================================================================================ .. toctree:: - templates/ansatz.rst templates/blocks.rst templates/chems.rst - templates/conversions.rst templates/dataset.rst templates/ensemble.rst templates/graphs.rst diff --git a/docs/source/tutorials/figs/landscape.jpg b/docs/source/statics/landscape.jpg similarity index 100% rename from docs/source/tutorials/figs/landscape.jpg rename to docs/source/statics/landscape.jpg diff --git a/docs/source/tutorials/figs/qd_alg.jpg b/docs/source/statics/qd_alg.jpg similarity index 100% rename from docs/source/tutorials/figs/qd_alg.jpg rename to docs/source/statics/qd_alg.jpg From 459ab38b9659acfcd19cb4ca2626ab0b799d6ec2 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 3 Jul 2023 18:14:22 +0800 Subject: [PATCH 515/725] Revert applications.rst to commit afc36a163bf0a22ac572e589d2e56c5131d74d17 --- docs/source/api/applications.rst | 3 --- 1 file changed, 3 deletions(-) diff --git a/docs/source/api/applications.rst b/docs/source/api/applications.rst index 337c8aec..2ecae939 100644 --- a/docs/source/api/applications.rst +++ b/docs/source/api/applications.rst @@ -1,12 +1,9 @@ tensorcircuit.applications ================================================================================ .. toctree:: - applications/ai.rst applications/dqas.rst - applications/finance.rst applications/graphdata.rst applications/layers.rst - applications/physics.rst applications/utils.rst applications/vags.rst applications/van.rst From dddfa421cca8cc4524229f68d4e2274a1480548b Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 3 Jul 2023 19:34:04 +0800 Subject: [PATCH 516/725] add qaoa_nae3sat.ipynb and qaoa_quantum_dropout.ipynb to tutorial.rst, revert check_all.sh --- docs/source/tutorial.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index c7bae543..6c71ea41 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -6,6 +6,8 @@ Jupyter Tutorials tutorials/circuit_basics.ipynb tutorials/qaoa.ipynb + tutorials/qaoa_nae3sat.ipynb + tutorials/qaoa_quantum_dropout.ipynb tutorials/tfim_vqe.ipynb tutorials/mnist_qml.ipynb tutorials/torch_qml.ipynb From dffffed47771f725ede930ee96ab40ab162e1d16 Mon Sep 17 00:00:00 2001 From: peilin <45784888+PeilinZHENG@users.noreply.github.com> Date: Mon, 3 Jul 2023 19:35:39 +0800 Subject: [PATCH 517/725] Delete check_all.sh --- check_all.sh | 15 --------------- 1 file changed, 15 deletions(-) delete mode 100644 check_all.sh diff --git a/check_all.sh b/check_all.sh deleted file mode 100644 index 84e839ef..00000000 --- a/check_all.sh +++ /dev/null @@ -1,15 +0,0 @@ -#! /bin/sh -set -e -echo "black check" -black . --check -echo "mypy check" -mypy tensorcircuit -echo "pylint check" -pylint tensorcircuit tests examples/*.py -echo "pytest check" -pytest -n auto --cov=tensorcircuit -vv -W ignore::DeprecationWarning -# for test on gpu machine, please set `export TF_FORCE_GPU_ALLOW_GROWTH=true` for tf -# and `export XLA_PYTHON_CLIENT_PREALLOCATE=false` for jax to avoid OOM in testing -echo "sphinx check" -cd docs && sphinx-build source build/html && sphinx-build source -D language="zh" build/html_cn -echo "all checks passed, congratulation! 💐" From 867a256858039d4cd0faebd4050d8563cf3eb2fe Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 3 Jul 2023 19:36:42 +0800 Subject: [PATCH 518/725] update --- check_all.sh | 15 --------------- 1 file changed, 15 deletions(-) delete mode 100644 check_all.sh diff --git a/check_all.sh b/check_all.sh deleted file mode 100644 index 84e839ef..00000000 --- a/check_all.sh +++ /dev/null @@ -1,15 +0,0 @@ -#! /bin/sh -set -e -echo "black check" -black . --check -echo "mypy check" -mypy tensorcircuit -echo "pylint check" -pylint tensorcircuit tests examples/*.py -echo "pytest check" -pytest -n auto --cov=tensorcircuit -vv -W ignore::DeprecationWarning -# for test on gpu machine, please set `export TF_FORCE_GPU_ALLOW_GROWTH=true` for tf -# and `export XLA_PYTHON_CLIENT_PREALLOCATE=false` for jax to avoid OOM in testing -echo "sphinx check" -cd docs && sphinx-build source build/html && sphinx-build source -D language="zh" build/html_cn -echo "all checks passed, congratulation! 💐" From 7859c6f26ed8345c3e5da27644420b79f147deee Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 3 Jul 2023 19:37:41 +0800 Subject: [PATCH 519/725] update --- check_all.sh | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 check_all.sh diff --git a/check_all.sh b/check_all.sh new file mode 100644 index 00000000..84e839ef --- /dev/null +++ b/check_all.sh @@ -0,0 +1,15 @@ +#! /bin/sh +set -e +echo "black check" +black . --check +echo "mypy check" +mypy tensorcircuit +echo "pylint check" +pylint tensorcircuit tests examples/*.py +echo "pytest check" +pytest -n auto --cov=tensorcircuit -vv -W ignore::DeprecationWarning +# for test on gpu machine, please set `export TF_FORCE_GPU_ALLOW_GROWTH=true` for tf +# and `export XLA_PYTHON_CLIENT_PREALLOCATE=false` for jax to avoid OOM in testing +echo "sphinx check" +cd docs && sphinx-build source build/html && sphinx-build source -D language="zh" build/html_cn +echo "all checks passed, congratulation! 💐" From 2d111a41910a9bf848502ad7969b313a166d06b5 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 4 Jul 2023 09:50:45 +0800 Subject: [PATCH 520/725] Fixed typo, removed redundant output. --- docs/source/tutorials/qaoa_nae3sat.ipynb | 326 ++++++------------ .../tutorials/qaoa_quantum_dropout.ipynb | 284 ++++++--------- 2 files changed, 218 insertions(+), 392 deletions(-) diff --git a/docs/source/tutorials/qaoa_nae3sat.ipynb b/docs/source/tutorials/qaoa_nae3sat.ipynb index 21d979bb..fc87efe6 100644 --- a/docs/source/tutorials/qaoa_nae3sat.ipynb +++ b/docs/source/tutorials/qaoa_nae3sat.ipynb @@ -21,7 +21,7 @@ "id": "b533d43e", "metadata": {}, "source": [ - "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In QAOA, the parameterized quantum circuit is regarded as an oracle, we sample the circuit to obtain the gradient of the parameters, and update them through the classical optimizer. Before this tutorial, there was already a tutorial of [QAOA for Max-Cut](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html). In this tutorial, we will focus on another combinatorial optimization problem - Not-all-equal 3-satisfiability (NAE3SAT), and discuss the performance of QAOA in different hardness cases.\n" + "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In QAOA, the parameterized quantum circuit is regarded as an oracle, we sample the circuit to obtain the gradient of the parameters, and update them through the classical optimizer. Before this tutorial, there was already a tutorial of [QAOA for Max-Cut](qaoa.ipynb). In this tutorial, we will focus on another combinatorial optimization problem - Not-all-equal 3-satisfiability (NAE3SAT), and discuss the performance of QAOA in different hardness cases.\n" ] }, { @@ -61,12 +61,12 @@ "$$\n", "\\begin{equation}\n", " \\begin{split}\n", - " H_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", " \\end{split}\n", "\\end{equation}\n", "$$\n", - "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $H_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT." + "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $\\hat{H}_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT." ] }, { @@ -94,7 +94,7 @@ " U(\\boldsymbol{\\beta}, \\boldsymbol{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", "\\end{equation}\n", "$$\n", - "where $U_{j}= e^{-i\\gamma_{j}H_{C}}$ is the driving layer and $V_{j}= e^{-i \\beta_{j} H_m}$ is the mixing layer. $H_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $H_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." + "where $U_{j}= e^{-i\\gamma_{j}\\hat{H}_{C}}$ is the driving layer and $V_{j}= e^{-i \\beta_{j} \\hat{H}_m}$ is the mixing layer. $H_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $\\hat{H}_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." ] }, { @@ -104,7 +104,7 @@ "source": [ "Begin with a set of initial $\\boldsymbol{\\gamma}$ and $\\boldsymbol{\\beta}$, the quantum state is obtained from the PQC and then the expectation value of $H_C$ is calculated. A classical optimizer is then used to vary the parameters until a lower expectation value is found. This process is iterated a certain number of times until the expectation value of $H_C$ is approximated to 0. Then we perform projective measurement on the quantum state output by PQC, and obtain a bit string, which is very likely to be the solution of NAE3SAT. Since NAE3SAT is an NP-complete problem, we can verify whether the solution is correct in polynomial time on classical computer. Even if this bit string is not the correct solution, we can repeat the projective measurement and verify the obtained solution until we get the correct solution.\n", "\n", - "For other details of QAOA, such as the selection of $p$ and the overall algorithm loop, please refer to [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028) or the tutorial of [QAOA for Max-Cut](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html)." + "For other details of QAOA, such as the selection of $p$ and the overall algorithm loop, please refer to [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028) or the tutorial of [QAOA for Max-Cut](qaoa.ipynb)." ] }, { @@ -121,8 +121,8 @@ "id": "b0def04d", "metadata": { "ExecuteTime": { - "end_time": "2023-06-30T02:02:33.234006600Z", - "start_time": "2023-06-30T02:02:33.229847200Z" + "end_time": "2023-07-03T11:21:55.043565200Z", + "start_time": "2023-07-03T11:21:54.946406500Z" } }, "outputs": [], @@ -155,7 +155,7 @@ "id": "c82972a4", "metadata": {}, "source": [ - "The graph of NAE3SAT is constructed by the set $\\mathcal{C}$ of clauses. When a clause is violated, the energy will increase by 4, so the upper bound of $H_C$ will not exceed $4|\\mathcal{C}|$. In practice, we multiply $H_C$ by a normalization factor $1/(4|\\mathcal{C}|)$." + "The graph of NAE3SAT is constructed by the set $\\mathcal{C}$ of clauses. When a clause is violated, the energy will increase by 4, so the upper bound of $\\hat{H}_C$ will not exceed $4|\\mathcal{C}|$. In practice, we multiply $\\hat{H}_C$ by a normalization factor $1/(4|\\mathcal{C}|)$." ] }, { @@ -164,17 +164,15 @@ "id": "f1532831", "metadata": { "ExecuteTime": { - "end_time": "2023-06-30T02:02:33.397944100Z", - "start_time": "2023-06-30T02:02:33.231412200Z" + "end_time": "2023-07-03T11:21:55.148550800Z", + "start_time": "2023-07-03T11:21:54.965499300Z" } }, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -215,8 +213,8 @@ "id": "055d1257", "metadata": { "ExecuteTime": { - "end_time": "2023-06-30T02:02:33.427591300Z", - "start_time": "2023-06-30T02:02:33.396852700Z" + "end_time": "2023-07-03T11:21:55.167476700Z", + "start_time": "2023-07-03T11:21:55.166422100Z" } }, "outputs": [], @@ -287,22 +285,19 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "backend = type(K).__name__\n", "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3))\n", "\n", "params_easy = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", - "if backend == 'JaxBackend':\n", + "if type(K).__name__ == 'JaxBackend':\n", " opt = K.optimizer(optax.adam(1e-2))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", @@ -338,7 +333,7 @@ "id": "fc1c257d", "metadata": {}, "source": [ - "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we can also use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." + "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we directly use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." ] }, { @@ -346,13 +341,13 @@ "execution_count": 9, "id": "8c5df93e", "metadata": { - "ExecuteTime": { - "end_time": "2023-06-30T02:29:09.636366200Z", - "start_time": "2023-06-30T02:28:26.850918300Z" - }, "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-03T11:48:26.692908100Z", + "start_time": "2023-07-03T11:47:45.326665300Z" } }, "outputs": [ @@ -361,58 +356,36 @@ "output_type": "stream", "text": [ "Circuit #0\n", - "measurement prob: 0.244925856590271\n", - "output: 111111000000\n", - "cost: 0.021371711045503616\n", - "max prob: 0.24492625892162323\n", - "bit strings: ['000000111111']\n", + "cost: 0.014918745495378971\n", + "max prob: 0.2869008183479309\n", + "bit strings: ['111111000000']\n", "\n", "Circuit #1\n", - "measurement prob: 0.2965589463710785\n", - "output: 000000111111\n", - "cost: 0.013323463499546051\n", - "max prob: 0.2965589165687561\n", - "bit strings: ['000000111111']\n", + "cost: 0.030193958431482315\n", + "max prob: 0.21499991416931152\n", + "bit strings: ['111111000000']\n", "\n", "Circuit #2\n", - "measurement prob: 0.05372887849807739\n", - "output: 111111000001\n", - "cost: 0.018687034025788307\n", - "max prob: 0.26440468430519104\n", + "cost: 0.021412445232272148\n", + "max prob: 0.24743150174617767\n", "bit strings: ['000000111111']\n", "\n", "Circuit #3\n", - "measurement prob: 0.2904357314109802\n", - "output: 000000111111\n", - "cost: 0.014396688900887966\n", - "max prob: 0.2904358506202698\n", + "cost: 0.013799840584397316\n", + "max prob: 0.2941778600215912\n", "bit strings: ['000000111111']\n", "\n", "Circuit #4\n", - "measurement prob: 0.2968122959136963\n", - "output: 000000111111\n", - "cost: 0.01325833611190319\n", - "max prob: 0.29681235551834106\n", - "bit strings: ['000000111111']\n", + "cost: 0.014260157942771912\n", + "max prob: 0.29104718565940857\n", + "bit strings: ['111111000000']\n", "\n", "Circuit #5\n", - "measurement prob: 0.28433939814567566\n", - "output: 000000111111\n", - "cost: 0.015517047606408596\n", - "max prob: 0.2843400239944458\n", + "cost: 0.013322753831744194\n", + "max prob: 0.2968374788761139\n", "bit strings: ['111111000000']\n", "\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -422,11 +395,6 @@ " c = QAOAansatz(params=params_easy[num_circuit], g=easy_graph, return_circuit=True)\n", " loss = QAOAansatz(params=params_easy[num_circuit], g=easy_graph)\n", "\n", - " # measurement output\n", - " m_out, m_prob = c.sample()\n", - " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", - " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", - "\n", " # find the states with max probabilities\n", " probs = K.numpy(c.probability())\n", " max_prob = max(probs)\n", @@ -435,13 +403,7 @@ " for i in index:\n", " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", "\n", - " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", - "\n", - "# plot NetworkX graph\n", - "colors = ['r' if m_out[i] == '0' else 'c' for i in easy_graph.nodes]\n", - "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", - "ax = plt.gca()\n", - "ax.set_facecolor('w')" + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')" ] }, { @@ -466,8 +428,8 @@ "id": "2115bb6d", "metadata": { "ExecuteTime": { - "end_time": "2023-06-30T02:29:09.636366200Z", - "start_time": "2023-06-30T02:29:09.635854Z" + "end_time": "2023-07-03T11:48:26.693910800Z", + "start_time": "2023-07-03T11:48:26.692908100Z" } }, "outputs": [], @@ -504,13 +466,13 @@ "execution_count": 11, "id": "b0cdc04f", "metadata": { - "ExecuteTime": { - "end_time": "2023-06-30T02:29:09.976150600Z", - "start_time": "2023-06-30T02:29:09.635854Z" - }, "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-03T11:48:27.165348700Z", + "start_time": "2023-07-03T11:48:26.692908100Z" } }, "outputs": [ @@ -524,10 +486,8 @@ }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -558,13 +518,13 @@ "execution_count": 12, "id": "e1551fb4", "metadata": { - "ExecuteTime": { - "end_time": "2023-06-30T02:29:09.976664900Z", - "start_time": "2023-06-30T02:29:09.976150600Z" - }, "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-03T11:48:27.165348700Z", + "start_time": "2023-07-03T11:48:27.164345100Z" } }, "outputs": [], @@ -591,16 +551,16 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 13, "id": "04596ec1", "metadata": { - "ExecuteTime": { - "end_time": "2023-06-30T02:53:56.645392800Z", - "start_time": "2023-06-30T02:53:52.616150200Z" - }, "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-03T11:48:31.015863400Z", + "start_time": "2023-07-03T11:48:27.165348700Z" } }, "outputs": [ @@ -608,21 +568,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "output: 111111000000\n", "cost: 0.000\n", - "prob: 0.880\n", + "prob: 0.910\n", "bit string: ['000000111111', '111111000000']\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -638,13 +587,7 @@ " sa_best_cases.append(sa_case)\n", "sa_prob = len(sa_best_cases) / n_exp\n", "sa_best_cases = list(set(sa_best_cases))\n", - "print(f'output: {sa_case}\\ncost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')\n", - "\n", - "# plot NetworkX graph\n", - "colors = ['r' if sa_case[i] == '0' else 'c' for i in easy_graph.nodes]\n", - "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", - "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "print(f'cost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')" ] }, { @@ -660,7 +603,7 @@ "id": "9f8cb1da", "metadata": {}, "source": [ - "We call the above problem a easy problem, because the classical simulated annealing method has a high probability to obtain the correct solution. Now let's define another relatively hard problem." + "We call the above problem an easy problem, because the classical simulated annealing method has a high probability to obtain the correct solution. Now let's define another relatively hard problem." ] }, { @@ -669,17 +612,15 @@ "id": "b0a1f778", "metadata": { "ExecuteTime": { - "end_time": "2023-06-30T02:29:14.201998500Z", - "start_time": "2023-06-30T02:29:14.058753400Z" + "end_time": "2023-07-03T11:48:31.522735600Z", + "start_time": "2023-07-03T11:48:30.976530700Z" } }, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -719,13 +660,13 @@ "execution_count": 15, "id": "f22b5956", "metadata": { - "ExecuteTime": { - "end_time": "2023-06-30T02:29:14.525210200Z", - "start_time": "2023-06-30T02:29:14.223057500Z" - }, "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-03T11:48:31.523763100Z", + "start_time": "2023-07-03T11:48:31.070473700Z" } }, "outputs": [ @@ -739,10 +680,8 @@ }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -762,16 +701,16 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 16, "id": "9df75fbc", "metadata": { - "ExecuteTime": { - "end_time": "2023-06-30T02:53:22.166071800Z", - "start_time": "2023-06-30T02:53:18.629941Z" - }, "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-03T11:48:35.050434800Z", + "start_time": "2023-07-03T11:48:31.518734800Z" } }, "outputs": [ @@ -779,21 +718,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "output: 111000010001\n", "cost: 0.000\n", - "prob: 0.090\n", + "prob: 0.070\n", "bit string: ['000000111111', '111111000000']\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -809,13 +737,7 @@ " sa_best_cases.append(sa_case)\n", "sa_prob = len(sa_best_cases) / n_exp\n", "sa_best_cases = list(set(sa_best_cases))\n", - "print(f'output: {sa_case}\\ncost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')\n", - "\n", - "# plot NetworkX graph\n", - "colors = ['r' if sa_case[i] == '0' else 'c' for i in hard_graph.nodes]\n", - "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", - "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "print(f'cost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')" ] }, { @@ -825,7 +747,7 @@ "source": [ "We found that the probability of SA getting the correct solution on the hard problem is much lower than that on the easy problem. This is because the energy landscape is different for the easy and hard problem, as shown in the following figure.\n", "\n", - "\n", + "\n", "\n", "The global minimum is located in a large and smooth neighborhood for a simpler problem and a narrow region for a harder problem. It is worth noting that when the system size is relatively small, most of the randomly generated problems are easy, and hard problems need to be constructed with special methods, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." ] @@ -840,7 +762,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "id": "1f6ba479", "metadata": { "collapsed": false, @@ -851,22 +773,19 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "backend = type(K).__name__\n", "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3))\n", "\n", "params_hard = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", - "if backend == 'JaxBackend':\n", + "if type(K).__name__ == 'JaxBackend':\n", " opt = K.optimizer(optax.adam(1e-2))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", @@ -891,16 +810,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 21, "id": "a6b7606f", "metadata": { - "ExecuteTime": { - "end_time": "2023-06-30T02:52:31.104782900Z", - "start_time": "2023-06-30T02:51:56.848514800Z" - }, "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-03T14:01:09.731783100Z", + "start_time": "2023-07-03T14:00:36.495805100Z" } }, "outputs": [ @@ -909,58 +828,36 @@ "output_type": "stream", "text": [ "Circuit #0\n", - "measurement prob: 0.011892922222614288\n", - "output: 100111100001\n", - "cost: 0.03514176607131958\n", - "max prob: 0.03562089055776596\n", + "cost: 0.02998761646449566\n", + "max prob: 0.04241819679737091\n", "bit strings: ['111111000000']\n", "\n", "Circuit #1\n", - "measurement prob: 0.021911870688199997\n", - "output: 111100100001\n", - "cost: 0.029562288895249367\n", - "max prob: 0.04285888373851776\n", + "cost: 0.034460458904504776\n", + "max prob: 0.03702807426452637\n", "bit strings: ['000000111111']\n", "\n", "Circuit #2\n", - "measurement prob: 0.016403989866375923\n", - "output: 111000011000\n", - "cost: 0.03551255911588669\n", - "max prob: 0.034648310393095016\n", + "cost: 0.04517427086830139\n", + "max prob: 0.027316443622112274\n", "bit strings: ['111111000000']\n", "\n", "Circuit #3\n", - "measurement prob: 0.006490767467767\n", - "output: 000110011110\n", - "cost: 0.029899753630161285\n", - "max prob: 0.042506810277700424\n", + "cost: 0.02961093559861183\n", + "max prob: 0.04281751438975334\n", "bit strings: ['111111000000']\n", "\n", "Circuit #4\n", - "measurement prob: 0.025229839608073235\n", - "output: 100110100001\n", - "cost: 0.03145389258861542\n", - "max prob: 0.04125567898154259\n", + "cost: 0.030255526304244995\n", + "max prob: 0.042135994881391525\n", "bit strings: ['111111000000']\n", "\n", "Circuit #5\n", - "measurement prob: 0.02942775934934616\n", - "output: 000111011110\n", - "cost: 0.03618713840842247\n", - "max prob: 0.035310640931129456\n", + "cost: 0.029639022424817085\n", + "max prob: 0.04278436675667763\n", "bit strings: ['000000111111']\n", "\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -970,11 +867,6 @@ " c = QAOAansatz(params=params_hard[num_circuit], g=hard_graph, return_circuit=True)\n", " loss = QAOAansatz(params=params_hard[num_circuit], g=hard_graph)\n", "\n", - " # measurement output\n", - " m_out, m_prob = c.sample()\n", - " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", - " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", - "\n", " # find the states with max probabilities\n", " probs = K.numpy(c.probability())\n", " max_prob = max(probs)\n", @@ -982,13 +874,7 @@ " states = []\n", " for i in index:\n", " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", - "\n", - "# plot NetworkX graph\n", - "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", - "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", - "ax = plt.gca()\n", - "ax.set_facecolor('w')" + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')" ] }, { @@ -996,21 +882,21 @@ "id": "565dd4a7", "metadata": {}, "source": [ - "The probability of QAOA getting the correct solution is also very low. A very simple trick can be adopted to improve the performance of QAOA, namely quantum dropout, please refer to following tutorials or [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." + "The probability of QAOA getting the correct solution is also very low. A very simple trick can be adopted to improve the performance of QAOA, namely quantum dropout, please refer to [following tutorials](qaoa_quantum_dropout.ipynb) or [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "id": "89ed16e3", "metadata": { - "ExecuteTime": { - "end_time": "2023-06-30T02:52:31.105332Z", - "start_time": "2023-06-30T02:52:31.104219200Z" - }, "collapsed": false, "jupyter": { "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-03T14:02:46.556219900Z", + "start_time": "2023-07-03T14:02:46.519177800Z" } }, "outputs": [ diff --git a/docs/source/tutorials/qaoa_quantum_dropout.ipynb b/docs/source/tutorials/qaoa_quantum_dropout.ipynb index 008ca304..232d5331 100644 --- a/docs/source/tutorials/qaoa_quantum_dropout.ipynb +++ b/docs/source/tutorials/qaoa_quantum_dropout.ipynb @@ -21,7 +21,7 @@ { "cell_type": "markdown", "source": [ - "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In the previous tutorial, we introduced solving the [Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) by QAOA and the dilemma of QAOA on the hard problem. In this tutorial, we will introduce a simple trick to alleviate this dilemma, namely quantum dropout, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more details.\n" + "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In the [previous tutorial](qaoa_nae3sat.ipynb), we introduced solving the [Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) by QAOA and the dilemma of QAOA on the hard problem. In this tutorial, we will introduce a simple trick to alleviate this dilemma, namely quantum dropout, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more details.\n" ], "metadata": { "collapsed": false @@ -50,11 +50,11 @@ " \\end{split}\n", "\\end{equation}\n", "$$\n", - "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $H_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT.\n", + "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $\\hat{H}_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT.\n", "\n", "The difference between the easy and hard problem is the energy landscape, as shown in the following figure.\n", "\n", - "\n", + "\n", "\n", "The global minimum is located in a large and smooth neighborhood for a simpler problem and a narrow region for a harder problem. It is worth noting that when the system size is relatively small, most of the randomly generated problems are easy, and hard problems need to be constructed with special methods, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171)." ], @@ -76,7 +76,7 @@ "source": [ "The algorithm is shown in the following figure.\n", "\n", - "\n", + "\n", "\n", "We first implement the classical algorithm that can be done in polynomial time, such as simulated annealing method (SA). If the result is satisfactory, we stop the procedure since there is no point in a quantum solver. Otherwise, these failed classical results, typically low-lying excited states (local minima), offer insights as we prepare quantum dropout for QAOA: whether a clause should be kept or available for quantum dropout to underweight the distracting local minima and enhance the chances to locate the true ground state. Specifically, the clauses violated by low-lying excited states should be all kept, and the other clauses can be randomly discarded at the ratio $R$.\n", "\n", @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 175, + "execution_count": null, "outputs": [], "source": [ "import tensorcircuit as tc\n", @@ -118,11 +118,7 @@ "R = 0.5 # dropout ratio, 0 means no dropout, 1 means all dropout" ], "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-06-30T07:04:53.070466200Z", - "start_time": "2023-06-30T07:04:52.893906200Z" - } + "collapsed": false } }, { @@ -136,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 176, + "execution_count": 2, "outputs": [], "source": [ "# a hard graph instance\n", @@ -146,14 +142,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:53.085860400Z", - "start_time": "2023-06-30T07:04:52.913910400Z" + "end_time": "2023-07-03T11:45:08.202605500Z", + "start_time": "2023-07-03T11:45:08.202029100Z" } } }, { "cell_type": "code", - "execution_count": 177, + "execution_count": 3, "outputs": [], "source": [ "# convert to a NetworkX graph\n", @@ -172,19 +168,19 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:53.090006Z", - "start_time": "2023-06-30T07:04:52.919783900Z" + "end_time": "2023-07-03T11:45:08.206621400Z", + "start_time": "2023-07-03T11:45:08.203172500Z" } } }, { "cell_type": "code", - "execution_count": 178, + "execution_count": 4, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -201,8 +197,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:53.098283300Z", - "start_time": "2023-06-30T07:04:52.932252Z" + "end_time": "2023-07-03T11:45:08.390560600Z", + "start_time": "2023-07-03T11:45:08.210412300Z" } } }, @@ -217,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 179, + "execution_count": 5, "outputs": [], "source": [ "def b2s(bit):\n", @@ -250,14 +246,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:53.178133800Z", - "start_time": "2023-06-30T07:04:53.126416600Z" + "end_time": "2023-07-03T11:45:08.390560600Z", + "start_time": "2023-07-03T11:45:08.390046300Z" } } }, { "cell_type": "code", - "execution_count": 180, + "execution_count": 6, "outputs": [ { "name": "stdout", @@ -270,7 +266,7 @@ { "data": { "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVhUWxfG3wm6UxoTCwW7u7sDG+zua3crFhcT61rY3XHtLuxWVERspGvm/f7gMh9IDTADqOf3POdRzuxYZ+LsddZe+90ikoSAgICAgIDAH4s4pw0QEBAQEBAQyFkEZ0BAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nCkyhSSy+UIDAyEgYEBRCKRum0SEBAQEBAQUAEkERoaChsbG4jFqT//K+UMBAYGwt7eXmXGCQgICAgICGQf7969g52dXaqvK+UMGBgYKBozNDRUjWUCAgICAgICaiUkJAT29vaKcTw1lHIGEqYGDA0NBWdAQEBAQEDgFyO9KX4hgVBAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nAEZ0BAQEBAQOAPR3AGBAQEBAQE/nCkOW2AgIDAb4RMBjx7Bnz5AohEgLk5UKgQIJHktGUCAgJpIDgDAgICWSMsDNiyBfjnH+DOHSAqKunr2tpAmTJAjx6Amxugp5cjZgoICKSOME0gICCQOWQyYOFCwMoK6N8fuHo1uSMAxJ+7cgXo3RuwtgaWLgXk8uy3V0BAIFUEZ0BAQCDjvH0LVK4MjBoFhIcDZPyRGgmDf2goMGwYUK0a8P59tpgqICCQPoIzICAgkDFevgQqVgRu3858G9evx7fx5o3q7BIQEMg0gjMgICCgPD9+ALVrA58/A3FxmW8nLg4ICopvKzRUdfYJCAhkCsEZEBAQUJ7hw+PD+6k4AmEApgBoCMAUgAjAhtTaiosD/P2BMWNUb6eAgECGEJwBAQEB5Th3Dli/Pj5xMBW+AJgO4DEAF2XalMuBFSviEwwFBARyDMEZEBAQUI5FiwBp2quRrQF8APAGwAJl25VKgSVLsmSagIBA1hCcAQEBgfR5/x44eDDdPAEtAFYZbTsuDti9G/j4MbPWCQgIZBHBGRAQEEifs2fTXjqYVWQy4MIF9bUvICCQJoIzICAgkD43bwIaGuprX0MDuHVLfe0LCAikieAMCAgIpM+zZ0BsrPraj4uL70NAQCBHEJwBAQGB9ElJZliVkEB0tHr7EBAQSBXBGRAQEEgfHR31ti8SxW9oJCAgkCMIzoCAgED6FCmi3pwBiSS+DwEBgRxBcAYEBATSp2xZ9ecMlCmjvvYFBATSJG0FEQEBAQEAcVWrQiwWQ6zE1sPeAIIBBP7390EAAf/9fzAAo5QqSaXxOxkKCAjkCIIzICAgkCrfvn2Dj48Pli1bBk+5HK2R/k3DE/EKhAns+e8AgC5IwRmQSoGOHQFzc5XYLCAgkHEEZ0BAQCAZDx48gJeXFzZv3gy5XI5OnTrBpUYNSHv0SLeuf0Y7k8niN0ASEBDIMQRnQEBAAAAgk8lw+PBhLF26FP/++y9sbGwwYcIE9OnTBxYWFvGFbt4Eli+P32BIFX0CeFSvHkqULq2S9gQEBDKHkEAoIPCH8+PHDyxevBhOTk5o0aIFIiIi4OvrC39/f0yYMOH/jgAAzJkDFCgASiRZ7pdSKT4aG6P8iRNwd3dHREREltsUEBDIHIIzICDwh/L06VMMGjQItra2GDNmDCpVqoRr167hypUr6NixIzRSWkqor4/Q/fsRKBYj7S2L0oYSCUSOjrB59Ag+mzZhx44dqFixIp4+fZqFVgUEBDKL4AwICPxByOVyHDt2DI0aNUKRIkWwc+dOjBw5Em/evMHmzZtRvnz5NOvHxsaizdChqKWtjec2NvFtZqB/ikQAgIva2og6cwawtkaXLl1w/fp1xMbGomzZstixY0dmL09AQCCTCM6AgMAfQGhoKJYtW4ZixYqhUaNG+PTpE/755x+8ffsW06ZNg7W1dbptkESfPn1w9uxZjPL0hPOHD+gDQG703/oAceq3E/l/r8mMjfFuxgzUi43F+MWLFa8XL14cN27cQPPmzdGhQwcMHjwY0YI8sYBA9kEl+PHjBwHwx48fyhQXEBDIJbx8+ZLDhw+noaEhJRIJ27dvz4sXL1Iul2e4rSlTphAAN2zYwGLFilEsFrN///5kdDTp60s2akSampLxOw38/zAzo6xRI/Y0NOSwgQNJkosWLSIAnjx5MkkfcrmcK1asoKamJsuVK0d/f3+VvA8CAn8qyo7fgjMgIPCbIZfLeerUKTZv3pwikYhmZmYcN24c3759m+k2161bRwCcPXs2p06dSpFIRBMTE37//v3nzsmAAK4aOJA1TE3J9+/jz5EcM2YMjY2NGRERQZlMxjp16tDW1pZfv35N1t+NGzeYN29empiY8NChQ5m2W0DgT0dwBgQE/jDCw8O5atUqFi9enABYokQJrlmzhhEREVlq9/jx45RKpezbty/v3LlDsVhMAFy/fn2qdebOnUszM7Mk5168eKGILJDku3fvaGxszA4dOqQYqfj27RubN29OABw3bhxjY2OzdB0CAn8igjMgIPCH8ObNG/711180MTGhSCRiy5Yt+e+//2ZqKuBn7ty5Q319fTZp0oQRERF0cXGhlpYWK1WqRJlMlmo9T09PGhoaJjtfr149VqpUSfH3tm3bCICbN29OsR25XM758+dTIpGwRo0aDAwMzPI1CQj8SQjOgIDAb4xcLuf58+fZpk0bisViGhkZceTIkXz16pXK+njz5g2tra1ZpkwZhoaGcvr06RSJRBSLxbxz506adZcsWUJdXd1k53ft2kUAvHfvnuJc586daWhomGZ+wPnz52ltbc08efLwzJkzmb0kAYE/DmXHb2E1gYDAL0RUVBQ2bNiAMmXKoHr16njw4AH+/vtvBAQEwNPTE/ny5VNJP8HBwWjcuDG0tLRw6NAhvHr1CtOnT4eGhgYGDBgAV1fXNOtraGggLi65EkHz5s2RJ08erFq1SnHO29sbRkZG6N69O2QyWYrtVatWDX5+fnB2dkadOnUwe/ZsyFWkgiggICAsLRQQ+CUIDAzEpEmT4ODgAHd3d1hbW+PYsWN49OgRBgwYAH19fZX1FR0djdatWyMwMBBHjx6FmZkZ3N3doaenByMjI8yYMSPdNqRSKWJT2PJYQ0MDHh4e2LRpk0Jx0NjYGBs3bsT58+exaNGiVNu0tLTE8ePHMWHCBEycOBHNmjXD169fM3+hAgIC/0eVYQYBAQHVcvXqVbq5uVEqlVJfX5+DBw/m06dP1dafXC5n586dqaWlxfPnz5MkZ86cqUgaTEj+S4+E1Qcp5RW8evWKIpGI69atS3J+9OjR1NDQoJ+fX7rtHz16lGZmZnRwcODVq1eVsklA4E9EyBkQEPhFiY6O5pYtW1i+fHkCYIECBbhkyRIGBwerve/x48cTALdv306SvH//PqVSKc3NzVm5cuU0kwYTs3HjRgJgVFRUiq83aNCAFSpUSHIuKiqKLi4uLF68OCMjI9Pt4+3bt6xUqRI1NDTo5eWlkoRJAYHfDcEZEBD4xfj48SOnT59Oa2trAmDdunV58OBBxsXFZUv/q1atIgB6enqSJGNjY1mmTBnmyZNHqaTBxPj6+hIAw8LCUnx9z549BJAsCnD//n1qaWlx2LBhSvUTHR3N4cOHEwDbtWsn3KMEBH5CcAYEBH4Rbt26xe7du1NTU5M6Ojrs27cvHz58mK02HDp0iGKxmIMHD1Y8Yc+ePZsikYi6urocPHhwhtrbuXMnASQXJfqPmJgYWltbxysY/sTixYtTVCdMi127dtHQ0JCFChXi3bt3M2SrgMDvjOAMCAjkYmJjY7ljxw5WrVqVAOjg4MD58+enqManbm7cuEFdXV22bNlSEYV48OABNTU1WaxYMVpaWqY6qKfGvn37CICfP39OtczEiRNpYGDA0NDQJOcT1AltbGwy9H48f/6cLi4u1NbWTpaPICDwpyIsLRQQyIV8/foV8+bNQ/78+dG+fXtIJBLs3r0bL1++xOjRo2Fqapqt9rx+/RpNmjRByZIlsWXLFkgkEsTFxcHd3R1WVlZ49OgR5s+fD2Nj4wy1K5VKASDFFQUJ9OrVC2FhYdi+fXuS82KxGBs2bEBERAT69+8Pkkr1WbBgQVy5cgVdunSBh4cHPDw8FCsWBAQE0kGVnoWAgEDK3Lt3j71796aOjg61tLTo4eGRoTl4dfD161cWLlyYBQoU4KdPnxTn586dS5FIxLx587JKlSpKJw0m5vjx4wSQ7n4IjRo1Yrly5VJ8bfv27QTATZs2Zbj/DRs2UEdHhyVLluSzZ88yXF9A4HdBmCYQEMhh4uLiuG/fPtauXZsAaGNjw1mzZiUZeHOKyMhIVq1alebm5kkGy4cPH1JTU5M1a9akWCxWaplfSpw+fZoA+PLlyzTLJUwn3L59O8XXu3Tpkq46YWrcu3ePhQsXpoGBAXfu3Jnh+gICvwPCNIGAQA4RHByMRYsWoVChQmjZsiUiIyOxbds2+Pv7Y/z48bCwsMhR++RyObp3746bN2/i4MGDKFSoEAAopgfs7e1x8+ZNDBw4EC4uLpnqI2GaICUVwsQ0adIEtra2SRQJE+Pt7Q1jY2N069YtVXXC1ChRogRu3LiBxo0bo127dhg6dChiYmIy1IaAwB+DKj0LAYE/mcePH3PAgAHU09OjhoYGu3TpwuvXr+e0WckYNWoURSIR9+zZk+T8/PnzKRKJWLdu3UwlDSbm8uXLBKDUqojJkydTX1+fISEhKb5+9uxZikQizps3L1O2yOVyent7U0NDgxUqVOCbN28y1Y6AwK+IME0gIJANyGQyHjlyhA0aNCAAWlpacsqUKfzw4UNOm5Yif//9NwHQy8sryfnHjx9TS0uL7dq1IwD+888/Wern+vXrKeoIpMTbt28pFou5atWqVMv89ddf1NDQyFKexbVr1+jo6EhTU1MeOXIk0+0ICPxKCM6AgIAaCQkJ4d9//00nJycCYJkyZbhx48ZUFfdyA3v37qVIJOKIESOSnI+Li2PFihVZqFAhFilShFWqVMmymt+dO3cIgDdv3lSqfNOmTVmmTJlUX09QJyxWrBgjIiIybdfXr1/ZpEkTAuD48eMZGxub6bYEBH4FBGdAQEANvHjxgsOGDaOhoSElEgnbt2/PS5cu5Xop3CtXrlBbW5vt2rVLtjrA09OTIpGIAwYMyFLSYGLu379PALxy5YpS5Q8cOJCu8/DgwQNqaWlx6NChWbJNJpNxzpw5FIvFrFWrVq6N4ggIqALBGRAQUBFyuZynTp1is2bNKBKJaGZmxnHjxqW7bC638Pz5c5qbm7NKlSrJNP+fPHlCbW1t9u7dm3p6ehwyZIhK+nzy5AkB8MKFC0qVj42NpZ2dHXv37p1muSVLlhAAT5w4kWUbz549SysrK1pZWfHs2bNZbk9AIDcirCYQEMgiERERWL16NUqUKIG6devC398fPj4+ePfuHWbPng17e/ucNjFdPn/+jEaNGsHMzAz79++Htra24jWZTAYPDw/Y2dnh+/fv0NPTw7Rp01TSrzKiQz+X79WrF7Zu3YqQkJBUyw0ePBh169ZFjx498O3btyzZWKNGDdy5cwdFixZF7dq1MXfuXMjl8iy1KSDwy6JKz0JA4HfA39+ff/31F01MTCgWi9myZUueOXMm108F/Ex4eDgrVqxIS0tLvnr1KtnrixYtokgkUuwFkNWkwcS8efMmw0/w7969o1gs5ooVK9IsFxAQQBMTE7Zr104ln0lcXBwnTJhAAGzatGmOSEILCKgLYZpAQCADyOVynjt3jm3atKFYLKaRkRFHjhyZ4iD6KxAXF8dWrVpRV1eXN27cSPb6s2fPqK2tzUGDBrFo0aKsWrWqSp2d9+/fEwAPHz6coXrNmzenq6trurYkqBNu3LgxK2Ym4fDhwzQ1NaWjo2OuXBIqIJAZhGkCAQEliIqKwvr161G6dGnUqFEDDx8+hLe3NwICAuDp6Yl8+fLltIkZhiRGjBiB/fv3Y/v27ShbtmyS12UyGdzd3WFrawtra2s8ffoU3t7eEIlEKrNBWdGhn+nbty/8/Pxw8+bNNMu1b98eXbt2xaBBg/DmzZtM25mYxo0b486dO7CyskKVKlXg7e2t9L4IAgK/PKr0LAQEfhXev3/PCRMm0NzcnADYpEkTHj9+/JebCkiJhQsXEkCq4faEJLydO3eqNGkwMd++fSMA7t69O0P14uLi6ODgwJ49e6ZbNjg4mI6Ojqxevbpit0VVEB0dzSFDhhAAO3TokKoYkoDAr4AwTSAgkAJXrlxhx44dKZVKaWBgwCFDhvxWG9ns2LGDADh27NgUX3/+/Dl1dHQ4ePBgdujQgXny5MmS0mBqhISEEAC3bduW4brTp0+nrq4ug4OD0y177tw5ikQizp07NzNmpsmOHTtoYGDAwoUL8/79+ypvX0AgOxCcAQGB/4iOjubmzZtZvnx5AmDBggW5dOnS3+77fOHCBWppabFTp04p7jQok8lYrVo15s+fnwcPHlR50mBiIiMjCYCbN2/OcN33799TIpFw2bJlSpVPUCdMbbOjrPD06VOWLFmSOjo63LBhg8rbFxBQN4IzIPDHExQUxGnTptHKyooAWK9ePR46dChTW/Lmdp48eUJTU1PWrFkzVRVELy8vRYa/OpIGExMbG0sAXL9+fabqt2zZkiVLllTKvqioKLq6umZZnTA1wsPD6e7uTgDs2bOnWvoQEFAXgjMg8Mdy69YtduvWjZqamtTV1WW/fv2U2jDnVyUoKIj58uVjsWLFUg35v3jxgrq6uhw4cCDnz59PiUTCu3fvqs0muVxOAPTx8clU/aNHj2ZIwTBBnVAd+Q8JrFu3jtra2nRxcfmtppYEfm8EZ0DgjyI2NpY7duxglSpVCICOjo5csGABv337ltOmqZWwsDCWLVuW1tbWqe7GJ5PJWLNmTebNm5dPnjyhnp5eliV9lUEqlXL58uWZqiuTyejo6MgePXooXUeV6oSpcffuXRYqVIgGBgbctWuX2voREFAVgjMg8Efw5csXzpkzh3Z2dgTAGjVqcM+ePSrNLs+txMbGsmnTptTX109zvnzZsmUEwNOnTyuSBpVJzssqOjo6yXZHzAgzZ86kjo6O0gmOMpmM9erVo42NjVqFg378+KHY3XHYsGGMjo5WW18CAllFcAYEfmvu3bvHXr16UVtbm1paWvTw8FDJBju/CnK5nP369aNEIuGxY8dSLffq1Svq6emxf//+PHXqlMqFetLCwMCACxcuzHT9wMBASqVS/v3330rXSVAnbNu2rVqXicrlcnp5eVFDQ4OVKlX6ZfapEPjzEJwBgd+OuLg47tu3j7Vq1SIA2tractasWfz8+XNOm5btzJkzhwC4du3aVMvIZDLWqlWLjo6O/PLlC4sUKaLWpMGfMTEx4bx587LURuvWrens7JwhmxOWV6prpURirl69SgcHB5qZmfHo0aNq709AIKMIzoDAb8P379+5cOFC5suXjwBYuXJlbtu2jTExMTltWo6wZcsWAuDkyZPTLLdixQoC4KlTp7IlafBnLC0tOWvWrCy1cfz4cQLgpUuXMlSva9euNDAw4OvXr7PUvzJ8+fKFjRo1okgk4qRJk/6IKSqBXwfBGRD45Xn8+DEHDBhAPT09amhosEuXLn+8ZvyZM2eooaHB7t27p/m0/Pr1a+rr67Nv37589+5dtiUNJsbGxoZTp07NUhsymYz58+dnt27dMlQvQZ2wWrVq2TI4y2Qyzpo1i2KxmHXq1GFQUJDa+xQQUAbBGRD4JZHJZDx8+DAbNGhAAMyTJw+nTJnCDx8+5LRpOc6DBw9oZGTEunXrppm0JpfLWadOHTo4OPDHjx9s3759tiUNJsbR0ZETJ07Mcjtz5syhtrZ2hleGnD9/niKRiHPmzMmyDcry77//Mk+ePLS2tub58+ezrV8BgdQQnAGBX4qQkBB6eXmxUKFCBMAyZcpw48aNqQro/Gm8f/+e9vb2LFmyZLq/w1WrVimW2GV30mBiChQowDFjxmS5nQ8fPlAqlXLp0qUZrjtmzBi1qROmRmBgIGvUqEGJRMJ58+b9FvtdCPy6CM6AwC/BixcvOHToUBoYGFAikbBDhw68dOmScANNREhICF1dXWlnZ8eAgIA0y/r7+1NfX5+9e/dmdHR0ticNJqZIkSIcOXKkStpq27YtixUrluHriI6OpqurK4sWLZqtyoGxsbEcN24cAbB58+a/vd6FQO5FcAYEci1yuZwnT55k06ZNKRKJaGZmxvHjx/Pdu3c5bVquIyYmhg0aNKChoSHv3buXZlm5XM569erR3t6eP3784Lx587I9aTAxzs7OKlMEPHnyJAHwwoULGa778OFDamtrq1WdMDUOHjxIExMT5s2blzdv3sz2/gUEBGdAINcRFhbGlStXslixYgTAkiVLcu3atYLWeyrI5XJ6eHhQQ0ODp06dSre8j48PAfDYsWOKpMFhw4Zlg6UpU6pUKQ4YMEAlbclkMhYoUIBdunTJVP2lS5cSAI8fP64SezLC69evWa5cOWpqanL58uVC1EsgWxGcAYFcg7+/P0ePHk0TExOKxWK2atWKZ8+eFW6K6TBt2jSl5/vfvHlDAwMD9uzZkyRzLGkwMeXKlWPv3r1V1t68efOopaXFL1++ZLhugjqhtbV1pupnlaioKA4aNIgA6ObmxtDQ0Gy3QeDPRHAGBOKJiSEPHiTHjSPr1iWdnMgCBcgyZcg+fcjVq0k1LIOSy+U8d+4cW7duTbFYTGNjY44aNSpb1n3/DmzYsIEAOHPmzHTLyuVyNmjQgHZ2dgwODlaE1Ddt2pQNlqZOpUqV6O7urrL2Pn78SA0NDS5atChT9d+/f09TU1O2adMmxxzRbdu2UV9fn0WKFOGDBw9yxAaBPwvBGfjTCQ0lp04lLSxIgJRKSZEo/v8Jh1T6/387diTTmZNWhsjISK5bt44uLi4EwKJFi3LFihUMCwtTwUX9GZw4cYJSqZS9evVSatBau3YtAfDIkSOMjo5m4cKFWa1atRyPvFSvXp1du3ZVaZvt27dnkSJFMn1tO3fuJABu2LBBpXZlhCdPntDZ2Zm6uro5sspD4M9CcAb+ZP79l7S3J8XipIN/WodUGn9Mnx4fTcggAQEBnDBhAs3NzSkSidi0aVOeOHEixwekXw0/Pz8aGBiwUaNGjI2NTbf8u3fvaGhoqHgCT0gaTC/ZMDuoXbs2O3bsqNI2T58+TQA8d+5cptvo1q0bDQwM+OrVKxValjHCw8PZvXt3AmCfPn0YGRmZY7YI/N4IzsCfird3fAQgI45A4kMkIuvUIZV4kpfL5bx8+TI7duxIqVRKAwMDDhkyhM+fP8+GC/39ePfuHW1tbVm6dGml5pTlcjkbNWpEGxsbfv/+nW/fvs3xpMHENGjQgG3btlVpm3K5nIUKFWKnTp0y3UaCOmHVqlVzVDpYLpdzzZo11NbWZqlSpfjixYscs0Xg90VwBv5EVq/OnAPw8yGRkDVrkqmo3EVHR3Pz5s0sV64cAbBgwYJcunSp8P3IAsHBwXR2dqajo6PSaovr168nAB46dIgk2a5dO1pZWeVo0mBimjRpwhYtWqi83QULFlBTUzNLG1TlhDphavj5+bFgwYI0MjLinj17ctocgd8MwRn407h///85AEocMwECYPG0IgQ/bYQTFBTEadOm0crKigBYv359Hjp0iDKZLIcu+vcgOjqaderUobGxMR89eqRUnYCAABoZGbF79+4kmWuSBhPTsmVLNmnSROXtfv78mZqamvT09MxSO2PHjqVUKuWtW7dUZFnmCQ4OZps2bQiAI0aM+GM34RJQPYIz8CcRG0u6uCjtDLwDqAtQLy1nICFCcPs2b968yW7dulFTU5O6urrs378/Hz58mNNX/Vsgl8vZtWtXampqKj0PLpfL2aRJE1pbW/Pbt2+5KmkwMW3btmX9+vXV0rabmxudnJyydL3R0dEsVapUtqsTpoZcLueSJUsolUpZuXJlQYRLQCUIzsCfxK5dGZoG6ACwNsAa6TgDMrGY501MCIB58+alp6enIKuqYiZOnEgA9PX1VbrOP//8QwA8cOAASXLu3Lm5JmkwMW5ubqxdu7Za2j579iwB8MyZM1lqJ0GdcPDgwaoxTAVcvnyZdnZ2NDc3zxGRJIHfC8EZ+JOoWTP+KV4JR+AcQAnAe0o4AwQoA3jMx0fYo10NrF69mgA4b948peu8f/+exsbGiiV7uS1pMDFdu3ZltWrV1NK2XC5n4cKFVbJawcvLiwnKjbmFz58/s0GDBhSJRJwyZYrw+xPINIIz8Kfw6ZPSEYE4gCUB9v3vb2WcAYrFZCZFXgRS58iRI5RIJBwwYIDSoW65XM6mTZvSysqKX79+JZn7kgYT4+7uzkqVKqmt/YULF1JDQ4OfPn3KUjsymYz169fPMXXC1JDJZJwxYwbFYjHr1q3Ljx8/5rRJAr8gyo7fYgj82ty6pXTRlQDeAJiRkfZFogz1IZA+t27dQrt27dCkSRN4eXlBJBIpVW/Lli04dOgQVq1aBVNTU5w8eRI7d+6Ep6cnjIyM1Gx1xtHQ0EBcXJza2u/evTvEYjE2bNiQpXbEYjHWr1+P6Oho9O3bFyRVY2AWEYvFmDhxIk6ePIl79+6hVKlSuHjxYk6bJfCbIjgDvzp+foBEkm6xrwAmA5gEwCIj7ctkwI0bmTJNIDn+/v5o2rQpihcvDl9fX0iU+OwA4MOHDxgyZAg6d+6M5s2bIyYmBoMHD0b16tXRqVMnNVudOaRSKWJjY9XWvpmZGdq2bYvVq1dDLpdnqS0bGxusWrUKu3fvxsaNG1VkoWqoXbs27ty5gwIFCqBmzZrw9PTMNQ6LwO+D4Az86gQHA+L0P8aJAEwBDM5MH9+/Z6aWwE98//4djRs3hq6uLg4ePAhdXV2l6pFEv379oKmpiaVLlwIAFi9ejBcvXmDZsmVKRxayG3VHBgCgb9++ePHiBc6cOZPlttq2bYvu3btj8ODBeP36tQqsUx02Njb4999/MWrUKIwePRqtWrVCcHBwTpsl8BshOAO/Oko4As8BrAYwBEAgAP//jigAsf/9/1taDSj59CqQOtHR0WjZsiU+ffqEo0ePwtLSUum6vr6+OHDgAFauXAkzMzO8e/cO06dPx5AhQ+Ds7KxGq7OGuiMDAFC1alUULVoUq1atUkl7Xl5eMDMzQ9euXSGTyVTSpqqQSqWYO3cu9u/fj3PnzqF06dK4fft2Tpsl8JsgOAO/OlZW8aH8NHgPQI54ZyBfouMagGf//X96GvU/kNi7dy9ev34thCczgVwuR/fu3XH9+nUcOHAATk5OStcNCgrC4MGD4ebmhpYtWwIARowYAUNDQ0ydOlU9BquI7IgMiEQi9OnTB3v37sXHjx+z3J6hoSE2btyIK1euYP78+SqwUPU0b94ct2/fhqmpKSpXroxVq1YJv0uBrKPKbESBHODChXRXEXwGuDeFozhAh//+fy+VurEiETdoaxOIVyw0MjJi9erVOXToUK5fv5537txhdCqyxQLx/PXXXxSJRNy1a1eG6snlcrZs2ZKWlpYK6d0TJ04QADdv3qwOU1XKxIkT6eDgoPZ+vn79Si0tLc6dO1dlbY4bNy7XqBOmRlRUFAcMGEAA7Ny5s1L7WQj8eSg7fovI9F3KkJAQGBkZ4cePHzA0NFSvdyKQMcLDARMTIBPh2JoAvgB4kEYZAthUqxYMhwyBhoYG7t69Cz8/P/j5+eH58+cA4p8AixcvDldXV5QqVQqurq5wcXHJlRnu2c2yZcswaNAgLF68GMOGDctQ3W3btsHNzQ27d+9G69atER0djZIlS8LKygpnz57NtbkCCUyfPh2rVq3C+/fv1d5Xt27dcOnSJTx//hxiJabO0iMmJgaVKlVCREQEbt26pXR+R07g6+uL3r17w8HBAbt27UKxYsVy2iSBXITS47cqPQuBHKJz5wztS5BwKKMzEC2VsrCNDQHQ3t6eo0aN4q1btyiXyxkSEsKLFy/S29ubPXv2ZJkyZaipqamIIuTPn5+tW7fm9OnTefDgQb579y5XyeWqm/3791MsFmdKECgoKIhmZmbs0KGD4tycOXMokUh4//59VZqpNmbNmkULC4ts6evixYsEwBMnTqiszUePHlFbW5uDBg1SWZvq4vHjxyxevDh1dXV/iaiRQPYhiA79SVy+nGFHQJlDJhZT3r8/ZTIZz58/z/79+9Pc3JwAWLhwYU6ZMoVPnjxJYkpMTAzv3bvHjRs3csSIEaxduzZN/pM0BkAzMzPWqVOHo0aN4ubNm/ngwQPGxsbm0BunPq5du0YdHR22adMmwxs5yeVytm7dmhYWFgpBnbdv31JXV5fDhw9Xh7lqYf78+TQxMcmWvuRyOYsXL842bdqotN2///6bAHj06FGVtqsOwsLC2LVrVwJg3759GRkZmdMmCeQCBGfgT6NDB6UliZVyBAB+A9imatUk+6zHxMTw6NGj7NatGw0MDAiApUqV4vz58/nmzZsUTZPL5Xzz5g3379/PqVOnsmXLlsybN6/CQdDW1ma5cuXYu3dvLlu2jJcvX/6l5z9fvHhBCwsLVq5cOVMb4Gzfvp0AuHPnTsW5tm3b0srK6pf6DS5atIj6+vrZ1p+XlxelUqnSW0Arg1wuZ4MGDWhlZZWlLZOzC7lcztWrV1NLS4ulS5fmy5cvc9okgRxGcAb+NL58Ic3MVOoQuIlENDExoba2NufOnZtsW9WIiAju2rWLbdq0oZaWFgGwatWq9Pb2Vko69du3bzxz5gwXL17Mbt26sWTJkpRKpQRAkUhEJycndujQgXPmzOHRo0cZFBSkrndPZXz+/JmFChVioUKFMjV4fPz4kebm5mzXrp3iXELS4JYtW1Rpqtrx8vKitrZ2tvX37ds3amtrc/bs2Spt9/379zQ1NWXr1q1/mWmu27dvs0CBAjQyMuK+ffty2hyBHERwBv5ErlwhdXQoF4uz7AhEDh3K0aNHK+b+xWIxXVxceOPGjRS7/vHjBzdu3MhGjRpRIpFQIpGwfv36XL9+fYZ086Oionj79m2uXbuWgwcPZrVq1RQRCAC0srJiw4YNOW7cOG7fvp1Pnz7NcBheXURERLBSpUq0sLBIEk3JCO3ataO5ubnCmYqKiqKTkxNr1KjxywxECaxYsYJSqTRb++zevTvz5cun8u/Erl27CIDr169XabvqJDg4mK1atSIAjho1KpkzL/BnIDgDfyiRZ84wWCxmbGacgP+ciNmammxQvz5jYmJ48OBBmpiY0MrKik5OThSLxRw+fDjDwsJSteHz589csWIFq1evTpFIRC0tLbZq1Yo7duzIVNhcJpPxxYsX3LVrFydMmMAmTZrQ1tZW4SDo6emxcuXKHDBgAFevXs0bN25k+3xpXFwcW7duTR0dHV67di1TbezYsYMAuG3bNsW5Xy1pMDE+Pj4EkK1OzOXLlwmoZwfCHj16UF9f/5cKvcvlci5cuJBSqZRVq1ZlQEBATpskkM0IzsAfSq9eveigrc3gOnXiB3hlVhmIRPGHvT155gxPnTpFDQ0NduvWjXK5nP7+/qxQoQKlUimbNWtGbW1t5s2bV6kb7rt37+jp6ckyZcoQAPX19dm5c2ceOnQoy08qnz594okTJzh//nx26tSJRYsWpVgsJgBKJBIWL16cXbp0oaenJ0+dOqXWHemGDRtGsVjM/fv3Z6r+p0+faGFhkSQU/ebNG+rq6nLEiBGqNDXb2LBhAwFka4KoXC5niRIl2KpVK5W3/ePHD+bNm5dVqlT55bYUvnTpEm1tbWlhYcGTJ0/mtDkC2YjgDPyBbNmyhQC4du3a+BNnzpBt2iie+GMBxonFpIYGYxI7A0WLkitXkome9n19fQmAY8eOJUlGR0dz2LBhBMD69euzRo0aBOLFTpTdQvbZs2ecPn06ixYtSgA0NTVlnz59eObMGZWFdcPDw3nt2jWuXLmS/fr1Y8WKFamrq6uIItjb27NZs2acNGkS9+zZw1evXmX5yXXx4sUEwGXLlmW6jQ4dOtDU1DRJXkSbNm1obW39y/7uNm/eTACZigZlBW9vb0okEr5//17lbV+4cIFisZizZs1Sedvq5tOnT6xfvz5FIhGnTp36yzk0AplDcAb+MJ4+fUp9fX126dIl+eD25Qu/b9vGcQBfNGxI9uvHvU5OnFm8OPn0KZnKYLho0SICoJeXl+Lcnj17aGRkxHz58nHKlCk0NTWlmZkZ//nnH6UHVblcTj8/P44ZM4aOjo4EQBsbGw4fPpzXr19XeVg5Li6Ojx8/pq+vL8eMGcP69evTwsJC4SAYGRmxRo0aClVFPz8/pVUVd+3aRZFIxL/++ivT9iXMR2/dulVx7vjx479k0mBiElZFhISEZGu/wcHB1NHR4YwZM9TS/vjx4ymVSnnz5k21tK9O4uLiOG3aNIpEItavX19pR17g10VwBv4gIiMj6eLiwsKFC6e6JO/69esEoJBXHT9+PO3t7dNte+TIkRSJRNyxY4fi3MuXLxUCQ3PmzKGbmxsBsF69ehmeT5XL5bx06RIHDRpES0tLAmCBAgU4YcIEPnjwIENtZbTfwMBAHj58mLNmzWK7du1YqFAhhYOgoaFBV1dX9ujRg0uXLuW5c+eSJUJeunSJWlpa7NixY6YjG58/f6alpSVbtmypcIJ+5aTBxOzevZsA+PXr12zv293dnY6Ojmp5+o2Ojmbp0qVZpEgRhoeHq7z97ODEiRO0sLCgra0tL126lNPmCKgRwRn4g+jXrx+1tbV59+7dVMskJKcl3JgT5nPTu5nJZDJ26tSJmpqaPHPmjOJ8VFQUBw0aRABs3749d+3aRQcHB+ro6HD+/PmZmieOjY3lyZMn6eHhQSMjIwJgiRIlOHv2bL569SrD7WUGZVUVhwwZQgMDA1aoUCFLyYpubm40MTFJsjZ+9uzZlEgkanWGsoMDBw4QgFLLTFXN1atXCYBHjhxRS/sJ6oQDBw5US/vZQUBAAKtUqUKpVMqFCxf+0o6nQOoIzsAfQkIodtWqVWmWW7BgAfX19RU/+EuXLhEA7927l24f0dHRrFu3Lo2MjJKV37FjBw0MDFioUCFevnxZkUhXqlSpLG3yEhUVxX379rFDhw7U0dEhAFasWJFLly5VqaiMMvysqlilShVFomJWVBX37NlDIOmmQ7960mBijhw5QgA5ksEul8vp4uLCFi1aqK2PX0mdMDViYmI4atQoAmCrVq34/fv3nDZJQMUIzsAfwPPnz2lgYMCOHTum69UPHDiQzs7Oir8/f/5MAErvpPfjxw+6urrSxsYmmdLgs2fP6OrqSi0tLa5evZrXrl1jyZIlKRaLOXLkyDSXISpDaGgot2zZwqZNm1JDQ4NisZi1a9emj48Pv337lqW2M0pYWBjLlStHKysrXrp0ifv27UtXVXH58uXJVBW/fPnCPHnysHnz5kk+u189aTAxCWJJ/v7+OdL/8uXLKZFI1OaMyOVyNmzY8JdRJ0yLffv20cjIiPnz5+ft27dz2hwBFSI4A785UVFRLF26NAsWLKjU59KkSRM2bdpU8bdcLqexsXGG1No+fPjAfPnysWjRosnmgSMjI9m3b1/FCoNv375xzpw51NbWZr58+Xj8+HHlLy4Nvn79Sh8fH9auXZsikYgaGhps1qwZt27dmmWnIz3i4uLYvHlz6unppRr1SE9VsXDhwuzQoQNdXV2pr6+fZGonIWkwcSLhr8yZM2cIINMCTFnlx48f1NPT47Rp09TWR2BgIM3MzNiqVatfPsz+8uVLlipVilpaWly1atUvfz0C8QjOwG/OoEGDqKmpqbQX7+zsnGz3tfLly9Pd3T1D/T59+pTm5uap6u5v3bqVenp6LFKkCO/fv8/nz5+zdu3aBMCuXbuq9AkqMDCQS5YsYYUKFQiAurq67NixI/fv38+oqCiV9UPGO08DBgygRCLJ8Dx0VFQUb926pVBVLFasmCKCkKCqWL9+fZqamrJYsWJ88uRJrlFVzAoXLlwgAD5+/DjHbOjVqxft7e3VuowuIVFy3bp1ausju0js1Hft2lXtDraA+hGcgd+YhJuPt7e3UuXlcjn19fW5YMGCJOe7dOnCKlWqZLj/q1evUldXly1atEhxbvzx48d0dnamjo4O161bR7lcznXr1tHExITm5ubctGmTyp86Xr58yVmzZrFEiRIEQGNjY3p4ePDkyZMqGQjmzZtHAPTx8clSO1+/fqWVlRWbNGnC58+fK1QVCxcunMRByA2qilklIYkvJ9UTE1bRHDp0SK39uLu7/3LqhGmxefNm6urqsnjx4jnqzAlkHcEZ+E159eoVjYyM2LZtW6UH1C9fvvDnXfBIctq0abS0tMyUHYcOHaJEImHfvn1TtCM8PJweHh4EwB49ejA8PJxBQUHs2LEjAbBBgwZqWyHw4MEDTpgwgfnz5ycA5smTh4MHD+bly5cz5YQkCDBNnDgxy7Z17dqVxsbGSQRx3rx5Qx0dHY4cOZIfP37MNaqKWeXmzZsEkKNz0HK5nKVKlWKzZs3U2k9ISAjz5cvHKlWq/DZbcj98+JBFixalnp7ebzN19SciOAO/IdHR0SxXrhzz5cuXoc1/bt26RQDJNhlKGOQym0G8bt06AuD06dNTLfPPP/8onjAePXpEkjx8+DDt7e2pq6tLT09Ptd085XI5r127xmHDhtHa2poAmDdvXo4dO5Z3795VyjE4e/YsNTU12bVr1yxHMxKW2m3YsCHJ+TZt2tDGxiZVcR5lVRUnT56sMlVFVXD37l0C4PXr13PUjpUrV1IsFvPt27dq7efixYsUi8WcOXOmWvvJTkJDQ9m5c2cCYP/+/VU+/SagfgRn4Ddk+PDh1NDQSHXnwNRImFb4WW0swUnIys165syZ6YbPE54wdHV1uWnTJpLxT1JDhgyhSCRimTJl1P70GBcXx3///Zd9+vShqakpAbBo0aKcPn06nz9/nqrdxsbGrFOnjtKKhKnx7ds3Wltbs3HjxkkG6mPHjmUqaTCxquJff/2lUlVFVfHw4UMCyHFRm5CQEOrr63PKlClq7ytBnTCjv9HcjFwu54oVK6ipqcmyZctmm+aHgGoQnIHfjP379xMAlyxZkuG6CxcupK6ubrKnxZCQkCxL3iZOrDt48GCq5cLCwti1a1cCYK9evRTJh1evXmWJEiUokUg4evTobFF0i46O5qFDh9i5c2fq6ekRAMuWLcuFCxcqlqEFBgbSwcGBzs7OGYrCpEb37t1pZGSUZJlbVFQUCxUqxJo1a6rkST4lVcWCBQsmU1V0d3dPVVVRlTx79owAeO7cObX1oSx9+vShra2t2kP40dHRLFOmDAsXLvzLqhOmxs2bN5kvXz4aGxvzwIEDOW2OgJIIzsBvhL+/P01MTJJI1maEIUOGsFixYim+ZmVlleUnpri4OLZq1Yo6Ojq8cuVKquXkcjnXrFlDbW1tlixZkk+fPiUZL3wya9YsamlpMX/+/Nm6q1p4eDi3b9/Oli1bUlNTkyKRiFWrVqW9vT2tra1VElo+dOhQitnms2bNolQqVbvSYIKq4t9//52mquL06dN58OBBvnv3TiXOyatXrwiAp06dUsFVZI2EKFhmd5XMCI8fP6aOjg4HDBig9r6ym2/fvrFFixYEwL/++uu3yY/4nRGcgd+EmJgYVqxYkY6OjpkW2GnevDkbNWqU4mvVqlWjm5tbVkwkSUZERLBq1ao0MzPjkydP0ix79+5dOjk5UV9fn9u2bVOcf/r0KWvWrEkA7NatW7Ynx33//p0+Pj40NzdXJOw1btyYmzZtyvRmO9+/f6eNjQ0bNmyYZIBNnDSYE/ysqlirVi2amJgoHARzc3PWrVs3w6qKiXn79i0BKLXVdXZQpkwZNm7cOFv68vb2Vqscck4il8u5YMECSiQSVqtWTS27QwqoDsEZ+E0YPXo0pVJpmk/c6VGyZEn2798/xdd69uzJsmXLZrrtxHz79o3FihWjo6MjAwMD0ywbEhKi2OCof//+imVzCdEDY2Njmpubc/PmzdmWDCeXy9mrVy9KpVLu2LGD3t7erFKlikJRsG3btty9e3eGlvi5u7vT0NAwWYShdevWaSYN5gRyuZxv3rxJoqqYsKukMqqKP/Phw4dsWdanLKtXr6ZIJEqmoKkOfid1wtS4cOECbWxsaGlpydOnT+e0OQKpIDgDvwEJ4eWf9QEyipGREefNm5fia/PmzaOhoaHKBty3b9/S1taWLi4u6c5Hy+Vyrly5klpaWixVqlQSpboPHz6wffv2BMCGDRvy9evXKrEvLWbMmJFitr+/vz/nzZtHV1dXAqChoSG7d+/OY8eOpfm0nKDNv2bNmiTnE5IGfX191XIdqkZZVcU5c+bw6NGjDAoKIvl/yeu9e/fm7AX8R2hoKA0MDDhp0qRs6S9BnTCz03u/Ah8/fmTdunUpFos5Y8aM30Is63dDcAZ+cd69e0czMzM2adIkSz+w79+/E0CScHxiEjbLSbiBq4L79+/T2NiYtWvXVmop0u3bt1mgQAEaGhom2yvh4MGDtLOzo66uLhctWqQ2Jbl//vmHANKVrn38+DGnTJlCJycnAqCFhQUHDBjA8+fPJ/mcgoODaWtry/r16ycZCBKSBmvVqvVLDxA/qypWrVqVBgYGSVQV69SpQwAcPnw4nz59misGin79+tHGxibb5roTfl9r167Nlv5ygri4OE6ePJkikYgNGzb8bSMhvyqCM/ALExsby6pVq9LOzi7L8+Z37twhAF69ejXF1x88eEAAvHDhQpb6+Zlz585RS0uLHTt2VGoQCA4OZtu2bQmAQ4YMSbIMLiQkhIMHD6ZIJGLZsmXp5+enUltPnTpFqVTKnj17Kj1Ay+Vy3rp1i6NGjaKdnZ1ivf+oUaN469Ytenh40MDAIFlIOruSBnMCmUzGFy9eKFQVGzRokKqqoo+PT46oKib8HrIzWvG7qROmxvHjx2lubk47Oztevnw5p80R+A/BGfiFGT9+PCUSCS9evJjltvbt25fmk39kZCRFIpFanlx27dpFkUjE4cOHK1VeLpfz77//poaGBsuVK5dsauDKlSt0dnamRCLhmDFjku2N8Dk6mse+fuWit28509+f89684c6PH/kqIiLVQf7evXs0NDRkgwYNGBMTk6nrlMlkPH/+PPv3769IPgTApk2bJkmm9Pf3p46ODkeNGpWpfn41oqOjFbLZCaqKbm5uOa6qWL58eTZs2FCtfSQmJCSE+fPnZ+XKlX/77Pt3796xcuXKlEqlXLx48S8d/fpdEJyBX5Tjx49TJBJxzpw5KmlvyZIl1NbWTvNH6ejoyLFjx6qkv59JyKr29PRUus6NGzeYN29eGhsbc9++fUlei46O5owZM6ipqckCBQrw8KlT3PDhA0vfuEGcOUOcOUPxmTOUnj1LyX9/48wZ2ly6xJn+/gxKFHF49+4dbW1t6erqqrJEvi9fvtDc3JzW1tbU19cnAJYqVYrz589nw4YNc13SoDqRyWSphsjDw8N59erVJKqKOjo62aKquHbtWopEomzJQ0ng0qVLv506YWrExMRwxIgRBMA2bdqoVctCIH0EZ+AX5P3797SwsGDDhg1VNr86bNgwFi5cOM0y9erVY+vWrVXSX0qMHz8+w+JGidczjxgxItlT+5MnT1iie3dixw6FA4B0DvGZM9Q6e5ZL3r3j9+BglixZkg4ODipdGtWnTx/q6+vT39+fkZGR3L17N9u2bUsNDQ0CoJOTE729vfnx40eV9ZmbEYvFXLVqlVJls0tVMSwsjIaGhpwwYUKG62aFCRMm/HbqhGmxe/duGhoasmDBgiqf2hNQHmXHbxFJIh1CQkJgZGSEHz9+wNDQML3iAplAJpOhbt26ePbsGfz8/GBhYaGSdlu3bo2IiAgcO3Ys1TIDBw7E+fPncf/+fZX0+TMk4eHhgS1btuDIkSOoW7eu0vWWLFmCv/76C+XKlcP27dthb28POYnRL19iUUAARCQoEmXYJuO3byEfNw6XT5xA8eLFM1w/JU6dOoV69eph5cqV6Nu3r+J8dHQ0ihUrBi0tLTg6OuLUqVMgiTp16sDNzQ2tWrWCkZGRSmzIbWhpaWHRokUYOHBgpuqTRFBQEO7cuQM/Pz/4+fnhzp07ePHiBQBAQ0MDxYsXR6lSpeDq6gpXV1e4uLik+34OHDgQe/bswdu3b6GhoZEp2zJKbGwsKlWqhLCwMNy+fRu6urrZ0m9O8uLFC7Rr1w5PnjyBt7c3PDw8IMrE71Ug8yg9fqvSsxDIPJMnT6ZYLFa5dGupUqXYp0+fNMskTCWoM9s7JiaGjRo1or6+fob3Ibhy5QodHBxoamrKQ4cPs+fjx+lGAdI9Tp1ivjNn+D2TeQI/ExISQgcHB9auXTtZODshafDhw4ck45fcrVy5kjVq1KBIJKKWlhZbtWrF7du3/3YStrq6upmS0E6PrKoqJmyitHv3bpXblha/szphakRERLB3794EwO7du/923/HcjhAZ+IU4ffo06tWrh+nTp2PixIkqbdvU1BSjR4/GuHHjUi1z9OhRNG7cGG/evIGDg4NK+09MWFgYateujbdv3+LKlSvIly+f0nW/ffuG7t2745CuLtC/v0rskQCobWKC4yVLZvlppX///ti0aRMePHiAvHnzKs6/efMGRYsWxcCBA7FgwYJk9QICArBjxw74+vri5s2b0NfXR4sWLeDm5ob69etn21OrujA2NsakSZMwcuRItfcVGxuLJ0+eKKIHCZGE79+/AwDMzc0V0QNXV1csWLAAlpaWOHHihNptS8zy5csxcOBAHD58GI0bN87WvnOSTZs2oV+/fsifPz927dqFwoUL57RJfwTKjt+CM5DDBAUFwdXVFc7Ozjh+/DgkEonK2k743LZu3Qo3N7dUy7148QKFChXCyZMnlQ7hZ5bPnz+jcuXKEIlEuHTpUoamQx6GhcHl+nXIxOLUCwUEAOvWAffvA6GhgKUlUKcO0KEDoK2dYpW1hQvDw9o6o5ei4PTp06hbty6WL1+O/j85Kq1bt8a1a9fw5MkTGBgYpNnO8+fPsW3bNvj6+uLx48cwNTVF27Zt4ebmhmrVqqn0u5FdmJubY9SoURg7dmyO9E8S7969SzbN8ObNG0WZEiVKoGLFioqphpIlS0JPT0+tNjVp0gS3b9/G/fv3VTYl+Cvw8OFDtG3bFgEBAVizZg06dOiQ0yb99gjTBL8AcXFxrFOnDvPkyaNS0Z8E7t27p9QWsrGxsZRKpVy+fLnKbUiJly9f0tLSkuXLl2dYWJjS9er5+SVZIZDs2L6d0Ncn8uQhevcmRowgGjaMDx1XrpxqPYPz5xmaySVfISEhdHR0ZK1atZJNsxw9ejRNwafUkMvl9PPz49ixYxVywDY2Nhw+fDivXbv2Sy3XsrKy4owZM3LajGR8+/aNR48epba2Np2dndNUVTx27JjKf58fPnygubn5b61OmBqhoaEKKfJBgwYpJUwmkHmUHb+l6vdLBFJjzpw5+Pfff3Hy5EnkyZNH5e37+/sDQJKwdUpIpVIUKFAAz549U7kNKZE/f34cOXIENWvWRPv27bFv3750w+HPIyJw8r9wb6qcOAGEhQFeXkDCFESzZoBcHv9aaCiQwtN5mEyGrZ8+oY+NTYavZezYsfjy5QvOnDkDcaKIRXR0NAYPHozatWujffv2GWpTJBLBxcUFLi4umD17Nq5evQpfX19s3boVixcvRoECBdCxY0e4ubmpLPlRXUilUsTGxua0GckwMTFBw4YN0atXL+zYsQPv3r0DSTx8+DBJBOHIkSMIDQ0FAFhZWcHV1TVJsmLBggWTfO7KYmVlBR8fH7Rq1Qrr16+Hh4eHqi8x16Kvr48tW7agWrVqGDZsGK5du4adO3fC0dExp037o8n4t1hAJZw7dw5TpkzBpEmTUKdOHbX08ebNG2hqasLKyirdsoUKFcLz58/VYkdKlClTBnv27MGJEyfQr18/MJ3ZqnVBQUg3SB4REf+vqWnS82ZmgFgMSFP3fVe8f5++0T9x5swZLF++HPPmzUuW/+Dp6Ql/f3/8/fffWcpHEIlEqFSpEry8vBAQEICTJ0+iRo0a8Pb2hrOzM0qWLIk5c+bg9evXme5DnWhoaCAuLi6nzUiVvn374tOnTzhw4AC0tLRQunRpeHh4wMvLCxcuXEBwcDBevHiBnTt3omfPnpBIJNi4cSM6dOiAwoULw9DQEFWqVMHAgQOxZs0a3Lx5E1FRUUr13bJlS3h4eGDIkCF4+fKlmq80dyESidC/f39cunQJnz9/RqlSpXD48OGcNuuPRsgZyAE+f/4MV1dXODk54dSpU2qbCx41ahT279+v1CA/cuRIHDx4MNuiAwls3rwZXbt2xcSJEzFjxoxUy1W5fRuXQ0LSbuz6dWDMGKByZcDdHTA0BB48ABYtAho1AtJY3iYGEFatGnSU/CzCwsJQsmRJODg44N9//03ydJiQNDho0CDMnz9fqfYySnR0NI4dO4Zt27bhwIEDiIiIQMWKFdGxY0e0b98e1lnIgVAlTk5OaNmypdreB1VQpUoV6Orq4uTJk0rX+fTpE+7evZskWfHp06eQy+WQSCQoUqRIkgiCq6srzMzMkrUTGhoKV1dX5MmTB+fPn4c0DYf1d+X79+/o3r07Dh48iLFjx2LGjBl/5PugLoQEwlyKXC5H48aNcfv2bfj5+cEmE6FpZWnbti1+/Pih1E1u5cqVGDRoECIjI7M9g33BggX466+/UkzAAwAZCf0LFxAll6ff2KZNwJYtQHT0/8916QL07Jlu1SulSqGikuv9Bw8ejHXr1uHevXsoUKBAktdat26N69ev4/Hjx+kmDaqCsLAwHDx4EL6+vjh27BhkMhlq1qwJNzc3tGnTBiYmJmq3IQGSuB0WhmshIbgdGortJ0/CwsICVVxcUEpfH2UNDFDZ0BDSTITW1cXGjRvRvXt3PH/+HAULFsx0OxEREbh//36SaYZ79+4hMjISAGBvb59smiFv3ry4cuUKqlWrhmnTpql8NdGvglwuh6enJ8aPH4+qVavC19c31zi0vzqCM5BLmTt3LsaPH49jx46hfv36au2rXLlycHV1hY+PT7pl//33X9SpUwfPnj1DoUKF1GrXz5DE8OHD4eXlhV27dqF169ZJXv8WGwuzS5eUa+zkyfijevX4yMDVq8CxY8DgwUCrVmlW3VGsGNpZWqbbxblz51CzZk14eXlh8ODBSV5LWKa5bdu2HMmU/vbtG/bs2QNfX1+cOXMGUqkUDRs2hJubG5o3b662LPlouRxrP3yAV0AAnkZGQgRAIhIh7r/biwTxAgByADaamhhga4uBNjYwzgVLJyMjI2Fra4vevXtj3rx5Km1bJpPh+fPnyVYzfP78GQBgZGQEV1dXREZG4ubNm9i4cSPatWsHTU1Nldrxq3D+/Hl07NgRcrkcvr6+qFWrVk6b9MsjOAO5kIsXL6JmzZoYM2YMZs2apfb+LCwsMGzYMEyYMCHdsgEBAbC3t8ehQ4fQpEkTtdv2M3K5HG5ubti/fz9OnjyJatWqKV77HBMDy8uX02/k33+B+fPjowOJl2vNmwecPQts2wak8eQ/VSrFlKpV0+wiPDwcJUuWhK2tLc6ePZssadDZ2RkODg44depUjiutffjwATt27MC2bdtw9epV6Orqonnz5nBzc0ODBg2gpaWlkn5uhoSg65MnePpfzka6NxTET8uYa2hgXZEiaJJC+Dy7GTZsGLZu3YqAgAC1D8Qk8eHDhyTOwZ07dxR5A1KpFM7OzhlWVfxd+PjxIzp16oSzZ89ixowZGDt2bKaSNAXiEZyBXMbXr18VYcGEJzZ1Eh4eDn19fWzatAldunRJt7xcLoe+vj5mzZqF4cOHq9W21IiOjkajRo1w584dXLx4UZEpHyGTQe/ChfQbGDoUkMkAb++k5y9cACZPBjw9gTJlUq8/bhw0b99G/vz5YW9vDzs7u2THsmXLsHHjRty/fz9ZSHnWrFmYOnUq7t27h6JFi2b08tXK69evFRoG9+/fh7GxMVq3bg03NzfUqlUr03kr6z58QO+nTyECIMtgXTHiIwVjHRwwO1++HHWeHj16hOLFi2P79u0ZXv2hKm7fvo3KlSujXLlyKFy4MPz8/HD//n3ExMQAiF+Fk+AcJDgKtra2Oe50qgOZTIapU6di5syZaNy4MTZu3JhizoVA+gjOQC5CLpejefPmuHr1Kvz8/GBnZ6f2PhNubhcuXEDVdJ52E3BxcUGVKlWwfPlyNVuXOj9+/ED16tXx7ds3XLlyRfFe5b1yBW8S5wGkRLdugL4+8LP9Z84A06fHRwjKl0+1euN//sHxTZtgYGAAFxcXREdHIyAgAIGBgZAnylfQ0NBA3rx5kzgJOjo6mDlzJjp27IgFCxbA3Nw81z7NPHz4EL6+vvD19cWrV6+QJ08etG/fHm5ubqhYsaLSg8v6Dx/g8fSpSmz6y94e837KvchuqlWrBk1NTZw+fTrHbFixYgUGDBigUCfMqKpiqVKl4OTk9Nsk4B07dgxdunSBnp4eduzYgQoVKuS0Sb8cgjOQi/D09MTo0aOzVX70yJEjaNKkCd69e6e089GuXTt8//4dp06dUrN1aRMYGIjKlStDX18fFy5cgImJCdwePsTOz5/TfvocPx64eRNYuxawt///+UmTgMuXge3bAXPzFKuaSKX4WqUKnjx5gt69e+PSpUvo1asX5s+fDwMDA/j7+6NmzZowMDBA37598f79ewQEBCiON2/eJFkeqampCVtb2xSjCwlHnjx5clRVkCRu3LiBbdu2Yfv27QgMDETevHkVGgYlSpRI1TG4GxaGMjdvZjgakBa7ixdH6xxU40tY2ZITeTMJkETTpk1x69atVNUJSeLt27cKx+BnVUVtbW2UKFEiyTSDulUV1cm7d+/Qvn173Lp1C56enhg8ePBvGQ1RF4IzkEu4evUqqlWrhuHDh2fr8qrly5dj6NChiIqKUnrAGT9+PDZv3oy3b9+q2br0efLkCapUqQJnZ2esXr0a444dw14Xl7Qr3b0LjBgRnxfQsuX/EwivXQOaNAFGjUqxmlQkgoeVFVb9p5Uul8uxevVqjBkzBjo6Ovj7779x6dIlrFq1Cvfu3Us2UCQkDa5atQplypRJ4iQEBATg3bt3iv9HJ4puSCQS2NjYpOkwWFtbZ8vqDplMhgsXLsDX1xe7du3Ct2/fULRoUbi5ucHNzS3JlEisXI7St27hcXg4ZJGR8bkYjx8DT57ECzuNGQM0bJi0g8eP4xM5Hz8GXr2Kn845c0bxsgjxDtnT8uVhnkPJc1FRUbC1tYWHh0eK+0hkF0FBQShRogSqVKmCvXv3Kj3wff/+HXfv3k0SQXj06BHi4uIgEong5OSUbJpBHWJn6iAmJgZjxozBkiVL0K5dO6xZsyZDY9HnmBjcCg3F66goxJLQk0hQXFcXLvr6Si8n/lURnIFcwPfv31GqVCnY2Njg3Llz2bpkb8yYMdi1a1eGxEw2bNgAd3d3REREQEdHR43WpY9cLseSJUswevRoyOVyGJiYINbXF1HpJb09fgz88w/w/DkQEgJYWwP16wNubkAaP/qjtrZo+NMg//79ewwePBh79+4FAEyePBnTpk1LUiYqKgrOzs6KrYnTunGTxNevX5M5Cz87DhEJ4kkAxGIxrKys0nQYbGxsVJYMCMTfeE+ePAlfX1/s27cP4eHhKFu2LNzc3NChQweclkjQ/cmT+MJBQfHvbZ488e+1n1/KzsCGDfFLPvPnByIjgXfvkjgDQPyKg1H29pibg9MFI0aMwKZNmxAQEKDS9zSj7Nu3D61atcKaNWvQU4llsakRFRWFR48eJYkg3L17N4mqYuIIQqlSpVCgQIFcO8W1e/duuLu7w8rKCrt27ULJkiVTLfs9Nhb/BAVheWAgnv+3vFP035Ew6SdG/GZlg21t0cTMDJLfMOIgOAM5DEm0atUK58+fh5+fn1p3A0yJDh064MuXLxma/7x06RKqVq2Ke/fuoUSJEmq0LnW+fPmCdevWYdWqVXj16hXy5csHf39/9OrVC8UnTcIwVSu1yWTA9euQTp6MIUOGYOLEiUnW5UdERKBgwYL48uULNDU1MXfuXPTv318RbZk5cyamTZumsqRBkvjx40eaDkNAQAB+/PiRpJ6lpWWaDoOtrS10dXUzbE9ERAQOHTqEbdu24fDhw4iNjYXepk0It7EBRSIgJiZeAtrUFHj6FOjXL2Vn4Ns3QE8P0NICli4F9u1L5gwAgLFUiqDKlaGVQ4PRkydPULRo0XQ398oOevXqhW3btuHu3bvJtCyyglwux+vXr5MtdwwMDAQA6OnpwcXFJUkEwdnZGdqpbPSV3Tx//hxt27bFs2fPsHz5cri7uyd5nSR8PnzA8BcvEPlfrk9ag5wE8cmvhXV0sLloUZT9zcY4wRnIYZYuXYphw4Zh//79aN68ebb3X6FCBRQvXhzr1q1Tus7nz59haWmJ3bt3J1vrr05I4sqVK1ixYgV27twJAGjfvj0GDBiAChUqYM2aNejTpw9mzp6NQw0a4EZIiMrmqvXFYrTYswdbli6FSCSCvr4+pk6dioEDB0JLSwsjR47E8uXLceHCBaxduxYrV65ExYoV4ePjA319fRQtWhRDhgxR+fr09AgNDU2Wt/Dz8fXr1yR1TE1N03QY7Ozs0hRJ+vHjB1YcPIhxqeWgpOUMJCYNZwAA9js7o3kquR3ZQY0aNSASiXD27NkcswH4vzqhpaUlLly4oPakwARVxcROQmJVxaJFiyaJILi4uORYhn9kZCQGDx6MtWvXwt3dHd7e3tDV1cWPuDi0ffgQp9LbxyQFErQwZubLh7EODr9NXoKy4/fvkXKay7hx4wZGjx6N4cOH54gjAMRL4mZUL8Dc3BzGxsbZJkkcFhaGLVu2YMWKFbh79y7y58+PGTNmwN3dHeaJBoPevXsjMDAQE8ePxzx7ezzPmxfBcXFZdghEADYWLYpWS5ZgVI8e6N27N27evIlRo0ZhyZIlcHd3x6JFi+Dp6YmyZcuibNmy6NSpE/r06YPSpUsjf/78MDU1xaRJk7JoScYxMDBAkSJFUKRIkVTLREZGpuow3Lp1C/v378fHjx+T1DE0NEzTWTCtXBlQY06JVCTC9ZCQHHUG+vbti86dO+Pp06co/F8eSU5gYGCAzZs3o2rVqpgzZ47av2eWlpaoV68e6tWrpziXkqri7t2701VVVPdAqqOjgzVr1qBatWro378/bt68iQ07dqBXWBjuhYVlqs2E+8n416/xIy4uR6ercgIhMqBigoODUbp0aZibm+PixYs5oiQWGRkJXV1d/PPPP+jWrVuG6pYvXx7Ozs4ZiihklIcPH2LFihXYuHEjwsPD0bRpUwwYMAD16tVLda6SJPr27Yt169bh70OHMElfHz/i4pCpLXBkMojEYmwqVgydEyVQyeVybNy4ESNGjEBISAhkMhl0dXWxZ88eNGjQQFEuOjoa7u7uCsnUbdu2oXr16pmxJMeJiYlBYGBgmhGGDx8+/H9pZf/+QOvWKW/6pILIgAhAA1NTHE1jLljdREdHw9bWFt27d8fChQtzzI4EJk+ejNmzZ+Py5cson8bS2OxCWVXFxE5C0aJF1XYvvH//Ptq0bYtXvXuDZcpAriJHxMfJCb3UKBefXQjTBDkASbRr1w6nTp3CnTt3ku1kl10kzHuePXsWNWrUyFDdLl264M2bN7igjMhPBoiJicHevXuxfPlynD9/HpaWlujduzf69OmjdD5FXFwc2rRpg1OnTmHb6dNYqq2N08HBAAkoeQMQA9AODYVozhw82Lo1xe2dv3//jjp16uDOnTvQ1tZGVFQUGjRogHnz5sHFxUWRNGhhYQGRSIQrV66gd+/emD9/PoyNjZV+T34V4uLiEBQUhICAAIwNDsYFLa2Ub7gqmiZwEomwy9QUurq6SY7sTMAdNWoU1q9fj/fv3+f4XHlsbCyqVKmC4OBg3LlzJ1cuEUxJVdHPzw8vXrwAEL/Utnjx4kk0EVSpqrji9WsM+G9pZTLmzgWOH0+98o4dSRVL/0NXLMbj8uXhkEtyJTKLME2QAyxfvhy7d+/G7t27c8wRAAB/f38ASHGgSw8nJ6cM7d6WHm/fvsXq1auxZs0afPz4ETVq1MC2bdvQqlWrDD8pSKVS+Pr6om7duvBo1gyXLl3CHgDj7t8H7O0hTaSFnxgNkQixJDSiojDayQkDjIxQ9cMHuLm54fz588kGmSdPnuDu3bsYNmwYrl69iqtXr+Ly5csoVaoUunbtCgsLC7x9+xaHDh2Ck5MTVq5cibFjx+LgwYPw9vZG69atf5v5RiD+fU+YJnB8/BiXPn5UZGOrg2fPnqFknz7JzkskkiTOgY6OTjKHQZlz6ZXR1NREnz59sHDhQuzevRudO3dW49Wmj4aGBjZt2oRSpUph1KhRWLFiRY7akxIikQg2NjawsbFJoqUSGhqq2N0xwUnYsmVLMlXFxNMMGVVVDIuLw5iAgNQLNGuWXHmUBBYvjl8Fk4q2RQyJES9eYJezs9K2/MoIkQEVcfv2bVSqVAl9+vTB33//naO2rFq1CgMHDkRUVFSGk458fX3RqVMnBAcHZ9prl8vlOHHiBFasWIFDhw5BT08P3bt3R79+/RQSw1nh69evqFq1KqKjo+Hq6oq9e/di5ObNEFWsiOshIXgQHo5IuRxSkQj5tbVRwdAQsTdv4p9evfD+9WtYWVkp9B9GjhyJuXPnKtqOjIxEqVKlYGxsjEuXLkEkEmHjxo0YPXo0QkNDIZVKER4ejvLly+P48eOKSEBAQAAGDRqE/fv3o0WLFli2bBlsbW2zfK25hbi4ODx79gyjXr3CcV1dyFOazlHRNEFlDQ0slEoRERGhOCIjI9P8O70y4eHhkMmUyzIRi8XQ0dFBTEwMxGIx8ufPrzJHI/E5bW3tDA16K1euRP/+/XNs/xBVoWpVxVWBgej/7JlSe2IouH8fGDIkfjfTNOTaxQDeVqoE2xxcZppVhMhANhISEoIOHTrA2dkZnp6eOW0O/P39YWdnl6nsYycnJwDxy3fKli2bobpfvnzB+vXrsXLlSrx69QouLi5YsWIFOnXqBH19/QzbkhpmZmY4duwYKlasiL1790JbWxszWrdOUxshOE8e+CJ+u9q//voLFStWxKxZszBmzBjUqlVLkRMwdepU+Pv7486dO4rlgz169ECLFi0wadIkLFu2DCKRCPfu3UP+/PkxceJEDBw4EHZ2dti7dy/27NmDQYMGoWjRopg7dy769euXa9dsp0ZoaCju3bsHPz8/xVPd/fv3ERUVBdStCyix8VVmkYhEqGFtjQr586u87djY2Aw5EVevXsX27dtRrlw56OrqJinz48ePVNtJeOpND5FIpHAUlHEitLW1UahQIXTo0AETJkxAnjx5lK6Xm76DGhoaKFGiBEqUKIGuXbsCSFlVcefOnYr7aVqqisvfv8+4EadOxU8t1q2bZjER4mW3J2YiyvqrIUQGsghJdOrUCYcPH8bt27eztB+6qnBzc8OHDx8ytTQq4bPesmULOnXqlG55krh27RqWL1+OHTt2gKRiWWBGdO4zw4ABA7BixQrY2dnh5cuX6U47dO7cGbdu3cLjx48hEokgl8vRuHFj3L59G3fv3sXbt29RuXJlzJo1C2PHjk1WP0Hi2cnJCc+ePUPBggXx+vVr2NvbY+bMmXBzc4NYLEZwcDDGjBmD1atXo3LlyvDx8UGxYsXU9TZkGpJ4//59kkE/8TyvhoYGihUrluQpTbdwYVRIbT8CFeUM7C1eHC1zUJY4gejoaNjZ2aFLly5YvHix0vXi4uIUjkFWIxo/nwsLC0NQUJDi+6ss2traKotopPa3jo6OyuW101NVLFiiBJ4vWaJ0zhAAIC4OaNMGcHAA0oniigDUMTHByfTUT3MxQgJhNrF69Wr07ds3R3c7+5nKlSvDyckJGzZsyFR9Kysr9O/fH1OmTEm1TFhYGLZu3YoVK1bAz88P+fLlQ79+/eDu7p6inrqqiYmJgaWlJX78+AENDQ20b98eGzduTPMJ6PTp06hbty4uXbqEypUrA4hfW+3i4oKiRYviw4cP0NfXx5UrV5JFVRKSBvPmzYvjx48rIgwRERHInz8/Hjx4gFKlSmHBggWoU6cOgPi92fv06YNXr15h3LhxGD9+fI6p2sXGxuLp06dJnrz8/PwUWgTGxsZJBv20MsBL37yJu2Fh/88b2Ls3XnjoyxfgwAGgWjUgQc2xVav4zaOCgoCEXJQrV+KVIj084v/OkydeJRKAsUSCD5UrQzuXSMT+9ddfWLNmDd6/f5/jqpwJ7N+/Hy1btsSqVavQuXPnDDkamXFQEpYRKoOWlpZaHI3E58RiMZ49ewY/Pz8cfvsWe2rWzNgbeOVK/D4mw4YBLVqkW9xIIsH3qlV/2TwgYZogG7h37x6GDh2Kfv365RpHAIifJki8VjijJDz5psSjR48UywLDwsLQpEkTzJ49Gw0aNMjWUOT27dvx48cPVKxYEcOHD0fHjh1hY2OT5v4PtWrVgqOjI9atW6dwBiwtLbF582bUrVsXEokEfn5+KU6vLFiwQJE0KJFI4O7ujpYtW2LSpElYsWIF8uXLh5iYGNStWxcNGzbEvHnzUL16dfj5+WH27NmYM2cOduzYAR8fH6V3kcwsP378UIT5E44HDx4owtf58uWDq6srhgwZosjqdsiAyEp/S0v0CQ39/9PY9u1AYr2CCxfiDwCoV+//zsDPy1UT/nZxAerXhwRAbxubXOMIAECfPn2wYMEC7Nq1SxHSzmlatGiBXr16YcSIEahdu7bao5FyuRzR0dEqcTSCg4Px4cOHVOsp8WwKID5qpaurGx/mz6gzcOpU/NJYJev9kMkQIZdDLxd9L9WBEBnIJGFhYShbtiy0tLRw7dq1HF9+lEBUVBR0dHSwbt26ZDKdytKzZ0/cu3cPN27cABD/FL5v3z4sX74c586dg6WlJXr16oU+ffrA0dFRleYrBUkULVoUT58+xc6dO9G2bVt4eXlh6NChWLx4MYYNG5Zq3WnTpsHT01MRBQDiRaLKly8PsViM8+fPo0qVKknq+Pv7o2jRohg6dGiSZMMEbt++jYEDByqSEt+/f4/Xr1+jW7dumD59OhwcHPDgwQP07t0bV69eRd++fTFv3rwsL6siiXfv3iUZ9O/evYtXr14BiF/O5ezsrBjwE+ZZs7L88fDhwxgyYgRejRsHkYMDqCoHkISJhgaeli8PixzaqCg16tati6ioKFy8eDGnTVEQFhYGV1dXhZ7J77BlMUmF05GeoxEcHIxPnz7hkr4+zv/n2CtFZGS8TkapUsDs2UpXC65aFUa/6HssRAbUCEn0799foeSWWxwBIH67TyBzywoTcHJywu7du/H27Vv4+PjAx8cHHz9+RPXq1eHr64vWrVvniJhSAmfPnsXTp09hamqKFv+F+YYMGYL3799j+PDhsLa2RocOHVKs26NHD0ybNg27du1Cjx49EB0djR49eqB06dLQ0dGBm5sb/Pz8YGpqqqgzbNgwmJubY+LEiSm2Wbp0aVy6dAkbNmzAmDFjEBUVhTZt2uDo0aPYtm0bhg4dinHjxuHixYtYsWIFxo0bhwMHDiiWISpDTEwMHj9+nGTQT5yBbWpqilKlSqFly5aKMH+RIkVUtjb/1atXGDp0KA4dOoR69ephQZkyaP/1q+q2MBaJYL9jB8RFiwI5JHGbGn379kX79u3x8OFDlayGUQX6+vrYtGkTqlatitmzZ2Py5Mk5bVKWiY2NxZcvXxAUFISPHz8iKChIcST+++PHjwgJCYmvVL06kBFn4OJFICERVklEAHRyUQKmuhCcgUywfv16bN68GZs3b85RudKUSNAYyOwTu1wuR3h4OH78+IF8+fJBT08P3bp1Q79+/eCcS9bbzp8/H2KxGAMGDEgy2M2ZMweBgYHo1q0bLC0tUatWrWR1HR0dUbduXaxbtw49evTA9OnT8fz5c9y6dUsxb+7h4aHYOvbw4cPYv38/duzYkeaKCLFYDA8PjyRTB0WKFEHjxo3h7e2NNWvWYMKECRg4cCBatGiBgQMHok2bNmjVqhW8vb1hk0jpLCFpKnFS38OHDxEbGwsAKFCgAFxdXTFixIhMr81WlsjISMydOxfz5s2DpaUldu3apdBRWBkYiN4qkq5uK5fjzNatKHPgAHbv3o0yP68Lz0FatGgBS0tLrFq1Cl5eXjltjoJKlSph4sSJmD59Oho2bJgr1Al/RiaTKQb4lAb1xAP+t2/fktW3sLBAnjx5YGVlBUdHR5QvXx5WVlaKI8LcHC2Cg5U36NQpQEcnQw5EAW1taP4BzoAwTZBBHj58iHLlyqFTp05Ys2ZNTpuTDB8fH/Tr1w+RkZEZenr/+vWrYllgwrbHo0aNwuTJk9PcvCa7efr0KYoUKQKRSIQ3b97A3t4+yesxMTFo1qwZrl69ivPnz8MlhSzgbdu2wc3NDbt27UKHDh0wdepUxVP/gQMH0KJFC3h5eaF3794oXrw48ufPjxMnTmRosE08ddC6dWvo6elh69atsLe3x6xZs9ChQwfs3r0bAwcORHh4OGrXrg2JRIK7d+/izX9KalpaWihRokSSpL4SJUpky2+QJPbv34/hw4cjMDAQo0ePxrhx45Kp360ODES/Z88gBjIcJRAjfivZUfb2mJ8/P969e4c2bdrg/v37WLZsWZa27lU1Y8eOxapVq/D+/ftM7f6oLnJCnZAkvn//nuqgnvjvz58/J1v1YGxsrBjgE47Efyf838LCIt3IlpyEwYULiFBmZUVwMNC2LVC7dnwCoRJIALjlyYNNKtiRNKcQVhOogfDwcJQrVw4SiQTXrl3LVTeFBCZOnIiNGzfirRKbySQsC1yxYgW2b9+ukFPu2bMnateunaW8A3XRr18/rF27Fg0bNsTBgwdTLBMaGopatWohMDAQly9fTjZlEhUVBWtra0ilUtjb2+PatWtJbjpDhw7FypUr4eHhgbVr1+LevXtpbgiUGnK5XDF1EB0djTZt2iie9PX19UES4eHhivLGxsZo3bo16tSpA1dX1zSFVtTJ8+fPMWTIEBw7dgyNGjXC0qVLUShhdUAKXAsJQZfHj/Hyv6xzZVLAxABMNTSwtnDhJJsSRUVFYejQoVi9ejV69+4NLy+vXDEN9/LlSxQsWBAbNmxA9+7dc9qcJDx79kyhjrly5cpMtUESoaGhqT65//z/hChVArq6urC2tk5xUE/8d548eVT+eXZ69Ag7P39OUX00CXv3Al5ewLx5QAaiKDuKFUM7S8ssWplzCM6AGvDw8MD27dtx8+ZNlexdrw6U2VsgPDwcvr6+WL58uWIPhb59+8LDw0OxLNDR0RGdOnXCnDlzssv0dPn69StsbW0RHR2NI0eOoFGjRqmW/fjxIypXrgwNDQ1cunQp2Var5cqVw82bN3Hr1i2ULl06yWvR0dEoW7YsHj58qEhKzKidiUP8N2/exJMnTxSZ0hYWFpDL5fj69SvKlCmDuXPnQiqVom/fvvD398f48eMxduzYbF+GGB4ejtmzZ8PT0xM2NjZYsmQJmjdvrlREJEomg8+HD/B6/x4vIiPj5V5lMsWGRgnbw8oBWGpoYKCtLQbZ2sI0lSe/devWYcCAAShRogR27dqVI4mqP1O/fn2EhYXh8uXLOW1KMhLUCQ8ePIimTZsqzkdGRqYZmk/8989LCDU1NVMd1H/+vypFxTLK+W/fUOPevfQLDhwIfPgA7NwJKLkywEJDA+8rVYLGLzxNICQQqphNmzZh/fr12LBhQ651BID4nIHU9kV4/PixYllgSEgImjRpgpkzZ6JBgwbJxEKcnJzw/Pnz7DBZaVatWoXY2Fg4ODgk2UUwJfLkyYNjx46hSpUqaNasGU6dOqWI5Ny+fRu3b98GAHz48CFZXS0tLVhaWuLhw4cICgoCyRQHRLlcjtevXydL6ktI4tTR0UHJkiVRvXp1DB48GNra2li+fDlu3ryJzp07o1atWpg3bx7q16+Pbt264dChQ/jnn38wc+ZMbN++HT4+PslWNqgDkti9ezdGjBiBT58+Ydy4cRgzZkyG1tVrSyQYbGeHQba2uBEaivpDh+JHnjwoVbs2LPLkgamGBkrp66OsgQGqGxlBms7N1cPDA66urmjdujXKlCkDX1/fLC2XVQV9+/ZF27Ztcf/+fZQoUSLH7IiJicGnT5+SDORfv35F3rx50bZtW5QuXRpfv35FUFDQ/xPt/kMikcDS0lIxkBcuXBg1atRIccA3NjbO9Wvr//33XwwfMQLo2ROi4sXTXt2ybFmG2x/v4PBLOwIZQYgMKMGTJ09QtmxZtG3bNtNCPtmFvb09evTogRkzZgCIn1NMWBZ49uxZWFhYKJYFprXiYODAgbhw4QLuKeNxZwPR0dFwcHDA169fFTLCynDjxg3UrFkTderUwZ49eyCXy1G2bFmIxWKQRMGCBbF79+4kdQ4fPoymTZtiyJAh8PLywvr169GxY0c8ePAgyaB/9+5dhIaGAogXakq8hM/V1RWFChVK5mTJ5XKsX78eY8aMQWxsLKZMmQINDQ3MnDkTP378wNChQ9G8eXOMHDkS165dQ//+/TFnzhyV7e72M48fP8aQIUNw6tQpNGvWDEuWLEH+LEoBBwcHw8TEBED8+59RWevEfP36FZ07d8aJEycwc+ZMjB07NsekdRMc0TZt2sDb21ulbSck2inzFJ8gFJUYc3NzmJub4+XLl7C0tESHDh1SDNubmZmpXCUwJ3j27BlGjx6NAwcOoFKlShju6Qm3qCjIRKKMqRGmghRAGQMDXCpdGpJc7hClhzBNoCIiIyNRoUIFxMXF4caNG7ly+9AEYmJioK2tDR8fHzRo0ACrV6+Gj48PgoKCUK1aNfTv3x+tW7dWKvy8ZMkSjBs3DuHh4blC13zjxo3o3r07pFIp3r9/D8sMzOEdO3YMzZo1g7u7O6ysrDBnzhzcuHEDFy5cwIgRIxAYGKiYHomKikKRIkVgamoKNzc3rFy5Eq9fv1bIv4rFYhQuXDjJoO/i4gIrK6sMXc+3b98wceJErFy5Es7OzliwYAEuX74MT09PaGtrY/z48RCJRJgyZQoMDQ2xbNkytGzZMkN9pEVoaChmzJiBxYsXw9HREUuXLlXZ5jcXLlxA9erVAQBBQUHIkydPltqTyWSYNm0aZsyYgebNm+Off/7Jsa2iJ0yYAG9vbwQGBqZ7L0hItEtvmVxQUBA+ffqULNHOyMgozdB8wpE40S4hATYh5+J349u3b5g+fbpiI7B58+ahefPm6Nu3LzZ9+gSkICOeUSQADKVSXC9dGgVzYV5YRlF6/KYS/PjxgwD448cPZYr/VvTu3Zva2tq8f/9+TpuSLs+ePSMAVqlShWKxmPr6+hwwYADv3buX4bYOHz5MAHz79q0aLM0YcrmcJUuWpK6uLt3c3DLVxoYNGwiAYrGYU6ZMIUl++vSJGhoa7NatG8ePH8/GjRvTwMCAiJ/epp6eHsuXL09jY2Pa2dnx3LlzDA8PV+GVkTdv3mSFChUIgF27dqWfnx/79u1LiUTCvHnz0svLi02aNCEAtm7dmu/fv89Sf3K5nFu3bqWNjQ11dHQ4Y8YMRkZGquhq4vH29qZYLKaWlhZlMpnK2j148CCNjIxYsGDBTH2nVcHLly8JgHPmzOGFCxe4c+dO/v3335wwYQJ79erFpk2bsmzZsrS3t6eGhobiu5Rw6OrqMn/+/KxcuTJbtWrF/v37c9q0aVy1ahX37dvHq1ev0t/fP0ufSa9evainp8fnz5+r8MpzlpiYGC5ZsoQmJibU19fn7NmzGRERwQ8fPrBixYrU0tLili1bOPrKFeLMGeL06fh/M3hIz5yhyYULvB0SktOXrDKUHb8FZyANtm7dSgD08fHJaVPS5MuXL/T09KStrS0BsHDhwlyxYgVDsvCFfv78OQHw1KlTKrQ0c5w+fVpxMz137lym2vj+/TvNzMwIgNWqVWOlSpWop6enaNfGxoY1a9akRCJhy5Yt+ezZM8VAdvfuXWppaXHAgAGqvCwFMpmMa9asoZmZGQ0NDblkyRLev3+fLVu2JACWLl2aEyZMoKWlJY2MjLhy5cpMDbL3799nzZo1FY6Fv7+/Gq6G7NOnDy0sLFiwYEGVt/3ixQuFY7hlyxaVtRsREcHXr1/z6tWr3LdvH1euXMmpU6eyf//+bNWqFStVqsR8+fJRV1c32QCvoaFBe3t7litXjs2aNWOvXr04ceJEent7c+fOnbxw4QKfP3/O0NBQldmbFqGhoSxQoAArVKjA2NjYbOlTXcjlcu7fv59OTk4Ui8Xs3bs3g4KCSJK3b9+mnZ0dra2tee3aNQYGBtLOzo6FunWj2YULlGTCGah86xZfRETk8FWrFsEZyCJPnz6lvr4+O3XqRLlcntPmJEMul/PatWvs3r07tbW1qampqXjCVMWTXmxsLKVSKZcvX64Ca7NGkyZNaGhoyOLFiyv1WQQFBfHYsWOcO3cuO3bsyCJFilAkEhGA4t8aNWpwwYIFnD17NgHw2rVrbN68Oe3s7BgWFpaszRUrVhAAd+3apY5LJEl+/fqV/fr1o0gkYsmSJXn+/HleuHCBFStWJADWqVNH4SBUq1aNjx8/Vqrd4OBgDh8+nBKJhE5OTjx+/LjaroEkK1asSEdHR9auXVst7YeHh7NLly4EwMGDBzM6OjrFcjExMQwICODNmzd5+PBhrl27lrNmzeLgwYPZvn17Vq9enU5OTjQyMko2wIvFYlpZWdHV1ZUNGzZk9+7dOWbMGC5evJgjRowgAO7Zs4ffvn3LlfeHK1euUCKRcOrUqTltSqbx8/Nj7dq1CYB169bl3bt3Fa/t2rWLurq6LFOmDAMCAhgZGckKFSrQxsaG79+/59eYGPZ/+pTa585RdOZMqo6B9OxZ4swZ2l66xGUBAZTlws8yqwjOQBaIjIyki4sLnZycsvR0rQ7CwsLo4+PD0qVLEwDz5s3LOXPm8OPHj5w0aRJtbGxU1peTkxOHDx+usvYyw5MnTxQ357///jvJa3FxcXz8+DF9fX05ZswYNmzYkFZWVoobuoGBAatWrcqOHTtSLBazZ8+eDA0NZdu2bamtrc1Lly4xLi6OdnZ2bNiwIQFw586dKdohl8vZtm1bGhkZ8fXr12q95hs3brB8+fKKqYPAwEDu2rWLhQoVokgkYoMGDejo6EhNTU1Onz491cFQLpdz48aNzJMnD/X09Dh37txUy6oKmUxGPT09Ojg4sEePHipvPy4ujh8/fqSfnx8HDRqkmE7p06cPO3fuzDp16rB48eKKKNDPh5mZGYsXL846deqwc+fOHDFiBOfPn8+NGzfy+PHjvHv3Lj9+/Mi4uLhUbYiJiaG1tTX79++v8utTJZMnT6ZEIuHVq1dz2pQM8eHDB/bs2ZMikYiFCxfmwYMHFQ6XXC7ntGnTCIAdOnRgeHg45XI5u3btSm1tbV6/fj1JW8GxsVwWEMAODx7Q8fJliv9zAkQnT9Jk1y72ffKEBz9/Ztxv6AQkIDgDWaB///7U0tKin59fTpui4PHjxxwyZAiNjIwoEonYpEkTHjp0KMlNq1u3bqxcubLK+mzSpAmbNGmisvYyQ79+/ainp0ddXV2eOHGCK1asYN++fVmhQgXq6OgobvL29vZs1qwZJ06cyF27dvHFixeUyWSMiYmhq6srS5QooRgIIyMjWb16dZqamvLRo0ccO3YsRSIRa9euneZT3vfv35k3b15WrFiRMTExar1umUxGHx8fxdTB0qVLGRERwWXLltHCwoLa2tqsWLEiJRIJixcvzsuXLyep7+fnx6pVqxIA27dvz3fv3qnV3gQSppfMzMw4efJkperI5XJ++/aNjx494r///ktfX18uXryYY8aMYffu3dmwYUO6urrSysqKEokk2QAvEokokUhYsmRJtm/fnoMHD+asWbO4du1aHj58mDdv3mRAQIBKP7OJEyfSwMAg20L/mSEmJobly5dnoUKFUox25TYiIiI4a9Ys6uvr09TUlF5eXkk+s/DwcLZv354AOGPGDMVvdf78+QTArVu3KtWPTC6nm5sbq1evrpbryG0IzkAm2b59OwFwxYoVOW0KY2JiuHPnTtaqVYsAaGFhwbFjx/LVq1cplq9evTo7deqksv6HDx/OQoUKqaw9ZZDL5Xz//j2PHDnCCRMmUCwWUywWK278UqmUJUuWZNeuXblw4UKePn2aX758SbW96dOnUyKR8ObNm0nOf//+nc7OznRwcGCvXr0IgPPnz0/XvitXrlAqlXLMmDFZvlZl+PLlS5KpgwsXLjAkJISTJ0+mrq4ujYyMaG9vTwAcOHAg37x5w8GDB1MsFrNo0aLZnvOxe/duxQDt7e3N58+fKxLtvL29OXHiRPbq1YvNmjVjuXLlaG9vT01NzWQDvI6ODvPly8dKlSopEu2mTp3KlStXct++fbxy5Qpfv37NiIgIBgUFKfI9Fi1alC1he39/f4pEolyfT/Ts2TPq6uqyb9++OW1Kqsjlcm7ZsoX29vaUSqUcPnw4v337lqRMQEAAy5QpQ11dXe7evVtx/tChQxSJRBw/fnyG+pwwYQLt7OxUYn9uR3AGMsGLFy9oaGjI9u3b5+g84Lt37zh58mRaW1srVgds2bKFUVFRadZzcHDguHHjVGbHihUrKJVK1fYUHBsby4cPH8ZnAY8ezXr16tHCwkIxIGhpaSnm+CdPnszbt2+n+x4k5u7du9TQ0OCECRNSfP3du3e0srKiSCSivb09a9WqpVS78+bNIwAeO3ZMaVuyyo0bN1iuXDkCYLdu3RgUFMTAwEDFygNTU1NKJBKKRCJqa2vT09NTLZ9bZGQk/f39FYl2q1at4rRp0xSJdnZ2dkmct5QS7cqWLcumTZuyV69enDBhAv/++29Fot2zZ88YEhKS4d9fbGwsR40apYiEZMcTe6NGjVi2bFm195NVVq5cSQA8cOBATpuSjMuXLytynRISd3/m2rVrtLa2pr29Pe/cuaM4//DhQxoYGLBFixYZTqhds2YNRSJRhu4nvyqCM5BBoqKiWKZMGRYoUCBHrlMmk/HEiRNs1aoVJRIJ9fX12b9//yRJM2kRGxtLiUTCVatWqcymU6dOEUCKP9CMEhISwosXL9Lb25u9evVi2bJlqa2trRgoHB0d2aJFC06ZMoV79+7lkydPaGVlpcjSzigxMTEsXbo0ixcvnuYPvmbNmoq5SQB8+fJlum3LZDI2aNCAFhYWDAwMzLBtmeXnqQMvLy/GxsZy165dNDExUQy4ANi2bVulbYuJieH79+9569YtRaLd7NmzOWTIELZv3541atRg4cKF0020a9CgAR0cHJgnTx4C4IIFC/jvv//y4cOH/Pr1a7Y42Dt37qS+vj6LFSvGJ0+eqLWvffv2EQBv3bql1n6yilwuZ9OmTWlpacmPHz/mtDkk4yMrHTp0IAC6urry33//TbHcli1bqKWlxUqVKilWEZDxEbMCBQrQ2dk5U3ldCSuUVHFvy+0IzkAGGTJkCDU1NbP9h/3161cuXLiQhQoVIgA6Oztz+fLlGf6Cv379mgBUmin+9u1bAuDhw4eVriOXy/nu3TsePHiQM2bMYJs2bViwYMEkT4eurq7s0aMHlyxZwrNnzyYLCZL/1wUQiURct25dhm2fOXMmJRIJb9y4kWqZgwcPKuYftbS00owi/MzHjx9pZWXFOnXqpJlspg6+fPnCvn37UiQSKRLlSpQowb///lux8kBTU5O6urqcPHkyjx07xo0bN3LBggUcOXKkItHO2dmZ5ubmaSba1a5dm506dVIk2v3zzz+KRLugoKBk116gQAFFMmZOzVM/evSIRYoUoYGBQZKQsqqJjY2lra1trg7BJxAUFEQLCws2a9YsR6OeP3784Lhx46ilpUUrKyuuW7cuxd+PTCbjuHHjFJGwxA59TEwMa9WqRXNz81SnTNPj1atXKr9f5lYEZyAD7NmzhwCSZaurk+vXr7NHjx7U1tamhoYG3dzceOHChUz/UM+cOUMAKn0akslk1NHR4eLFi1N8PSYmhvfu3ePGjRs5YsQI1qlTJ0kWt4mJCWvVqsXhw4dzw4YN9PPzUyqbPUFkKH/+/DQ2Ns6w0M/9+/epoaGR5pRJREQE8+XLx3r16lEul3Pv3r0EQH19faXXZp86dYoikYizZs3KkH2ZJSHR7uHDhxw5ciR1dHQU0ygFChRgrVq16OrqSmNj4xQHeENDQzo5ObF69eps166dItFuzZo1PHToEG/evMl3795lesVBSEgIAbBNmzY0MzNT8dVn3Ja2bdsSAMeMGaO29faTJ0+mvr5+rlt1lBIHDhwgAJVGD5UlLi6Oq1evpqWlJbW1tTlp0qRUp3JCQkLYokULikQiLliwINk9ccCAAZRKpTx79mym7UmIpK5cuTLTbfwqCM6Akrx+/ZrGxsZs3bq12j3m8PBwrl27lmXKlFGExmfPnp0k/JVZEp6kI1QsmFGiRAn279+fwcHBPHfuHL28vOjh4cHSpUsnSfzKnz8/W7duzWnTpnH//v188+ZNpt/PhBCekZERhw4dmqG6sbGxLFOmDIsVK5bm9MDUqVOpoaGRxHkaM2YMAbBnz55K9zdx4kRKJBJevHgxQ3YmJjQ0lM+fP+fFixe5a9cuent7c9KkSezdu7ci0c7BwSHFRDstLS2amZlRKpVSKpWySpUqnDRpEpctW8bevXtTX1+fIpGIYrGY48ePV+vSwsuXLyucgVKlSqmtH2WRy+X09PSkRCJh7dq11RIif/v2LcVicY4MsJmhd+/e1NXVzdbw+MmTJ1miRAkCYJcuXdJUNX39+jVLlChBAwMDHjx4MNnrCXofqni/8+XLl22JwDmJ4AwoQXR0NMuXL8+8efPy+/fvauvnyZMnHDp0KI2NjSkSidi4cWMePHhQpeHlqVOn0srKKsvtyOVyvnnzhvv37+e0adMUsrUJg4+mpibLlClDDw8Penl58fz58wwODlbBFfyfJk2aKDLkHz16lKG6s2fPplgs5rVr11It8/LlS2prayeLHMjlckUC48aNG5XqLzY2llWrVqW9vT2/fv2qOJ+QaHft2jXu379fkWg3YMAAtm7dmpUrV2aBAgWSqCAmnkqxs7NTJNr17NmTw4cPZ6VKlSgSiVioUCH6+vomSbRLPHVQsmRJhXMSEhLCsWPHKnIJrKysMq3imB4rV66kRCJhgwYN2KJFC7X0kRnOnDlDS0tL2tnZqWXNfdOmTVm6dGmVt6sOQkNDWbBgwWxRJ3z8+DGbNm2qSIJO6zdJkhcuXKC5uTnz5cvHBw8eJHv9zJkzlEqlHDx4sErsq127Ntu1a6eStnIzgjOgBCNGjKCGhka6X9LMEBMTw127dikUtMzNzTlmzJhMz3GlR48ePVihQoUM1YmOjqafnx83bNjAYcOGsWbNmklCzGZmZnR0dKSBgQE3bdrE+/fvq319/ePHjwmATk5OrFmzZobqPnjwgJqamul6+82aNaO9vX2Kc9qenp4Ui8WUSCTJ5hNjY2MViXZHjhzhunXrOHv2bHp4eFBTU5NmZmZ0cnJKMUwvFouZJ08euri4sEGDBuzWrRv/+usvLlq0iFu3buXp06dTTLSLi4vj8uXLaWJiQmNjY3p7e6fpRF6/fp1ly5YlAHbv3l0RdQoMDGSbNm0U9jRo0EDlTtyAAQNYrFgxFi9enIMGDVJp21klICCAlSpVooaGBlesWKHSKGBC+D2t/JTcxNWrV9WqTvjlyxcOHjyYUqmUefPm5Y4dO9J9v9euXUsNDQ3WqFGDnz9/Tvb6y5cvaWpqyrp166rMienZs+cvsRokqwjOQDok/IAXLVqk0nYDAgI4ZcqUJMsCN2/erPYlLLVq1WKHDh1Sff3bt288c+YMFy9ezO7du9PFxSXJRioFCxZk27ZtOXPmTB46dIgBAQGUy+Vct26dWqYfUqNv376KvIPt27crXS82NpblypVjkSJF0pRjTkgaTJAVlslk/PTpE+/du8eTJ08qNtlJWKpXvnx5Ojs708LCQjE/n/gwNTVlsWLFFGHQmjVrct68efznn3947Ngx+vn5pZhopwyXL19mqVKlFFMXnz59UqpeXFwcV61aRVNTUxoZGSlWHZDx+RTOzs6KCMTMmTMzbFdqVK1alW5ubjQwMFBKsyG7iY6O5qBBgxSOkqq+07GxsbSzs2Pv3r1V0l52MGXKFJWrE0ZHR3PRokU0NjamgYEB586dm640elxcnELeuXfv3ilOY/348YPFixdnwYIFk0TfssrMmTNzPLclO/gznYHoaPLTJ/LjRzKNwffNmzc0MTFh8+bNVfKEIJPJePLkSbZu3ZoSiYR6enrs16+f0ssCVUHC/JdcLuerV6+4Z88eTp48mS1atKCjo6Ni8NLW1ma5cuXYu3dvLlu2jJcuXUoz+enixYsEkC27Nn7+/Jna2tqsUKEC8+TJk6H57blz51IsFvPKlSuUy+X8/v07Hz9+zDNnznDbtm1csmQJR40aRX19fZqbm7NUqVK0trZOUdFOKpVSU1OTBgYG1NLSYteuXTlz5kyuWbOGBw8e5I0bN1JMtBs6dKhKVqR8/PiRPXr0IACWKVMm0zfsL1++sE+fPhSJRHRxcUmS17B9+3bFUkErK6tUl3Ypi1wup6GhIadMmUIA3LZtW5baUyebNm2ijo4OXV1dlVpKqgxTp06lnp5e7r9H/keCOmHBggWzrMmQkIBbsGBBisVi9u3bV6n8jODgYDZs2JBisZheXl4p3ovj4uLYtGlTGhoaKr0Xh7Js2bKFAH6J5M+s8Gc4A3I5efky2a8fWaIEKZWSQPwhFpNFipAeHuTp0/FlGf8jqFy5Mh0cHLLsZX779o2LFi2ik5MTAbB48eJctmxZtr1PUVFRvHXrFn18fCgSiViwYMEka8EtLCxYv359/vXXX9y6dSsfPnyY4RDbx48fCUCtS7QSSFjiZ2BgkKKiWFhYGF+8eMGLFy9y9+7dXLZsGSdNmsS2bdtSJBLR2tqaDg4O1NLSSjbAa2trK3I26taty379+nHKlClcsWIF9+7dy8uXL/PVq1cMDw/noUOHCMTv2Ojk5MSCBQsqdXOLiopi6dKlWahQoUzdYGJjY+nl5UUjIyOamppy5cqVKskruXbtmmLqoEePHoprkclkHDp0qMIhqly5Mt+8eZOpPvz9/QmAy5YtI4Bk8si5jbt377JAgQI0MTHJ0NLZ1Hj37h3FYnGuUC5VlgR1wj59+mS6jdu3byt2wqxfv77SDw3Pnz9nkSJFaGRklObyvjFjxlAsFvPIkSOZtjE1rly5QgDZ+tCWE/z+zsCpU6Szc/zAn9gJ+PlIeK1gQXLvXo4ZM4ZSqTRLN6vr16/T3d2dOjo61NDQYMeOHXn+/Hm1rkb48uULT58+zYULF7Jr164sUaIEpVIpE9biA2D16tU5Z84cHjlyhIGBgSqxRy6X08jIiHPnzlXBVSQnKiqKb9684YULF2hiYqLYjKdLly5s06YNq1SpkmqinVQqpZ2dHXV1damnp8fu3btz/Pjx9PLy4o4dO3j+/Hk+ffqUP3784IsXL6ilpaWUQmNsbCytra05cOBAvnr1ilZWVixbtqxST1DPnj2jvr4+u3TpkqH3//z58yxZsiRFIhH79u2bpsRyZvh56uDvv/9WOIYfPnxQqMCJxWL26dMnwwm1+/fvJwDFqpaAgACV2q8Ovn//zqZNm1IkEnHKlCmZ2hY6Mc2bN6erq2uu3MUwNVatWkUA3L9/f4bqBQYG0t3dnSKRiEWLFuWRI0eUvu7Tp0/TxMSETk5OaS6F3rRpEwHQ09MzQ7YpS1BQEAFw7969amk/t/D7OgPh4WTfvv9/+k/NCfj5EIlIgFsBLp02LRPdxi8LTHjCcnBw4KxZs1SyLDAxMpmML1684K5duzhx4kQ2bdqUdnZ2igFQV1eXFStWZN++fblixQpeuXKFx48fz1TmvbKUK1eOHh4eSpePjY1lYGAgb9++rUi0mzNnDocOHcoOHTqwZs2aLFKkSKrr4TU1NVmyZEnWr19fkWi3cOFCbtmyhadPn+aDBw/45csXymQyzp8/nyKRKF3nrmnTpqkmDabE2LFjaWxszMjISN6+fZsGBgZs2LChUgmUmzdvJgCuX78+3bKBgYGK7XgrVKig9iS0xFMHrq6uvHTpkuK1ffv2KT4THR0denp6Kp3rMmPGDJqYmHDZsmWUSqXZLsSUWWQyGWfMmKFY5ZOVaOHhw4cJQC0JyeoiQZ3QwsJCqXtZeHg4p0+fTj09PZqZmdHb2ztDScXLly+nRCJhvXr1UhQbS+Dq1avU0tJijx491OZcyeVy6urqqjxvLLfxezoDISFkpUoZcwJ+OuJEIsqLF4/PLVCCp0+fctiwYYoQc6NGjXjgwAGV3OwiIiJ448YN+vj4cODAgaxSpQr19fUVg6KVlRUbNmzIsWPHctu2bXzy5EmK/W7cuJGA+hTfOnXqxCpVqvDz58+8f/8+T548yU2bNtHT05OjRo1ily5dWLduXZYoUSLdRLtatWrRzc2Nw4cP59y5c7lhwwYePXqUTk5OCu39Q4cOKWXX48ePqaWlxZEjR6ZZLiFZNCNTHU+fPiUA+vr6kowXGNLQ0GC3bt2Uujm5u7tTV1c31XnOmJgYLly4kAYGBjQ3N+fatWuz/GSaEVKbOggPD2f//v0Vn6GNjQ23bt2arm3t2rVjjRo1OHbsWObNmzc7LkGlHDt2jKampsyXLx9v376dqTbi4uLo4OCQIcc5N5CgTti0adNUv9symYybN2+mnZ0dNTQ0OHLkyAxFj2JiYjhgwAAC4JAhQ9KcrgwICKC1tTUrV66s9sTrYsWKqWypYm7l93MG4uLImjVJiSTTjoDikEhIFxcylUzX2NhY7t69m3Xq1GHCEru//vorS8lGnz594okTJzh//nx26tSJxYsXV8zVJuww5+bmxnnz5vH48eMZijjMmDGDFhYWGbYpIdHuyZMnPHv2LLdt28alS5dy3LhxdHd3Z6NGjVi6dGkaGBik+ARvYGDAQoUKsWrVqmzbti0HDRrEmTNn0sfHR5Fo9/bt23R/0Al7IDRs2JCOjo5KOVpxcXGsWLEinZyc0swKT1AarF+/foafMKpWrcp69eop/t66dSsBKDXVEBYWxiJFirBkyZLJ7Pv3339ZrFgxisViDhw4MM0nJHUSFxfHlStX0tTUNNmyxdu3b7NYsWKKz7pUqVI8ffp0qm0VLlyYQ4YMYadOnVitWrXsugSV8vr1a5YuXZra2trcsGFDptqYPn06dXV1Vb5sU92kpU548eJFli9fngDYunVrvnjxIkNtf/36lbVr16ZUKk1XLCg8PJxly5alvb29yqOuKdGkSRM2bdpU7f3kJL+fM7BgQaqD+3WAAwEWA6gL0B5gO4BP03IIxGLyp/Xo79+/59SpU2ljY0MArFSpEjdt2pTu8pjEyGQyPn36lNu3b+e4cePYuHFjRXsAqKenx8qVK3PAgAFcvXo1r1+/nmG53Z/p2bNnks18wsLC+PLlS166dEmRaDd58mT26dOHzZs3Z4UKFejo6Jhqol3evHlZsWJFtmjRgn379mXr1q0JgJs2bUqSaKcqGjduzGLFilFHR0dpad+FCxdSJBKlq/w3ZcoUamho8OnTpxm2a926dRSJRPT390/SL6CcdPXdu3eppaXFAQMGkIxPMkvYnKVy5cpJdmDLST5//szevXsnmzqIjY2lp6cntbS0FOqHjRo14r1795LUDw8Pp1gs5po1a1itWjV27tw5Jy5DJURGRtLDw4MA2K9fvww/mb5//54SiYTLli1Tk4Xqo0+fPtTV1VX8Vl69esV27doRAEuXLp0psapHjx6xYMGCNDU15ZkzZ9IsK5fL2bFjR+rq6mY6OpNRBg0axOLFi2dLXznF7+UMvHhBamikOrC3AWgFcDBAH4AzAOYBqAfwfloOgUhE+Y0bPHXqFNu0aaNYFtinTx+lbtTh4eG8evUqV61axf79+7NSpUpJEt1sbW3ZpEkTTpgwgTt37uSzZ88yHQpOSLS7fv06Dxw4wNWrV3PGjBkcOHAgLSwsaGZmxoIFCyaZZkicaGdra8syZcqwcePG9PDwUCTabd++nefOnePTp08ZHByc4tPzjRs3CKhHVOXRo0cEwE6dOlEqlfLDhw/p1nn69Cm1tbU5fPjwNMu9fPmSWlpaGd7rPIHQ0FDq6+tz2k85JiNGjKBIJOLOnTvTbSNBPrVLly7U09Njnjx5+M8//+TKJLOrV68qpLLd3d0VUwevXr1ivXr1CEAhb+zu7s53796R/P/34/r163R0dFTpNto5hY+PDzU1NVm+fPk05XNTomXLlixZsmSu/IzTIkGdsEyZMhw1ahQ1NTVpY2PDDRs2ZOq+dfToURoaGrJ48eJKRVVnzpxJAEr9rlTFokWLqKur+8t9Vhnh93IGhgxJc8XAJYDRP517BlALYOc0nIE4sZgH/wuBFytWjN7e3qmG9z58+MBjx45x7ty57NixI4sUKaLYt10ikdDZ2ZldunShp6cnT548qZRATOJEu6NHj3L9+vWcM2cOhw0bxo4dOyoS7RK2p018iEQiWlpasmTJktTR0WGxYsU4evRoLly4kJs3b+apU6eSJNplheDgYALg1q1bs9ROSvTp04d58uRh4cKF2b59+3TLx8XFsUqVKixYsGC60YmMJg2mRM+ePZk3b94k76FMJqObmxu1tLTSfVo6fvy4wkFzd3fP9eHjhKmDnxUP5XI5N23aRDMzM+ro6NDAwIDa2tocO3Ysvby8KBKJGBISQolE8kstr0uL69ev08HBgebm5mlOkfzM0aNHCYBXrlxRo3WqJzY2VrE/h1Qq5ZQpUzL125HL5Vy8eDHFYjGbNm2q1LiRsFHYlClTMmF55knoNzumJHKK38cZCAsj9fQylRtQ+r8jrTJxIhEv792r8Azj4uL4+PFj+vr6csyYMWzQoIFif/aEefJq1apx0KBBXLNmDW/evJlkGkEmkykS7U6dOsXNmzcrEu26du3KevXqsUSJErS0tEwx0c7ExIRFixZlrVq12LFjRw4bNixJot2dO3f44cMHRQKOTCajhoYGvb291foxWFpaqly+NEFkKCEsm14YkSQXL15MkUjE8+fPp1kuM0mDKXHp0iUmaA4kJjo6mnXq1KGRkVGysDkZL2yVIP9buXJl2tjYsGLFimqXc1YVnz9/Zq9evRT5AgmrNT5//syuXbsSAPPmzUsdHR1qa2vTwsKCL168IJCxLa9zO58/f2a9evUoFos5b948pZ4gZTIZHR0d2aNHj2ywUDUcP35coUzp4uKiEPDKKNHR0ezZsycB8K+//lIq/+fu3bvU09Nj27ZtszWJliT9/Px+ScctI/w+zsCJE5lyBOQAbQHWV6LsSXd39unTh+XLl0+yKY+DgwObNWvGiRMncuPGjTx58iT//fdfbt++XZFo5+HhwcaNG7N06dK0tbVVrP1PfOjr67NgwYKKRLuBAwdyxowZ9PHx4f/YO++oJrauje9JQkJC70iRqoDSRcXeuyiCvYsN20XsvfeGvXJt99rbtXex94a9d1GwoPSWeb4/MPOKtCQkgH781spSJjPnnEkmc/acvfez9+3bh6tXr8oVaJcT7969gyIR+MpSvXp1dOzYUaVtTp06FWKxGC1btoSzs3O+N9onT55ALBbnW8lQFjTYqFGjAi//sSwLJyenHM/9+/fv8PT0hKWlJbeUnJKSgmnTpkEsFqNUqVLYvHkzWJbF5cuXIRAIfrsqaT+7DoKCgrgVr6NHj8LOzo4TiZJlHhD9eSIuGRkZGDNmDIgIrVq1kus+KLsG1FkATRU8ePAATZs2BRGhRo0auHbtGtLT01G5cmU4ODgopE4YExODGjVqQCgUYsOGDXIfY2NjA09PT7VlQ+WFbG5Tx6pnceHPMQZmzFAqg+CfHxPx3/nsl0qEBQwDGxsbVK5cGQ0bNkTz5s3RpEkTLtBOU1Mz2wQvEom4Y1q2bIk+ffpgwoQJWL58OXbv3o0LFy7g+fPnar/AC0suOCgoKEuQYkFJSUmBmZkZunbtCoFAgIULF+a5v1QqRfXq1eHg4JDvZ1qQoMGcmD17NkQiUY5R/1FRUbC1tYWLiwu2bdsGR0dHCAQCDBs2LJsK4Zw5c0BEOHLkiErGVVhkZGRgxYoVnOtg2bJlyMjIQEJCAoYOHQqizEJczs7OICJ4enoWWN64OPLff/9BV1cXZcuWzbGq3s9ERUVBIBDIFWhaFHz69AkDBgwAn8+Hvb09du7cmcVwlqkTyltvITIyEjY2NjA1NZVb0C01NRU1atSAqamp0sqXqsDQ0FDuwOXfkT/HGOjcWWFj4CERdIlQhQgZcqwgHKH/BdpZWFjA29ubC7QbPXo0Fi1ahG3btuH06dN49OhRroF2RUFh6WvPnDkTenp6KjvvdevWgYgwePBgiMXifNPrFi1aBCLK10cvUxpUNmgwJ6KiosDn87F8+fIc35dpEBBlFiq6f/9+jvtJpVI0atQIJiYmiIqKUtn4CoucXAeylSl7e3swDAOBQMDpFzRt2jRHF8rvzJMnT+Dq6gotLa186y8EBATA1dW12NwrgEwjfN68edDT04Ouri7mzp2b64rk6tWrQZS/OuF///0HLS0teHp6yj2psyyLXr16QSgUZhG+Kgp8fHzQs2fPIh2DOvlzjIHAQE49UJ7XByLYU2Z64Xs5j0nw8MCnT58K3V+lCqZPn14olbd27doFIpK7cl5esCwLNzc3NG3aFKVLl0aPHj3y3P/p06cQi8VyiYM0b94cpUuXVvmKjJ+fX7Zyp0lJSZg0aRI0NTVhamoKoVCIli1b5uknjY6Ohrm5OerVq/fbqPT9yqVLl+Dt7Q2iTD16IsLTp09RrVo1MAyD0qVLY8yYMXB0dMyWefAnkJCQgI4dO4KIEBoammsciEwZtKgnOyDzN7dr1y44ODiAx+OhX79++f6WWZZFixYtclUnZFkWM2bMAMMwCAgIUOg3JzPu5VHpVDdt2rRB3bp1i3oYauPPMQbat5dbcfAbETyJYEiE+4q4FerUKfzzUhG9e/eGt7e32vu5c+cOiCjfvH55OH78OIgI06dPhywlLTekUilq1qwJe3v7fG82sqDB3bt3F3iMv/Lff/9l8Yfv27cPdnZ20NDQwKhRoxAfH48DBw6Az+cjODg4z6fBEydOgGEYlZYPLmwyMjKwfPlyLsZm6dKl8PPzQ+3atbk0xLZt22LGjBkwMTHhMg+KezaFvLAsi8WLF0MgEKBGjRo5psRKpVLY29uja9euRTDC/3Hjxg3UqlULMp2I/FwcPxMdHQ1TU1M0a9YsyzWdnJyMTp06gYgwfvx4hR6kjh07Bh6PhyFDhih0HupixIgRsLOzK+phqI0/xxgYPTrvQkQ/XslEqEGZokMXFTAE0oiwy9gYQUFBWLRoEU6fPl3sg35+pmHDhggICFB7P0lJSSAirF27tsBtNW3aFB4eHmjWrBm8vb3znDiXLFkCeTINkpKSYGtrq5KgwZxIS0uDqakpunXrhmbNmnFPxb8WWvn7779BRJg6dWqe7Y0bNw58Ph/nzp1T+VgLk1atWsHU1BREmfUMWrVqBZZlsXHjRhgZGcHQ0BArVqzA2LFjIZFIYGRkhIULF6pdZrawOH/+PEqVKoVSpUrlaCjPnDkTmpqaRaIy+e7dO3Tr1g0Mw6BcuXJKx6rs378fRISVK1cCyHSbVapUCZqamgqXqn78+DH09fXRuHHjYrMytmLFCvD5fIUruv4u/DnGwK5d+U7oGURoQQQBEQ4qsiJAmTED66tUgbe3dxZFvp8zCQoqGKROypYtW2gWdunSpQssKCMTGZo3bx4YhsGaNWty3ff58+eQSCQYMGBAvu1OmDABQqEQT548KdD4ciMxMRG+vr4gIlhbW2P37t25Gh1Tp04FEeHvv//Otb309HRUr14d1tbWBS6lXZSUL18e/fr1w6VLlzh57Z49eyImJgYxMTHc02P9+vVx4cIF9O7dGzweD3Z2dtiyZUux/E0pyocPH1CjRg0IBAIsWrQoy3Xx8eNHuQJkVUlCQgImTZoEiUQCY2NjrFixosATXd++fSGRSLBr1y5YWlrCwsJCYRGy2NhYODk5wdnZuVitEB05cgREhJcvXxb1UNTCn2MMfPyYr5sg5McE7keZWQS/vvJdHfix9JuWloZ79+5h06ZNGDFiBBo1agRzc3POQNDS0uIqBi5fvhwXLlxQe+BeXkilUohEIixatKhQ+qtXrx4CAwML1EafPn1QqlQpjBw5Erq6urku/UulUtSuXRu2trb5pjfJggbHjh1boLHlBMuy2L17N2xsbLggwX///TffY4KDg8Hn8/NM+Xzz5g0MDQ3RsmXLYhVkJi8pKSmcyFB8fDyICN26dYO+vj4MDAywfPlyZGRk4MiRI5wmwezZsxEZGQk/Pz8QEXx8fP6IzIO0tDSEhoZCpqb583XdunVruLi4qP07lkql2LBhAywtLSEUCjF8+HCVTboJCQkwNzcHj8eDj48P3r9/r9Dx6enpaNSoEQwMDNRmsCuLrCjZn3Ad5sSfYwwAQEBAnq6CWpS9iM7Pr7xWFM5RZn70lClTcpXCjY6OxrFjxzB37lx07twZbm5uWfQEHBwcEBAQgMmTJ+O///7Dy5cvC+Xm/uHDB8gT7asq+vXrBzc3N6WPj4mJgaamJiZPngxTU1MMHDgw132XLVsGIspX+Y1lWS4QUZX1EoDMm4QsQK5Zs2Z4+vQpfH190aRJk3yPzcjIgL+/P8RiMS5fvpzrfnv37gURYfHixaoceqFw69YtEBEuXrzIrficOXMGMTExnPCMt7c3Ll++jISEBAwZMgQ8Hg+enp64fv06zpw5wxXA+VMyD7Zu3QotLS24urpyk54sRkadLqGzZ89yWRytW7cuUFG1X5FKpZg4cSKIMpVPlVkdDA0NBZ/Px/Hjx1U2LlWRkpIChmEQHh5e1ENRC3+WMXDmjEJL/4q87k+ZwhXo0NDQQPv27XHu3Ll8J/OUlBTcunUL69evR2hoKOrWrQsjIyPOQNDT0+OUCtesWYOrV6/mWV1PGS5duoTCFHkJCwuDWCxWeml3ypQpEIvFCA8PBxHlGsj04sULaGlpoV+/fvm2KZtMVRk0mJCQgFGjRkFDQwN2dnbYt28f997q1avB4/Hkio5PSkpCtWrVYGRklKfmQUhICIRCIW7cuKGS8RcWGzZsgCytNael1osXL8LLyyuL6+DatWvw9PTkAsji4+OxY8eOPyrz4N69eyhbtix0dXXx33//QSqVwsHBAZ07d1Z5X8+fP+eULn18fFRucCQkJKB169aQBfxOmjQJfD5fbi0B4H9xNMXZ4LWyslLLymJx4M8yBgCga1fVlC/+8ZLyeDjK58PM1BRbtmzB169fERYWhjJlyoCI4O7ujtWrVyuULsOyLN69e4eDBw9ixowZaNeuXZYaBjweD87OzmjXrh1mzJiBgwcP4t27d0qvImzZsgVEVGj+twMHDoCIFC7cAmRGH5uamiI4OBi1a9fOtcytVCpFnTp1YGNjk68LRhY02LhxY5WsxLAsi23btsHKyopbwfjVgPv+/TskEoncIiVfvnyBi4sLbG1tc9UWSElJgbe3N8qUKVOkbidFGTp0KOzt7QFkFvZhGCZbmp0s60DmOlixYgWSk5Mxe/ZsrkLmkSNHkJqaiiVLlnCZB6NHjy5WfmVF+f79O1q1agUiwpgxYzBz5kyIRCJ8/vxZJe1/+/YNw4cPh1AohKWlJTZu3Kjy+Is3b97Ay8sLWlpanLGdnp4OX19fudUJz58/Dw0NDfTu3btYu8Jq1KihcoXV4sKfZwzExgKlSqnGIODzAX19fLhxg7OqmzRpgpcvX0IqleLo0aNo0aIFeDwe9PT0MHjw4AL5uRITE3H16lWsWbMGAwcORI0aNaCrq8utIhgZGaFu3boIDQ3F+vXrcevWLbmirWfNmgV9fX2lx6UoT548kWvpPifWrl0Lokzd+rzkP2VV/n6tBZATqgwafPDgAerVqwciQsuWLfHixYtc9+3WrRscHBzkvrm9fv0alpaW8PT0zPU39OTJE2hra6Nz587F+qb5M/Xr14e/vz8AYPz48bC0tMx135iYGK4Ghcx18OzZM+4z79SpE2JiYvD9+3eMGzcOYrGYyzxITU0trFNSKSzLYvbs2eDxeKhVqxYEAgEWLFhQoDbT09OxfPlyGBsbQyKRYPLkySp3jwGZq45mZmYoXbo0bt++neW9p0+fQktLC7169cqzjdevX8PU1BQ1a9Ys9t9h165dUaVKlaIehlr484wBAHj4EDA0LJhBwOdnFj76Kbd93759sLa2hkQiwdy5c7nI25cvX2LkyJHc8n/Dhg2xd+9elaTEsCyLly9f4r///sPkyZMREBAABwcHzkAQCARwc3ND586dMXfuXBw7dowrKSsjODgYnp6eBR6LvKSlpSlVlU4mMtS8eXOEhITAxMQkR2Pn5cuX0NbWRp8+ffJtU1VBg3FxcRg2bBgEAgEcHR1x6NChfI85c+YMiAinT5+Wu5+7d+9CT08P9erVy/XG+O+//6K4CLHIg6mpKSZMmAAg00CS52b6s+ugV69eiImJwfr162FoaAgjIyOuvPP79+/Rq1cv8Hg82Nvb/9aZBydPnuQm79KlSytt7B0+fBjlypUDwzDo3r073r17p+KRZrJx40aIRCJUq1Yt2z1HRn7qhPHx8fDw8ICtrS0+ffqklnGqkokTJ8Lc3Lyoh6EW/kxjAACePAFcXBRSJeRePB5gYwPcupWt2bi4OISEhIDH48HLyytL2kxycjI2bNjABTvZ2Nhg1qxZarnI4+LicOHCBSxfvhx9+/aFr68vtLS0OCPB3NwcjRo1wogRI+Du7o46deoUan5smTJlEBoaqtAxsgCqQ4cOQV9fP8diPSzLol69erC2ts73OlNF0CDLsti0aRNKlSoFsViM6dOny537zrIsHB0dFRaTOX36NEQiETp06JDrxNajRw9IJBI8fPhQobYLm48fP4KIsHPnTgBAnTp10K5dO7mOzcjIwLJly7K4DqKiojhVvwYNGnABcPfv3/8jMg/evHnD1W4YNmyYQsfeu3cPjRs3BhGhVq1aaostkUqlXAnj7t275/l7kKkTGhsbZwu8lkqlCAgIgLa29m8TFCqLf1HHKktR8+caAwCQmgqMG5eZYSCHOiHL42UaDyEhQD5f9s8BTiEhIdl8uFevXkW3bt0gEokgEonQtWvXPBX0VIFUKsWTJ0+wY8cOjBs3Dn5+fihdujRnIIhEInh7e6NHjx5YuHAhIiIi1CZy0qxZMzRv3lyhY5o0aQJPT0/8/fffYBgmx0jnVatWgYhw9OjRfNsraNDgnTt3ULNmTRARAgMDlSqSMn36dIjFYoV/Ezt37gTDMBg6dGiO7yckJMDZ2Rnu7u4qDzhVJceOHQMRcS4aBwcHhSe56Oho9OjRA0SEChUq4MqVKzh06BBsbGwgFouzrNL9mnmg7sJc6iA5ORl6enpcQOXPpc9zIiYmBv369QOfz4eDg0Oe2hYFJS4uDn5+fmAYBvPmzZOrH5k6YdOmTbPsP2HCBDAMg//++08tY1UHZ8+eBRHlWlfkd+bPNgZkfPwITJ8OODjkagi8JsLD1q0BBYLe0tPTMXfuXEgkElhbW2eJJpfx6dMnzJ49G7a2tiAiVKxYEevXr8/3B64qWJaFpqYmBgwYgEWLFiEoKAgVKlTIIpxkbW2N5s2bY+zYsdi+fTseP35cYBfH4MGDUbZsWbn3v3//PogIGzduRMWKFdG4ceNs+7x69Qra2tr5+iCBggUNfvv2DSEhIeDz+XBycsKxY8cUOv5n3r59Cx6Ph9WrVyt8rExVcf78+Tm+HxkZCZFIhP79+ys9PnUzb948SCQSSKVSSKVSCIVCpaPFL168CE9PTzAMg169euHly5cYPHgweDwevL29uSdhlmWxfft2Tl8/KCjot8s8mDt3Lvh8PjQ1NVGhQoUchW5SUlIwZ84c6OrqQk9PD/Pnz1erz/3FixdwdXWFrq4uDh48qNCxsqBimetw+/btkGUe/E68ffsWROovBV8U/P8wBn4mNhaIiAC2bwe2bQNOnAA+f4aLi0u+hXBy48WLF9zyXGBgYI5CGxkZGdi3bx8aNWrEBQOOGDFC7WpW0dHROT4dp6en48GDB9iyZQtGjRqFJk2acHXmiQgSiQSVK1dGnz59sHTpUpw7d06h73X58uUQCARyuyZ69+6NUqVKcWmQv/oYWZZFgwYNYGVlJVf0uDJBg1KpFOvXr4epqSm0tLQwe/ZsldxcmzRpAl9fX6WOHT16tFyBlLJl+OJG165dUblyZQD/07soyJNgRkYGli5dyrkOVq5ciUuXLsHd3R18Ph/Dhg3jlnBlmQfGxsa/XebBp0+fIBQKERoaCjs7OxgaGnIywSzLYseOHbCzswOfz8fAgQPV7m8/c+YMjI2N4eDgoPRTcXBwMCQSCXbv3g2xWIwOHTr8NkGwMmQGbXEtOV0Q/v8ZA7kwfPhwmJqaKh18xLIstmzZAlNTU+jq6mL58uW5tvXkyROEhoZCX18fDMPAz88PR44cUUvg09WrV0FEuHnzplz7x8TE4MSJE5g/fz66du0KDw8PTlGPiGBnZwd/f39MnDgRu3fvxvPnz3P8QZ84cQJEmVXq5OlTJBJh+vTp6NWrF6ytrbOtTKxZswZEhMOHD+fb3tOnTyESiTBu3Di5zhnIFMapWrUqiAjt27dX6ZPkjh07lF5aZFkW3bp1g4aGRo6ZEyzLonXr1tDT0yuWMqmenp5crXtFr8W8+Nl14OPjgwsXLnD6/nZ2dllWc75//46xY8f+dpkHHTp0QNmyZfH582c0adIEDMMgODgY1apVg0zg6sGDB2ofR3h4ODQ0NFCnTp0CpTwmJCRwRbsqVKhQrN1beVGmTJliUzxJlZQYAz+Q+YLyUoGThy9fvnC13KtWrZqnzzIhIQFr1qyBh4cHiAhlypRBWFiYSgsgyZbjChIbkJqaisjISGzcuBFDhw5F/fr1YWJiwhkIOjo6qFatGvr3749Vq1bh8uXLePToEZcimB8ykaEXL15AIpFgypQpWd5//fo1dHR0EBQUlG9bLMuiSZMmsLGxkSvI5+vXrxgwYAB4PB7KlSunlsCz1NRUGBsbK+wrl5GWlobGjRtDR0cHt3IIao2NjYWtrS18fX1zLZNbFKSlpWV5itq5cyeISGU59ABw4cIFznXQu3dvXLlyBXXr1gURoUuXLlmemN+9e5cl82Dr1q3FOvPg9OnTIMqUv339+jXc3d2535s6Km7+Snp6OgYPHgwiQnBwcIGvreTkZLi6uoKIEBISoppBFgENGzbkUmX/JEqMgR+kp6fDwMBAoafJvDh79iycnZ0hEAgwZsyYPK1glmVx/vx5dOjQARoaGpBIJOjdu3e2vF1lmDNnDnR0dFS+HMeyLKKionD48GHMmjULHTp0QLly5bgiNAzDgGEYeHp6Ytq0adi/fz/evHmTbRwykaF+/fphyZIl4PP5WUR3WJZFo0aNYGlpKZeRJCshvGfPnjz3k0qlCA8Ph7GxMXR0dLBgwQK1TqSDBw+Gqamp0n3Ex8fDx8cH5ubmOWobXL58GQKBIMcMjKLi7t27kEkPA8CCBQsgkUhUfi3KXAd6enpc9cPw8HAYGBjA2NgY//zzT5Y+f808yK/SZVHBsizKlCmD8uXLQywWc9Lc+vr6cHBwUKuiaGxsLBo1agQ+n49ly5YVuD2WZdG1a1eIRCKuCJUi6oTFieDgYHh4eBT1MFROiTHwE506dVLpl5ySkoJJkyZBKBTC0dFRLoGcDx8+YOrUqbC0tAQRoVq1atiyZYvSy5oDBgwoUJ0ARUlOTsb169fx999/w8jICBYWFtDX1+dWEQwNDVG7dm2EhIRg7dq1nJb5o0ePUK5cuWwFjmQSpfKsMCQmJsLGxgZNmjTJc8K5du0aKleuDCJC586dc1X8UyV37tyRy0jJi+joaDg6OqJMmTI5+ojnzJkDIlK6BK2q2bRpU5ZVqcGDB8PJyUlt/UVHR6N79+7cJH/48GG0b98eRIRGjRplM6JOnz6NihUrckvuxSnzQBa/IhMd++uvv7j76vPnz+Hp6QmxWIx//vlH5X0/fvwYTk5O0NfXV1mNgLlz54KIsGnTpizqhL+TkqaM2bNnQ1dX97eLd8iPEmPgJ2SyvcrI6ObFw4cPuRS1rl27yhXsk56ejp07d6JOnTogIpiZmWH8+PEKC4g0a9YMfn5+yg69QAQEBKB+/fpgWRavX7/Gvn37MHXqVLRu3RplypQBwzDcKoKdnR2ICL1798aRI0fw4cMHvH37Frq6uujevbtc/Y0fPx5CoTDXOIXPnz+jb9++YBgG7u7uOHv2rCpPN198fHwK/F08e/YMpqamqFy5cjYJbKlUikaNGsHExKRQDJz8GDlyJEqXLs39HRAQgAYNGqi9319dB5s3b0bp0qUhkUgwb968LEGtxTHz4PTp0/D29oZM5VIoFGLOnDlZ9klMTES3bt1ARBg4cKDKYiCOHz8OfX19ODk5qaxq4MGDB8EwDEaNGsVte/bsGbS0tNCzZ0+V9FGYyFyvv3NJ8ZwoMQZ+IjY2FgKBAMuXL1d527JlaQMDgywKavJw//59DBgwANra2uDz+QgMDMSpU6fkOr58+fJ5Vv1TJ6NGjYKNjU2u78t0AEJDQ+Ho6AhNTU1oa2tzqwhCoRAikQgDBw7EP//8gzt37uS6zP706VMIhcIc3TwZGRlYuXIlDA0Noaenh8WLFxeqAJOM5cuXZ3ODKMP169ehra2NZs2aZTuP6OhomJubo169eipRwCwITZo0yaI14ePjU2g3//T0dCxZsoRzHSxatAiDBg0CwzCoUKFCtiDG1NRULF68uEgzD54+fcrVKahUqRIuXLgAIHPF0tHRMVt8A8uyWLFiBTQ0NFClSpUCKQ2yLIulS5eCz+ejUaNGKotbevDgAXR1deHn55dt/LKg4IKslhUF165dAxHh+vXrRT0UlVJiDPxCnTp10LRpU7W1//HjR3To0AFEhHr16skVbS/j+/fvWLp0KVxcXEBEKFeuHJYtW5brUhvLstDW1sa8efNUNXyFkIkH5RYv0bhxY3h6euLjx4/Q0NDA/PnzIZVK8ezZMwwYMABEBF9fX06jQWYgeHp6olu3bliwYAFOnjyJT58+5Ro0ePnyZVSoUIFTS/v48WNhnHqOxMbGQlNTE7Nnzy5wW0ePHoVAIEBQUFA2o/DEiRNgGAbTpk0rcD8FwdLSEmPGjOH+NjU1xeTJkwt1DB8/fuRcBxUrVsS6devg5uYGPp+PESNGZLtefs08WLRokdozD2JjYzF06FBoaGjA2toamzZtyjJxyoKbc3MzXr58GVZWVjA1NVUq/iEtLQ3BwcEgIgwePFhlhvKXL1/g4OCA8uXL53iPYlkWLVu2zFGdsDjz+fNnEBF27NhR1ENRKSXGwC/Mnz8fIpFIoSqEynD48GHY2tpCU1MT06dPV+iGw7IsTp06hcDAQPD5fOjo6GDAgAHZ0oxkF21R5aCfO3cORJSjL/ZnkaFZs2ZBJBJxy27v3r2Dnp5eFhnfb9++4ezZs1iyZAl69eqFihUrQiwWc0aCTJ1u9OjR2Lp1Ky5cuMBNAl5eXsUmWKljx45wcnJSib/xn3/+ARFh/Pjx2d4bN24c+Hy+ykvVyovs2tu6dSuAzFgSoqKrp3D+/Hl4eHhwgkXjxo2DSCSCvb19jn7xnDIPVO0jTk9Px9KlS2FkZAQtLS1MnTo1xwwYlmXh4uKCNm3a5NpWdHQ06tSpAz6fL7cyIJD5PdWuXRsaGhpYs2aN0ufyK2lpaahXrx6MjIxyVBKVERMTAzMzs2zqhMUZlmWhq6urEqO+OFFiDPyCrOJeYUhkJiQkYPjw4eDz+XB1dVVqwnr79i3GjRsHMzMzEBHq1q2LXbt2IT09HdevXy/S5azcBI+A/4kMJScnw87Ojpv4WZZFs2bNUKpUqXzTITMyMnDz5k0YGxvD3t4eTZs25QIvZS8bGxv07NkTS5YswdmzZ4tcdObkyZMgIm4JuKDMnj07i7KbjPT0dFSvXh3W1tZF4ts8deoUiIgzUJ8+fQoi5SpZqopfXQdTpkxBrVq1QETo1q1bjimP9+7dQ/PmzbmVBVVkHrAsi4MHD8LFxQUMwyAoKChf11FYWBgEAkGeK1vp6elczYDWrVvnG5x3//592Nvbw9jYmMv4UBUDBgyAQCCQq0iXTJ1QHe5ZdeHh4YHg4OCiHoZKKTEGcqBs2bJySd6qilu3bqFixYpgGAb9+vVTasJKTU3F5s2bOUESKysrzh1RVNXAZBb0rFmzsmyXiQzNmDEDhw4dAhHh0qVLAP5XCCQnaeec+Dlo8Pz58/D09ARRpi791KlT0b17d3h5eUEoFHIGgq2tLVq2bIkJEyZg165dePbsWaHlm0ulUtja2sqlmSAPLMtyhbN+9b2+efMGhoaGaNmyZaE/dS1cuBAikYhbcpYZQYq4xdTFx48fueC7ihUrYuzYsdDX14eJiQk2bdqU42elqsyDu3fvokGDBiAi1KlTJ0fdiJz48uULRCJRtt9STuzatQs6OjpwdnbOVZTo4MGD0NHRgaura55luJVh5cqVICKsXLlS7mOCg4MhFovx6NEjlY5FXfj7+6NRo0ZFPQyVUmIM5MDQoUNhbm5eqIIkGRkZWLRoEbS1tVGqVCns3LlT6Rv4rVu30KtXL045sGPHjrhw4UKRLMP5+Phkm/gmT54MiUSCL1++oEWLFvD09OTK0err66Nz585ytS0LGgwNDUXXrl25m/uVK1ey7ZuWloa7d+/i33//xfDhw9GwYUNuNYWIoK2tjSpVqiA4OBgrVqzAxYsXER8fr5LP4FcmT54MLS0tlbUvlUrRtm1baGpqZnMLyII0la0HoCxBQUHw9vbm/l63bh2IqNBqcsjDz66DLl26oGXLliAiNG7cOEc1R5ZlsW3btiyZB/IG7UVHR6Nv377g8XgoU6YM9u7dq/DvsUuXLrC3t5frviRL1dXW1s7i22ZZFvPmzeOUT1Wd2hcREQGBQIABAwYodFxCQgLKli0LHx+fYiWclRuhoaEK1V75HSgxBnIgIiICRJSlPHFh8ebNG7Ro0QJEBD8/vwKlOfbu3RtmZmZwdHQEEcHT0xNr1qwp1PKbHTp0QI0aNbi/ZSJD/fv3x+vXr8Hj8bBy5UqwLIvmzZvDzMxMrmVtmRiRgYEBdHV1YWRkhNWrVytswH38+BFHjx7FnDlz0KlTJ7i6umYRTnJ0dERgYCCmTJmCvXv34tWrVwU2ql69egWGYbB27doCtfMzKSkpqF27NvT19bPJHoeEhEAoFKqtpG1O+Pj4ZKn1MXnyZJiamhZa//KSnp6OxYsXQ1dXF4aGhhg4cCAsLS0hkUiwYMGCHDMyfs48EIvFGDNmTK6recnJyZg1axZ0dHSgr6+PsLAwpQMSz58/DyKSu3BWfHw82rZtC6LMcsgJCQlcHM2oUaNUnm3y/PlzGBkZoW7dukpN6FevXoVAIFCZ8Js6Wbx4MYRCYbFWsFSUEmMgB9LS0qCvr48JEyYUSf8sy2LXrl2wsLCAlpYWFi5cqNQPt0WLFmjatCmkUikOHz6M5s2bg2EY6OvrY8iQIWpfso1NS0OXsDBo9+yJYc+eYejTpwjYtQvk64uLDx5g/Pjx0NHRQVxcHBcMJ2+sxvTp07kJu1+/fir1i6ekpODmzZtYt24dBg8ejDp16sDQ0JBbRdDX10fNmjUxaNAghIeH49q1awrrrDdo0ADVq1dX2ZiBzCBLd3d3WFtbZ8mVT0lJgbe3N8qUKVMoIi8ZGRnQ1NREWFgYt61nz57w8fFRe9/K8vHjR251qUKFCmjbti0YhoGPj0+uSqB5ZR7IVhFsbW0hEAjw119/FViGmWVZlC9fPpswV37HLFiwAHw+H7q6utDQ0MDGjRsLNI6ciIuLg6urKxwcHAr0W5wyZQp4PJ7KYmrUxf79+0FERa5JoUpKjIFc6NChQ5ZlzqLg27dv6N+/P3dTUrTAi7u7e7byti9evMCIESNgZGTELYkeOHBAZU8JLMvixNev8L97F7yICFBEBOjECWicPg2N06dBJ05kbouIgHDJEjSaNg1v37+HgYEBOnbsmG/779+/55529PX1Cy04kmVZvH37FgcOHMD06dPRtm1bODk5ccJJPB4PLi4uaN++PWbOnIlDhw7h/fv3ua4iyASuHj9+rNJxvn//HqVLl4arq2uWXPEnT55AW1sbnTt3Vru7SFaX4udgwYYNGyIgIECt/aqCc+fOwd3dHQzDwN/fH87OzuDz+Rg5cmSuBt+7d+/Qs2dPLvNg2rRpXNErPz8/lfrBFy9eDIFAoFAq3u3bt2FqagoejwcTExOVZ9ZkZGTAz88Purq6BS6clJ6ejipVqsDe3r5YqxPKsqEKW7hMnZQYA7kgk1ItiJCHqrh48SK3fC1b7pMHXV3dbMplMpKSkrB+/Xr4+PiAKLMa4Zw5cwr09PI+JQVNIiNBEREQnD7NTfq5vn4YBvpbtsDQ0zPPvtPS0jBv3jxoa2tDIpGAz+erfCJVhsTERFy5cgWrV6/GgAEDUL16dU5ClohgbGyMevXqYciQIdiwYQNu376N1NRUJCcnw8DAIIsqm6p48OABDA0NUbNmzSw+etk1re70vm3btoGIEBMTw21zdnbG4MGD1dqvqkhPT8eiRYs495O/vz+EQiEcHBzyzIY4fvw4l80iFovVou/x9etXLh1ZHvbs2QMtLS14eXnh6tWrqFq1KjQ0NLBs2TKVGYWjRo0CwzBySYbLw7Nnz6CtrV2s1QkTExNBRNiwYUNRD0VllBgDufDlyxfw+XyFImLVSVpaGlei1dbWNt9SvrGxsSAibNu2Ld+2r1y5whUR0dTURPfu3RWOlzj+5Qt0zp6FID8DIKfX8ePgnzqFjbk87Zw8eRIuLi7g8Xjo0qULNDQ0csytLy6wLIsXL15gz549mDRpElq1agV7e3vOQNDQ0IC7uzucnJygo6ODI0eOZJk4VcGFCxegqamJ1q1bZ1n16dGjByQSCR4+fKjS/n5m7NixKFWqFPc3y7KcD/534sOHD5zrwN3dnZMI7tGjR5al8Pj4eIwbNw6ampowMzPDsGHDOCO7WbNmuHfvnkrH1a1bN9ja2ubpr2ZZlnOlBQYGcg8Qqamp+Ouvv0CUWdWxoPFD//77L4gIc+fOLVA7vxIeHl7s1QnNzMwwadKkoh6GyigxBvKgZs2aWeRUiwPPnj1D/fr1QURo3759rnnHt27dAhHlGFmfGzExMZg5cyZsbGxARKhcuTI2btyYbwT4sS9fIDh9+n9ugQK81v6Ub/327VvOJVC9enXcunULTZo0ga2tbaEGQaqK79+/4/z581i2bBn69OnDlXOVvUqVKoXGjRtj5MiR2Lx5M+7fv18gNbi9e/eCx+Nh4MCB3FNgQkICnJ2d4e7urrZ68n5+flnSrn53xbazZ8/Czc0NDMOgVq1a0NXVhampKTZt2oS///4bpUqVgkgkwpgxY7ilbVnMgL29PXg8Hnr27KmyVcaLFy+CKPeCVElJSVxa8cSJE3M0GjZt2gSJRAJ3d3c8e/ZMqXFcuXIFIpEIXbt2VUtVVH9//2KtTujr64tu3boV9TBURokxkAdz586FpqZmsZt4WJbFP//8A2NjY+jr62PNmjXZfvB79uwBESE6Olrh9jMyMrB37140bNiQW+oeNWoUXr16lW3fV8nJkJw5oxJDgCIiwERE4OynT5g5cyYkEgnMzc25ErSycyoMQajCwsPDA/Xr18f27dsxduxYNG/eHNbW1pyBoKmpiQoVKiAoKAiLFi3C6dOn8xVj+plVq1aBiDBz5kxuW2RkJEQiEfr166eOU4KNjQ1GjBjB/X3z5k2FDdPixs+uAwMDA5QtW5b7jlq0aJHjbwNQLPNAXliWhZubG1q1apXtvffv33PqnNu3b8+znTt37sDR0RF6enrYv3+/QmN49+4dSpUqBV9fX7Wli8rUCfOrQlpU/Jop9btTYgzkwcOHD0FECv9QCotPnz5xqUI1atTIEryzcOFCiMXiAv+IHj9+jJCQEOjp6YHH46Fly5Y4duwYpFIpWJZF7Vu3Ml0Dhw6BunYFVawI0tHJvFGOHJnzpL9+feZ+mpqZ+zZoANqzBxQRAd6pU9DYuhU8TU2EhoZy11JiYiJKly79W8mWyoMsIOxXo+3Lly+IiIjAwoUL0aNHD3h7e0MkEnETUOnSpeHn54dx48Zhx44dePLkSa7LxrIy0evXr+e2rVixAkSql6r+9u0biAj//vsvt+2///4DERXbJzxFuHDhAmesaWpqQl9fX66Mn2/fvmHMmDEqq3kgKyr0/v17btu1a9dgYWEBS0tLudNIY2NjuVTm8ePHyxVInJSUBB8fH1hZWan9Oz148GCxVSccO3YsrKysinoYKqPEGMgDlmXh6OiIPn36FPVQ8uTkyZNwdHSEhoYGJk6ciJSUFAwePBjOzs4q6yMhIQGrVq2Cu7s7iAhly5ZF0Nq1/5vgf0THk5kZ6IcKYI7GwPbtID09kIUFaOBAUM+emQaBgwPo2LHMfU6exLCrV7P0L9OSV3ZJs7jy+fNnCIVCzJ8/P99909PTce/ePWzatAkjRoxAo0aNUKpUKc5A0NLSgq+vL/r27Yvly5fjwoULiIuLA8uy6N27N/h8PhdrwrIsWrduDT09vRwFdpRFVo/izp073LY/ISf769evCA0NhYaGBkqXLo2JEydyroPy5cuDKLPSYGRkZJ7t/Jp5sG3bNqWM22/fvkEikWDq1KkAgK1bt0JTUxOVK1dWuCqmVCrF9OnTwTAMGjVqlGcgL8uy6NChA8RicaHpVvTr169YqhOGh4eDYRikpKQU9VBUQokxkA+hoaGwsLAo9k+jSUlJGDt2LAQCAZycnFC9enU0btxY5f2wLItz586hffv2oLCw/6UKHj0K2rUr8/8/5EhzNAZatACJRKCtW/+3bd68zP2HDOG22Vy8COmPz/zJkycQCoXFOmiwILRt2xblypVT+hqLjo7G8ePHMW/ePHTp0gXu7u4QCASckeDg4IBWrVrByckJIpEIe/bsAcuyiI2Nha2tLXx9fVWm+rZs2TJoaGhkeeodPnw4HBwcVNJ+YZOWlobFixfD0NAQ2tramDFjBhdrkZ6ejoULF0JXVxd6enqwsLAAn8/H6NGj843H+LXmgTwa/r8SFBQEa2trjBkzBkSETp06FWjJ/ujRozAyMoKtrW2uE70sKDE/F4QqSUxMLJbqhDKJ7SdPnhT1UFRCiTGQD7IvvDDV2wrCvXv3uBxnZ2dntRWpeZWcnLvvPy9jwMAAVKtW9u3W1iBv7yzbTsfGgmVZNG7c+LcNGpSHI0eOqNynnpqaitu3b2PDhg0YMmQI6tWrB2Nj4yzyy9WrV0fr1q25LA1VfL59+vSBu7t7lm3t2rVDnTp1Ctx2YcKyLPbv389pSfTq1SvXJfEPHz6gS5cuIMqsCSIQCODo6IhTp07l209ERARX86B58+YKZR7IlFIZhsHMmTNV8sDy6tUr+Pj4QCQSZVPIlLl7ikKM7dq1a8VOnfDFixcgIhw9erSoh6ISSoyBfEhLS4Ouru5vlUIilUohkUigqanJRT2remVja3S04sbA9u2Z2/v0yX5MgwYgXV3ub35EBGa+esUFDe7du1el4y9OZGRkwNraGn379lVrPyzL4u7du7C0tIShoSH8/f25ynky4SQnJye0bdsW06dPx4EDB/D27VuFrh1fX99stSWqVKnyW0VdR0ZGchk79erVy1WB8FfOnDnDuQ5k7pugoKB8DXJlMg9ev34NDw8P8Hg8VKpUSe5zk4fk5GT07t0bRIQ+ffogJSUFd+7cgZaWFgIDA4vM3TN16tRipU6Ynp4OPp+frWLo74q88zeP/p+ioaFBjRs3pgMHDhT1UOQmPj6ekpKSaMGCBVSrVi3q1KkTNWnShF6+fKmyPm7Gx5MGwyh20Nevmf8aGWV/z9CQKC6OKC2NiDIfX698+0YhISHUrFkz8vPzK9iAizF8Pp+6d+9OW7ZsoaSkJLX1wzAMubq60oULF0gkEtHbt2/pypUrFB8fT76+viSRSKhatWr08eNHmjNnDjVv3pysra3JxMSE6tatS6GhobR+/Xq6desWpaamZmufZVm6e/cuubu7Z9n+5s0bsra2Vtt5qYro6Gjq06cPeXl50du3b2n//v10/Phx8vDwkOv4mjVr0s2bNyksLIwSEhJIW1ubtmzZQs7OzrR9+3YCkONxDMNQ27Zt6eHDhxQWFkZ79+6lMmXK0NixY+n79+/Z9r948SJVrFiRvn37RqNGjaIbN27Q+/fvC3TuP6OpqUmrV6+m8PBw2rBhA1WpUoWaNm1Kjo6OtGHDBuLximY6GDVqFFWuXJm6dOlC8fHxRTKGnxEIBGRtba3S++rvwP9bY4CIyM/Pj65fv05RUVFFPRS5eP36NREReXp60vbt22n//v304MEDKl++PM2dO5fS09ML3EdUWhqxudzcckU2gWhoZH9PKMz894cxwBLR1VevKDo6mhYtWkSMoobHb0b37t0pLi6Odu3apfa+bGxs6PDhw/T06VNq3bo1aWho0N69e0lbW5tev35Np06dotjYWHr16hXt3buXQkJCyNDQkA4cOEA9evQgb29v0tbWJjc3N+rcuTPNnTuXjh07RteuXaPExMQsk2d6ejpFRUVR6dKl1X5eypKSkkIzZ84kR0dH2rVrFy1cuJDu3r1LzZs3V/i6EwgEFBISQo8fPyZ/f39KTk4mqVRK7dq1oxYtWtDbt29zPVYoFNJff/1Fz549o9DQUAoLCyNHR0dasmQJpf34XWzYsIHq1KlDZcuWpWvXrtHIkSNJU1OT/v777wJ9BjnRs2dPOn36ND148IDev39Pw4cPJy0tLZX3Iy8CgYD++ecfiomJocGDBxfZOH7G3t7+/50x8P/WTQBkRnzzeDysWbOmqIciF/v27QMRZYkqjo+PR2hoKHg8Hjw8PHD1l2h9Relw/z74iroJZNtHj85+TLt2me8dPZpl/xYtWuDgwYO4du0aXr9+XaxK4KqaOnXqoHbt2oXW36lTpyAUCtG5c2dIpVKcOHECDMNg2rRpuR4THx+PixcvYsWKFQgODkaVKlWgpaWVRTypVq1aGD58OP79918uHiI3gZyihGVZbNmyBTY2NhAIBBg8eLDKY2zOnDkDV1dXMAwDLS0taGlpYfHixXKl8P2ceeDg4AA/Pz/O9fBzgGavXr1gbW2t8iqEsiwUgUCASpUqgcfjYcaMGUWeFfL333+DiLB79+4iHQdQ/AtwKUJJzICcVK9eHS1atCjqYcjF4sWLIRKJcvzRXr9+HV5eXmAYBn/99ZfSxUD6PX6cWXhITTEDdOoUaO7cLJOM7KWjowMHBwdUrVoV/v7+6NOnD8aNG4fFixdj69atOHXqFO7du4eYmBiV3yDViaxyY2GmT27duhVExIkEjRs3Dnw+H+fOnZO7DalUiqdPn6Jt27aQSCRo0aIFp2Ipe7m4uKB79+4ICwvDqVOn1BbYKi+XLl2Cr68viAgtW7ZUa52LtLQ0hIWFQUdHB5qamlwa4s/pl/mN1dTUlNOXiIiIyPL+tWvX1KKHsnjxYhAR1q5di4yMDIwbN477vAoqnFQQZOqERkZGCqdRqppp06bByMioSMegKkqMATmZPXs2JBKJ2iRcVcmQIUNQpkyZXN9PT0/H/PnzIZFIYGVlpVRw3op378Aok02gr597NoGX1//+Pn4802gggoGBATw8PNC6dWuMGTMGM2fOxPDhw9GtWzc0adIEFSpUgJWVFYRCYTbDgcfjwdTUFG5ubqhXrx46dOiAkJAQTJ8+HWvWrMHevXtx6dIlPH/+HPHx8QX52AtMYmIidHV1Cz1ieuHChSAiLFq0COnp6ahevTqsra0VnrBbtWqFevXqcX/HxsZyE0jXrl3h4+PDTYb0I/K+WbNmGDNmDLZt24ZHjx6p3Xh7/fo1J9Xr6emZZ+EhVRMVFYXOnTuDKLOQEZ/Px9ixY/Nc7Xr+/DnKlSsHXV1dzJ49m6t58HPmAcuy8PLyUql0+vHjx8Hn8xEaGppl+759+6Cnp4cyZcrg7t27KutPUYqLOqGs+NefMOeVGANyIitZqarKXOokMDAQDRo0yHe/ly9fomnTpiAiBAQEKKSdfu37d+VSC2U6A9u2ZdcZCA3Nsq/fvHmoWrUqjIyMuIh32cvAwACVKlVCSEgIjh49iu/fv4NlWXz79g1PnjzB+fPnsXv3bqxcuRJTpkzBwIED0bZtW9SqVQsuLi5cCedfXxKJBLa2tqhUqRKaN2+OoKAgjBo1CgsWLMC///6LY8eO4fbt24iKilJLznPfvn1hZWVV6Csaw4cPB8Mw2LZtG968eQNDQ0O0aNFCoRutg4NDtsljxowZMDQ05P5OT0/HgwcPsGXLFowaNQpNmjSBhYVFls+/UqVK6N27N5YuXYpz586p5H4SFxeHMWPGQFNTE+bm5vj777+LbNXozJkznFCRzAWQk85AREQEjIyM4OjoyKmLSqVSbN26NVvmwcqVK8Hj8fDmzZsCj+/JkyfQ19dHo0aNcqyN8fTpU7i5uUEikWDz5s0F7k9ZDh06BCLCsmXLimwMsjoR8macFGdKjAE5YVkW9vb2atNzVyUVKlRA79695dpXltZkZmYGHR0dLF26VK6bpJRlYX3xYtaJ/q+/QEFBmRM+EahGjcy/g4JA+/dn7rNtW6Y7wMICNGgQqFevTAVCe/ss8QKap0/j+083orS0NFy6dAljxoxBjRo1YGJiks1A0NHRgaenJ4KDg7Fnz55cizjJSE9Px4cPHxAZGYnjx49j06ZNCAsLw+jRo9GzZ0/4+fmhUqVKsLW1hVgsztF4MDIygouLC2rVqoU2bdpgwIABmDx5MlasWIFdu3bh3LlzePz4Mb59+ybXxHr16tUi8bFLpVJ07twZQqEQp06dwt69e0FEWLx4sVzHx8fHgyh7eeTg4GB4eHjke/ynT59w4sQJzJ8/H127doWHhwc0NDS4z9nOzg7+/v6YOHEidu/ejefPn8vlu87IyEB4eDjMzc2hqamJcePGFfkKEJB5PS9YsABaWlqcQFTPnj25uhOrVq2CQCBA3bp1c1yhSU1NxaJFi2BkZASxWIxhw4ZBS0sLEydOLNC4vn37BmdnZzg5OSE2NjbX/RITE9GpUycQEUJCQopMDKh///7Q1NRUaxXOvPj48SOIind1RXkpMQYU4K+//oK1tXWxVyM0MjLKMwgsJ75+/Yo+P5blfX195fJnznn9OmuBIjOzHCdMIsqUK5btt3YtyMcnszaBtjaofv3/qRdGRIB38iT6yeHDTU1NxZUrVzBx4kTUrl0bpqam2QwEiUSC8uXLo3v37ti8eTNevHih9PeXkJCAFy9e4PLly9i3bx/Cw8MxY8YMDB48GB06dEC9evXg5uYGMzMz8Hi8bJ+BUCiElZUVvL290bhxY3Tt2hXDhg3DnDlzsH79ehw6dAjXrl2Dk5MTAgIClBpjQUhNTUXDhg2hq6uLyMhIhISEQCgUyiW4denSJVAO4lxNmzaFn5+f0uOJjIzEP//8g2HDhqFBgwac71xm/FWrVg39+/fHqlWrcPnyZa5UL5ApGObh4QGiTHW+169fKzUOdRIVFYWOHTuCiMDn82FgYIDGjRuDiNC/f/98J1lZzQNNTU1oampCT09PafGojIwMNG7cGPr6+nLFULAsi6VLl0IgEKBatWpF4r9PTEyEk5MTKlSoUKBaD8ryu5bnzgl5528GyD+PLC4ujvT09Oj79++kq6ub3+6/HSdOnKAGDRrQrVu3yNPTs6iHkyMJCQmko6ND//77L3Xq1Enh48+fP099+vShp0+f0vDhw2n8+PEkFotz3Pd7RgaVvXKFPqenE1vQgcsASMTj0YNKlcg+l37zIi0tje7cuUNHjx6l06dP0927dykmJiZLjrdQKCQbGxuqWLEi1a9fnypVqkROTk4kEAhUdRbEsix9/fqVYmJisr2io6OzbYuLi8vWhq6uLpmZmZGpqWmuL9n7BgYGKsn/jo+Pp9q1a9PHjx8pIiKCOnToQPHx8XTjxg3S0dHJ9bjVq1dT//79KSEhgTQ1Nbntbm5uVKtWLVq6dGmBxybj48ePFBkZmeX16NEjkkqlxDAM2djYUGpqKn348IGcnZ1p9uzZ5OfnV6zTU8+cOUO9evWiZ8+eERFRuXLl6OjRo2RlZSXX8e/evaOBAwfS3r17ydzcnBYuWkRV/PzoflISxUulJGAYKi0SkZu2NolyuU6GDRtGCxcupMOHD1ODBg3kHvvFixepTZs2xLIsbd++nWrUqCH3sarg+vXrVKVKFRo5ciRNmzatUPsmIipfvjzVq1ePFi9eXOh9qxJ55+8SY4AyJxpjY2MaMWIEjRs3rqiHkyP3798nV1dXOn/+PFWrVk2pNlJTU2nOnDk0bdo0sra2ppUrV1L9+vVz3Pfgly/U/O7dggw5G4MAWlynjsraS01Npbt379LJkycpIiKCIiMjKTo6OouBwOfzydramry9valOnTpUqVIlcnNzy9UQUjUpKSn06dMniomJoadPn1KnTp2oefPmVLZs2RyNh1+1Ivh8PpmYmMhlOJiampJEIsl1LNHR0VS1alUSCoW0YcMGqlevHvn7+9PGjRtznVAHDhxIERERdP/+/Szb9fT0aOzYsTRixIiCf0h5kJKSQpcuXaIZM2bQyZMnSSQSEZ/Pp8TERCIiMjAwIA8PD/Lw8CB3d3fy8PCg8uXLZzFcipInT55Q8+bN6d27d8SyLKWnp5NQKKQ5c+bQgAED5Db0HBo1oigfH0qpXJkoh3uwgGHIW1ub+llYUDtTUxLz+UREtH79eurRowctWrSI/vrrL4XH//HjR2rfvj2dP3+e5s2bRyEhIYVqfE2fPp0mTJhAZ8+eVfq+pywyPYr9+/cXar+qpsQYUJA2bdrQmzdv6MqVK0U9lBw5ePAgd1OxtLQsUFuPHz+mvn370pkzZ6hLly40f/58MjExybbf8OfPaV4eYipyw7Jk8uQJfRk0iBaFhdGAAQPUdkNJSUmhO3fu0Llz5+jkyZMUGRlJHz58yGIgMAxDpUqVIi8vL6pVqxZVrFiRPD09SV9fXy1j+pnAwEB69uwZ3b59O9tnAIC+f/8u14pDTEwMfZUpP/6ElpZWnoZDeno6DR48mBwcHCg4OJh69+5N69ato+7du+c43po1a5KlpSVt2bKF2/b9+3fS19enLVu2UPv27VX6+fxMeno6LV++nCZPnkwZGRk0duxYCgkJIZFIRO/evcu2ivD06VMCQHw+n5ycnDgjQfYyNzcv1Ins+PHj1LZtWzI3N6f9+/eTRCKhwYMH044dO4iIyN3dnTZv3kzly5fPtY13KSnU58kTOvz1K1FGBlEeq1w8yhT1MhAIaGmZMmTz7BnVrVuXunbtSqtXr1b63DMyMmjUqFE0f/58ateuHYWHh5O2trZSbSnTd61atejDhw90+/btQp1/Bg0aRKdOncpmCP9ulBgDCrJx40bq1q0bffz4kczMzIp6ONlYvnw5DR48mFJSUlSybAyA1q9fT0OHDiUej0fz5s2jbt26ZblhAKAuV67QppQUIoBImZsJQA0kEtrj5UXjR42isLAw6tmzJy1btoxEIlGBz0MekpOT6c6dO3Tx4kU6deoU3bp1K0eZV2NjY/Lw8KCaNWuSj48PeXl5UalSpVQ6FplRd+PGDfL29i5QW+np6fT582e5DIfo6GhKSUnJ1oZIJKK0tDSqWLEi2draZjMeunTpQsHBwTRhwgTS0dEhhmHo3r175ObmRhcuXKCqVasW6BxyAgDt37+fhg8fTs+ePaPevXvT5MmT8/1dJiYm0r1797IYCHfu3OEkbk1MTLIZCC4uLqSRk3JmAce/dOlSCg0NpYYNG9KWLVtIT0+Pe//MmTPUo0cPevnyJfF4PBoyZAhNnTo122rGzpgY6vH4MaWwLGUooArKUGbwhfDqVapw7BidPnSIhDIl0AKwY8cO6tGjB9na2tLu3bupbNmyBW5THl68eEEeHh7Upk0bWrt2baH0SUS0YMECGj9+PCUkJBRrV1R+lBgDCvLp0ycyMzOj8PBwCgoKKurhZGPEiBG0e/duzveoKmJiYmjIkCG0adMmqlOnDq1cuTLLj7xnr160JyGBMvr3p4SMDIKchgifiKTp6dTgzRs6HBRE/B8/pg0bNlCfPn3Ix8eHdu3aRebm5io9H3lJSkqiyMhIunLlCkVEROSqA6+rq0tubm5UrVo18vHxIW9vb7Kzs1PaIMvIyKDSpUtTQECASv3t+QGAEhMTOePg8OHDNHXqVPLy8qKXL18Sy7Lk5eXFGRefP38mls0aMSISicjU1JREIhE9e/aMWrduTXZ2dtlcFaampmRiYqLUBHT79m0aOnQonTp1iho0aEDz588nNzc3pc+bZVl69epVtlUEmdSshoYGlStXLpuRYGxsrFR/aWlpNGjQIFq9ejUNHTqUZs+eTfwfS/Y/k56eTmFhYTR+/HhKS0sjc3Nz2rp1K9WqVYuIiNZ9+EA9Hz8mosyJXSmkUvLU0qKzPj6ko6K4mYcPH1KrVq0oKiqKNmzYQK1atVJJu/mxbt06CgoKol27dlFAQECh9Pnff/9Rq1atiu0DoryUGANKUK1aNTIzM6Pdu3cX9VCy0bZtW/r69SudOHFCLe0fO3aMgoODKSoqisaNG0cjRoyg2NhYsrGxocmTJ1PtwECqsmIF8Zs1owwejzQYhtJ/uXQEDENSgPgMQ8b37hF/0yZ6evJkNv/8lStXqFWrVsTn82nPnj3k4+OjlnNSlMTERLp9+zZdv36dTp8+TdevX6d3795l208sFlO5cuWoatWqVKFCBfLy8lLoCXPMmDG0YsUK+vDhQ5H6tmX+5H79+tHatWspKCiIli9fTkREUqmUtmzZQl26dKGtW7cSAM6QOHPmDJ0/f558fX25eIicCszo6+vnG+MgeyUnJ9PEiRNp7dq15OTkRPPnz6cmTZqo7YksLi6O7ty5k8VAuHv3LiUnJxMRkYWFRTYDoWzZsjlO7DI+f/5MrVu3posXL9KqVauoR48e+Y4jKiqK+vTpQwcPHiQiooCAAOq6cCG1ev5ceSPgJ/hEVN/AgA67u6vss4yLi+Mm5lGjRtHUqVNVGqSbEwAoMDCQzp49S3fv3lX5il1OREZGkqenJ126dIl8fX3V3p+6KDEGlGDmzJk0ffp0+vz5c7EJQJJRuXJlcnV1VUvhEhlJSUk0ZcoUmjdvHjk5OVHlypVp27Zt9O7dOxo3bhxt376d7jx/TkcTE+lKfDxdjYujjz8KrRhqaFBFHR2qqKNDmlevUlBAAO3bty/XqoRRUVHUqlUrunPnDoWHhyuVIVEYJCQk0K1bt+jGjRt0/vx5unLlCmcgMAzDxSIIBAJycnKiKlWqkLe3N3l5eZG7u3uOAX1Pnz6lsmXL0ubNm6lDhw6Fej6/MnPmTBozZgx16tSJNm3aRDt37qTAwEAiygzeWjxvHn3ct4+YmzeJ7t4lSkykW3fv0oW3b2ngunVEVaoQlSpFycnJnGGQm6vi51dGRka2sTAMQxYWFuTi4kJmZmZ5ZlyoIwBUKpXSs2fPsq0iyL5vTU1NcnV1zWIguLu7k76+Pt2/f5/8/PwoISGBdu/eTdWrV1eo71OnTlGnTp3oY1wc0caNxBgaEvKavJ88IdqwIfM7SUsjKlWKqHlzoh/f3a+EOzlRTxVOoABo/vz5NHLkSKpTpw5t2bIlx7gjVfL582dyc3MjT09POnTokNqX7mXzXnH4nRaEEmNACWS+0MOHD1Pjxo2LejhZMDMzo4EDB9L48ePV3ldkZCT16tWLrl+/Tq6urrRz507y8PCg8ePH09ixY/M8NjExkcqVK0fu7u75RuGmpKRQ3759aePGjTR8+HCaOXNmnk9exYX4+Hi6desWXb9+nS5fvkyXLl3KYiAQZd4sGYYhOzs7qly5Mnl7e5O3tzd5enqSoaEh1axZk0QiER0/frwoT4UA0KBBg2j58uVUpUoVun//Pt2+fZtsNTVpZ716VP/pU9JPTyfi8TJfLEtSgEBEAlkcSfPmRCEhRPXqyd1nbGwsrV27lubMmUNfv36lWrVqkY+PD8XHx2czHGJjY7O1oa2tne9qg+xlZGRUoOvqy5cv2VYR7t+/z1UcNDU1pS9fvpCRkRFNmjSJGjRoQPb29gq7ktLT06nmli102dKSKK/xXrtGNHYskaMjUZ06RGIxUVQUEcsSBQfneIgWj0dvq1QhAxXHR0RERFC7du1IJBLRrl27qFKlSipt/1cOHz5MTZs2paVLl9KAAQPU2hcRkZGREQ0ZMiTf+15xpsQYUAIAZGdnR82bNy9Uf25+JCUlkZaWFm3cuJG6dOlSKH2uXr2agoODSSwWE8MwxLIsvX//ngwMDPI8buzYsTR//nx68OAB2dvb59sPAFq0aBENHTqUGjVqRJs3by6UqH5V8/37d24F4cqVK1kMBNmkIPPBW1hYkJmZGd26dYvWrFlDjRs3JktLyyILUpKV4j148CAZ6OtTf4mExsbEEJuQQHJNoQJBZqR7mzZEy5YR5fOEeOnSJQoNDeXcRXPmzCFHR8dc909LS6PPnz/LteIQHR1NqbKS2j9gGIaMjY3lMhxMTU1JW1s73+8iPT2dHj16RDNmzKCtW7eSiYkJMQxDMTExRERcKeifVxHc3NzyjMJPlErJ7MIFSmTzUPdITCTq0oXI1ZVo0qRMA00eABqpo0Oz1OCSe/fuHbVp04Zu3rxJixcvpj59+qj1Wh44cCD9/fffdPPmTXJxcVFbP0REPj4+5OnpSeHh4WrtR52UGANKMmjQINq3bx+9evWq2ESQPnr0iFxcXOjMmTNUs2ZNtfcHgFxdXalMmTI0bdo08vLyooyMDGrWrBktW7aMbGxscjzuyZMn5OrqSmPGjKFJkyYp1Ofx48epXbt2ZGJiQnv37iVnZ2cVnEnR8u3bN7p58ybduHGDrl69SleuXOHq3vP5fJJKpdy+hoaGVKFCBc7F4OXlRY6OjirJHJGHlJQUatagAfW/fJkCMzKIpcxUNYXg84n09YmOHSPKIVPi1atXNGrUKNq2bRt5e3vTggULuIA5VQGAEhIS5DIcZIGSv94CNTU18zUc9PT0aN68ebRz504aM2YMTZ06lXg8HkVHR2fJZIiMjKSHDx9SRkYGMQxDDg4O2WIRSpcuTQzD0NqfggZzZd8+orAwovXriWxsiJKTiUSi/I0CliX68IF6nT5NkydPJgsLi4J90L+QlpZGQ4YMoWXLllH37t1p+fLlatPySEpKogoVKpBEIqFLly6pJFMiN9q2bUtfvnyhkydPqq0PdVNiDCjJsWPHqFGjRnTnzp0CRTGrkiNHjlCTJk3o9evXVLp0abX3d/ToUWrcuDGdOXOGzpw5QzNmzKAVK1bQuHHj6Nu3bzR16lQaNGhQlqAhANS4cWN6+vQp3b9/X6kbwbNnz6hly5b07t072rJlCzVt2lSVp1UsiI2NpZs3b9L169dp5cqV9PbtW84oEAgExOfzuSdbLS0t8vT0JC8vL85IKFeunHpufhkZlObvT4KDBxU3An6Gz89ctj53juiHmmdcXBzNnDmTwsLCyMjIiGbMmEFdunQpNEMnL6RSabb0zLxeCQkJ2dowMDDI03DQ19en+Ph4ioqKoqdPn3JGwpcvX4goM9DS3d2dooOC6Gnp0sTm9RAycSLRjRtEkycTLVpE9PYtkaYmUcOGRAMGEOVzbRj07EkpHz7QkCFDaMSIESq/n//zzz/Ut29fcnZ2pl27dpGdnZ1K25dx48YN8vX1pREjRtD06dPV0gcR0ciRI2nHjh304sULtfWhbuSev1WpbfwnkJKSAm1tbUyfPr2oh8KxYsUKCASCHCuNqYOGDRuiQoUKiIuLg6GhIQYOHAgg8zoYOHAgGIaBt7d3Fr36Xbt2qaT2+vfv39GiRQswDINZs2YV+3oRBeHChQsgIuzatQvHjh3DjBkzEBgYCCsrK06nX0NDAxKJJMvfXl5eCAoKwpIlS3D+/HnVFOiZPBlgGCBTUaJgLz4fsLJCRmwsVq9eDVNTU4jFYkyYMCFLjYHfkQsXLqBUqVIwNDTE/Pnz8ffff2PmzJkIDQ1Fp06d0KBBA3h4eMDc3Bx8Pj9bHQsNDQ1YWFjA09MTtWrVQt26dVG9enW4u7uDv3lz7hVDZS97+8zaH5qaoFatQJMnZ/5LBKpbN9/jt79+jdGjR0NTUxPGxsZYsmSJyrX/b9++DXt7exgYGODQoUMqbftnpk+fDh6Ph/Pnz6utjxUrVoDP5xfavVcdlBQqKgABAQGoUqVKUQ+DY9SoUbC1tS2Uvu7evQsiwqZNm7BgwQIIBIJshWAuX74MNzc38Hg8DBkyBB8/foS1tbXK6q5LpVKMGzcORIQOHTooXaCluMOyLJydndGxY8ds73369AlHjhzB9OnT0apVqywGglAohI6ODlc0iWEYODk5oX379pg9ezaOHTuGT58+yT+Q27czJ/A8JvgUIowgQikiaBKhEhGO5bE/y+Nhq6EhiAhdunTB27dvVfjJFQ07d+6ERCJBhQoV5DofqVSKz58/48GDBzh9+jS2b9+OpUuXYsKECQgODkZAQACqV6+OsmXLQk9PD3TsWP7GgKwsdIsWWbf7+WVu/+efXI9lIiKw+Me43759i6CgIDAMA0dHR2zfvl2lhvfXr1/RrFkzMAyDyZMny1WJUlEyMjJQrVo12NnZqW1uOnLkCIgIL168UEv7hUGJMVAA1q5dC4ZhEB0dXdRDAQC0b98etWvXLpS+goKCYGlpifj4eFhYWKBHjx457peWloZZs2ZxFdUEAgGeP3+u0rFs374dEokE3t7eKqnnXhyZM2cORCIRV+I2L2JiYnD48GFMnToVLVu2hKWlJWcgiEQi6OvrQygUctusrKzg5+eHCRMm4L///sPr169zvuE3bJivMdCeCAIiDCPCKiJU+fH3uXxWCSJ37FDDp1a4sCyLKVOmgIjQtm1bhYxTlmWRkJCA9+/f4+HDh7h8+TKOHj2KHTt2IDw8HPPnz8fEiRMxePBgMCdP5m8M2Npmfr8LF2bdvnBh5vZRo3I9lh8Rgfm//I7u3LmDpk2bgohQuXJlnDlzRmWfm1QqxZQpU8AwDJo2bSrXNa4oL168gLa2Nrp3767ytgHg8ePHICKcPHlSLe0XBiVVCwtAdHQ0lSpVitauXZurZnthUqVKFXJ2dqZ169aptZ/o6GgqXbo0TZ06lfT19Sk4OJgePnxITk5OuR5z4sQJatiwIQGgtm3b0qJFi1SqKnj79m3y9/en5ORk2rVrl8L528Wdjx8/kpWVFS1evJj69++v8PHR0dF048YNun79Ot24cYOuXbtGHz58IKLMQDgtLS1KTk6mpKQkIsoMVJQFKHp5eVElIyNyzCeN9ioRVSaiuUQ07Me2FCJyJSJTIrqYy3Hg84n56y+iBQsUPq/iQEZGBkVHR1NwcDAdOHCAgoKCyN/fn+Li4iguLo6+f//OvX7++9f//xwo+iva2tqkp6dHurq69HjhQmLziwcZPpzo+vVMjYGf44fevCHq1i0zbqB16xwPZYhoeZkyFJxDbZOIiAgaPnw43bhxg/z8/GjWrFlUrlw5eT6mfDly5Ah17NiRDAwMaNeuXSqvDKtOdcLU1FQSi8W0Zs0a6tmzp0rbLixKAggLiK+vL1lZWdHOnTuLeihkYWFBffr0UThCX1EmTpxI8+fPp5cvX5Kvry9VqFCBtm/fnuv++ClocPz48TRixAjKyMig2bNnU69evVQWIPbp0ydq06YNXbx4kZYtW0a9e/dWSbvFhZYtW9L79+/p+vXrKmnvw4cPdOPGDc5IuHbtGkVHRxMRkUQiIW1tbUpNTaXv37/TBCIaT0R56ceNIKIFRPSViH7+9c8kojFE9IaIrHM7WE+PKDZWuboWSgKAUlJS8pyk85vAv3//zlVGzAk+n096enrcS1dXN9////q3jo5OFv2DCtev080cAhSzsGYN0ebNRPPnZ83YuHmTaOjQTP2BXCqREhGd8fSkmrmk7spKFY8ZM4Zev35NQUFBKss8ePnyJQUGBtLDhw9p1apV1LVr1wK3KQMAtW7dmittrupMCWtra+rWrVuRlFFWBfLO3+rVkPyNkVnHqamphVZQJydSUlLow4cPZGtrq9Z+kpOTacWKFdSjRw86fvw4vXjxIl9DaPfu3XTs2DHav38/NW/enFq0aEHDhw/nhIRWr16tkqcLExMTOn78OA0ePJj69OlDkZGRFBYWpvICM0WF7IkzMjKSPDw8CtxeqVKlqHnz5tS8eXNuW1RUFLd6cP36dc7w8KXMJ8a8uEVEZSmrIUBEJJOXuU15GAPfvxO9eEHk4CDX2FmWpfj4eKUncNn/fy0F/TMSiSTHSdvKyor7//fv32ndunXE5/Np2rRpVKFChSzHyPQ3VImvri7dSUzMuyhR7dqZxsChQ1mNgYMHMzM58njqZojIKw+dAx6PR+3bt6dWrVrRypUraerUqbRp0yYaOnQoDR8+vEAPgnZ2dnThwgUaMGAAdevWjS5fvkxhYWEqubcyDEOrVq0iNzc3CgoKosOHD6v0u7Gzs+NqWfzJlKwM5MKdO3fIw8ODjh07Rg0aNCiycTx58oScnJwoIiKCateurbZ+wsPDqU+fPvTo0SMKDAwka2trOnToUK77JyYmkouLC3l6etK+ffuyvHf69Gnq27cvvXz5kkaNGkVjxoxRmbzz6tWraeDAgVS1alXasWOH2iVQC4P09HSysrKiDh060MKFCwulTwD0/v17Mi1XjoQ51BX4GVciMiOiXzOtHxBReSJaSUR98zj+dP/+dMfJSa7JPKcaBzJ4PJ5ST+C/Po3nZ0Ru2bKFgoKCyNPTk/bs2VNoxbQOfP5Mfvfu5b/jnDlEhw9nGgYeHkS3bxOdOUPUsSNRbqtmLEvufD5FKqDr8P37d5o9ezaFhYWRjo4OTZgwgfr06VOg1FYAFB4eTgMHDiQvLy/auXMnWVlZKd3ez8hSsJcsWUIDBw5USZtERN26daOnT5/SxYu5OcSKNyVuggICgGxsbMjf358WL15cZOM4fvw4NWzYkF68eKG2nF0AVL58eXJycqIePXpQy5Yt6dy5c3n658eMGUNhYWH04MGDHMeVkpJCM2bMoFmzZpGdnR2tWrVKZcbM+fPnKSAggCQSCe3du1clT9NFzfDhw2ndunX0/v37wluJAjKfJvO5BTgQkRMR/WoavvjxXhgRDc7lWJaIBhHRWk1NpSdw2f+1tLTUKgTGsixNmDCBpk+fTl26dKHVq1cXao0SKUDWFy7Qh/T0vN0qGRlEmzZlGgRfvhCZmRH5++caK8AxZQpVSUmhwYMHU0BAgNzFhd69e0cTJkyg9evXk4ODA82YMYNat25doO/i2rVrFBgYSCkpKbRt2zaqU6eO0m39zKBBgyg8PFyl6oSTJk2ilStX0sePH1XSXmFTojOgAvr37w87O7sizXVfvXo1eDwe0tLS1NbH4cOHQUQ4c+YMKlWqhBo1auS5/6NHj6ChoYFJkybl2/b9+/dRrVo1EBF69OiBz58/q2TMr1+/hpeXFyQSCXb8ARHrDx48ABEV7rmwrFy6AeWJUDeH7fd/ZC2szONYKREudeqEe/fuFetc7fj4ePj7+4NhGMyePbvQf/Pp6elYtmwZtDp1yj+jQMEXPyICthcvYte+fahTpw6ICNbW1pgzZ45CEf6qzjyIiYlBvXr1wOPxMGfOHJV85omJiXB2doa3t7fK9BPWr18PIvptU5xLUgtVwKFDh0BEuHfvXpGNYcyYMShdurRa+2jQoAF8fHxw4sQJEBEOHz6c674sy6Jhw4awt7dHUlKSXO1LpVKsWrUKenp6MDExwb///quyH3779u1BRBg/frxacpkLkypVqqBx48aF26mubr7GQH0iuOSw/cQPY2BfPsd3+LGfpqYmKlWqhL59+2LlypW4cuWK3NeQOnn16hXc3d2hra2Nffv2FXr/x48fh6urKxiGQfcePVDh0iUIVGgMMBEROBsby/V3+/Zt9OjRA0KhEBKJBP3798fjx4/lHu/JkydRoUIFEBFatGiBBw8eKH3uGRkZGD16NIgIAQEBKpljbty4AYFAgNGjRxe4LQA4e/YsiAj3799XSXuFTYkxoAKSk5MhkUgwa9asIhtDp06d8n1SLwh37twBEWHz5s2oV68evLy88pyod+7cCSLCgQMHFO4rKioKbdu2BRGhYcOGKtElYFkWM2fOBMMwaNGixW99ja5ZswYMwxSupkLt2vkaA8OIwCfC91+2T/8xyb/J53jnH/vp6urCwsICxsbGYBgGRAQejwdXV1d06dIFCxYsQEREBGJ/mrjUzfnz52FiYgI7OzvcvXu30PoFgCdPnsDvh1hQtWrVcP36dQDA08RE6J09C76KjIHRufzOPn78iEmTJsHU1BREhGbNmuHEiRNyGepSqRRbtmyBnZ0deDweevfujffv3yv9WezZswe6urpwcnJSyaQrUyc8d+5cgdt6+/at0ve84kCJMaAiWrZsiWrVqhVZ/9WqVUOXLl3U1n6PHj1gZWWF8+fP57tMnZCQwAnZFISDBw/CxsYGYrEYs2bNUokL5MCBA9DV1UW5cuXw7NmzArdXFHz//h0SiQTTpk0rvE5HjQIEgjwn88s/JvO5P21LIYIjESrnYwiwYjGePnqEHTt2YOzYsWjevHk2uWVTU1OYmppCIBBw2+3s7BAYGIhp06bh4MGDiIqKUvmpr1u3DhoaGqhZs6Ziio0F5Nu3bxg6dCg0NDRQunRpbN26NdsEfO37d5UYBMGPH+c7uaekpGDdunVwd3cHEcHV1RXh4eFyrdqkpKQgLCwMhoaGEIvFGDdunNLzxOPHj1G+fHloaWlh27ZtSrUhQ6ZOaGtrW+B5SyqVQigUYsmSJQVqp6goMQZURHh4OHg8XqHeLH7G0tIS48ePV0vbHz9+hFAoxOzZs9GyZUs4OTkhIyMj1/1HjRoFTU1NlUhzJiQkYOjQoeDxeHB3d8fly5cL3ObDhw9RtmxZGBgY4NixYwVuryjo1q0b7O3tC83l8XLv3nxXBkCENpSpODicMhUIq/74+0xexwkEQM+eOfb7+fNnnDx5EgsWLEDXrl3h7u7OGQMMw0BfXx8mJibQ1NTkDARTU1M0btwYo0ePxvbt2/Hs2TOlPqeMjAwMHToURIRevXqpXJs/r35XrlwJExMTSCQSTJkyJc8J92FCAryuXQOjoAEgOH0awtOnEfbmjULuOJZlcerUKa42iLGxMcaPHy+XIRYbG8vdH0xMTJSueZCQkMC5/oYMGVKgOJMXL15AR0cH3bp1U7oNGWXKlEFoaGiB2ykKSowBFfHhwwcQETZu3FjofaempoJhGISHh6ul/QkTJkBLS4tbFVi3bl2u+8qCBidPnqzSMdy4cQMVKlQAwzAYOHBgga+x2NhYNG7cGDweDwsWLPjtCh2dOXMGRITTp0+rtZ/z58+jZcuWYBgG1zQ0IM2nSFHyD3eBORFERKhIhCNyGBH4qZhVfqSkpODWrVtYv349Bg8ejNq1a8PAwIAzBsRiMYyMjKClpcVt09HRQc2aNRESEoL169cjMjIyz5Wmb9++oWnTpuDxeFi0aFGhXR+nTp3inry7dOmCd+/eyXVculSKWa9fQ//cOVBEBHj5BApSRAQa3r6NxwUMdnv69CkGDRoELS0taGhooGvXrrh582a+x7158wY9evTgah7s2LFD4c+YZVksWrQIAoEAtWrVwocPH5Q9Daxbtw5EhJ07dyrdBpBZvM3f379AbRQVJcaACqlYsSLatGlT6P0+e/YMRIQTJ06ovO2kpCQYGxtj0KBB6NSpE0qXLp3rTZRlWTRo0AD29vZITk5W+VjS09OxYMECaGlpwdLSEnv27ClQexkZGRg+fDiICN26dVPLmNUFy7JwdHRE165dVd52RkYGdu/ejSpVqoCI4OzsjPDwcKQeOybX6oBCLz4fCAgo8JhZlsXr16+xb98+TJkyBQEBAXBwcOCMAT6fD319fejo6HDbhEIhKlSogN69e2P58uW4dOkSEhMT8fTpU7i4uEBPTw9Hjx5VwSeaP8+ePUOrH1UFq1SpgitXrijVTnJGBjZ++ICAu3dheeFCFiNA88wZVLlxAyOfPcMTFUe8x8bGYv78+bCxsQERoWbNmtizZ0+eK4hA9syDs2fPKtz3uXPnYG5uDgsLC1y4cEGp8bMsi4CAABgaGhYopiE4OBgeHh5KH1+UlBgDKmTKlCnQ1dUttOVEGbLofnX4wFevXg2GYXDq1CnweLw8/WE7duwolACaV69eoVmzZiAi+Pv7F7jS3b///gtNTU1Urly5QDeCwmbGjBkQi8Uq+70lJSVhxYoVKFOmDHdD379/f9Yl9oEDwfJ4qjEEeDzAwABQY6Gv79+/4/z581i6dCl69eqFihUrZnEpaGlpQVdXlwtUZBgGDMNAR0cHw4cPx4kTJ/Dlyxe1jm/EiBEQCoWwsrLCpk2bVLoKEZeejqiUFHxKTUVGIaxupKenY+fOnVyasJ2dHcLCwvK9RguaeRAVFYXq1atDIBBgyZIlSn2Gnz59QqlSpdCwYUOl3W+zZ8+Grq7ub7fSCJQYAyrl5s2bantCz4vw8HAwDKNyI0QqlcLFxQWtWrVC3759YWpqmqvvUhY02KJFC5WOITdYlsX27dthbm4OHR0dLFmyJN+nkLy4du0aLC0tUapUKZXEJRQG7969A4/Hw6pVqwrUzqdPnzBp0iQYGxuDx+OhTZs2uT+ZJibim7Mz0lVhCAgEQCH/VoDMCevBgwfYvHkzRowYgUaNGsHMzIwzEBiGgba2dpZARWtra/j7+2Py5MnYt28f3r59W6AbfkZGBsLDw2FmZgaxWIyJEyciISFBhWdZ9Fy9ehWdOnWCQCCAjo4OBg8enGdmkFQqxebNm5XOPEhLS8PgwYNBROjUqZNSn6esFPHixYsVPhbIrKBKRGo1INVFiTGgQliWhaWlJQYPHlyo/Y4fPx6WlpYqb1emn7Bnzx4IhULMnDkz131VGTSoCLGxsejbty+3zBgZGal0Wx8+fECVKlUgEomwYcMGFY5SfTRt2hSVK1dW6tinT5+iX79+EIvFEIvFGDhwoFyrS0umTcMFHg9sPvEDub4EAkAkAvLQqShM0tLSMGDAAO6pdMaMGejQoQNcXFzA4/E4A0FLSytL6WdDQ0M0aNAAI0eOxNatW/H48WO5nijPnDkDLy8vEBE6duz4x5bdlvH+/XuMGTMGhoaG4PF4aNWqFc6cOZOrMfVz5oFEIlE482DLli2QSCRwc3PD06dPFR7vwIEDoampqVTq4rVr10BEuHbtmsLHFjUlxoCK6du3LxwcHAp1mahLly5qSWuUiQwNGTIEenp6+PbtW477qStoUBHOnz+PcuXKgc/nY+TIkUqrgKWkpKBnz54gIoSGhhZrNTzgf3oOigheXbp0CQEBAWAYBiYmJpgyZYpCio9du3ZFVR8fYNKkTJ9/PimHWVYDiIBKlYBHj5Q5XZXz5csX1KtXDwKBACtXrsz2flJSEq5evYo1a9ZgwIABqFatGrS1tTmDQCQSZXE7SCQSVK1aFQMHDsTff/+Nmzdvcit2L168QOvWrUFEqFixIi5evFjYp1ukJCYmYtWqVXBxcQERwdvbGxs3bsx1RfPXzIOlS5fKnV587949lClTBnp6egoLRCUmJsLFxQVeXl4Kr7Z+/vwZRITt27crdFxxoMQYUDEHDhwAERVIbUtRatSogU6dOqm0TZnI0KpVq6ClpYWxY8fmuJ+6gwYVITU1FdOmTYNIJIKdnZ3SwV8sy2LJkiXg8/lo0KCBQlKshU1qaiqMjY0xdOjQPPeTSqX477//UL16dRARypYti1WrViml7Ofp6YlevXpl/nHnDtClC6R8PkAE9lfDgM//nxHg6gqEhwMFcOeokocPH8LR0RGGhoaIiIiQ+zipVIpnz55h165dGD9+PPz8/LJoIvD5/CwGAp/Ph4mJCXg8HvT09AqUY/8nwLIsjh49iiZNmoCIYG5ujilTpiAmJibH/ZXNPPj27Rv8/f1BRBg7dqxCbkRl1QlZloWOjg5mz56t0HHFgRJjQMUkJSVBLBZjzpw5hdZn6dKlMWbMGJW2KRMZGjduHMRica4/1MIKGlSEx48fc9rqnTp1QrSSAWonT56EkZERHB0di7XE6ODBg2FiYpLjU1NycjJWr14NJycnyBTs/vvvP6UDpNLS0iAUCrP5VAe0a4eRVlZAaChQrx7g4wNUqQJ06gQsWABcvZpZ46CYcPjwYejp6alUfOrLly+IiIhAWFgYunXrBjc3N87NIDMKZIGKsuC6tm3bYvbs2Th27FiRaZQUJQ8ePEBwcDDEYjFEIhF69uyZq8JjZGQkZ0DIm3nAsixmzZoFHo+Hhg0bKrQCNmPGDDAMo3CGg4eHB4KDgxU6pjhQYgyoAT8/P7VKA/9MWloaeDweVq9erbI2P3z4AKFQiClTpsDAwAAhISE57hcfH1+oQYOKwLIs1q1bB0NDQxgaGmLt2rVKuW5evHgBNzc3aGtrY+/evWoYacGRreL8nGr5+fNnTJ06FaampmAYBgEBASpZlr537x6IKEvxGalUClNTU4wYMaLA7asblmURFhYGHo+Hpk2bqu1ede7cOS46vlGjRpg/fz5CQ0NRu3Zt6OnpcQaBQCAAn8/n/jY1NUWzZs0wYcIE/Pfff3j9+vVvGZmuKJ8/f8bMmTNhaWkJIkL9+vVx4MCBHI3WkydPwtvbW6HMgxMnTsDY2Bg2NjZy+/MzMjJQvXp12NjYKHSd+Pv7o1GjRnLvX1woMQbUgKyCYGFElL548QJEpFIlvfHjx0NLSwtTpkyBhoZGrgFORRU0qAgxMTHo0qULiAi1a9dWqNCKjPj4eLRq1QoMw2DatGnF8uZcsWJF+Pn54fnz5xg4cCAkEgk0NTXRr18/PHnyRGX9bN68GUSUxXVy9erVbAZCcSQ1NRW9evUCEWHYsGEFyj7JjdevX6Ndu3YgIlSoUCFHzXuWZfH27Vvs378fU6dORWBgIJefLwtW/NlAkAkmDRs2DJs2bcKDBw/UMvbiQFpaGjZv3oyKFSty7qxly5ZlywyQZR7Y2tqCx+OhT58++Sogvn79GhUrVoRIJJJboE0ZdcLQ0FCULVtW7v2LCyXGgBp4//49iAj//vuv2vuKiIgAESk1yeVEUlISjIyM0L9/f5ibm6NnLjKxDx8+hIaGBqZMmaKSftXNsWPHYG9vD6FQiMmTJyMlJUWh46VSKSZPngwiQps2bYpdGtjIkSPBMAx4PB6MjY0xadKkXF07BWHUqFGwtrbOsm3SpEnQ09NTa/nsghITE4MaNWpAKBTmqaCpLAkJCRg/fjw0NTVhbm6OtWvXKuyKiYuLw4ULF7B8+XL07t0bnp6eWbIXfjYQhEIhPD090a9fP6xZswbXr19X+JouzrAsi4sXL6JNmzbg8XjQ19fHiBEjsj2YpKSkYMGCBVzmwfjx4xEXF5druykpKVz2Ua9eveSKc5KVJpa3bPjixYshFAp/u+qoJcaAmqhQoQLat2+v9n5kMpqqCt5btWoVGIbB1KlTwePxcnyqZFkW9evXh4ODQ5EHDSpCYmIiRo0aBYFAABcXF6Uqle3evRtaWlrw8PDAy5cvVT9IBZBKpdi/fz9q1qzJPVH6+/urtZ56kyZN0KxZsyzbKlWqVCTKm/Jy584d2NrawtTUFOfPn1dp21KpFBs3boSFhQVEIhFGjx6d52SkKBkZGXj48CG2bt2KUaNGoV69ejAyMuKMgp9jEng8HhwdHdGpUycsXLgQZ8+e/SPuxa9evcLw4cOhp6cHPp+Pdu3a4dKlS1n2iY2NxciRI+XOPFi7di1EIhEqVKiAV69e5dk/y7IIDAyUW51w//79IKICi6EVNiXGgJqYOHFioTwtTZw4EaVKlVJJWzKRoZYtW8LW1hbt2rXLcT+ZsMbBgwdV0m9hc+fOHfj6+oKI0KdPH4WzBe7cuQM7OzsYGxurvTZATqSkpCA8PJxL0fL19cWuXbvQoUMHlC1bVq1uDEtLyywR1tHR0WAYBuvXr1dbnwVh79690NbWhoeHR743fUW5dOkSKlWqBCJCYGBgobrLoqOjcezYMcyZMwdt27aFvb19FsPg50DFUqVKwc/PDzNmzMDhw4fx8ePHQhunKomPj8fSpUs5hczKlStjy5YtWe6xb968Qffu3cEwDMqUKZNn5sGNGzdga2sLQ0PDfDOPPn/+LLc64f3790FESkkrFyUlxoCauH79OogIp06dUms/3bt3h6+vr0rakokMjRs3DkSE27dvZ9tHFjTYsmVLlfRZVGRkZGDZsmXQ0dGBmZlZjuVh8+Lz58+oW7cuBAIBli9frsaR/o+vX79ixowZMDc3B8MwaNmyZZYn3ZMnT4KIVP70K0OWQ71lyxZu24YNG0BExW6CkUWRMwyDVq1aIT4+XmVtv3nzBh07dgQRwdPTs0gMwpxITk7G9evXER4ejv79+8Pb2xtisThHA0FfXx81a9bEmDFjsGvXLrx48aJYxsLkhGxFrF69eiAiWFlZYdasWVlitH7OPPD19c11Yv7y5QsaN27MxQPlNdEfPXoU8qgTJiYmgoh+G+EyGSXGgJpgWRYWFhYYMmSIWvupXbu2ytwR9evXh4+PD8qVK5dtKViGbCmuqJfIVcW7d+8QEBAAIkLTpk0VenpMT09HSEgIiAh9+/ZVW02KV69eISQkBFpaWhCJROjTpw8e5SDaI5VKYWtri6CgILWMQxaf8nOaZdu2beHj46OW/pQlOTkZnTt35gxbVfluExMTMWnSJIjFYpiammLNmjXFPpCPZVm8ePECu3fvxvjx41G/fn2YmJhwRsHPL7FYDE9PT/Tv3x///PMP7t27V+xFt+7cuYOgoCCIRCJIJBL069cPDx8+5N4/ceIEl3nQsmXLHDMPMjIyMHHiRBAR/Pz8EBsbm2t/gwYNkkud0MzMDJMmTVL6vIqCEmNAjfTu3RtlypRRax+2trYYNWpUgduJjIwEUWZtcCLKMQ3t4cOHEAgEv03QoCL8999/sLS0hEQiwfz58xW6Ca5duxZCoRDVq1dXWtMgJ27cuIH27duDz+fD0NAQ48aNy/cJfPLkydDS0lLpk7CMRYsWQSQScZ9Neno69PT0MHHiRJX3pSwfPnxA5cqVoampmWUFoyCwLItNmzbBysoKQqEQI0aM+O3vcV+/fsXp06excOFCtGvXDg4ODlkCFH9OfSxTpgw6duyIFStW4MqVK0oJVamb6OhoTJ48masx0aRJExw7dgwsy8qdeXDgwAHo6+vD0dERd+7cybGfpKQkuLi4wNPTM0/j39fXVy0VRdVJiTGgRvbt26fSSP9fSU9Ph0AgwIoVKwrcVvfu3WFlZYUKFSqgdu3a2d7/XYMGFSEuLg5//fUXGIaBt7c3rl+/LvexFy9ehJmZGaytrXHjxg2lx8CyLA4dOoS6detywjRLliyRO3vh9evXYBgGa9euVXoMudGzZ094e3tzf589exZEpHS5XVVz48YNWFlZoVSpUrh69apK2rxy5QpXytnf318tlUGLC2lpabhz5w42btyIgQMHwtvbG1paWtkMBIZhYGlpiWbNmmHOnDmIiIjI82m6MElJScGGDRvg6ekJIkL58uWxZs0aJCUlyZV58OzZM3h4eEAsFueaDXbjxg1oaGjk+RDWoUOHQtOaURUlxoAaSUxMhKamJubNm6eW9l+/fg0iwuECFnyJioqChoYGevfunatmgSxo8NChQwXq63fgypUr8PDwAI/Hw+DBg+V+yn779i18fHwgFosVfipNTU3FunXr4OrqCqJM7frt27crtQzdsGFDtdSqqFixIrp37879PXLkSJiYmBSLFKrt27dDLBbDx8cH7969K3B779694/Qp3NzccPLkSRWM8veDZVm8e/cOBw4cwKRJk1CvXr0sFR5/fhkaGqJ69eoYNWoUDh48mG/ev7rHffr0afj7+4NhGBgZGWHs2LGIioriMg9EIlGOmQeJiYncdz9o0KAcVwBmzpwJhmFy1dYYM2YMrKys1HZ+6qDEGFAzzZo1y/FJWxWcOXMGRJTFR6YM48aNg7a2NqpXrw4fH59sgUTx8fGwtLT87YMGFSEtLQ2zZ8+GWCxG6dKlsX//frmOS0pK4vzVo0aNyncyj42NxezZs2FhYQEiQvPmzfOs6CYPW7duBRHlGFegLBkZGRCLxViwYAG3zc3NrciXQqVSKSZNmgQiQvv27Qu8hJ2UlISpU6dCIpHA2NgYK1euLPZxAUVBfHw8Ll68iKVLl6JNmzZwdHTMUvJZ9tLS0oKnpyf69u2LrVu34unTp4VuPD579gwhISHQ1taGhoYGOnfujOvXr+P169fo1q0bl3mwc+dO7nfHsiyWL18ODQ0NVK1aNVtKYUZGBmrUqAEbG5vsBdw+f8bh0FCMJEL60KHAyJHAvHnAqVNALsXeigMlxoCaWbFiBfh8vlqK3WzcuBFEVKC8cpnIUJs2bUBE2L17d7Z9/rSgQUV48eIFGjVqxIkNyfO0w7Is5s2bBx6Ph2bNmuVY7fHNmzcYMmQIdHR0IBQK0bNnT5UVt0pOToaBgQFGjhypkvaAzMqURIQTJ04AyBw/EWHr1q0q60NREhMTueu2oMqQLMti27ZtsLGxgUAgwJAhQ4rN0vfvQkZGBh49eoStW7dy2Qw6OjrZDAQNDQ04OjqiXbt2WLVqFSIjIwtFsOrbt29YsGABbG1tQUSoUaMGdu3ahZs3b6Jx48Zc5sHP+iOXLl2CpaUlzMzMsmWNvHz5Ejo6OpkGsVQK7N8PNGoE/CjtnU4/CndpaPyvWBePB/j7AydOFKtaHUCJMaB23r59my0dS1VMmTIFpqamBWpDJjJUt25duLi4ZLPaHzx4AIFAgKlTpxaon98ZlmWxefNmmJiYQE9PDytWrJDr6ebIkSPQ09ODs7MzFzdy69YtdOrUCQKB0h3HOQAAKyRJREFUAPr6+hgzZoxallMHDhwIc3NzlUWDy9xEMlXDlStXqs3IlYe3b9/C29sbEokkRwNWEa5fv85Vc/Tz81NbjM//V2JiYnD8+HFMnDgRdevWhZmZWZY0R5lgkoWFBRo1aoTp06fj4sWLahPPysjIwO7du1GjRg0QEWxtbbFgwQL8999/OWYeREdHo06dOuDz+Zg/f34Wo3PDhg1wIMKnsmX/V6WT8inlLavs2bgxoAKXlqooMQYKAS8vL3Ts2FHl7QYFBaFSpUpKHy+VSuHs7MwFq23cuDHL+yzLol69en900KAifPnyBT179gQRoWrVqrh3716+xzx+/BhOTk6QSCTw8vICEcHGxgaLFi1SS8S/jJs3b4KI5HZv5Me4ceOyiFu1aNGiyAKkLl++DHNzc1hbW+PWrVtKt/PhwweuNG758uVVWt+jhLxJTk7GjRs3sHTpUgQGBsLBwQEaGho5xiFUqVIFQ4cOxZEjR1Re7+X69evo3LkzNDQ0oKOjg7/++otbPfg58yA9PR0jRowAEaFt27bcb5fduhVpPB7S8jMAcjMKtLUBJUutq5oSY6AQGD9+PAwMDFSes1uvXr0CycAePHgQRIR69erB1tY221Ldtm3b/t8EDSrC6dOn4eTkBA0NDYwdOzZXQyktLQ0bN25E+fLluZtbx44dC03D39PTE61atVJJWy1atOAqsaWkpEAikWDmzJkqaVsR/vnnH4hEIlStWlVpoaPk5GTMmDED2traMDIywrJly4p9Pv3/B1iWxcuXL7F9+3b07dsXnp6e0NXVzTEOwc3NDT169MCWLVvw9u3bAgsmvX//HuPGjYORkREYhoGfnx/69+8PfX19SCQSTJgwAXFxcdi5cye0tbXh4uKC93PnAgwD9odbQKkXj5dpFBQwCFwVlBgDhYC6qro5ODhg+PDhSh9fr149uLu7g8fjZVPRkwUN+vv7F3SYfyQpKSmYOHEi5//8Odr8+/fvmDt3LqysrLic5+PHj2PUqFEgInTu3LlQcrWXLFkCgUCgEu0DW1tb7lqTKbHlloutDqRSKff5devWTamiPCzLYufOnbCzs4NAIEBISEiRuTlKkJ/Y2FicOnUKY8eORe3atWFmZpZFepkos3CTvb09WrVqhcWLF+PRo0dKBSomJSVhzZo1nAHv5uaGpk2bQigUwtTUFMuWLcOdO3cQYGeXGROgrBHwq0EgFgPPn6vh05OfEmOgEJBKpTA3N8ewYcNU2qaGhgaWLVum1PG3b98GEXE+vF+fbkeMGAGxWPz/MmhQER48eMD5Hlu3bo2BAwdCV1cXGhoa6N69O+7evZtl/61bt3IpcOouZPLlyxcIhcICp7Z++/YNRIR//vkHABASEgIrK6tCk6+Ni4tDixYtwDAM5s6dq1S/t27dQq1atSBTmixoBk4JRYtME2HhwoXw9/fnKpL+GodQqlQp1K1bFxMmTMClS5fkVgllWRbHjh1D06ZNQUQwMTHhtAvKOToi1tISGbmsCNwjQmsi2BFBTAQjItQgwr78XAY1amQGIhYRJcZAIdGzZ084OzurrL13796BiHDgwAGlju/evTssLCygoaGBOXPmZHmvJGhQMW7fvs0J0zAMg2bNmuU50d+8eRPW1tYwMzPDhQsX1Dq2du3aoVy5cgWauM+dOwciQmRkJACgTJky6NOnj6qGmCcvX76Em5sbdHR0lLrWP378iF69eoFhGDg7OxdYk6OE4gvLsnj//j22bNmCoKAguLu755jNYGBggIoVK2LAgAHYv39/vrE7jx49Qr9+/SCRSCAUCjFWTw/SPCb2g0RoRIRJRFhNhIU/jAEiwqr8Vgm2by+kTys7JcZAIbFnzx4QEZ4+faqS9s6fPw8ikiuI7VdkIkM1atSAvr5+FhUuWdCgo6NjSdBgHrAsixMnTnApSdbW1pg4cSICAwNBRKhfv36eanXR0dGoUaMGhEIh/v77b7WNU7akf/nyZaXbWLZsGQQCAVJTU/HkyRMQEfbu3avCUebM2bNnYWxsDHt7e4Wv85SUFMyZMwc6OjowMDDAokWLCi1Wo4TiRUJCAk6dOoXhw4ejRo0aMDU1zeZmkEgkcHFxQceOHfH333/nGI/y5csXzJ41C88FgjyNgZxeGUTwIIJTXvvx+UD16kXwCWVSYgwUEgkJCRCJRAgLC1NJe//++y+ISKmI9HHjxkFLS4sLjPkZWdBgyRNUzqSlpWHTpk1cZoCHhwf+/fffLBPNoUOHYGNjA01NTcyYMSPXSSg1NRV9+/aFTOlMHZNVRkYGrK2tC/Qk37dvX7i5uQEAFi5cCKFQqNZMCAAIDw+HhoYGatWqhU+fPsl9HMuy2LNnD6e1P3DgQHz+/FmNIy3hd0QqleLevXuYM2cOmjdvDltb22xuBqFQCBsbGzRt2hQzZ87EgwcPwF64oHRsQHMimMmzbxFJXpcYA4VIkyZNULduXZW0NX36dBgbGyt8XGJiIoyMjFCpUiVoaWlluVGWBA3mTlxcHMLCwlC6dGkQERo2bIjjx4/nuvyekJCAYcOGgc/nw83NDZcuXcq17RUrVkAgEKBu3bpqmbjGjx8PHR0dpfO2q1Spgs6dOwMAGjRogAYNGqhyeFlIT09HaGgoiAh9+vRRqBJkZGQklybbsGFDpVbNSvj/TXR0NNavX48uXbqgfPny0NbWzmIgDGEYZMg5+ScQ4RMRnhFhARH4ROgoz7G51ERQNyXGQCEiW27NSZFOUXr37o0KFSoofNzKlSvBMAx0dHSylVcuCRrMzvv37zFq1Cjo6+tDIBCgS5cunO9cHm7evIkKFSqAYRj0798/1+/+zJkzMDY2hp2dncqj9J8/f46cdCTkQSqVQltbG3PmzEF8fDyEQiEWLlyo0vHJ+PbtGxo3bgw+n48lS5bIHecQExODvn37gsfjoWzZsjhw4EChBTeW8OeTnJyMI0eOICQkBEeMjJAupzHQ9ycjgkeZQYVf8ztOQwMYPLhIzrPEGChEZIWFtm3bVuC2GjRogMDAQIWOkUqlcHJygqurK4RCYZaCLrKgwWnTphV4bH8C9+/fR48ePTgxkmHDhuHNmzdKtZWRkYGFCxdCS0sLFhYW2LVrV46T1atXr+Dh4QEtLa0Cq+r9St26dZWqkSEzJI4cOYK9e/eCiPDkyROVjg0Anjx5AmdnZ+jr68st/pOamor58+dDT08Penp6WLBggUIrCSWUoDA1asjtFnhIhONE2ECEZkRoRYSP+R3H4wHt2hXJqZUYA4WMu7s7t+RaEMqWLYuhQ4cqdMyBAwcgi6b92YfMsizq1q0LR0dHpfK3/xRYlkVERASXTmRpaYm5c+eqZCUHyDQG/fz8QERo0aJFjsZFQkIC2rZtCyLCpEmTVFbURRZjomgJ3t27d4OIEBUVhT59+sDR0VEl4/mZEydOwMDAAGXLlpVLCphlWezbtw9lypQBj8dDv379FIorKKEEZWBZFsne3krHDDQgQkXKR5uAYYDWrYvk/EqMgUJm7NixMDQ0LFAlNKlUCpFIhMWLFyt0XL169WBjYwMej5dlUvj/HjSYnp6OrVu3wsfHBzKhkQ0bNqjlKVMmfFOqVCloa2tj0aJF2a4FlmUxffp0MAyDVq1aqSRYLykpCXp6ehg7dqxCx02aNAnGxsaQSqWwsrJCSEhIgcfyM8uWLQOfz0fDhg3lKgx07949NGjQADLlzMIUPirhzyYhIQHnzp3D4sWLERwcjAYNGsDFxQUmJiYQiUQgytQKUDSTQPZa9cNl8Civ/QQCICioSM6/xBgoZC5dugQiylIZS1GioqIyL8x9++Q+RiYyZGxsnKVOQlxcHCwsLFQmW/s7ER8fj0WLFnFVzOrXr48jR44Uir/527dv6NevHxiGQcWKFXH79u1s++zbtw86OjpwdXXFcxWokwUHB8PS0lIhQzQgIAB169bFnTt3QEQ4qiId9bS0NPTr1w9EhJCQkHzlgD99+oT+/fuDz+fD0dERe/fuLYkLKEFupFIpnj9/ju3bt2PcuHFo06YNKlWqhNKlS0NHRydbqqFMM0QsFsPc3Bzu7u5o1qwZjlaqBKmsAqGCr4U/2r2S38rAokVF8hmVGAOFjFQqhampaYHKy8oMCkWeirp16wZDQ8Nsxw0fPhxisRivXr1Sejy/Gx8+fMDYsWNhYGAAPp+Pjh074ubNm0UylgsXLqB8+fLg8/kYPnx4toj/+/fvw9HREYaGhlkkj5VBJoutyAqQo6MjQkNDMXPmTEgkEpW4kb58+YK6detCIBBg9erVee6blpaGhQsXQl9fH7q6upg7d+7/a1dWCTnz/ft3nD17FosWLULfvn25p3pjY+NsKYOyl0AggJ6eHuzt7VG9enV06dIF06dPx4EDB/Dx48ecjc09e/Kd9KNz2JZGBG/KVCSMz89wULMQWW6UGANFQI8ePVCuXDmlj9+yZYtCn3NUVBQEAgFMTEzQokULbvv9+/f/XwUNPnz4EL169YJQKIS2tjZCQ0Px+vXroh4WUlNTMX36dIhEItjZ2eHIkSNZ3v/69SsaNmwIPp+PxYsXK/1EzLIsXF1d5S5uFR8fD4ZhsG7dOtSoUSPLtaMsDx48gIODA4yMjLLVh/+VgwcPwsnJCQzDoE+fPiqpsVDC70daWhqePHmCrVu3YuzYsWjdujUqVqwIa2traGtry/VU37x5cwwePBhr1qzBzZs3lTco4+MBLa08J3N/ItSlTAXCNUSYSgTnH+Oan58hUKoUUERFs0qMgSJg165dICKll35nzpwJAwMDufcfO3YsNDU1QURcvvv/l6BBlmVx9uxZLnCvVKlSmDVrllz+6cLmyZMnXJ58hw4dsqigpaenY+jQoSAiBAUFKf2dLViwABoaGnIF3F2+fBlEhIiICPD5fKxcuVKpPmUcOnQIurq6KF++PF68eJHrfg8ePOCUHWvXrp2jC6WEPwOWZfHp0yecOXMGCxcuRJ8+fVC/fn04OzvDyMhIqaf6qKgo9bqQBg3K9O3nMqFvIUJ9yhQYEhDB4Mffe/MzBHg8oAgfzEqMgSIgLi4OQqEQi5T0DQUHB8PLy0uufRMTE2FgYABTU9Msgkdbt25VeMn4dyIjIwM7duxApUqVQEQoX7481q1bV+wNH5ZlsWHDBhgZGcHAwADh4eFZbmwbNmyASCRClSpV8OHDB4Xbj4mJgYaGhlzX3urVq8Hj8bBx40YQkdKplSzLYv78+eDxeGjevHmu94cvX77gr7/+Ap/Ph52dXa4pmCX8PiQnJ+Phw4fYsmULRo8ejcDAQPj4+MDKygpaWlpgGCbHyV5TUzPbU314eDhu3rxZKBU/8+T168wqgwrGDOT5YhjA0BAoQrXMEmOgiGjYsCHq16+v1LGNGzeWWyVQJjJERDhx4gSAPztoMDExEUuXLoW9vT33ZHnw4MHfblL59OkTunbtCiJCzZo1s1TZu3LlCiwsLGBpaYmrV68q3HZgYCDc3d3z/UwGDBgAFxcXdO3alZMjVpSUlBT06NEDRISRI0fmGLyYnp6OJUuWwNDQENra2pg1a1ZJXYzfAKlUig8fPiAiIgILFixA7969UbduXTg5OcHQ0BAaGho5TvR8Pj/Xp/p3796pLJ1WraxcqVpjgAhQsbaIopQYA0XEkiVLoKGhodRn5ezsjMFyqFTJRIaMjY1RqVIl7ub/JwYNRkdHY8KECTAyMgKPx0O7du1w7dq1oh5WgTlx4gQcHR0hFAoxadIkbmUjKioKvr6+EIlEXGlheTl48CCICNevX89zvxo1aqBt27YwMTFRKuA1Ojoa1apVg1AozFX98OjRoyhXrhwYhkFQUJBSqx0lqIf4+HjcvXsXmzZtwqhRoxAQEIAKFSrA0tISEokkz6d6MzMzLgI/JCQE4eHhuHHjRpaiaL81LAu0bZu5tK8KQ2DAgKI+oxJjoKh4+fIliAg7duxQ6DiWZSEWi+WShJWJDP1cZU4WNDh9+nSlxl3cePz4Mfr27QtNTU1IJBL89ddfefqjf0eSkpIwZswYCAQCODs74+zZswAyl2C7d+8OIsKwYcPkThlMT0+HhYUF+vfvn+s+LMtCT08PwcHBICKuT3mJjIxE6dKlYWZmhosXL2Z7/9GjR2jevDmICDVq1MCNGzcUar+EgpGeno7Xr1/jxIkTWLBgAXr27Ik6deqgTJkyMDAwgEAgyHGi5/F40NXVhZ2dXZan+oMHD+LVq1f5poj+UaSmAoGBBTcEevcGisFqSIkxUIS4urqiW7duCh0THR0NIsKePXvy3bdu3brQ09ODq6srpFIpWJblfvDF3XeeHxcuXIC/vz8YhoGZmRmmT5+OL1++FPWw1Mrdu3dRpUoVEBF69eqFr1+/gmVZLFy4EHw+H40bN8bXr1/lamv06NHQ19fP1f8qk87u0KED9PT0FLrJ79mzB1paWvD09MyWrREbG4vQ0FAIBALY2Nhg+/btv50Lp7jDsiy+fPmCW7du4d9//8XIkSPh7+8PLy8vWFhYQCwW5zjRExFEIhHMzMzg5uaGZs2acb7669evc9dbCT+RkQHMnw8IhXkGFWZ7CQSZWQnh4ZmrDMWAEmOgCBk9ejSMjY0VEoG5cuUKiAi3bt3Kc79bt25xP/BNmzYB+P2DBjMyMrB7925uQnR2dsaaNWv+X/mXpVIpli9fDl1dXZiammLLli1gWRbHjx+HgYEBypQpkyW+IDeePHkCIsLmzZtzfH///v0gIri7u6Nt27ZyjU2mnEhECAwMREJCAvdeeno6VqxYAWNjY2hpaWH69OlFHwj2m5KSkoJnz57h2LFjmDt3LoKCglCrVi04OjpCX18ffD4/16d6HR0d2NnZoVq1aujcuTPnq3/27Nlv/4BQpDx+DHTokDnJM0zOhoHsPZEoU2WwGKQ1/0yJMVCEXLhwAUSU4zJqbsikg/NLjevatSskEgns7e2Rnp7OBQ0GBAQUcNSFT1JSElasWIEyZcpwAXX79u37PQKN1MT79+8RGBgIIkLjxo3x4sULPHv2DOXLl4euri7279+fbxs1atTIDGJlWeDNG2DfPmDDBmDjRmzu3h22P8q3btiwId+2kpKS0LFjRxARJkyYkOW7OXHiBFxdXUFE6NatG96/f1+gc/+TkUql+PjxI65evYoNGzZg+PDhaNmyJTw9PWFubs6lCOf0EgqFMDU1hauraxZf/ZUrVxAdHV3yVF8YREcDy5YBPXoA5csD5uaZ2gHu7pnugDVrADlX7wqbEmOgCMnIyICxsTFGjx4t9zFz5syBrq5unvvIRIYYhsGqVasAAMOGDYNYLC4WIjvy8unTJ04bn8fjoXXr1rh8+XJRD6tYsW/fPlhbW0MsFmPu3Ln4+vUrWrZsCYZhMGPGjDwngN0zZyKMCBkGBrkuZ74iQvzIkUBUVK7tREVFoVKlStDU1MTWrVu57U+fPkWLFi1ARKhatapSmQ9/GvHx8Xjw4AEOHjyIOXPmoHv37qhZsybs7e2hp6eXo4COTERHW1sbtra2qFq1Kjp37oxp06Zh3759ePToUTblyhJKUJQSY6CI6dq1K1xdXeXev3///nB3d89zn7Fjx0IgEMDc3BwpKSm/XdDg06dP0b9/f4jFYojFYgwYMEDhanv/n4iLi0NISAh4PB48PT1x+fJlTJgwAUSEdu3aZZ8ovn4FunYFKFMmNS/fJks/xFAEAmDcuMygqZ+4fv06LC0tYWFhwWVvfPv2DcOGDYOGhgasra05V8afTnp6Ot68eYMLFy5g3bp1GDp0KPz8/ODu7g4zM7NcBXSICBoaGjA2NoarqyuaNGmCkJAQrFmzBhcuXMD79+8LVNishBLkocQYKGJ27NgBIsLLly/l2r9p06Z5ysImJiZyTxjz58//rYIGL1++jMDAQDAMAxMTE0yZMgWfi1CE43fj2rVr8PT0BI/HQ0hICP755x9IJBJ4eXn9b0Xo3DnA1BTg85UTRnFxAX4YZtu2bYNYLEbFihW5CWv16tUwMTGBRCLB5MmT/5gnVpZlERsbi8jISOzbtw8zZ85E165dUb16ddjZ2UFHRyfXVDsigpaWFmxsbFClShV06tQJU6dOxd69e3H37t2S+2UJxYISY6CI+f79OzQ0NLBkyRK59i9fvjwGDRqU6/srVqwAEUFfXx/x8fFcHYNf9e6LC1KpFHv37kX16tVBRChbtixWrVpVElymJOnp6Zg7dy4kEgmsra25qowmJiaIDAvLjHouSG40nw/W2BiLBgwAEaFjx45ISkpCREQEPDw8QETo3Lkz3r59W9QfhUKkpqbi+fPniIiIQHh4OEJDQ9GsWTO4urrCxMQk11Q7mYiOsbExypUrh8aNG+Ovv/7CqlWrcPbsWbx69QppaWlFfXollJAv8s7fDABQPsTFxZGenh59//6ddHV189u9hB80aNCA+Hw+HTlyJM/9AJCOjg5NmTKFhgwZku19lmWpTJky9OrVK5o4cSKFhoaSs7Mz+fr60q5du9Q1fKVISUmhf/75h+bPn0+PHz+matWq0bBhw6hFixbE4/GKeni/PS9fvqT+/fvTkSNHqHnz5iR+947W375NmgxDvPx/ynkiZRh6D9COCRPIv2tXGjFiBO3evZsqV65MCxcuJF9fXxWdhWoAQJ8+faI3b97Q69ev6fHjx/Tw4UP6v/buPijqel/g+HsfREBwQQER2F1gQZ4UIjMtT0515urYQOaxY2UPVnbvqXwoU8/kTE1zPac7FShoTunxNtnJUhvPmSm1ZPI0PXfOrUxEBDF52AVEFAVWngT2d//4xR7RXUDYhXQ/rxmHmd3f78d3d4rf5/f9fj6f78mTJ6mtreXs2bO0tLS4PT8wMJCwsDCioqKIi4sjNTWV1NRU4uPjMZlMhIaGotFohvETCeF5A71/64dxTD4nOzubNWvWYLfbCQ4OdntcQ0MDLS0txMbGunz/448/pry8nMDAQJYtW8a6des4f/48eXl5Xhr51WtoaODNN9/k9ddf58yZM8yfP5+3336bW265ZaSHdl2Ji4vj448/Zvfu3axcsYIPz53DD1wGAp8Dd7i5znfA5bd2naIQo9Hwm48+IvWVVwgPD2fHjh088MADIxLItbS0YLPZsNlsVFRUUFxcTFlZGVarldOnT9PY2Eh3d7fLc7VaLSEhIZhMJkwmE4mJiUyePJnExERMJhNGo5HRo0cP8ycS4tdLggEvysrK4plnnuHgwYPMnz/f7XFVVVUAmM1ml++/+uqr6HQ6li5dyqlTp8jPz2fdunWYTCavjPtqVFRUkJeXx1tvvYXD4eDRRx/lueeeIzExcaSHdt3SaDTcf//9ZJ05Q9CKFf0evwKYdtlrCW6O1SoK0w8f5vUlS3hw40bGjBkz1OG61N3dTV1dHVarFavVSllZGSUlJVRUVFBTU8PZs2dpa2tze35AQAATJ04kKioKi8VCcnIyqampmM1mTCYTERER8lQvxFWQYMCL4uPjSU1NZe/evX0GA5WVlQAuZwYOHz7M119/zahRo3j22Wd58MEHiYuLc7mcMJx++OEHcnJy2LNnD6GhoaxZs4ann36aiIiIER2Xz1AUgrZuBY1GXfXvw23AvVdzaZ2O/2pvhyEEAk1NTc4bfWVlJSUlJZw4ccL5VN/U1ITD4XB5rkajwWAwOG/siYmJpKWlER8fj9lsxmg0ei1IEcJXSTDgZVlZWWzfvh2Hw+F2qrWyspKgoCDGjRt3xXs5OTlotVoef/xxvvzySz7//HMOHDgwIlOcDoeDTz75hJycHL744gssFgubN29m8eLFBAYGDvt4fNr330Nx8YAPtwMBDOx/eE13N+zeDa+/DqGhV7x/8eJFampqnDf78vJySkpKKC8vdz7VX7x40e31R48eTWRkJNHR0cTHx5OSkkJSUhImkwmz2UxkZCQ6nW7An00IMXQSDHhZdnY2r732Gt9//z3Tp093eUxVVRWxsbFXTGvW1taya9cuAJYuXcqcOXNYsGABc+bM8fq4L9XR0cF7773H+vXrOXbsGNOnT2fPnj3cc8898kd7pHzxBWi14Obp+lKPARcAHeosQQ5wU38ndXXxbV4e348fT2lpaa+n+ubm5j5PNRgMxMbGYjabSUxMJCUlhbi4OOf6vcFgGNBHFEIMHwkGvGzGjBmMGzeOvXv3ug0GKisrXeYLbNq0CUVRWLhwIe+88w5NTU1s2LDB20N2On/+PFu2bGHTpk3U1dVx9913s3XrVmbOnCnrsSPtxx/VJYI++AELgLuAMOAYkIsaEHwLZPZxbhew/09/4n8ue12v1zvX6nue6hMSEpxT+tHR0YwaNWqwn0oIMUIkGPAyvV7PXXfdxb59+/jzn//s8pjKykpmzZrV67WWlhY2b96MoigsWrSIBQsWDFvSYFVVFfn5+Wzbto2uri4eeeQRVq1aRVJSktd/txigEyfATSZ9j1t/+dfjbtTcgXRgLdBnwatGw11JSUQ8+SRms9l5sx83bpwEgkJchyQYGAbZ2dns2LEDq9V6xc1cURTnMsGltm/fTktLC7NnzyYvL4/4+HivJw0eOnSI3NxcPvjgAwwGAytXrmTZsmVMmDDBq79XDExzc7NznX56XR3jB3GNBGAe8HegG3XpwBW9VsvMm29m5jPPDHa4QohriAQDw2DOnDno9Xr279/PU0891eu9xsZGmpubey0TOBwO5yzCbbfdxosvvkhBQYFXkgYVRaGgoICcnBw+++wz4uLiyM/P57HHHpOM7WHU2dnpTMqz2WycOHGC0tLSXqV2HR0dzuO/ofdT/9UwAheBFsBtCxKtdkjVBEKIa4sEA8PAYDAwa9Ys9u7de0Uw4KqscP/+/dTV1TF16lTeeOMNFixYwOzZsz06posXL7Jz505yc3M5evQo06ZN44MPPmD+/Pno9fKfhScpikJDQwM2mw2r1crJkyc5duwYJ0+epLq6mvr6+n6T8oKCgoiOjsZoNGKxWAgsLsbxww9o+1kqcKUc8AeC+jqoqwvS0q762kKIa5P81R8mWVlZrF27lpaWll5P3D0Nhy4NBl544QUALBYLJSUlHk0abGpqYuvWrWzcuJHa2lqysrLYvHkzs2bNkrXgQWpra6O6uhqr1erslNeTfV9XV8f58+fp6upye35AQABGo9GZlJecnIzFYsFoNGI0GomOjsbPz6/3Sdu2wb/+1ee4zgDhl71WCHwEzAX67CmoKDB1ap/XF0JcPyQYGCbZ2dk899xzHDx4kHnz5jlfr6ysJCAggLCwMEBdtz9y5Ahms5k9e/bw8ssveyRp0GazOZMCOzo6eOihh1i1ahWpqalDvvb1zOFwcPr0aWfznJ6WuBUVFdTW1tLQ0NBnpzw/Pz/CwsKIjIwkNjaWSZMmkZSU5GyeExMTM7geDXPn9ttw6D7U3gK3AhGo1QR/AQKBV/q7fliYBANC+BAJBoZJQkIC8TNmkFtSwifJyRxtaaHF4aDOZMLvpZfYVFPDHSEhrF27FlCnhRMSEoacNFhYWEhubi67du0iKCiIZcuWsXz5ciZOnOiJj3XNs9vtzo1uSkpKnBvdVFdXc+bMGex2u9tOeTqdjtDQUGcNfUJCgnOjm54bvdc29oqJgexs2L/fbVXBPcB7wAagGXWW4HfAS7hvRwyATgdPPQVSIiiEz5BdC4fBV42NvGazse/sWQBGabV0XvK1a7q7QadDASgtJXDfPlr376egoGBQuQKKonDw4EFycnL49NNPMZvNrFy5kiVLlhAU1OdK8XWls7OT2tpa5452R48e5eeff8ZqtVJfX09jY6PbTnlarZbg4GDCw8OJiYlxtpaeNGmSc6ObEd/V7rvvYObMftsRX7UxY6CsDKKiPHtdIcSwk10LfwUudHWxprycLbW16hf9y42j87I/3sqlXfwSE2ldvZoJCxeSclnvgf50dnaye/ducnNzKSws5MYbb2Tnzp3ce++9111SoKIonDt3DpvNxvHjxykqKqKsrIzKykrq6uo4d+5cn9vXBgUFERkZ6dy+NikpibS0NGJjYzEajYSHh//6t1y+5RZYsUJtGzyAToQDtnGjBAJC+BiZGfCSmo4O7jx8mJNtbVx9vrda/x2k01GQkcH0fr7z5uZmtm3bRn5+PtXV1cydO5fVq1dzxx13XLNJge3t7VRXV/Pzzz9TWFh4RZmd3W53u32tv78/oaGhREZGYjabSUhIYPLkyUyaNAmj0UhkZOT1Exy1tMCMGVBaqlYADIVWC/Pmwd/+1m93QyHEtUFmBkbQmYsXmfXTT1g7OgYVCIDaEOZCdze/PXyYrzIzyQwOvuKYmpoaNm3axJYtW2hra2PRokWsXr2ayZMnD2n83uZwOKivr6e8vJzCwkJnmZ3NZqO+vp6mpqZeNfWX8vPzw2AwkJSU5CyzS01NJS0tDbPZ7Drz/no2Zgz84x9w++3q1P4gSg0B9eY/Zw68/74EAkL4IAkGPExRFB4rLaWqvX3QgUCPbqDd4eB3xcUUT5tG4C/LCUVFRaxfv57333+fgIAAnnzySVasWEF0dPSQx+8JFy5coKKigqKiIoqKijhx4gRVVVXOMrvW1lZcTUjp9XqCg4Od5XRxcXEkJyeTnp6OxWIZfOb99S4iAr75Bp5+GnbtGtC2xk46nbrE8Mc/wrp14EuBlBDCSYIBD3vv9Gn2nzvn/oDjx+Gtt9TtZxVFbezyhz9Aguv87m7A2t7O2vJy5tls5OTkcODAAYxGI6+88gpPPPHEsC7ddHV1UVNTQ1FREUeOHOH48eO9yuwuXLjgsqZeq9UyZsyYK8rs0tPTSUlJwWg0yhLUUISGws6dsHAhPP+8Okug17tfOuh5b/p02LBB/SmE8FmSM+BB3YqC+bvvqHG3l3tZGSxfrj7JZWerT2Qffgh2O7zxBvTVT8DhgIULyYiJYc2aNSxcuNDju8MpisL58+cpLi7mp59+cu5R31Nm19zc7HL6XqPREBAQQEhICBEREc4yu7S0NNLT04mPjx/5zHtfoijw1VfqlP8//6kGnj1Bgb8/ZGbCrbfC4sUwZcrIjlUI4VUDvX9LMOBB+86eJfvoUfcHPP88HDsG774LPXu6NzTAww/DTTep07TuOBw8rCi8c+edg76pdnR0cPz4cQ4dOkRxcbGzzO706dM0Nja6nb4fPXo0Y8eOJTw8nOjoaCwWC8nJyWRkZJCSknJtZN77sq4uaG1VEwQDA9WfQgifIAmEI2BnfT06cJ8rUFQE06b9OxAAGD8eMjLUJ7i2NggIcH2uVsvX/v5uAwFFUbBarfz444+9yuxOnTrlLLNzNX2v1+t7ldnFxsaSlJREeno6GRkZREVFXT+Z975KrwcJ4oUQfZC/8h70bVNT30mDnZ3gaufB0aPV9yoqoI/2wBXt7bycn0/VsWOUl5f3KrNzNX3fs04fGhrqbJaTmJjIlClTyMzMxGKx+FbmvRBCCJckGPCQC11dVLoph3MyGqGkRC3/6mk01Nmp1ogDnDnT7+954e234cgRNBoN/v7+zjK7mJgYZ5ndDTfcwJQpU2QLYiGEEAMiwYCHNA6k4cu8eZCXBzk5cP/9aqLXu++qeQMA7hIPL/HS+vUsz8xk/PjxQxyxEEIIoZJgwEMGlNR3991QXw+7d0NBgfpaUpIaGOzY4T5f4BI33nCDBAJCCCE8SoIBDxmn16MF+u0Q/8QTcN99UFmpdo+Lj1f3pgd1J7p+RMhOckIIITxMggEPCdDpmBQYSGlra/8HBwf3ru8+dAjCw/vuMwBogQwf2nVQCCHE8JCCYw/6jcGA/mp7AHz2mZpAeO+9fdZ/a4DUMWMIuHSHQyGEEMIDZGbAgxZPmMD/njrl/oDCQvjrX9UGQ2PHqpUFn3wCN98MCxb0e/0nJk704GiFEEIIlQQDHjTTYCAlMJDjra2ucwfCwtSn/9271Y5wEyfCkiXw+9//u9TQDT+NhsUTJnhl3EIIIXybBAMepNFo2JiQwOwjR1wfEB2tlhUOwn/HxREiyYNCCCG8QHIGPOw/xo3jPydO9NgXqwOmBgWxagCVBkIIIcRgSDDgBfkJCdwydixDTfXTAxP8/Pj75MnoZXMZIYQQXiJ3GC8I1Ok4kJ7O7SEhg76GFjD5+/NNZiYmf3+PjU0IIYS4nAQDXhKk11OQkUGexcJojWbAswQ9pYlLo6M5Mm0asQPoSiiEEEIMhSQQepFOo+FZo5F7wsJ4o7aWv9TW0tTdjRbQajQoioLml5/dwCiNhkURESyPiWFqcPBID18IIYSP0CiKovR3UHNzMwaDgaamJsbKvuiD1t7dzf/Z7fxot3OstZW27m78tFosAQFMDQpi+tixhErFgBBCCA8Z6P1bZgaGkb9Ox6yQEGYNIZdACCGE8DTJGRBCCCF8nAQDQgghhI+TYEAIIYTwcRIMCCGEED5OggEhhBDCx0kwIIQQQvg4CQaEEEIIHyfBgBBCCOHjJBgQQgghfJwEA0IIIYSPk2BACCGE8HESDAghhBA+ToIBIYQQwsdJMCCEEEL4OAkGhBBCCB8nwYAQQgjh4yQYEEIIIXycfiAHKYoCQHNzs1cHI4QQQgjP6blv99zH3RlQMGC32wEwGo1DHJYQQgghhpvdbsdgMLh9X6P0Fy4ADoeD2tpagoOD0Wg0Hh2gEEIIIbxDURTsdjtRUVFote4zAwYUDAghhBDi+iUJhEIIIYSPk2BACCGE8HESDAghhBA+ToIBIYQQwsdJMCCEEEL4OAkGhBBCCB8nwYAQQgjh4/4fmVnTzShjTOcAAAAASUVORK5CYII=" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -290,8 +286,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:53.442102700Z", - "start_time": "2023-06-30T07:04:53.126416600Z" + "end_time": "2023-07-03T11:45:08.708112400Z", + "start_time": "2023-07-03T11:45:08.390560600Z" } } }, @@ -306,7 +302,7 @@ }, { "cell_type": "code", - "execution_count": 181, + "execution_count": 7, "outputs": [], "source": [ "def sim_annealing(graph, t_max: int, T: float):\n", @@ -331,20 +327,20 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:53.444340600Z", - "start_time": "2023-06-30T07:04:53.442102700Z" + "end_time": "2023-07-03T11:45:08.711814200Z", + "start_time": "2023-07-03T11:45:08.709702400Z" } } }, { "cell_type": "code", - "execution_count": 182, + "execution_count": 8, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "number of low-lying excited states: 21\n" + "number of low-lying excited states: 23\n" ] } ], @@ -360,14 +356,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:56.794388500Z", - "start_time": "2023-06-30T07:04:53.442661600Z" + "end_time": "2023-07-03T11:45:12.123684300Z", + "start_time": "2023-07-03T11:45:08.709702400Z" } } }, { "cell_type": "code", - "execution_count": 183, + "execution_count": 9, "outputs": [ { "name": "stdout", @@ -405,8 +401,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:56.798234600Z", - "start_time": "2023-06-30T07:04:56.794388500Z" + "end_time": "2023-07-03T11:45:12.128858800Z", + "start_time": "2023-07-03T11:45:12.128083Z" } } }, @@ -430,12 +426,12 @@ }, { "cell_type": "code", - "execution_count": 184, + "execution_count": 10, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVyU2ffHPzOkpAKKCaiASqi4u3auSAn22oWBgYW9ayc2BnaA2K2AoqIoBrZioYRBCSgg0jVzfn/4m/kyMsAAQ8l9v1683J3nPveeB2bmfu6555zLISICg8FgMBiMagu3og1gMBgMBoNRsTAxwGAwGAxGNYeJAQaDwWAwqjlMDDAYDAaDUc1hYoDBYDAYjGoOEwMMBoPBYFRzmBhgMBgMBqOaIytJIz6fjy9fvkBVVRUcDqesbWIwGAwGgyEFiAgpKSmoX78+uNyC1/8SiYEvX76gUaNGUjOOwWAwGAxG+REZGYmGDRsWeF0iMaCqqirsTE1NTTqWMRgMBoPBKFOSk5PRqFEj4TxeEBKJAcHWgJqaGhMDDAaDwWBUMYra4mcBhAwGg8FgVHOYGGAwGAwGo5rDxACDwWAwGNUcJgYYDAaDwajmMDHAYDAYDEY1h4kBBoPBYDCqOUwMMBgMBoNRzWFigMFgMBiMag4TAwwGg8FgVHOYGGAwGAwGo5rDxACDwWAwGNUcJgYYDAaDwajmMDHAYDAYDEY1h4kBBoPBYDCqOUwMMBgMBoNRzWFigMFgMBiMao5sRRvAYDAYjLIhLSsXnxPSkJ3Lh7wsF3qaylBWYF/7jPywdwWDwWD8RoTGpeDYowjcCv6KiMR0UJ5rHAA6Gkro0awORrTTgYG2akWZyahkcIiIimqUnJwMdXV1/PjxA2pqauVhF4PBYDCKQWRiOv678Bp3w+Ihw+WAxy/4q11wvYu+Ftb2N0UjDaVytJRRnkg6f7OYAQaDwajinHwSAXMXfwR8TACAQoVA3usBHxNg7uKPk08iytxGRuWGbRMwGAxGFcb1Vig2XQ8p0b08PoHHJyw8/xrxqVmY1sNAytYxqgrMM8BgMBhVlJNPIkosBH5l0/UQnGIegmoL8wwwGAxGFSQyMR3LPN8WeD0rNgxJ/h7Iin4HAFCo3xy1ethDXrtJgfcs9XyLjk21WAxBNYR5BhgMBqMK8t+F18gtIDYgKzYMcUfnIzcpFjU7DYN6p6HI+f4FsccXIichqsA+c/mE/y68LiuTGZUYJgYYDAajihEal4K7YfEFBgr+uHsUHFl51B29CWrtBkC93UDUHbURIEKSv0eB/fL4hLth8Qj7mlJWpjMqKUwMMBgMRhXj2KMIyHA5BV7PjHwLRb3WkKnxv1QyWRUNKDYyQfqHx+BnZxR4rwyXg6MPWexAdYOJAQaDwahi3Ar+Wmj6IPFywJGVz/c6R04B4OUi51t4gffy+IRbIV+lYiej6sDEAIPBYFQhUrNyEZGYXmgbOY2GyPoSDOLzhK8RLwdZX4IBALkpCYXeH5GQjrSs3NIby6gyMDHAYDAYVYjwhDQUVTZWtY0NchOjkXBlO7LjI5D97TPivbeAl/odAEC52YXeTwA+J6RJx2BGlYClFjIYDEYVIjuXX2QbVTMb5CbHI/nReaS9uQkAkK9rALX2A5EccApceUWpjMP4fWBigMFgMKoQ8rKSOXRrdRsNtXYDkPMtHFwFZcjX0cN3/8MAAFmNBlIbh/F7wMQAg8FgVCH0NJXBAYrcKgAAGUUVyDQyFv5/5udAyKhqQU6zYaH3cf5/HEb1gYkBBoPBqAJkZWXB398fXl5eIPoDUK1drPvT3t1BdkwoavUYBw6n8FW/jqYSlBXY9FCdYH9tBoPBqKR8/foVV65cgZeXF65fv47U1FTo6OhAb2AzRJAmqIBJPTPiDX7cPwHFxmbg1lBD9pf3SH11A4pN/oDqX30LHVOGy0EPwzpl8TiMSgwTAwwGg1FJICK8efMGXl5e8Pb2xsOHDwEA7dq1w7///gtLS0s8e/YM63YfBln9V2A/MqqaAJeL5Efnwc/OgGxNbdTsOgpqbfuBw5Up1AYenzCyvY5Un4tR+WFigMFgMCqQrKws3L59G97e3vDy8kJ4eDhUVFRgYWGBQ4cOwcbGBioqKti/fz/69u2LL1++YNCgQcjSlsebbzliiw/J1aoH7SGrim2LDJeDjk00oV9HVRqPxqhCMDHAYDAY5Yw497+uri7s7OxgZ2eHbt26QUFBAT9+/MCuXbvg4uKCxMREjBgxAv/++y+aN2+OyMR0mG+5DR4RwCm4NHFxkOVysLa/qVT6YlQtmBhgMBiMMiav+9/LywuPHj0CALRv3x7//vsv7OzsYGJiAs7/T+rx8fFYvXo1duzYgYyMDIwbNw7z589H48aNhX3yU76B9+Qk0GaI1Oxc2ceYHV9cTWFigMFgMMoAgftfsP8vzv1fp45ooF5MTAw2b96MPXv2gIgwefJkzJkzB/Xr1xdpFxQUBAsLC8jLy2PcREccehZfanvnWTTDkL9YrEB1hYkBBoPBkBJfv37F5cuX4e3tXaj7/1c+f/6MDRs24NChQ1BQUMCsWbMwa9YsaGlp5Wv76NEj2NjYoEGDBrh27Rrq1asHQ90ILPN8i1w+FXqA0a/IcDmQ5XKwso8xEwLVHA4RFfnOSU5Ohrq6On78+AE1NbWimjMYDEa1gIjw+vVrYfBfXve/nZ0dbG1tRdz/vxIcHAxnZ2ccO3YMNWvWhJOTExwdHaGuri62va+vL/r3749WrVrB29sbtWrVEl6LTEzHfxde425YPIjPKzRrQIbLAY9P6KKvhbX9TdnWwG+MpPM3EwMMBoNRDApy/1taWsLOzg7W1tb53P+/8vLlS6xduxZnzpxBvXr1MHfuXDg4OEBZueCqf2fOnMGIESNgbm6Os2fPQklJ/AS+brc7Nl54CKOe/yAqKfOXSoUEXU1l9DCsg5HtdVjWQDVA0vmbbRMwGAxGEQjc/4Lo/7S0NInc/7/y8OFDrFmzBt7e3mjcuDF2796NsWPHFnnv3r17MWXKFAwbNgzu7u6Qk5MrsO2TG15onhaLuwv2IC0rFzvcT2LZilVobqiPVk3rw8N5f7Gfn/H7w8QAg8Fg/ILA/S+I/n/8+DGAn+7/RYsWwc7ODsbGxgW6/3/t69atW1izZg38/PzQokULeHh4YNiwYZCVLfwrmIjg7OyMRYsWYdq0adi2bRu43IJLCefk5ODGjRuYN28eAEBZQRb6morIjglBi65mCHn7uhi/BUZ1gokBBoPBwE/3/61bt4T7/xEREUL3/5QpU2BjY4PatSU/D4CIcOXKFaxevRoPHz6EmZkZzp49i/79+xc6oQvg8/mYO3cuXFxcsGLFCixZsqRI8REQEIDk5GRYW1sLXxNsPTRp0gRXrlwBEUkkYhjVCyYGGAxGtSUuLk6k+E9aWhr09PTQt29f2NraSuz+zwuPx8P58+exdu1aBAYGomPHjrh8+TKsra0lnoRzcnIwfvx4HD16FK6urnB0dJToPh8fH9SpUwdmZmbC1wRiQFdXFykpKYiOjkbDhoWfWsiofjAxwGAwqg0Fuf87dOhQbPf/r+Tk5OD48eNwdnZGcHAwzM3NcevWLXTr1q1Y/WVkZGDIkCHw8fHBsWPHMGzYMInv9fHxgbW1tYjnQSAGBLUKgoKCmBhg5IOJAQaD8VuTmZkpEv1fWve/uP7d3d2xfv16fP78GX369MHhw4fRrl27Yvf148cP2NnZ4enTp/Dy8oKVlZXE90ZFReHVq1f47z/RA4wEYkBNTQ01atQQFixiMPLCxACDwfjtiIuLEyn+k9f9b2dnh65duxbb/f8raWlp2Lt3LzZt2oTY2FgMHjwYly5dQsuWLUvUX2xsLKysrBAREYGbN2+iQ4cOxbr/6tWr4HK56NWrl8jrghTEzMxMNG/eHEFBQSWyj/F7w8QAg8Go8hARXr16JQz+y+v+X7x4MWxtbUvs/v+VpKQkuLq6YuvWrfjx4wdGjRqFhQsXwtDQsMR9fvr0Cb169UJ6ejru3LkDExOTYvfh4+OD9u3bQ0NDQ+R1gWcgLS0NRkZGTAwwxMLEAIPBqJKUtfv/V759+wYXFxfs3LkTWVlZmDBhAubNmwddXd1S9fv69WtYWlpCWVkZ9+/fFzmMSFJ+TSnMy69igGUUMMTBxACDwagyCNz/Xl5e8PX1LRP3/69ER0dj06ZN2Lt3L7hcLqZOnYrZs2ejbt26pe47ICAAvXv3hq6uLq5duwZtbe0S95OcnAwbG5t81xQUFMDlcoVi4Pv374iLi5OK/YzfByYGGAxGpUXg/hes/n91/9vZ2cHIyKhMVrkfP37E+vXr4e7uDiUlJcybNw8zZsyApqamVPr38fHBwIED8ddff8HT07PA8wgk4cqVK9DW1kbr1q3zXeNwOFBWVkZ6ejqMjIwA/MwoYGKAkRcmBhgMRqUiMzNTWPxH4P5XVVWFpaUlpk6dCmtra6m6/38lKCgIzs7OOHHiBDQ1NbFy5UpMmTJFqueynDhxAqNHj4a1tTVOnTqFGjVqlKo/Hx8fWFlZFVjMSFlZGWlpaWjSpAnk5eURFBSEv//+u1RjMn4vmBhgMBgVTmxsrLD4jzj3f7du3SAvL1+mNrx48QJr1qzB+fPn0aBBA7i4uGD8+PEFHghUUlxdXTFjxgyMHj0aBw4cKLIkcVFERUXh9evXWLRoUYFtBGJAVlYWzZo1Y0GEjHwwMcBgMMqdvO5/QfQ/h8MpF/f/r9y/fx9r1qyBj48PmjZtin379mH06NFSFx9EhBUrVmDFihVwcnLCpk2bJCpLXBQFpRTmRSAGALCMAoZYmBhgMBjlgsD9L9j/j4yMFLr/HR0dYWNjAy0trXKxhYhw48YNrFmzBv7+/jA2NsaxY8cwePDgUq/UxcHn8zFz5ky4urpi7dq1WLhwodSEzpUrV9ChQ4d8KYV5UVJSEhEDN2/elMrYjN8HJgYYDEaZERsbKyz+I3D/N27cGP379xfW/i9r939e+Hw+vL29sWbNGjx+/Bh//vknLly4gD59+khllS6O7OxsjB07FidPnsTevXvh4OAg1b5v3LiBBQsWFNruV89AfHw8vn37VqaxF4yqBRMDDAZDaohz/3O5XHTo0AFLliyBra1tubn/88Lj8XDmzBmsXbsWr1+/RpcuXXD16lVYWFiUqS1paWkYNGgQ/Pz8cPr0aQwaNEiq/QcEBCAlJUXklEJx/CoGgJ+Bkt26dZOqPYyqCxMDDAajVFQm9/+vZGdn4+jRo1i3bh1CQ0NhaWmJnTt3okuXLmU+dmJiImxtbfHq1StcvnwZ5ubmUh/Dx8enwJTCvCgrKyMmJgYAoK+vD1lZWSYGGCIwMcBgMIqNwP0viP5PT08Xuv8FxX/K0/3/KxkZGTh06BA2bNiAiIgI9O/fH8ePH8eff/5ZLuN/+fIFlpaWiImJgZ+fH9q2bVsm4xSVUihAUGcAAOTl5WFgYMCCCBkiMDHAYDCKhIjw8uVLkeI/Avf/0qVLYWdnhxYtWlR4iduUlBTs2bMHmzdvxrdv3zBs2DD8+++/MDY2LjcbwsLCYGFhgZycHNy9exctWrQok3EiIyPx+vVrLF68uMi2ebcJAJZRwMgPEwMMBkMsmZmZ8PPzExb/Ebj/raysKtz9/yuJiYnYsWMHtm3bhtTUVIwZMwYLFiyAvr5+udoRGBgIKysr1KxZE7dv34aOjk6ZjSVJSqEAcWJg//79ZWYbo+rBxACDwRBS2d3/vxIXF4ctW7Zg165dyM3NhYODA+bOnYtGjRqVuy137tyBnZ0dDAwM4OPjU+aR+j4+PujQoQNq1apVZNu8qYXATzEQGxuLxMTEQlMSGdUHJgYYjGpMXve/l5cXnjx5Uind/78SGRmJjRs3Yv/+/ZCTk4OjoyOcnJxKfNBPafHy8sLgwYPRoUMHXLp0CaqqqmU6nqQphQLEeQYA4N27d+jUqVOZ2MioWjAxwGBUMwTuf8H+f1RUlND9P336dFhbW1ca9/+vhIWFYd26dfDw8ICqqir+/fdfTJ8+XaLVcVnh4eGBcePGoU+fPjh+/DgUFRXLfExJUwoFCAII+Xw+uFwuDA0NweVyERQUxMQAAwATAwxGtUCc+79JkyYYOHAgbG1tK537/1fevHkDZ2dnnDx5EnXq1MHatWsxadKkMl+BF8XWrVvh5OSE8ePHY8+ePWVSvVAcV65cQd26dYtMKRSgrKwM4GeWhbKyMhQVFdG0aVMWRMgQwsQAg/EbQkQIDAyEt7e3iPu/Y8eOldr9/ytPnz7FmjVrcPHiRejo6GDHjh0YN25cuay+C4OIsGTJEqxZswYLFiyAs7Nzuf4uJU0pFCAQA+np6cL/ZhkFjLwwMcBg/CZUZff/r9y5cwdr1qzB9evXYWBggEOHDmHkyJGQk5OraNPA4/Hg6OiIvXv3YuPGjZg7d265jh8ZGYk3b95gyZIlEt8jEABpaWnCwEYjIyMcOXKkTGxkVD2YGGAwqjAxMTFC9/+NGzdE3P92dnbo0qVLpXb/54WIcO3aNaxZswb37t1Dy5YtcfLkSQwaNAgyMjIVbR4AICsrCyNHjsT58+dx6NAh2Nvbl7sNxUkpFJBXDAgwMjJCVFQUkpOToaamJnU7GVULJgYYjCqEwP0vWP3ndf8vW7YMtra2VcL9nxc+n49Lly5hzZo1ePbsGdq2bQtPT0/Y2tpWqudITU3FgAEDcOfOHZw7dw79+vWrEDuKk1IoQJwYEBRievfuHdq1ayddIxlVDiYGGIxKTkZGhkjt/6ioKKipqVVJ939ecnNzcerUKTg7O+Pt27fo3r07fH190bNnz0olAgAgISEBNjY2ePfuHXx8fNCjR48KsSM7Oxu+vr74999/i3WfkpISAFEx0KxZM3A4HAQFBTExwGBigMGojPxO7v9fycrKgoeHB9avX48PHz7AxsYG+/btQ8eOHSvaNLFERUXBwsIC8fHxuH37Ntq0aVNhtty/fx+pqakSpxQKEOcZUFJSQuPGjVkQIQMAEwMMRqUgr/vfy8sLT58+FXH/29nZoXnz5pVuxVwc0tPTceDAAWzcuBHR0dEYOHAgzpw5AzMzs4o2rUCCg4NhYWEBALh37x4MDQ0r1B4fH59ipRQKECcGAJZRwPgfTAwwGBVERkaGSPR/dHS00P0/c+ZMWFlZVUn3/68kJydj165d2LJlCxITEzF8+HD8+++/ZXaAj7R49uwZrKysUKdOHVy7dg0NGzasaJOEKYXFFYWFiYHTp09LzT5G1YWJAQajHBHn/m/atCn++ecf2NraVmn3/68kJCRg+/bt2L59O9LT02Fvb4/58+ejSZMmFW1akdy6dQt9+/aFkZERLl++DE1NzYo2qUQphQJkZGSgoKAgPMZYgJGRET5//oy0tDShYGBUT5gYYDDKkOrg/v+VmJgYbNmyBbt37wafz8fkyZMxZ84cNGjQoKJNk4gLFy5g6NCh6NatG86fPw8VFZWKNgnAT6+AjIxMsVIK8/Lr+QTA/84oeP/+Pf74449S28ioujAxwGBImaLc/9bW1pVipSltwsPDsWHDBhw8eBAKCgqYOXMmZs2aVean90mTQ4cOYeLEiRg0aBA8PDygoKBQ0SYJKUlKYV7EiYHmzZsDAIKCgpgYqOYwMcBgSIGYmBhh6d8bN24gIyND6P63s7ND586dfxv3/6+EhITA2dkZR48ehbq6OpYsWQJHR0fUrFmzok0rFhs2bMCCBQswefJkuLq6VppCR8D/TiksbkphXn49xhgAVFVVoaOjw4IIGUwMMBglgYjw4sULoQAQuP87deqE5cuX/5bu/1959eoV1q5di9OnT6NevXrYsGEDHBwcqtzeMxFhwYIF2LhxIxYvXoyVK1dWur9bSVMK8yLOMwCwjALGT5gYYDAkJCMjAzdv3oS3t3e1cv//yqNHj7BmzRp4eXlBT08Pu3fvxtixYyuVS11ScnNzMXnyZBw8eBAuLi6YNWtWRZskluKeUiiOwsSAp6dnKaxj/A4wMcBgFEJR7v8uXbpUisNz0rJy8TkhDdm5fMjLcqGnqQxlBel9vIkI/v7+WL16NW7evInmzZvj8OHDGDZsWKV4/pKQmZmJ4cOHw9PTEx4eHhg1alRFm1QgPj4+sLa2LpXHojAx4OLigoyMDNSoUaM0ZjKqMEwMMBh5ELj/BdH/z549E7r/V6xYATs7O2EZ14omNC4Fxx5F4FbwV0QkpoPyXOMA0NFQQo9mdTCinQ4MtFVLNAYRwcfHB2vWrEFAQABat26NM2fOoH///pVqT724JCcno1+/fnjw4AEuXrwIW1vbijapQCIjI/H27VssW7asVP0oKysjNTU13+tGRkYgIgQHB5fK88Co2jAxwKj2CNz/guj/L1++QF1dHVZWVpg1a1alc/9HJqbjvwuvcTcsHjJcDnh8yteGAIQnpuPIo3C4P/iMLvpaWNvfFI00lCQag8/n4/z581i7di1evHiBDh064PLly6VenVYGvn79Cmtra4SFheH69evo0qVLRZtUKKVNKRSgrKyMuLi4fK8Lij8FBQUxMVCNYWKAUS358uWLSPEfgft/8ODBlcr9/ysnn0Rgmedb5P6/ABAnBPIiuB7wMQHmLv5Y0ccYQ//SKbB9Tk4OTpw4AWdnZ7x//x49e/aEn58funfvXuVFAPAz/dHCwgI/fvyAv79/lZj8BCmFpc3OKGiboGbNmqhfvz4LIqzmMDHAqBZUJfd/QbjeCsWm6yElupfHJ/D4hIXnXyM+NQvTehiIXM/KyoK7uzvWrVuHz58/w87ODm5ubmjfvr00TK8UBAUFwcLCAvLy8rh//z6aNm1a0SYViSCl8L///it1XwWJAYBlFDCYGGD8xhTm/ndycoKVlVWlcv8XxsknERIJgR8Bp5B05wjktHRQf8IusW02XQ9BbRUFDPlLB2lpadi3bx82bdqEmJgYDB48GJcuXULLli2l/QgVyqNHj2BjY4MGDRrg2rVrqFevXkWbJBH37t0rdUqhAHF1BgQYGRnh2rVrpR6DUXVhYoDxW/Hlyxdh9P/NmzeRkZEBfX19DBkyRFj7vzK6/wsjMjEdyzzfFtkuNzkePx6cBkdOsci2Sz3f4vnVUzi0fQOSkpIwcuRILFy4EM2aNZOGyZUKX19f9O/fH61atYK3t3eJK/hVBD4+PqhXrx5atWpV6r6K8gzs3LkTWVlZVTJFlFF6mBhgVGmICM+fPxcKAIH7v3PnzlXG/V8U/114LYwRKIzvtw5CoX4zEJ8PfkZyoW0zs3Pg8SEbgwcPxvz586GrqystcysVZ86cwYgRI2Bubo6zZ89CSUmyAMrKQklPKRRHUWKAx+MhNDQUJiYmpR6LUfVgYoBR5UhPTxep/f+r+9/a2hoaGhoVbaZUCI1Lwd2w+CLbZUa8Qfr7+6hnvx2JvnuKbM/hykBBtzWcnGZAt07J0g4rO3v37sWUKVMwbNgwuLu7VzmPUEREhFRSCgUoKysjJycHOTk5+X4XggOLgoKCmBiopjAxwKgSFOb+F9T+r2pf9pJw7FFEgemDAojPQ6LvHqi0soB8HT2J+5bhcnD0YQSW9zGWgqWVByKCs7MzFi1ahGnTpmHbtm3gcrkVbVaxkVZKoQBBmej09HSoq6uLXNPU1ESdOnVYEGE1hokBRqVE4P4XrP7zuv9XrlwJW1vbKu/+l4RbwV+LTB9MfeGD3ORv0B62plh98/iEWyFfsRy/jxjg8/mYO3cuXFxcsGLFCixZsqTKvkd8fHzQsWNHqR34JBADaWlp+cQAwDIKqjtMDDAqDenp6SK1/wXuf2tr69/O/S8JqVm5iEhML7QNLyMZSXePoWbHIZBRyv8FXxQRCelIy8qVauniiiInJwfjx4/H0aNHsXPnTkydOrWiTSox2dnZuHnzplRSCgXkFQPiMDIygr+/v9TGY1Qtqv43AKNKEx0dLVL8JzMzs1q4/yUhPCENRYUNJt05Am4NFaj+aVeiMQjA54Q0GNcvvpCoTGRkZGDIkCHw8fHBsWPHMGzYsIo2qVRIM6VQgCB4sjAxsH//frExBYzfHyYGGOVKXve/l5cXnj9/DhkZGXTq1AmrVq2CnZ0dDA0Nq6xrV5pk5/ILvZ6TGI3UwGuo1XMieCmJwteJlwPi85CbFAeOghJkahQeIFjUOJWdHz9+wM7ODk+fPoWXlxesrKwq2qRSI82UQgGSeAZycnLw4cMHNG/eXGrjMqoGTAwwyhyB+9/LywuXL18Wcf/PmTMHVlZW1cr9XxBZWVl4//49Xr9+jTdv3uBJWAxgMLjA9ryUBID4+H5jL77f2JvvevSe8VD9sw80zB0KHffVi+fQU21TpfLvBcTGxsLKygoRERG4efMmOnToUNEmSYUrV65I/RyIosSAsfHP2JGgoCAmBqohTAwwyoTo6GiR6H/m/v8fPB4PHz58wJs3b/DmzRvh5B8aGgoejwcA0NHRQYuWrQEioIAJQa62LmoPWJTv9aQ7R8DPzoCGuQNkaxZeaY+IYP+PLSgnE40bN4aZmZnIT7169Sqtl+bTp0/o1asX0tPTcefOnd8mJS4iIgJBQUFYsWKFVPstSgzUrl0bmpqaCAoKwoABA6Q6NqPyw8QAQyrw+XyR4j/i3P+/Y3W7wiAiREdHCyd7wU9QUBAyMzMBAFpaWjA1NUWvXr3g5OQEExMTGBsbC6O9u228hfACgghllNShZJh/JZz85BIAiL32Kw3U5OET+AwvXrzA8+fP8eLFC2zevBlJSUkAAG1t7XwCoUmTJhWeqvf69WtYWlpCWVkZ9+/fR+PGjSvUHmkiSCk0NzeXar95UwvFweFwWEZBNYaJAUaJyev+9/b2RkxMTLV1/yckJORb6b958wY/fvwA8POL2MTEBGZmZhg9ejRMTExgYmKCOnXqFLry7tGsDo48Ci8yvbAkEJ+H97c8MfV6MOzt7bFy5UooKyuDiBAeHi4iEA4fPgxnZ2cAgJqaGlq3bi0iEFq0aFFunp6AgAD07t0benp6uHr1KrS1tctl3PJC2imFAhQVFcHhcAr0DAA/4wYePnwo1XEZVQMmBhjFQpz738DAAMOGDYOdnR06der0W7v/09LS8PbtW5GV/uvXrxEbGwsAkJOTQ4sWLWBiYoLevXvDxMQEpqam0NHRKdFqekQ7Hbg/+Fyse+qOWCdROw5XBkuGdsflEx8wduxYTJs2DYMHD4a9vT06deoEPT099O/fX9j+69evePHihVAkXL58Gdu2bQMAKCgowNTUVEQgtGzZUurlf318fDBw4ED89ddf8PT0FJsvX5XJysrCjRs3sGhR/u2f0sLhcAotSQz8FAPu7u7g8XiQkZGRug2MygsTA4xCEbj/BdH/L168gIyMDDp37vxbu/+zs7MREhKSb6X/8eNHAD+/WJs2bQoTExNMnDhRuNI3MDCQqhgy0FZFF30tBHxMkKp3QIbLQccmmnAa3xtO44chPDwchw8fhpubGw4dOgQDAwOMHTsWo0ePRsOGDQEAderUgaWlJSwtLYX9JCcn4+XLl0KB8OjRI7i5uSE3NxdcLhfNmjVDmzZtRERCSQMVT5w4gdGjR8Pa2hqnTp1CjRo1pPK7qEzcu3cPaWlpsLGxKZP+Czu5EPgpBrKysvDp0yfo6+uXiQ2MygmHiIr8hklOToa6ujp+/PgBNTW18rCLUYGkp6fjxo0bwuI/ed3/dnZ2v5X7n8/n49OnT/lW+sHBwcjNzQUANGjQQDjZC1b6LVq0KLdDbyIT02Hu4o8sKaYAKshyccOpGxppiD4Dn8+Hv78/3NzccPbsWWRlZcHCwgL29vbo06cPFBWLPhExMzMTb9++FdlmePnyJTIyMgAAurq6+QRC/fr1C90ucXV1xYwZMzB69GgcOHAAsrK/5zpm7ty5OHHiBKKiosokcLNJkyYYMmSIcMvnV758+YIGDRrg0qVL6NOnj9THZ5Q/ks7fTAwwAABRUVHC4j953f92dna/hfufiBAbG5tvpf/27VthQFXNmjVhamoKU1NT4cRvbGxcKYTP8Uef8d/Foo8xlpT1A0wx5C+dQtskJyfj9OnTcHNzQ0BAAGrVqoXhw4fD3t4ebdq0KdZkxePxEBISIiIQXrx4ge/fvwP4Gcn+q0Bo2rQpOBwOVq5cieXLl8PJyQmbNm2q8ODFssTY2Bjt27fHwYMHy6R/U1NT9OjRA9u3bxd7nYhQq1YtLFy4EAsXLiwTGxjlCxMDjEIpzP1vZ2cnrP1fFUlKShJZ6QsEQGLiz8I8NWrUgLGxschK38TEpNKm0RERZsyYgSPPv6Fm11Gl7k8uyAcPDi6HlpaWxPcEBwfD3d0dhw8fRkxMDExNTWFvb4+RI0eidu3aJbKDiBARESESh/DixQtER0cDAFRUVKCqqoqYmBgMHDgQixcvhrGxcZUWpYURHh4OPT09nDlzBoMGDSqTMdq3bw9jY+NCxUbHjh2hr68PDw+PMrGBUb4wMcDIh8D9Lyj+ExMTg5o1a8La2hq2trZVzv2fkZGBd+/e5VvtR0VFAQBkZGTQrFkzkQnfxMQEjRs3rlLBURs2bMCCBQuwZ88eqLexxjLPt8jlU7FiCGS4HMhyOZjaTgtrxvWGrq4ubt68WezPc25uLq5fvw43NzdcunQJRAQ7OzvY29vD2tpaKu77b9++4fHjx1i0aBFevnyJOnXq4OvXrwAAeXl5mJiYiHgRWrZsKUybq8rs2bMH06ZNQ3x8vNQzCQT07NkTderUwYkTJwpsM2HCBAQGBuLp06dlYgOjfJF0/v49N94YQqKiooR7/1U1+j83NxehoaH5VvofPnwAn/9zH71x48YwMTHBqFGjhJO/oaEhFBQUKtj60nH06FEsWLAAS5YswaRJkwAAnZpq4b8Lr3E3LL7I4425HIBPQGOlHLhN6YVGGkroeu0aunfvjr59++LKlSvFCsSTlZWFjY0NbGxskJCQgOPHj8PNzQ19+vSBtrY2Ro0aBXt7exgZGZX4mZWUlODq6op3794JV8kpKSkigYpPnjyBu7u7MFDR0NAQZmZmIiKhKglb4GemRKdOncpMCAAoMpsA+BlEeOLECfD5/N96S4YhCvMM/Gbw+Xw8e/ZMmP73q/tfUPu/MiJwG/+60n/37h2ys7MB/CyC8+tK38jICKqqhdffr4r4+vrCxsYGo0aNwsGDB/NtYYTGpWCvXxBO3H4FOY16AP53nQNAR1MJPQzrwP/gasR/fIOXL18Kv9zv3bsHCwsLmJub49y5c6UWhC9fvoSbmxuOHj2KhIQEtG3bFvb29hg6dGixJrfExETY2tri1atXuHjxYqGFd7KyssQGKgpiQHR0dPIJhAYNGlTKraCsrCxoampi8eLFZbpXP2zYMHz9+hU3b94ssM3Vq1dhbW2Njx8//lbFnKorEs/fJAE/fvwgAPTjxw9JmjPKmbS0NLp06RJNmDCB6tWrRwCoZs2aNGzYMDp+/DglJiZWtIn5iIuLo5s3b9K2bdto4sSJ1L59e1JVVSX8PEiP1NTUqGPHjuTg4EDbt2+nW7du0devXyva7HLj+fPnpKKiQtbW1pSdnV1gu8uXLxMAehscRloGrWnWqq30JjqJUjNzhG3u3r1LAOjixYsi9/r4+JCcnBwNHz6ceDyeVOzOysqis2fPUu/evYnL5ZKioiINHz6cfH19ixwjOjqaTExMSFNTkx49elSi8XNzc+ndu3d0/PhxmjdvHvXs2ZM0NDSE7ystLS3q1asXLViwgE6ePEnBwcFSe/bScOPGDQJAgYGBZTrOmPEO1KZnH3oenpjvfSIgPDycAJC3t3eZ2sIoHySdv5lnoIoicP97eXnBz88PmZmZMDQ0FAb/VRb3f0pKCt6+fZuvJK9gD1hBQQEtWrQQWembmJigUaNGlXIFVx58/vwZHTp0QIMGDXD79m2oqKgU2NbZ2Rnr1q1DUlISatWqhUWLFmHevHn52nXr1g0ZGRl49OiRyO/19OnTGDp0KKZMmQJXV1ep/s5jYmJw5MgRuLm54f3799DR0cGYMWMwduxYNGnSRKRtWFgYLCwskJOTg+vXr6NFixZSs4OIEBkZmS9QURBboqKiglatWol4EIyMjCAvLy81G4qiLFMKQ+NScOxRBG4Ff0V4QprIWRccADoaSujRrA5GtNOBgbYqiAhqampYunSp2PcSo2rBAgh/MwTuf0HpX4H7v0uXLrC1ta1w97/gxL1fS/KGh4cDALhcLgwMDPJF8Ddt2vS3zRkvCQkJCejUqRNycnIQEBBQZKndIUOGICYmBnfu3IGqqipWrlwJJyenfO18fX1hYWGBa9euwcLCQuTa/v374eDggEWLFmH16tVSfR7g52T86NEjHDp0CCdPnkRKSgq6desGe3t7DBo0CKGhobCyskLNmjVx/fp16OgUnvIoLb59+4bAwEARgRAaGgoigry8PIyNjUW2GVq1alVmgYpGRkbo0KGDVFMKIxPTJY4tEVzvoq+Ftf1NMdCqO4yNjeHm5iY1exgVAxMDvwFpaWkixX9iY2OF0f+C4j/lfewsj8fDx48f8630Q0JChCfuNWrUKN9Kv0WLFhIVrKnOZGRkwNzcHCEhIQgICICBgUGR9zRv3hwWFhbYvn07atSogfXr12PGjBn52hER2rVrB0VFRdy5cyff9Y0bN2L+/PnYtGkT5syZI5XnEUd6ejrOnz8PNzc3+Pn5oUaNGsjNzUWTJk1w584d1KlTp8zGloSUlBS8evVKRCC8ffsWOTk54HA4YgMVNTU1SzWmIKXw7NmzGDhwoFSe4+STiFJlnejGP8aP51fw6NEjqdjDqDhYNkEVpSD3/4gRI4TR/+Wxkqb/P3Hv15V+3hP3NDU1YWpqip49e2LmzJkwNTUVOXGPITk8Hg/Dhw9HYGAgbt26JZEQSEtLQ0hIiNCVW1g9eQ6Hg8WLF6Nv3764c+cOunbtKnJ93rx5+P79O+bOnYuaNWti/PjxpX8oMSgpKWHkyJEYOXIkDhw4gClTpkBWVhbBwcHo0qWLsARygwYNymT8olBVVUWnTp3QqVMn4WvZ2dn5AhW9vLyEUfmNGjUSCgOBSGjYsKHE7n4fHx/IyspK7ZRC11uh2HQ9pET38v5fPITU/BPpNcJARNV2u666wTwDFUxe97+XlxcCAwOF7n/B/n9Zu//znriX90dwjK2ysjKMjY3zrfa1tbXZF4UUICJMmzYNe/fuxaVLl9C7d2+J7nv06BHat2+PJ0+e4M8//4SMjAx27dolTEH8FT6fDzMzM9StWxfXrl0Ta4ejoyP27t2LU6dOlVnhGwDw8PDAuHHj0KdPHxw9ehQPHz6Em5sbzp07J1ICuW/fvpUyPZTH4yEsLCxfRcWEhAQAP4XyrwLBwMBAbKpe3759kZSUBH9//1LbdfJJBBaef13qfgQs6N4QUyxbSa0/RvnDtgkqMQL3v6D4T2xsLGrVqiVS/Kcs3P9paWkICgrKl7oXExMD4OeJe82bN8+3r6+rq8vyjcsQZ2dn/Pfff9i/fz8mTJgg8X179+6Fo6MjUlJSoKioCC6XW2Qfp06dwtChQ/H48WP89ddf+a7z+XyMHDkSZ8+ehZeXl8ihRNJi69atcHJywvjx47Fnzx4RT9ePHz+EJZAfPHgADQ0NYQlkMzOzSi0+iQhRUVH5BEJkZCSAn6K6VatWIgJBX18f9erVk0pKoeAMi4z0NCQ/Oo+sL8HIjgkBPzMVmjazoNIyv+chJz4SiTf3IysqCBwZWdRo+hdq9ZwAGSX1n7ETMhz4zemR7wwLRtWhWoqBtKxcfE5IQ3YuH/KyXOhpKkNZoXLshERGRooU/8nKyhJG/0vb/Z+Tk4Pg4OB8RXo+ffokdPs1adIk30rf0NCwUmQgVCcOHz6MsWPHYvny5Vi2bFmx7p06dSr8/f3x9u1b5ObmQk5ODocOHYK9vX2B9/B4PBgZGaFFixa4ePGi2DY5OTno378//Pz84OvrK+IyLw1EhCVLlmDNmjVYsGABnJ2dC53c379/D3d3d3h4eCAmJgYtW7aEvb09RowYUeISyBVBfHw8AgMDRQRCSEgIiAgyMjLg8Xjo27cvevbsiTZt2qBVq1aFZpAUxKiDjxDwMQFZibGI3jMeMmq1IVuzLrIiXosVA7nJ8YhxmwGugjJU/7QDZWci+fF5yKjVRr0xW8CRkQMHhM76tXFkfDtp/ToY5Uy1EQN502YiEtOR92HEpc2UF3w+H0+fPhXu/5eF+5/P5+Pz58/5VvrBwcHIyckBANSvXz/fSr9Fixa/RfnWqs61a9dga2uLsWPHYt++fcVe9Xbq1Al6eno4duwYsrKyoKioiMOHD2P06NGF3ufu7g57e3u8evUKpqamYttkZGTA2toagYGBuH37Nlq3bl0s236Fx+MJtyA2btyIuXPnSnyvoATyoUOH4OnpCQCwtbXFuHHjYGVlVSWzUVJTU/Hq1SssWbIEDx8+hKGhoUigooGBQb5thsLOkgiNS0GvrT8DQyk3B/zMVMio1EJWTChiDzuJFQMJ13Yh7fVN1J+4G7LqPwM3Mz4H4uvJxdCwmgbV1lbCtjecukK/zu9X2Ks68NuLgdKkzZSVy6sw97+dnR0sLS1L5P6nPCfu5V3p/3ri3q+V+UxMTKpcSdbqwrNnz9CtWzd0794dFy9eLPaExufzhbng8+fPR3p6OpSVlXHs2DEMHz680HtzcnJgYGCADh06FFqjPjk5GX///TciIyNx9+7dEovXrKwsjBo1CufOncOBAwcK9VwURXx8vLAEcmBgIOrWrSssgSzN2gTlhZGRETp27IgDBw4gOzsbQUFB+SoqpqamAgAaNmwocqpjmzZthPU4lnu+xZFH4fm+BwsTA5HbR0JRxwS1+4luT0TvmwRZVS1oD1sD4Of356h2uljex7gMfxOMsuK3FgOlTZtZ0ccYQ4s4vlVSBO5/QfR/VlYWmjVrJsz9L677PykpSWyRHkFgkqKiotgT94o6D55Refj06RM6dOgAXV1d+Pn5lchLExYWBgMDA2HdAMFn9OTJkxgyZEiR9+/ZswdTp07Fu3fvCj2dMj4+Hl26dEF6ejru3buHRo0aFcvO1NRUDBgwAHfu3MHJkyfRr1+/Yt1fGIGBgXBzc8OxY8eQkJCAdu3aCUsgV4WMFklSCvl8vthAxfj4eACAhoYGzMzMEPPnZKRx8p8xUZAYyE2JR/TOsajZfSzU24sGisZ7bUbGh6doNOt/QlFXUwn+c3tI47EZ5cxvm1oojbSZhedfIz41C9N6FJ2+9SsC97+g+E9e9//atWthZ2cnUVpY3hP38rr58564Z2hoKEzdE0z+TZo0qVIn7jFEiY+Ph5WVFVRVVeHl5VXi7ZrAwEAAQKtWPyO9BTUeJH1vjB07FitXrsS6desKLSyjpaUFX19fdO7cGb169cLdu3cl3q9PSEiAjY0N3r17Bx8fH/ToId3JpHXr1ti2bRs2bNgAb29vHDp0CFOnTsWsWbMwYMAAjBs3Dj169Ki0wa+SpBQKDmEyNDQUijxB2q9AIDx9+QapUERxlgK81O8AABmV/J5DGZVa4GemgHJzwJH9GUMUkZCOtKzcShODxZA+Veove/JJRIFCgJ+dIXEELQBsuh6C2ioKGCKBhyAtLQ2+vr7w9vbO5/5fsGCBsHqaOHJzcxEWFpZvpR8WFiY8cU9PTw8mJiYYOXKkcKXfrFmzSplSxSg56enpsLOzw/fv3/HgwYNSFdh5+fIltLW1hRUKBWJAUi+UoqIi5s2bh/nz52PZsmXQ09MrsG3Dhg3h6+uLLl26wMrKCn5+fkWuvKOiomBhYYH4+Hjcvn0bbdq0kezBSoCCggIGDhyIgQMH4suXL8ISyMePH4eurq6wBHJlO3TnypUr6Nixo0ReDD6fj+zsbOTk5CAnJwdycnIwMzODiYkJ2samYopnRLHGptwsAABHJn/AMEdGXthGIAYIwOeENBjXr/weF0bJqDJiIDIxHcs83xZ4nZ+ejB/3T0BGrTbk6jRGVkTRubZLPd+iY1MtsTEEBbn/R44cKaz9n/eLl/KcuJd3pZ/3xL06derAxMQE1tbWwpW+sbHxb3niHkOU3NxcDBs2DK9fv8bt27fRtGnTUvX38uVLkaC+4noGAMDBwQFr167Fhg0bsGvXrkLbCrYkunfvjj59+uDq1asFHn0cHBwsLHl87969ci2TXb9+fSxYsADz58/Hw4cPcfDgQWzZsgUrV65Ep06dMHjwYFhaWkJOTk44sQp+8k62hf1Io11WVhYeP34MbW1tGBsbF9mXYOEgDvl6hqg3Zkuxfk8c2Z8LDeLl5LtGvGyRNgKycwu2gVH1qTJi4L8Lr5FbWJCgigYaTjsiEkFbFLl8wn8XXuPI+HYi7n8vLy+8fPkSMjIy6Nq1K5ydnWFrayt0/3/79g137tzJV6QnJSUFwM8qZiYmJmjbti3GjRsnrMxX0aVWGRWDoJjP5cuX4eXlhT///LPUfQYGBmLYsGHC/8/NzQVQPDGgrKwMJycnrFy5EosXL0b9+vWF9vJ4vHwTWq1atbB3716MGTMGlpaW2LRpE4hIpM27d++wbNkyqKmpYd68eQgICIC/v3+5T7aCn7whUffv38f9+/dL9XuXlZWFnJxckT/y8vL5XlNQUICKigrk5OTw7ds38Pl8dOnSBfXq1StWn7m5uYiPj0dsbCzi4uLwKSkHn4v5HDIqPwOZeamJ+a7xUr+Dq6gq9AoIkJetnNstDOlQJcRAaFwK7obFF9qGIysnfINLCo9PuBsWj6EOs3Db8yTi4uKE7v+FCxeiU6dOwpK8rq6u+U7ck5eXF56417dvX+FqX0dHhwXzVUOICLm5ufkmqi1btmDfvn1YvXo1GjRogGfPnpVq4ktOTkZkZCRev36NadOmIScnB9+//9wDXr9+PQ4cOCBxf9nZ2cjOzhbGogiuF8Xdu3fRrl3BuefJycmYOXOm8P9LOoHKycmhRo0aUFNTK7KdJH0mJibi9u3b8PX1xdevX9GoUSP06dMH/fr1Q4MGDYrsT1qf6zlz5iAoKAgnT54U22dGRgY+fPiA0NBQhISEIDQ0VPjfsbGxwnaamppo2twIaEYipxEWhayqFrhK6siODct3LSsmBPLaolsqHAB6miwd+XemSoiBY48iikwfLCnE5+HJd0VYWlpCR0dHmN6zcOFCkRP39PX1YWJigsmTJwv39fX19atkjnNlg4gqxFUr7XaC1XlBLF68GIsXL5b498LhcMROSIItgeDgYHz58gVycnJCN3JKSgqUlJQgJycHZWVliSbQ27dv4/79+1i8eDE0NDQkmmTv3r2LxYsXY9CgQVixYgVu376NWbNmoX379jh8+DBq1aolbCsrK1upxPGECRPA5/Nx+/ZtuLm54eDBg9i9ezcsLS1hb2+PPn36lHm8zpUrV9CrVy/hRP/rhB8VFSX0aqipqcHAwAAGBgbo1q0bDA0Nhf8vSB3utvEWwhPTi2WDUrOOSHvth9zkb5BV+xkUmvE5ELmJ0VD7q69IWx1NJRY8+JtTJf66t4K/lokQAAAOVwaZmk3hsXc9gJ/BUqamphg8eLDIiXsF7Y9WJHw+v1JPjpK2E0xu0oLL5ZZoBSr4UVRULNYKtKB2r169wtq1a2FlZYU5c+ZAQUGhWCvaglz+W7duxb///ovg4GChGA0NDYWhoSG2bNmC7t27F+v35ejoCD09PWRmZmLq1KkS3dOlSxfUrVsX48ePR2pqKq5du4ZBgwbBw8OjSgS+crlc/P333/j777/h6uqKU6dOwc3NDYMHDxaWQB43bhzMzMxKNQ6Px0N4eLjIhP/q1Su8f/8eISEhcHd3BwDUqFFDOMGPGDFCZMKvU6dOkWKqR7M6InUGkp95gZ+ZJtwGyAh7jNyUn95VtT/swFVUhnqHwUh/fx9xx/+D6p99QDk/g7DlautBxbSXsG/i89C+EYtr+t2p9GIgNSsXEcVUvMVFrlY9HD99Di0MmqBGjRoiE1VGRgYePXpUYRNpYW0KCyoqCTIyMiWaPAU/SkpKpZ5ApdGuMqSSPXnyBGPHjkXv3r1x/vx5qXqQAgMDYWJiItJnSQIIBWhpaWHKlCnYsWOH8NRCSRg3bhwuXLgAb29vtG/fHsePH6+Saa/q6upwcHCAg4MD3r17JyyB7OrqilatWglLIBdUAZDP5yM6OjrfCj80NBQfPnwQbrvIy8ujadOmwu2GLVu2oGXLljAwMED9+vVL9b4d0U4H7g8+C/8/+dEF8JK/Cv8/PSQACAkAAKgY9wBXURmyarWhPdwZ3/0OIMnfHRyuLGro/4Vaf48XiRfgcGXQWiWlxLYxqgaVXgyEJ6ShbHwCeeFgzLS5yPn6qUR3iwsqknQSU1RUhKqqaoVPoLKyspViEv0d+PDhA3r37g1TU1OcPHlS6ltJL1++xB9//CHyWnFTC39l9uzZ2LFjB3bu3IlFixYV2Z6IsHDhQnh7e6Nz5864d+8eDh48CAcHhxKNX1lo0aIF1q9fjzVr1uDatWtwc3PDvHnzMHfuXFhYWKBr167Q0NAQ7ueHhoYiLCwMGRkZAH6KscaNG8PAwAAWFhYiK3wdHR3IyMigT58+qFWrlkhMRWmJC30JTtx78GsbgMOVQcOphyS6T762LrSHrCrwugwHSPv0Akk6mgBY0aHfmUovBsornWW76y4YahY9if460Va2/VBGxfLt2zdh3Qlvb28oKUm39LUgpmX8+PEir5fGMwAA9erVw4QJE+Di4oKZM2cWelBObm4uJk+ejIMHDwrbz5gxA5MnT4a6urpEFRArKwkJCSJ797KysmjRogWCg4Nx5coVXLlyBcDPfXxjY2N07twZ48aNE074jRs3hpxcwYd9ZWVl4ebNm1i6dKlU7E1NTcV///0HV1dX/NndEkn1WyCbJ53l08+A2BwovDyPIC3pHFbFqLxUejFQXuksi/9biKYaCtDX14eBgYHw3wYNGkBTU7NcbGBUbdLS0mBra4uUlBQEBAQUerBMSXn//j2ys7OFlQcFlCS18Ffmz5+PvXv3Yu/evZgzZ47YNpmZmRg+fDg8PT3h4eGBUaNGAQC2bduGpKQkjBw5EmpqarC2ti6xHWVNcnKyyISf162fmPi/VLv69evDwMAAbdu2Fe7j5+bmws/PD6dOncKDBw9ARGjdujU6d+4sUfGgO3fuID09XSq/nxs3bmDixImIi4vDli1bMH36dJx5Ho2F54uusSIJHA4H2tF38PjdC1xI/or169dLXdwyKg+VXgzoaSqDA5TxVgFh+tihCP/w84vh5s2biIuLE16tVatWPpEg+FdDQ4N5BhjIzc3FkCFDEBQUBH9/fzRp0qRMxnn58iUAoGXLliKvl3abAAB0dHQwevRobNq0CY6OjlBUVBS5npycjH79+uHBgwe4ePEibG1thde4XC4OHTqEHz9+YODAgbh27Rq6dOlSYltKS3p6OsLCwsRO+nk/21paWjA0NETz5s1hZ2cndOvr6+sX6B0ZNGgQXFxc4OXlBTc3N0yZMkVYAtne3r7QEsg+Pj5o0KBBgadFSsKPHz8wd+5cHDhwAN27d8eNGzeERayG/qWDL4mp2H77E0DFSzf8lXkWzTC1uw1svr/H1atX0aZNGxw9elQqdTIYlY9KLwaUFWSho6EkUdqMJBG04tDVVMayuaInd6WkpCAsLEz4hSL418/PTyTPt2bNmmJFAhMK1QciwpQpU3Dt2jVcvny5TEvvBgYGonHjxvlWoaXdJhCwcOFCuLu7C+v8C/j27Rusra0RFhaG69evi53o5eTkcPr0aVhbW8PW1ha3b98udTR+YWRlZeHjx49iJ3zBGR/AzwBBwSTfs2dPkX18SYMlf0VBQQGDBg3CoEGDEB0dLSyBfOzYsUJLIPv4+MDa2rrE3wuXL1/GpEmTkJycjD179mDixIn5hMe7sy5IeRkLTYsp4BFKdJjbyj7GwlLtY8eOxdWrV6GoqIgOHTpg6dKl+Pfff1la9W9GlTi1sKDjOX8latc4kQjavDSYfBCyNbXzX+Dz0Embj8MzbCV+c6ekpAgDiH4VC5IIBX19fWhqajKh8JuwYsUKLF++HIcPH8bo0aPLdCxzc3Ooqanh/PnzIq/fu3cPXbp0QVBQUKmP8h0+fDju37+PsLAwyMnJISIiAr169cKPHz9w7dq1fFsUv5KSkoKePXvi8+fPuHv3bqGnIhZFbm4uPn/+LHbCDw8PF2bUKCkpiUzyBgYGwv/X0tIql88aEeHBgwdwc3PDqVOnkJKSgh49esDe3h4DBw7E169f0bhxY5w7dw4DBgwoVt8JCQmYNWsWjh49CktLS+zbtw86OvnPVTlz5gwGDx6MAwcOwKL/MKkc8/769Wu0bNkSt27dgp+fH9asWYO2bdviyJEj0NfXL9ZzMMqf3+oI49C4FPTaeqfM+o/ePxkNVGQwc+ZMjB8/vlTPmJqaKtajEBYWhpiYGGG7mjVrFrj1wIRC1eHAgQOYOHEi1q5di3///bdMxyIi1K5dG9OnT8eyZctErvn7+6N79+4IDg4u9VkAb968gampKQ4dOoR27drBwsIC8vLy8PX1lfhMhYSEBHTt2hUpKSm4d++e2IlLAJ/PR2RkpMjevWDS//jxozAeQkFBAU2bNhWZ9AX/Xa9evUr1mUlLS8P58+fh5uaGW7duQVVVFaampnj06BESEhKKdcTyuXPnMHXqVGRnZ2Pr1q0YPXq02GcNDw9Hq1atYGFhgVOnTgnbhMal4NijCFx+8RlfM0jkXiJCbUXAtk1jjGyvA/06+esJZGVlQUlJCbt374aDgwMePHiAUaNGISYmBi4uLpg4cWKl+t0zRPmtxAAAjDr4CAEfE6RbfIjPg0kdeaz6WxtbtmzByZMnoaSkhIkTJ2LGjBmFfoGVhNTU1AI9CnmFgrq6eoEehfJa5TCKxtvbG/369YODgwN27txZ5n+X6OhoNGzYEBcuXEC/fv1Ervn5+aFnz5748OGDVOIV+vfvj2fPniEtLQ0NGjTAtWvXUK9evWLb27lzZ8jLy+POnTvg8/n5Ku0JcvEzMzMB/Ix5aNy4sdgJv2HDhlWyjsGnT5/g7u6ODRs2IDMzE82aNYO9vT1GjRolPA9CHHFxcXB0dMS5c+fQt29f7N69u8C/QW5uLrp3746oqCgEBgaK3f5wc3PD+ElT8Tw0CsThQl6Wi97d2qK/rQ1cXFwKfYZmzZrB2toaW7duBfDzu2zOnDnYt28fbG1tceDAAeEJmozKxW8nBiIT02Hu4o8saaYa8nIQvX8KZowbjtWrVyMxMRE7duzA3r17kZKSgn/++Qdz5swpl4AZgVD4VSSIEwoFeRSYUCg5aVm5+JyQhuxcPuRludDTVC60/Orjx4/Ro0cPWFhY4OzZs+UySV25cgW9e/fGp0+f8h057OvrCwsLC3z+/Bm6urqlHmvnzp2YNm0aDA0N8fDhQ9SqVfS5H0SEhIQEkQn/+fPn8PX1BZ/PF7r0ORwOdHV1xbr1dXV1C03Nq6pkZmZCU1MTI0aMQHp6Os6dO4fs7GxYWVnB3t4ednZ2wsqNRIRjx45h5syZ4HK5cHV1xeDBgwv9bC9fvhyrVq3CnTt30KmT+DTANWvWYOvWrfj27ZvwtbFjx+LVq1d4/vx5ofb3798faWlpuH79usjrXl5ewvLO+/fvzydSGRWPpPN3lYkAaaShhBV9jKWWNgMAzgPNEF1nDhYvXowrV67A3d0d69atw+LFi+Hm5oatW7fir7/+QpcuXTBnzhzY2tqW2Ze+iooKWrVqJXY/Ni0tTezWw507d/DlyxdhOyYUiofAfXor+CsiEtNFMlY4AHQ0lNCjWR2MaKcDA+3/uU/DwsLQu3dvtG7dulyr7gUGBkJdXV3sZC+N1EIBZ86cgZOTE7S0tCArK5vPpZ2UlCTi0s+7yk9KShK2a9CgAQwMDNCvXz9cvnwZenp6OHr0KIyNjatEyWJpcvfuXaSnp2P69OkwNTXFzp07hSWQ//nnH2hoaGDEiBGwsbGBq6srLl++jKFDh2L79u2oXbt2kX2vWrUKy5YtK1AIAEBMTEw+z0LXrl3h4eGBHz9+FLp1YWRkhMOHD+d73c7ODq9fv8bEiRPRv39/jBs3Dlu3bmXHsldBqoxnQIDrrVBsuh5S4vuJfu6ZzbNoBsceP4NfgoKCMGbMGDx//hwLFizAsmXLoKCgAB6Ph0uXLmHz5s0ICAiAvr4+nJycMGbMGCgrV44TvNLS0grcesgrFASHnYgTC7Vr165WQiEyMb3EgVXyOSno2LEj5OTkcP/+/XKtQTFkyBDExsbC398/3zVvb2/Y2dkhJiYGdevWLfEYe/fuxZQpU/DPP/+gV69emDhxIkaMGAE5OTnhhJ93ZVmnTh0RV77gv5s2bSryGXn48CHMzc3RpUsXXLp0CfLy8iW2sSoye/ZsnD59GpGRkfk+a+/evcOhQ4ewb98+JCcnQ1ZWFmPGjMG6deuKrFXx/ft3tGrVCnp6erh161ahYnDAgAFIS0vDtWvXhK99+PAB+vr68Pb2Ru/evQu899ixYxg5ciSSkpLEigYigpubG2bOnInatWvjyJEjhQoTRvnx220T5OXkkwgs83yLXD4VK4aA+Dxw+Dyk3nFDwJFNIoFWubm5WLduHVauXInmzZvDw8MDrVu3Fl5/+PAhtmzZgnPnzqFmzZqYPHkypk2bVux91PJEIBTEBTNGR0cL26mpqRXoUfjdhEJJ3zuClCu5VxeR8NgTDx48yOeqL2uaNWsGS0tLbN++Pd+1S5cuoV+/fvj69WuRK0kBmZmZ+PjxI0JCQhASEoIzZ87g6dOnUFZWRlpamrCdjIwM/vjjj3xufQMDg2IFwt24cQO9e/dGv379quw5BiWlRYsW6Ny5M/bv35/v2qdPnzBx4kTcvHkT5ubmUFRUFE7Yffr0gb29PSwtLfNlOxER/vnnH/j5+SEwMLDIGKcOHTqgefPmcHNzE+mjYcOGGDlyJNavX1/gvS9evECbNm3w4MEDtG/fvsB2Hz9+xKhRo/Dw4UMsWLAAy5cvr3bCr7LxW4sBoGSrO135dARsm456avKoWbMmHj58mK+iVmBgIMaMGYOgoCAsXboUCxcuFNnD/Pz5M7Zt24YDBw4gKysLw4cPx+zZs/MVganspKWlCXO088YnFCQUxNVRqGpCobReJUERlxGmalgzvHwL6qSlpUFVVRUHDhzAuHHj8l0/d+4cBg0ahISEBOGxtgCQk5ODz58/56u0FxISgoiICOExuXJycsjJyYGxsTH69esnnPi/fPmCQYMG4erVq7C0tCz1c5w/fx7//PMPxo8fj71791ap909J+fTpE5o0aZIvpZDP52PXrl1YuHAhNDQ0sH//fuHv+Nu3bzh+/DgOHTqEV69eoV69ehg1ahTs7e3RvHlzAMD+/fvh4OAgcaqinp4ehg8fjrVr14q8PmzYMHz+/BkPHjwo8N709HSoqKgU+P7LC4/Hw4YNG7B06VKYmJgIt4YYFcNvLwYECPd9Q74iIkHMvq+mEnoY1sHI9jporKmEjh07IiEhAdHR0RgyZAjc3NzyfSFlZ2dj5cqVWLduHVq3bo3Dhw/nezP/+PED+/fvx7Zt2xAVFQVzc3PMmTMHlpaWVf4LTpxQEPybVyioqqoWuPUgybGr5cnJJxFSjTdZP8BUWJSlPHj48CE6dOiAp0+fij2kaPfu3Zg+fTo2bdokTNMLCQnBp0+fhAWJFBUVhX8jwWTfuHFj7NmzB2fPnoWrq2u+I4yJCO3bt4eCggLu3JFOeq+7uzvs7e0xf/78Qlejvwu7du3CzJkzkZCQIPz+DAkJwfjx43Hv3j1MmTIF69atE/vdSkR48eIF3NzccPz4cSQmJqJ9+/awsrLC+vXrMWrUKOzdu7dIG4gIioqK2Lx5M6ZNmyZybc+ePZg+fTqSkpIK3f5s2rQp+vfvj02bNkn03M+fP8fIkSPx8eNHrF+/HtOnT2eHoVUA1UYM5EWSiPBXr16hTZs26NevH86dO4f9+/djwoQJYvt7/PgxxowZg48fP2L16tWYPXt2PtdmTk4Ozp49i82bN+PZs2cwMjLC7NmzMWLEiHzlXH8H0tPTC9x6yFv1TVVVtcCth/IWCkVlouQkRiPp7lFkRQWBn5EKGbXaUDbqBrV2/cGVE/83VJDl4oZTN5HiLGXJnj174OjoiCtXriA8PFxkhf/hwwdkZ2cD+LnCb9KkSb59fEFqXt4v44yMDAwZMgQ+Pj7w8PDAsGHDxI7t5eWFPn36wN/fH127dpXK82zbtg2zZs2Cs7MzFi5cWPQNVRg7Ozukpqbi1q1byM3NhYuLC5YuXYoGDRoISwpLQlZWFjw9PXHgwAFcv34dHA4HQ4YMwcSJE9G9e/dCJ9qEhARoaWnh7NmzGDhwoMi1oKAgGBsbw9fXF+bm5oU+B4/HEx7WJAkZGRn4999/sW3bNvTs2RPu7u5o2LChxPczSk+1FAOSsnDhQmzduhX9+vXDxYsX8eDBgwLLpmZkZGDJkiXYsmULOnToAHd3dxgYGORrR0S4e/cuNm/eDC8vL9SuXRuOjo6YMmWKxHu4VZ309PQCPQrihII4saCtrS11oVBYjYrc5G+IOTgNHAVlqJpZg1tDFVnR75H2+gZq6LdDnUFLxPYpw+WgYxNNHBnfTmp2EhG+ffuWr9JeSEgIgoKChBkDXC4Xenp6IgF7ERER2LRpE1JSUgo9cVDAjx8/YGdnh6dPn+L8+fOwsrIq1K7WrVujbt26IsFnpWX58uVYsWIFdu3ahSlTpkit38qEIKVw2bJlsLGxwbhx4/D06VM4OTlh1apVJTr4Z+bMmdi7dy8mTZoEHx8fhIaGQk9PT1gCWVwsi6CQ1P3799GxY0eRa0SEOnXqYPLkyVi1quDjjBcsWIBTp07h8+fPxbb5xo0bGDt2LNLS0rB7924MHTq02H0wSgYTA4WQnp4OU1NTNGzYECkpKfjx4weePXtWaJ3ye/fuYezYsfjy5QvWr18PR0fHApV4SEgItm7dCnd3dxARRo8eDScnJ+FeX3UkIyOjwDoKeYWCiopKgR6FkgiFoqpX/gg4jaQ7Hqg3fifka/8vZS/eewvS3vih4ayTkFEseHK94dRVbNW2wvj+/bvYCT80NBTJycnCdo0aNRJO+FevXoWuri727t2LJk2a5AvKErjes7Ozi8zTj42NhZWVFSIiInD58mV06NChSJtPnz6NIUOG4NGjR2jbtm2xnrcgiAizZs3Cjh07cOzYsQI9E1UZQf0HR0dH7Nu3D02bNsWhQ4ck+p2LQ5A1sn37dkyfPh1EhICAAGEJ5NTUVPz999+wt7fHgAEDhGLj+vXrsLS0FFujAgAGDhyI+Ph4sZkqAg4fPoyxY8dKLDh/JTExEVOnTsWpU6cwbNgw7Ny5U6L6FYzSwcRAEQg+pOvXr4ezszO6du2KixcvFjrZpKWlYcGCBdi5cyd69OiBQ4cOFRpRnpCQgD179sDV1RWxsbHo3bs35syZg+7du1eq/fSKpiChEBYWhsjISGG7kgiFos61+H7bHckPz6LhjGOQUVIXff3ReTRyOg2uvPitAhkuB6Pa6WJ5n/zBUampqWKPyA0JCUFCQoKwXd26dfNV2jMwMEDTpk2FX+R8Ph9qampYtmwZ5s2bJ9aWgwcPYsKECeDxeIW6iz99+oRevXohPT0d169fh4mJSYFt88Lj8WBsbIxmzZrh0qVLEt0jCXw+H+PGjcOxY8dw8eLFQtPbqiIjRozAmTNnwOfzsWDBAixZsqTE24cxMTFo2bIl2rdvD09Pz3zv97S0NJw7dw5ubm64ffs21NTUMGTIENjb2yM4OBj29vbIyMgQO/727dsxf/58JCUlFWjfkydP0LZtWzx58qRUhdhOnDiBKVOmQEVFBYcPH0bPnj1L3BejaJgYkIBRo0bh8uXL2LZtG0aPHo3169dj/vz5Rd538+ZNjBs3DomJidiyZQsmTJhQ6OSelZWFEydOYMuWLXj9+jXMzMwwe/ZsDB48mKXdFEFGRkaBWw/ihMKvImHh/UxE/8guuP+Pz/D19DLU0G+Hml1G/P82wTskXHWFimkvaJhPLNS+eiqymG+Unm+Vn/fAKk1NTbEH6Ojr60v0eQoNDYWhoSGuXbsGCwsLsW327duHyZMnC6v8ieP169ewtLSEsrIyrl+/nu9EvaIQrAxfvnwp1eyZ3Nxc/PPPP7h69SquXr2Kbt26Sa3viiIzMxMrV66Es7MzNDQ04OvrW6rTLPl8PiwtLfH27Vu8fPmyyK3Hjx8/4vDhw3B3d0dERARq164tPDdFXAnkwMBAmJmZFRoXkpqaClVVVakcyBUZGYmxY8fCz88Ps2bNwtq1a1GjRo1S9ckQDxMDEvDt2zc0b94c1tbWaNSoETZu3IibN29K9GWUnJyM2bNn4+DBg7CyssKBAwfQoEGDQu8hIty4cQNbtmzB1atXUb9+fcyYMQMODg7MXVYCBEKhQI+CnCIaOZ0u0guTdP8kkh+cAeVmCV9T6zgEtbqOKtIGIkLkln+goigntp6+4Cjr0nD27Fn8888/iI2NLbD+uyBiPScnR+z1gIAA9O7dG3p6erh69WqJ6sjn5OTA0NAQ7dq1w8mTJ4t9f2FkZmaid+/eePLkCW7dupUvY6Iq8eDBA4wbNw4fPnxATk4OTp06hcGDB5eqzw0bNmDhwoXw9fUt1kqaz+fDz88Pjo6OCA0NBYfDgZWVFcaNGwc7OzvhYoTH40FTUxNz587F4sWLC+xPT08PQ4cOxbp160r1PALbtm/fjoULF6Jp06Y4evRomR55XV2ReP4mCfjx4wcBoB8/fkjSvErh7u5OAOjy5cvUvXt3qlu3Ln358kXi+y9fvkz16tWjmjVrkoeHB/H5fInue/PmDY0fP57k5eVJWVmZpk+fTmFhYSV9DMYvpKenk+fd56S70LvIH03bOaTYuA1pWE2j2v3/I+WWvQjgUK1ekyS6/86rjxL/3UvCokWLqG7duoW22b59OykqKoq9duXKFapRowZ17dqVkpKSSmXL7t27icPh0Pv370vVjziSk5Opbdu2pKWlRe/evZN6/2VNWloaOTk5EYfDob/++osWLVpEsrKypf7efPToEcnKytKCBQtK3MegQYOoe/futGfPHmrXrh0BIE1NTZoxYwa9ePGCiIhsbW3J3Ny80H6sra3Jzs6uxHaI482bN9S6dWuSk5MjZ2dnys3NlWr/1R1J5+9qn/Q5evRo/P3333B0dMTBgwfB4XAwbNgwYeR2UdjY2ODNmzfo3bs3Ro8ejf79+yMuLq7I+4yNjXHgwAFERERg9uzZOH78OAwMDDBw4EDcv39fWAyGUTJq1KiBhjp6RbZLC/JH4lVXaFrPgGprKyg16wgtm5lQNu2JpNvu4GUkF9mHinrNMo0BefnypdgzK/LC4/HEVvQ7ceIE+vTpA3Nzc1y9erVYFQPFMXbsWNSrV08qK8NfUVVVhY+PD7S1tdGrVy+Eh4dLfYyy4vbt22jZsiV2796NDRs2ICAgAIGBgejcuXOpvKkpKSkYPnw4zMzMCo30L4ovX75AR0cHkyZNwsOHD/H27VuMGzcOp06dgpmZGczMzMDlchEQEFCgdwn4eUZBUFBQie0Qh7GxMR49eoQ5c+bgv//+Q7du3fDx40epjsEommovBjgcDvbs2YOYmBjs2bMHJ0+exL179wp1lf2KhoYGjh49ivPnzyMgIADGxsY4c+aMRPdqa2tj5cqViIyMxJ49e/D27Vt07twZHTp0wJkzZyQWJYz8yMsW/fZOeX4F8tpNIKsmWgNeSb8tKCcL2XFFfyn17N4NxsbGsLKywoQJE7BixQocPHgQ169fR1BQEFJSUkr8DMBPMZC3NLY4cnNz84kBV1dXjBgxAiNGjMD58+elsierqKiIuXPn4siRIyVKMSsKDQ0NXL9+HfLy8jA3N5dIWFckKSkpmDp1Knr06IF69erh5cuXmDt3LnJzc+Hn5wdra+tS9e/o6IivX7/ixIkTpTrN8ddDioyMjLBhwwZERkbC09MTjRs3xuXLl5Geng5LS0tcuXJF7HePkZERPn78iIyMjBLbIg55eXk4OzvD398f0dHRaNWqFQ4dOsQWReVItRcDAGBgYIClS5diy5YtUFNTg7OzM9avXw9PT89i9dO/f3+8ffsW3bt3x+DBgzF06FCRyPHCqFGjBhwcHBAUFARvb28oKSlh8ODBMDAwwNatW0VSzhiSoaepjKLW67z0JBDlD7oj/s+qfRD8WyCEOZNGo2fPnqhRowZevnyJ3bt3Y8KECbC0tISxsTHU1NSgrq4OExOTYguGxMREREZGSuQZENSuJyKsWLEC06dPh5OTEw4dOpSvrn1pEMS4bNiwQWp95qV+/fq4ceMG0tLSYGFhge/fv5fJOKXl2rVrMDExgYeHB3bs2AF/f3/heSd37txBRkYGbGxsStz/0aNHceTIEezatQtNmzYtcT9EhC9fvog9R0VOTg52dnY4f/48IiIiIC8vj3fv3qF3797Q0dHBwoULERwcLGxvZGQEIhJ5TZp06dIFL1++xODBgzF+/HgMGDBA5GAsRtnBxMD/M3fuXLRo0QITJ06Ek5MT+vXrh9GjRxfbXVW7dm2cOXMGx48fx/Xr12FsbFwsUcHlctG7d2/4+fnh2bNn6Ny5M+bNm4dGjRph7ty5iIiIKO6jVVuUFWShU0SFQLla9ZEd9wE5idEir6cF+QMcLuRq6xV6v2zGdyjIANOmTcOFCxfw5MkTxMbGIisrCx8/fsSdO3dw/PhxLFq0CH///bfEgmHixIlYsWKF0B2vqqpaqIdBsE3A5/MxY8YMLF++HGvXrsWmTZukXgJWWVlZGDyb92RMadK4cWP4+voiKioKvXv3Fjk4qaL5/v077O3tYWVlBQMDA7x+/RrTpk0T+T37+PigYcOGJa7J/+HDB0yZMgUjR47EyJEjS2VvUlISsrKyxGYR5KV+/fro1q0b2rRpg2fPnmHgwIHYt28fmjdvjo4dO2L//v3CIGlpbxXkRU1NDQcPHsT58+dx7949mJiY4PLly2U2HuMn1Tqb4FcePHiATp06wcXFBWPGjMGff/4JNTU1BAQElCg3+MuXL3BwcMDly5cxZswYbN26tdDCRgURFRUFV1dX7N27FykpKRg8eDBmz55dqlzf6kJRdQYyI94g7sR/4NZQg+ofvSFTQw3pYY+R+fEZVFpZQNN6RoF9c0DQSHiDoCMrkJmZCUNDQ/Tp0wd2dnbo2LFjkavx7OxsREdHIyoqCpGRkWL//dVNrq6ujoYNG6Jhw4Zo1KiR8F9/f39cvnwZPXr0wLlz57Bnzx44ODgU/xcmIT9+/ICuri7GjRuHLVu2lNk4jx8/Rs+ePdGxY0d4enpCQUGhzMaShEuXLmHy5MlIT0/H5s2bMX78eLHxIs2bN0fXrl2xb9++Yo+Rk5ODzp07Iz4+Hi9evCj1d66g3PDdu3fRuXPnQtuuWbMGGzZsQGJiImRkZJCZmQlPT0+4ubnh+vXrUFBQAIfDQf/+/eHh4VHmZw3ExsZiwoQJuHz5MiZNmoRNmzaVqOBRdYalFpYQR0dHHD58GEFBQcJDQUaPHl2iDzXw00Xn7u6OmTNnQl1dHQcPHiwwV7woUlNT4ebmBhcXF3z69Aldu3bF7NmzYWdnxw4AKYCiKhACQNaXYCTdO46cuI/gZaRAtqY2VEx6Qq39QHC4hR+zu/RPDoZYdcPNmzfh5eUFb29vxMbGQkNDAzY2NujTpw8sLS1L/LkZNWoUXr58iZ07d0osGJSUlNC4cWMRsfCrgFBVLV7VRLHPvnQpNm/ejM+fP5dpyW0/Pz/Y2NjAzs4OJ0+erJCjj799+4YZM2bg5MmT6N27N/bs2VNgjf2PHz+iadOmOH/+PPr371/ssf79919s2rQJ9+/fl0q1xxs3bqBXr1748OEDmjRpUmjbu3fvomvXrnj+/Hm+NL/o6Gh4eHhg9erVSE9Ph56eHsaOHYsxY8aU6XHeRIR9+/Zh9uzZqF+/Po4cOVLoMcoMUZgYKCE/fvyAkZER2rRpA09PTxw6dAgTJkyAu7s7xowZU+J+IyIiMH78eNy4cQOTJk3Cxo0bS/yFzOPxcOnSJWzevBkBAQEwMDDArFmzMHbs2BLVOv/dKexsgpLC5QByiR8RsncGOnTogFWrVuHvv/8GEeHp06fw8vKCp6cnXr16BTk5OXTv3h12dnaws7Mr1henmZkZ/vzzT+zfv7/ANrGxsTAzM0NcXBwWLlwIdXV1REVFSeRh+FUw5P23qBVYQkICdHV1MXPmTKxZs0biZyoJly5dwsCBAzF27Fjs37+/3Cp4EhFOnz6NadOmCfPihw8fXuj4O3fuxKxZs0ROKZSUmzdvolevXnB2dsaCBQtKaz4A4MiRIxg9ejTS09OLDCLNysqCuro61q1bh1mzZoltM3PmTFy8eBHm5uY4ffp0gSWQpU1oaChGjRqFJ0+eYNGiRViyZEmpgiqrC0wMlIILFy5gwIABOHPmDAYNGoRx48bh5MmTePToEUxNTUvcLxFhz549mDt3LrS1teHm5lbqamsPHz7Eli1bcO7cOdSsWRNTpkyBo6Oj2GCh6kpRpxaWBAVZLnxndcW7p/ewZMkSPHnyBF27dsWqVatEKriFh4fDy8sLXl5euHXrFnJycmBqaircTvjrr78K9OpkZ2dDRUUFW7ZsyXfsrIAvX77A0tISHz58QK1atUSOmM5LVlYWvnz5UqB3ITIyEl+/fhW5R11dXaxXIe+/K1aswL59+xAeHl6iLbDi4OHhgTFjxmDOnDnYuHFjmQuCmJgYTJ06FRcvXsSgQYPg6uoqUbEmW1tbpKenw8/Pr1jjffv2Da1atYKRkRGuX78uNW/fhg0bsHbtWiQlJUnUvnv37tDQ0MD58+fFXt+3bx+mTp2KtLQ05Obm4uzZs3Bzc4O/vz/U1NQwdOhQ2Nvbo127dlL/G+Xm5sLZ2RkrVqyAmZkZjh49imbNmkl1jN8NJgZKSf/+/fHw4UO8e/cO8vLy6NChAzIyMvD06dNS/w4+fPgAe3t73L17FzNnzsTatWtLraY/f/6Mbdu24cCBA8jOzsbw4cPh5OQk1bKxVZmTTyKw8PxrqfW3foAphvylA+CnyPP29sbSpUsRGBgIc3NzrFq1Kp8rMzk5GdevX4enpycuX76MxMREaGtrw9bWVlgLIO/74NWrV2jVqlWBe71hYWGwsLBATk4OevXqhXv37iEkJKTEz5SVlSWMYZBUMKipqSElJQX6+vro3r27WNEgzT3eHTt2YMaMGVi9ejUWLVoktX7zQkQ4fPgwnJycIC8vj507d2LQoEES3ZuZmQkNDQ2sWLGiwHMkChqzb9++CAgIwKtXr4oM9isOs2bNEmatSMLSpUuxa9cufP36VawguXfvHrp06YLXr1+LnG3x4cMHHD58GIcPH0ZERASaN28Oe3t7jBo1SuqLkydPnmDkyJGIjIzExo0bMXXqVHbeSwGwCoSlJDIyklRVVWnSpElERBQSEkJqamo0aNAgqVSb4/F4tGXLFlJUVCRDQ0N68OBBqfskIvr+/Ttt3LiRGjZsSADI3NycfHx8yrRCXlVhh1+IRBUFC/xZ4EW6C73J1S9UbP88Ho/OnTtHJiYmBIBsbGzo6dOnYtvm5OTQnTt3aN68edSsWTMCQIqKimRra0t79+6l6OhoOnz4cIGfuxcvXpC2tjY1a9aMwsPDycnJiVq0aCHV35c4MjMz6cOHD+Tv709Hjx6ldevWkampKcnJyVHr1q2pTp06BEDkp2bNmmRiYkJWVlY0ceJEWrFiBR06dIiuX79O7969o5SUlGLZsHLlSgJArq6uUn++8PBwsrS0JAA0cuRIio+PL9b9165dIwD0+vXrYt23Y8cOAkBeXl7Fuk8SBg8eTH///bfE7W/cuEEA6M2bN2Kvx8fHEwA6efKk2Os8Ho98fX1p+PDhpKioSDIyMtS7d286e/YsZWVllegZxJGWlkaOjo4EgCwtLSk6Olpqff9OSDp/MzFQCIIP6N27d4mI6Ny5cwSAXFxcpDbGu3fvqG3btsTlcmnBggWUmZkplX6zs7Pp+PHj9McffxAAMjIyogMHDlBGRoZU+q+qnHgcTk3/9SSdeReLJQQa/+tNOnPO0aAFW4ocg8fj0cmTJ6l58+YEgPr27UsvX74s9J7g4GDatGkTde3albhcLgEgbW1tqlWrFr148UJEzPn7+5Oamhr98ccf9PXrVyIimjFjBpmYmJTul1NCwsPDSVZWljZt2kRERBkZGfkEg6OjI/Xt25fatGlTqGCwtramiRMn0sqVK+nQoUPk6+ubTzDw+XxycnIiAHTkyBGpPAOPx6Pdu3eTiooKNWjQgLy9vUvUz8yZM6lhw4bFEt8vX74kBQUFmj59eonGLIrOnTvTyJEjJW6fmppKsrKytGvXrgLbaGtr09KlS4vs6/v377R7925q27YtASAtLS2aOXMmBQYGSmxPUfj4+FDdunVJQ0ODzpw5I7V+fxeYGJACubm51K5dO2rRooVwkp49ezbJysrS/fv3pTZOTk4OrV27luTk5MjY2LjA1WRJ4PP55O/vT3369CEOh0N16tShFStWCCeR6kZCQgJp6TWj1k4HSXehNzX573KhIkBwfeSBh7Ro7RbicDh08+ZNicbKzc0lDw8Patq0KQGgf/75h96+fVvkffHx8XTkyBGqU6cOycrKEgBq1KgRTZ06lZYvX06Kior0999/U3JysvAeR0dHatWqVUl/LaVm/PjxVLduXYnFpkAw3L59m44ePUrOzs7k6OhIffr0kUgwTJgwgczMzIjD4dCKFSvo3bt3lJqaWiLbw8LCqHv37gSAJk6cWKrzGwwNDWnixIkSt09LS6MWLVpQy5Yty0yoN23alObNm1esezp06EBDhgwp8HqPHj1o0KBBxerzzZs3NHfuXNLW1iYAZGZmRtu3by+290Uc3759o4EDBxIAGjVqVKnP4PidYGJASrx8+ZJkZWVp5cqVRPRzxd2pUydq0KABxcXFSX2s1q1bk4yMDC1btoyys7Ol2n9wcDBNmTKFatSoQYqKiuTg4FAlD4QpDdOmTSM1NTWKjY2lkNhkWnbpDXXd6Ed6v4gAvYXe1HWjHy279IZC435Oujwej/7++2+qX79+sb7AsrOz6cCBA6Srq0scDodGjBhBwcHBhd7D5/NJU1OTFi9eTL6+vjR9+nTS0tIiACQjI0P9+vUjd3d3oaibNGkStWnTpuS/mFISGhpKXC6Xdu7cKbU+ixIMtWvXFisYTE1NC/Qw5BUMubm55OLiQjVq1CA9PT3y9fUtlb0fPnwgAHThwgWJ75k0aRLVqFFDIpFYEvh8PikpKdGWLUV7tPKyYMECqlevXoEeDkdHRzIyMiqRTdnZ2eTp6Un9+vUjWVlZkpeXp0GDBtGVK1dKdUgRn88nDw8PUlNTIx0dHbp9+3aJ+/qdYGJAiixcuJDk5eWFJ7VFRUVRnTp1yNzcXOonbGVlZdHSpUtJRkaGzMzM6NWrV1Ltn+jnynP16tVUt25dAkC2trbk5+f328cVvHr1irhcLm3evDnftdTMHHoTnUTPwxPpTXQSpWbmiO0jKiqKNDQ0qF+/fsX+fWVlZdHu3bupQYMGJCMjQ2PHjqWPHz8WOA4AunjxIhERubi4EADq378/rVq1itq1a0ccDoe4XC516tSJ/vrrLzI1Na3Qv+Hw4cNJR0dHqvvCRZGUlESdOnWiGjVq0MqVKyUWDIaGhlSzZk0CQO3ataPdu3eTr68vvX//vsQeBldXV5KTkxPx2BSGYNtx7969JRpPEpKSkgrd3y+IK1euEAAKCQkRe33nzp0kKytb6gVLXFwcbdmyhUxNTQkA1a9fnxYuXFikWC6Mz58/U9euXYnD4dDcuXOltvVaVWFiQIqkp6dT06ZNqVu3bsIv2xs3bhCXy6UlS5aUyZhPnjwhIyMjkpeXJ2dnZ8rJET85lYbMzExyc3MTfhDNzMzoyJEj5fplXl7w+Xzq3r07NWvWrNTPd+HChVJ9iWdkZNC2bdtIW1ubZGVlycHBgSIiIkTaeHt7EwD6+PEjLVq0iADQggULRCb7mJgYOnDgAPXt25dkZGQIAOnr65OTkxPdunVL6p6lonj9+jUBoIMHD5bruCkpKdS+fXvS0NAQu8LOyMigsLAwun37Nrm7u5OlpSVxuVxSVlYmAwMDsYKhVq1aQg+Dg4MDrVy5ktzc3AoVDL1796YePXpIZHNERATVqlWLBgwYUKYC7t27dwSA/P39i3VfUlIScblcOnDggNjrt27dIgAUFBQkDTOJz+fT06dPydHRkWrVqkUAqGPHjrR///4SzTu5ubm0ceNGkpeXJ1NT0yJjdn5nmBiQMr6+vvm+6FavXk0A6MqVK2UyZkZGBs2fP584HA61a9euTM6QJ/r5Qbx+/bowirpBgwa0bt06SkxMLJPxKoLTp08TAPLx8ZFKfwL3bmm+DNPS0mjTpk2kpaVF8vLy5OjoKIyIXrNmDampqZGDgwMBoI0bNxba17Bhw8jIyIgcHByofv36whXw8OHD6cSJE/T9+/cS21kc+vfvT/r6+uV+Jn1iYiKZmppS/fr1C/S2BAYGUps2bYjL5dL8+fMpPT1deC2vYDhy5Ag5OzvT1KlTqU+fPmRmZlaoYLCxsaHx48eTrKwsDR48mG7cuFGohyE3N5e6du1KDRs2pISEhDL5fQi4efNmoSv8wmjTpg2NGjVK7LW4uDgCQGfPni2tifnIyMigU6dOkaWlJXE4HFJSUqJRo0aRn58f8Xi8YvX18uVLMjExIXl5edq4cWO5vy8rA0wMlAGjR4+mWrVqUWxsLBH93EO2sbEhDQ0N+vz5c5mNe//+fdLX1ydFRUVycXEp9geiOLx+/ZrGjRtH8vLypKysTNOnT6cPHz6U2XjlQVpaGjVq1Ij69Okj1T6bN29OrVu3LrUbMiUlhdauXUu1atUiRUVFcnJyIhsbG9LS0iIul0uHDh0qso/hw4dT9+7diejn+/LJkye0dOlSat26NQEgWVlZ+vvvv8nFxaVM/55Pnz4lAHT8+PEyG6MgYmJiqGnTptS0aVP68uWL8HXB1pusrCwZGxvT48ePS9S/QDDcunWLjhw5QmvXrqWpU6eSnZ2dMEi0MMHg4OBAq1atov79+xOHw6EjR46UeEtCUo4ePUoAip2+SUTk5OREurq6Yq8JYloEsVRlRWRkJK1Zs4b09fUJADVu3JhWrFhRrO/bjIwMmjt3LnE4HOrWrVuZfldXRpgYKAO+fftGmpqaNGzYMOFrCQkJpKurS23bti3Tvam0tDSaMWMGAaCuXbuW+QQdGxtLS5YsIU1NTeJyuTRgwACpZlCUJ8uWLSN5eXkKCwuTar/Pnz8nOTk5mjNnjlT6S0pKouXLl5OqqioBIA6HQ4cPH5bo3iFDhlDPnj3FXgsPD6edO3eSlZUVycvLEwAyNjamhQsXUkBAgNRXS1ZWVmRiYlKmorUgPn36RPXr1ydTU1NKSEigx48fk4mJCcnKytLSpUvL7DM6c+ZMatSoEaWnpxcoGMzMzIRxCr8KhpYtW5KNjQ1NmjSJVq1aRe7u7kIPQ1paWont2rhxI6mqqpboXsF2WEGTZ5cuXWjo0KEltq048Pl8unv3Lo0bN45UVFSIw+FQz5496ejRoyIensK4desW6ejokJqaGnl4eJR4e0bS+KLKAhMDZYSgEExed/OTJ0+Ebt6yxs/Pj3R1dUlZWZl2795d5gFj6enptGfPHmFhnPbt29Pp06fLJIahLPj06RMpKirSf//9Vyb9b968mQDQtWvXpNJffHy8cDUvJydHKioqtHjx4iK3bAYNGkQWFhZF9p+cnEznzp2jMWPGCLMTateuTfb29nT+/PkSrSB/5d69e8WOqpcmb9++JQ0NDapXrx5xuVwyMzOTal67OAwNDcnBwaHQNt+/fycdHR3q0KEDvXv3rkDBIPi7SCoYgoODCxQMTk5O1KxZsxI9k6C4kIeHh9jrkyZNopYtW5ao79KQkpJCbm5u1LVrVwIg3E578OBBkd+HSUlJNGrUKAJAgwYNkjgrSJh5tKGAzKMNPzOPQmIlCx4tT5gYKCP4fD717NmT9PT0RFx8u3btKjf3aHJyMk2cOJEAkIWFRb7gs7KAx+ORl5cX9ejRgwCQnp4eubi4SBw5XVEMHDiQGjRoIJVJThw8Ho8sLCyobt26pa7dEBkZSS1atBAGUN24cYPmzZtHNWrUIHV1dVqxYkWBn8F+/fqRjY1NscbLzc2le/fu0YIFC6hFixYEgBQUFMja2pp2795NkZGRJX6Wbt260R9//FEh2Q13794lHR0dAkBNmzYts7+9gLCwsCLFD5/Pp8GDB5O6urpEbur09HQKDQ2lW7dukYeHB61du5amTJlCdnZ21Lp1a7GCQUNDI59gaNeuHbVq1apQwVAYJiYmNGHCBLHXtm3bRgoKChW6MAgLC6PFixdTo0aNCAC1aNGCNmzYQDExMYXed/r0aaFgLCyOKCIhjUYeeFjsmiQRCSX35kgbJgbKkNDQUFJUVKS5c+cKX+Pz+TRixAhSVlaWWoRtUfj4+FCDBg1ITU2N3Nzcyu2L99mzZzRixAiSlZUlNTU1mjt3brkIkuIiKKt67NixMh3ny5cvpKWlRba2tiX+G7x//550dHRIR0eHVqxYQTIyMsIiNDExMTRr1ixSUFAgDQ0NcnZ2zjfB2dnZkZ2dXameIzQ0lLZs2UI9evQQZie0adOGli1bRs+ePSvWswkCbq9evVoqm4pDSkoKTZ8+nTgcDrVv357c3d1JQUGB+vfvX6YT1o4dO4pMKTx48CABoFOnTklt3NIIht69e9OkSZNo9erV5O7uTjdv3hQrGKZOnUoGBgZixxf8jUsSnChtcnNz6fr16zRs2DBSUFAgGRkZsrW1pXPnzhWYPRQdHU0WFhYEgBwdHfM9+4nH4WS4+EqRIkCcKDBcfIVOPA4vj0cvEiYGypi1a9cSl8ulZ8+eCV9LTU0lIyMjatGiRZmvRgR8//6dRo8eTQDIzs5OJHCqrImMjKQFCxZQzZo1SUZGhoYNGybV6omlITs7m4yNjalTp07lIpK8vLwIQImK7jx9+pRq165NRkZGFBkZSZMnTyZjY+N87aKiomjq1KkkJydHtWvXps2bNwv3S21sbKhfv36lfg4BiYmJdPz4cRo6dCipq6sLs0wmT55Mly9fLrJaHp/Pp3bt2lHnzp2lZlNh3Lhxg/T09KhGjRrk4uIijIPw9PQU1nQoqxgGGxubQlMK379/T0pKSjR+/PgyGb8w9PX1afz48eTn50ceHh60Zs0amjJlCtna2kokGMzNzQkAbd26NZ9giI6OFqmFUVlITEykXbt20V9//UVA4SWQ+Xw+ubq6Cs+IEQSXlvock///2eFX8UKJiYEyJjs7m0xMTOiPP/4QWXW8e/eOlJWVadiwYeXqIr148SLVqVOHNDQ06MSJE+U6dkpKCm3fvp0aN24sDHC8dOlShQSQCdi2bRtxOBx6/vx5uY3p6OhIioqKBR7wIg4/Pz9SVVWldu3aCfcvO3ToQCNGjCjwnvDwcJo4cSLJyspS3bp1afv27WRubk4DBw4s9TOIIzs7m27evEmzZs2iJk2aEABSUlKifv360aFDhwqsxOnp6VmiHPfikJSUJNwy6969O4WG5j9E6ujRo8ThcGjWrFlS/1xkZGRQjRo1Ckz9zMzMpNatW1OzZs3KPHNAHCoqKsIzIwpC4GEQJxgEh26JEwytWrUiWVlZatu2La1evZoOHz5coIehonjz5g3NmTNHWN66TZs2tGPHjnwpne/evaM///yTZGVlacTSnVIRAoKfkxXsIWBioBx48OABcTicfAcXnThxosSrxNLw7ds3Gjx4sDA4przPH8jNzaWzZ89Sx44dCQAZGBjQrl27yv2L4evXr6Suri48cbK8SE9PJ2NjYzI1NZWozvz58+dJXl6eevXqJfQk8Xg8UlZWpg0bNhR5/4cPH2jMmDHE5XJJQUGB/vjjjzIvGMXn8+nt27fk7OxMHTt2JA6HQxwOhzp06EBr166lN2/eCCdcPp9PrVq1ol69epWJLd7e3tSgQQNSUVGh3bt3Fyo+d+7cSQBoxYoVUrXh6tWrBBR8wp+TkxPJy8uXqygVkJycLJU4JkFwZEhICPn5+dHhw4eFgqFWrVpUq1Yt0tTULFAw9O7dmyZPniwiGEJCQsr1eyE7O5suXbokUgL5n3/+ESmBnJ2dTbMWr6ZGc84JTyjN+1N3zBZSbdOb5LR0iCOnQDJqtUmpeWeq77C3UDFguPhKhcYQMDFQTkybNo2UlZXzBQVNmzaN5OTk6NGjR+Vu08mTJ0lDQ4Pq1KlTYRHdDx48oH/++Ye4XC5paGjQokWLigzqkRYODg5Us2ZN+vbtW7mMlxfBCXQzZswotN3BgweJy+XS4MGDRdLdQkJCCABdv35d4jHfv38vXPno6enRoUOHyi2oKy4ujtzc3Kh///6krKwszAWfMWMG3bhxg44dO0YApPo5iI+PF0aEW1paUni4ZCsvQZGwbdu2Sc2WGTNmUKNGjcR6HAQlfYt7LoC0CA4OJgB069atUvUzYcKEAk/EnDBhgvBMjPT09HyCYfLkyWRra0utWrUSKxg0NTWpVatWZGtrK1YwSJo2WBzi4uJo8+bNQq9H3hLIIw88pMb/ip/UlZp1JBnlWqT6hx1pWE8n9S4jiatckzhyilRvvGuhMQQjDzyU+nNIiqTzN4eICEWQnJwMdXV1/PjxA2pqakU1r1YkJyfDyMgIrVu3hpeXFzgcDgAgOzsbXbt2RUxMDJ4/fw5NTc1ytSs2NhaTJk2Cp6cnRo4cie3bt6NWrVrlagMAfPr0Cdu3b8eBAweQnZ2N4cOHY/bs2TA1NS2T8Z4/f44///wT27dvx7Rp08pkjKLYvn07Zs6ciStXrsDa2jrf9Y0bN2L+/PmYPHkyXF1dISMjI7x25swZDB48GHFxcahTp47EY3bt2hU1a9aEgoICzp49C319fSxbtgzDhg0T6b8syczMxK1bt+Dl5QVPT09ER0dDTU0NRAQDAwPcuHGj1O/Bc+fOYerUqcjOzoaLiwvGjBkj/MwVBRFh3rx52Lx5Mw4fPozRo0eXyhYAMDQ0RI8ePbB3716R12NjY9GyZUv8+eef8Pb2BpfLLfVYxcXf3x/du3fH+/fv0axZsxL3c+TIEYwePRrfvn2DlpaWyDUXFxcsWrQIqampEj1jeno6oqOjERUVhcjISLH/JiQkiNyjqamJhg0bolGjRmL/bdiwIWrUqFHs5yIiPHv2DG5ubjh+/DjSZFRRf+LuAttnRr2DQj19cGTkhK/lJEbjy8FpUG7eCVp2cwsd74ZTV+jXUS22naVF0vmbiQEpcPHiRfTv3x+nTp3C4MGDha9HRESgTZs2aNu2bYV8IRARPDw8MHPmTCgrK+PgwYOwsrIqVxsEJCUl4cCBA9i2bRuioqLQq1cvzJkzBxYWFhJ/mRcFEaFz585ITk7GixcvICsrK5V+S2JH79698ezZM7x69Qra2trC1xcuXIgNGzZgyZIlWLFiRb5nX7x4MQ4ePIiYmJhijdmxY0c0b94chw4dQmBgIJYtWwZPT0+0aNECy5cvx6BBg8r1/UdECAwMhKenJ9zd3fH582fIyMigS5cusLOzg52dHQwMDCTuLy4uDtOmTcPZs2fRt29f7N69G/Xq1SuRXRMnToS7uzvOnj2Lfv36FbsPAR8+fIC+vj4uXLgg0g+fz4e1tTVevnyJV69eFUvUSZMTJ05g+PDhSE5OhqpqySehiIgI6Orq5ntOALh27RqsrKzw8eNHNG7cuJQW/0QgGAoSC2UhGDIzMzFupw8CvskCnOJ9TmLcZgIA6tlvK7CNDJeDUe10sbyPcbH6lgZMDJQzAwYMQEBAAN69eyey+rl69SpsbGywcuVKLF68uEJsi4qKwvjx43H9+nVMmDABmzdvrrC/Y05ODs6ePYvNmzfj2bNnMDY2xuzZszF8+HAoKiqWqu9jx45h5MiRuHnzJv7++28pWVwy4uLi0LJlS/zxxx+4fPkyeDweJk+ejIMHD2Lr1q2YOXOm2Pvs7OyQm5sLHx+fYo3Xrl07tGzZEvv37xe+9uTJEyxbtgw+Pj4wNTXFihUr0K9fP6mJL0nJyclBkyZNoK2tDW1tbdy8eRNZWVlo3rw57Ozs0KdPH3To0EGsB4OIcPz4ccyYMQNcLheurq4YPHhwqZ6Bx+Nh2LBhuHTpEq5cuYKePXuWqB9XV1fMnj0bCQkJIpPt5s2bMXfuXFy7dg0WFhYltrO0bNmyBUuXLkVqamqp+9LT00P//v3h4uIi8npkZCR0dHTg7e2N3r17l3ocSSlKMERGRiIxMVHkHk1NzULFwrgLkYj8nlEsO4gI0bvGQk5LB9pDVhXaVldTCf5zexT7WUuLxPO3NPccqjNRUVGkqqoqtgrZ0qVLicPhlPq89NLA5/Npz549pKysTLq6uuTn51dhtgjs8ff3pz59+hCHw6E6derQypUrS7zPn5ycTPXq1aNBgwZJ2dKSI9gz3rRpE/Xv359kZGQKrOYmoGHDhrRgwYJij/XHH38UGDB5//596tmzJwE/T6b08vIq92JAe/bsIQ6HIzzA58KFCzRu3DhhrIOmpiaNHj2azp49K8zXj4qKIltbWwJAQ4cOlWpAbFZWFllaWpKysjI9fFj0fq64ErQ2Njb0999/i7R7+vSpVEtUl4Y5c+aQvr6+VPoaPXq0MDYgL3w+n1RUVCQKeC1v0tLSKDg4mG7evEnu7u60evVqmjRpEvXu3ZtatWpFGhoawtgFjnwN0hETNFjUj6btnJ/vX+sZRbbVW+hdIaWLWcxABbBz505MmzYNd+7cQZcuXYSv83g8WFtbIzAwEC9evECDBg0qzMaPHz9i3Lhx8Pf3x/Tp0+Hs7AxlZeUKswcAQkJCsHXrVri7u4OIMGbMGDg5ORVrn/Pff//F1q1b8f79e+jq6pahtcVj8uTJ2LdvH+Tl5XH27FnY2toW2DYhIQFaWlo4ceIEhg4dWqxxWrdujU6dOmHnzp0FtvH398eSJUtw9+5dtGvXDitXrkSvXr3KxVOQlZWFJk2aoFevXnB3dxe+zufz8fjxY3h6esLLywtv3ryBnJwcDA0N8eHDB6iqqmLfvn2lcucXRFpaGiwtLREUFIQ7d+7AxMRE5HpoXAqOPYrAreCviEhMR94vSg6AnKRYtKkrj82T+8FAWxWpqalo06YN1NTUEBAQAHl5eanbXBxGjBiBqKgo+Pv7l7qvgwcPwsHBAYmJiVBXVxe51q5dOxgZGcHNza3U45Q36enpiIqKQsC7CCx/mFWse3MSIhHjMQfyWjrQHrEeHG7RsTmXp3eGcX31IttJE0nn7/KPavmNmTx5Mtq3bw8HBwdkZf3vjSUjI4Njx45BQUEBgwcPRk5OToXZ2KRJE/j5+WHr1q3Yv38/WrdujYCAgAqzB/gZhLVr1y5ERERg8eLFuHjxotCFfPv2bRSlV8PCwrBlyxYsXLiwUgmBb9++4cmTJ+BwOKhbt26R7uiXL18CAFq1alXssXg8XpExEt26dYO/vz98fX3B4XBgaWmJrl274vbt28Uer7goKChg3rx5OHr0KD5//ix8ncvlon379li7di1ev34Nf39/NG7cGG/fvkVWVha+ffuG5cuXY+nSpXjy5An4fL7UbFJWVoa3tzd0dHRgYWGBjx8/AgAiE9Mx6uAj9Np6B0cehSP8FyEA/FxOytasizdZGui19Q5GHXyECbMW4MuXLzhx4kSFCwEAiImJKVFchTi6desGPp+P+/fv57tmZGSEoKAgqYxT3igpKcHQ0BCtzP4o1n281O/4emYFuArK0Or3r0RCAACyc6X3/pU2TAxIERkZGezbtw9hYWFYv369yLXatWvj9OnTePz4MRYuXFhBFv6Ey+Vi5syZePnyJbS0tNC5c2fMnz8fmZmZFWqXlpYWFi1ahPDwcLi5ueHz58/o0aMH/vzzTxw7dqxAETV79mzUq1cP8+fPL2eLCyYiIgKdO3dGdHQ0Tp8+jbi4OMydW3i08cuXL6GoqFiswDoBPB5PoqwBDocDc3NzBAQE4PLly8jIyECPHj3Qs2dPsV/00mTixInQ0NDI99kAfnoIXF1dYWNjg4yMDFy9ehXfv3/HyZMnYWJiAldXV7Rt2xYNGzaEg4MDvL29kZFRvP1dcdSsWRPXrl2DiooKzM3Nscf3Fcxd/BHw8WeAGo9fuBAVXL4f9g0BNXvCfvWBEv39yoIvX76gfv36UumradOmqFevHu7cuZPvmkAMSOBkrhRkZmbi9evXOHPmDFatWoXhw4djzKgREt/Pz0xD3Oll4Gemoc7gFZBVlTxTTF628k65ldeyKoqpqSnmz5+PNWvW4P379yLXOnTogE2bNmHLli04d+5cBVn4PwwNDXHv3j2sW7cO27Ztwx9//IGnT59WtFlQUFDA2LFj8erVK1y/fh21a9fGyJEj0bhxY2zYsAHfv38XtvXx8YGXlxc2bdpUovSisiAoKAgdO3ZETk4O7t+/j4EDB2Lz5s3YtWsXvLy8CrwvMDAQpqamJcqCkFQMCOBwOLCxscGTJ09w8eJFxMfHo3PnzrCyssLjx4+LPb4kKCsrw8nJCYcOHcKXL1+Er4eEhKB79+6YPn06Ro8ejTdv3sDS0hLq6uoYMmQIjh49iq9fv+L27dsYNmwYbt26BTs7O2hqaqJv3744cOAAYmNjS2yXtrY2fH19kdvMHOv8IpGVyy9SBPwKHxxwZeXhFacK11uhJbZFmkjTM8DhcNC1a1exWw5GRkZITU1FVFSUVMaSFgkJCbh37x4OHDiAuXPnwtbWFk2bNoWSkhJatmyJwYMHY8eOHYiKisKfzXSBfP6f/FBuNr6eXYnc79Go889SyGvpSGwPB4CeZsVuyRYGEwNlwOLFi6GjowMHB4d8bs0ZM2bgn3/+gb29PUJDK/5LQ0ZGBvPnz8ezZ8+gqKiI9u3bY8mSJcjOzq5o08DhcNCrVy9cvXoVr1+/hqWlJZYsWYJGjRph5syZeP/+PWbNmoUePXpg4MCBFW0uAODRo0fo0qULNDQ0cP/+fTRt2hQAMGXKFNjZ2WHcuHEFpg2+fPmyRFsEAJCbm1siEcHhcNC3b1+8ePECp0+fRkREBNq1a4c+ffogMDCwRLYUhqOjI5SUlLBp0ybweDxs2rQJrVq1QnR0NG7duoVdu3aJ3deUlZVFt27dsHnzZoSEhODdu3dYsWIFEhMTMWnSJNSrVw/t2rXDmjVr8OrVq2KvUh985YDbum/pHu7/Yy82XQ/BqScRpeurlKSlpSE5OVlqYgD4uVXw9OlTpKWlibxuZGQEABWyVcDj8fDx40dcuXIFmzdvxsSJE9GlSxfUrl0bWlpa6NKlCyZNmoSLFy8C+Jn1tX//fty7dw/x8fH4+vUr7ty5g0P7dkNXo/CJmvg8fLu4Hllf3qN2v4VQaNCiWLbqaCpBWaFi0p0lgQUQlhE3b96Eubk59u/fjwkTJohcS05Oxl9//QUFBQU8fPgQSkpKFWSlKDk5OXB2dsaqVatgbGwMDw8PtGzZsqLNEiEuLg47d+7Erl27hKlDhw8fxqhRoyrYMsDX1xf9+/dHq1at4O3tna/Azrdv39CyZUuYmpri6tWrInn/2dnZUFFRgYuLCxwdHYs9tp6eHkaOHInVq1eX6hl4PB5OnTqF5cuXIzQ0FAMGDMCKFSvyBdeVhqVLl2LDhg0wNjbGixcvMGvWLKxatarEgazx8fG4cuUKvLy8cPXqVaSmpkJXV1eYttitW7dC9/AjE9Nh7uKPrAL2cyk3B0l3jyLt7S3wM1MhV1sPNbuOQo3GZgX2qSDLxQ2nbmikUTGf7bCwMBgYGEg1zfbt27cwMTGBr68vzM3Nha/z+XyoqKhg9erVmD17tlTG+pW0tDSEhITg/fv3eP/+Pd69e4f3798jJCREGJ+lpKSE5s2bC39atGiB5s2bQ19fX6K05eWeb3Hk4WfwCpgRE2/sQ8pTT9TQbwul5l3yXVcxKThtsCrUGWCegTKiZ8+eGDNmDObNm4e4uDiRa2pqajh37hzCwsIwderUSrPXJicnh6VLl+LRo0fg8Xj4888/sWbNGuTm5la0aUK0tbWxcuVKPHr0CPLy8lBXV8fo0aPRoUMHnD17tsJsPXv2LHr37o2uXbvC19dXbKW92rVrw8PDA76+vti6davItXfv3iEnJ6fEnoHibhMUhIyMDIYPH46goCC4ubnhxYsXaNmyJYYNG4bg4OBS95+Tk4OcnBxkZWUhPDwc9+/fx5YtW0qV0aKlpYXRo0fjzJkziI+Px9WrV2Fra4tLly7BwsICWlpa+Oeff3DkyJF8xWoA4L8Lr5FbyLZA/GUXJD+5CGWj7qhl7gAOl4uvZ5YjM/Jtgffk8gn/XXhd4mcqLQLvkzQ9A0ZGRtDS0soXN8DlctGiRYtSewaICHFxcbh9+zb27NmDWbNmwcrKCrq6ulBRUUGbNm0wfPhw7Nu3T7ittWHDBly7dg3h4eFISUnBs2fPcOzYMSxZsgSDBg2CiYmJREIgKSkJMffOFCgEACA77meAaUbYYyR4b873Uxg8PmFke8m3FCoC5hkoQ+Lj49GiRQuYm5vjxIkT+a4LynyK8x5UNFlZWVi+fDk2bNiAP/74A4cPH0aLFsVzi5UlY8eOhbe3N4KDg/HgwQNs3rwZt2/fhp6eHmbNmoVx48aVqupacdi7dy+mTJmCYcOGwd3dHXJycoW2nzNnDnbs2IFHjx7BzOzn6tLDwwNjxowp8WesXr16mDp1KpYsWVKiZyiInJwcuLm5YfXq1YiOjsbIkSOxZMkS6OvrF7uvFy9ewN7eHm/evMFff/2Ft2/fIiIiAjVr1pSqzQKICK9evRKmLT558gRcLhedOnVCnz59YGdnB27N+ui1NX9QnICsL8GI9ZiDmj3GQb3dgJ/95mbjywFHyCiro+6oTYXaUFElaE+dOoWhQ4ciKSkpXypgaRgwYAASExPzZaCMGjUKHz58kCgzKTc3Fx8/fhRZ4Qt+kpKSAPwUpfr6+vlW+c2aNZPq+yU7Oxu7d+/GypUrkZmZiVYz9yMO6oWKguIiw+WgYxNNHBnfTnqdFgPmGagEaGlpwcXFBSdPnsSVK1fyXR81ahQcHBwwbdo0vHjxogIsLBgFBQU4Ozvj/v37+PHjB8zMzLB582bweLyKNg2PHj3C4cOHsXbtWmhqasLW1ha3bt3Cs2fP0KlTJ8ydOxeNGjXC/PnzERkZWWZ2EBHWrl2LyZMnw9HREUeOHClSCADA2rVrYWxsjOHDhwv3XwMDA9GkSZMSi21peQZ+RU5ODg4ODggNDcX27dvh6+uL5s2bY8KECQgPD5eoj8zMTCxatAh//fUXiAiPHz/GhQsXkJ2dDVdXV6nbLIDD4aBVq1ZYsmQJHj9+jOjoaOzZswfq6upYsmQJmjdvDqtpa8ChgtO90oPvAxwuVFv/r4w3R1YeKq16ISv6PXKTvxV4rwyXg6MPKyZ2ICYmBjVq1JD64q1r1654+PBhvswjcRkFycnJePLkCY4cOYJFixZh4MCBMDIygpKSEpo1a4a+fftizZo1CAoKgqGhIebPn4/z58/j3bt3SE9Px/v373Hx4kWsW7cOY8aMQbt27aQmBIgIZ86cgZGREWbPno0BAwYgNDQUp+b2g6yMdKdFWS4Ha/uXzVks0oSJgTJmxIgR6NWrF6ZOnZov8AYAtm3bBmNjYwwaNEioiisT7du3x4sXLzBlyhTMmzcP3bt3x4cPHyrMHj6fj+nTp8PMzAzjx48XudamTRscPXoUnz59wqRJk7Bv3z40adIEI0aMwLNnz6Rux5w5c7Bo0SKsWLEC27dvl7j2v4KCAk6cOIHw8HDhHmtpggeBshMDAhQUFODo6IgPHz5g48aN8PLygoGBAaZMmVJoFPnDhw/Rpk0bbNy4EcuWLcOTJ0/Qpk0b1K1bFxMnToSLi4tUyuVKQv369TFx4kR4eXkhISEBly5dgnxjM1Ahteiz4z5CTqMBuAqie//y9QyF1wuCxyfcCvkqHeOLiSCTQNoFpbp164asrCw8efIE+D/2zjoqqvXr498JOqRLQhERwQBbVFBBFL222GLrtVvx2t2K3X3t7sbuFhQVxQREBAUFyfm+f/gyP5GagQH1Op+1Zi0954l9DjPn2Wc/O/D/6XjDwpCSkoLY2Fh069YNnp6esLS0RJEiRVClShX4+vpi06ZNiIuLg6enJ/z9/XHmzBmEhYUhNjZWqtyPHj0azZs3h4ODQ4Hmabh8+TJcXV3RunVrlCpVCg8ePMDq1athYWEBKwNNTFLwvv7kJk4/zXdEHpTKQAEjEAiwfPlyREZGYsKECZnOq6urY/fu3YiJiUHnzp1/Gf+B79HU1MSCBQtw7tw5hIWFoVy5cli2bJlCE8DIysaNG3Hz5k0sWrQo28XP0tISs2bNwtu3bzFv3jxcvXoVlSpVQu3atXHw4MF8y52SkoKuXbvC398fS5cuxfjx4+V+6Do4OMDf3x+rVq3C3r17cf/+fTg7O+dZpoJWBtLR0NDAkCFDEBoaiqlTp2LXrl2ws7PDoEGDMoT3JSQkYNiwYXB1dYW2tjbu3LmDcePGZXjIjxgxAnFxcVixYkWBy/0jmpqaqFu/IRJF2jm2S/sSA5F2Zv8PkbaB9HxOvI5OQHxS4fuxKDLHAPDNnP7o0SM8f/4campqGDBgACpXrgxdXV1YWlpKn23nzp2Dnp4eunTpgs2bN+PWrVuIi4vDmzdvcOrUKSxatAh9+/ZF3bp1YWFhUah1Mp4+fYoWLVqgZs2aSEpKwpkzZ3DkyBE4OWVc/NtWtsZwr2/KXn6fxyO8SqFN5V/bVyAdpTJQCJQoUQITJ07EggULcOfOnUznixcvjk2bNuHgwYOYM2fOT5BQNtzc3PDgwQP4+vqiX79+8PLywuvXhWcGjY2NhZ+fH9q3b4+aNWvm2l5bWxsDBw5ESEgIdu/ejeTkZDRt2hQODg5Yvnw5EhIS5Jbh69evaNmyJbZu3YqtW7eib9++ebkUAN+S8DRv3hzdu3dHdHR0viwDeQ0tzCtaWloYOXIkQkNDMXbsWGzatAm2trYYMWIEDhw4gHLlymHp0qWYNWsWrly5kmU0grW1NTp37ox58+YpJIGQvLyKjs81spypyYAo89aPQKz6v/M59QfwMjqzRbCgyWuOgY8fP+Lq1atYv349Ro0ahaZNm6JUqVLQ1NSEk5MTfHx8IJFI8PLlS5QrVw7jx4/HwYMH8ejRI6iqqmLIkCHYvXs3pk6dio4dO6JixYqF5ruTHVFRUejfvz+cnJxw+/ZtqZKSU5RFv9p2MAo9CaQmAzlsI2WFSCiAmliIWS3Kol8d+X1rfhZKZaCQGDp0KMqUKYOePXtm6fHeuHFj+Pn54Z9//lFILvGCQltbG8uXL8eJEyfw5MkTlClTBuvWrSsUi8bkyZMRHx+P2bNny9VPJBKhZcuWuHLlCq5cuYLy5cujf//+sLa2xrhx42ROWBMbG4v69evjzJkzOHTokNz1A35EIBBg9erV0u2F/IRxFpZl4Ed0dXUxduxYvHjxAgMGDMDChQvRrFkzJCUl4fz58xgxYkSOSoqfnx/ev3+PdevWFaLU35AlNaxArAqkZc58ma4EpCsF+Z1H0YSHh2erDEgkErx69QonTpyAv78//v77b9SuXRtmZmYwMDCAq6srunfvjp07dyI5ORkNGzbEsmXLcP78eURGRmLKlClITU3FihUrMGLECDRu3Fjq4PcrpSVOSEjA9OnTUaJECfz777+YNm0anjx5go4dO+a6pbdhwwbc3rkIkRsGoJLlN2VGJMzZipF+3tXWEKeHuP82FoF0lMpAIaGiooLVq1fj7t27WLRoUZZtpkyZglq1aqFt27Zy17MvbLy8vBAYGIiWLVuie/fu+OuvvzJklVM0wcHBWLRoEcaMGZOvQk/Vq1fHrl278OzZM3Ts2BH+/v6wsbFBt27dEBiYfSjYu3fv4O7ujqCgIJw+fRoNGjTItq08pGfRA4CdO3fmeZyfpQykc/36dWzfvh2qqqqoV68eoqOj4eXlhYkTJyI2NjbbfnZ2dmjbti1mzZpV6ImuZEkNK9I2QNqXj5mOp28PpG8X5HceRRMREQFjY2M8ePAAO3fuxOTJk9G+fXu4uLhAW1sbxYoVQ4MGDTB69Ghcu3YNZmZm+Pvvv7Ft2zbcvXsXX758wYsXL3Ds2DEsWLAAvXr1gpubG0xMTFC7dm3Ex8dnsnL+KjUK0tLSsHHjRpQqVQoTJkxAt27d8OzZM4wcOVKmMMOIiAgMHjwYQqEQw3p3we7+tXFqsBs6VbWBjaEmflQJBPhWnrhTVRucHuKGzd2r/hY+AplQZAlEJbkzYMAAampq8sWLF1mej4iIoLm5Od3d3ZmSUvjlLvPCwYMHaWZmRn19ff77778KL48rkUjo5eXFEiVK8OvXrwod++PHj5w9ezYtLS0JgF5eXjx+/HiGawgNDWWJEiVobm7OwMBAhc5Pkj4+PrSysqJYLObNmzfzNIZAIODKlSsVLFnuxMTEsGvXrgRADw8PhoaGkiQjIyM5bNgwqqurU09Pj1OnTpWWJv6RoKAgAuDatWsLU3R+/JyQa9lZ3SotCIGQVkN2Zjiu5+ZLACzad/1PL1sbFRXFixcvctWqVRw6dCjr168vLc2b/jE2NmatWrXYs2dPzp8/n0ePHmVoaChTU1Plni85OZmampqZyhZPnjyZBgYGhV4e+3tOnjzJ8uXLEwBbtWrFkJAQucdo0aIF1dTUaGpqys+fP2c6n1U5618ZWddvpTJQyMTFxdHS0pLe3t7Z/mjOnz9PkUhEPz+/QpYu73z48IHt2rUjADZv3pyRkZEKG/vAgQMEwIMHDypszB9JTk7mli1bWKFCBQKgk5MT165dy9u3b9Pc3Jx2dnbShU7RlCxZkv369WPFihVZsmTJLB9AOSGRSAiAa9asKRD5suPAgQM0Nzenrq4uV69eneX3OTw8nAMGDKCqqiqNjIw4e/ZsxsfHZ2rXvHlz2tnZFagCnJqaytu3b3POnDn09vampqYmLXqvynExN/OdRwDUq9NNesx6+D6K9c2palEqV2XCbU6AwmR/9uwZDx8+zLlz57J79+6sUaMGDQ0NpQu+UCiknZ0d69SpQwAcOnQoL1++zA8fPihEhu/x9PRko0aNMhzbvXs3ASj0ty8r9+/flypBrq6uvHLlSp7G2bVrl/R+bty4UcFS/hyUysAvTPritn379mzbzJ49mwB44MCBQpQs/+zatYtGRkY0MjLi7t278z3e169faWtry/r16xfKG4dEIuG5c+fYpEkTAqBAIKCZmRkfPnxYIPN9+fKFAoGAa9eu5ZMnT6ipqclu3brJNUZKSgoBcP369QUi44+8f/9eqvg1bNiQb968ybXP69ev2bt3b4rFYpqamtLf3z+DlefWrVsEwK1btypMTolEwqCgIC5evJjNmzenvr4+AVBFRYXGxsYUi8XU9+xFm5EHclzQNR1qEkIRdau2oEGD/lQrWpoQimjafmaO/Wz/OcIJB4LkkvnLly+8ffs2t2zZwnHjxtHHx4dlypShmpqadJHS1NRkhQoV2KFDB06ZMoW7du1iYGCg9H5eunSJABgUJN/c8jBlyhQWKVIkg2Xh0aNHBMCzZ88W2Lw/8vbtW3bt2pUCgYAlS5bknj178vyciI6OpomJCYsUKcLKlSszLS1NwdL+HJTKwC9OixYtaGJiwpiYmCzPSyQSNmvWjHp6enz+/HkhS5c/3r17x2bNmhEA27dvz+jo6DyPNW3aNIrFYgYHBytQwtw5evQo1dXVaW5uTnV1daqrq7N37958/PixQue5evUqAfD27dskybVr1xIAd+3aJfMYiYmJBMDNmzcrVLYfkUgk3L59O42MjGhgYMDNmzfL/eB98eIFu3XrRpFIRAsLCy5dupSJiYkkSW9vbzo5OeX5ISyRSPjs2TOuWrWKbdu2pampKQFQLBazVKlStLe3p4qKCgGwevXqnD9/Ps/fe5rr27318L3UrdKCIi19QqRCVfOSNGk9Kdd+Nn6HGRKZeWtEIpEwIiKCZ8+e5bJlyzhw4EB6eXnR2to6g2nf3NycderUYZ8+fbhw4UKePHmSr1+/zvX+pL/d5ud3lxvnz58nAN65c0d6LDk5mWKxmEuXLi2wedOJi4vjmDFjqKGhQSMjIy5evJjJycn5GrNz587U0NAgAF69elVBkv58ZF2/lemIfxJhYWFwdHREmzZtsGrVqizbfPr0CZUqVUKRIkVw+fJlmZxffhVIYsuWLRgwYAA0NDSwevVqNGrUSK4x3r59i1KlSqFPnz6YOzfntK+KZNu2bfD19YW3tzd27NiB+Ph4rFy5EosXL0ZkZCQaN26MoUOHwt3dPd9x0itWrED//v3x5csXqKurgyRat26N06dP48GDB7Cyssp1jPj4eGhra2Pr1q1o165dvuTJjoiICPTr1w/79u1Dy5YtsXTpUpiamuZ5vJCQEEyePBlbtmyBlZUVxo0bh5IlS6J27drYu3cvmjdvLtM4b9++xdmzZxEQEICAgAC8fv0aQqEQzs7OMDc3x4cPH3D37l0kJyfD1dUVPj4+aNmyZYb72mntdVwJjZa7bHFOiIQCVCtugPG19DOk201Pv5vuVJmedjfdG//7T17TCC9atAgjR47E169fCyyOPzExEXp6epg1axYGDRokPe7k5IQ6deoUWGbJlJQUrF69GhMnTsTnz58xZMgQjBo1Kt8pl0+cOIEGDRpAW1sbzZo1w+bNmxUk8c9H1vVbqQz8RJYvX46+ffvi/PnzcHNzy7LNvXv3UK1aNXTu3BkrV64sZAnzT1hYGHr06IHjx4+jW7dumD9/vsw/3Pbt2yMgIABPnz4ttO/d0qVLMWDAAPj6+mLNmjUZwuKSkpKwbds2zJs3D0FBQahQoQKGDh2K1q1by5SGOCv69OmDS5cuZYhk+PjxI8qVKwdbW1sEBATkGiWQ/vvcsWMHWrdunSc5soMkNm3ahMGDB0NVVRVLly5Fq1atFDZ+cHAwJk6ciJ07d8LW1haqqqrQ1NTErVu3slzI3r9/j3PnziEgIABnz57F06dPAQDly5dH9erVoaamhsePHyMgIAApKSmoUaOGVAGwtLTMUobcqhbKC0kIJKmIXNcfidFhAL6FYP6YZ9/BwUF6zYpk9OjR2L59O168eKHQcX/E3d0dRkZG2LNnj/RY69at8eHDBwQEBCh0LpI4ePAgRo0ahadPn8LX1xdTpkyRSVnOjc+fP0vzYERFRSEkJCRfEUu/GjKv34o0MyiRj7S0NLq6urJUqVJSU2lWrFmz5rd2aJFIJFy9ejW1tbVpZWXFU6dO5drn4sWLhboPLpFIOHHiRKnjVU6mWIlEwhMnTkgdlooWLcpZs2bx48ePcs9brVo1dujQIdPxc+fOUSAQcNq0abmOERMTQwAK8dH4nlevXrFBgwYEwI4dOxaII1o6Dx48YPPmzaUm8lGjRjE1NZUfP37kgQMHOGjQIJYtW1Z6vlSpUuzTpw/Xr1/PRYsWsWHDhlRRUaFAIGDNmjW5cOFCvn37Vub5t15/JZPZX9ZP0Vo+nDVrFs+cOcPw8PBC9bD39fWlq6trgc8zduxYGhkZZbi2CRMm0NTUVKHzXL9+nbVq1SIAenp68u7duwodv3///tTQ0KBYLOaUKVMUOvavgNJn4DchMDCQYrGYEyZMyLFd165dqaGhwQcPHhSOYAXAixcvpJ7Offv2zdZrPjU1lc7OzqxSpUqhOPGkpaWxf//+BMAZM2bI9eAODAxkt27dqKqqSi0tLQ4cOFDmqIPU1FRqaWlxzpw5WZ7/559/KBKJeO3atRzHef/+PQFw//79MsudE2lpaVyxYgV1dHRoYWHBQ4cOKWRcWbh48SK1tLQIgBoaGhQIBARAa2trdu3alZs3b2ZQUBDXrVtHb29vqQJQq1YtLlq0iGFhYXLPKZFI2L9/f+pWb60QRWDkhjM0NjZmiRIlCt3XhSTr1avHli1bFvg8p06dIoAMzrU7duwgAIUojs+fP2ebNm0IgGXKlOGxY8cUrlRdvHiRAoGATk5OtLGxYUJCgkLH/xVQKgO/EWPGjKGqqiofPXqUbZv4+HiWK1eOJUuW/K3/DmlpaVy8eDE1NDRoa2vLCxcuZGqzYsUKAsh1EVQESUlJbNeuXb7j9CMiIjhu3DgaGhpSKBSyZcuWuYY3PXnyhAB48uTJLM8nJyezSpUqtLW1zTZGP31uAApZtJ89eyZV2Hr06JEna4c8JCYm8ty5cxw/fjxr1qwpdfADQAMDAwKgg4MDN2/ezLVr19Lb25tisTjfCkBMTAyvXLnCNWvWsGLFigRAExMT6jg3oNWwPbQesV8uBcD2nyO0H3uU22+8IvktN4WjoyP19PR45swZRd+2HClTpgz79+9f4PN8+fKFYrGYy5Ytkx4LDAwkAF68eDHP40ZHR3PIkCFUUVGhhYUF165dm6d8CLnx9etXlipVig4ODgTAnTt3KnyOXwGlMvAb8fXrV5YsWZK1atXK8U346dOn1NXVZatWrX5qYg9F8PTpU7q6ulIgEHDo0KFSjTw6OpqGhobs0qVLgcvw5csXNmjQgKqqqnJ57+dEfHw8V6xYQXt7ewJgtWrVuGvXriwfZjt37sw1LvvZs2fU1tamr69v1teQmMKAu0+pam7PlTuP5DkBSmpqKv39/ampqclixYrJtJWTF1JSUnjt2jVOnz6dnp6eVFdXJwDq6+uzRYsWXLJkCR8+fMhy5crR3d2do0aNkioF6W+IixYtYnh4eK5zpaWl8cWLFzx27BgXLFjA3r17083NjSYmJpmS8jg5OXHIkCFcuXIldx87y9bLLkgX+dyUABu/w+y45hpfR2fMn/Dp0yfWq1ePYrG4UHNAGBgYcPr06YUyV7Vq1di2bVvp/xMTEykSifKkWH/9+pVz5syhnp4etbW1OWXKFH758kWR4mZg9OjRVFVVpa2tLd3c3H77Z2p2KJWB34yAgAAC4KpVq3Jst2fPHgLgggULCkewAiQ1NZVz5syhmpoaHRwceP36dfbv3586OjqMiIgo0LljYmLo6upKLS2tAln40tLSeOjQIdauXZsAWLx4cfr7+2d4wx8zZgzNzc1zHWvjxo0EwG3btpEkn76L44QDQXSbHcBiWWS8c5sdwAkHgvj0XfbWhO8JDg5m9erVCYD9+/eXO+lRTqSlpfHu3bucN28e//rrL+ro6BAAtbW12ahRI86dO5d37tyRKsEfPnzgmjVrpFnkBAIB3d3dOWDAAFaqVEmaVOb06dPSh3dCQgLv3bvH7du3c+LEiWzbti2dnZ2lYWIAqK6uzvLly7NNmzacMGECt23bxi5duhAAlyxZkqXs0vs8J/N9th51iBUnHOSEA0FZhg+mk5yczN69exMAR44cWeDbXulhpoXlazNy5Eiam5tnWEhLlSrFQYMGyTxGWloat2zZwmLFilEkErFPnz589+5dAUj7P+7cuUORSMSGDRtSIBBkCJH8r6FUBn5DunTpwiJFiuS6EA4dOpRisZiXL18uJMkKlocPH7JSpUoUCAQUCAScOXNmgc4XFhbGMmXK0NDQkNevXy/QuUjy9u3b7NChA8ViMYsUKcIRI0bwzZs3bNSoERs0aJBrf4lEwrZt21Lf0o4tF5/N9xtrOikpKZwxYwbV1NRYsmTJLLds5EUikTA4OJhLly5ly5YtpRny1NXV6eHhwWnTpvHq1asZYsI/fPjA1atX08vLiyKRiEKhkO7u7jQ1NWW9evWk40ZGRnLu3LksVqyYdBvB3Nxc6leA/0+76+bmxl69eknT7r548SLDIiyRSPjPP/8QAP39/WW6rh9T0JpZ2nDMmDEy35P58+dTIBCwRYsWWWZgVBQvXrwgAB4/frzA5view4cPE0CGtL/NmzeX/t1y49y5c1Ilr2nTpoXiY5GcnExnZ2fpNk7Pnj0LfM6fiVIZ+A358OEDjYyM2KZNmxzbJScns0aNGixatOhPSf1ZECQnJ7N48eJSk62iPYbTCQkJYfHixWlpaZmjj0ZB8ObNG44cOZJFihShWCymhoaGzNsha88F02b43lyz5WW3l73t//ey07l//z4rVqxIoVDIESNG5Mtx6sWLF1y7di07dOhAc3NzaaKfGjVqcNy4cTx79mymmhJRUVFctWoV69WrJ1UA6tSpwyVLlvDq1as8dOiQ1HmsfPnyGbYKhEKhNA0yADo6OnLlypUyO61NmDCBADhv3rw8X7O3tzcbNmwoV58DBw5QS0uLlSpVkmmbIy9cuXKFAArN0fjTp0/SDJrpjBkzhkWLFs2x36NHj9i4cWMCYOXKlXn+/PmCFlXK9OnTKRQK6ePjQ11d3f/MMzQ7lMrAb8q///5LADx8+HCO7d6+fUsTExN6enoWiHNNYZOeNW3JkiUsV64cxWIxJ0+enO+sYt9z9+5dmpqaslSpUnz16lXuHQqIuLg4Tp8+Xbq4ubu78+DBg9makBcH5J4lT5bP4oCnTEpK4oQJEygWi+nk5JQny0hYWBj//fdfduvWTfqWLhAIWKlSJY4cOZLHjx/Pcqvh/fv3XLlyJT09PSkUCikQCOjo6Ehvb2/+9ddfLFOmDFVVVaX3RUtLi6qqqrS2tpam3Q0KCpKG4aalpXHPnj0sU6aMNDXyrVu3cpR98uTJBMBZs2bJfd3f888//8i0xfMjd+7cYdGiRWllZcV79+7lS4asSN9GjIqKUvjY2eHi4pLBp2XLli0EwE+fPmVqGxERwd69e1MkErFYsWLctm1boab9DQ4OppqaGrt06UKhUMi5c+cW2tw/C6Uy8JuSXqHP2to6173b06dPUygUcvz48YUkXcEQHx9Pa2trNm7cmOQ3D/8xY8ZQJBKxYsWKCsmxfuHCBerq6rJixYp8//59vsfLL2fOnCEALly4ULpfb29vz+XLl2cwI2+78S3+3WroLhap0Y7qxStQqK5NADRsODjTgm/mO4/aLg2palqCEIoIIMN5e+8uFIvFHDduXI65Lb7nw4cP3L17N/v27Sv1vE535hs4cCD379+fZVptiUTCwMBADhkyhKVKlZKa87/Ps4/v0u727duXixYtkqbdlUgkXLFiBQUCQY7m47S0NG7bto2lSpUiADZr1oz379/P1G7atGkEIFPuhtxIV17zsrf99u1buri4UFtbO1elX14WL15MFRWVQnWGGzx4MIsVKyb9/927dzOl9P3y5QsnTZpELS0t6uvrc968eTJ//xRFWloaa9SoQTs7O9auXZslS5ZkUlJSocrwM1AqA78xz58/p4aGBocMGZJr26lTp1IgEPDYsWOFIFnBMGHCBKqqqmYqN3r9+nU6ODhQVVWVs2fPzrMF5NChQ1RXV2fdunVzDNErTObNm0cNDQ3pNV25coWtWrWiUCikoaEhx44dy9uPX9J+7NFvSWz+/lazQKRrTDXrstkqA0VqtCOEYqqa2VFsUDSDMmA96hBtRuzj8Ys5l0mOjY3l4cOHOXToUDo7O0sX8ZIlS7J3797cvn17hkUwOTmZwcHB3LdvH2fMmME2bdpIncHSF/z0gk/e3t708/Pjxo0bef369SzfHr8nMTGRFhYW7Ny5c673NCUlhZs2bWKJEiUIgD4+PtIY+FmzZhEAJ02alOs4svDs2TMCyPPv7suXL2zSpAmFQiEXLVqkEJnIbxYLa2trhY0nC3v37iUAqbUtISFBunWQmprK1atX09zcnKqqqhw2bFi29VgKmiVLlhAAp06dqrBQ3N8BpTLwmzNr1iwKhcJczZ5paWls2LAhDQwMfqrpO6+8ePGC6urqHD16dJbnExISOGzYMAoEArq6uvLp06dyjb9x40aKRCK2aNEi0771z8TX15eVK1fOdDw0NJSDBg2itrY2TdtOpc2og/9fLGcfLftv/vb233lBtsqA5YDNtBq2hzZ+h6lToVEmy4DtP0fYcU3G/A3x8fE8deoUR48ezapVq0oXcUtLS3bu3JkbN27k69ev+enTJ16/fp0bNmygn58fmzVrRgcHB4rFYumin95XIBDQzs6Offr04eXLl/O13ePv70+RSCRzMqfk5GSuWbOGNjY2FAgE0rLUirSgpaWlUVdXN18hfKmpqRw2bBgBsF+/fgop39y1a1dWrVo13+PIQ1RUFIGMhbJKlCjB5s2bS7dw2rZtW2AlwGXh5cuX1NbWZs+ePVmiRIlCq4L6K6AsVPSbk5KSgsqVK0MoFOLGjRsZcuT/SExMDCpUqABTU1NcuHABampqhShp/mjVqhWuXr2KJ0+eQFtbO9t2ly5dQpcuXRAeHo5Zs2ahX79+EAqFOY7t7++PIUOGoHv37li5cmWuOf4LE2dnZ1SpUiXbIlW3n4Wj5dq7WZ5LigjBu41DYNhwMLTLeWY7R8zJ5fh85whs/A5nOjfLTRtPbp5HQEAArl69iuTkZJiYmKB27dpwcXGBmZkZ4uLi8OTJE2lxnYiICGl/Kysr2NraQiAQIDw8HCEhIRAIBKhbty5at26N5s2bw8jISM67kjUJCQkoVqwYWrZsieXLl8vcLzk5GR06dMDu3bshEAjQuXNnjB8/HsWLF1eIXO7u7jA1NcXOnTvzNc6qVavQt29feHl5Yfv27fl6xjZo0ACamprYu3dvvmSSlzJlysDV1RWrVq3C3bt34eXlhQ8fPsDNzQ1z585F5cqVC1We7yEJb29vPHz4ED179sTkyZPx4MEDODo6/jSZChNZ1++cn6ZKfhoqKipYvXo17t27h4ULF+bY1sDAALt378a9e/cwfPjwQpIw/wQEBGDPnj2YM2dOjooAANSsWRP3799Ht27dMHDgQHh6euLly5dZtiWJsWPHSiuarV69+pdSBJKTk/Ho0SOUL18+2zaHHn2ESFgwFecoSUOf+Vsxd+5cJCQkoF69emjUqBGsrKxw5MgRjB49Gl27dsWIESNw4cIFGBoaonv37vj3339x4sQJzJs3DyVKlMDFixdx8eJFFCtWDKtWrUJkZCROnTqFnj17KkwRAABNTU0MHToU69atQ1hYmMz9Vq9ejd27d2Po0KFYsGABjh07Bnt7e/Tu3Rtv3rzJt1wuLi64ezdrhU0eevXqhWPHjuHKlSuoWbMmXr9+neexIiIiYG5unm+Z5MXNzQ1nzpyBr68vKlasCIlEAmNjY5w7d+6nKgIAsHnzZpw4cQIzZszAnDlz0K9fvz9GEZAHpTLwC1O5cmUMGDAA48ePz3bhS6dSpUrw9/fHkiVLsH379sIRMB+kpqZi4MCBqFGjhsxld7W0tLBkyRKcPn0az58/R9myZbF69Wp8b9xKS0tDnz59MG3aNMyZMwczZ84ssDKueSU4OBgpKSlwdnbOts3ZJ+8VWlL3ewRCETRsK+Hz58+4efMmrly5go8fP8LZ2RkTJ07EoUOHEBISgvj4eAQGBmLx4sUwMzPD6tWr0aBBA4waNQpqampSBeDEiRPo0aOHQhWAH+nbty80NTVlLmWdXhp66NChmDt3LgYNGoTQ0FDMmDEDe/fuhZ2dHfr374/w8PA8y+Ti4oJnz54hLi4uz2OkU69ePVy5cgVfvnxBlSpVcOPGjTyNEx4eDgsLi3zLIw+xsbEICwtDaGgojh49imXLlmHu3LmIiorCly9fClWWH4mMjMTgwYPRoUMHnD17FqqqqpgwYcJPlemXRZF7DkoUT1xcHC0tLdmgQYNc97gkEgk7dOhALS2tQo+hl5dFixblK/NXbGwsu3fvTgBs0KAB3759y8TERPr4+FAoFHLdunUKllhxbNiwgQCydWb8nJiSKeNdhoiBHHwGvv9k5TPwv88hngw4z/fv32f5vQoPD+fixYvp5uZGgUBAsVjMBg0acO3atYyOji7oW5Ql48ePp4aGRq7RIKtXryYADho0KMtrSw/t1NfXp7q6OocMGZKnWPP79+8TgEKSNaUTGRnJ6tWrU11dXe4U2UlJSQSQIea/IElKSuLChQtpaGgoTSu9YcMGkuTNmzcJgDdu3CgUWbKjVatWNDIy4qlTpygQCLh06dKfKs/PQNb1W2kZ+MXR0dHBsmXLcPz4cezYsSPHtgKBACtXroSNjQ1atmz507Xy7IiKisL48ePRs2dPuLi45GkMXV1drFmzBocPH8b9+/fh5OSESpUq4eDBg9izZw+6du2qYKkVx/3792FrawsdHZ0sz7+KjkfB2AS+RwCLUuVhbGwstZyEh4dj8eLFcHNzQ9GiRTFkyBBoaWlh7dq1iIyMxLFjx9CtWzcYGBgUuHRZMXDgQIhEIixYsCDbNuvXr0evXr3Qr18/LFiwIEurkI6ODkaPHo0XL17Az88Pa9euRfHixeHn54fo6GiZ5SldujTU1NQUslWQjomJCQICAtCsWTP4+PhgxowZGSxfOREZGQkABb5NQBK7d++Gk5MThgwZgmbNmuH58+coWbIkbt68CQBwcHAAADx69KhAZcmJvXv3Yvfu3Vi0aBEmTpwIJycn9OrV66fJ86ujVAZ+Axo3boxWrVph0KBBiImJybGtlpYW9uzZg9evX6NXr14yP0gKk7FjxwIApk6dmu+xGjVqhAsXLkAsFiMoKAiVKlVC9erV8z1uQXLv3r0ctwiSUyWFIkdyqgRhYWFYtGgRatWqBUtLSwwbNgw6OjpYt24d3r9/j6NHj6Jr164/TQH4HkNDQ/Tp0wdLlizBx48fM53ftGkTunfvjt69e2Px4sW5bg8VKVIEEyZMwMuXLzFkyBAsXboUxYoVw7hx4/Dp06dc5VFRUUGZMmUUqgwAgLq6OrZu3Yrx48fjn3/+Qbdu3ZCcnJxrv/Qtj4LcJrhy5Qpq1KgBHx8f2NnZ4d69e1izZg0sLCzg5uaG8+fPAwC0tbVhY2Pz05SBjx8/ol+/fmjcuDEA4PLly/D398/REftPR6kM/CYsXLgQiYmJGDlyZK5tHRwcsGbNGmzbtk0u7+vC4M6dO1i9ejUmT54MY2PjfI/39u1bNGnSBEKhEHPmzMHTp0/h5OSEXbt2KUBaxUMS9+/fz9F5UFVcOD/L3j27w9LSEsOHD0eRIkWwfv16REZG4siRI+jSpQv09fULRQ55GDp0KFJSUrBkyZIMx7ds2YIuXbqge/fuWLp0qVx+Ivr6+pg6dSpevHiBPn36YN68eShWrBimTJmSqz+AopwIf0QgEGDSpEnYvHkztm7dCi8vr1xfBNKjPQrCMhASEoJWrVqhRo0a+Pr1K06dOoVjx46hbNmy0jZubm4ICgqSWlccHR1/mjIwbNgwJCQkYP78+Rg5ciSaNWsGDw+PnyLL74JSGfhNsLCwwKxZs7B27Vqp9p0Tbdu2Rf/+/TF48OA8OyMpGpIYMGAAHB0d0adPn3yP9+TJE9SoUQPx8fG4dOkShg8fjocPH6J27dpo3bo12rZtK5fZtzAICwtDTExMjpaBYoZaKGiXR5KIfvkYo0aNwps3b3D48GF07tz5l1QAvsfMzAw9evSAv7+/dBtsx44d8PX1RefOnbFy5cpcQ06zw8jICLNnz0ZoaCi6du2KadOmoXjx4pg1axbi4+Oz7OPi4oKHDx8iKSkpz9eUEx07dsSZM2cQFBSE6tWrIyQkJNu24eHhEIvFCnXk/PDhAwYOHAhHR0dcv34dGzduxO3bt+HpmTmk1d3dHcC3MGDg5ykDp06dwvr16zF37lxs2bIF79+/l9nx9I9GkQ4ISgqWtLQ0urq6slSpUjIl0ElKSmLVqlVpbW0tcxGXgiS97sKZM2fyPdatW7dobGxMR0dHvnnzJsM5iUTCrVu3Ul9fn6ampjxw4EC+51MUhw4dIgC+fPky2zaRkZEs+8/eTE5/+vV6s0itjtR2aUgA1LR3ZZFaHVmkVkdaDd7xLVNhn3XSY6oW39Lzpv/f8K+h/0tLPGwrTU1Nv42jqcmGDRvS39+fwcHBv3wyllevXlFFRYVz5szhrl27KBKJ2KlTJ4XX6Hj79i379u1LFRUVGhsbc968eZkKOqUXBrp9+7ZC5/6RZ8+esVSpUjQwMMi2qM/YsWNpaWmpkPkSEhI4Y8YM6urqUldXlzNmzJCpmJW1tbU0c+ratWspEAgKtErjj3z+/JnFihVjnTp1+OrVK2poaHDUqFGFNv+viDID4X+UoKAgqqioyJxN7dWrVzQ0NKS3t3ehFgT5kc+fP9PCwoKtWrXK91gBAQHU0dFh1apVc1RywsLC2KjRN4/6zp078+PHj/meO79MnTqVenp6mRbctLQ0njhxgq1ataKKigqN6veRZh9M/4h0TTLk9P/+U/TvtbTxO0zTdtOzbaNmVUaahXDCgSBKJBLeu3ePs2fPpqenp7RIkLW1NXv06MGdO3f+tNSxudGjRw9p9cf27dsXaLGuly9fskePHhSJRDQzM+OiRYukefW/fPlCgUDANWvWFNj86cTExLBu3bpUUVHhxo0bM53v3r17llkt5SEtLY0bN26klZUVxWIxBwwYIFctj06dOrFixYokyatXrxJAniOG8sKgQYOooaHBZ8+esV27djQ1Nf1lUpD/LJTKwH+YsWPHUkVFRZp3PTeOHTtGgUDAqVOnFrBk2TN69Giqq6vn+EYsC3v37qWqqirr1auXayEn8puVYN26ddTR0aGlpSVPnDiRr/nzS6tWreju7i79/9u3bzl58mTa2NhIi/8sXLiQN5+8UUilwuw+IZGZH5Dx8fE8evQoBw8ezNKlS0vLBVetWpXjx4/npUuXFJIyVxGsWLGCAFihQoVCk+nZs2fs3LkzhUIhLS0tuWLFCiYlJdHBwYH9+vUrFBmSk5OlIbVjxozJoOB7e3uzadOmeR771KlTdHZ2JgC2bNlS7tTf5LewTqFQyE+fPvHTp08EwH///TfPMsnD5cuXKRAIOG/ePF68eJEAfukQ48JCmY74P0xiYiLKlSsHU1NTnD9/XqY90gkTJmDq1Kk4efJkoTvSPHv2DE5OThg9ejQmTpyY53HWrVuHnj17olWrVti0aZNcaZdfv36N7t274/Tp0+jduzfmzJmTbWhfQWJvb4/69eujXr16WL16NY4ePQp1dXW0bdsWPXv2RNWqVaXOb53WXseV0GiFJh8SCQVwtTXE5u5Vc2375s0bnDx5EidPnsSpU6fw8eNH6OrqwsPDA/Xr14eXl5fCUvvKw+HDh9GiRQuYm5tDIpHg+fPnUFVVLbT5nzx5gkmTJmH79u2wsbGBqakphEIhrly5Uijzk8ScOXMwatQotG7dGhs2bICGhgZcXFxQrVo1uZ2Gg4KCMHLkSBw7dgzVq1fH3Llz4erqmifZnj59ilKlSuHo0aPw9vaGpaUlOnfujGnTpuVpPFlJTEyEi4sLdHV1cenSJWlE0Y0bN/LsQ/JfQeb1W5GahZLC4+zZswTAlStXytQ+NTWV9erVo7GxMd++fVvA0mWkcePGtLa2ztfe4ezZswmAf//9d55NwhKJhMuWLaOmpiaLFy/Oc+fO5VmevBAYGEgA1NPTIwBWqlSJK1euzPZ39To6Xlq1UFEf+7FH+Tpa/r9Damoqr1+/zsmTJ7NmzZrSgkQlS5Zkv379ePDgwUIxxx47doyqqqps3ry5tFRuYZjosyIwMJAtW7aUFmbauHFjgW5X/MiePXuooaHBqlWr8t27dzQ1NZWrKmNYWBi7d+9OoVDIEiVKcNeuXfn2F5FIJDQzM5Pu09erV4/NmjXL15iykG4tDQwM5Lp16wiAly5dKvB5fweU2wR/AN26dWORIkUYHh4uU/v379/T0tKSNWrUyFcVOXk4evQoAcidTS0diUTCkSNHEgDHjRunEOe2Z8+esVatWtIsdQXp4JSYmMgdO3bQ09NTunfv4+PDu3fvytR/8dE7ClUGtt9QTGXLT58+cd++ffz7779ZvHhxAqCKigrd3d05bdo03rp1S+E+KidPnqSamhqbNGkirUPfokUL2tnZ/dTti+XLl0v/tqVLl+aOHTsKzT/n5s2bNDMzo7W1NQUCAVevXp1rn7i4OI4bN46ampo0NDTkwoULpfdTEbRu3ZrVq1cnSQ4ePJj29vYKGzsr7t27R7FYzIkTJzI2NpampqZs165dgc75O6FUBv4AoqOjaWxsTB8fH5n7XLlyhWKxmEOHDi1Ayb6RlJREe3t71qlTJ0+LeEpKinR/1N/fX6Gypaamct68eVRTU6O9vT2vXr2q0PGDg4M5bNgwGhkZEQBr1KhBX19fikSiXCNBQkNDOWvWLFaqVOlb2uFa7aUphPOjCCwJCFHoNX5PSEgIly5dyqZNm1JHR4cAaGRkxHbt2nH9+vUMCwvL1/hnzpyhuro6GzVqJHXeI8nbt28TALds2ZLfS8gzHz58IABOnTqV3t7eBMCyZcty7969hRKZ8fr1a6mPR06WgZSUFC5fvpympqZUU1PjqFGjCsSpdunSpRSLxYyPj+eqVasoFAoz/M0USUpKCitWrMgyZcowKSmJo0aNooaGBl+/fl0g8/2OKJWBP4QtW7YQAA8dOiRzH39/fwLg7t27C1Aycu7cuRSJRHzw4IHcfb9+/crmzZtTJBJx06ZNBSDdN4KDg1mlShUKhUKOGjUqXw+thIQEbtq0SWp1MDQ05NChQ6V1Inr37s0yZcpk2ff58+ecOXMmK1asSADU0NBgy5YtuX37dn7+/Jnbbryi/dijtP3niFwKgO0/R2g/9qjCLAKykJyczAsXLnDMmDGsVKkSBQKB1Dly2LBhPHHihExhaumcPXuWGhoabNCgQZaKlLe3N52cnH5qtIyVlRVHjhxJ8psjm4eHh9TB8fDhwwWuFKRvGwqFQi5btizDOYlEwgMHDtDBwYEA2KlTJ756VXDfh/TtsNOnT/PSpUsEkKdngCzMmjWLQqGQ169fZ0hICFVVVTlx4sQCmet3RakM/CFIJBLWr1+fVlZWMnnXp/fx8fGhjo5OnjyGZSEiIoI6Ojrs37+/3H1jY2NZp04dqqury6Xk5JWUlBROmzaNKioqdHJy4q1bt+Tqf+/ePfbr149FihQhAHp4eHD79u2ZFItq1aqxY8eO0v8/e/aMM2bMYIUKFaQKQKtWrbhjx44s/5avo+PZcc21bwv9D2GHWSkBNn6H2XHNtTz5CCiSqKgobtu2jV27dqWFhQUBUF1dnV5eXpw3bx4DAwOzXSwvXLhATU1N1qtXL1sF4vLlywTAvXv3FuRl5EiTJk1Yr169DMfOnTsnVQyrVq3KkydPFphScODAAQKQWtIGDx7M1NRU3rhxg+7u7tLvZWGE+aWlpdHQ0JDjx49ndHQ0AXD79u0Kn+fJkydUV1eXWjmbNm1KKyurQs1r8DugVAb+IEJDQ6mhocHBgwfL3Cc2Npb29vYsW7Zsgfx4unTpQkNDQ7kr3L1//54VK1ZkkSJFFFoNThbu379PZ2dnikQiTpgwIUe/iri4OK5atYqVK1cmAJqZmXH06NF89uxZlu1TU1OpqanJUaNGcfr06XRxccmgAOzcuZNfvnzJVcY3b95QxciarWbsoNucgEzVDYv5HabbnABOOBCUZfjgz0YikTAoKIjz5s1j/fr1pdXuLCws2KVLF27bto1RUVEkyUuXLlFLS4t169bN9Ttau3ZtVqhQ4aclTJowYQKNjIwyzS+RSHjq1ClWq1aNAFirVi2ePXtW4fOvWLGCQqGQqampXLx4MYVCoVTxcnJy4tGjRwv13jRr1kwaQmtmZiZzXhRZSUtLY61atWhra8v4+HieOnWKALht2zaFzvNfQKkM/GHMnj2bQqGQN2/elLlPYGAgNTQ02LlzZ4U+KK5du0YAXLFihVz9Xr16RXt7e5qamvLevXsKk0cekpKSOG7cOIpEIrq4uGQwb0okEl67do3du3enlpYWhUIhGzVqxP379+eoOISEhHDo0KFSJzNNTU36+PjIrAB8z4wZM6ihoSH9LX5JTGFQ2CfeeRXDoLBP/JL4a+QBkJWEhASePHmSw4YNY9myZaWe+aVLl6aqqiqdnZ1lSnx0+vRpAuCxY8cKQerM7N+/nwAyZcNMRyKR8MiRI9JtoLp16/Ly5csKm3/8+PG0sLBgTEwMhw0bRrFYTIFAQCsrK7548UJh88jK/PnzqaamxsTERNatW1chyca+Z9myZQTAgIAApqSk0MnJiTVq1Pjls2f+DJTKwB9GSkoKnZ2d6ezsLJdn9aZNmwhAJi9kWUhLS2PlypXp7OwsV5jVw4cPWbRoURYvXjzbt+vC5ObNm3R0dKSqqirHjx/PBQsWSBcra2trTpo0KUcnpadPn3LatGnSJC5qamrSMLi8WmIkEgkdHBzYvn37vF7WL09YWBjHjx9PsVhMsVhMANTW1maTJk24ZMkShoSEZPnAl0gkrFatGl1dXX/KgvDq1SsC4MGDB3NsJ5FIuG/fPpYrV44A2KBBA16/fj3f83fr1o2WlpbU19enlpYWJ02axGvXrtHa2poWFhZyb33ll3THzosXL7J///50dHRU2NivXr2itrY2e/bsSfKbw6JAICj0a/xdUCoDfyA3btygUCjknDlz5OrXq1cvqqmpKWQ/MT3G9+LFizL3uXbtGg0MDFi2bFmZwyQLGolEwpMnT9LR0VH6turl5cVjx45lq+Q8efKEU6dOZfny5QmAWlpabNOmDXfv3s0RI0bQ3Nw8XzJdv36dAH56FsWC5NatW9TT06Orqys/ffrEW7ducfr06XR3d5cqB8WLF+fff//NvXv38tOnT9K+6XUfCsIMnxsSiYQGBgYyx/mnpaVx586d0iiAxo0byxxu+uO827Zto4aGBgGwd+/ejIiIkJ6PiIhglSpVqKmpyX379sk9fl5JTU2lrq4up06dymXLllEsFisknFkikdDb25sWFhb89OkTo6OjaWBgwG7duilA6v8mSmXgD2Xw4MHU0NBgaGiozH2+fv3KChUq0NbWNl+hRp8+faKpqalcb64nT56klpYWXV1df4k8+JGRkZw9ezbt7e2lSXX69u3LYsWKUV1dnQsWLMjgtf748WNOmTJF+qanpaXFtm3bcs+ePRksAI0aNaK3t3e+ZOvbty+LFi1aqIltCpM7d+5QX1+fVatWzfJZExcXx4MHD7J///7Sv49IJGKNGjU4efJkXr16leXKlaOnp+dPkJ708PCQO8FOamoq//33X5YsWZIA2KJFCwYGBsrU9/z581KflSJFimQbYpyQkEAfHx8KBALOnTu30CwnDRs2pJeXF8+dO0cA0qia/LB58+YMFpiBAwdSR0cngwKkJCNKZeAP5fPnz7SysmL9+vXl+tGHhoZST0+PTZo0yfPDYtiwYdTS0pI5w+GuXbuooqJCb2/vn+oB/GORIDU1NbZv355nz56V3ov4+HgOHDhQmjlw8ODB0m0DbW1ttmvXjnv37s3W471o0aL08/PLs4yJiYnU19f/z1Zgu3fvHg0MDFi5cuUMb/s5ERoayhUrVrBFixbSSA4tLS0C4D///FPosebDhw+njY1NnvqmpKRw/fr1LF68OAUCAdu2bcvHjx9n2fbx48ds2rSp9Lt49uxZmpubc8KECdmOn5aWxtGjRxMAe/bsWShJx2bOnEktLS2GhYUpJJQ5MjKSBgYGbNu2LclvW4sikYizZs1ShLj/WZTKwB/MwYMHCYBbt27NU7/Zs2fLPWdwcDDFYjGnTZsmU/sVK1ZQIBCwQ4cOhZYN8Ud+LBLk5OREf3//LCMgHj16xEmTJkmz7QFg5cqVc1QA0omKisp3eNXu3bsV9nb1qxEYGEgjIyNWqFAhz9ahlJQUXr58mWPHjpVGKKRnBBw0aBCPHj0qt7OmvKTn/JA3guZ7kpKSuHLlSlpZWVEoFNLX11fqQ/Pu3Tv26dOHIpGINjY23Lp1K9PS0piamkqhUChTavJ169ZRRUWFHh4eBV7FM7288/Xr12lkZMTJkyfna7w2bdrQ0NCQ79+/p0QioZeXF0uUKFFgCY3+KyiVgT8cHx8fGhsby/1g8vPzo0gkyrZmelak/zBtbW1zza4nkUg4bdo0AuCAAQMKPVFMSkoKDxw4wL/++otCoZCamprs1q0br169mski8vDhQ06cOJFOTk4EQB0dHXbo0EEaMw+AXl5eub6Bpnu6BwcH51nuxo0b57s87a/Iw4cPaWxsTGdn53wtot+T7hQ7e/Zs9ujRg1ZWVgRAVVVVenh4cNasWbx3757CzeWPHj0iAJ45cybfYyUmJnLx4sU0NzenSCRixYoVqampST09Pc6ZMyfD7yw8PFwm58V0zp49S319fTo4OPD58+f5ljU7kpKSqKmpydmzZ9PNzY1t2rTJ81jp0RrpmSbT/UP279+vKHH/syiVgT+c8PBwFilSRG7HmpSUFNauXZtmZmYy78OlJzw5cOBAju3S0tI4ZMgQadrUwvT6Dg0N5ZgxY6Sx1xUrVuSKFSsyfaeDgoI4YcIEqeOgrq4uO3bsyAMHDmRSdI4dO8aiRYtSV1eX69evz/Z65s2bRw0NjTzv9UdGRlIsFnPJkiV56v+rEhwcTFNTU5YrV44fPnxQ2LgpKSksXry4dA9dIpEwODiYCxcuZMOGDampqUkANDU1ZadOnbh582a+e/cu3/Om55KYO3duvsdKH2/58uXU1dWVZhfs2rVrpm24dM99ecKKnzx5Qjs7OxoZGSk0xPFHPDw8+Ndff/Hvv/9m2bJl8zTGx48faW5uzkaNGlEikTApKYklS5akp6enMpRQBpTKgBJpzXd5vasjIiJobm5Od3f3XMMUv379Sltb21x9FJKTk+nr60uBQMClS5fKJU9e+bFIkK6uLvv27ZspaiIoKIjjx4+XenanKwAHDx7M1QQZExPDTp06ST3Cs1KgfH19WaVKlTxfx4IFC6iioqLQBfNn8+TJE5qbm9PJyYnv379X+PgrV66kQCDI0hqTmJjIM2fOcNSoUdLQTwB0dnbmqFGjeObMmTybnqtVq8YOHTrkV3weP35c6pPSpk0bBgYGctasWTQ0NKSamhoHDRok/a6lvyXLW//hw4cPdHNzo5qamtxbirIyefJkFilShP7+/lRVVc1TQakePXpQR0dHaoGbO3cuhUKhzI6WfzpKZUAJ09LSWKNGDdrb2+dqvv+R8+fPUyQS5er0Nm3aNIrF4hxN4AkJCWzcuDHFYnGhZAjLqkjQhg0bpE6KEomEgYGBmRSATp06yaQAZMX+/ftpYmJCAwMDbtu2LYNiVK5cOWlMdF5wdnZmixYt8tz/VyMkJIQWFhYsXbq0Qt7IsyIxMZFFixalr69vrm3fvXvHzZs3s1OnTjQ1NZUmhmrYsCEXLlzI4OBgmd9A+/Tpk6+Y+rt377JevXrSbIU/5iCIjY3llClTqKenRw0NDQ4fPpzz5s2jQCDI00KbmJhIX19fAuDEiRMV/qadHkmQ/mLy5MkTufqnb7GlJzCLjIykrq4u+/Xrp1A5/8solQElJL/tyaqoqHDcuHFy9509e3aO5v83b95QU1OTw4YNy3aMT58+sVatWtTU1CzQ7HBZFQkaMmQIHz58SPKbAvDgwQOOGzdOWrClSJEi9PX15aFDhxTihBQVFUUfHx8CYKtWrfj+/XsmJSVRRUUlz9aQ+/fvy7QF87vw/PlzWlpaslSpUgUeDubv70+RSCRXmG1aWhrv3bvHWbNm0cPDg6qqqtJEUz169OCuXbtydHJMr9Inb3TMmzdv2LlzZwoEApYqVYr79+/PcWH++PEjx40bRx0dHaqoqFBLSyvPPhcSiYRTp04lAHbo0EHuF4ec+Pr1K1VVVTl58mQCkCvXwZcvX1i8eHG6u7tLfYt69uxJfX39/5SVrKBRKgNKpIwfP54qKioMCgqSq59EImGzZs2op6eXpaNR+/btaWJikm0oWEREBMuXL099fX1euXIlT7LnRk5FgiQSCe/fv8+xY8eyVKlSUgWgc+fOPHz4cIF5IW/fvp0GBgY0MTHh/PnzCYCXLl3K01hDhw6lsbHxT4u4UCQvXrygtbU1S5Ysme+SxrIQHx9PY2Nj9u7dO89jfPnyhUePHuWgQYOkViShUMhq1apx/PjxvHz5coY38ps3bxIAr127JtP4nz594ujRo6murk5jY2MuW7ZMrr/1hw8f6OzsTIFAQF1dXU6YMEHm0Mwf2bFjB9XU1FijRg2Fbt3UqlWLzZs3p56enszRRiQ5ZMgQqqurS4up3blzhwKBgIsWLVKYbH8CSmVAiZSvX7/S3t6erq6ucnvvf/z4kSVKlGCFChUyvDFcvHiRALhu3bos+4WGhrJEiRI0NzdX+N5eTkWCJBIJ7927xzFjxkgT0+jp6bFLly48cuQIk5KSFCpLdkRERLBJkybS/ei8lIxNSUmhqakpBw0apHgBC5lXr16xWLFiLFGihMx5KBTBjBkzqKqqqrA5X716xTVr1tDHx4f6+vpSBbNFixZcsWIFHz9+TJFIxOXLl+c4TnJyMhcvXkwjIyNqaGhwzJgxeX6+NmnShJ6enhw6dCjV1dWpr6/PadOmMS5O/kJVV69epYmJCW1tbfMV/fI9Y8aMoZGREV1dXWX2p7h69SoFAoE0zFkikbBWrVp0dHT8TyjGhYlSGVCSge/37uTl7t27VFNTY69evUh+83J2dnZm5cqVs1QuAgMDaW5uTjs7O7lMtDmRU5GgpKQk3r17l//88480k5u+vj67du3Ko0ePFpoCkJXMXl5e0gpy8m6THD58mAAKpexsQfLmzRva2tqyePHihZ4IKDY2lnp6enJV9JSV1NRUXrt2jZMnT2aNGjUoEomkIYxOTk48ePBgpgVZIpFwz549LFmyJAUCQZbRAfJSqVIl9ujRg+S32g79+/enqqoqjYyMOHv2bLm3LF68eEEnJyfq6enx9OnT+ZKN/JZlNH3rzMXFJdf2iYmJdHR0ZKVKlaRWl507d/7nU3EXFEplQEkmunfvTl1d3TyZaNesWUMA3Lhxo9QZKCtT6OXLl6mnp0dnZ2eFOIfFxMRw0aJFmYoEvXr1infu3OHo0aNpZ2cnVQC6devGY8eO/TQF4Efq1KnDBg0a0MvLiwDYo0cPmX9HPj4+LFu27G8dPhUWFkY7Ozva2Njw5cuXP0WGCRMmUENDg5GRkQU6z6dPn7h3717a29tLfQ1UVFTo7u7O6dOnc/369XR1dSUA1q9fn/fv31fIvEWLFs3kE/T69Wv27t2bYrGYpqam9Pf3l8sX4NOnT/Ty8qJYLM53EbPPnz9TJBKxVatWVFdXzzXENr1QVfr9SUhIoLW1NRs3bpwvOf5UlMqAkkxER0fTxMQkz+VEu3btSnV1danZ/UeOHj1KDQ0Nurm55Xnfkvz29nTu3Dl26NCBampqFIvFbNGiBY8ePcqbN2/Sz89PqgAYGBiwe/fuPH78+C9nPkwvXjN58mRKJBKuWLGCWlpatLGxYUBAQI59Y2JiqKqqqrCY9Z9BeHg47e3taWVlpTALUV6Ijo6mtrY2R48eXSjzLViwgOrq6gwODuaSJUvo4eEhLbIkEolYp04dbtiwQSF+E6mpqRSJRFy2bFmW50NDQ9m1a1eKRCJaWFhw6dKlMvvKpKSksE+fPgTAESNG5CtBWNWqVVm7dm0CyDHR0f379ykWizMoN1OmTKGKiorUd0CJfCiVASVZsnXr1hyzlX1JTGFQ2CfeeRXDoLBP/JL4P+eo+Ph4GhoaUigUZvphbt26lWKxmI0bN841PW92/FgkyM7OjjNnzuTJkyfp5+fHEiVKSCMFevTowRMnTvxyCsD3vH79OlMkwPPnz+nu7i7NwJhditzly5dTJBL9tgVY3r17RwcHBxYtWvSXKEk9cuRI6ujoFEoxrPQtuYsXL3LQoEFUUVFh0aJFOXr0aPr5+bFSpUoUCAQEwLJly3LYsGE8efJknn437969kykT39OnT9mxY0cKBAJaW1tz9erVMv12JBIJFyxYQIFAwObNm+c5pfOIESOkYZuHDh3Ksk1KSgorVapER0dHqcLy9u1bampqcvjw4XmaV4lSGVCSDRKJhA0aNKCVlZV0P/PpuzhOOBBEt9kBLOZ3mDbffYr5Habb7ABOOBDEwxdvUyQSUU1Nja1atZKar5csWUKBQMDOnTvLHeucXZGgFStWcOTIkbS1tc2gAJw8efKXVgC+Jz0ZzI/Og2lpafT396e6ujrt7OyyzABXrVo1NmzYsLBEVSiRkZF0dHSkubn5L/M29+7dO6qrq8tcYji/cwGghoYGdXR0OH369EwLfVRUFLdt28YuXbpIs2Kqq6uzfv36nDdvHoOCgmTaHrp79640/78sPHr0iK1btyYA2tracuPGjTL9Zg8ePEgtLS1WrFgxTxaN9N+ClpZWtoWF5s6dS4FAwKtXr0qPdezYkcbGxvmyNP7pKJUBJdkSGhpKTU1N9hg8ih3XXKON32Ha/nMkgxLw4yf9fLGu87hs4w4C4IIFCzhx4kQC4NChQ+UyI2ZVJGjo0KEcMGCAtBiQkZERe/bs+VspAN+Tnhwmu4f648ePWa1aNQoEAo4YMUK6p/v48WMC4I4dOwpTXIUQFRXFsmXL0tTUNNuqez+LAQMG0MDAIE9e9rKQlpbGzZs309ramgBYvnx5mfwU0pNgzZs3j15eXtJCS0WLFmXXrl25bds2RkVFZdn3yJEjBMA3b97IJeuDBw/YvHlzAmCpUqWkRY9y4u7duyxatCgtLS157949ueb7+PEjBQIBixcvzs6dO2c6HxISQnV19QyOnumFjvLrs/CnI+v6LSBJ5EJcXByKFCmC2NhY6Orq5tZcyW9At2lrcPqjAcSqapDk+g34H0IAKmIhHL8+xIH5I0ESM2bMwKhRoyAQCHLsm5qaiqNHj2L16tU4evQo1NXV4eHhAR0dHVy5cgUvX76EkZERWrRoAR8fH9SuXRtisTh/F/oT8fHxQVRUFM6dO5dtm7S0NMydOxfjx4+HnZ0dNm7ciH379mHZsmWIiIiAurp64QmcT2JiYlC3bl1ERETg7NmzcHR0/NkiZeDNmzcoUaIEpk2bhhEjRih07ICAAIwYMQJ37txB8+bNkZCQgKSkJJw9e1busb5+/YqLFy/i5MmTOHHiBIKCgiAQCFCxYkXUr18fXl5eqF69OlRUVLB27Vr07NkTSUlJUFFRkXuuO3fuYPz48Thy5AicnJwwadIkNG/eHEKhMMv24eHhaNy4MZ4+fYrt27ejUaNGMs/l4uKCz58/w8DAADdu3JAel0gkqFu3Ll6/fo3AwEBoaWlBIpGgWrVqSE1Nxc2bNyESieS+NiXfkHX9zvovruQ/zZKzIQj4Yg6hWFUuRQAAJACSUiW4q1IaOtV8oKenh+7du+eoCLx48QJjx46FjY0NmjZtimfPnsHDwwNGRkY4dOgQTp06hfr16+P06dOIiIjAypUr4enp+VsrAgBw7949ODs759hGJBJh1KhRuH37NtTU1FC1alUsWbIErVq1+q0UgY8fP6JevXoICwvDmTNnfjlFAACsrKzQuXNnzJs3D1+/flXImA8fPkSjRo3g4eEBVVVVXLx4EXv37kWtWrVw7949yPCulQkNDQ14eXlh7ty5CAwMRFhYGNatW4eSJUti5cqVcHd3h4GBAZo2bYr9+/dDX18/T4oAAFSoUAGHDx/G1atXUbRoUbRq1QoVK1bEwYMHs5TdwsICFy5cgKenJ5o0aYJFixbJfI3u7u74+PEjHj16lKHPmjVrcP78eaxevRpaWloAgH///Rc3b97EwoULlYpAIaFUBv4wtt98jbknn377Ty5v8rmh7+4LDScPtG/fHmlpaRnOJSUlYefOnahXrx5sbW3h7+8PY2NjmJub4/Hjx7h//z4aNmyIM2fOIDw8HCtWrICHh8dvrwCk8+XLFzx//hzly5eXqX2ZMmVw/fp1dOzYEXFxcTh37hwePHhQwFIqhk+fPsHLywuvXr3CmTNnUKZMmZ8tUrb4+fkhKioKa9euzdc4ERER6NmzJ8qVK4fHjx9j586duHLlCmrWrAng21vwp0+f8PLly3zLbGFhgS5dumDr1q2IjIzErVu3MHr0aMTGxuLIkSOIiYlBiRIl0KdPH+zbtw+xsbFyz1GtWjWcOHECFy5cgJ6eHpo2bYqqVavi+PHjmRZ7LS0t7NmzB0OHDsWgQYPQv39/pKam5jqHm5sbYmJiEB8fjyehL/EwPBYnbj2B38wl6Ny9Fzw8PAB8++34+fmhdevWqFWrltzXoiRvKLcJ/iDexCTAc8F5JKVKMp1LjnqF2EtbkfzuGdLiP0GgogYVQyvoVm0BzZJVsx1TRQi8Wt4Towf0xKRJk/D48WOsWbMGGzduxIcPH2BhYYHExETExMTAxMQELVu2hI+PD9zc3P7TGv/Vq1fh6uqKO3fuwMXFReZ+vr6+OH/+PLS1tRESEoIJEyZg1KhRv6ySFBsbCy8vL4SEhCAgICBXS8ivQMeOHXH+/Hk8f/4cqqqqcvX98uUL5s6dizlz5kBdXR3jx49Hnz59Mo0TEREBCwsL7NmzBy1atFCk+Blo3LgxwsPDUb16dZw8eRIhISEQiUSoVq2adEuhUqVKcv/WAgICMG7cOFy5cgWurq6YPHky6tatm8kCuGrVKvTt2xf16tXDjh07clwfrj9+De8B06BRohJU9C0ynBMAsDbQRJ1SJvhwbR/WLpiGx48fw8bGRi65lWRGuU2gJBP/7AtEajb7Amlx7yFJ/gqtsh7Q9+yJIq5tAABRe6bg873j2Y4pgQCV/p6LyZMno0yZMihdujSWLl2KxMTEb+OmpaFt27Y4e/YswsPDsWzZMtSpU+c/rQgA37YIxGKxXObyz58/Y8+ePejVqxfu3LmDYcOGYfz48XB1dUVwcHABSps3Pn/+DG9vbzx9+hSnT5/+LRQBAPjnn3/w9u1bbN68WeY+qampWLVqFUqWLImZM2eiX79+eP78OQYNGpSlQmFubg5TU1PcvXtXkaJn4v3793B2dsaSJUvw9OlThIaGYunSpTAxMcHcuXNRrVo1mJiYoE2bNli7di3evHkj07h169bFpUuXcPz4caSkpMDT0xN16tTBxYsXM7Tr1asXjh8/jqtXr6JGjRp49epVprHexCSg09rraLMxELoVGmVSBIBvObtfxSRg87WXOEwXOA9ZA6GOcZ7uiZK8oVQG/hBCIj/j4rMPSMtGGdAoURmmbSZDr2Z76Dg3gG7lpjBtPx0qJsURd2N/tuOmSYhwFoHY0BIPHz4EABQpUgSdO3fGuXPnEBYWhqVLl6J27dr/eQXge+7fv4/SpUtDTU1N5j579uzB169f0alTJ6ipqWHGjBm4fPkyYmNj4eLignnz5mXajvlZfPnyBQ0bNsTDhw9x8uRJVKhQ4WeLJDOOjo5o2bIlZsyYkat5myQOHz6McuXKoXfv3vDw8MCTJ08we/Zs6Onp5djXxcWlwJWBiIgImJubS/9fvHhx9O7dG3v37kV0dDQuXbqE/v3749WrV+jVqxesra3h6OiIwYMH49ixY0hISMh2bIFAgPr16+P69es4ePAgYmNj4ebmBi8vL1y7dk3aztPTE1evXkV8fDyqVKmC69evS89tv/kangvO40po9LcDwpyfAWn//3h6Dz14LjiP7Tdf5+GuKMkLSmXgD2HL9dcQCeXzERAIRRDrGEGS9CXHdpSkwbh6C+jo6MDBwQGhoaFYsmQJ3N3d/ygF4Hvu3bsns79AOhs3bkSdOnVgbW0tPVatWjXcvXsXffr0wYgRI1C7dm08f/5c0eLKRXx8PBo1aoT79+/j5MmTqFy58k+VJy+MGTMGz58/x86dO7Ntc/v2bdStWxeNGzeGmZkZbt26hX///Vdm03VBKwMSiQTv3r3LoAx8j1gsRo0aNTBp0iRcu3YNUVFR2LlzJ2rUqIG9e/eiYcOG0NfXh6enJ+bMmYP79+9n6QwoEAjQuHFj3L59G7t375ZuSzRq1Ai3b98GAJQuXRrXr1+HnZ0dateujV27dmHJ2RD47Q1EUqok25eQ7EjjN0dlv72BWHI2RP6bo0RulMrAH8LZJ+9l+kFKkhORlhCLlI8RiLuxH19Db0PdJudFTSAUoaRbMwQEBCA0NBSjRo1SlNi/JWlpaQgMDJRLGXj58iXOnTuHzp07ZzqnqamJBQsWSC0t5cqVw7JlyyCRZPb9KGgSEhLQuHFj3LlzB8ePH0fVqtn7k/zKuLi4oGHDhpg2bVqm+/jy5Ut06NABlSpVwvv373H48GGcOXMGFStWlHuO8PBwvH//XpGiS4mOjkZKSgosLDKb3bPCwMAAPj4+WL16NV69eoXg4GDMnj0bampqmDhxIpydnWFubg5fX1/8+++/iIyMzNBfKBSiZcuWePDgAbZt24bnz5+jUqVKaN68OR48eABjY2OcOXMGLVq0QLepa/7nqJxP5p58ih1KC0GBo1QG/gC+JKXidUz25sDv+RiwBm8XdUD4yp74eHYdNO2rw8CrT679XsckoHRZZ/j7+2PJkiXYvn17fsX+bXn+/DkSEhLk2kPfvHkztLS0cnQ2c3Nzw4MHD+Dr64t+/frBy8sLr18X3kPy69evaNq0KW7cuIFjx47B1dW10OYuCMaMGYNHjx5h//79AL6FR44YMQKlSpVCQEAAVq1ahfv376NRo0a55tDIinTH0YKyDkRERABAtpaBnBAIBHBwcMCgQYOkEQlnzpxB586dERgYiE6dOsHMzAwuLi7w8/NDQEAAkpKSAHxTCtq2bYugoCBs3LgRDx48QPny5dG6dWuEhoZixqJVMGnYP0srQ+KrB3g1868sP0lhj7OVd/zBh3gj4zNMSd5QRhP8ATwMj0WjxZdkapsS/Qapn6OR9jkaCY8vASIxDOv3hUhLP9e+B/tWR5mievD19cX+/ftx8+ZNlC5dOr/i/3bs3LkTbdq0wfv372FsnLsTFEnY29ujRo0a2LBhg0xznDx5Et27d0dsbCz8/f3RtWvXPC1YspKYmIhmzZrhwoULOHbsGNzd3QtsrsKkbt26+PjxI3x9fTF16lQkJiZi5MiRGDZsGLS1tfM1tkQigZ6eHv755x/4+fkpSOL/cfz4cXh7e+Ply5cK97p/9+4dTp8+jRMnTuDkyZN4//49NDU1UadOHXh5ecHLywulSpWCQCBASkoKNm3ahClTpuD169coN2gVPmuYS/f/vyfx1QNEbvsHOhUbQ9XcPsM5DdsKEGkWyVIekVAAV1tDbO7+e1qifiayrt+/ZrySEoWSnEUoYXaoGFpBxdAKAKBd1gOR28fh/e7JMPOdn+tiU7lqdSRHPIVIJIJEIkGZMmVQpEgRiMViiMViqKio5Pjv/J4v7LGy84e4f/8+LCwsZFIEAODKlSt49uwZVq1aJfPfycvLC4GBgRgyZAi6d++OPXv2YPXq1TKbjOUhKSkJLVu2xPnz53HkyJH/jCJAEjVr1sSUKVPw4MEDdO/eHZMmTcrTm3ZWCIVCODs7F7hlwMzMTOFjm5mZoWPHjujYsSMkEgkePHggzYg4YsQIDBo0CNbW1vDy8kL9+vXRokULdOrUCbNWbMTaCPNv4QE5oGblBC2HmjLLkyYhLj77gGfvP8PORCefV6ckK5TKwB+Aqjjvu0GaDjUQc3wJUmPCoGJomWPbSRPGwUiUiNTUVLx9+xZz5syBjY0NfHx8kJqaitTUVKSkpOT47++PJSQk5HhelrEKcl9dIBBkqSzExsZCIBCgZMmSMikWQUFB0NTUxMqVK7Fu3Tq5FBoXFxeoq6tjy5YtKFmyJHx9feHm5pZpjLwqPCTRtm1bnDlzBocOHULdunUL7H4WJpcuXcLw4cNx/fp16OnpoVixYli5cqXCrSsuLi44duyYQsdMJyIiAoaGhnJFrOSFdKXG2dkZI0eORHx8PM6fPy9VDtasWQOhUIgqVaqgSN0eEAogU2ZTSVICBCpqEOQSYZCOSCjAv9deY2ITp3xekZKsUCoDfwDFDLUgQK7KepYw5ds+oSQpPsd2AgADurSFltr/vlJlypRBu3bt0KtXL/Tpk7vfQUEgkUiQlpaWq+KhyPOzZs1C2bJlUatWrVzbJiYmIiwsDNbW1oiKisqXLACwYsUKrFixQuH3USgUonHjxoVuwVG0tefNmzeYM2cOTp48ibJly+LAgQNITk6Gj48PAgICskyskx9cXFywaNEifP78GTo6in2jDQ8PLxBLUG5oaWmhYcOGaNiwIQDg9evXOHnyJE6ePImrHwUQZW3pz0D00YVg8ldAIISalRP063SDmnnJHPukSYizT99jIpTKQEGg9Bn4Q3CfcxavcnDASYv/BJGWXoZjTEvFu03DkBL9FpYD/4VQVSPb/jaGmjg/vE6m4wMGDMCqVatw6dKl3zIETV4+fPgAY2NjbN++HW3atMm1/fbt29GuXTs8ffoUJUvm/DDMCZKQSCTYsWMHBgwYAACYO3cuGjRokCfFIjExEf7+/rhz5w769esHR0fHPFtnFH2+oHMtKFJJ+fz5M06ePAlvb28ULVpUocrRtGnTkJSUhAULFuRprOyKEeWVL0mpKDvxRI4vHYlvg/H55j5o2FaCULMIUj68RtyNfWBKIsw6zoGqWYkc5xAACJpYP8NLh5KckXX9VioDfwgTDz7E5uuvsg0vfL9nKpicADWrMhDpGCLty0fEPzqH1Oi30K/bHbpVmmc7NiVp0Hv/AINqWaBly5YoUuR/rwbJyclwc3NDREQE7ty5A0NDQ4Vf26/EmTNn4OnpieDgYDg4OOTa3tvbG3Fxcbh8+bLCZIiMjMTff/+N/fv3o3379li8eDEMDAxk7p+amooOHTpg37592LNnDxo3bqww2RQBSZmVkc+fP2Pz5s3YuHEjBAIBOnTogMaNG0MgEGRoe+XKFSxevBh+fn6wtrZWmOKSnJyMc+fOoVixYjA2NpZrrHRrT0EhEAgUanVJ1jTBfYuGcsuR8jEcEWsHQM3KCaZtJufa/siAmnCykMH8oASAUhlQ8gMhkZ9Rz/9CtufjH53HlwenkBz1EpKvnyFU1YCqmR10KjbOsTZBOpb31+PK8b1QVVXFX3/9hQ4dOqBhw4ZQU1PD69evUaFCBVSpUgWHDx9W+BvJr8T8+fMxduxYfP78OdeES+Hh4bCyssLy5cvRq1cvhcpBElu2bMGAAQOgoaGB1atXy1RuNi0tDZ06dcKuXbuwc+dONG+evRL4K5OWlobNmzdj7NixeP/+Pfr164exY8dmq4ymO7yWKFEChw4dUqgsFStWRPny5bFu3Tq5+0okkmyVherVq+Ovv/7CwIEDC906k9X5L2pGCC/TIU/3KOrAbCQ8vQLrYXty9SHY18cVLta5Rzcp+YYymkBJBkqa6qCWnRGuhEZnaR3QcnSHlqP8XuLSkJ8ZuxEWFobt27djy5YtaNGiBfT09NCqVSu0b98emzZtwl9//YUZM2ZgzJgxirikX5J79+6hbNmyMmVe3LJlC1RUVNC6dWuFyyEQCNCxY0fUqVMHPXr0wF9//YVu3bph/vz5GSw335OWloYuXbpg586d2LFjx2+rCJw8eRIjRozAgwcP4OPjgxkzZqBEiZzNz0KhEKNHj4avr69MpaflwcXFRZqpT16EQiHU1NQyOQmSRFRUFJycnH6ZctHyhDD/iFjXCEhLBVOSIFDTzLFtfhyilWSP8q7+QUxvXhZiOVMS54ZYKMD05mUBAEWLFsWwYcNw584dPHr0CP369cOZM2dQt25d9OrVC9WqVcO4ceNw+vRphcrwK3H//n2ZFhKS2LhxI5o1a5Zrjvv8ULRoURw9ehSrV6/Gzp07UbZs2Szvv0QiQffu3bF161Zs3boVLVu2LDCZCooHDx6gfv36qF+/PnR0dHD16lXs3LkzV0UgnXbt2qF48eKYPn26QuVycXHBw4cPkZycrLAxY2JikJyc/FMcCLPDWAPIm5sykPrpHQRiVQhU1XNsJ8A3h2glikepDPxBWBloYpKCw3ImN3GClUFmTb506dKYOnUqnj9/jsuXL6Np06YICQkBSTRo0AB+fn4KqfX+K5GUlIRHjx7JlIb4zp07ePjwYZbphxWNQCBAjx49EBgYCDs7O9SrVw/9+vXDly/fak5IJBL06tULmzdvxubNmwvEUlGQvH37Fl27doWzszNevHiBvXv34uLFi6hWrZpc44jFYvj5+WH37t0KrRLp4uKClJQUaSEvRZCf7IOKJCQkBAsXLkT9+vVhZWaClI8RObZPS4jNdCw5MhQJITegXswFAkHOS5K1oabSebCAUCoDfxhtK1tjuJd97g1lQBh0GK5mOVsaBAIBXF1dsXTpUoSHh2Pr1q1QVVXFnDlzULx4cdSsWRPLly/Hhw8fFCLTzyQ4OBipqakyWQY2btwIMzMz1KtXr+AF+3+KFSuG06dPY/HixVi/fj3Kly+P8+fPo0+fPli3bh02bNiA9u3bF5o8+SUuLg5jxoyBvb09Dh8+jMWLF+Phw4do3rx5nsMDO3fuDAsLC8ycOVNhcpYrVw4CgUChyYd+ljLw9etXHD9+HAMHDoSdnR3s7e0xcuRIkMSsWbPQyrU0cjI+Ru2fhfe7JiL2yg58vnccMadX492/IyBQUYN+7S45zi0SClDH3kSxF6REilIZ+APpX6ckZrYoCzWxUO5KhiKhAGpiIYa7mYNBx+Hm5oYXL17I1FdFRQXt2rXDmTNnIBAI4O3tDV1dXQwYMADm5ub466+/sG3bthzLqv7K3Lt3DwBQtmzZHNslJydj69at6NixI8Tiwn3LEQqF6N+/P+7fvw9TU1PUrl0bq1atwooVK9CpU6dClSWvpKSkYNmyZbCzs8P8+fMxZMgQPH/+HP369YOKikq+xlZTU8PIkSOxZcsWhIaGKkRebW1t2NvbK1QZCA8PB1A4ysCLFy+wdOlS/PXXXzA0NIS3tzcOHDiAevXq4eDBg4iOjsbJkycxePBg9PMql2PCIU37akhLiEPcjf2IObkcCY8vQtPeFeZdFkDFyCpHOdIkRMdq1jm2UZJ3lMrAH0rbytY4PcQdrrbfvKtzUwrSz7vaGuL0EHf0966A8+fPQyQSwd3dHc+ePZN57urVq2PevHk4duwYunfvjvDwcCxYsAAxMTFo3749TExM0KlTJxw/fhypqTnXm/+VuH//PkqUKJFrcpmjR48iOjq6ULYIssPOzk5ahU8sFmPBggW4cePGT5NHFkhi//79KFOmDPr3749GjRohJCQE06ZNU2iUU48ePWBgYIDZs2crbExFlzOOiIiAvr4+1NVz3mPPC0lJSThz5gyGDRuG0qVLw9bWFoMHD0ZCQgImT56Mhw8f4uXLl1i+fDkaN26coYbDhcM78fXFnWwXFt1KTWDeeT6sBm+DzcgDsOy/CUaNh0FFP2ffB5FQgFp2RspUxAWIUhn4g7Ey0MTm7lVxarAbOlW1gY2hJn5UCQT4llCoU1UbnB7ihs3dq0p9BKytrXHhwgVoamrCzc0Njx9nX3XsRwYOHAgfHx907doVsbGx6N+/P65cuYLnz5/Dz88Pt27dkiZqGThwIK5fv55lFbRfCVmdBzdu3IgKFSqgTJkyBS9UFpDE0KFDsWTJEqxcuRL379+HtrY2qlevjjFjxkir0/1KXL9+HW5ubmjevDlsbGxw9+5drF+/HpaWOafIzguampoYNmwY1q9fj7dv3ypkTBcXF9y/f19h6bHDw8MVahV48+YNVq1ahWbNmsHQ0BCenp7Yvn07atasib179yI6OhoBAQEYPnw4HB0ds9yGCQsLw7Bhw1BXOxIqCvb4/95RWUnBoMwzoCQD8UmpeBkdj+RUCVTFQhQz1MrVYScyMhIeHh6IiorCmTNnZF7k4uLiULlyZairq+Pq1avQ1PyfIyJJ3L17F1u2bMG2bdsQERGBEiVKoEOHDmjfvj1KlSqVr+tUNCRhaGiIIUOGYNy4cdm2+/DhAywsLDB37lwMHDiwECX8BkmMHDkSc+fOxdKlS9G3b18A30zvs2bNwqRJk1C6dGls2rRJoeF1eSU0NBSjR4+WRkLMmTMH9evXL/B54+LiYGNjg86dO8Pf3z/f4506dQpeXl548uQJ7O3z77Pj4+ODT58+4dSpU3nqn55o6ejRozh27BgCAwMhEong6uoKb29vNGzYUOrrIAsk0axZM9y4cQOPHj3CiWef4bc3ME+yZcWsFmXRprJyiyAvyLp+Ky0DSjKgpSaGk0URuFjrw8miiEyeu6ampjh79izMzc1Ru3Zt6d55bujq6mLPnj0ICQlBv379Mrz5CwQCVKhQAfPmzcObN29w+vRpuLm5wd/fHw4ODqhUqRIWLFggdaT62bx9+xYfP37MdQHdtm0bSKJdu3aFI9h3kMQ///yDuXPnYuHChVJFAPjmzzF27FjcvHkTAoEAlStXxpQpUwo8C152REdHY8iQIXBwcMClS5ewbt063L17t1AUAeDbd3PQoEFYtWoV3r9/n+/xXFxcAEBhWwURERFyWwYiIiKwbt06+Pj4wMjICLVr18aGDRtQoUIF7NixA1FRUbhw4QJGjx6N8uXLy+WEuWvXLhw8eBBLly6Fvr4+2la2RpcK/5/gKZ8WvRFepZSKQCGgVAaUKARjY2MEBASgePHiqFu3Lm7evClTvzJlymDlypXYsGFDthnaRCIRPDw8sG7dOkRGRmL37t2wtraGn58fLC0tUa9ePWzYsAFxcXGKvCS5SFeAcgsr3LhxIxo1aiRzeWNFMmHCBMycORPz58/P1irh7OyMGzduYOTIkZg4cSKqV6+u0JC43EhMTMScOXNgZ2eHNWvWYMKECQgJCUHXrl1lSuSkSAYOHAiRSIQFCxbkeywjIyNYWloqTBmQpUhRamoqLl++jLFjx6JChQqwsLBAjx498PbtWwwfPhy3bt1CREQENmzYgNatW0NfP29Z/T58+ID+/fujZcuWaNGiBYBvTrKHZvaD6PZ2qKmI8uyoPKtFWfSrY5cnuZTICWUgNjaWABgbGytLcyV/MJ8+fWL16tWpq6vLy5cvy9yvV69eVFNT4507d2TuExMTw9WrV7N27doUCARUV1enj48P9+/fz8TExLyIn2emTJlCfX19SiSSbNsEBQURAPfu3VuIkn1j4sSJBMDZs2fL3Of69et0cHCgqqoqZ8+ezdTU1AKTLy0tjVu2bKGNjQ1FIhH79u3LyMjIAptPVkaOHEkdHR3GxMTke6zGjRvTy8sr3+NIJBKqq6vT398/07nIyEhu2rSJbdu2pb6+PgHQ0NCQ7du357///suoqKh8z/8jHTt2pL6+PiMiIqTHhg4dShUVFd66dYuvo+PZcc012vgdpu0/R2jjdzjbT/r5jmuu8XV0vMJl/RORdf1WKgNKFE5cXBzd3NyopaXF8+fPy9Tn69evrFChAm1tbfnx40e553zz5g1nz57N8uXLEwD19fXZs2dPnjt3jmlpaXKPJy8tW7Zk7dq1c2wzYsQIGhoaMikpqcDl+Z4pU6YQAGfMmCF334SEBA4bNowCgYCurq58+vSpwuU7e/YsK1asSABs1qwZHz9+rPA58sq7d++orq7OSZMm5Xus8ePH09jYOEeFURY+fvxIANyxYwfT0tJ4/fp1TpgwgZUrV6ZAICAAVqxYkePGjePVq1cLVIk7cuQIAXDDhg3SY0ePHiUAzp8/P0Pbp+/iOOFAEN3mBLDYD0pAMb/DdJsTwAkHghgSGVdg8v6JKJUBJT+VL1++sG7dutTQ0ODp06dl6hMaGko9PT02bdo0Xw/MoKAg/vPPPyxWrBgB0MrKiiNHjuT9+/fzPGZu2NnZcdCgQdmeT0lJobm5Ofv3719gMmTFjBkzCIBTpkzJ1zgXL15kiRIlqKGhwUWLFilEwXr48CH/+usvAmCVKlV44cKFfI9ZEAwYMID6+vqMi8vfIrVv3z4C4Nu3b/M1zuXLlwmA9evXp7GxMQGwSJEibN26NTds2MB3797la3xZiY2NpZWVFb28vKS/1/DwcBobG9Pb2zvH78iXxBQGhX3inVcxDAr7xC+JKYUi85+IUhlQ8tNJSEhggwYNqK6uzmPHjsnU5+DBg3Kbs7NDIpHw0qVL7NOnDw0NDQmAZcqU4YwZM/jy5ct8j59OXFwcBQIB169fn22bY8eOEQBv3rypsHlzY86cOQTACRMmKGS8L1++sF+/fgTAOnXq8MWLF3kaJyIigr169aJQKGTx4sW5ffv2fL8tFySvX7+miopKvr+TL1++JAAeOnRIrn4SiYR37tzh1KlT6erqKn37d3Bw4OjRo3nx4kWmpBT+YtqnTx9qaWlJvwdpaWn09PSkmZnZL7HFo+QbSmVAyS9BYmIiGzduTFVVVR48eFCmPn5+fhSJRDJvMchCUlISDx06xLZt21JDQ4MAWLNmTS5fvpwfPnzI19jpb2o5+Tu0bduWjo6OhbboLViwgAA4ZswYhc95+vRpWltbU1tbm6tWrZJ5/C9fvnDixInU0tKivr4+58+fX+i+HXmlZ8+eNDExYUJCQp7HkEgk1NfX5+TJk3Nt++nTJ+7atYtdu3almZkZAVBHR4ctWrRgt27dCIDx8T9vT/38+fMEwMWLF0uPzZw5kwKBQGZLoJLCQakMKPllSEpKYsuWLSkWi7l79+5c26ekpLB27do0MzPL4JSkKOLi4rhp0ybWr1+fIpGIKioqbNy4Mbdv356nB+yyZcsoFouzXdg+ffpEdXV1zpo1K7+iy8SiRYsIgKNGjSow5SM2Npbdu3cnADZo0CBH03dKSgpXrVpFMzMzqqqqcvjw4QpxyCtMnj17RqFQyEWLFuVrnLp167J58+aZjkskEj548IAzZ86ku7s7xWIxAdDR0ZHDhw9nQECA1Ndk1qxZLFKkSL7kyA8JCQksWbIka9SoId0KuHbtGsViMf38/H6aXEqyRqkMKPmlSElJYbt27SgSibhly5Zc20dERNDc3Jzu7u4FagJ99+4dFy1axKpVqxIAtbW16evry+PHj8s8b69evVi2bNlsz69atYpCoZBhYWGKEjtbli5dSgAcPnx4oVghDh8+THNzc+rp6XHTpk0Z5pRIJDxy5AidnJwIgO3bt8/z1sKvQMeOHWlpaZkvB9Bhw4axWLFiJL8ppfv27WOvXr1oaWlJANTU1GTjxo25fPnybLeyBg8eTAcHhzzLkF9GjhxJNTU1BgcHk/ym7BYrVozVqlVjcnLyT5NLSdYolQElvxypqans3LkzBQJBBu/j7Dh//jxFIlGhvW2EhIRw0qRJtLe3JwCamppy4MCBvH79eo4La9WqVdmxY8dsz9eoUYP169cvCJEzsHLlSgLg4MGDC3UPPjo6mh06dCAANm3alO/evePt27dZt25dAmDt2rUL1VeioHj48CEFAgFXr16dp/4SiYSzZ88mALq5uVFFRYUAaG9vz8GDB/PEiRP8+vVrruO0bt2adevWzZMM+eXmzZsUCoWcPn06yW/X1KZNG+rq6jI0NPSnyKQkZ5TKgJJfkrS0NPbs2ZMCgYCrVq3KtX36w/PAgQOFIN03JBIJb968ycGDB0v3a0uWLMkJEyZkCq1LTU2lhoYG586dm+VYISEhBMCtW7cWqMxr164lAPbv3/+nOePt2bOHBgYGVFVVJQCWLl2ahw4d+qWdA+WlZcuWLFGihMxWo/j4eB4+fJh9+/aVRrekR08sWrSIISEhcstQq1YtdujQQe5++SU5OZnlypWjs7Oz1AKQ/r3bvn17ocujRDaUyoCSX5a0tDSpV/qSJUtybCuRSNisWTPq6enx+fPnhSTh/0hNTeWpU6fYpUsX6ujoEAArV65Mf39/RkRE8PHjxwTAU6dOZdl/3Lhx1NXVzZfjWW5s2LCBAoGAffr0+WkL78ePH6XmYzU1NQKgj49Pvp0zfzXu3LlDAPz333+zbRMSEsKFCxeyQYMG0ntRvHhx9uvXjwcPHqSGhgbnzZuXZxlKlCjB4cOH57l/Xpk6dSpFIhFv375Nknz06BE1NTXZvXv3QpdFiewolQElvzQSiYRDhw4lgFwfjB8/fmSJEiVYoUIFmcyoBUVCQgJ37tzJpk2bUkVFhUKhkOXKlSOALBWVtLQ02tjYsEePHgUm0+bNmykQCNizZ89CSa70I0lJSfT396ehoSE1NTU5fvx4xsbGcsuWLdTX16epqWmhWnUKg4YNG9LR0VF6v79+/coTJ05w0KBBLFmyJAFQRUWFnp6enD9/Ph8/fpxBScttWyknJBIJNTU1MyX0KWgePnxIVVVV6Zbd169fWb58eTo4OPDLly+FKosS+VAqA0p+eSQSCUePHk0A0j3I7Lh79y7V1NTYq1evQpIuZ6Kjo7ly5UpaWVkRANXV1dm6dWseOHBA6mB29uxZAuDFixcLRIatW7dSKBSyW7duha4ISCQS7ty5kyVKlKBQKGSPHj0yOUiGhYWxYcOGBMDOnTvnKbPkr8iVK1cIgD179uRff/1FTU1NaXKr3r17c//+/fz8+XO2/f/++286OTnlae70Z/G2bdvyKr7cpKamsnr16rS3t5cq4wMGDKCamhrv3btXaHIoyRtKZUDJb4FEIuGkSZOkyXFyMnOvWbOGALhx48ZClDBnGjZsyDp16nDmzJlSK4GBgQF79+5Nb29v2traFojpfseOHRQKhezcuXOhKwKXL19m9erVCYANGzZkYGBgtm0lEgnXrl1LHR0dWlpa8sSJE4UoqeJISkrimTNnOGzYMDo6Okr3/t3d3Tlr1iwGBgbK/HdeuXIlRSJRnraOgoODCUChOThyY+HChRmU2vTEYN/nGFDy66JUBpT8VqSnzfXz88v2oSqRSNilSxdqaGjwwYMHhSxh1lhYWHD06NHS/wcGBtLPz09qMShSpAhHjRqlUHl3795NkUjEDh06FGje+R95+vQpW7RoQQB0cXHhmTNnZO776tUrenp6EgB79+6d79S+hcGbN2+4atUqNm/enNra2gRAMzMzduvWjRMmTCAAHj16VO5xb9y4QQC8fv263H0DAgIIoEBqRGTFixcvqKmpyX79+pEk3759S0NDQzZp0uQ/5Rj6X0apDCj57Zg/fz4BcMiQIdk+aOLj41muXDmWLFnyp38fo6KisvWk3rBhgzS23sDAgABYtmxZzpw5k69evcrznPv27aNYLGbbtm0LLQXt+/fv2b9/f4rFYlpbW3Pz5s15skZIJBIuW7aMmpqaLF68OM+dO1cA0uadlJQUXrhwgX5+flIrj1AoZI0aNTht2jTeuXNH+r2USCSsXr06q1evLvei+PXrV4pEIq5YsUJuGbds2UIAOW5DKAqJREJPT09aW1szLi6OqampdHd3Z9GiRf9zjqH/ZZTKgJLfkiVLlhAA+/Xrl+2C8/TpU+rq6rJVq1Y/9e3k9OnTBJBllT0PDw+6u7uT/GZiPnDgANu0aUN1dXVpnPnKlSsZHR0t83wHDx6kiooKfXx8CkURSEhI4PTp06mrq0tdXV3OnDlTIVERz549Y61atQiA1Cq2bgAAJy1JREFUgwYN+qlpdSMiIrh+/Xr6+PiwSJEiBEBjY2P6+vpy27ZtOf59Dh8+TAAMCAiQe94yZcqwd+/ecvebM2cOdXR05O6XF9atW0cA0roiU6ZMoUAg4NmzZwtlfiWKQakMKPltWbVqFQUCAXv06JGtQrBnzx4CyLKme2Exd+5camhoZDLVv379mgKBgOvWrcvUJy4ujhs3bqSXlxeFQiFVVFTYtGlT7ty5M8eF9siRI1RVVWWLFi0KPMtbWloaN2zYQEtLS4rFYg4cOJBRUVEKnSM1NZXz5s2jmpoa7e3tefXqVYWOn9O8V65c4dixY6VlkwUCAatUqcKJEyfyxo0bMls9JBIJnZ2d6eHhIbccnTp1YpUqVeTuN3ToUNrb28vdT17Cw8Opp6dHX19fkuSlS5coEok4bty4Ap9biWJRKgNKfms2bNhAoVBIX1/fbPfFhw4dSrFYzMuXLxeydN/o1KkTq1atmun4tGnTqKmpmeu+eEREBP39/Vm5cmVpIZrOnTvz5MmTGa75+PHjVFNTY9OmTfOVClcWTp06RWdnZwJgq1at8pQURx6Cg4NZpUoVCoVCjho1qkAKF0VFRfHff//NsGWjr6/Pdu3acfPmzXz//n2ex969ezcByK3MzJ8/n+rq6nJbeNq2bcvatWvL1UdeJBIJmzdvThMTE3748IExMTG0trZmjRo1fkp1RCX5Q6kMKPnt2bZtG0UiEdu2bZvl23BycjJr1KjBokWL5uuBnlfKli2bKdRRIpHQ3t5e7jjyp0+fcuLEidI4dTMzMw4ePJhLliyhmpoa//rrrwJVBB48eMAGDRoQAF1dXXnlypUCm+tHUlJSOG3aNKqoqLBMmTLSpDZ5JS0tjTdv3uSkSZNYtWpVacnfChUqcOzYsbx8+bLCHC/T0tJYunRp/vXXX3L1Sw87DQoKkqufu7s727VrJ1cfedm1axcBcNeuXZRIJGzZsiX19PQUWvZbSeGhVAaU/CfYvXs3xWIxW7RokeVi+PbtW5qYmNDT07NQPesTExMpFou5bNmyDMevXr2aY0bC3JBIJLxx4wYHDRpEfX19AqCWlhbHjRtXIG/pb9++Zbdu3SgUCmlnZ8fdu3f/ND+M+/fv09nZmWKxmBMmTJBrOyQmJobbt2+nr68vTUxMCEDqV7Ju3TqGh4cXmNybN2/OtYT1j3z8+JEAuHnzZrnmsre359ChQ+UVUWaio6NpYmLC5s2bUyKRcMWKFQQgU7VRJb8mSmVAyX+GgwcPUlVVlY0bN87SjHz69GkKhUKOHz++0GRKT0v74xbF33//TUtLy3wrJufOnaOGhgYrVKjADh06SEPbqlatyoULF/Ldu3f5Gj8uLo5jx46lhoYGDQ0NuWjRogLfgpCFpKQkjhs3jiKRiC4uLtmGZEokEt69e5fTpk1jzZo1KRQKpREbo0aN4vnz5wutgl5KSgptbW3ZqlUrufoVL15c7oVdW1s72zoYiqBz587U09NjeHg4g4KCqK6unidHRyW/DkplQMl/imPHjlFdXZ3169fP0tFu6tSpFAgEUs/ngmb9+vUEkMEv4OvXr9TT08uQdyAvXLx4kVpaWvTw8JBea3x8PLdv384mTZpQRUWFIpGI9evX56ZNm+SK2U9JSeGyZctoYmJCdXV1+vn58dOnT/mStyC4efMmS5cuTVVVVc6YMYMpKSmMjY3lnj172L17d1pYWEitJs2aNeOqVav4+vXrnyZvutPro0ePZO7TokUL1qlTR+b2cXFxBCBTCfC8cOzYMQLgunXrmJCQQCcnJzo5ORVoXQ0lBY9SGVDyn+P06dPU0NBg3bp1M+VDT0tLY8OGDWlgYJCvOH5ZGTx4MO3s7DIc27lzZ7ahhrJy5coVamtrs3bt2tmG3H348IErVqyQhudpaGiwbdu2PHToULZvwxKJhPv372epUqUoEAjo6+v7UxdPWUhISGDXrl2lzpVisVhaDXHo0KE8ffp0gTgc5oXExERaWlqyU6dOMveZMmUK9fT0ZN6WefLkSZ5DGXMjLi6O1tbW9PT0pEQiYZ8+faiurp5jdkklvwdKZUDJf5Lz589TW1ubtWrVyvRGHB0dTRsbG1apUqXATd61a9dmy5YtMxxr1KhRltEFsnLt2jXq6OiwVq1aMhd/efnyJWfMmMEyZcoQAA0NDdmnTx9evHhRGiJ348YNurm5EQA9PT3l2tsubD5//swDBw6wd+/etLa2JgCqqalRU1OTYrGYY8eO/SkFmWRh4cKFFIlEMlfXTM9T8OLFC5nanzt3Lt/KZnb079+fmpqaDA0NlYbtLl++XOHzKCl8lMqAkv8sV65coa6uLqtVq5ap+M3NmzepqqrK/v37F9j8EomE+vr6nDJlivTYu3fvKBKJMjkUysrNmzdZpEgR1qhRI8+peu/fv8+RI0dKUyEXLVqUpUuXJgCWKVOGx44d++VSyEokEj5+/JgLFixgvXr1qKqqSgC0s7PjwIEDefz4cX79+pVfvnzhgAEDpAmbfkY569yIj4+niYmJzMW0wsLCCIB79+6Vqf22bdsK5Dl88eJFCgQC+vv789WrV9TT02OLFi1+ue+KkryhVAaU/Ke5efMm9fX1WbFixUxZ4pYtW1agld1evXpFADx48KD02Lx586iqqipXRsF0bt++TT09PVavXl0hv7GoqCi2bt2aQqFQGlZXvnx5zp49+5fYGkhISODRo0fZv39/2traSt/+69evz4ULF+aYdz8gIIA2NjbU0tLi8uXLf7kFa+bMmVRRUeGbN29ybSuRSGhiYiJzIp958+ZRS0tLodf89etXlipVitWrV2diYiJr1qxJKyurPH2PlfyaKJUBJf957t69SyMjI5YvXz5DngGJRMIOHTpQS0tLLocuWUmv2vb9wlquXLlM2waycPfuXerr67NKlSr5duRLTEzk3Llzqa+vT21tbU6ePJnR0dHcv38/fXx8qK6uToFAQHd3d65atYoxMTH5mk8enj9/zsWLF9Pb21uaktnGxoZ9+vThoUOHZN4WIb/tb/fs2ZMA6OXl9UsoOOnExsZSX1+fgwYNkql9/fr1Zc5RMHz48Ex+Kvll9OjRVFVV5cOHDzl+/HgKhcICK7mt5OegVAaU/BEEBgbS1NSUTk5OjIiIkB7//PkzHR0dWbp0aYUXdZk8eTL19fWlb2h3797NZCmQhQcPHtDQ0JAVK1bMtN0hD2lpady6dSuLFStGkUjEv//+O8vQw9jYWK5fv56enp4UCoVUVVVls2bNuGvXLmmdekWRmJjIkydPcvDgwbS3tycAqqiosG7dupw7dy4fPXqU7zfcY8eOsWjRotTV1eX69et/GSvBxIkTqaGhwcjIyFzb+vn5sWjRojKN26FDB9aqVSu/4km5c+cORSIRp0yZwnPnzlEoFHLy5MkKG1/Jr4FSGVDyxxAcHExzc3OWKlWKb9++lR5/9OgRtbS02L59e4UuFC1btsyQEnbw4ME0NjaWK649KCiIxsbGdHFxyZdJ9ty5c9J0xk2aNGFwcLBM/cLDwzl//nxWqlRJmqCna9euPH36dJ5zJLx69YrLly9nkyZNqKWlJfVb6NmzJ/ft21cgZYtjYmLYqVMnAmDjxo0zKIQ/i+joaGpra9PPzy/Xtjt27CAAmTJo1qlTh23atFGEiExOTqazszPLlSvHiIgIFi1alO7u7oWauEtJ4aBUBpT8UYSEhNDKyoolSpTIEFqY7nSVV8e+rLCzs+PgwYNJfnuoGhsbS/8vC48ePaKJiQnLlSuX51KwwcHBbNKkCQGwcuXK+SoH/PjxY44fP54lSpQgAJqbm3PIkCG8detWjkpUcnIyz549yxEjRtDJyYkAKBKJ6ObmxhkzZvD+/fuF9ra+f/9+mpiY0MDAIMuS0oXNqFGjqK2tnaui9/TpUwLgiRMnch3TwcFBru9ZTkyfPp1CoZA3b95kkyZNaGBgIJOfg5LfD6UyoOSP48WLFyxevDhtbGwyeJv379+fqqqqvHHjRr7nSE/8sn79epL/8x+4e/euTP0fP35MMzMzlilTJk/1FN69e8e///6bIpGIxYoV47Zt2xQWaieRSHjt2jUOGDBAmtK3VKlSnDx5Mp89e0bymwf8mjVr2KJFC+ro6BAATU1N2aVLF+7cuTNf2x35JSoqij4+PgRAHx+fn1KvIp13795RXV2dEydOzLFdWloadXR0OHPmzFzH1NXV5ezZs/MtW3BwMNXU1Dhy5EhpyfADBw7ke1wlvyZKZUDJH8nr169ZsmRJWlpaSr3Sk5KSWLVqVVpbW+f5TTydy5cvZ1j8W7ZsyXLlysnU9+nTpzQ3N6ejo6NM+8nf8+XLF06ePJna2trU19fnvHnzCjThTkpKCo8dO8b27dtTQ0ODAKipqSkt+Vu9enVOmTKFt2/f/uXi/rdv304DAwOamJhw3759P02OgQMHUl9fP9ftkZo1a+Zq/o+Pj89TLYMfSUtLY40aNViyZEleu3aNampqBRqGq+Tno1QGlPyxhIeH08HBgWZmZtJoglevXtHQ0JDe3t75WryWLl1KsVjMxMRERkdHU1VVlfPmzcu137Nnz1i0aFE6ODjIVVcgNTWVa9asoYWFBVVVVTl06NACD/uKjIzkxo0b2aZNG+rp6UkzABYtWpQikYgikYje3t78999/Fe6cqSgiIiLYuHFjAmDHjh0LNXIinTdv3lBFRYWzZs3Ksd2AAQNob2+fY5tnz54RAE+fPp0vmRYvXkwAPH78OB0cHFiuXDmFO48q+bVQKgNK/mjevXvHMmXK0NjYWFrs5tixYxQIBJw6dWqex+3Vq5fUErB06VKKRKJcF/fQ0FBaWVnR3t5e5up5EomER48elWYWbNu2LUNDQ/Msd06kpqby2rVrHD9+vNShMN0XYcKECbx27ZrUsSwqKorLli1jjRo1pNaCdu3a8fDhw4VWGEhWJBIJN2zYQF1dXVpYWBRa3Yrv6dmzJ01MTHLM779u3ToKBIIcFasLFy4QQL5CZV++fEktLS326dOHPXr0oKamZoGE3ir5tVAqA0r+eKKioujs7EwDAwPevn2bJKWx1Hl9w6pSpYo0/3yVKlXYqFGjHNu/fPmSNjY2LFGiRIZIh5y4c+cOPTw8pNn2FOHr8CMfPnzgli1b2KFDBxoaGhIA9fT02KZNG27cuFEm68WLFy84bdo0Ojo6EgCNjIzYt29fXr58+ZcJ8yO/bR3Vq1ePANijR49CfY49f/6cIpGIixYtyrZNemjqpUuXsm2THnWQV58MiUTC+vXr09LSkuvWrSMArlmzJk9jKfm9UCoDSpTwW+hZ5cqVqaenx+vXrzM1NZX16tWjsbGxzItzOqmpqdTQ0ODcuXMZHBxMANy5c2e27V+/fs3ixYvT1tZWpsQ4r1+/pq+vLwUCAR0cHHjgwAGFLappaWm8desWJ0+ezOrVq0tL/jo7O/Off/7hpUuXmJKSkqex08sJjxgxgkWLFiUAFi9enGPGjPll3jwlEglXrFhBLS0t2tjYFEixn+zo2LEjLS0ts62XkZSURBUVFS5evDjbMRYsWEB1dfU8fx82btxIAFy7di11dXXZpk2bX0phU1JwKJUBJUr+n9jYWLq6ulJHR4eXLl3i+/fvaWlpyRo1ashl2n78+LF039bPz496enrZ7re+ffuWJUqUYLFixXKtovjp0yf6+flRXV2dJiYmXL58eZ4X5u/5+PEjd+7cyS5dutDU1FS699+yZUuuXbuWYWFh+Z7jR9LS0nj27Fn26NFD6m/g7OzMOXPmyK18FQTPnz+nu7s7AXDAgAFyZT7MKw8fPqRAIODq1auzbePi4sJu3bple37kyJG0tbXN0/wRERHU19dn+/btWa1aNRYrVuyXLFutpGBQKgNKlHzH58+f6e7uTi0tLZ49e5ZXrlyhWCzm0KFDZR5j+/btBMB3796xaNGi/Pvvv7NsFx4ezpIlS9La2jrHinRJSUlctGgRjYyMqKGhwXHjxuUrMY9EIuH9+/c5Y8YM1qpViyKRSFqkaMSIETx79myBV3P8nsTERO7du5etWrWimpoaBQIB69SpwzVr1vzUEMS0tDT6+/tTXV2ddnZ2vHz5coHP2apVK9ra2mar5HXr1o0uLi7Z9u/UqRNr1KiR57mNjY05aNAgikQiXr16NU/jKPk9USoDSpT8QHx8PD09PamhocFTp07R39+fALhnz55s+3xJTGFQ2CfeeRXDv/2msqiNLU+ePEkAWT5UIyIi6ODgQEtLS2ls/o9IJBLu3r2bdnZ2FAgE7NatW57fmuPi4rh371726NFDaqLX0tJikyZNuGLFilytEoXFp0+fuG7dOnp4eFAgEFBNTY0tWrTgnj17fpo3++PHj1mtWjUKBAKOGDGiQOW4c+dOjqGBixcvpoqKSrbKmoeHB318fOSeN70c8ZgxYygQCDh9+nS5x1Dye6NUBpQoyYKvX7/S29ubampqPHz4MH18fKirq5uhUt7Td3GccCCIbrMDWMzvMG2+/4w6xFLDttG21Sg+icj4e4iMjKSjoyMtLCyyrbx35coVurq6EgAbNGggjXSQFYlEwocPH3Lu3LmsW7cuVVRUpMmBhgwZwlOnThVo/gFFEBYWxnnz5rFChQoEwCJFirB79+48c+ZMoafDTU1N5cyZM6mqqkpHR0fevHmzwOZq1KgRS5cunWVo66VLl3JMXuXo6MiBAwfKNV9MTAzNzMzYoEEDmpmZ0cPD45fLCaGk4JF1/RZCiZI/CHV1dezbtw8NGjRA8+bN0bx5c5iZmaFVq1Z4GhaNTmuvo57/BWy+/gqvYhLAHwcQCJCoogOJXU14LbyITmuv401MAqKiouDh4YGYmBgEBASgZMmSGbo9e/YMrVq1gqurKxISEnDq1CkcO3YMZcuWzVXm+Ph4HD58GH379kXx4sXh5OSEsWPHQl1dHQsWLMDz58/x+PFjzJ8/H56enlBTU1PcDSsALCwsMHToUNy+fRvBwcEYMGAAzp49Cw8PD9jY2GD48OG4e/cuyEx3X+GIRCKMGjUKt2/fhpqaGqpVq4bx48cjOTlZ4XONGTMGwcHB2LdvX6Zz5cuXh0AgwN27d7PsGxERAXNzc7nmGzZsGL5+/Yrk5GSkpqZi8+bNEAqVj3wlWSOgDL+4uLg4FClSBLGxsdDV1S0MuZQoKVBSUlLQoUMH7Nu3DzNnzsS07Weh59ELApEYaRLZFyGRUACxEBDe2YOPt4/g3LlzcHBwkJ7/8OEDpkyZgmXLlsHMzAzTpk1Dx44dc30oh4SE4OjRozh69CjOnz+PpKQk2NraomHDhmjYsCFq164NDQ2NPF//rwZJXL9+HVu2bMGOHTsQFRWF0qVLo0OHDmjfvj2KFy9e4DKkpKRg+vTpmDp1KsqUKYONGzeiXLlyCp3Dw8MDHz9+xO3btyEQCDKcK1WqFOrXr49FixZlOP7161doampi48aN8PX1lWmeU6dOwcvLC23atMGOHTtw5MgRNGzYUGHXoeT/2rv7qKjKfQ/g382MvA1vAwyjqIOB2hHRe03Nk2KGgpYWJb7mpLnU7s2rXtPCjrJcWr5kdpd2s5uVSnpr8PSCYSkqR0Eqwda5kW+IkoSigjOCCgwMIzOz7x8e5oTIvMCIL/P9rDUr2LP3s/du4ezvPPu3n+fB4ej1m2GA3JbJZMLMmTOxp9SEoCenQxTFFh/QDhFFQBAw/V+CsGrqMAC3PsA/+OADrF27FgCwdOlSLFy4sNULuMFgQG5uLjIzM7Fv3z6cO3cOnp6eGDFihDUA9OrVq23H94BpbGzEwYMHodFokJGRgbq6OgwdOhRqtRqTJk2CQqG4q/svKCjAjBkzUFxcjBUrVuDNN9+EVCp1Sds5OTkYOXLkHS/OL774Ii5duoQff/yx2fLS0lJERkYiKysLCQkJdveh1+vRr18/KBQK/Prrr1iwYAE2bNjgkuOnBw/DAJED0n4+j2UZhS2WV+7ZiLpTh1rdruu87ZD6h7ZY/s74GJjO/oCUlBRUVFRg7ty5WL58+R0vYKWlpdi3bx8yMzORnZ0Ng8EAlUplvfjHxcXBz8+vfSf4gKurq8Pu3buh0Whw4MABCIKA0aNHQ61W4/nnn4dMJrsr+zUajVi5ciXWr1+PgQMHYseOHejTp0+72xVFEcOG3QqMR44caRbu1q9fj1WrVqG6urpZz9GRI0cQGxuLU6dOoW/fvnb3sXDhQmzZsgVKpRJyuRz5+fn3/a0junsYBojsuHitHvEbc2E0WVq8Z7xchMbrV25bKuLagf+BNFCJ8Dkf3blRcyMuf/oqEkcNw7p165rVDhiNRvz000/W7v8zZ85AKpVi+PDheOaZZzB27FhER0e7xbf/trh69Sq+/vpraDQa5OXlQSaT4YUXXoBarUZCQoLLvr3/0dGjR/Hyyy/jwoULWLNmDV577TVIJJJ2tZmZmYlx48YhOzsbcXFx1uVNXfvFxcXN/m6++eYbTJo0CVVVVQgODrbZdl5eHmJjYzFw4EAUFRWhoKAAvXv3btfx0oONYYDIjunbfkbe71UO1wg0XCyEVvMmgp6cgcChk++8ksWMmDAv7Hl9DADg4sWL1m//hw4dgl6vR3h4uPXiHx8fz39TbVBaWoq0tDRoNBoUFRVBoVBgypQpUKvVGDJkiEsDVX19PVJSUvD+++8jNjYW27dvR1RUVJvbE0URAwcOhFwux6FD/+x9qqyshEKhwJdffonJk//597Vp0yYkJyfDYDDYPK+GhgYMGDAAjY2NKCkpcarGgB5ejl6/WVpKbuk3bS1+PFfpVLFg3elcAAJk0SNaX8lDglOVJsz9y1vo378/VCoV5s6di6qqKixbtgzHjh3DpUuXsHXrViQlJTEItNEjjzyClJQUFBYWWu/x79q1C0888QR69uyJ5cuX48yZMy7Zl6+vLzZu3IjDhw/j8uXL6N+/Pz766CNYLC17lBwhCAJSUlKQnZ2N/Px86/LQ0FB069atxRMF5eXl6NKli92As2bNGpSUlKC8vBxqtRrTp09v0/GRe2LPALmlld8V4vOfLzgcBkSzCZc+nIFOId3Q+aX1tte1mGEuykF88HWMHTsWCQkJkMvlrjhsssFsNiM3NxcajQbp6emorq7GY489BrVajalTpyI8PLzd+9Dr9UhOTsbHH3+MUaNGITU1FSqVyul2LBYLYmJiEBkZiT179liXJyYm4ubNm9i/f7912cyZM1FcXIy8vLxW2zt+/DgGDRqEsLAw+Pj4oKCggJ/VBIA9A0Q25ZzVOdUrYCgtgMVQA1n0U3bXFTwkiBqeiO3bt2Py5MkMAh1EIpFg5MiR2LZtG65cuYL09HT06NEDS5cuRbdu3RAfH4/U1FRUV1e3eR9+fn7YvHkzDhw4gLNnzyImJgapqalOj4ng4eGBZcuWYe/evc16AgYMGNBijIWmnoHWmEwmzJo1C0FBQdBqtdi5cyeDADmNYYDcjt5oQtm1eqe2qTudC3hI4dsn1qH1y67Vo85oasvhkQt4e3sjKSkJ6enp0Gq12LJlCywWC+bMmQOlUomJEyfi22+/hdFobFP7o0ePxsmTJzFhwgTMnj0bzz77LMrLy51qY+rUqYiMjLQ+fgrcCgM6nQ4VFRXWZRUVFTZ7NTZs2IBjx46hsrIS69atw+DBg50/IXJ7DAPkdi5U1bUcWdAGy00DDL8dhc8jAyDxcewblwjgfFVdm46PXCsoKAizZ89GdnY2ysrKsHr1apSUlCApKQmdO3fGK6+8gsOHDztdAxAUFITPPvsM3333HX755RfExMQgLS3N4V4CqVSKpUuXIj09HUVFRQBuhQEAzXoLbI0+2DQWgre3N8aMGYPFixc7dQ5ETRgGyO3cvMOjhLbUFx+F2GiErO9TTm2X/OZSzJ8/H6tWrcKnn36K3bt3Iz8/H7///jvq6hgU7oVu3bpZhzsuLCzEvHnzcPDgQcTFxSEiIgJLlizB8ePHner2f+6551BYWIgxY8ZArVZj4sSJ0Ol0Dm07Y8YMdO3aFe+88w4AQKVSQS6XW8OA0WhEVVXVHXsGmno6BEGAn58fduzYweGGqc1c/2Au0X3OU+rcB2bd6cMQPH3g02uIU9vpq2/gh+OnoNVqUVlZ2eKbp0wmg1KpRFhYGJRKZbPX7csCAwM5/oCLRUdHY/Xq1Vi1ahXy8/Oh0WiQmpqK9957D9HR0dahkHv06GG3rZCQEOzcuRNJSUmYO3cuYmJisHnzZkyYMMHmdp6enliyZAkWLVqEFStWICoqCgMGDMD/HTuJwvJqlF0qR6ewRyBXdG6x7SeffGIdrTAjIwNKpbJN/x+IAD5NQG6ozmhCzMoDDt0qMNdX49KHMyDr8yRCn3vd4X0IAE6tHAOZ1628bTabUVVVBa1Wa33pdLpmv/9xWWNjY7P2PD09WwSE1n4PCQlp98A47qqxsRFZWVnQaDTYvXs36uvrMWzYMOtQyKGhLUedvJ1Wq8Wrr76KjIwMTJs2DZs2bbI5WJDBYECPHj0wKukl9H5mFr7OO406+AC3hb+IYF/EPRoG9RAVvIzX0adPHxgMBiQnJ+Pdd99t97nTw4mDDhHZMOK9HFxwoIiw5pfvcf1vnyBs8lvwiRzocPsRIb7IfSPO/op3IIoibty4YTcwNL3q65ufh4eHBxQKhUO9DmFhYejUqVObjvNhp9frkZGRgbS0NGRlZUEQBDz99NNQq9VITEyEr69vq9uKoogvvvgCCxYsgK+vL7Zs2YJx48bdcd2L1+rx4sbvccnkB4kAmG18Iks8BJgtInyrL6Dky9XoG9EZR48ehaenZ3tPlx5SDANENjg6zkDF/74O0w0tus3fAcHDsW/bEg8B04dEYGWi/XHkXUGv17cICK2FiBs3brTYXi6X271N0bTM1gXwYabT6fDVV19Bo9Hg6NGjkMlkGD9+PNRqNeLj41sdCvny5cuYM2cO9u/fj1mzZmHDhg0IDAy0vv/Xv5dhxXeFMJktNkPA7USzCRDNeP2pCPznOMdDKrkfhgEiG37T1iLh/R/uWvsHFz2JnmH+d639tjIajc2Cgq0QUVlZ2aKQzs/Pz25gaPo5ICDgoaxzKCkpsQ6FfPbsWYSFhVmHQn788cdbnLMoiti6dSsWL14MuVyO1NRUxMfH48Oc3/BfWcXtOBIRgIA3RvfG/Lhedtcm98QwQGSHs3MTOELiIWBoZAg+n+1cseH9yGQyobKy0qFbFTqdDiZT83EVvLy8bNY2/PEVHBz8wFXCi6KIgoICpKWlYefOnaioqEDPnj0xbdo0qNXqFhMEnT9/HrNmzUJOTg6eXbgWJ336u+xY3k3qhymDnR8JkR5+DANEdtiatbCtvKQeOLhoBLoHu1d3uiiKuH79ut3A0PSzwWBotr1EIrHWOdjrdVAoFPddnYPZbMbhw4etQyHX1NRg0KBBUKvVmDJlinWcAIvFgrX//Qm2lCshSDxbFAk2MV45h+qf0mC8dBqiqRHSICX8/vVpBAxKvOP67vp3R/YxDBA54K9/L8Nfdp10WXv8hmafKIrQ6/UOF0jW1NS0aCMkJMThXgdvb+8OPT+DwYC9e/dCo9EgMzMTJpMJI0eOhFqtRlJSEuZ9XYS8kspWawQMpQXQffM2PJVRkP1pOARPb5huXAFEC+Rxs+64zcPUI0WuxTBA5KD237u9JXn0o5gX19MFR0R/1NDQYLdAsun3qqqqFnUO/v7+DhVHKpVK+Pv7u7TO4fr160hPT4dGo0Fubi58u0QhdMb7ra5vMdbj8qf/Bq+ufaAYvxSC4Nytk/u1VoXuHYYBIidYq7otolM1BBIPAVIPAW8n9mWPwH3AZDLh6tWrDvU66HQ6mM3mZtt7e3vbHceh6SWXy52qc7h48SL+Y1sOThqCgFaeTKn9NRPXDnyE8Dmb0Sm0Oyw3GyB08nQoFHT0Uyz0YHD0+s0RCIkATB2swrCoUCz79iR+PFdpfZ67NU3vD40Mwdrx/Xiv9j4hlUrRpUsXm7P8NbFYLC3qHG4PDCdOnLD+fPukRlKptFmdg61eB4VCge7du6NG1h0wtj6+RcP5YxC8fGHSV0G3azVM1y5D6OQNWUwcgke9AkHa+ngCZouInGIdVoJhgJzHngGi2/ymrYXm5zLkFOtQVlXfbKRCAYAqxBdxvcPw0p9V7JJ1E6Ioora21qHRI7VaLWpra5ttLwgCQjp3hWzG5laLBgGgfNt8mG7cmrHQr/9oeKv6oaHsJGp/+R6+fZ6E4vklNo/z9pEvidgzQNRGvZT+WJnYFyvRF3VGE85X1eGmyQJPqQd6hMj4QeuGBEFAQEAAAgIC0KuX/Wf6DQZDi8BwurwGuwy26xHExgaIjUb4DXgGwQn/DgDwfXQoRHMj9Mf2o3G4Gp2Cu7a+PW7Nltk3PLDVdYjuhJ9qRDbIvKT8YCWn+fj4ICIiAhEREdZlv5Zdx67NeTa3a7oNIOszotlyWfRT0B/bD+PlMzbDAOD8rJxEAKcwJiLqEI7MlinxC7n1X1lQ8+WyW4HU0qB3yX6Ibse/GiKiDtAjRAZ7Dy16do4CAJhqq5otN9VeAwBIfG33Ugn/2A+RsxgGiIg6gMxLCpWdp05kfxoOANCfyGq2XH8iC/CQwEvVz+b2qhBf1rRQm/Cvhoiog8Q9GmZztkzPzlGQ9U9A3Ym/4arFAm9VDBrKTqL+zE8IeGISpP4hrbYt8RAQ1zvsbh06PeQYBoiIOoh6iArb88/bXCdkzDxIAxTQnziI+uJ8SAMVkI96BQGDn7e5ndki4qU/c+ArahuGASKiDtJL6Y/hPUNtzpYpSKQIip2GoNhpDrfbNDcBx72gtmLNABFRB1o7vh+kHq6b/wAApB4C1o63XU9AZAvDABFRB+oe7Iu3XDx/wNuJfTkkNrULwwARUQebOliFN0b3dklbyaMf5SRZ1G6sGSAiugfmx/VCqJ8XZ8uk+wJ7BoiI7pGpg1U4uGgEhkb+Y+RBO7UETe8PjQzBwUUjGATIZdgzQER0D3UP9sXns4dwtky6pziFMRHRfYazZZKrcApjIqIHFGfLpI7GmgEiIiI3xzBARETk5hgGiIiI3BzDABERkZtjGCAiInJzDANERERujmGAiIjIzTEMEBERuTmGASIiIjfHMEBEROTmGAaIiIjcHMMAERGRm2MYICIicnMMA0RERG6OYYCIiMjNMQwQERG5OakjK4miCACoqam5qwdDRERErtN03W66jrfGoTBQW1sLAOjevXs7D4uIiIg6Wm1tLQIDA1t9XxDtxQUAFosF5eXl8Pf3hyAILj1AIiIiujtEUURtbS3Cw8Ph4dF6ZYBDYYCIiIgeXiwgJCIicnMMA0RERG6OYYCIiMjNMQwQERG5OYYBIiIiN8cwQERE5OYYBoiIiNzc/wMw5IGl1cJHrAAAAABJRU5ErkJggg==" }, "metadata": {}, "output_type": "display_data" @@ -452,8 +448,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:56.975607Z", - "start_time": "2023-06-30T07:04:56.798234600Z" + "end_time": "2023-07-03T11:45:12.461569500Z", + "start_time": "2023-07-03T11:45:12.132507800Z" } } }, @@ -468,7 +464,7 @@ }, { "cell_type": "code", - "execution_count": 185, + "execution_count": 11, "outputs": [], "source": [ "def QAOAansatz_iso(params, g, each=1, return_circuit=False):\n", @@ -508,8 +504,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:04:56.978247300Z", - "start_time": "2023-06-30T07:04:56.976145900Z" + "end_time": "2023-07-03T11:45:12.464821600Z", + "start_time": "2023-07-03T11:45:12.462095700Z" } } }, @@ -524,24 +520,23 @@ }, { "cell_type": "code", - "execution_count": 186, + "execution_count": 12, "outputs": [ { "data": { "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACLuElEQVR4nOzdeXxU1f3/8dedfV+yJySQQNj3XRRXUKzdtGip9VuXn7WtrbbW1oVaEVSqolZttdrSr6J+W7Uu1bYqLigqBVHBsO8Qtuzr7Pv9/THJQCRAICQTyOf5eMxjZu7ce+45E+q8e8655yqqqqoIIYQQQvQimnRXQAghhBCiu0kAEkIIIUSvIwFICCGEEL2OBCAhhBBC9DoSgIQQQgjR60gAEkIIIUSvIwFICCGEEL2OLt0V6IkSiQQVFRXY7XYURUl3dYQQQgjRAaqq4vV6KSgoQKM5ch+PBKB2VFRUUFRUlO5qCCGEEOI47N27l8LCwiPuIwGoHXa7HUh+gQ6HI821EUIIIURHeDweioqKUr/jRyIBqB2tw14Oh0MCkBBCCHGS6cj0FZkELYQQQoheRwKQEEIIIXodCUBCCCGE6HVkDpAQQgjxFfF4nGg0mu5qiK/Q6/VotdoTUpYEICGEEKKFqqpUVVXR1NSU7qqIw3C5XOTl5XV6nT4JQEIIIUSL1vCTk5ODxWKRxXB7EFVVCQQC1NTUAJCfn9+p8iQACSGEECSHvVrDT2ZmZrqrI9phNpsBqKmpIScnp1PDYTIJWgghhIDUnB+LxZLmmogjaf37dHaOlgQgIYQQ4iAy7NWznai/jwQgIYQQQvQ6EoCEEEII0etIABJCCCFOYeXl5SiKQllZWZeeZ9GiRbhcri49x4kkAagbRcNxPPVB/M3hdFdFCCFEL1FUVERlZSUjRozo0vPMmjWLrVu3pt7PnTuXMWPGdOjYl19+mSFDhmAymRg5ciRvvfVWF9XyAAlA3ejL9/bw/B0r+PzN8nRXRQghRC+h1WrJy8tDp2t/5RtVVYnFYp0+j9lsJicn55iPW758OZdffjnXXnstX375JRdffDEXX3wx69ev73SdjkQCUDeKBKqJhdfTuH/r0XcWQgiRdqqqEojEuv2hquox1TORSLBgwQJKS0sxGo307duX+fPnA4cOgS1duhRFUXj77bcZP348RqORZcuWHbGM1mMOXiG7rKwMRVEoLy8H2g6BLVq0iHnz5rFmzRoURUFRFBYtWtRu3R977DEuvPBCbrnlFoYOHco999zDuHHjePzxx4/pOzhWPWIhxCeeeIIHH3yQqqoqRo8ezR//+EcmTZrU7r4LFy7kueeeSyXD8ePH87vf/a7N/ldffTXPPvtsm+NmzJjB4sWLu64RHVC3/TNigXep2zUa+GZa6yKEEOLogtE4w+a80+3n3Xj3DCyGjv9Ez549m4ULF/LII48wdepUKisr2bx58xGPuf3223nooYfo378/brf7uMo4nFmzZrF+/XoWL17M+++/D4DT6Wx33xUrVnDzzTe32TZjxgxef/314zp3R6U9AL300kvcfPPNPPXUU0yePJlHH32UGTNmsGXLlna70pYuXcrll1/O6aefjslk4oEHHuCCCy5gw4YN9OnTJ7XfhRdeyDPPPJN6bzQau6U9R6KtqwMg6mtOc02EEEKcKrxeL4899hiPP/44V111FQADBgxg6tSpRzzu7rvv5vzzz+9UGYdjNpux2WzodDry8vKOuG9VVRW5ublttuXm5lJVVXVc5+6otAeg3//+91x33XVcc801ADz11FO8+eabPP3009x+++2H7P+3v/2tzfu//vWvvPrqqyxZsoQrr7wytd1oNB71S+9uJpsVgFhcJkELIcTJwKzXsvHuGWk5b0dt2rSJcDjMtGnTjukcEyZM6HQZJ7O0BqBIJMKqVauYPXt2aptGo2H69OmsWLGiQ2UEAgGi0SgZGRltti9dupScnBzcbjfnnXce995772Hv7RIOhwmHD4QSj8dzHK05upDaCEA8IQFICCFOBoqiHNNQVDq03h/rWFmt1g6XodEkpwwfPDeps7eiaJWXl0d1dXWbbdXV1V3eiZHWSdB1dXXE4/FOdX3ddtttFBQUMH369NS2Cy+8kOeee44lS5bwwAMP8NFHH/G1r32NeDzebhn33XcfTqcz9SgqKjr+Rh3B/tBuAFRVApAQQogTY+DAgZjNZpYsWdJlZWRnZwNQWVmZ2na0dYUMBsNhf3cPNmXKlEPO+9577zFlypSjHtsZPTvWHsX999/Piy++yNKlSzGZTKnt3/ve91KvR44cyahRoxgwYABLly5tt3tv9uzZbSZgeTyeLglBEVPy/iWqGkFVVbnfjBBCiE4zmUzcdttt3HrrrRgMBs444wxqa2vZsGED11577Qkpo7S0lKKiIubOncv8+fPZunUrDz/88BHLLC4uZteuXZSVlVFYWIjdbm93Pu4vfvELzj77bB5++GG+/vWv8+KLL/LFF1/wl7/85bi+j45Kaw9QVlYWWq32uLq+HnroIe6//37effddRo0adcR9+/fvT1ZWFtu3b2/3c6PRiMPhaPPoCoq7NaRFiYSkF0gIIcSJceedd/KrX/2KOXPmMHToUGbNmkVNTc0JK0Ov1/PCCy+wefNmRo0axQMPPMC99957xPJmzpzJhRdeyLnnnkt2djYvvPBCu/udfvrp/P3vf+cvf/kLo0eP5pVXXuH111/v8oUbFfVYFxs4wSZPnsykSZP44x//CCTXMujbty833HBDu5OgARYsWMD8+fN55513OO200456jn379tG3b19ef/11vvWtbx11f4/Hg9PppLm5+YSGoccX3Uj47V0A/M/8P5Nb2ucoRwghhOguoVCIXbt2UVJS0mZUQfQsR/o7Hcvvd9oXQrz55ptZuHAhzz77LJs2beL666/H7/enrgq78sor20ySfuCBB7jzzjt5+umnKS4upqqqiqqqKnw+HwA+n49bbrmFTz/9lPLycpYsWcK3v/1tSktLmTGj+2fyH0znzgCSM/ub9lYfeWchhBBCdJm0zwGaNWsWtbW1zJkzh6qqKsaMGcPixYtTE6P37NmTmn0O8OSTTxKJRLj00kvblHPXXXcxd+5ctFota9eu5dlnn6WpqYmCggIuuOAC7rnnnrSvBWQxuwmgRSWOp7I+rXURQggherO0ByCAG264gRtuuKHdz5YuXdrmfeuS24djNpt5553uX7WzI6xmF/VoUAFPjSyGKIQQQqRL2ofAehO7zY3SMuPK1+RLb2WEEEKIXkwCUDdyWLNQSAAQ9AXTXBshhBCi95IA1I2ctkxoDUBBuQxeCCGESBcJQN3Ibc8AJbkqZiRyYpYQF0IIIcSxkwDUjewmKwliAMTisTTXRgghhOi9JAB1I6PWSEKTDD5xCUBCCCG6QXl5OYqiHPXeXZ21aNEiXC5Xl57jRJIA1I10Gh1xTXLoK6HGiUWPfpM4IYQQojOKioqorKzs8ltLzJo1i61bt6bez507lzFjxhz1uA0bNjBz5kyKi4tRFIVHH3206yp5EAlA3ay1BwiihAPSCySEEKJrabVa8vLy0OnaX/pPVVVisc7/HpnNZnJyco75uEAgQP/+/bn//vuPeh/QE0kCUDeL65JXgalqlJBfJkILIYTovEQiwYIFCygtLcVoNNK3b1/mz58PHDoEtnTpUhRF4e2332b8+PEYjUaWLVt2xDJaj2lqakqds6ysDEVRUgsUHzwEtmjRIubNm8eaNWtQFAVFUVi0aFG7dZ84cSIPPvgg3/ve97r1jg09YiXo3iShbVkJUY0QCcoQmBBC9GiqCtFA959XbwFF6fDus2fPZuHChTzyyCNMnTqVyspKNm/efMRjbr/9dh566CH69++P2+0+rjIOZ9asWaxfv57Fixfz/vvvA+B0Oo+rrK4iAaibxVu/cTVKNCRDYEII0aNFA/C7gu4/728qwGDt0K5er5fHHnuMxx9/nKuuugqAAQMGMHXq1CMed/fdd3P++ed3qozDMZvN2Gw2dDpdtw5rHQsZAutmCX0y0atqhEhIeoCEEEJ0zqZNmwiHw0ybNu2YjpswYUKnyziZSQ9QN4sbWzNnlIj0AAkhRM+mtyR7Y9Jx3g4ym83HdQqr9UAP09HK0GiSv12qqqa2RaMn9zxW6QHqZgmDNvlCjRCVHiAhhOjZFCU5FNXdj2OY/zNw4EDMZjNLliw57mYerYzs7GwAKisrU9uOtq6QwWAgHu+5v3PSA9TNVJM++axGiIalB0gIIUTnmEwmbrvtNm699VYMBgNnnHEGtbW1bNiwgWuvvfaElFFaWkpRURFz585l/vz5bN26lYcffviIZRYXF7Nr1y7KysooLCzEbre3e5VXJBJh48aNqdf79++nrKwMm81GaWnpsX8hHSQ9QN1MNRtaXkRlDpAQQogT4s477+RXv/oVc+bMYejQocyaNYuampoTVoZer+eFF15g8+bNjBo1igceeIB77733iOXNnDmTCy+8kHPPPZfs7GxeeOGFdverqKhg7NixjB07lsrKSh566CHGjh3LD3/4w2Oq/7FS1IMH9AQAHo8Hp9NJc3MzDofjhJZ9658uJfejEADjvvEA5/5g+AktXwghxPEJhULs2rWLkpISTCZTuqsjDuNIf6dj+f2WHqBupthtqddBjzeNNRFCCCF6LwlA3Uxvs6O09LmFfb70VkYIIYTopSQAdTOzxYFGTc7uD/vTsLqoEEIIISQAdTeryYGmpQcoEpIAJIQQQqSDBKBuZjO70LTMO4+GQmmujRBCCNE7SQDqZg5LBoqavCN8JBJOc22EEEKI3kkCUDdzWBwoJNf/iUUlAAkhhBDpIAGom1kNFmgJQIl4DDUhyzAJIYQQ3U0CUDcz6UyotN4CI0I0LKtBCyGEEN1NAlA3M+vMJDTJ0KOqckd4IYQQXau8vBxFUY5689LOWrRoES6Xq0vPcSJJAOpmJq2JhCY5CRo1IvcDE0II0aWKioqorKxkxIgRXXqeWbNmsXXr1tT7uXPnMmbMmKMet3DhQs4880zcbjdut5vp06fz2WefdWFNkyQAdTOjzkhM2zLvR40QlQAkhBCiC2m1WvLy8tDpdO1+rqoqsVjnRyPMZjM5OTnHfNzSpUu5/PLL+fDDD1mxYgVFRUVccMEF7N+/v9N1OhIJQN3MrDMT0yZ7gGQITAghxImQSCRYsGABpaWlGI1G+vbty/z584FDh8CWLl2Koii8/fbbjB8/HqPRyLJly45YRusxTU1NqXOWlZWhKArl5eVA2yGwRYsWMW/ePNasWYOiKCiKwqJFi9qt+9/+9jd++tOfMmbMGIYMGcJf//pXEokES5Ys6YqvKqX9OCi6jFlnJqpV0UWRHiAhhOjhVFUlGAt2+3nNOjOKonR4/9mzZ7Nw4UIeeeQRpk6dSmVlJZs3bz7iMbfffjsPPfQQ/fv3x+12H1cZhzNr1izWr1/P4sWLef/99wFwOp0dOjYQCBCNRsnIyDiuc3eUBKBuZtKaiOgTmEOgqhGiYekBEkKInioYCzL575O7/bwrv78Si97SoX29Xi+PPfYYjz/+OFdddRUAAwYMYOrUqUc87u677+b888/vVBmHYzabsdls6HQ68vLyjunY2267jYKCAqZPn35c5+4oCUDdTKvREte1rv0jl8ELIYTonE2bNhEOh5k2bdoxHTdhwoROl3Gi3X///bz44ossXboUk8nUpeeSAJQGMX1Lt6YaJSIBSAgheiyzzszK769My3k7vK+54/sezGq1drgMjSY5ZVhVDyzeG41Gj+u8h/PQQw9x//338/777zNq1KgTWnZ7JAClQczQ+g9JeoCEEKInUxSlw0NR6TJw4EDMZjNLlizhhz/8YZeUkZ2dDUBlZSVutxvgqOsKGQwG4vGO/cYtWLCA+fPn884777TpmepKEoDSIG7SJl9IABJCCNFJJpOJ2267jVtvvRWDwcAZZ5xBbW0tGzZs4Nprrz0hZZSWllJUVMTcuXOZP38+W7du5eGHHz5imcXFxezatYuysjIKCwux2+0YjcZD9nvggQeYM2cOf//73ykuLqaqqgoAm82GzWY79i+kg+Qy+DSIm/StrwgH5IaoQgghOufOO+/kV7/6FXPmzGHo0KHMmjWLmpqaE1aGXq/nhRdeYPPmzYwaNYoHHniAe++994jlzZw5kwsvvJBzzz2X7OxsXnjhhXb3e/LJJ4lEIlx66aXk5+enHg899NAx1f9YKerBA3oCAI/Hg9PppLm5GYfDccLL/9kjF9L/02Tn29Bz5nDR9ZNO+DmEEEIcm1AoxK5duygpKenyCbji+B3p73Qsv9/SA5QGisWC0hI7w4FAeisjhBBC9EISgNJAY7WjTSSvBItIABJCCCG6nQSgNNDbnLTcDYNI0JveygghhBC9kASgNDA6XOgSyTGwaFB6gIQQQojuJgEoDWxmG9pEsgsoFu7+e8wIIYQQvZ0EoDSwGS1o1GQAikbkMnghhBCiu0kASgObwYKiJhdAjMcjaa6NEEII0ftIAEoDs86MQvIu8IlElHg8keYaCSGEEL2LBKA0MOvMoCYDEGqEmNwOQwghhOhWEoDSwKQzoWpaA1BY7gcmhBCiy5SXl6MoylFvXtpZixYtwuVydek5TiQJQGlg0VlItCwFLXeEF0II0ZWKioqorKxkxIgRXXqeWbNmsXXr1tT7uXPnMmbMmKMe99prrzFhwgRcLhdWq5UxY8bw/PPPd2FNk+Ru8Glg1pmJt66EKAFICCFEF9JqteTl5R32c1VVicfj6HSdiwRmsxmz2XzMx2VkZHDHHXcwZMgQDAYD//nPf7jmmmvIyclhxowZnarTkUgPUBqYdWaiLQFIVcNEQxKAhBBCHL9EIsGCBQsoLS3FaDTSt29f5s+fDxw6BLZ06VIUReHtt99m/PjxGI1Gli1bdsQyWo9pampKnbOsrAxFUSgvLwfaDoEtWrSIefPmsWbNGhRFQVEUFi1a1G7dzznnHC655BKGDh3KgAED+MUvfsGoUaNYtmxZV3xVKdIDlAZmnZmoLgEqMgdICCF6MFVVUYPdv2CtYjajKEqH9589ezYLFy7kkUceYerUqVRWVrJ58+YjHnP77bfz0EMP0b9/f9xu93GVcTizZs1i/fr1LF68mPfffx8Ap9N51ONUVeWDDz5gy5YtPPDAA8d17o6SAJQGJp2JqC6BNipzgIQQoidTg0G2jBvf7ecdvHoVisXSoX29Xi+PPfYYjz/+OFdddRUAAwYMYOrUqUc87u677+b888/vVBmHYzabsdls6HS6Iw6/tWpubqZPnz6Ew2G0Wi1/+tOfUnXrKhKA0sCsMxPRJzBHkR4gIYQQnbJp0ybC4TDTpk07puMmTJjQ6TJOFLvdTllZGT6fjyVLlnDzzTfTv39/zjnnnC47pwSgNDDrzIT1KsmpYjHCQVkNWggheiLFbGbw6lVpOW9HHc/EYwCr1drhMjSa5JRhVVVT26LR6HGd93Dll5aWAjBmzBg2bdrEfffd16UBSCZBp4FJayJkOLD6c8jnS2NthBBCHI6iKGgslm5/HMv8n4EDB2I2m1myZMlxt/NoZWRnZwNQWVmZ2na0dYUMBgPx+PGNcCQSCcLhrr1XpvQApYGiKMSMOhRVQVVUQj5/uqskhBDiJGUymbjtttu49dZbMRgMnHHGGdTW1rJhwwauvfbaE1JGaWkpRUVFzJ07l/nz57N161YefvjhI5ZZXFzMrl27KCsro7CwELvdjtFoPGS/++67jwkTJjBgwADC4TBvvfUWzz//PE8++eRxfR8dJQEoTRJGIxpVQ1yJE5YAJIQQohPuvPNOdDodc+bMoaKigvz8fH7yk5+csDL0ej0vvPAC119/PaNGjWLixInce++9XHbZZYctb+bMmbz22muce+65NDU18cwzz3D11Vcfsp/f7+enP/0p+/btw2w2M2TIEP7v//6PWbNmHVP9j5WiHjygJwDweDw4nU6am5txOBxdco4b7zmbQWsyiGijlE64lm/fckmXnEcIIUTHhEIhdu3aRUlJCSaTKd3VEYdxpL/Tsfx+yxygNFEtFloXg44EZA6QEEII0Z0kAKWJxmo9EICCMgQmhBBCdCcJQGmitdnQJZIJKBoKpLk2QgghRO8iAShNDHYHunhLAIqE0lwbIYQQoneRAJQmRocTvQQgIYQQIi0kAKWJ3epEm4gBEI+duNU0hRBCCHF0EoDSxGawoqjJAJSIy60whBBCiO4kAShNLHoLkOz5SahR1IQsxySEEEJ0FwlAaWLVW4lrkj0/qhomGpE7wgshhBDdpUcEoCeeeILi4mJMJhOTJ0/ms88+O+y+Cxcu5Mwzz8TtduN2u5k+ffoh+6uqypw5c8jPz8dsNjN9+nS2bdvW1c04JgcHINQI0bAEICGEECdeeXk5iqIc9ealnbVo0SJcLleXnuNESnsAeumll7j55pu56667WL16NaNHj2bGjBnU1NS0u//SpUu5/PLL+fDDD1mxYgVFRUVccMEF7N+/P7XPggUL+MMf/sBTTz3FypUrsVqtzJgxg1Co51xtZdVbiWlbhr0kAAkhhOgiRUVFVFZWMmLEiC49z6xZs9i6dWvq/dy5cxkzZswxlfHiiy+iKAoXX3zxia1cO9IegH7/+99z3XXXcc011zBs2DCeeuopLBYLTz/9dLv7/+1vf+OnP/0pY8aMYciQIfz1r38lkUiwZMkSINn78+ijj/Lb3/6Wb3/724waNYrnnnuOiooKXn/99XbLDIfDeDyeNo+uZtFZiOgTLXUOSwASQgjRJbRaLXl5eeh07d//XFVVYrFYp89jNpvJyck57uPLy8v59a9/zZlnntnpunREWgNQJBJh1apVTJ8+PbVNo9Ewffp0VqxY0aEyAoEA0WiUjIwMAHbt2kVVVVWbMp1OJ5MnTz5smffddx9OpzP1KCoq6kSrOsaqtxI2tNwLQw0TCXX+H58QQojeKZFIsGDBAkpLSzEajfTt25f58+cDhw6BLV26FEVRePvttxk/fjxGo5Fly5YdsYzWY5qamlLnLCsrQ1EUysvLgbZDYIsWLWLevHmsWbMGRVFQFIVFixYdtv7xeJwrrriCefPm0b9//xP99bSr/TjYTerq6ojH4+Tm5rbZnpuby+bNmztUxm233UZBQUEq8FRVVaXK+GqZrZ991ezZs7n55ptT7z0eT5eHIKveSlifQIkCqIT8QcDdpecUQghxbFRVJRZJdPt5dQYNiqJ0eP/Zs2ezcOFCHnnkEaZOnUplZeVRf0dvv/12HnroIfr374/b7T6uMg5n1qxZrF+/nsWLF/P+++8Dyc6Iw7n77rvJycnh2muv5ZNPPjmucx6rtAagzrr//vt58cUXWbp0KSaT6bjLMRqNGI3GE1izo7PoLQQMKtaWNRCDzd5uPb8QQoiji0US/OUXH3X7eX/02NnojdoO7ev1ennsscd4/PHHueqqqwAYMGAAU6dOPeJxd999N+eff36nyjgcs9mMzWZDp9ORl5d3xH2XLVvG//7v/3b5JO2vSusQWFZWFlqtlurq6jbbq6urj/qFPfTQQ9x///28++67jBo1KrW99bjjKbM7WfVWQiYFRU1m0GBTY5prJIQQ4mS0adMmwuEw06ZNO6bjJkyY0OkyOsvr9fKDH/yAhQsXkpWV1a3nTmsPkMFgYPz48SxZsiQ147t1QvMNN9xw2OMWLFjA/Pnzeeedd9r8AQFKSkrIy8tjyZIlqdnnHo+HlStXcv3113dVU46ZSWsiaFDQoCVOjFBzQ7qrJIQQ4it0Bg0/euzstJy3o8xm83Gdw2q1drgMjSZZH1U9sGhvNNr52zjt2LGD8vJyvvnNb6a2JRLJIUedTseWLVsYMGBAp8/TnrQPgd18881cddVVTJgwgUmTJvHoo4/i9/u55pprALjyyivp06cP9913HwAPPPAAc+bM4e9//zvFxcWpeT02mw2bzYaiKNx0003ce++9DBw4kJKSEu68804KCgq65bK6jlIUhajRgEbVElcg5G1Od5WEEEJ8haIoHR6KSpeBAwdiNptZsmQJP/zhD7ukjOzsbAAqKytxu5PzVY82ZGUwGIjHj3yF85AhQ1i3bl2bbb/97W9TQ3JdOR837QFo1qxZ1NbWMmfOHKqqqhgzZgyLFy9OTWLes2dPKnkCPPnkk0QiES699NI25dx1113MnTsXgFtvvRW/38+PfvQjmpqamDp1KosXL+7UPKGuEDMZ0aoKUSDs86W7OkIIIU5CJpOJ2267jVtvvRWDwcAZZ5xBbW0tGzZs4Nprrz0hZZSWllJUVMTcuXOZP38+W7du5eGHHz5imcXFxezatYuysjIKCwux2+2HzLc1mUyHrE/UeiVZV69blPYABHDDDTccdshr6dKlbd63Xm53JIqicPfdd3P33XefgNp1nbjZhDahgBYiAX+6qyOEEOIkdeedd6LT6ZgzZw4VFRXk5+fzk5/85ISVodfreeGFF7j++usZNWoUEydO5N577+Wyyy47bHkzZ87ktdde49xzz6WpqYlnnnmGq6++ujPNPKEU9eABPQEk5ww5nU6am5txOBxddp7r/vB1Jn1ox2Pw0af4DL73wOwuO5cQQogjC4VC7Nq1i5KSkh43YiAOONLf6Vh+v9O+EnRvprHY0MWT+TMaDqa5NkIIIUTvIQEojXR2O7pESwCKhNNcGyGEEKL3kACURga7E13LDPloJJLm2gghhBC9hwSgNHLYXakAFI9JABJCCCG6iwSgNMqwuIDkTVDj8c4vKCWEEEKIjpEAlEYukwNIBp94QgKQEEII0V0kAKWRw+AgkbwdPKoEICGEEKLbSABKI4fBQVyTvPoroUaRJZmEEEKI7iEBKI3sBjtRTcvkZzVCPJZIb4WEEEKIXkICUBrZDXYi+tb1f6KE/aG01kcIIcSpp7y8HEVRjnrz0s5atGhR6j5eJwMJQGlkN9iJGGKp94GayjTWRgghxKmoqKiIysrKLr+56KxZs9i6dWvq/dy5cxkzZsxRj1u0aBGKorR5dMetSHrEzVB7K4fRQcgARLVAHH9dNdmDStNdLSGEEKcQrVZLXl7eYT9XVZV4PI5O17lIYDabMZvNx3Wsw+Fgy5YtqfeKonSqLh0hPUBpZNPbCBoUFPQABOvr0lwjIYQQB1NVlWgo1O2PY70oJpFIsGDBAkpLSzEajfTt25f58+cDhw6BLV26FEVRePvttxk/fjxGo5Fly5YdsYzWY5qamlLnLCsrQ1EUysvLgbZDYIsWLWLevHmsWbMm1auzaNGiw9ZfURTy8vJSj9zc3GNq//GQHqA00igagmY9Vr8OFQg0Naa7SkIIIQ4SC4f5w1WXdvt5f/7sK+iPYRho9uzZLFy4kEceeYSpU6dSWVnJ5s2bj3jM7bffzkMPPUT//v1xu93HVcbhzJo1i/Xr17N48WLef/99AJxO52H39/l89OvXj0Qiwbhx4/jd737H8OHDj+vcHSUBKM0iFhNa9CSAwEHJWgghhOgIr9fLY489xuOPP85VV10FwIABA5g6deoRj7v77rs5//zzO1XG4ZjNZmw2Gzqd7ojDbwCDBw/m6aefZtSoUTQ3N/PQQw9x+umns2HDBgoLC4/r/B0hASjNolYLWlVDVIGAx5fu6gghhDiIzmjk58++kpbzdtSmTZsIh8NMmzbtmM4xYcKETpdxIkyZMoUpU6ak3p9++ukMHTqUP//5z9xzzz1ddl4JQOlmt6NNaEALAZ8EICGE6EkURTmmoah0ON6Jx1artcNlaDTJKcMHz02KRrvmDgZ6vZ6xY8eyffv2Lim/lUyCTjOt04UukZztHg7KOkBCCCGOzcCBAzGbzSxZsqTLysjOzgagsvLAci1HW1fIYDAQj8ePuS7xeJx169aRn59/zMceC+kBSjOjOwt9vB70EA6Fj36AEEIIcRCTycRtt93GrbfeisFg4IwzzqC2tpYNGzZw7bXXnpAySktLKSoqYu7cucyfP5+tW7fy8MMPH7HM4uJidu3aRVlZGYWFhdjtdoztDO3dfffdnHbaaZSWltLU1MSDDz7I7t27+eEPf3hc30dHSQBKM2d2HoZYLQDhcCTNtRFCCHEyuvPOO9HpdMyZM4eKigry8/P5yU9+csLK0Ov1vPDCC1x//fWMGjWKiRMncu+993LZZZcdtryZM2fy2muvce6559LU1MQzzzzD1Vdffch+jY2NXHfddVRVVeF2uxk/fjzLly9n2LBhx1T/Y6WocgfOQ3g8HpxOJ83NzTgcji4919PrnsN662L2OTyYDG5+9vzzXXo+IYQQ7QuFQuzatYuSkpJuWYlYHJ8j/Z2O5fdb5gClWY4lA4XkRLJYPHaUvYUQQghxIkgASrMMcwYJJTn0FU/IEJgQQgjRHSQApZnb6CamDQKgqhFU6QUSQgghupwEoDRzm9yEda2Xv6uEGyrSWh8hhBCiN5AAlGZuk5ugMQgtN0QNVO9Lb4WEEKKXk2uDerYT9feRAJRmRq2RgDEKmuQqnJ6qqjTXSAgheie9vuX/iAYCaa6JOJLWv0/r3+t4yTpAPUDIbMAeMZIAfHW16a6OEEL0SlqtFpfLRU1NDQAWiwVFUdJcK9FKVVUCgQA1NTW4XC60Wm2nypMA1ANErRY0zck7wvsaGtNdHSGE6LVa71zeGoJEz+NyuY56h/mOkADUA8TsDjQtfwpfkyfNtRFCiN5LURTy8/PJycnpspt9iuOn1+s73fPTSgJQT5CRgTaR/IMG5Y7wQgiRdlqt9oT90IqeSSZB9wDGrDx0anKcOegPprk2QgghxKlPAlAP4Mzriz6WvKwvFJQ7wgshhBBdTQJQD1CQW4QuEQcgFJaVoIUQQoiuJgGoByhx90ElGXyiMQlAQgghRFeTANQDFDrySGiSQ19RuReYEEII0eUkAPUA2eZsotpkAIqrMdSITIQWQgghupIEoB5Ar9UT0rdOfk4Qbdyf1voIIYQQpzoJQD1E0BSndVmmQPXu9FZGCCGEOMVJAOohQlYdisYKgL9GeoCEEEKIriQBqIeIuEygJANQU6XcEV4IIYToShKAegglMxuNYgSguU5uiCqEEEJ0JQlAPYQ5vwStagDA2yA3RBVCCCG6kgSgHiKrcCi6lhuiepvkhqhCCCFEV5IA1EP0zylBQ/KGqH6/3A9MCCGE6EoSgHqIAe58VCUBQCAiq0ELIYQQXUkCUA+RaTMRb/lrRGLx9FZGCCGEOMVJAOoh7EYdYZ0KQEyNoapqmmskhBBCnLokAPUQiqIQNOpb3qmEGmQtICGEEKKrSADqQfw2Gyim5Ov929NcGyGEEOLUJQGoB4lm5qC0rAbtrdiZ5toIIYQQpy4JQD2Isc9AFI0dgPqdW9NcGyGEEOLUJQGoB8nJzUsFoH3lckd4IYQQoqtIAOpBcjItKIoZgIZ6f5prI4QQQpy6JAD1IDkOI4qiAyAYlLWAhBBCiK4iAagHybaZSGiSASgmi0ELIYQQXUYCUA+S4zAS0SYvg4+jEk9IL5AQQgjRFSQA9SCZVgMN+gwAVEVly761aa6REEIIcWqSANSD6LQaGm2ZoBgB2PLft9NcIyGEEOLUJAGoh9HYLalL4WvWrU5zbYQQQohTkwSgHsbmMqIoyQAU2led5toIIYQQpyYJQD1MRqYZRWMDwOhNUOmrTHONhBBCiFOPBKAeJifPmhoCM4X1rKxameYaCSGEEKee4wpAd999N4FA4JDtwWCQu+++u9OV6s365FpBYwEgoTGxesvS9FZICCGEOAUdVwCaN28ePp/vkO2BQIB58+Z1ulK9WaHbQkyXvAosaNBR8/kyovFommslhBBCnFqOKwCpqoqiKIdsX7NmDRkZGZ2uVG9W6DYT0CZ7gCJa6LMnwOdVn6e5VkIIIcSp5ZgCkNvtJiMjA0VRGDRoEBkZGamH0+nk/PPP57vf/e4xVeCJJ56guLgYk8nE5MmT+eyzzw6774YNG5g5cybFxcUoisKjjz56yD5z585FUZQ2jyFDhhxTndLJadbTbHICkNBASZWG9/e8n+ZaCSGEEKcW3bHs/Oijj6KqKv/v//0/5s2bh9PpTH1mMBgoLi5mypQpHS7vpZde4uabb+app55i8uTJPProo8yYMYMtW7aQk5NzyP6BQID+/ftz2WWX8ctf/vKw5Q4fPpz33z8QGnS6Y2pmWimKQtzhgiobqD7yG3T8Zde73D7pdgxaQ7qrJ4QQQpwSjikZXHXVVQCUlJRwxhlndDpY/P73v+e6667jmmuuAeCpp57izTff5Omnn+b2228/ZP+JEycyceJEgHY/b6XT6cjLy+tU3dLJkWFG0TpRYz5U9Jiqmvhw74fMKJ6R7qoJIYQQp4TjmgNkt9vZtGlT6v0bb7zBxRdfzG9+8xsikUiHyohEIqxatYrp06cfqIxGw/Tp01mxYsXxVCtl27ZtFBQU0L9/f6644gr27NlzxP3D4TAej6fNI52y8yxoNC4AAgY9g/er/HP7P9NaJyGEEOJUclwB6Mc//jFbt24FYOfOncyaNQuLxcLLL7/Mrbfe2qEy6urqiMfj5Obmttmem5tLVVXV8VQLgMmTJ7No0SIWL17Mk08+ya5duzjzzDPxer2HPea+++7D6XSmHkVFRcd9/hOhqNCBokkOLwaMOobtUVm+fzn7ffvTWi8hhBDiVHFcAWjr1q2MGTMGgJdffpmzzz6bv//97yxatIhXX331RNbvmH3ta1/jsssuY9SoUcyYMYO33nqLpqYm/vGPfxz2mNmzZ9Pc3Jx67N27txtrfKiBxU7QJgOQz2Rm3D4Dqprg+Y3Pp7VeQgghxKniuC+DTyQSALz//vtcdNFFABQVFVFXV9ehMrKystBqtVRXt73fVXV19Qmdv+NyuRg0aBDbt28/7D5GoxGHw9HmkU79c+3EWi6FDxj0OBrD5DTBa9teozncnNa6CSGEEKeC4wpAEyZM4N577+X555/no48+4utf/zoAu3btOmRI63AMBgPjx49nyZIlqW2JRIIlS5Yc05VkR+Pz+dixYwf5+fknrMyuZtJrCZhdAER1EFcUptXnEYwFeXHzi+mtnBBCCHEKOK4A9Oijj7J69WpuuOEG7rjjDkpLSwF45ZVXOP300ztczs0338zChQt59tln2bRpE9dffz1+vz91VdiVV17J7NmzU/tHIhHKysooKysjEomwf/9+ysrK2vTu/PrXv+ajjz6ivLyc5cuXc8kll6DVarn88suPp6lpo7ozQUmuCB0w6JhelwyWz218Dk8kvZO0hRBCiJPdcV3HPmrUKNatW3fI9gcffBCtVtvhcmbNmkVtbS1z5syhqqqKMWPGsHjx4lQv0p49e9BoDmS0iooKxo4dm3r/0EMP8dBDD3H22WezdOlSAPbt28fll19OfX092dnZTJ06lU8//ZTs7OzjaWrauPNsRLc5UeM1BIx6Cjbso3TGALY37+DpdU9z0/ib0l1FIYQQ4qSlqKqqHu/Bq1atSl0OP2zYMMaNG3fCKpZOHo8Hp9NJc3Nz2uYD/evtHez42+MkotsYWt1ASVUj9X/5Ldfvuh+T1sSb33mTHMuhi0UKIYQQvdWx/H4f1xBYTU0N5557LhMnTuTnP/85P//5z5kwYQLTpk2jtrb2uCot2ho+KANF6wIgnJmcED1kS5CxOWMJxUM8tvqxNNZOCCGEOLkdVwC68cYb8fl8bNiwgYaGBhoaGli/fj0ej4ef//znJ7qOvVJxPyeKxg2A15gcqfR//DG3TLgFBYV/7fiX3CRVCCGEOE7HFYAWL17Mn/70J4YOHZraNmzYMJ544gnefvvtE1a53kyr0xA3twQgNTmvKvDllwwzl3DpoEsBuPfTe4nGo2mroxBCCHGyOq4AlEgk0Ov1h2zX6/Wp9YFE5xnzkitShxIKSlEexGL4ly/nF+N+QYYpg53NO3l247NprqUQQghx8jmuAHTeeefxi1/8goqKitS2/fv388tf/pJp06adsMr1dkWluaBYAYiXJic8+z7+GKfRya8m/AqAP5X9iW2N29JWRyGEEOJkdFwB6PHHH8fj8VBcXMyAAQMYMGAAJSUleDwe/vjHP57oOvZaQ4dkotEmh8E8luRQl/+TZaiqyjf7f5Mz+5xJNBHljmV3yFCYEEIIcQyOax2goqIiVq9ezfvvv8/mzZsBGDp0aJs7u4vOy+1rR9FkAPvwRupxm0zEqqsJb96MaehQ5p0+j0v+dQmbGjbx1NqnuHHsjemushBCCHFSOKYeoA8++IBhw4bh8XhQFIXzzz+fG2+8kRtvvJGJEycyfPhwPvnkk66qa69jzzCh6DMAaPZrsU6eAIB3yQcAZFuyufO0OwH433X/y9ratempqBBCCHGSOaYA9Oijj3Lddde1u7iQ0+nkxz/+Mb///e9PWOV6O0WjYM/tA0B92IJ5WHKFbO8HB+6fNqN4BheVXERcjXPHsjsIxoJpqasQQghxMjmmALRmzRouvPDCw35+wQUXsGrVqk5XShxQPCx5nzV/DJoNNaDREN64iej+/al9fjP5N+SYcyj3lLPg8wXpqqoQQghx0jimAFRdXd3u5e+tdDqdrAR9gvUb3i91U9RgRRmWltuNtA6DATiNTuafOR8FhVe2vsLi8sVpqasQQghxsjimANSnTx/Wr19/2M/Xrl1Lfn5+pyslDsgb4ESjTd7INebxY5qcvBms94MP2ux3Wv5p/HDkDwGYt3wee717u7eiQgghxEnkmALQRRddxJ133kkoFDrks2AwyF133cU3vvGNE1Y5AVanEaM1GSr3BAqoMjUBEPj8c+JNTW32/emYnzIuZxy+qI9bPrpFLo0XQgghDuOYAtBvf/tbGhoaGDRoEAsWLOCNN97gjTfe4IEHHmDw4ME0NDRwxx13dFVde63MomIAqsMOlPrlGAcNgngc38cft9lPp9HxwFkP4DQ62VC/gUdXP9r9lRVCCCFOAscUgHJzc1m+fDkjRoxg9uzZXHLJJVxyySX85je/YcSIESxbtozc3Nyuqmuv1W/kEAB8kQSDAl+iTj4NAO/7Sw7ZN8+axz2n3wPAcxuf46O9H3VfRYUQQoiTxDGvBN2vXz/eeust6urqWLlyJZ9++il1dXW89dZblJSUdEUde72hpw8HNCTUKN6onW1aDwC+ZctIhMOH7H9u33P5n6H/A8Bv//tbagI13VldIYQQosc7rlthALjdbiZOnMikSZNwu90nsk7iK5w5NnTGTAA2+4biCH6CNjcXNRDA/9/l7R7zy/G/ZGjGUJrCTcz+ZDbxRLw7qyyEEEL0aMcdgET3cuUne9d2B3KZzHqqh44CwPtO+5e8G7QGFpy1ALPOzGdVn/H0+qe7ra5CCCFETycB6CTRb8RwAOrDejTAbn09kJwH1N4wGECxs5jfTP4NAE+UPUFZTVl3VFUIIYTo8SQAnSSGTk0ugBiL1rE/MoSz3Z8SdmeR8PvxL1t22OO+PeDbqVtl3PbxbXginu6qshBCCNFjSQA6SeT064dGZwKirPGfRpGmjm05WQB43nr7sMcpisKdp91Joa2QCn8F85bPQ1XVbqq1EEII0TNJADpJKBoNWUUDANgb6oOqKpQU7gHA++GHJNpZnLKVzWBjwVkL0Ck63t39Lv/c/s9uqbMQQgjRU0kAOokUj07OAwoGa9gbHcP4rO00WeyogQC+jz4+4rEjs0dy47gbAbhv5X3sbNrZ5fUVQggheioJQCeRviOSV34lonvYqL8KRQFdUQwAz9uHHwZrdfXwq5mSP4VQPMQtH99CON7+5GkhhBDiVCcB6CTSZ/AwtDo9qH52VNkIqC5G9EsOg3k+/JC4z3/E4zWKht+d+TsyTBlsbdzKw1883B3VFkIIIXocCUAnEZ3BQOGwEQDEwrvZ4roJkztKzKZFCYdpeLv9NYEOlmXO4t4z7gXghc0v8OGeD7u0zkIIIURPJAHoJNN3xGgAErE9rKsZR0JjIL+kEYAtz77QoTLOLDyTK4ddCcCc5XOoC9Z1TWWFEEKIHkoC0Emm38gxACRi+/A0hNlZMBtncQAVyNy+gU2rNnWonJvG3cSQjCE0hZuYt0IujRdCCNG7SAA6yeQU98fmzgA1QiK2h9VVU9Bl2LHlJi+Df+/RZ4jGE0ctR6/VM3/qfHQaHUv3LuU/O//TxTUXQggheg4JQCcZRaOhdNIUANTYdur2B9k3cB7OkiAAozd8wh/e29Khsga5B/HT0T8FkpfGV/uru6bSQgghRA8jAegkNHDSGQCoiZ2oaoKV24djG5GHRp8gJ9DEJ6+8wxflDR0q65oR1zAicwTeqJe5K+bKUJgQQoheQQLQSahw6HDMdgfxSACFfVSX+9g9/GEc/ZK9QJfvfI9f/qMMbyh61LJ0Gh3zp87HoDGwbP8yWSVaCCFEryAB6CSk0WoZdFqyF8jm3AXApyutuC6cCsCoyp2E9+9j7r82dqi8/q7+3Dg2uUr0gs8XUOGr6IJaCyGEED2HBKCT1Ihzzgegcf9aDOYYjVUBdg2dgyUvDirM3v13Xl29j1dX7etQeT8Y9gPGZI/BH/UzZ/kcEurRJ1ILIYQQJysJQCep3AEDyepbTDwWJa84OXn508W1WGd+F4Dhu3YxLLGTO15fx5Yq71HL02q03HPGPZi0JlZWruSf22QoTAghxKlLAtBJSlEURp6b7AWqK1+OK9dM0BtlY9YV6Ow64mENj9f/BTUa4qd/W4U/HDtqmcXOYm4YewMAD696WBZIFEIIccqSAHQSG37OdAxmMw0Veykdl5wAvf7jSpSZP0nusCHIHebX2VHr5zf/XNehK7yuGHoFwzKH4Y14uW/lfV1ZfSGEECJtJACdxIwWK6Omfw2A3WXvMWBcNqoKZeoEMBkJN+m5uPI9RmrLeaOsgr+t3HPUMnUaHXOnzEWraHl397ss3bu0axshhBBCpIEEoJPc2Au/iUarZe/GdZSOU9GbtFTv9lN/0U0ANGww8bzzz5gJMe/fG1ixo/6oZQ7NHMqVw5P3Crv303vxR498l3khhBDiZCMB6CTnyMpm2FnnAbD6zRc4/TsDAFjv7UfQnk+w1ohhdyULc14jGlf50fNfsLX66JOirx99PYW2QqoD1fxh9R+6tA1CCCFEd5MAdAqYcunlaPV69m5ch8VeReEQN/GoytbTbkBFoW6jjame//CL3DV4QzF+/PwqgpH4Ecs068zMmTIHgBc2v8Ca2jXd0RQhhBCiW0gAOgU4snIYc8HXAVj24nOc/f2B6I1a6qMu9hZNw19pIliv56bA40yw1bGrzs8vXvzyqJOipxRM4VsDvoWKytzlc4kmjr6ytBBCCHEykAB0iph8yXcxmC3Ulu+kvOxjzri0FIAdA76Nx1ZEzdYilKif52yP49RGeHdjNY+8t/Wo5d4y4RbcRjfbm7bz7IZnu7oZQgghRLeQAHSKMNsdnDHrBwAse+FZ+o0wM2BsNioaNgy/Fs8+FX9zLpamrbze7xVA5Q8fbOf1L/cfsVyXycUtE28B4MmyJ9njOfqVZEIIIURPJwHoFDJmxkXklAwgHPDz8d+e4Zz/GYLNbSRozmbLoO9RvX0AKlpKKv7DwsFfAHDrK2uPeuf4b/T/BlPypxBJRLj707vljvFCCCFOehKATiEajZbpP/wpKAqbPvmQiq1lnH/tcBQFqnMnsctXgDfzagCm7/kDN5ZUEIkn+NHzq9hdf/hL3RVF4c7T7sSoNbKyciX/3vnvbmqREEII0TUkAJ1i8ksHM+5r3wLg3af+gCtHYdK3+gOwZeB32bq4nsSwWShqnJubfsd5eUEa/BH+539XUu0JHbbcIkcR14++HoAHP3+QxlBj1zdGCCGE6CISgE5BUy+/kow+RfibGlny1z8x7oK+lIx0o2r0fJnzbfZXjIX8MSjBBv6iXcCwDJW9DUH+568rafRHDlvulcOvZJB7EE3hJh764qFubJEQQghxYkkAOgXpDUYuuuFXaLRatq78L5uWfcj0a0fitCWIGF189LmR0JmPgi0PXf0WXsv8MwV2LdtqfFy96HN8h7lxql6jZ+6UuSgo/GvHv1hRsaJ7GyaEEEKcIBKATlG5/UuZcun3AXj/f/+Ep2Yf37hlCjo1TLO9mHf/tB718hdBb8G092PeLn0Dt1nHmr1N/Oi5LwhF218ocWT2SC4fcjkA93x6D6HY4YfNhBBCiJ5KAtApbNLFl9Jv1Fhi4TD/+v19mO0K530rF0WNszfWh+VvBmDm/wIKzk1/580JX2I1aFm+o56fv/AlsXii3XJvHHsjOZYc9nr38ue1f+7eRgkhhBAngASgU5hGo+WiG3+NPTObxsr9vPPUo5ReNJbR9m0AlK0Os6l2JFx4HwAFn9/H61P3YNBpeHdjNbe9uo5E4tBL3m0GG3dMvgOAResXsbXx6AsqCiGEED2JBKBTnMXh5Js3345Gq2PbyuV89sYrTL7jcoqrPwLgw79tZbftMjjtZwAMXHE7L53ThFaj8Orqfdz9n43trvtzXt/zmN53OjE1xrzl84gnjnxvMSGEEKInkQDUC+SXDua8a34EJFeJ3rllA2dcM4Hc6s9RUXj7qXVUlPwaRl8Oapyxn97EM+cmrwZbtLycO99Y325P0O2Tbseqt7K2bi3/2PqPbm2TEEII0RkSgHqJ0edfxNgLvwnA24//nsDQQUzI2EFm/XriMZX/PLmOmtG/g0Ffg1iIs764kb9M16Mo8H+f7mH2a+uIfyUE5VpzuWncTQA8tvoxqv3V3d0sIYQQ4rhIAOpFzrnqh/QfN5FYNMIbD96D7ec/ZeT253E1biUaivOvJ9ZTf8YT0O8MCHu4YNWP+OsMIxoFXvpiL79+ec0hE6O/O/i7jMoehT/q577P7ktTy4QQQohjIwGoF9FotHz957eQ3beYQHMT/170FK4fXcOo9U/h9O8h7I/xxuMbqT/naegzAYKNTFt5HYsusqLTKPzzy/384sUyogeFII2i4a4pd6FTdCzZs4Qlu5eksYVCCCFEx0gA6mUMZgsX33YXtswsGir28eGebRgGlTDqyz/gpImgN8rrj2+j9tz/gz7jIdjAWSv+H899w4peq/Dmukp+9NwXBCIHFksc5B7ENSOuAeB3n/0OX8SXruYJIYQQHSIBqBdyZGVz6W/uwWR3UL1zG2VDitFoYoxadi+Zzjghf5Q3/rSN6rOeh4KxEKjn9GXX8Ldv2jDqNHy4pZbvL1xJw0G3zfjRqB/R196XmkANf/jyD2lsnRBCCHF0EoB6qczCImbePhe90cS+ndvYfNZkdLEgIz+6h9wiM+FAjH89uZ3Kqc9D/hgI1DNp6Q94/dsGnGY9ZXubuPSp5exrDABg0pm4c8qdALy4+UXW1K5JY+uEEEKII5MA1IvllQ7i27/+LVqdjt21lWwYNQilqZZx5c9TMNBFJBTnX0/uoHz8c1A4CUJNDH33B7z5zQT5ThM7a/1850/L2VTpAeC0/NP41oBvoaIyd/lcoolomlsohBBCtE8CUC/Xb9QYvv6LW1E0GvYocdb1yyX0yYdMLdhOv5GZxKIJ3np6JxtL/wL9z4Gon8I3r+TNGT4G5dqo8Yb57lMr+GhrLQC/nvBrXEYX25u28+yGZ9PbOCGEEOIwJAAJBk46na//PBmC9rlsrC/Mpv7BB5j+jQyGnJ6PmlD58MVdfOF+CHXwNyAeJuPf1/D6GXuZVJKBNxzjmmc+47kV5bhNbm6deCsAT615ivLm8vQ2TgghhGiHBCABwOApU/naDb9CUTTszXSwzm2h8tZbOPfyUsZ/rR8AK9/cy0fx35IYmVwx2vLWz/j74GXMHNuHhApz3tjAXW+s58J+FzElfwrheJjZn8yWoTAhhBA9jgQgkTL0jLO58Kc3gaKwJ8vJqrr91P3pSU779gDO+t4gUGDDskreqvgJkUk3A6Bbei8PWZ7ltgsGAPDsit1c+9wqbp0wB7vBzvr69fx5jdwxXgghRM8iAUi0Meys85jxk18AsDvLydJ/v4L/888YeU4hF143Aq1ew+4NDbz6xYV4pj4CKCirnub6qrks/N4QTHoNH2+t5fpFO/jpiNsAWLhuIWU1ZelrlBBCCPEVEoDEIUacM50Lf/pLFGBvpoP/3DOHaGMjA8blcMmvxmFxGmio8PPKOwOpPPNvoDPB1rc5//PreO3KQeTYjWyr8fHwP81Mzj6fhJpg9iez8Uf96W6aEEIIAfSAAPTEE09QXFyMyWRi8uTJfPbZZ4fdd8OGDcycOZPi4mIUReHRRx/tdJmifcPPnsaFP/o5iqqyz6zj9V9eTywaJbfYwWW3TyCryJZcNfqfFraMew3Mbti/imFvXsyb38tgZB8njYEoHy4/A7sum32+fTzw2QPpbpYQQggBpDkAvfTSS9x8883cddddrF69mtGjRzNjxgxqamra3T8QCNC/f3/uv/9+8vLyTkiZ4vCGTbuAGZf9ACWhsifo4/Vbf0E8FsXmNvGdX4+nZHQWiZjK+/8K82nfl1HdA6BpD9kvfYtXp/v4ztg+xGMmqrdfAij8c/s/eXPnm+lulhBCCIGiqqqarpNPnjyZiRMn8vjjjwOQSCQoKirixhtv5Pbbbz/iscXFxdx0003cdNNNJ6zMVh6PB6fTSXNzMw6H49gbdoopu+9ePly9nIRGQ7+BQ7h4zu/QGQyoCZVP39jJ6nd2A1AywsF00+8w7FsCigb1gvk8E7uQ+W9vRpvxDsbsDzBpzbz0jRfp7+qf5lYJIYQ41RzL73faeoAikQirVq1i+vTpByqj0TB9+nRWrFjRrWWGw2E8Hk+bhzhg9G2/YaojF00iwe5tm/nn7+YQDYVQNApTLhnAtKuHotEp7Frv4ZW9t9A48HpQEyjvzOb/Nf2B/7tmLJbA14j5BxCKB/nJe78gEA2ku1lCCCF6sbQFoLq6OuLxOLm5uW225+bmUlVV1a1l3nfffTidztSjqKjouM5/qlI0GsY9/AhTPFG08QR7Nq3n1d/NIeRP3vV9yGn5fOdX47G6jDRWB3nl86+xa+ijgAKrnmHK8h/znx+Oom/sOhJRO5WBcq759+0kEom0tksIIUTvlfZJ0D3B7NmzaW5uTj327t2b7ir1OFqXi9EP/Z7Je2rQxePs37KRf8ybjb+pEYDcEgff/c1E8kudREJx3vqwH58Xv4Sqs8Gujyh89Zu8cWl/xltuRFUVNno/5PIXHyUUjae5ZUIIIXqjtAWgrKwstFot1dXVbbZXV1cfdoJzV5VpNBpxOBxtHuJQ5pEjGfyLX3La9goM0Ti1u3fx4l234qlNTjC3OAx8+6axjDy7DwCffarnbdtLRKylUL8d06LzeXackzMyfgDAhsizfOuvi6hsDqatTUIIIXqntAUgg8HA+PHjWbJkSWpbIpFgyZIlTJkypceUKdpyf//7FE47nynb92OOxWmqquSFObdQvy/Za6bVaTjr8sGc+4MhyXlBmyO84v0Djdlfh4gX5cXLecqRYELmeShKggrDX/jGn97gi/KGNLdMCCFEb5LWIbCbb76ZhQsX8uyzz7Jp0yauv/56/H4/11xzDQBXXnkls2fPTu0fiUQoKyujrKyMSCTC/v37KSsrY/v27R0uU3SOoijk33sPmaUDmbJlL/YE+BrqeXHubVTt2Jbab9gZBQfmBdWEeXnbj9lR+NtkGUt/x5PeGgY5BqPoAgQzF3L5/y7l7yv3pKtZQgghepm0XgYP8Pjjj/Pggw9SVVXFmDFj+MMf/sDkyZMBOOeccyguLmbRokUAlJeXU1JSckgZZ599NkuXLu1QmR0hl8EfXbSykl2XfZdgYwOrxwymIRZBbzJz8S130nfEqNR+/uYw7/51AxXbmgAYM8rLlLofoUmEqMks4XvZTmrDDcR8pQT3Xs0Vk/tz1zeHY9DJ9DQhhBDH5lh+v9MegHoiCUAdE/jyS/ZceRXReIy1UydQ1dyAVq/nG7+4jdKJp6X2i8cTfPr6TsreS/bwFPTVcoH+dqz+jWxw5XNNlo1gPEzUM5rQ/llMLM7kT1eMJ9tuTFfThBBCnIROinWAxMnPMnYseXPnokuojP7kC/oVFhOPRvnX73/H2iXvpPbTajWcMbOUC380Ar1JS8WeOP+ouZ8K8wUMb6rk0coqdIoGvWMN9oI3+by8gW/+cRlr9zWlr3FCCCFOaRKARKe4Zn6HjGuuQauqDH3nIwYNHYmaSPDeX/7If//xNw7uYBwwLofLbp+AO99KwBvn9d3XU2a9jSk+L/OrW25V4vwveX2XUeUJcelTK3h11b40tUwIIcSpTAKQ6LScW36N46KL0MRiDPzXu0w4cxoAn776Au88+RjxWCy1rzvPyqW3jWfgxFzUBPx3x2m8q/8z070Jbq9PXgnmt77J8KFfEokl+NXLa7j73xuJxWXRRCGEECeOBCDRaYpGQ/7992E57TTUQID8F17l3JnfR9Fo2PDR+/zzgXmEAwdufWEw6Tj//w3jzFmD0GgUtu/L4eXw88xoyuf6xmYA9vAS503aCMDT/93FlU9/RqM/kpb2CSGEOPVIABInhMZgoPDxP2IcMoR4fT32Py3k61f/BJ3RyO61X/LS3Nvw1NWk9lcUhVHnFnLJr8dhcxtpatbxSv0Czqo/n580JEPQ597n+N707VgMWpbvqOebjy9jY4Xcp00IIUTnSQASJ4zWZqPvXxdi6N+fWFUVmgce4jvX34zF6aJ29y7+9pubqdi6qc0xef2dzLpjEv1GZhKPw0e1V1Ba/WuurwsB8Ob+v/K9CzZRlGFmX2OQmU8u5z9rK9LRPCGEEKcQuQy+HXIZfOdEa2rYc+VVRMrL0ffpg/vR3/Pm8wup3b0LrU7HBT/+OcPOOq/NMWpCpez9vXz6+g4SCRWH2UMg5yEeL0j2Bn2n/6Xs2HoBy7Yl5wn99JwB/OqCwWg1Sre3TwghRM8k6wB1kgSgzotWV7P7yiuJ7t6DriCfvCee4IM3X2X7558CMOGb3+HMy69Co9W2Oa5qZzPv/HU9voYwGk0CU+b/8fsBq0CBaQVnkRH5EU9/krwy7NzB2Tz6vbE4zfpub58QQoieRwJQJ0kAOjGiVVXsufoaIuXlaF0uCp/6E6s3r2PlP/8BQJ8hw/nGL27FlpHZ5riQP8qSZzdRvrYOALNlPU8P/gfNpmbGuAZxYcHd3P3GHsKxBP2zrPzlygmU5ti6vX1CCCF6FglAnSQB6MSJNTSw9yfXE1q7FsVspvCxR6kwaHjnqceIBINYnC6+/vNb6DtidJvjVFVl7Yf7WPHPHcSjCbSaIJ8W/ZtV+cvJNzq5cczD3Pe6l4rmEHajjj98fyznDs5JUyuFEEL0BBKAOkkC0ImV8PvZ94ub8C9bBloteXf+Fs4+k3///j5q95SjKBpOv+z7TL7kuyiatvPyG6v8fPDcJqp2Jq/+qnB/weLSl1H0UX45bg6vL8vj8/JGFAVunTGEn5zdH0WReUFCCNEbSQDqJAlAJ54ajVL529/S/Ma/AHDNmkXmLb/iw/97mvUfvgdA0fBRXHj9TTiy2/bkJBIqa5bsZcVr21FVCBtqeHvg36ly7OJ7pZfhqfoGL31eCcA3RuWz4NJRWAy67m2gEEKItJMA1EkSgLqGqqrUL/wrtY88AqqKedw4Ch97lM3ry1jyzFPEwmEMZjPnXvUjhp8z/ZCenH1bGnnv6Q0EmiNAgrL8pXxR9BajsgcxyfUrHnm7llhCZWi+g7/8YDxFGZb0NFQIIURaSADqJAlAXcv30Ufs//UtJLxetJmZFNx/P9GB/Vn8xCOpdYIGTJjM+dfdgNXlbnNsJBjj45e2suXTKgA8xho+HPAivowKLh94C8++56LOF8Ft0fPE98dxemlWt7dPCCFEekgA6iQJQF0vvGsX+2/6JeEtWwDI+H//j6yf38Cqd95k+T/+j3gshslm58zvX83Ic88/ZG5Q+bo6lj6/Ab8nDsD63E9Y2e/fnN1vGls3TmfD/ghajcKtMwbzo7NkXpAQQvQGEoA6SQJQ90iEw9QseJDGv/0NAOOwoRTMn4/XaubtJ35PbflOAAoGDWX6dT8ju29xm+PDwRjLX97ExuW1AHgNDXw04EUi+Y0UxH/AJ2uyAbhgWC4PXjZa1gsSQohTnASgTpIA1L28S5ZQ+Zs7iDc3g1ZL5g9/SMaPf0TZB++w/B9/IxoOoWg0jLvo25x+6eUYzG3n9uzdVM+Hf/0Mr98IwObsT1le/Dql7sl8+eXZRKJm+mVaePKK8QwrkL+nEEKcqiQAdZIEoO4Xq62l6t75eN95BwBDSQn58+8l1reIpc8uZNtnywGwOF2cftkVjDzvgjarSEdCMVY+/zFrVyUADX59M/8teY263HKitd+kpmoYRp2Wey4ewXcnFKWjiUIIIbqYBKBOkgCUPp5336Xq7nuI19WBouC6dCbZN93Ent07+fDZv9BUlbzcPbOwL2f9zzWUjJnQZn5P5ZptfPB0GU3h5OrS+5xb+G/xq0TNTqp3XUQinMesCUXM+/ZwTHptu3UQQghxcpIA1EkSgNIr3txM9f0P0PzPfwKgsdvJvuFnOL57GWuXvs+KV14g5PMCUDhsBKdfdgVFw0amjo8FAqx68lm+3FZCHAMJJc7avI9YXfguPs9YwrXTGZydy2OXj2FInvx9hRDiVCEBqJMkAPUMgVWrqJo/n/DG5KXxhgEDyPnVr9BNmsBnr7/Ml2//i3gsBiQXUTz9su9TOHRE6vjmZa/x31d3sis4DgC/vplP+/2Lbe6NhOrOQ/GdzuwLR3D16cVylZgQQpwCJAB1kgSgnkONx2l69VVqH3mUeGMjAObx48n51a+I9e3DZ6+/zLoP3iMRTwahviNGMeWyKygcMjxZQNMedj99H5/sOIPmeAEAVbZdrCh+nUqjh3DNDM4omMaDM0eT4zClpY1CCCFODAlAnSQBqOeJezzUL/wrDc89hxoOA2A77zyyb/oFkQwXK//5D9Z/+H4qCBUMHsaEb1zMgAmT0agq8Y8eoeztTXzhm0lMNQOwI+NLVvb7N42qCW3zDH573ky+O6FIeoOEEOIkJQGokyQA9VzR6mrqHn+CpldfhUQCAPsFF5B1/U+IZGUmg9DSA0HIlZfPuIu+zYizp6OvXYv/pZv5bP+ZbAqeh4qWuBJjQ94yVvd5F38sg4GG7/D4xZdTlGFNZzOFEEIcBwlAnSQBqOcL79xJ7WN/wPvuu9DyT9h23nlkXX898T75lL37JmvefYuQ3weAyWZn9PlfY8w5Z2Nb9Ufql7/Lcu+V7Ikk5wdFNCHW5X/EmoIPCceyubjfNdw57RKMcqWYEEKcNCQAdZIEoJNHeNs26p76M5633koFIfOE8WTfcAP60aPZ8PESVr/5Bk3VycvntTodQ844h3HjSsj5Yj579pv41PsDamMDkuVpg6wp+IB1+R+hJnK5avg13Dj5ErQaCUJCCNHTSQDqJAlAJ5/wzl3U//nPNP/nPxBP3h/MPHYsmdf9EMtZZ7Jz9ed88Z/XqdiyMXVMwcDBjOmrUlrxN/aGRrPS930aYn0BCOr8lBW8z4a8T9Bq3Vwz/CquHfNdTDqZKC2EED2VBKBOkgB08opWVVH/l7/Q9MqrqJEIAIb+/cm45mqc3/oW1XvKWfXm62z7bDmJ1qBktzGyj8qIyEfUJsbzuf9ymmLJK8YCei9f9nmPTTkr0GhNzBp8OT8e+wOcRmfa2iiEEKJ9EoA6SQLQyS9aXUPj/z1P44svkfAmF03UZmWR8T9X4P7e9wiqCdZ/8C5rlizGV1+XPEhR6J8ZZ5RpM2HNSL4IXI43ngNASBtgXf5HrM/7mJg+zvl9L+K6Mf/DIPegdDVRCCHEV0gA6iQJQKeOuM9H08uv0PDcc8Qqk/OAFLMZ18yZZFx9Fbr8fHas/ow1777F7rVfpo6zGRMMs1VgMvZnS+Q7qTWEopoIG3P/y9r8pfiNTQxxjeba0f/DtL7T0GvkbvNCCJFOEoA6SQLQqUeNRvEsXkz9/z5NePPm5EaNBvv555Pxg//BPH48TVUVrHnvLTZ89EHqVhsAhZZmsi12qvkWDfFkj0+CBPucW9ia8xnbM1dj02fwvSHf5ftDv0u2JTsdTRRCiF5PAlAnSQA6damqSmDFCur/92n8//1vartxyBAy/ucKHN/4Bgmtlh1frGT90vcoX7M6dXWZQROj0JogrJ9KXeKM1IKJDaYavixczM6MtSS0CSbmnMWPxlzBpLxJsqiiEEJ0IwlAnSQBqHcIbdlK4//9H83//jdqKASA1unEOXMm7u9ehqG4GE9dLRs/WsL6j96nuboqdazLEMZpzqeG76Bqkv9GQtoAm3KXszH3v3hNDdi0eVw6cCZXjbqULHNWWtoohBC9iQSgTpIA1LvEm5poevVVGv/2d6IVFantlsmTcX33Muznn4+i07Fv03rWf/geW1f+l1jLFWYaVDLMZiK60whrx6AoGlRU9jm2silvOeXudSQUlb7m8Vw2+BK+P2IGBp0hXU0VQohTmgSgTpIA1Dup8Ti+jz6i6aV/4Pv449TQl9blwnnJJbguuwxj/xLCAT+b//sx65e+R9X2ranjTVoVs7EYv+48NFo3AGGtj805n7M1+3PqLftRVCsDzGcxa8jFXDx8Eia9Li1tFUKIU5EEoE6SACSiFRU0vfoaTa++SqzqwNCXZeJEXN/9LvYLzkdjNFK3p5z1S99j48cfEvR6UvvZDUYS+jHEdGNRNBYAmkyVbMlexfasVXhNDajhPProzmR63xnMGDKY4QVOtBqZMySEEMdLAlAnSQASrdRYDN8nn9D0j5fxffRR6gasWqcT58Xfxvmd72AaPJh4LMqOVZ+x/sP3KC9bjaom91MUsBrcRLTjUQyDURQjANW2nWzLWs2ujHX4DU3EAiXog+OZmH0O5wzsx+mlWfTPssokaiGEOAYSgDpJApBoT7SqiqbXXqPplVeIVVSmthsHD8b5rW/h+MbX0efm4muoZ8uKT9i07COqd25L7afRaDGb8okoY9Do+6MoyeGvGuseyjPWsStjHU2mKkyBIpqaJ5OhmcDpJQVMKM5gQrGb0mwbGukhEkKIw5IA1EkSgMSRqPE4/v/+l6aXX8G3dClqNJr8QFGwTjkNxze/hf3889HarDRW7mfzfz9m838/oqFiX6oMrc6A2dyPsDoSja4viqIBoNlYS3nGenZlrKXBuos+ARdxzwj2eE9HMWYzrp+bCf3cjO+XwegiJxaDzCESQohWEoA6SQKQ6Kh4czOexe/Q/K9/EVy1KrVdMZmwT5uG4+sXYT3jDBSDgdrdu9i0bClbln+Ct742ta/BbMdiH0Ao1B9VU4SiJO88H9R52ePexF7nZmodmxgW9dHXl0nUO5TN8YFsUYopys9jdJGTUYUuxhS5GJBtk3lEQoheSwJQJ0kAEscjsm8fnn//m+Y3/kWkvDy1XWO1YjvvPBxfuzAZhvR69m/ZyOb/fsyWT5cROmjytN5kxZYxhHCwkLjaF0VJ3l5DJUGtdR97XZuocm5koHYz0wN++vqd7IyXsC7Rn7WJEnbrB9C/Ty6ji1yMLnQxushJH5dZ5hIJIXoFCUCdJAFIdIaqqoTWr6f53//G+867xKqrU5+lwtCFM7CecQaqTseedWVs+2w52z//tM2VZDqDEWfuUBL0J+DNT02gBghrg1Q6tlPp2IbLtJ5JiR2cGwxQFItRlhjAp4lhrEn0Z53an6C5gNF93YwqdKaCUYZV1iISQpx6JAB1kgQgcaKoiQTBsjV431mMZ/E7bcKQYjJhnXoG9mnTsZ1zNhqng/2bN7L9sxVs+2xFm2EyjUaLq6AUg7k/nuYc4pGMNr06QZ2PCsc2wrbNlOrWcnZsJ6MjEbRAvWpnbaI/a9UByVCUKMHoLmBEgZNhBQ6G5jsYVuCgwGmSniIhxElNAlAnSQASXaFNGHrvvTZXkqHRYBk3Dtv0adinTUNfWEj1zu1s/3wF21YubzOBGsDiysSVO5SImo+3IRslbmrzeUDvoc6+A4dxE6M0azg3vh0bidTn1aqLdYkS1qslyedECSFTDsMKnKlANCzfQR+3GYdJJ8FICHFSkADUSRKARFdTVZXw5s1431+C94MPCG/a1OZzQ0kJtrPOxHrmWVgmTsDT2MCusi/YVbaKvevXEotGUvtqtDqy+w3G6Cqh0e8mXOtGo7a9OiysDRB27CXXso2JkeUM02xFq8Tb7FOrOtiYKGa9WsyGRDEb1GL2qDkMynVyemkmk0syGF7gpNAtc4qEED2TBKBOkgAkultk3358H3yAd8kSAl98AfED4UQxm7FOmoT1rDOxnXUWSm4O+zauZ9eXX7Cr7AuaqirblGXPzCa7/wiCugxqm6xQ60AXbzvnJ66JonE1UGSvZoS6hrzQh1g1jYfUy6Oa2aT2Y32ihA2JfqxXS2g0FzOsMIORfZwML3AwvMBJUYaEIiFE+kkA6iQJQCKd4l4v/uUr8H3yMf6PPyFWU9Pmc0NxcTIMnXkWlkkTaW6oY1fZqmTv0Ia1xFvXJQI0Wi25AwZiyOlDTVRLQ5MFc0Muppj1kPPq7VGKsoP0MZeTF19JhmcpukTgkP1Cqp7NahEbEiVsUItZnyimwlhCaUEWwwuSoWhEHyf9s6zotJoT/wUJIcRhSADqJAlAoqdQVZXw1q34Pk6GocCXX0IslvpcMZmwTJ6EbeqZWCZPQtO3iH2bWnuHVtFcXdWmPI1WS1ZJCeFMOxUxlUafGbe3HxnBPBTahhWtXiG3QEdeRiN5+m3kRf+LqX4lSsR3SD1jqobtah82tAyfrU8Us11bQlF+XjIQtQSjwXl2THpt13xZQoheTwJQJ0kAEj1V3OvFv2IF/k8+wffxJ22uKgPQZmRgmTQJ6+RJmCdNImSzsG/jevZuXMfejevw1tW22V+j1WIpyqMpQ6E8ESQcySQ72J9cbzHGuOWQ8zuyTeT10ZJrryVbu5Ws0Ap0NatRAnXt1rc8kct6tTg1t2gzJbiz+zC8jyPVWzSswIHDpD9xX5IQoteSANRJEoDEySDZO7QN/ycf41++gsDq1aihUJt9dNnZWCZNwjJ5EtbJkwmYjOzbtJ59LYHIU9t2eE3RaNDmu6nJjLBdaQKlIBWIMoL5h1ZCAXeuhex8Ldn2RrK128mKrMRQ9wVK875D9weqVDfrWyZZb0gkH1p3X0YUOhnecmn+8AIHOXZTu8cLIcThSADqJAlA4mSkRiIE163Dv3IlgZWfEfzyS9RIpM0+uvx8rJMmYZk8GevkSQT0OvZtWs/eDa2BqG2PEhqFRK6NvS4vO01NYMgjO1BClr+IHH9fLJH2//fhzDaT3cdItqOJbP1OsqNfYKz/Auq3o3Dof3IaVRsbEv1aQlEJG9R++Kz9GFzgZmi+naF5yfWK+mdb0cu8IiHEYUgA6iQJQOJUkAiHCX5ZRuCzlfhXfkZw7Vo4aII0gL6wMNU7ZJk8maBGSQ2X7du4juaaQwNROMtAuaOJPS4PHpseV7iQbH8RReGB5Pj7ovW333OT2cdKbl8L2c4msnU7yAivRl+zGrV2E0oidsj+ftXIJrVf6uqzjYliyjV96ZfjYki+nWH5DobkORiabyfTZmznjEKI3kYCUCdJABKnokQgQODLLwms/IzAypUE169vc7k9gKFfPyyTJydD0aRJBBS1zRyir06qBgi6tey1N1PlDlHjDhPVGcgOFDFMHUe/yBAsTW7CDYf+Z0ZRwJVrIauPhUynn0z9HrLia7A2fgbV61FiwUOOiahatqpFyYnWLUNom9S+2OzJBRyH5tkZmu9gSL6dAdk26S0SopeRANRJEoBEbxD3+QmuXpUaMgtt3AiJRJt9DAMGYJ08CcukZCgKxGOpIbN9G9fRVF15SLkRE1Q4/dS6w9S4w9Q7ItiUDKYwjYHREdg9OYSqVYLe6CHHApisejL7WMnKjJJhrCIjsRl3oGVeUaj5kP0TqsJuNYctal+2qIVsSRSxRS1ivyafkhxXmyG0Ifl2sqS3SIhTlgSgTpIAJHqjuMdD4ItVBFauxP/ZZ4Q3b4av/OfBOGhQav6QeexYwloNFVs2sX/rJiq2bKR65w4S8bbDWQlFpd4RodYVps6VfNa6bZzuPovRyiTywyVEazTU7fPRVB346ilTrC4jGdkaMqzNZOj2kBFdi9vzCcZgebv7h1UdO9Q+bFaL2JooZItaxJZEERFrAUNb7oE2NN/OkDwHA7JtGHTSWyTEyU4CUCdJABIC4k1N+D//PDVkFt627ZB99P36YhkzFvPYsZjHjUXTt4ia8p1UbNlExdZNVGzZ1OYO961C+nibQGQszGZc30mMy5zAIHUEiXoD9ft9NFb6aajw42+OHFJGK6tTR4Y7Roa5gQxtORnRNbh8yzHF278036Oa2doSijarRWxVi9ih9CUzOz85ryi/ZRgtz0G2XXqLhDiZSADqJAlAQhwqVl9P4PPPk0Nmn39OZPuOQ/bR2O2YR4/GPHYMlrFjMY4chS/go3L7Fqq2baFy2xaqy3eQiB066bnZGqXWFabWFUZXkMGQQeOZUDiJCbkTcJFJY1WAhgofjZUBGip9Rw9GDi0ZrggZ5joyNLtwh8twB1Zg4tBABlCjuticKGKreqC3qMHSn5KCbIbmOxiYY2NAjo0B2TacZlm3SIieSAJQJ0kAEuLo4s3NBNeuJbB6NcEvywiuXYsa+MqtMzQajIMGYR47JhmMRo1C06cPdXvLqdy2lartW9i/dROer15tRnLorMkWpd4RQc2x0mfAEEYPP53J/c4gz5oHQDgQpaEykOopaqhq6TFqCh+23marBpcjjNNQj1PZgzOyAVd4LU5tFQZN23WUEqrCHjUnGYjUQrYkkvOMfNZ+FOc4GZBto7QlFA3IsZHvMKHRyD3RhEgXCUCdJAFIiGOnxmKEt24l8OWXyUD05ZdE9+8/ZD+N3Y555AhMI0dhHjUS08iRRE1GqnZspXLbVvZt3UDVjm3EAodeBaai4rHGCGbqcPUtZMCg0UwYdS4D8oa0uRlrOBBt6THy01DZ8jhKMAKwmOM4LR5cmv0441txJbbh1Fbi1FWiVw70NoVVHTvVgpb5RUWpeUYN+txUL9HB4ag4y4JRJ7cAEaKrSQDqJAlAQpwY0eoagmXJMBRcu5bQxo2HrFYNoMvLwzxyJKYRIzANGYxh8GBCWg015TvZu2MTO7eU0bRnH/jaDzBBSwIl10F2cX+GDJ3ImBFTsWdkHXKH+kgwRlNNgOaaIM21AZpqgjTXJJ9DvvavSmtlNQVx6apxqjtxavbi0la0hKMqdEryWK9qTg6hJQrZovZlq1rI5kQRzYqDogwLpdmtw2jWVDhyWQzH+e0KIb5KAlAnSQASomuo0Sjh7dsJrl1HcN1aQmvXEd6+/ZDL7wG0bjfGIYMxDRmKachgjEOGEs90s6d8K2s3/Jd9OzYTqqjD5D30WICYWYOpIIv8/oMYMngCBf1KceX3Qadvf/5OyB+lufZAIDr4ORw4dM7SQa3Cpm/GqbSEIl0FrpZeI6e2Cq0So1Z1sEvNpzyRxy41n11qHuVqHuVqLlarPTWENiDbyoAcG6XZNvq4zDKcJsQxkgDUSRKAhOg+Cb+f0MaNBNeuI7RpE6HNm4jsKj9kkUYARa/HUFqKaciQVCgK9clmdfkXbN70ObXlu6Dai92rRcOh4UFVwJjlIqeomD79BpFZ2JfMwr64C/qgNxz+iq+QL9rSc3RoOIqEDq1nqr4ksGlrU4HIoa3Coa3Boa3Brq3BqPioIqMlGOW2hKI8dqr51Ojy6JOV0dJTZE0Nq/XPtmLSy3CaEO2RANRJEoCESK9EKER423bCWzYT2ryF0OZNhDdvIeHztbu/Lj8f05AhGIcMRj94EHuz4Iv6zezavh7P3v2YGuO4fHoMscOs9aMoOHNyU4Eos08RmYV9yehTiMFkPmw9VTW5oOPBgai5NpgaZouGDx+OAPRKAIe2Gru2tiUYVWNvCUc2TS31GjO7EnmpYLRLzWM3eSScfemX46Y020ZxlpWiDAtFbjMFLrOEI9GrSQDqJAlAQvQ8qqoS3b+f8ObNhDZtJrRlM+FNm9udaA2gsVgwDh6McchgIv0L2J4V50sq2LZvM80VFTi8Wlw+PS6fHmP08KHBnpXdJhRlFhaR0acIk9V21PoGPBGaaw4EIm99EE99CE99iKDn8JfwtzIqvlQgchz0bNHU4tUk2Ke4U8Npe9Vs9qnZRG19yMjIpMhtptBtoSgj+VzYEpDk9iDiVCYBqJMkAAlx8oh7PIS3bEn2FLWEovC2baiRdgKGomAoLkY3oITmAgfl7hhl5lpWxsuJNPtwefU4fQZcfj0urx5z5PDByObOIKOwLxkFfXDnFeDKL8CdV4AjOxetTnfUekcjcXwNITx1oQPBqOW1tz5E8CiTsgGMiheHtjoVjloDkqr10axRqcTJPjWb/WoW+9RsKsgmYiskIzOLQreZopZgVJSRfM5zmNBJQBInMQlAnSQBSIiTmxqLEdm1q83wWWjzZuL19e0foCgoffLx93FRnaFlu83PGmM1e80REooep9+Ay6fH6dPj9hmwhA4fjBSNBmdOLq68Apw5ebhycnHm5uHMST6MFkuH2hANx/G0hCFvS6+Rty7Y8hwgFDjy8BqAWdOcCkZ2TS02bR12bR2qxo9Ho1KNmf1ks0/NolLNpE7JQLXnY3YXUJBpb9ODVOS2kGM3ysRs0aNJAOokCUBCnJpitbWENm8hvGM7kR07Ce/cSWT7duLNh95ktVVCr8OfbaUyQ2G7zc9+Z5wap4LPaEST0OMI6MkImskMWZJXpMXavyqtlcnuwJWTi+Mr4ciVm4c9MxuNtmNzeCLBGN6GlmBUH2zpPQrhqfPjrQsSDh39P+1aIti0ddi09dg0ddi1yZBk0dQT1wbxKgnqFCs1qpsq1U2dkknUmodqz0Pn6oPdmUWu00yOw0iuw9TyMGIxHL0HTIiuIAGokyQACdF7qKpKvKGB8PYdRHbuIFK+m8ju3UT27CGydy9EDz8UFdMpVLmg0g2VGVDlUqizawkYDWgw0ieRSXbEhiWgQdMcJuY/dHHHgykaDY6sbJw5eTiyc7FnZh3yMJg71oMUDkSTAaklGHkbQ/gawvjq/fgagvi9cWjnSrmvMij+lp6jWmyaulRgsmrq0Wua8WlU6hUr1aqbKjWDatVNsy6LqCUXHAXoXQVkuuzk2g8EpFyHiWy7USZsixPupAtATzzxBA8++CBVVVWMHj2aP/7xj0yaNOmw+7/88svceeedlJeXM3DgQB544AEuuuii1OdXX301zz77bJtjZsyYweLFiztUHwlAQggANR4nWlmZDEV7dhPdvbvl9R4i+/YdMRxFdFDlgqoMhSo3VLoVapwKUaudbFshfRKZZITMmPwQb/Tjq6slfoTyWhnMljaByJaRhSM7h8w+RThzcjE7nIcsANmeeCyBvymMrzGMtyGErzGErzGMrz6Et8GPrzFMONixnwej4sOqrcemqceqrceqaWx5bsCqbSCqhGlWdFTjokrNoAY31aqboCET1ZqNxpGH0ZlHpstJrsNIjsNEjt1Itt1Ilk2Ckui4kyoAvfTSS1x55ZU89dRTTJ48mUcffZSXX36ZLVu2kJOTc8j+y5cv56yzzuK+++7jG9/4Bn//+9954IEHWL16NSNGjACSAai6uppnnnkmdZzRaMTtdneoThKAhBBHo8ZiyXC0ew+R3eVEdu8muntPsvdo3z5o54avrcI6qG4JRVVuqHIrhHNcOHKLyXb2I1d14wgZMPhVgo2NeOvr8DbUEfb7j1ovnd6APSsbe2YmtowDIeng92a7o0MhKRKK4W8K460PtQlKyeAUwtcQIhrp2E+IQhyLphGrtjEZjFrCkVXTgEXbhEXTSFwJ4VMUGhQ7daqTetVBAw68GhdRUwYJSxYaWzZ6RzZmRzYZdjNZNiOZNkPy2WrAZTGglXlKvdZJFYAmT57MxIkTefzxxwFIJBIUFRVx4403cvvttx+y/6xZs/D7/fznP/9JbTvttNMYM2YMTz31FJAMQE1NTbz++uvHVScJQEKIzkiFo9RwWstz+W6i+/a1u8hjq4QC9XaocUGtS0M4x4W+sBBXyUCy+w0nz1mMLWwg0NiQCkbNNdXU79uDv6kROvCfdK1Oh9WdiS0jE5s7I/nczmu90XTUsiLBGL6mMP7GML6mZFDyN0fwN4UJNIfxN4YIeKMdqVbrN4BJ8baEouTDrGk66H0jFk0zJqWJoCZBI3YacFCnOmhQHTRiJ6jPIGLKIG7OQmPNQufIxuzIwmU1k2kz4LYYyLAacFsNuMx6LAZthwKh6PmO5fc7rTPVIpEIq1atYvbs2altGo2G6dOns2LFinaPWbFiBTfffHObbTNmzDgk7CxdupScnBzcbjfnnXce9957L5mZme2WGQ6HCYcP3GPI4/EcZ4uEEAIUnQ5DURGGoiI4c2qbz9RYjGhFRSoQRfbsIVi+k+CectTKGjSRKNkeyPYAexJAQ8tjLfAqES3scil4M81EczPQFuTjKCqmeMoMcvuNwGrNJNDQgLehHl9DPd76OnwNdXjr6/E11OFvbiIei+GprcZTW33EdhitVmypoJSJLSMDqzsDmysDq9uN1ZV8n5FvJSPfethyEvEEQW8Uf3MYf1PLoyUk+ZvC+D0Rgp4QQW8MVdUQUp2EYk4a6Hfk75k4Jo2nJRg1U6BpZICmGbOmDpN/FyaNN/XQ4yOoUWjESoPqoBw7q1pCk0fjIGxwEzdloJrdaKxZ6O2Z2Gx23BY9LksyNLks+tR7l1kvSwac5NIagOrq6ojH4+Tm5rbZnpuby+bNm9s9pqqqqt39q6qqUu8vvPBCvvOd71BSUsKOHTv4zW9+w9e+9jVWrFiBtp0rLO677z7mzZt3AlokhBBHpuh0GPr2xdC3L5x5ZpvPVFUlXldHZN8+Inv30ly+jcZdmwnv3YumqhZLQwBDHArqVagPwNYAsA/4HAA/0KiFZreeUJYdNS8LQ59CCvsNIOe0SeT0H442M5OAx4OvMRmQfA31+BobDnkdDYcI+/2E/X7q9+05YptMNjtWl7slHLmxZmQmn90ZB7a7M7C6HBwp0yQSKiFflIAnQtATIeAJE/BEk8/eCIHmCMHWZ38UVdUSTLgJJtwcZoGDQxgUfzIUKV4yNF7yW0NScB8mz6Y2oUlVIgQUFR96GrFTiY2Nqo0m7DSqNkJ6JzGjG9XkRrFmorO6MVjdOMwGnGY9TrMeR8tz8rUOp1mPzaiTHqce4JS8VvF73/te6vXIkSMZNWoUAwYMYOnSpUybNu2Q/WfPnt2mV8nj8VBUVNQtdRVCiFaKoqDLzkaXnY1l7FhctM0LajRKqGI/1dvXUrdzI749O4lWVKCpqsNc58fpiWGIQ3ZdFOoaYHMDsBX4AB/gA+Ia8LvNRHNcKPm5WIv60bffILImnoEhvwBdXh6KwUAkGMDX0BKMWsNSYz3+xkZ8TQ34GxvxN9YTj8UI+byEfN6jBiWD2ZzsNXK5DzzcGVicLqwud/LZ6SIj34Wm8MgrbSfiCYItYelAYGp57YsQ8sUI+aOE/FHCvijhYHJOVkS1Eolb8ZDX4b+LhmhLKPLhULzkpEJSE0b/XkzKQT1Nio+IJk4ABY9ioUm1UYGVjaqdJtVKI3a8io2I3knc6EI1u1EsGegtTpyWg4KT6UBwOvhhM+lkjtMJktYAlJWVhVarpbq6bTdsdXU1eXnt/+PMy8s7pv0B+vfvT1ZWFtu3b283ABmNRozGw98IUQghegJFr8fcr5jifsUUT/vWIZ/HwiEqdq2jasc6Gsu3Eti3G7WyCn1NM46GEBkeFV0CHPVBqA/CpkqgjCCw96Bywg4TiSw3urw8bIX9yCksoTA/H/3ICejy89Hn5KAYDKiqSsjvw9+YDES+xnr8TY34GxvwNSUDUmtgioXDRIJBIsH9NFa2f/uSAw1VMNvsLcHIhcXpPug5GZRaw1JmgYvsIvtRv7tEPEE40BqKWp590VRIag1Kqfe+CCF/jHhMJYGeQCKDQCLjmP5eeiWAUfFh1PjJUALkafyYFB8GjR+jUoNR48eo8WNQ/OiUIGFFJago+BQtXnQ0Y2U/NppUK83YaFJtNGMlYnCiGl1gdqeCk8Okx2lpp9fJpGvTGyW3QjkgrQHIYDAwfvx4lixZwsUXXwwkJ0EvWbKEG264od1jpkyZwpIlS7jppptS29577z2mTJly2PPs27eP+vp68vPzT2T1hRCiR9EZTfQdMpG+QyYe8lksEaPCs4/9u9ZTu2sDnj07iOzf39J75COrOUGmB4wxMHpC4KmEnZWE+ZJwO+dKuB1o8nIwFxRhKijElpeLKy8PfVF/9BNPR5edjaLXA8mhvUgwkAxHrY/GRvzNybAUaG7C39RIoLmJQHMzqpog6PUQ9HqO2qvUNiy5vxKaDgpLLjcWhxOz3dDh71NVVWKRxKFh6SvBKdXb5IsQ9kcIB5OLYUZVC1HVgu/Ia2Mell4JYlD8FGoCDFACGBQ/Rk0AQ7Acg8aPQQmgU4LElTgRRSWkQEhR8CsaGtGyW9HjwYwHK82qFQ8Wojo7qskJJhdaixOHxfSVXiddKki1bnO0PJv0mlNq6C7tV4G99NJLXHXVVfz5z39m0qRJPProo/zjH/9g8+bN5ObmcuWVV9KnTx/uu+8+IHkZ/Nlnn83999/P17/+dV588UV+97vfpS6D9/l8zJs3j5kzZ5KXl8eOHTu49dZb8Xq9rFu3rkM9PXIVmBCiN4klYlT6Ktnj2c2+/Zup37sV395yolWVaGobcXuS4SjLo5LhBcPR78KBqlEgw4U+JxdTfgH63Fx0ObnocnPR5WSjz8lBl52Nxtl23aJEIk7I68Xf3ESgqYlAc0tgam76SlA6EJY6rCUstQ1GbcNS6jOHs8Orcn9Va29TOBAjHIwRCcQIBaJEgge2hQMxIoFoy34RIoFIcls4Qezoy0F1mI5wS1gKYlAC6DVBjEqg5XUAlChxJUZcSRBRVMJAUNHgVzT40OFVdDRhwKNY8CtW4kYnqtGBYnahN9txmA3YTbqDgpIO+yGvdTjMemwGXZffSuWkugwe4PHHH08thDhmzBj+8Ic/MHnyZADOOecciouLWbRoUWr/l19+md/+9rephRAXLFiQWggxGAxy8cUX8+WXX9LU1ERBQQEXXHAB99xzzyGTpw9HApAQQiS1hqPd3t3s8exhj2c39VXlhCv2E6+qxtwYINOjkumBTK9KphcyPaDraC4x6NFlZ6PPzkHXEop02dkHXuckX2tdrkN6H74alvzNjQRaw9JBoem4w5LdgbUlKLXtYToQksx2B2aHo0NLBnRUPJ4gEoylAlPydTwZpoKx1HPEHyLsCxEJhIkEo0RCcSIhlUhEIRY/sUNdGqIYlAAGTbClZyqAXgmBEmkJUQliLT1R4ZaeqABafIoOLzo8ioFGxUjEaCXR0gN1ycT+/L+pJSe0niddAOppJAAJIUTH+KN+Kn2VVPgrqPRVUumvpMK7H0/VXsJVFSh1jbi8CTK8Khk+cHshw6vi9oE9dAwn0ukOBKLsrzyystBltXyWkZEaejvYwWEp1YvUTljyNzUS9HiOLSwBOqMRs92RDEUtwcjicGC2OzE7HJgdTiz2ls8cDkwWK4qm6+bjxOMJoq2hKRQjGkqGqEioJTwFIkR8ASL+ABF/mEgwktweThAJJxc5j0S1xOInfqaMlggGTZDM3L18+66fn9CyT5p1gIQQQpzcrHorpe5SSt2l7X4eTUSp9ldT6U+Go0pfJVv8lVT4Kqht2k+wphJLcwS3X8Xt5cCzD1z+5JCbIwjEYsQqK4lVVh61TlqnE21WFrrMTHRZmWgzD7w2ZWZiy8pCN2Aw2qwsNIZD5wR1NCwFvR6CnmbisRixcBhvuBZvXW2HvjdFo0n2Hn0lNJkdzpbg1Pr6QC+TVndosDvsd6DVoLVpMNk6fkx7EvEE0XA82bsUjCVfB6NEfEEiPi9Rb0uICiRDVDQYIxKOEw0ne6IiUQ3RuJZIzEBcTdYljoFgwoDTdvibEHcH6QFqh/QACSFE91BVlaZwE9WBamoCNVT5q6gJ1FAdqKban9xW561C1+jD7Ts4IKm4/OBqCUpuHzj9oD3GXzSN3d4SjrLQZmehy8xCl5mB1uVC63ajdbmTz24XOpcL5SuBSVVVoqEgAU8yDAU8zalgdPDroCc5qTvgaSYSDBzXd2W0WFNh6EAvk/Mrr5O9ThaHA73J3KMmLcfjCaKhOJFAhKjXg8lmwJrT/gLFx0uGwDpJApAQQvQs/qi/TSiqDdZSF6yjNtDyHKylPlCL1hvE5QenX8Xp58DrQDIgHby9w/OUDqKx2VoCUWsocrd5r3W70bkP2uZwoOjaDrbEolFCLWEo6PEQ8LYGpOZUWDqwzXNcQ3IAWr2+3Z6kg4fiLC1DdCabHZPNjlZ3cg8MSQDqJAlAQghx8lFVFX/U3yYcpV4Ha6kL1FETrKEuUIc34sEaAmcAXL4DocjlV3EEwB4Ee0DFHgRHAGxBOK4ZO4qCxuFA19qjdHB4Ovi968A2jcPRZn6QmkgQ8vtSPUhf7VEKtvQ0tQaqoKeZWDRyXN+h0WLFZLdjttkx2R0tz3ZM1mRAMttsqbBkstkwWm2YrLbjvmLuRJMA1EkSgIQQ4tQWioWSvUbBehpCDdSH6mkINhx4HWpIfdYUbkJJqFhDyWDkOCgctQal5DawB1XsgeQ+tmOZ5H0wjebAEFxrUHK5D9p2aIDS2GxthruiodBhh+MCqd6mA88hv69T36fRYsV0cDiyHvza2ma70ZYMTWa7A107c7A6QwJQJ0kAEkII0SqaiNIUakoFo4PD0cHvm8JNNIYaCcSSc3w0CRVbS0hyfCUcfTVAtQYrS3urTnaETnfEITmNw4G25aGxO9A6HWjtdhSLBUVRkhO/fT5CPm8yGPm8hLwtz6lH8vOQ35d6fbzzmQDGf/3bnHPldcd9fHvkKjAhhBDiBNFr9GRbssm2ZHdo/3A8TFOoicZwI42hxlQwOvi5ovWzlv2iieTqh9p4SzAKgKMlMH01QCWD04HhOVMUiMWI19YRr607tsbptGjtLcGoNSA57FgdThwOe3Kb3YG2MKdNcNI4nWhtNhKKQjjgP0xIOuh962v/gc+N1iPf762rSQASQgghTiCj1kiuNZdca8cW31VVlUAsQGMoGYo8EQ/eiBdPxHPgEfawv+W1N+LFEz7wWhdNpHqTHIH2A5Q1BNZQchjPGk6+1yWAWJx4YyPxxsbjaqtisRzoWXLY0TucmOz2g3qc7GgKc9E67G1ClmKzo5hP3OKRx0MCkBBCCJFGiqJg1Vux6q0U2guP6diEmsAf9bcbjDwRD83hZqoPClOpYBVqJuz3YAhEU4EoFZBaH+GD36tYwgc+s7TMsVYDAWKBALGqqmNut/0HV1B4x2+P+bgTRQKQEEIIcZLSKBrsBjt2g/24jg/FQm2DUdjTpufJG/Gy/yuhyhPx4A95UL3+Q8PTYcKUJaxiC4EllJwcrkvAF/6NHFvcO7EkAAkhhBC9lElnwqQzkWPJOeZjY4kY3oi3bXiKetr0Qu1v2d66jy/qwxv2EAn4uHr4aV3Qoo6TACSEEEKIY6bT6HCb3LhN7uM6PnEcizueSF13JzYhhBBCiMPQKOmNIBKAhBBCCNHrSAASQgghRK8jAUgIIYQQvY4EICGEEEL0OhKAhBBCCNHrSAASQgghRK8jAUgIIYQQvY4EICGEEEL0OhKAhBBCCNHrSAASQgghRK8jAUgIIYQQvY4EICGEEEL0OhKAhBBCCNHr6NJdgZ5IVVUAPB5PmmsihBBCiI5q/d1u/R0/EglA7fB6vQAUFRWluSZCCCGEOFZerxen03nEfRS1IzGpl0kkElRUVGC321EU5YSW7fF4KCoqYu/evTgcjhNadk8g7Tv5neptPNXbB6d+G6V9J7+uaqOqqni9XgoKCtBojjzLR3qA2qHRaCgsLOzSczgcjlP2HzZI+04Fp3obT/X2wanfRmnfya8r2ni0np9WMglaCCGEEL2OBCAhhBBC9DoSgLqZ0Wjkrrvuwmg0prsqXULad/I71dt4qrcPTv02SvtOfj2hjTIJWgghhBC9jvQACSGEEKLXkQAkhBBCiF5HApAQQggheh0JQEIIIYTodSQAdaMnnniC4uJiTCYTkydP5rPPPkt3lTrkvvvuY+LEidjtdnJycrj44ovZsmVLm33OOeccFEVp8/jJT37SZp89e/bw9a9/HYvFQk5ODrfccguxWKw7m9KuuXPnHlL3IUOGpD4PhUL87Gc/IzMzE5vNxsyZM6murm5TRk9tW6vi4uJD2qgoCj/72c+Ak+/v9/HHH/PNb36TgoICFEXh9ddfb/O5qqrMmTOH/Px8zGYz06dPZ9u2bW32aWho4IorrsDhcOByubj22mvx+Xxt9lm7di1nnnkmJpOJoqIiFixY0NVNSzlSG6PRKLfddhsjR47EarVSUFDAlVdeSUVFRZsy2vu733///W32SVcbj/Y3vPrqqw+p+4UXXthmn578Nzxa+9r736OiKDz44IOpfXry368jvwsn6r+dS5cuZdy4cRiNRkpLS1m0aNGJaYQqusWLL76oGgwG9emnn1Y3bNigXnfddarL5VKrq6vTXbWjmjFjhvrMM8+o69evV8vKytSLLrpI7du3r+rz+VL7nH322ep1112nVlZWph7Nzc2pz2OxmDpixAh1+vTp6pdffqm+9dZbalZWljp79ux0NKmNu+66Sx0+fHibutfW1qY+/8lPfqIWFRWpS5YsUb/44gv1tNNOU08//fTU5z25ba1qamratO+9995TAfXDDz9UVfXk+/u99dZb6h133KG+9tprKqD+85//bPP5/fffrzqdTvX1119X16xZo37rW99SS0pK1GAwmNrnwgsvVEePHq1++umn6ieffKKWlpaql19+eerz5uZmNTc3V73iiivU9evXqy+88IJqNpv/f3v3GhPF2cUB/L8giyDCglwWlLuIooCAlaxt0cgGJL3Q+gGkBsVaqSipRFFik6bWVMWaopZW6ociVE3Vpq0ktNXItVW3CBRUBKmsXGzDJUBXIWhB9rwffJkwcrOKsNs9v4RkeeaZmefs2Z3nMLPD0tGjRyc9Ro1GQ0qlkk6fPk03b94klUpFixcvpqCgINE2XF1daffu3aK8Dn7fTmaMY+Vw7dq1tGLFCtHYOzs7RX10OYdjxTc4rubmZsrMzCSJREJqtVroo8v5e5J5YTyOnbdv3yZzc3PaunUrVVdXU3p6OhkbG9O5c+eeOQYugCbI4sWLafPmzcLv/f395OTkRPv27ZvEUT2dtrY2AkDFxcVC29KlS2nLli0jrvPTTz+RkZERtbS0CG0ZGRlkaWlJ//zzz/Mc7pg+/PBD8vf3H3aZRqMhExMT+vbbb4W2mpoaAkAqlYqIdDu2kWzZsoU8PT1Jq9USkX7n7/HJRavVklwupwMHDghtGo2GTE1N6ZtvviEiourqagJApaWlQp+ff/6ZJBIJ/fXXX0REdOTIEbK2thbFl5KSQt7e3s85oqGGm0Afd+XKFQJAjY2NQpurqysdPHhwxHV0JcaRCqDIyMgR19GnHD5J/iIjI2n58uWiNn3JH9HQeWG8jp07duyg+fPni/YVHR1N4eHhzzxmvgQ2AXp7e1FeXg6lUim0GRkZQalUQqVSTeLIns7du3cBADY2NqL2kydPwtbWFgsWLMDOnTvR09MjLFOpVPD19YWDg4PQFh4ejnv37uHGjRsTM/BR3Lp1C05OTvDw8MDq1avR1NQEACgvL0dfX58od3PnzoWLi4uQO12P7XG9vb04ceIE3n77bdGX/epz/garr69HS0uLKGdWVlYIDg4W5Uwmk2HRokVCH6VSCSMjI5SUlAh9QkJCIJVKhT7h4eGora3F33//PUHRPLm7d+9CIpFAJpOJ2lNTUzFjxgwEBATgwIEDossLuh5jUVER7O3t4e3tjYSEBHR0dAjL/ks5bG1txY8//oj169cPWaYv+Xt8XhivY6dKpRJtY6DPeMyd/GWoE6C9vR39/f2iJAOAg4MDbt68OUmjejparRZJSUl48cUXsWDBAqH9rbfegqurK5ycnHDt2jWkpKSgtrYW33//PQCgpaVl2PgHlk2m4OBgZGVlwdvbG83Nzfjoo4/w8ssvo6qqCi0tLZBKpUMmFQcHB2HcuhzbcM6ePQuNRoO4uDihTZ/z97iB8Qw33sE5s7e3Fy2fMmUKbGxsRH3c3d2HbGNgmbW19XMZ/9N48OABUlJSEBMTI/piyffeew+BgYGwsbHB5cuXsXPnTjQ3NyMtLQ2Abse4YsUKrFy5Eu7u7lCr1Xj//fcREREBlUoFY2Pj/1QOs7OzMX36dKxcuVLUri/5G25eGK9j50h97t27h/v378PMzOypx80FEPtXNm/ejKqqKly8eFHUHh8fLzz29fWFo6MjQkNDoVar4enpOdHD/FciIiKEx35+fggODoarqyvOnDnzTG8uXfXVV18hIiICTk5OQps+58/Q9fX1ISoqCkSEjIwM0bKtW7cKj/38/CCVSvHuu+9i3759Ov81C6tWrRIe+/r6ws/PD56enigqKkJoaOgkjmz8ZWZmYvXq1Zg6daqoXV/yN9K8oOv4EtgEsLW1hbGx8ZBPv7e2tkIul0/SqP69xMRE5ObmorCwELNmzRq1b3BwMACgrq4OACCXy4eNf2CZLpHJZJgzZw7q6uogl8vR29sLjUYj6jM4d/oUW2NjI/Ly8vDOO++M2k+f8zcwntHeb3K5HG1tbaLlDx8+RGdnp17ldaD4aWxsxIULF0Rnf4YTHByMhw8foqGhAYB+xDjAw8MDtra2otfkfyGHv/76K2pra8d8TwK6mb+R5oXxOnaO1MfS0vKZ/0DlAmgCSKVSBAUFIT8/X2jTarXIz8+HQqGYxJE9GSJCYmIifvjhBxQUFAw55TqcyspKAICjoyMAQKFQ4Pr166ID1sAB28fH57mM+2l1d3dDrVbD0dERQUFBMDExEeWutrYWTU1NQu70KbZjx47B3t4er7zyyqj99Dl/7u7ukMvlopzdu3cPJSUlopxpNBqUl5cLfQoKCqDVaoXiT6FQ4JdffkFfX5/Q58KFC/D29taJSycDxc+tW7eQl5eHGTNmjLlOZWUljIyMhEtHuh7jYH/++Sc6OjpEr0l9zyHw6IxsUFAQ/P39x+yrS/kba14Yr2OnQqEQbWOgz7jMnc/8MWr2RE6dOkWmpqaUlZVF1dXVFB8fTzKZTPTpd12VkJBAVlZWVFRUJLods6enh4iI6urqaPfu3VRWVkb19fWUk5NDHh4eFBISImxj4HbHsLAwqqyspHPnzpGdnZ1O3Cq+bds2Kioqovr6erp06RIplUqytbWltrY2Inp0K6eLiwsVFBRQWVkZKRQKUigUwvq6HNtg/f395OLiQikpKaJ2fcxfV1cXVVRUUEVFBQGgtLQ0qqioEO6ASk1NJZlMRjk5OXTt2jWKjIwc9jb4gIAAKikpoYsXL5KXl5foFmqNRkMODg4UGxtLVVVVdOrUKTI3N5+w2+BHi7G3t5def/11mjVrFlVWVorelwN3z1y+fJkOHjxIlZWVpFar6cSJE2RnZ0dr1qzRiRhHi6+rq4uSk5NJpVJRfX095eXlUWBgIHl5edGDBw+EbehyDsd6jRI9uo3d3NycMjIyhqyv6/kba14gGp9j58Bt8Nu3b6eamhr64osv+DZ4fZSenk4uLi4klUpp8eLF9Ntvv032kJ4IgGF/jh07RkRETU1NFBISQjY2NmRqakqzZ8+m7du3i/6PDBFRQ0MDRUREkJmZGdna2tK2bduor69vEiISi46OJkdHR5JKpTRz5kyKjo6muro6Yfn9+/dp06ZNZG1tTebm5vTmm29Sc3OzaBu6Gttg58+fJwBUW1sratfH/BUWFg77mly7di0RPboV/oMPPiAHBwcyNTWl0NDQIXF3dHRQTEwMWVhYkKWlJa1bt466urpEfa5evUovvfQSmZqa0syZMyk1NXWiQhw1xvr6+hHflwP/26m8vJyCg4PJysqKpk6dSvPmzaO9e/eKCojJjHG0+Hp6eigsLIzs7OzIxMSEXF1dacOGDUP+YNTlHI71GiUiOnr0KJmZmZFGoxmyvq7nb6x5gWj8jp2FhYW0cOFCkkql5OHhIdrHs5D8PxDGGGOMMYPBnwFijDHGmMHhAogxxhhjBocLIMYYY4wZHC6AGGOMMWZwuABijDHGmMHhAogxxhhjBocLIMYYY4wZHC6AGGOMMWZwuABijLFhuLm54dChQ5M9DMbYc8IFEGNs0sXFxeGNN94AACxbtgxJSUkTtu+srCzIZLIh7aWlpYiPj5+wcTDGJtaUyR4AY4w9D729vZBKpU+9vp2d3TiOhjGma/gMEGNMZ8TFxaG4uBiHDx+GRCKBRCJBQ0MDAKCqqgoRERGwsLCAg4MDYmNj0d7eLqy7bNkyJCYmIikpCba2tggPDwcApKWlwdfXF9OmTYOzszM2bdqE7u5uAEBRURHWrVuHu3fvCvvbtWsXgKGXwJqamhAZGQkLCwtYWloiKioKra2twvJdu3Zh4cKFOH78ONzc3GBlZYVVq1ahq6vr+T5pjLGnwgUQY0xnHD58GAqFAhs2bEBzczOam5vh7OwMjUaD5cuXIyAgAGVlZTh37hxaW1sRFRUlWj87OxtSqRSXLl3Cl19+CQAwMjLCZ599hhs3biA7OxsFBQXYsWMHAGDJkiU4dOgQLC0thf0lJycPGZdWq0VkZCQ6OztRXFyMCxcu4Pbt24iOjhb1U6vVOHv2LHJzc5Gbm4vi4mKkpqY+p2eLMfYs+BIYY0xnWFlZQSqVwtzcHHK5XGj//PPPERAQgL179wptmZmZcHZ2xh9//IE5c+YAALy8vPDJJ5+Itjn480Rubm74+OOPsXHjRhw5cgRSqRRWVlaQSCSi/T0uPz8f169fR319PZydnQEAX3/9NebPn4/S0lK88MILAB4VSllZWZg+fToAIDY2Fvn5+dizZ8+zPTGMsXHHZ4AYYzrv6tWrKCwshIWFhfAzd+5cAI/OugwICgoasm5eXh5CQ0Mxc+ZMTJ8+HbGxsejo6EBPT88T77+mpgbOzs5C8QMAPj4+kMlkqKmpEdrc3NyE4gcAHB0d0dbW9q9iZYxNDD4DxBjTed3d3Xjttdewf//+IcscHR2Fx9OmTRMta2howKuvvoqEhATs2bMHNjY2uHjxItavX4/e3l6Ym5uP6zhNTExEv0skEmi12nHdB2NsfHABxBjTKVKpFP39/aK2wMBAfPfdd3Bzc8OUKU9+2CovL4dWq8Wnn34KI6NHJ7zPnDkz5v4eN2/ePNy5cwd37twRzgJVV1dDo9HAx8fnicfDGNMdfAmMMaZT3NzcUFJSgoaGBrS3t0Or1WLz5s3o7OxETEwMSktLoVarcf78eaxbt27U4mX27Nno6+tDeno6bt++jePHjwsfjh68v+7ubuTn56O9vX3YS2NKpRK+vr5YvXo1fv/9d1y5cgVr1qzB0qVLsWjRonF/Dhhjzx8XQIwxnZKcnAxjY2P4+PjAzs4OTU1NcHJywqVLl9Df34+wsDD4+voiKSkJMplMOLMzHH9/f6SlpWH//v1YsGABTp48iX379on6LFmyBBs3bkR0dDTs7OyGfIgaeHQpKycnB9bW1ggJCYFSqYSHhwdOnz497vEzxiaGhIhosgfBGGOMMTaR+AwQY4wxxgwOF0CMMcYYMzhcADHGGGPM4HABxBhjjDGDwwUQY4wxxgwOF0CMMcYYMzhcADHGGGPM4HABxBhjjDGDwwUQY4wxxgwOF0CMMcYYMzhcADHGGGPM4PwP1iIdAmDSOCwAAAAASUVORK5CYII=" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "backend = type(K).__name__\n", "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(K.vvag(QAOAansatz_iso, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "QAOA_vvag = K.jit(K.vvag(QAOAansatz_iso, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3))\n", "\n", "params_iso = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", - "if backend == 'JaxBackend':\n", + "if type(K).__name__ == 'JaxBackend':\n", " opt = K.optimizer(optax.adam(1e-2))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", @@ -570,7 +565,7 @@ { "cell_type": "markdown", "source": [ - "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we can also use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." + "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we directly use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." ], "metadata": { "collapsed": false @@ -578,63 +573,43 @@ }, { "cell_type": "code", - "execution_count": 187, + "execution_count": 13, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Circuit #0\n", - "measurement prob: 0.018767010420560837\n", - "output: 111000100101\n", - "cost: 0.04574383422732353\n", - "max prob: 0.04061311483383179\n", + "cost: 0.042537812143564224\n", + "max prob: 0.047906018793582916\n", "bit strings: ['000000111111']\n", "\n", "Circuit #1\n", - "measurement prob: 0.01276576891541481\n", - "output: 111001011000\n", - "cost: 0.04524344578385353\n", - "max prob: 0.04112391918897629\n", - "bit strings: ['111111000000']\n", + "cost: 0.033970173448324203\n", + "max prob: 0.054868899285793304\n", + "bit strings: ['000000111111']\n", "\n", "Circuit #2\n", - "measurement prob: 0.0424429252743721\n", - "output: 000111011110\n", - "cost: 0.03893017768859863\n", - "max prob: 0.048920851200819016\n", - "bit strings: ['000000111111']\n", + "cost: 0.033648744225502014\n", + "max prob: 0.055139534175395966\n", + "bit strings: ['111111000000']\n", "\n", "Circuit #3\n", - "measurement prob: 0.0024669470731168985\n", - "output: 011101011100\n", - "cost: 0.03952330723404884\n", - "max prob: 0.04860881343483925\n", - "bit strings: ['000000111111']\n", + "cost: 0.03602508455514908\n", + "max prob: 0.05475332960486412\n", + "bit strings: ['111111000000']\n", "\n", "Circuit #4\n", - "measurement prob: 0.018215017393231392\n", - "output: 000111000101\n", - "cost: 0.045170776546001434\n", - "max prob: 0.04154610633850098\n", + "cost: 0.03601868823170662\n", + "max prob: 0.05406792089343071\n", "bit strings: ['111111000000']\n", "\n", "Circuit #5\n", - "measurement prob: 0.03104996867477894\n", - "output: 111000011000\n", - "cost: 0.041469376534223557\n", - "max prob: 0.04604189097881317\n", - "bit strings: ['111111000000']\n", + "cost: 0.03338256850838661\n", + "max prob: 0.05537496879696846\n", + "bit strings: ['000000111111']\n", "\n" ] - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -644,11 +619,6 @@ " c = QAOAansatz_iso(params=params_iso[num_circuit], g=iso_graph, return_circuit=True)\n", " loss = QAOAansatz_iso(params=params_iso[num_circuit], g=iso_graph)\n", "\n", - " # measurement output\n", - " m_out, m_prob = c.sample()\n", - " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", - " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", - "\n", " # find the states with max probabilities\n", " probs = K.numpy(c.probability())\n", " max_prob = max(probs)\n", @@ -656,26 +626,20 @@ " states = []\n", " for i in index:\n", " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", - "\n", - "# plot NetworkX graph\n", - "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", - "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", - "ax = plt.gca()\n", - "ax.set_facecolor('w')" + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:26:06.999371800Z", - "start_time": "2023-06-30T07:25:37.198477Z" + "end_time": "2023-07-03T12:07:03.904854400Z", + "start_time": "2023-07-03T12:06:31.721659700Z" } } }, { "cell_type": "markdown", "source": [ - "On average, QAOA with isotropic quantum dropout improves the probability of correct solution (max prob) by nearly 0.01 compared to regular QAOA.\n", + "On average, QAOA with isotropic quantum dropout improves the probability of correct solution (max prob) by nearly 0.015 compared to regular QAOA.\n", "\n", "It should be noted that isotropic quantum dropout will lead to more ground state degeneracy, so it does not necessarily lead to better results than conventional QAOA. However, it has a high upper limit, which means that it is possible to get much better results, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more analysis and details." ], @@ -703,7 +667,7 @@ }, { "cell_type": "code", - "execution_count": 188, + "execution_count": 21, "outputs": [], "source": [ "def graph_weights(graph):\n", @@ -715,19 +679,26 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:26:07.002622300Z", - "start_time": "2023-06-30T07:26:06.999371800Z" + "end_time": "2023-07-03T13:23:26.871885Z", + "start_time": "2023-07-03T13:23:26.858216600Z" } } }, { "cell_type": "code", - "execution_count": 189, + "execution_count": 22, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Here is the graph of the H_C of the last driving layer:\n" + ] + }, { "data": { "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVxU3fPHPxt0g1ISJoqIgNjd3Y2NhajYPna3YjyIgdiFgY3dYmGCYhAqJYLSXbvz+8Mf+5WH2oVdQD3v12tfuveeM2fuLnvP3DkzczhERGAwGAwGg/HXwi1vBRgMBoPBYJQvzBhgMBgMBuMvhxkDDAaDwWD85TBjgMFgMBiMvxxmDDAYDAaD8ZfDjAEGg8FgMP5ymDHAYDAYDMZfDl+cRkKhEJGRkVBTUwOHw5G1TgwGg8FgMKQAESE5ORmGhobgcgt//hfLGIiMjISxsbHUlGMwGAwGg1F2hIeHw8jIqNDzYhkDampqImHq6urS0YzBYDAYDIZMSUpKgrGxsWgeLwyxjIHcpQF1dXVmDDAYDAaD8ZtR3BI/CyBkMBgMBuMvhxkDDAaDwWD85TBjgMFgMBiMvxxmDDAYDAaD8ZfDjAEGg8FgMP5ymDHAYDAYDMZfDjMGGAwGg8H4y2HGAIPBYDAYfznMGGAwGAwG4y+HGQMMBoPBYPzlMGOAwWAwGIy/HGYMMBgMBoPxl8OMAQaDwWAw/nKYMcBgMBgMxl8OMwYYDAaDwfjLYcYAg8FgMBh/OfzyVoDBYPxZpGbmICQ2FVk5QsjzuaiqowIVBXarYTAqMuwXymAwSk1QdDKO+YThbsB3hMWlgX45xwFgoq2MdrV1MbyJCWrpqZWXmgwGoxA4RETFNUpKSoKGhgYSExOhrq5eFnoxGIzfgPC4NCw89xbewTHgcTkQCAu/neSeb1WzEtb2s4SxtnIZaspg/J2IO3+zmAEGg1EiTjwPQ8et9/H4cywAFGkI/Hr+8edYdNx6Hyeeh8lcRwaDIR5smYDBYEiM690gON8ILFFfgZAgEBLmn32LmJRMTG1XS8raMRgMSWGeAQaDIREnnoeV2BD4L843AnGSeQgYjHKHeQYYDIbYhMelYdnFd4WeF2alI8nnLDIjA5D1LRDCjBTodJ8B1fodC+2z9OI7NK9RicUQMBjlCPMMMBgMsVl47i1yiogNEKYlIfGRB7JjwyGnW00smTlCwsJzb6WlIoPBKAHMM8BgMMQiKDoZ3sExRbbhqWrDaOoR8FS1kPktCFGHZhYrVyAkeAfHIPh7MmrqsrRDBqM8YJ4BBoMhFsd8wsDjcopsw+HLgaeqJbFsHpeDo09Z7ACDUV4wY4DBYIjF3YDvxaYPlhSBkHA38LtMZDMYjOJhxgCDwSiWlMwchMWlyXSMsNg0pGbmyHQMBoNRMMwYYDAYxRIamwrZ+AT+BwEIiU2V8SgMBqMgmDHAYDCKJStH+EeNw2Aw8sKMAQaDUSzy/LK5VZTVOAwGIy/sl8dgMIqlqo4Kis4jKD2c/x+HwWCUPcwYYDAYxaKiwIeJjCsEmugoQ0WBlT5hMMoD9stjMBjFkpOTA2NeEkKJC3CKfoZIenkJwoxUCFLiAADpwc+Qk/yzWJG6bS9wFfM//fO4HLQz05W+4gwGQyyYMcBgMAolLi4O7u7u2LFjB6LSAMMJu4rtk+RzDoKk/9UMSAt8DAQ+BgCoWrQr0BgQCAkjmppIT3EGgyERzBhgMBj58Pf3h4uLC44ePQqhUIhhw4bByckJW15l4fHn2CKLDxlN3i/RWDwuB82r67BSxAxGOcJiBhgMBgBAIBDg4sWL6NChAywtLXH58mUsWrQI4eHh2L9/P2xsbLC2nyX4xZQklgQiAoeEWNvPUmoyGQyG5DBjgMH4y0lMTMTWrVthZmaGPn36IC0tDR4eHggJCcGiRYtQuXJlUVtjbWWs6G0htbE5HA6iL7tg6ewpSEuTbYVDBoNROMwYYDD+UgICAjB16lRUqVIF8+bNQ7NmzeDj44MnT55g6NChkJOTK7Bf99qaUAy8CeDnk31pmNu5NnbNHYVTp06hadOmCAgIKJU8BoNRMpgxwGD8RQiFQly7dg3dunVDnTp1cPr0acyePRuhoaE4evQoGjduXGT/7OxsDBw4EFG3D8Ii1ReUkwUIBRIqIQAE2VjdyxxT2tXEiBEj8OzZM2RnZ6Nhw4Y4depUKa6QwWCUBGYMMBh/AcnJydixYwfq1q2Lbt264fv37zh06BDCwsKwYsUKGBgYFCuDiDBx4kTcu3cPGzduxLUdS/Ft3xRYGSgBQLHbG9P/Gw3Whsr4cXAaXnm6is5ZWFjg+fPn6N27N4YMGQInJydkZmaW4ooZDIYkMGOAwfiD+fz5M2bNmgUjIyNMnz4dVlZWePjwIV68eIFRo0ZBQUFBbFkrVqzAwYMH4e7ujn///RcAMMGuHy7M6ISbM1pjZBNTmOoo56tUyAFgqq0EwYe7aJ/+COend8TqBTOxdetW3Lp1S9ROVVUVR48exa5du7Bnzx60atUKoaGhUvgUGAxGsZAYJCYmEgBKTEwUpzmDwShHhEIh3bp1i3r37k0cDod0dHRowYIFFBYWVmKZ+/fvJwC0du1aWr58OXE4HNLS0qL4+Ph8bVMysmnGcmfSt2hK/l8TKCUjm4iI5s2bR5qampSWlkYCgYA6dOhAVapUodjY2Hwynj9/TlWrViUtLS3y8vIqsd4Mxt+OuPM3MwYYjD+E1NRUcnNzIwsLCwJAlpaWtHfvXkpLSyuV3OvXrxOfzycHBwd6/fo1cblcAkAHDhwotM/69etJR0cnz7Hg4GACQAcPHiQiovDwcNLU1KQhQ4aQUCjMJyMuLo569+5NAGjBggWUnZ1dqutgMP5GmDHAYPwlhIaG0j///ENaWlrE4XCob9++dOfOnQInWEl5/fo1qaqqUo8ePSgtLY2srKxIQUGBmjVrRgKBoNB+zs7OpK6unu94p06dqFmzZqL3J06cIAB09OjRAuUIhULauHEj8Xg8atOmDUVGRpb6mhiMvwlmDDAYfzBCoZAePHhAAwYMIC6XSxoaGjR79mz6/Pmz1MYIDQ0lAwMDsrW1peTkZFq5ciVxOBzicrn0+vXrIvtu27aNlJWV8x339PQkAPTmzRvRseHDh5O6ujqFhIQUKu/BgwdkYGBAenp6dPfu3ZJeEoPx1yHu/M0CCBmM34iMjAwcPHgQtra2aN26Nfz9/bF9+3ZERETA2dkZ1apVk8o4CQkJ6N69OxQUFODl5YXPnz9j5cqVkJOTw+TJk2FtbV1kfzk5OeTk5OQ73rt3b+jp6cHNzU10zNXVFRoaGhg9ejQEgoLTFFu1agVfX1/Uq1cPHTp0wNq1ayEUCkt1jQwG438wY4DB+A2IjIzEkiVLYGJiAnt7exgYGODatWt4//49Jk+eDFVVVamNlZmZif79+yMyMhJXr16Fjo4O7O3toaKiAg0NDaxatapYGXw+H9nZ2fmOy8nJYezYsThy5Iio4qCmpiYOHz6MBw8eYMuWLYXK1NXVxfXr17Fo0SIsXrwYvXr1QmxsbMkvlMFg/A9puhkYDIZ0efr0KdnZ2RGfzydVVVVycnKigIAAmY0nFApp+PDhpKCgQA8ePCAiotWrV4uCBnOD/4ojN/ugoLiCz58/E4fDof379+c5PnfuXJKTkyNfX99i5V+9epV0dHTIxMSEnj59KpZODMbfCIsZYDB+UzIzM+nYsWPUuHFjAkA1atSgbdu2UUJCgszHXrhwIQGgkydPEhHR27dvic/nU6VKlah58+ZFBg3+yuHDhwkAZWRkFHi+S5cu1KRJkzzHMjIyyMrKiiwsLCg9Pb3YMcLCwqhZs2YkJydHLi4uUgmYZDD+NJgxwGD8ZkRHR9PKlSvJwMCAAFDHjh3p0qVLlJOTUybju7m5EQBydnYmIqLs7GyytbUlPT09sYIGf8XDw4MAUEpKSoHnz549SwDyeQHevn1LCgoKNGPGDLHGyczMpJkzZxIAGjRoELtHMRj/gRkDDMZvwsuXL2n06NEkLy9PSkpK5ODgQO/evStTHby8vIjL5ZKTk5PoCXvt2rXE4XBIWVmZnJycJJJ3+vRpAlBgUSIioqysLDIwMCBHR8d857Zu3UoA6ObNm2KP5+npSerq6lSrVi3y8/OTSFcG40+GGQMMRgUmOzubTp06RS1btiQAZGJiQhs3biywGp+sef78OSkrK1Pfvn1FXgh/f3+Sl5enunXrkq6ubqGTemGcP3+eANCPHz8KbbN48WJSU1Oj5OTkPMdzqxMaGhpK9HkEBQWRlZUVKSoq5otHYDD+VlhqIYNRAYmNjcWGDRtQvXp1DB48GDweD2fOnMGnT58wd+5caGtrl6k+X758QY8ePVC/fn0cO3YMPB4POTk5sLe3h76+Pt6/f4+NGzdCU1NTIrl8Ph8ACswoyGX8+PFISUnByZMn8xzncrk4ePAg0tLS4OjoKPY2yTVr1sSTJ08wYsQIjB07FmPHjhVlLDAYjGKQpmXBYDAK5s2bNzRhwgRSUlIiBQUFGjt2rERr8LIgNjaWateuTTVq1KDv37+Ljq9fv544HA5VrVqVWrRoIXbQ4K9cv36dABS7H0K3bt2oUaNGBZ47efIkAaAjR45IPP7BgwdJSUmJ6tevT4GBgRL3ZzD+FNgyAYNRzuTk5ND58+epffv2BIAMDQ1pzZo1eSbe8iI9PZ1atmxJlSpVyjNZvnv3juTl5alt27bE5XLFSvMriNu3bxMA+vTpU5HtcpcTXr16VeD5ESNGFFudsDDevHlDtWvXJjU1NTp9+rTE/RmMPwG2TMBglBMJCQnYsmULatWqhb59+yI9PR0nTpxASEgIFi5ciMqVK5erfkKhEKNHj8aLFy9w6dIl1KpVCwBEywPGxsZ48eIFpkyZAisrqxKNkbtMUFAVwl/p0aMHqlSpkqci4a+4urpCU1MTo0aNKrQ6YWFYWlri+fPn6N69OwYNGoTp06cjKytLIhkMxl+DNC0LBuNv5sOHDzR58mRSUVEhOTk5GjFiBD179qy81crHnDlziMPh0NmzZ/Mc37hxI3E4HOrYsWOJggZ/5fHjxwRArKyIpUuXkqqqKiUlJRV4/t69e8ThcGjDhg0l0kUoFJKrqyvJyclRkyZNKDQ0tERyGIzfEbZMwGCUAQKBgK5cuUJdunQhAKSrq0vLli2jb9++lbdqBbJ9+3YCQC4uLnmOf/jwgRQUFGjQoEEEgA4dOlSqcZ49e1ZgHYGCCAsLIy6XS25uboW2+eeff0hOTq5UcRY+Pj5kampK2tradOXKlRLLYTB+J5gxwGDIkKSkJNq+fTuZmZkRALK1taXDhw8XWnGvInDu3DnicDg0a9asPMdzcnKoadOmVKtWLapTpw61aNGi1NX8Xr9+TQDoxYsXYrXv2bMn2draFno+tzph3bp1KS0trcR6xcbGUo8ePQgALVy4kLKzs0ssi8H4HWDGAIMhA4KDg2nGjBmkrq5OPB6PBg8eTI8eParwpXCfPHlCioqKNGjQoHzZAc7OzsThcGjy5MmlChr8lbdv3xIAevLkiVjtL168WKzx4O/vTwoKCjR9+vRS6SYQCGjdunXE5XKpXbt2FdaLw2BIA2YMMBhSQigU0q1bt6hXr17E4XBIR0eHFixYUGzaXEUhKCiIKlWqRC1atMhX8//jx4+kqKhIEyZMIBUVFZo2bZpUxvz48SMBIG9vb7HaZ2dnk5GREU2YMKHIdtu2bSMAdOPGjVLreO/ePdLX1yd9fX26d+9eqeUxGBURlk3AYJSStLQ07NmzB5aWlujYsSNCQkLg7u6O8PBwrF27FsbGxuWtYrH8+PED3bp1g46ODi5cuABFRUXROYFAgLFjx8LIyAjx8fFQUVHBihUrpDKuOEWH/tt+/PjxOH78OJKSkgpt5+TkhI4dO2LMmDGIi4srlY5t2rTB69evYW5ujvbt22P9+vUQCoWlkslg/LZI07JgMP4EQkJC6J9//iEtLS3icrnUt29funv3boVfCvgvqamp1LRpU9LV1aXPnz/nO79lyxbicDiivQBKGzT4K6GhoRI/wYeHhxOXy6Vdu3YV2S4iIoK0tLRo0KBBUvlOcnJyaNGiRQSAevbsWS4loRkMWcGWCRgMCRAKhXT//n0aMGAAcblc0tDQoNmzZxc4if4O5OTkUL9+/UhZWZmeP3+e73xgYCApKirS1KlTydzcnFq2bClVY+fr168EgC5fvixRv969e5O1tXWxuuRWJzx8+HBp1MzD5cuXSVtbm0xNTStkSiiDURLYMgGDIQYZGRk4cOAAGjRogDZt2uDdu3dwdXVFREQEnJ2dUa1atfJWUWKICLNmzcKFCxdw8uRJNGzYMM95gUAAe3t7VKlSBQYGBggICICrqys4HI7UdBC36NB/cXBwgK+vL168eFFku8GDB2PkyJGYOnUqQkNDS6znr3Tv3h2vX7+Gvr4+WrRoAVdXV7H3RWAwfnukaVkwGL8LX79+pUWLFlGlSpUIAPXo0YOuX7/+2y0FFMTmzZsJQKHu9twgvNOnT0s1aPBX4uLiCACdOXNGon45OTlkYmJC48aNK7ZtQkICmZqaUuvWrUW7LUqDzMxMmjZtGgGgIUOGFFoMicH4HWDLBAxGATx58oSGDh1KfD6f1NTUaNq0aX/URjanTp0iADR//vwCzwcFBZGSkhI5OTnRkCFDSE9Pr1SVBgsjKSmJANCJEyck7rty5UpSVlamhISEYtvev3+fOBwOrV+/viRqFsmpU6dITU2NateuTW/fvpW6fAajLGDGAIPx/2RmZtLRo0epcePGBIBq1qxJ//777x/39+zt7U0KCgo0bNiwAncaFAgE1KpVK6pevTpdunRJ6kGDv5Kenk4A6OjRoxL3/fr1K/F4PNqxY4dY7XOrExa22VFpCAgIoPr165OSkhIdPHhQ6vIZDFnDjAHGX09UVBStWLGC9PX1CQB16tSJvLy8SrQlb0Xn48ePpK2tTW3bti20CqKLi4sowl8WQYO/kp2dTQDowIEDJerft29fql+/vlj6ZWRkkLW1damrExZGamoq2dvbEwAaN26cTMZgMGQFMwYYfy0vX76kUaNGkby8PCkrK9OkSZPE2jDndyUqKoqqVatGdevWLdTlHxwcTMrKyjRlyhTauHEj8Xg88vPzk5lOQqGQAJC7u3uJ+l+9elWiCoa51QllEf+Qy/79+0lRUZGsrKz+qKUlxp8NMwYYfxXZ2dl06tQpatGiBQEgU1NT2rRpE8XFxZW3ajIlJSWFGjZsSAYGBoXuxicQCKht27ZUtWpV+vjxI6moqJS6pK848Pl82rlzZ4n6CgQCMjU1pTFjxojdR5rVCQvDz8+PatWqRWpqauTp6SmzcRgMacGMAcZfQUxMDK1bt46MjIwIALVp04bOnj0r1ejyikp2djb17NmTVFVVi1wv37FjBwGg27dvi4IGxQnOKy1KSkr5dkeUhNWrV5OSkpLYAY4CgYA6depEhoaGMi0clJiYKNrdccaMGZSZmSmzsRiM0sKMAcYfzZs3b2j8+PGkqKhICgoKNHbsWKlssPO7IBQKadKkScTj8ejatWuFtvv8+TOpqKiQo6Mj3bp1S+qFeopCTU2NNm/eXOL+kZGRxOfzafv27WL3ya1OOHDgQJmmiQqFQnJxcSE5OTlq1qzZb7NPBePvgxkDjD+OnJwcOn/+PLVr144AUJUqVWjNmjX048eP8latzFm3bh0BoH379hXaRiAQULt27cjU1JRiYmKoTp06Mg0a/C9aWlq0YcOGUsno378/1atXTyKdc9MrZZUp8StPnz4lExMT0tHRoatXr8p8PAZDUpgxwPhjiI+Pp82bN1O1atUIADVv3pxOnDhBWVlZ5a1auXDs2DECQEuXLi2y3a5duwgA3bp1q0yCBv+Lrq4urVmzplQyrl+/TgDo0aNHEvUbOXIkqamp0ZcvX0o1vjjExMRQt27diMPh0JIlS/6KJSrG7wMzBhi/PR8+fKDJkyeTiooKycnJ0YgRI/76mvF3794lOTk5Gj16dJFPy1++fCFVVVVycHCg8PDwMgsa/BVDQ0Navnx5qWQIBAKqXr06jRo1SqJ+udUJW7VqVSaTs0AgoDVr1hCXy6UOHTpQVFSUzMdkMMSBGQOM3xKBQECXL1+mLl26EADS09OjZcuW0bdv38pbtXLH39+fNDQ0qGPHjkUGrQmFQurQoQOZmJhQYmIiDR48uMyCBn/F1NSUFi9eXGo569atI0VFRYkzQx48eEAcDofWrVtXah3E5c6dO6Snp0cGBgb04MGDMhuXwSgMZgwwfiuSkpLIxcWFatWqRQDI1taWDh8+XGgBnb+Nr1+/krGxMdWvX7/Y36Gbm5soxa6sgwZ/pUaNGjRv3rxSy/n27Rvx+Xz6999/Je47b948mVUnLIzIyEhq06YN8Xg82rBhwx+x3wXj94UZA4zfguDgYJo+fTqpqakRj8ejIUOG0KNHj9gN9BeSkpLI2tqajIyMKCIiosi2ISEhpKqqShMmTKDMzMwyDxr8lTp16tDs2bOlImvgwIFUt25dia8jMzOTrK2tydzcvEwrB2ZnZ9OCBQsIAPXu3fuPr3fBqLgwY4BRYREKhXTz5k3q2bMncTgc0tHRoYULF1J4eHh5q1bhyMrKoi5dupC6ujq9efOmyLZCoZA6depExsbGlJiYSBs2bCjzoMFfqVevntQqAt68eZMAkLe3t8R93717R4qKijKtTlgYly5dIi0tLapatSq9ePGizMdnMJgxwKhwpKSk0O7du6lu3boEgOrXr0/79u1jtd4LQSgU0tixY0lOTo5u3bpVbHt3d3cCQNeuXRMFDc6YMaMMNC0YGxsbmjx5slRkCQQCqlGjBo0YMaJE/f/9918CQNevX5eKPpLw5csXatSoEcnLy9POnTuZ14tRpjBjgFFhCAkJoblz55KWlhZxuVzq168f3bt3j90Ui2HFihVir/eHhoaSmpoajRs3joio3IIGf6VRo0Y0YcIEqcnbsGEDKSgoUExMjMR9c6sTGhgYlKh/acnIyKCpU6cSALKzs6Pk5OQy14Hxd8KMAUY+UjKyyf9rAr0KjSP/rwmUkpEts7GEQiHdv3+f+vfvT1wulzQ1NWnOnDllkvf9J3Dw4EECQKtXry62rVAopC5dupCRkRElJCSIXOpHjhwpA00Lp1mzZmRvby81edHR0SQnJ0dbtmwpUf+vX7+StrY2DRgwoNwM0RMnTpCqqirVqVOH/P39y0UHxt+FuPM3h4gIxZCUlAQNDQ0kJiZCXV29uOaMCkRQdDKO+YThbsB3hMWl4dcvmwPARFsZ7WrrYngTE9TSUyv1eBkZGfDw8MC///4LPz8/mJubY9q0aRg5ciRUVFRKLf9v4ObNm+jevTvGjBmDPXv2gMPhFNl+//79GDduHK5cuYIOHTqgfv360NXVxf3794vtK0vatGkDU1NTHD58WGoyhwwZgjdv3uD9+/clujZPT08MGjQIBw8exOjRo6WmlyQEBARg4MCB+Pz5M3bv3o2RI0eWix6MvwNx529uGerEKEPC49Iwcp8POm17gCM+oQj9jyEAAAQgNC4NR3xC0WnbA4zc54PwuLQSjff161csXrwYxsbGGDduHIyNjXHjxg28e/cOkyZNYoaAmPj5+WHAgAHo1KkTdu3aVeyEFxERgZkzZ8Le3h7dunXDtm3bEBwcjB07dpSrIQAAfD4f2dnZUpXp4OCAjx8/wtvbu0T9Bw4ciFGjRsHJyQlfvnyRqm7iUrt2bfj4+GDQoEEYNWoUHBwckJGRUS66MBi5MM/AH8iJ52FYdvEdcoQEgbDYr1cEj8sBn8vBit4WGNrIpNj2RISnT5/CxcUFnp6eUFJSgr29PZycnFCzZs3SXMJfSUREBJo2bQo9PT3cv38fqqqqRbYnIvTo0QN+fn549+4dkpOTYW5ujgkTJmDr1q1lpHXhdO3aFWpqajh9+rTUZBIRateujUaNGuHYsWMlkpGYmAgrKysYGxvj3r174PF4UtNPEogI+/fvx9SpU2Fubo7Tp0+jRo0a5aIL48+FeQb+UlzvBmH+2bfIzBFKZAgAgEBIyMwRYv7Zt3C9G1Rou6ysLBw7dgxNmjRB8+bN8eLFC2zevBkRERH4999/mSFQAhITE9GtWzfw+Xxcvny5WEMAAA4dOoSrV69iz5490NTUxOzZs6Gmpobly5fLXmExkIVngMPhYOLEifD09ERMTEyJZGhoaODIkSN49OgRNm3aJFX9JIHD4WDcuHF4+vQpkpOTYWtri3PnzpWbPoy/G2YM/EGceB4G5xuBYrVNfHwSoet7InLv5ALPO98IxMnnYXmORUdHY+XKlTA1NcWIESOgpaUFLy8vBAQEYNq0acxrVEKysrIwYMAARERE4OrVq9DX1y+2z9evXzFjxgyMHj0aPXr0wK1bt3D69Gls2rQJGhoaZaB18cjJySEnJ0fqcseMGQPgpzFUUlq1aoV58+ZhyZIlePXqlZQ0KxlWVlZ48eIFOnbsiP79+2P27NlSN6IYjOJgywR/COFxaei49T4yc4TFts1JikGkuwMADvgaujAcv7PAdgp8Lm7NbIPvXz7AxcUFJ06cAJ/Px+jRozF16lTUrVtXylfx90FEGD16NE6ePImbN2+idevWYvXp1asXXr16hXfv3kFFRaXCBA3+yqBBg5CUlITr169LXfawYcPw8uVLfPz4scTXm5WVhaZNmyIjIwMvX76EkpKSlLWUDCKCi4sL5syZg8aNG+PkyZMwMjIqV50Yvz9smeAvY+G5t8gRc1kg/u4+KBjWhrx+0e787BwBOi7ch4YNG+LBgwdYu3YtIiIisHPnTmYISImlS5fiyJEjOHTokFiGAAAcOXIEly9fhpubG7S0tLB169YKEzT4K7LyDAA/AwkDAwNx//79EsuQl5fH0aNH8eXLF8ybN0+K2pUMDoeD6dOn48GDBwgLC4ONjQ1u3LhR3mox/hKYMfAHEBSdDO/gGLFiBDLC/JH28RG0Okwstq0QHGRqVceu4+cQHByM2bNnQ0tLSxoqMwC4u7tj9erV2LBhA4YOHSpWn8jISEyfPh0jR45Er169EB4ejlWrVsHJyQmWlpYy1lgyZBEzkEvr1q1Ru3ZtuLm5lUpO3bp1sXHjRmzfvl0mHoyS0KxZM7x+/Rq2trbo2rUrli9fDoFAUN5qMf5wmDHwB3DMJww8bvFPhCQUIO7mbqhadYa8blWxZPO4HESp1Cq3iOs/latXr8LR0RGTJ0/G3LlzxepDRHBwcICioiK2bdsGABUuaPBX+Hy+zDwDuYGEZ86cwY8fP0ola8qUKejcuTPs7e0RGxsrJQ1LR6VKlXDlyhWsXLkSq1atQteuXfH9+/fyVovxB8OMgT+AuwHfxfIKpLy+ipykH9BsLX6RE4GQcDeQ3YSkycuXLzFo0CD06NEDLi4uYrv2jx07Bi8vL7i5uUFbWxs3b97E6dOn4ezsXGGCBn9FlssEADB69GhwuVwcPHiwVHK4XC4OHDiAzMxMODg4QIwwqjKBy+Vi8eLFuHnzJt68eQMbGxs8fPiwvNVi/KEwY+A3JyUzB2FiFAoSpCchwfsYNJsPAU9ZsokjLDYNqZmyu6n/TYSEhKBnz56wsLCAh4eH2B6Xb9++Ydq0aRg+fDh69+6NrKwsODk5oXXr1hg2bJiMtS4ZslwmAAAdHR0MHDgQe/bsgVBYfOBsURgaGsLNzQ1nzpyRasVEadC+fXu8fv0aNWrUQNu2beHs7FxhDBbGnwMzBn5zQmNT81UWLIiEB0fAVVKFWsNeEo9BAEJiUyXux8hLfHw8unfvDmVlZVy6dAnKyspi9SMiTJo0CfLy8vj3338BoMIGDf6KrD0DwM9AwuDgYNy9e7fUsgYOHIjRo0eXa3XCwjA0NMSdO3cwZ84czJ07F/369UNCQkJ5q8X4g2DGwG9OlhiphNlxX5Hiex1qtr0hSI5DTkI0chKiQYJskFCAnIRoCNKTSz0Oo3AyMzPRt29ffP/+HVevXoWurq7YfT08PHDx4kXs3r0bOjo6CA8Px8qVKzFt2jTUq1dPhlqXDll7BgCgZcuWMDc3L3UgYS4uLi7Q0dHByJEjK1zQHp/Px/r163HhwgXcv38fDRo0KPcaCYw/B2YM/ObI84v/CgXJsQAJEX/LDV93jxO9siIDkBP3FV93j0PiI48iZTx6cB9fvnxh7skSIBQKMXr0aDx79gwXL16EmZmZ2H2joqLg5OQEOzs79O3bFwAwa9YsqKurV8igwV8pC89AbiDhuXPnEB0dXWp56urqOHz4MJ48eYKNGzdKQUPp07t3b7x69Qra2tpo3rw53Nzc2O+SUWr45a0Ao3RU1VEBByhyqUCusikq91+U73jCgyMQZqVDu+NE8DUNCu1PRJg21g5O2RnQ0NCAlZUVbGxsYG1tDWtra9StWxfy8vKlv5g/lAULFuDUqVM4ffo0mjdvLnY/IoKjoyP4fD5cXFwA/NzR0NPTE0ePHq3wBcDKwjMAAKNGjcL8+fNx8OBBqdQLyK1OuHTpUnTp0gUNGjSQgpbSpVq1anj06BFmzZqFSZMmwdvbG7t37xarjDWDURCsAuEfQJtNdxFagt0Go47NhzA9qdAKhLkoC1Kxtrk85OTk4OfnB19fX/j6+iIo6Of+BXJycrCwsIC1tbXISLCysqqQEe5lzY4dOzB16lRs3boVM2bMkKjviRMnYGdnhzNnzqB///7IzMxE/fr1oa+vj3v37lXYWIFcVq5cCTc3N3z9+lXmY40aNQqPHj1CUFAQuNzSOzyzsrLQrFkzpKWl4eXLl2LHd5QHHh4emDBhAkxMTODp6ckKgjHywCoQ/kW0q60rVp2BksAhIVKCfNCvXz84OjoiPj4e8+fPR0BAAJKSkvDw4UNs3boVtra2ePv2LebOnYs2bdpAU1MTNWrUwIABA7Bq1Sp4eXkhIiLir3JnXrx4EdOmTcOMGTMkNgSio6MxdepUDBkyBP379wfwM2jw06dPFTpo8FfKyjMA/Awk/Pz5M27fvi0VebnVCUNCQipEdcKisLOzw4sXL8Dlcku1myPj74Z5Bv4AgqKT0WnbA5nJvzG9FaKD/ODh4YHTp08jJiYGtWvXxtChQ2FnZ4fatWuL2mZnZ+Pjx48i74Gvry9ev36N+Ph4AD/TwX71IFhbW6N27drg8/+sFatnz56hbdu26N69O06dOiXR0yoRYeDAgfD29sa7d+9QuXJlhIeHo06dOnBwcMCWLVtkqLn02LRpE9atW4e4uDiZj0VEsLS0RJ06deDp6Sk1ua6urnBycsLVq1fRtWtXqcmVBampqXB0dMSRI0fg4OCAbdu2QVFRsbzVYpQz4s7fzBj4Qxi5zwePP8dKvG1xUZAgB8opX+E1u4ton/Xs7Gzcvn0bHh4eOHfuHJKTk2FjYwM7OzsMGTIEJiYm+eUQITw8XGQY5BoJISEhAABFRUVYWlqKjAMbGxtYWlr+tuufnz59QrNmzVCrVi3cunVL4g1wTp06hSFDhuD06dMYOHAggJ+b/jx8+BABAQG/zW9w69atWLp0KZKTi85UkRbbt2/HrFmzEB4eLtbOj+JAROjWrRv8/Pzw9u1bVKpUSSpyZQURYe/evXBycoKFhQVOnz6N6tWrl7dajHKEGQN/GZLsWigWRBDmZCH19AKkfQ/D8uXLMWvWLMjJyYmapKen48qVK/Dw8ICXlxcyMzPRsmVLDB06FIMGDSo2fS4+Pl4Ug5BrJLx//x45OTngcDioVatWHg+CjY0N9PT0pHN9MiImJkYUJPj48WOJJ4/v37/DwsIC7dq1w6lTpwD8DBrs3Lkzjh07VmELDBXE9u3b8c8//yA9Pb1MxouPj4ehoSGWLl2KBQsWSE1uZGQkLC0t0bZtW3h6ev4WSzSvX7/GoEGDEBMTg0OHDqFPnz7lrRKjnGDGwF/IiedhmH/2rdTkNRQG4MzG2ahevTpCQkJgaWmJvXv3omHDhvnaJiUl4cKFC/Dw8BDttNahQwfY2dmhX79+YgcTZmZm4v3793k8CL6+vqKnS319/XzLDDVr1pRK0FhpSU9PR4cOHRAcHIwnT56IvCmSMHjwYNy9exfv3r2Drq6uKGjQwMAAd+/e/S0molx2794NJyenMosbAIAxY8bgwYMHCA4OlurfxJkzZzBw4EAcOHAAY8aMkZpcWZKYmAh7e3ucO3cOc+bMwdq1a/MY84y/A2YM/KVsuf4eLve+AERAKSaOuZ1rY0q7mvDy8sKoUaOgoKAAdXV1BAcHY/r06Vi1ahVUVFQK7BsTEwNPT094eHjA29sb8vLy6N69O+zs7NCzZ0+J3eZCoRBfvnzJt8yQG6WuoqICKyurPB6EevXqlel6qUAgwODBg3H16lXcu3cPjRs3lljG6dOnMXjwYJw4cQJDhgwBAKxfvx6LFy+Gr69vhS4wVBB79+7FhAkTIBQKy8yIefLkCZo3b45r166hS5cuUpVtb28PT09P+Pn5/TaudyLC1q1bMW/ePDRt2hQnTpxAlSpVylstRhnCjIG/lAkTJuCM7zdU6jIZAoJEMQQ8Lgd8Lgcre1tgSKP/rf2HhoZiyJAhePnyJbp164abN29CX18fu3fvLvaGGxERgZMnT8LDwwMvX76Eqqoq+vTpAzs7O3Tu3LlUTyo/fvzIF6gYEBAAoVAIHo+HOnXq5PEgWFtbQ0dHp8TjFcXMmTPh4uKCc+fOoXfv3hL3//HjBywsLNCqVSuRKzosLAzm5uaYNGkSNm/eLAOtZcuhQ4cwZswYZGdnl1mAKBHBysoKNWvWxNmzZ6UqOykpCVZWVqhSpQru37//W+3k+fjxYwwePBhZWVk4fvw4OnbsWN4qMcoIsedvEoPExEQCQImJieI0Z5QTx44dIwC0b98+CotNpRF7n5LpfC+qvvAymc73KvSVe37E3qcUFptaoOzMzEyaMWMGAaDOnTtTmzZtCAANHz6cvn//LpZ+gYGBtHLlSjI3NycApK2tTRMnTqS7d++SQCCQymeQmppKPj4+tHv3bpo0aRI1bdqUlJWVCT/rMpGxsTH16tWLlixZQmfPnqXPnz+TUCgs1Zhbt24lALRjx44SyxgyZAhpa2tTVFSU6NiAAQPIwMDgt/3dHT16lABQWlpamY7r6upKPB6Pvn79KnXZ3t7exOVyac2aNVKXLWu+f/9OnTt3Jg6HQ8uXL6ecnJzyVolRBog7fzNj4A8hICCAVFVVacSIEXkmt8CoJFp2wZ9arL9JJvMu5TUE5l2i1pvu0LIL/hQUnSTWOGfPniUNDQ2qVq0aLVu2jLS1tUlHR4cOHTok9qQqFArJ19eX5s2bR6ampgSADA0NaebMmfTs2bNST87/JScnhz58+EAeHh40b9486ty5M1WuXFlkIGhoaFCbNm1o+vTpdODAAfL19aXMzEyxZHt6ehKHw6F//vmnxPp5enoSADp+/Ljo2PXr1wkAHTt2rMRyy5uTJ08SAEpKEu9vS1okJCSQkpISrVq1SibyFy5cSHw+n168eCET+bIkJyeHVqxYQRwOhzp37iy2Ic/4fWHGwF9Eeno6WVlZUe3atSk5ObnANs+ePSOOnCJ53n5Kr0LjaNKC1WRcrWaJxvv06RPZ2tqSvLw8rVu3juzs7AgAderUiT59+iSRLKFQSI8ePaKpU6eSrq4uAaAaNWrQokWLyN/fv0T6iTtuZGQkXb58mdasWUODBg2iWrVqiQwEOTk5sra2pjFjxtC///5L9+/fp4SEhDwyHj16RAoKCjR06NASezZ+/PhBurq61LdvX5ERlJGRQWZmZtSmTRupG0ZlyZkzZwgAxcbGlvnY9vb2ZGpqKpOn38zMTGrQoAHVqVOHUlML9qRVdG7cuEGVK1emKlWq0KNHj8pbHYYMYcbAX8SkSZNIUVGR/Pz8Cm1z6tSpPDfmgwcPEoAS38wyMjJo6tSpBIAGDx5Mnp6eZGJiQkpKSrRx40bKzs6WWGZ2djbdvHmTxo4dSxoaGgSALC0tae3atfT58+cS6SkpSUlJ9PDhQ3J1daVx48aJjJ5cI6F69erUv39/mjZtGqmpqVGTJk0oPT29xOPZ2dmRlpYWffv2TXRs7dq1xOPxZGoMlQUXL14kABQdHV3mYz99+pQA0JUrV2Qi//3796SoqEhTpkyRifyyICIiglq0aEF8Pp82b978WxuejMJhxsBfQq4r1s3Nrch2mzZtIlVVVdEP/tGjRwSA3rx5U6rxT506RWpqalSrVi16/PgxzZgxg7hcLtnY2NDLly9LLDcjI4POnz9PQ4YMISUlJQJATZs2pX///TfPxFkWZGVl0Zs3b+jw4cM0a9YsatGiBXG5XJGBoKOjQx06dKA5c+bQ0aNHyd/fXyxj6OzZswSAjh49KjoWGhpKysrKNGvWLFleUplw5coVAkARERFlPrZQKCQrKyvq06ePzMbYvn07AaCrV6/KbAxZk5WVRXPmzCEA1K9fP4qPjy9vlRhShhkDfwFBQUGkpqZGQ4cOLdaqnzJlCtWrV0/0/sePHwSAPD09S61HYGAgWVtbk4KCAu3Zs4d8fHyofv36xOVyafbs2ZSSklIq+cnJyXTs2DHq2bMnycnJEZfLpfbt25O7uzvFxcWVWn9JSElJoUaNGpG+vj49evSIzp8/T8uXL6e+fftS1apVRQaCoqIiNWrUiCZMmEA7d+6kx48f51nCiYmJIT09Perdu3ee7+53Dxr8lRs3bhAACgkJKZfxd+7cSTweT2bGiFAopK5du5K+vj79+PFDJmOUFefPnycNDQ2qXr06vXr1qrzVYUgRZgz84WRkZFCDBg2oZs2aYn0vPXr0oJ49e4reC4VC0tTUpLVr10pFn/T0dHJwcBBlGMTFxdG6detIUVGRqlWrRtevX5fKOLGxseTu7k7t27cnDodDcnJy1KtXLzp+/HipjY7iyMnJod69e5OKikqhXo+4uDi6e/cubd26lUaNGkX169cnPp9PAIjD4VDt2rVpyJAhZG1tTaqqqnmWdnKDBn8NJPyduXv3LgGg4ODgchk/MTGRVFRUaMWKFTIbIzIyknR0dKhfv36/vZv906dPZGNjQwoKCuTm5vbbXw/jJ8wY+MOZOnUqycvLi23F16tXj6ZOnZrnWOPGjcne3l6qeh0/fpxUVFSoTp069PbtWwoKCqL27dsTABo5cqRUn6AiIyNp27Zt1KRJEwJAysrKNHToULpw4QJlZGRIbRyin8bT5MmTicfjSbwOnZGRQS9fvqR9+/aRk5MT1a1bV+RBAED6+vrUuXNn0tbWprp169LHjx+llmpZnnh7exMA+vDhQ7npMH78eDI2NpZpGl1uoOT+/ftlNkZZ8atRP3LkSJkb2AzZw4yBP5jcm4+rq6tY7YVCIamqqtKmTZvyHB8xYgS1aNFC6vp9+PCB6tWrR0pKSrR//34SCoW0f/9+0tLSokqVKtGRI0ek/tTx6dMnWrNmDVlaWhIA0tTUpLFjx9LNmzelMhFs2LCBAJC7u3up5MTGxpK+vj716NGDgoKCyNPTkxYtWkS1a9fOYyCoqKhQ8+bNafLkybRnzx56/vx5qQIVy4PcIL63b9+Wmw7Pnj0jAOTl5SXTcezt7UlVVVXibJqKytGjR0lZWZksLCzK1ZhjlB5mDPyhfP78mTQ0NGjgwIFiT6gxMTEEgE6fPp3n+IoVK0hXV1cWalJqaiqNHTuWANCYMWMoNTWVoqKiaOjQoQSAunTpIrMMAX9/f1q0aBFVr16dAJCenh45OTnR48ePS2SEeHh4EABavHhxqXUbOXIkaWpq5imIExoaSkpKSjR79myKjo6mGzdu0MaNG2nYsGFkbm4uClbk8XhkYWFBI0aMIGdnZ7p16xbFxMSUWidZ8eLFCwJQrmvQQqGQbGxsqFevXjIdJykpiapVq0YtWrQoUSZNReTdu3dkbm5OKioqf8zS1d8IMwb+QDIzM6lRo0ZUrVq1fDnvRfHy5UsCQM+fP89zPHeSk2UE8aFDh0RPGO/fvyciosuXL5OxsTEpKyuTs7OzzG6eQqGQfHx8aMaMGWRgYEAAqGrVqjR//nzy8/MTyzC4d+8eycvL08iRI0vtzchNtTt48GCe4wMGDCBDQ8NCi/OIW1Vx6dKlUquqKA38/PwIAD179qxc9di9ezdxuVwKCwuT6TgPHz4kLpdLq1evluk4ZUlycjINHz6cAJCjo6PUl98YsocZA38gM2fOJDk5uXyTenHkLiv8t9pYrpEg65t17hOGsrIyHTlyhIh+PklNmzaNOBwO2drayvzpMScnh+7cuUMTJ04kbW1tAkDm5ua0cuVKCgoKKlRvTU1N6tChg9gVCQsjLi6ODAwMqHv37nkm6mvXrpUoaPDXqor//POPVKsqSot3794RgHIvapOUlESqqqq0bNkymY+VW51Q0t9oRUYoFNKuXbtIXl6eGjZsWGY1PxjSgRkDfxgXLlwgALRt2zaJ+27evJmUlZXzPS0mJSWVWcnblJQUGjlyJAGg8ePHi+rVP336lCwtLYnH49HcuXPLpKJbZmYmeXl50fDhw0lFRYUAUMOGDWnz5s2iNLTIyEgyMTGhevXqSeSFKYzRo0eThoZGnjS3jIwMqlWrFrVt21YqT/IFVVWsWbNmvqqK9vb2hVZVlCaBgYEEgO7fvy+zMcRl4sSJVKVKFZm78DMzM8nW1pZq167921YnLIwXL15QtWrVSFNTky5evFje6jDEhBkDfxAhISGkpaWVp2StJEybNo3q1q1b4Dl9ff0yeWIi+jlZ7d27lxQVFal+/foUEBBARD8Ln6xZs4YUFBSoevXqdPPmzTLRh+inC/7kyZPUt29fkpeXJw6HQy1btiRjY2MyMDCQimvZy8urwGjzNWvWEJ/Pl3mlwdyqitu3by+yquLKlSvp0qVLFB4eLhXj5PPnzwSAbt26JYWrKB25XrALFy7IfKwPHz6QkpISTZ48WeZjlTVxcXHUp08fAkD//PPPHxMf8SfDjIE/hKysLGratCmZmpqWuMBO7969qVu3bgWea9WqFdnZ2ZVGRYnx8/MjMzMzUlVVpRMnToiOBwQEUNu2bQkAjRo1qsyD4+Lj48nd3Z0qVaokCtjr3r07HTlypMSb7cTHx5OhoSF17do1zwT7a9BgefDfqort2rUjLS0tkYFQqVIl6tixo8RVFX8lLCyMANC1a9dkdBWSYWtrS927dy+TsVxdXWVaDrk8EQqFtGnTJuLxeNSqVSuZ7A7JkB7MGPhDmDt3LvH5fHry5EmJZdSvX58cHR0LPDdu3Dhq2LBhiWWXlKSkJNEGR46OjqK0uVzvgaamJlWqVImOHj1aZsFwQqGQxo8fT3w+n06dOkWurq7UokULUUXBgQMH0pkzZyRK8bO3tyd1dfV8Hob+/fsXGTRYHgiFQgoNDc1TVTF3V0lxqir+l2/fvpVJWp+47NmzhzgcDoWGhsp8rD+pOmFheHt7k6GhIenq6tLt27fLWx1GITBj4A8g17383/oAkqKhoUEbNmwo8NyGDRtIXV29XKLPhUIh7d69mxQUFMjGxiZPpbpv377R4MGDCQB17dqVvnz5InN9Vq1aVWC0f0hICG3YsIGsra0JAKmrq9Po0aPp2rVrRT4t59bm37t3b57juUGDHh4eMrkOaSNuVcV169bR1atXKSoqioj+V/L63Llz5XsB/09ycjKpqanRkiVLymS83OqEJV3e+x2Ijo6mjh07EpfLpVWrVv0RxbL+NJgx8JsTHh5OOjo61KNHj1L9wOLj4wlAHnf8r+RulpN7Ay8PXr16RTVq1CB1dfV8eyVcunSJjIyMSFlZmbZs2SKzSnKHDh0iAMWWrv3w4QMtW7aMzMzMCABVrlyZJk+eTA8ePMjzPSUkJFCVKlWoc+fOeSaC3KDBdu3a/dYTxH+rKrZs2ZLU1NTyVFXs0KEDAaCZM2dSQEBAhZgoJk2aRIaGhmW21p37+9q3b1+ZjFce5OTk0NKlS4nD4VDXrl3/WE/I7wozBn5jsrOzqWXLlmRkZFTqdfPXr18TAHr69GmB5/39/QkAeXt7l2qc0pKQkEADBw4kADRt2rQ8aXBJSUnk5OREHA6HGjZsSL6+vlId+9atW8Tn82ncuHFiT9BCoZBevnxJc+bMISMjI1G+/5w5c+jly5c0duxYUlNTy+eSLqugwfJAIBBQcHCwqKpily5dCq2q6O7uXi5VFXN/D2XprfjTqhMWxvXr16lSpUpkZGREjx8/Lm91GP8PMwZ+YxYuXEg8Ho8ePnxYalnnz58v8sk/PT2dOBxOhXhyEQqFtH37dpKTk6NGjRrlWxp48uQJ1atXj3g8Hs2bN0+UnvhfUjKyyf9rAr0KjSP/rwmUklH4U+CbN29IXV2dunTpQllZWSXSWyAQ0IMHD8jR0VEUfAiAevbsSR8/fhS1CwkJISUlJZozZ06JxvndyMzMFJXNzq2qaGdnV+5VFRs3bkxdu3aV6Ri/kpSURNWrV6fmzZv/8dH34eHh1Lx5c+Lz+bR169bf2vv1p8CMgd+U69evE4fDoXXr1klF3rZt20hRUbHIH6WpqSnNnz9fKuNJg+fPn1PVqlVJU1OTzp8/n+dcZmYmrVq1iuTl5alGjRqitLXAqCRadsGfWm+8Q1Xne5HpL6+q872o9cY7tOyCPwVG/S9gLzw8nKpUqULW1tZSC+SLiYmhSpUqkYGBAamqqhIAsrGxoY0bN1LXrl0rXNCgLBEIBIW6yFNTU+np06d5qioqKSmVSVXFffv2EYfDKZM4lFwePXr0x1UnLIysrCyaNWsWAaABAwbItJYFo3jEnb85REQohqSkJGhoaCAxMRHq6urFNWeUkMjISFhbW8PW1haXL18Gl8sttcyZM2fi6tWr+PjxY6FtOnfuDDU1NZw5c6bU40mL+Ph42Nvb48KFC5g1axbWr18POTk50fmAgABMnDgRj/0CUG/sGsQr6IPH5UAgLPzPOfd8q5qVsKBTNdj16oSEhAQ8efIEhoaGUtHbwcEBx48fh7+/P/T09HDlyhV4eHjgwoULyM7OhpmZGaZNm4ZBgwZBV1dXKmNWZHg8Hnbt2oWJEycW21YgECAoKAi+vr54/fq16N8fP34AADQ0NGBtbS162djYwNzcHPLy8hLplJqaCkNDQzg5OWH16tUluq6SsHjxYmzYsAFPnjxBw4YNy2zc8uLs2bOwt7eHrq4uPD09YWVlVd4q/ZWIO38zY6CCIBAI0LFjRwQGBsLX1xeVK1eWitz+/fsjLS0N165dK7TNlClT8ODBA7x9+1YqY0oLIsK2bdvwzz//oFGjRjh58iSMjY1F5z18QrHkwltkC4TgcHliy+VxORDmZCP1wQHc3bsGFhYWUtH31q1b6NSpE3bv3g0HBwfR8czMTNStWxcKCgowNTXFrVu3QETo0KED7Ozs0K9fP2hoaEhFh4qGgoICtmzZgilTppSoPxEhKipKZBzkGgjBwcEAADk5OVhYWMDGxkZkJFhZWRX7eU6ZMgVnz55FWFhYHiNTlmRnZ6NZs2ZISUnBq1evoKysXCbjlifBwcEYNGgQPn78CFdXV4wdOxYcDqe81fqrEHf+Lv2jJ0MqrFy5Eg8ePICHh4fUDAEACAkJgampaZFtzMzMEBwcDKFQKLVxpQGHw8HMmTPh7e2Nr1+/wtraGleuXAEAuN4NwoLz/sghjkSGAAAIhAQhhwflthNw97tkT5WFkZycjHHjxqF9+/b5noI3b96MsLAweHp64urVq/j27Rt27NiBzMxMjB07Fnp6eujfvz9OnTqFtLQ0qehTUeDz+cjJySlxfw6HAwMDA3Tv3h0LFy7EqVOnEBQUhKSkJDx8+BBbtmyBra0t3rx5g7lz56JNmzbQ1NREjRo1MGDAAKxatQpeXl6IiIjAr889Dg4OiIqKwqVLl6RxmWIhJyeHo0ePIiwsDHPnzi2zccuTmjVr4vHjxxg5ciTGjx8Pe3v7P+5v/E+BeQYqALdv30anTp2wcuVKLF68WKqytbW1MXfuXCxYsKDQNlevXkX37t0RGhoKExMTqY4vLeLi4jB69Gh4eXlh4LwteM4xk5rsDf0tMaRR6a7b0dERR44cgb+/P6pWrSo6HhoaCnNzc0yZMgWbNm3K1y8iIgKnTp2Ch4cHXrx4AVVVVfTp0wd2dnbo3LlzmT21ygpNTU0sWbIEs2fPlvlY2dnZ+PjxY55lBl9fX8THxwMAKlWqlGeZYdOmTdDV1cWNGzdkrtuv7Ny5E1OmTMHly5fRvXv3Mh27PDly5AgmTZqE6tWrw9PTE7Vr1y5vlf4K2DLBb0JUVBSsra1Rr149XL9+HTyeZE+5RZH7vR0/fhx2dnaFtgsODkatWrVw8+ZNdOzYUWrjSxuhUIilG/7FkVhTcPjyQAHuxuy4r0jwPorMiPcQpqeAp14ZKnXbQL1JP3DlFAuUq8Dn4tbMNjDWLpnb9vbt2+jYsSN27twJR0fHPOf69+8PHx8ffPz4EWpqakXKCQoKwokTJ+Dh4YEPHz5AW1sbAwcOhJ2dHVq1aiXVv42yolKlSpgzZw7mz59fLuMTEcLDw/MtM4SGhoraWFpaomnTpqKlhvr160NFRUWmOvXo0QOvXr3C27dvpeoJrOi8e/cOAwcOREREBPbu3YshQ4aUt0p/PMwY+A0QCATo0qUL/P394efnBz09PanKf/v2LerXr49Hjx6hefPmhbbLycmBkpISXFxc8k1mFY2R+3zw6FMMCooTzEn6gW/7poKjoAI1m27gKqkh8+tHpL69BaWaTaA7cEmBMnlcDppX18GRcU0k1ic5ORmWlpaoXr06bt26lSfo89q1a+jWrRtOnDgh0U2PiPDmzRuRYRAaGgpDQ0MMGTIEQ4cORaNGjX6bdVcDAwNMmTJF6h6v0hIfHw8fHx/069cPNWvWBJfLxfv375GTkwMOhwMzM7M8gYrW1tZS/X1GRUXB0tISLVu2xNmzZ3+b71MapKSkYOLEifDw8MDUqVPh7OwMBQWF8lbrj0Xc+Ztfhjox/sO6detw584d3Lx5U+qGAPAzXgBAHrd1QfD5fNSoUQOBgYFS10GaBEUnwzs4ptDzqf53IcxMhcGIjZCv/DNOQs26K0BCpPrfgSAjBTxF1Xz9BEKCd3AMgr8no6Zu0U/v/2X+/PmIiYnB3bt38xgCmZmZcHJyQvv27TF48GCJZHI4HFhZWcHKygpr167F06dP4eHhgePHj2Pr1q2oUaMGhg4dCjs7O6kFP8oKPp+P7Ozs8lYjH1paWujatSvGjx+PU6dOITw8HESEd+/e5fEgXLlyBcnJyQAAfX39PMaBtbW1yJCQFH19fbi7u6Nfv344cOAAxo4dK+1LrLCoqqri2LFjaNWqFWbMmAEfHx+cPn262NgmhmxhAYTlxP3797Fs2TIsWbIEHTp0kMkYoaGhkJeXh76+frFta9WqhaCgIJnoIS2O+YSBxy38CUqY9TMwiaeimec4T1Ub4HDB4RZu+/K4HBx9GiaRPnfv3sXOnTuxYcMGVKtWLc85Z2dnhISEYPv27aV66uNwOGjWrBlcXFwQERGBmzdvok2bNnB1dUW9evVQv359rFu3Dl++fCnxGLJETk6uVAGEssbBwQHfv3/HxYsXoaCggAYNGmDs2LFwcXGBt7c3EhISEBwcjNOnT2PcuHHg8Xg4fPgwhgwZgtq1a0NdXR0tWrTAlClTsHfvXrx48QIZGRlijd23b1+MHTsW06ZNw6dPn2R8pRULDocDR0dHPHr0CD9+/ICNjQ0uX75c3mr91bBlgnLgx48fsLa2hpmZGW7duiWzteA5c+bgwoULYk3ys2fPxqVLlyq0d6DNprsIjSs8Ejn980t8P7UMSjWbQLPV8P9fJviA2GuuULXsBO2OE4qUb6qjjPtz2omlS0pKCurXrw8TExPcuXMnz9NhbtDg1KlTsXHjRvEuTkIyMzNx7do1nDhxAhcvXkRaWhqaNm2KoUOHYvDgwTAwMJDJuJJiZmaGvn37yuxzkAYtWrSAsrIybt68KXaf79+/w8/PL0+wYkBAAIRCIXg8HurUqZPHg2BtbQ0dHZ18cpKTk0VLEA8ePACf//c5a+Pj4zF69GhcunQJ8+fPx6pVq/7Kz0FWsJiBCopQKET37t3x6tUr+Pr6Sq3YTUEMHDgQiYmJYt3kdu/ejalTpyI9Pb1CRrCnZObAcvl1FPfHmvDoBJKenAblZIqOqTcfAq3WI4sdgwPAf3kXqCgUfyNycnLC/v378ebNG9SoUSPPuf79++PZs2f48OFDsUGD0iAlJQWXLl2Ch4cHrl27BoFAgLZt28LOzg4DBgyAlpaWzHUoiNTMHNi27YqmzVti7uyZqKqjItZnW9YcPnwYo0ePRlBQEGrWrFliOWlpaXj79m2eZYY3b94gPT0dAGBsbJxvmaFq1ap48uQJWrVqhRUrVlS42IqyQigUwtnZGQsXLkTLli3h4eFRYQza3x1mDFRQ1q9fj4ULF+LatWvo3LmzTMdq1KgRrK2t4e7uXmzbO3fuoEOHDggMDEStWrVkqldJeBeZiB7bHxbbLsX/LlLf3YVy7ebgKakj7dNzpL65Ba1OE6Fu26vY/pedWsLCsOiCNffv30fbtm3h4uICJyenPOdy0zQlDRqUFnFxcTh79iw8PDxw9+5d8Pl8dO3aFXZ2dujdu7dMo+SBn3Edx3zCcDfgO8Li0vIYbxwAJtrKaFdbF8ObmKCWnuwNJXFIT09HlSpVMGHCBGzYsEGqsnOrKv43m+G/VRXT09Px4sULHD58GIMGDZK4quKfwoMHDzB06FAIhUJ4eHigXTvxPHWMwmHGQAXk4cOHaNu2LebNm4c1a9bIfLzKlStjxowZWLRoUbFtIyIiYGxsDC8vL/To0UPmuknK67B49Nv1uMg2qe/vI/aKCwwnuoGvXkl0PObyNqR99EaVyQfAUyr67/ecY3PYmBT+JJ2amor69eujSpUquHfvXr6gwXr16sHExAS3bt0q9wjxb9++4dSpUzhx4gSePn0KZWVl9O7dG3Z2dujSpYtUI7jD49Kw8NxbeAfHSFQWem0/yxKndEqTGTNm4Pjx44iIiJD5RExE+PbtWx7j4PXr16K4AT6fj3r16klcVfFPITo6GsOGDcO9e/ewatUqzJ8/Xyql2f9WmDFQwYiNjRW5BXOf2GRJamoqVFVVceTIEYwYMaLY9kKhEKqqqlizZg1mzpwpU91Kgjiegaij8wASQn9k3uI+aQGP8ePcWugOXQ2lqtZFyvhxZBZM1LgwNjaGkZFRvteOHTtw+PBhvH37Np9Lec2aNVi+fDnevHkDc3PzEl2nrPjy5YsoVfHt27fQ1NRE//79YWdnh3bt2pUqbuXE8zAsu/gOOUIq0gj4LzwuB3wuByt6W2BoKYs+lZb379/DwsICJ0+elDj7Q1q8evUKzZs3R6NGjVC7dm34+vri7du3yMrKAgBUr149X7pjlSpVyt3olAUCgQDLly/H6tWr0b17dxw+fLjAmAtG8bDUwgqEUCjE6NGjkZ6eDg8PjzIJjsktqlJcWmEuXC63QmcUVNVRAQcoMmZAkJYAbgGpgyQU/PxP7r+FQYSs2K+ISpWDnp4ePnz4gJs3byIyMjJPqWY5OTl07949j5GgpKSE1atXY9iwYdDR0YFQKKxQTzPVqlXDggULsGDBArx79w4eHh7w8PDA/v37oaenh8GDB8POzg5NmzaVaHJxvRsE5xslCzoV/L/xMP/sW8SkZGJqu/Jbnqpbty5atmwJNze3cjMGGjRogK1bt2Ly5MlYsGAB9u7dW2BVxa1btxZaVdHGxgZmZma/fQAej8fDqlWr0KJFC4wYMQINGjTAqVOn0KSJ5LVAGOLBPANlgLOzM+bOnVum5UevXLmCHj16IDw8HEZGRmL1GTRoEOLj43Hr1i0Za1cyWm+8g7D49ELPfz+9Aukhr2E4bgfktKv87/iZ1UgPfoYqkw+Ar1b404WpjjJ299DHhAkT8OjRI4wfPx4bN26EmpoaQkJC0LZtW6ipqcHBwQFfv35FRESE6BUaGpqn9r28vDyqVKlSoHch96Wnp1euVQWJCM+fP8eJEydw8uRJREZGomrVqqIaBpaWlkUaBieeh2H+WeltbiWNstCl4ejRoxg5cmS5xs0QEXr27ImXL18WWp2QiBAWFiZaZvhvVUVFRUVYWlrmWWaQdVVFWRIeHo7Bgwfj5cuXcHZ2hpOT0x/pDZEVbJmggvD06VO0atUKM2fOLNP0qp07d2L69OnIyMgQe8JZuHChaCOVikRoaCj27NmDQ2/TwDNvV+jGRBlh/oj2WAiukjrUbHv8DCAMfoaMzy+hatUZOt2mFToGj8vByCamWN7bAkKhEHv27MG8efOgpKSE7du349GjR3Bzc8ObN2/yTRS5QYNubm6wtbXNYyREREQgPDxc9P/MzP9lOfB4PBgaGhZpMBgYGJRJdodAIIC3tzc8PDzg6emJuLg4mJubw87ODnZ2dvmWRMLj0tBx632kp6UiyecsMiMDkPUtEMKMFOh0nwHV+nnLWmdGBiDl7W1kRQYg60cIIBTAdL5XnjalLQtdWjIyMlClShWMHTu2wH0kyorc6oQtWrTAuXPnxJ744uPj4efnlydYsSyrKsqSrKwszJs3D9u2bcOgQYOwd+9eieei1MwchMSmIitHCHk+t8Jmt0gbZgxUAOLj42FjYwNDQ0Pcv3+/TFP25s2bB09PT4mKmRw8eFC0q5iSkpIMtSseoVCI69evY9euXbh8+TJUVVXRf8xk3FVuWWS/zMgAJDw8juzozxCkJ4OvqQfVeh2g3nRAsbsb3prZOk8Fwq9fv8LJyQnnzp0DACxduhQrVqzI0ycjIwP16tUTbU1c1I2biBAbG5vPWPiv4fDrrm5cLhf6+vpFGgyGhoZSDQbMysrCzZs34eHhgfPnzyM1NRUNGzaEnZ0dhgwZgipVqmDkPh88/hyLzLgofN09Djz1yuBr6iMz7G2BxkCC9zEkPjkNed2qEGalIyfuaz5joDRloaXFrFmzcOTIEURERJRridzz58+jX79+2Lt3L8aNG1diORkZGXj//n0eD4Kfn1+eqoq/ehBsbGxQo0aNCrXE9StnzpyBvb099PX14enpifr16xfZ/nfMbpE2zBgoZ4gI/fr1w4MHD+Dr61vmuwEOGTIEMTExuH37tth9Hj16hJYtW+LNmzewtLSUoXaFExMTg/3798PNzQ2fP3+GtbU1Jk+eDDs7O6iqqoomIUkC1YqDBDnIDHuL4VXisXjx4jx5+WlpaahZsyZiYmIgLy+P9evXw9HRUeRtWb16NVasWCG1oEEiQmJiYpEGQ0REBBITE/P009XVLdJgqFKlCpSVJX/iTktLg5eXF06cOIHLly8jOzsbTbv0Q6T1z/K5lJMNYUYKeKpayPwWhKhDMws0BgSp8eDIK4Mrp4C4G7uQ/OpyPmMgl/8aZWXJx48fYW5uXuzmXmXB+PHjceLECfj5+eWrZVEahEIhvnz5ki/dMTIyEgCgoqICKyurPB6EevXqQVGx4I2+ypqgoCAMHDgQgYGB2LlzJ+zt7fO1+d2zW6QJMwbKmX///RczZszAhQsX0Lt37zIfv0mTJrCwsMD+/fvF7vPjxw/o6urizJkz6N+/vwy1ywsR4cmTJ9i1axdOnz4NABg8eDAmT56MJk2a5HnaznVPZ+YICxMnMVwSINzNAYLEaKioqGDFihWYMmUKFBQUMHv2bOzcuRPe3t7Yt28fdu/ejaZNm8Ld3R2qqqowNzfHtGnTpJ6fXhzJycn54hb++4qNjc3TR1tbu0iDwcjIqMgiSYmJiTh37hy2eX9FfCXLfJ6WooyBXynKGPh1uaa8aNOmDTgcDu7du1duOgD/q06oq6sLb29vmQcF5lZV/NVI+LWqorm5eR4PgpWVVblF+Kenp8PJyQn79u2Dvb09XF1dRcbun5DdIk2YMVCOPH/+HC1atMDUqVOxZcuWctFBX18fkydPxtKlS8XuQ0TQ1tbGvHnzymTL2ZSUFBw7dgy7du2Cn58fqlevjkmTJsHe3h6VKlUqtJ8sAtdqy8Vh4sSJeP78OTgcjmjteOXKlXB2dsbs2bMBAN7e3pg4cSI+ffqE6tWrIzk5GQEBAVBVzZ/FUN6kp6cXazBER0fn6aOurl6swdBnry/CCigLLQ1jAJCsLLQsOH78OIYPH46PHz+idu3a5aYHADx58gQtW7bE8uXLsWRJwbtuypKSVlUsqwC/Q4cOwdHRETVr1oSnpydufOWUOLvlV+Z0NivX7BZpwoyBciIhIQENGjRApUqV8PDhw3KpJJaeng5lZWUcOnQIo0aNkqhv48aNUa9ePYk8CpLy7t077Nq1C4cPH0Zqaip69uyJyZMno1OnTmKvVZYmpe0nBICDuZ1rY0q7n8FxQqEQhw8fxuzZs5GYmAiBQAAlJSWcO3cOXbp0EfXMzMyEvb29qGTqiRMn0Lp161LoUn5kZWUhMjKySIPh27dvotRKjrwSjGeeKvBmLy1jQJKy0LIgMzMTVapUwejRo7F58+Zy0eFXli5dirVr1+Lx48do3LhxeasjdlXFX40Ec3Nzmd0L3759i4EDByJOsw5U2k+Umtzyzm6RFswYKAeICIMGDcKtW7fw+vXrfDvZlRW565737t1DmzZtJOo7YsQIhIaGwtvbW6o6ZWVl4dy5c9i5cycePHgAXV1dTJgwARMnTixxPEWuOzAzKxsoJjgwDyQECXLwT4eqmNLVJt/p+Ph4dOjQAa9fv4aioiIyMjLQpUsXbNiwAVZWVqKgwcqVK4PD4eDJkyeYMGECNm7cCE1NzRJdS0UmJycHUVFRiIiIgE/gV2z9UPDasbSMAQD4t5s+6lXRhLKysuhVlgG4c+bMwYEDB/D169dyXyvPzs5GixYtkJCQgNevX1fIFMGCqir6+voiODgYwM9UWwsLizw1EaRZVfFD+Hd0d30CIYeXz1CN8dqKVP/CY6eqTDkIvlp+T2R5Z7dIC1Z0qBzYuXMnzpw5gzNnzpSbIQAAISEhAMQvOPQrZmZmEu3eVhxhYWHYs2cP9u7di+joaLRp0wYnTpxAv379Sv2kMLSRCQy4yRi86SyUqjUoNlAIJAQ4XDStpoWn22fg6EM5TOzwIN8k8/HjR/j5+Yn2Wn/y5AkeP34Ma2trjBo1CpUrV0ZYWBi8vLxgZmaG3bt3Y/78+bh06RJcXV3Rv3//PyoPms/ni5YIFAzjsfVD0WWhpcHgocOQ9S2v54fH4+UxDpSUlPK8F/dYcW3k5eUxceJEbN68GWfOnMHw4cNlfr1FIScnhyNHjsDGxgZz5szBrl27ylWfguBwODA0NIShoWGeWirJycmi3R1zjYRjx47lq6r46zJDSaoqrr3xBVy+HKiA37+aTVco5qs8Soi7vgN8Db0CDQEAyBESFp57W67ZLWUJMwakxKtXrzBr1ixMnTq1TIPvCiI0NBQ8Hg9VqlQpvvF/qFWrFr5//47ExMQSW+1CoRA3btzArl274OXlBRUVFYwePRqTJk2ChYV0A8P2bFmL7yePY43rfmQZN8bdwO8Ii82fQqTJz0aYz3V4bfsHzepWw1MrV7Rq1QpLlizB+vXrRW3T09Nhb2+PRo0awdnZGRwOB4cPH8Y///yD7OxseHp6Ii0tDY0bN4a+vj64XC4mT56M3r17Y+rUqRg4cCD69OmDHTt2lOjzr6jk5OQgMDAQt5+8ASD7SP/DB/ZDVz4LaWlpSEtLQ3p6uuj/Bb3PPRYbG1tgm9TUVAgExVSg/H+4XC6UlJQgJyeHcePGYc2aNVIzNH49pqioKPakV7t2bWzZsgWOjo7o2bNnhdw/pCDU1NTQsmVLtGz5v5TggqoqbtmypcRVFYOik+EdHFOoDgpVzKFQJW+mT0b4O1B2JlTqti20n0BI8A6OQfD35HLLbilLmDEgBZKSkjBkyBDUq1cPzs7O5a0OQkJCYGRkVKLoYzMzMwA/03caNmwoUd+YmBgcOHAAu3fvxufPn2FlZYVdu3Zh2LBhMgmwi42NxalTp6CoqIiZY4dCSUkJy2FRYHGR7PQUGBjYwdurGprV/QdNmzbFmjVrMG/ePLRr104UE7B8+XKEhITg9evXovTBMWPGoE+fPliyZAl27NgBLpeLN2/eoHr16li8eDGmTJkCIyMjnDt3DmfPnsXUqVNhbm6O9evXY9KkSRU2Z7swkpOT8ebNG/j6+oqe6t6+fYuMjAxw5BRhPOu0TD0fHAA92zaResxAdnZ2oUZEQe+fPn2KkydPolGjRlBWVs7TJjExsVA5uU+9xV4nhyMyFMQxIhQVFVGrVi0MGTIEixYtgp6entj9KtLfoJycHCwtLWFpaYmRI39uLV5QVcXTp0+L7qdFVVU85hNWvFfwP6S+vw+AA5W6RS+j8rgcHH0aVq7ZLWUFMwZKCRHBwcEB0dHRuHr1arkWKsklJCSkREsEAETV9QIDA8UyBogIPj4+2LlzJ06dOgUiwuDBg3H06FGJ69xLyo4dO5CTk4Px48fnKZKkosDPvw2xws+Nefbv34+5c+eCw+Fgzpw5uHPnDkaOHAk/Pz+EhYXB2dkZa9asyVczQEtLC927d8eOHTtQs2ZNBAYGwsjICHPnzsX27duxevVq2NnZYcCAAejQoQPmzZuHKVOm4NixY3B3d0fdunVl9jmUFCLC169f80z6v67zysnJoW7durC2tsawYcNEN+B++/wQWkA2gbQw0VGWSfCgnJwc5OTkxI57yszMxO3bt6GtrY2tW7eKPU5OTo7IMBDXo1HY++/fv+c5lpKSgrS0NCxevDjPfhnFoaioKDWPRmHvlZSUSlxem8PhwNTUFKampujTp4/o+H+rKj59+hT79+/PU1WRei6HQE78J3cS5CDt40MoGJmDr1l0BUaBkHA38DuW4883BlgAYSnZs2cPHBwcynW3s//SvHlzmJmZ4eDBgyXqr6+vD0dHRyxbtqzQNikpKTh+/Dh27doFX19fVKtWTZQWWFA9dWmTlZUFPT09JCQkICAgQOTRKIrbt2+jY8eOePToEZo3bw7gZ261lZUVzM3N8e3bN6iqquLJkyf5vCq5QYNVq1bF9evXRUsH6enpqFatGvz9/WFjY4NNmzahQ4cOAH7uzT5x4kR8/vwZCxYswMKFC8vNWMzOzkZAQECeJy9fX19RLQJNTc08rtmiIsCXX3yHIz6hoiexpJeXIMxIhSAlDimvr0DZrDnk9KoDANRte4GrqIKcxO9I8b8DAEj/9BxZkQHQaPVzN02+hi5U67UHUDHqDPzKP//8g7179+Lr16/lXpUzlwsXLqBv375wc3PD8OHDJTI0SmKg5KYRioOCgoJMDI1fj3G5XAQGBsLX1xfPX7/BVZWOgAQPHWnBz/DDcyW0O0+GWoPi94op7+yW0sICCMuAN2/eYPr06Zg0aVKFMQSAn56BTp06lbi/mZkZAgMLTtt7//69KC0wJSUFPXr0wNq1a9GlS5cydUWePHkSCQkJaNKkiViGAAC0a9cOpqam2L9/v8gY0NXVxdGjR9GxY0fweDz4+voWuLyyadMmUdAgj8eDvb09+vbtiyVLlmDXrl2oXr06srKy0LFjR3Tt2hUbNmxA69at4evri7Vr12LdunU4deoU3N3d86yfyoLExESRmz/35e/vL3JfV6tWDdbW1pg2bZooqtvExERsL85AGz0cfBIiep/kcw6CpO+i92mBj4HAn0GGqhbtfhoDCVFI9D6aV8//f69gXE9kDAiEhBFNK04618SJE7Fp0yZ4enqKXNrlTZ8+fTB+/HjMmjUL7du3z7dvhLQRCoXIzMyUiqGRkJCAb9++FdpPjGdTAD+9PMrKylCuYgb53pLd61Lf3we4fCibi/c7JAAhsan5vY1/GMwzUEJSUlLQsGFDKCgowMfHp9zTj3LJyMiAkpIS9u/fX2CZTnEYN24c3rx5g+fPnwP4+RR+/vx57Ny5E/fv34euri7Gjx+PiRMnwtTUVJrqiwURwdzcHAEBATh9+jQGDhwodt8VK1bA2dlZ5AUAfhaJaty4MbhcLh48eIAWLVrk6RMSEgJzc3NMnz49T7BhLq9evcKUKVPw9OlTtG7dGhEREfjy5QtGjRqFlStXwsTEBP7+/pgwYQKePn0KBwcHbNiwodRpVUSE8PDwPJO+n58fPn/+DOBnOle9evVEE36um7806Y+XL1/G9OnTkdJoDJRMrUAc6RmAFWFvgoLo2LEjMjIy8PDhw/JWRURKSgqsra1F9Ux+9y2LgZ9/z7lGR3GGRkJCAr5//47g+Bw80xQ/fVqYlY6I7SOgaFIfuoMK93z+l3OOzWFjolV8wwoI8wzIECKCo6MjIiIi8PLlywpjCAA/t/sESpZWmIuZmRnOnDmDsLAwuLu7w93dHdHR0WjdujU8PDzQv3//cimmlMu9e/cQEBAAbW3tPOuL4jBmzBisWLECnp6eGDNmDDIzMzFmzBg0aNAASkpKsLOzg6+vL7S1tUV9ZsyYgUqVKmHx4sUFymzQoAEePXqEgwcPYt68ecjMzMSAAQNw5coVnDhxAtOnT8eCBQvw8OFD7Nq1CwsWLMDFixdFaYjikJWVhQ8fPuSZ9H19fUUR2Nra2rCxsUHfvn1Fbv46depILTf/8+fPmD59Ory8vNCpUycsnNUHDhcjpFYWmoggzMnB3Lbibbddljg4OGDw4MF49+6d1LNhSoqqqiqOHDmCli1bYu3atRJVGq2oZGdnIyYmBlFRUYiOjkZUVJTo9ev76OhoJCUlAQDkdKvBcKz4xkBa4NOfWQQWbSXSTZ5fcQIwZQUzBkrAgQMHcPToURw9erTcy5X+l9waAyV9YhcKhUhNTUViYiKqVasGFRUVjBo1CpMmTUK9evWkqGnJ2bhxoyilT9LJztTUFB07dsT+/fsxZswYrFy5EkFBQXj58qVo3Xzs2LGirWMvX76MCxcu4NSpU0VmRHC5XIwdOzbP0oG5uTl69OgBV1dX7N27F4sWLcKUKVPQp08fTJkyBQMGDEC/fv3g6uoKQ0NDkazcoKlfg/revXuH7OxsAECNGjVgbW2NWbNmlSo3WxzS09Oxfv16bNiwAbq6uvD09BTVUVgBDamVheZwOEj3PoTeJ6fjzJkzsLW1lYpcadCnTx/o6urCzc0NLi4u5a2OiGbNmmHx4sVYuXIlunbtWiGqE/4XgUAgmuALmtR/nfDj4uLy9a9cuTL09PSgr68PU1NTUUpv7ktduzKGnI6AuHkEqe/vgSOvBKVa4nufOACq6lS8Qk/Shi0TSMi7d+/QqFEjDBs2DHv37i1vdfLh7u6OSZMmIT09XaKn99jYWFFaYO62x3PmzMHSpUuL3LymrAkICECdOnXA4XAQGhoKY2NjiWWcOHECdnZ28PT0xJAhQ7B8+XLRU//FixfRp08fuLi4YMKECbCwsED16tVx48YNiSbbX5cOBgwYACUlJXh4eMDY2Bhr1qzBkCFDcObMGUyZMgWpqalo3749eDwe/Pz8EBoaCuBnMJalpWWeoD5LS8sy+Q0SES5cuICZM2ciMjISc+fOxYIFC/JVvyt9WeifzO1cG71qyGPAgAF4+/YtduzYUaqte6XN/Pnz4ebmhq9fv5Zo90dZUR7VCYkI8fHxhU7qv77/8eNHvqwHTU1N0QSf+/r1fe7/K1euLJax32bTXbGyWwRpiYhwHQUV89ao1Gu22Ndb3ntllBZWjlgGpKamolGjRuDxePDx8alQN4VcFi9ejMOHDyMsLKzYtrlpgbt27cLJkydF5ZTHjRuH9u3blyruQFZMmjQJ+/btQ5cuXeDlVXg526LIyMiAgYEB+Hw+jI2N4ePjk+emM336dOzevRtjx47Fvn378ObNG9SpU0ficYRCYZ6lg4EDB4pSpFRVVUFESE1NFbXX1PyZ/tihQwdYW1sXWWhFlgQFBWHatGm4du0aunXrhn///VeUcloQpd0lbmVvC1EN+IyMDEyfPh179uzBhAkT4OLiUiGW4T59+oSaNWvi4MGDGD16dHmrk4fAwEDY2Nhg5MiR2L17d4lkEBGSk5MLfXL/7/9zvVS5KCsrw8DAoMBJ/df3enp6Uv8+/5vdUhhJLy8h/qYbdAevgFJ18TxPFS27pSSwmAEZ4OTkhNDQULx48aJCGgLAz2WC4pYIUlNT4eHhgZ07d4r2UFixYgXGjh0rSgs0MTEpNKOgvIiNjcXBgweRk5ODKVOmlFiOoqIiatasiRcvXuD69ev5nj42btyIO3fuwM3NDdOnT5fYEIiNjc3j4q9cuTI+fvyIAwcOAPjp+hQKhYiNjYWtrS3Wr18PPp8PBwcHHD16FCYmJhgwYECZGwKpqalYu3YtnJ2dYWhoiPPnz6N3797FekSGNjJBixqVJN4/vnl1nXz7xysqKsLNzQ1NmjTB5MmT8fr1a3h6epZLoOqv1KhRA506dYKbm1uFMwbMzMywefNmUXXCnj17is6lp6cX6Zr/9f1/Uwjl5eXzTOo2NjaFPsWX566dQxsZ5cluKYzUd/fAVdYsoDRx4VS07BZZwowBMTly5AgOHDiAgwcP5itIU5EICQkpdF+EDx8+iNICk5KS0KNHD6xevRpdunTJVyzEzMwMQUFBZaGy2Li5uSEnJwcmJiZ5dhGUlFevXuHVq1cAgG/fvuU7r6CgAF1dXbx79w5RUVEgogInRKFQiC9fvuQL6ssN4lRSUkL9+vXRunVrODk5QVFRETt37sSLFy8wYsQItG3bFhs2bEDnzp0xatQoeHl54dChQ1i9ejVOnjwJd3f3fJkNsoCIcObMGcyaNQvfv3/HggULMG/ePIny6o21lXFkXBMERSfjmE8YDlx/BqhVzvO5cfCzoFA7M12MaGpSZInXsWPHwtraGv3794etrS08PDxKlS4rDRwcHDBw4EC8ffsWlpaW5aZHVlYWvn//nmcij42NRdWqVTFw4EA0aNAAsbGxiIqKEgXa5cLj8aCrqyuayGvXro02bdoU+BSvqalZ4ffYuHPnDmbNmoX0OgOgVNUaKCK7xWCUZDtQ5ma3/A2liAG2TCAWHz9+RMOGDTFw4MASF/IpK4yNjTFmzBisWrUKwM81xdy0wHv37qFy5cqitMCiMg6mTJkCb29vvHnzpow0L5rMzEyYmprix48fWLt2LebNm1ciOVlZWWjYsCG4XC6ICDVr1sSZM2fytLl8+TJ69uyJadOmwcXFBQcOHMDQoUPh7++fZ9L38/NDcnIygJ+Fmn5N4bO2tkatWrXyGVlCoRAHDhzAvHnzkJ2djWXLlkFOTg6rV69GYmIipk+fjt69e2P27Nnw8fGBo6Mj1q1bJ7Xd3f7Lhw8fMG3aNNy6dQu9evXCtm3bUL169VLJTEhIgJaWFjhyijh55Q5qmtURlYWWtHBLbGwshg8fjhs3bmD16tWYP39+uZXWzc7OFnltXF1dpSo7N9BOnKf43EJRv1KpUiVUqlQJnz59gq6uLoYMGVKg215HR6fEVQIrEoGBgZg7dy4uXryIZs2aYd7KjZh1Ox45xJGaAfO37VrIjIFiSE9PR5MmTZCTk4Pnz59XyO1Dc8nKyoKioiLc3d3RpUsX7NmzB+7u7oiKikKrVq3g6OiI/v37i1UFb9u2bViwYAFSU1MrRF3zw4cPY/To0eDz+fj69St0dXVLJGfZsmVYu3Ytnj9/Dm9vb8yaNQuRkZGi5ZGMjAzUqVMH2trasLOzw+7du/HlyxdwuVwIBAJwuVzUrl07z6RvZWUFfX19ifSIi4vD4sWLsXv3btSrVw+bNm3C48eP4ezsDEVFRSxcuBAcDgfLli2Duro6duzYgb59+5bomgsiOTkZq1atwtatW2Fqaop///1XapvfeHt7o3Xr1gCAqKgo6OkVXfK1OAQCAVasWIFVq1ahd+/eOHToULltFb1o0SK4uroiMjKy2HtBbqBdcWlyUVFR+P79e75AOw0NjSID7HJfvwba5QbA5sZc/GnExcVh5cqVoo3ANmzYgN69e8PBwQHn/KKh032a1Mba0N9SFMvyO8OMASkxceJEHDlyBM+fP68wqXWFERQUBDMzM7Ro0QJPnjyBsrKyKC1QUrfmlStX0KNHD4SFhZUoYl+aEBFsbGwQFBSEPn364Pjx4yWS8/r1azRu3BiLFi3C8uXL8ePHD1SpUgV2dnYwMjKCr68vvL29RU/7KioqqFevHgICAqCiooLjx4+jYcOGUo0XefnyJaZMmQIfHx+MHDkSs2fPxq5du7B3714YGxtj1qxZuH79Oi5fvoz+/ftj+/btedIQJYWIcOLECcyZMwfx8fFYuHAh5syZI9Wgrh07dmDatGmQk5NDWlqa1IxJLy8vjBgxApUrV8bZs2fLxVX/+fNn1KhRA+vWrUPLli2LneQLCrQrKsDu1/+X9DuZMGECPDw84OvrK/PqhGVFdnY2du7ciRUrViA7OxsLFy7EjBkzkJiYiH79+uH169fYv38//KkKjvunAEQSlSj+L3M718aUdn/GZ8eMASng4eGBYcOGwd3dHePHjy9vdQolN7Bu69at+Pr1K2rXro0ZM2Zg+PDhJU4LDA4ORq1atXDr1i1Rrf3y4s6dOyId7t+/L3rqlISEhAQ0btwYaWlp6NGjB96+fYs3b96IovkNDQ1hZmYGb29v9OrVCxs3bkSNGjVEOxQ2btwY48aNw44dO6R6bUD+pYOVK1eiQ4cOWLJkCc6fP48GDRqgW7ducHd3R2ZmJjZs2IAJEyZIPMn6+/vDyckJ9+7dQ//+/bFlyxaZBOY5ODjg3Llz0NDQkHrcyadPn9C/f38EBwfD3d0dw4YNk4rc3EC7op7ic9+npeVNY5OTkys2TS73VRaBdn9SdUIiwqVLlzB37lwEBwdj3LhxWLVqFfT09PD69Wv07t0bAoEA58+fh7GxMRo3bgxN2+7IsuwrleyWPwFmDJSSwMBA2Nraonfv3jh69GiFC6QhIjx//hw7d+7EyZMnIRQKYWNjAx8fH6Snp5f6SS8nJwdKSkpwcXGBo6OjlLQuGT179oS3tzeMjIzg7+9f7HcRHR2db0OegIAAEBF4PB7q1KkjcvHnPmX4+PhgzZo1ePXqFT5+/JjPBbx79244OjrC09MTAwYMkMl1xsXFYdGiRXBzc4OlpSVcXV3B4XAwd+5cPH36FB06dICamhrOnz+PVq1aYc+ePWJlOiQmJmLFihVwcXFBjRo1sH37dnTu3Fkm1wD8LIbz7ds31KhRA7dv35a6/LS0NFHmhZOTE5ydnQusqZGdnY3v37+LVdEuMTExT18ulysKtPvvpB4eHo4tW7bg7NmzaNu2bYUMtHv69ClatmyJJUuWFLnhWEXGz88Ps2bNwp07d9CxY0ds3rwZ9evXBwCcOXMGo0aNgrm5OS5cuAAdHR20bdsW4eHheP78OQSKmhJnt7SqWSlfdsufgNjzN4lBYmIiAaDExERxmv/2pKenk5WVFZmZmVFSUlJ5q5OHlJQUcnd3pwYNGhAAqlq1Kq1bt46io6NpyZIlZGhoKLWxzMzMaObMmVKTVxI+fvxIAIjD4dD27dvznMvJyaEPHz6Qh4cHzZs3j7p27Ur6+vqEn3uLkJqaGrVs2ZKGDh1KXC6Xxo0bR2lpaflkGBkZUdeuXQkAnT59ukA9hEIhDRw4kDQ0NOjLly+yulwiInr+/Dk1btyYANDIkSMpMjKSPD09qVatWsThcKhLly5kampK8vLytHLlSsrMzCxU58OHD5Oenh6pqKjQ+vXrC20rLQQCAamoqJCJiQmNGTNG6vJzcnIoOjqafH19aerUqcTj8ahq1ao0ceJEGj58OHXo0IEsLCxIR0dH9Hfw60tHR4csLCyoQ4cONHz4cJo1axZt3LiRDh8+TNevXyc/Pz+Kjo6mnJycQnXIysoiAwMDcnR0lPr1SZOlS5cSj8ejp0+flrcqEvHt2zcaN24ccTgcql27Nl26dImEQiER/fybXrFiBQGgIUOGUGpqKgmFQho5ciQpKirSs2fP8sgKjEqiZRf8qfWmO1R1vheZ/vqad4lab7pDyy74U1B0xbrPSxNx529mDBSAo6MjKSgokK+vb3mrIuLDhw80bdo00tDQIA6HQz169CAvL688N61Ro0ZR8+bNpTZmjx49qEePHlKTVxImTZpEqqqqpKSkRDdu3KBdu3aRg4MDNWnShJSUlEQ3eWNjY+rVqxctXryYPD09KTg4mAQCAWVlZZG1tTVZWloWOhHOnz+fOBwOtW/fXnTTKYj4+HiqWrUqNW3alLKysmR1yUT0c1J1d3cnHR0dUldXp3///ZfS0tJox44dVLlyZVJUVKSmTZsSj8cjCwsLevz4cZ7+vr6+1LJlSwJAgwcPpvDwcJnqm0tQUJBo0l26dKlYfYRCIcXFxdH79+/pzp075OHhQVu3bqV58+bR6NGjqWvXrmRtbU36+vrE4/HyTfAcDod4PB7Vr1+fBg8eTE5OTrRmzRrat28fXb58mV68eEERERFS/c4WL15MampqlJycLDWZ0iYrK4saN25MtWrVopSUlPJWp1jS0tJozZo1pKqqStra2uTi4pLnO0tNTaXBgwcTAFq1apXot7px40YCQMePHy9SfkpGNvl/TaBXoXHUe9Rkatm2g0yvp6LAjIEScvLkSQJAu3btKm9VKCsri06fPk3t2rUjAFS5cmWaP38+ff78ucD2rVu3pmHDhklt/JkzZ1KtWrWkJk8chEIhff36la5cuUKLFi0iHo9HXC5XdOPn8/lUv359GjlyJG3evJlu375NMTExhcpbuXIl8Xg8evHiRaFtpk+fTgBo48aNxer35MkT4vP5NG/evBJdn6TExMTQpEmTiMPhUP369cnb25uSkpJo6dKlpKysTBoaGmRsbEwAaMqUKRQaGkpOTk7E5XLJ3Nycbt26VSZ65nLmzBnRBO3q6kpBQUHk7e1Np0+fJldXV1q8eDGNHz+eevXqRY0aNSJjY2OSl5fPN8ErKSlRtWrVqFmzZtSvXz9ydHSk5cuX0+7du+n8+fP05MkT+vLlC6WlpVFUVBS1bduWeDwebdmypUiDTlqEhIQQh8Mhd3d3mY9VGgIDA0lZWZkcHBzKW5VCEQqFdOzYMTI2NiY+n08zZ86kuLi4PG0iIiLI1taWlJWV6cyZM6LjXl5exOFwaOHChRKNuWjRIjIyMpKK/hUdZgyUgODgYFJXV6fBgweXyQ2lMMLDw2np0qVkYGBAAKhFixZ07NgxysjIKLKfiYkJLViwQGp67Nq1i/h8vsyegrOzs+ndu3d07Ngxmjt3LnXq1IkqV64smhAUFBSIw+EQAFq6dCm9evWq2M/gV/z8/EhOTo4WLVpUaJtPnz6RoqIimZiYULt27cSSu2HDBgJA165dE1uX0vL8+XNq1KgRAaBRo0ZRVFQURUZGkoODA/F4PNLW1iYej0ccDocUFRXJ2dlZJt9beno6hYSE0NOnT+n8+fPk5uZGK1asIEdHR+rXrx8ZGRnlMd5+fcnJyZGxsTE1bNiQevbsSePHj6dFixbR9u3b6fTp0+Tt7U2BgYGUlJQk8e8vOzub5syZI/KElMUTe7du3ahhw4YyH6e07N69mwDQxYsXy1uVfDx+/JiaNGlCAKhv374UGBiYr42Pjw8ZGBiQsbExvX79WnT83bt3pKamRn369CGBQCDRuHv37iUOhyPR/eR3hRkDEpKRkUG2trZUo0aNcrlOgUBAN27coH79+hGPxyNVVVVydHQkPz8/sfpnZ2cTj8cjNzc3qel069YtAlDgD1RSkpKS6OHDh+Tq6krjx4+nhg0bkqKiomiiMDU1pT59+tCyZcvo3Llz9PHjR9LX1ycjIyNq1KiRxONlZWVRgwYNyMLCosgffK9evcjY2Jj27t1LAOjTp0/FyhYIBNSlSxeqXLkyRUZGSqxbSfnv0oGLiwtlZ2eTp6cnaWlpiSZcADRw4ECxdcvKyqKvX7/Sy5cv6fLly7Rv3z5au3YtTZs2jQYPHkxt2rSh2rVrk4aGRr4Jnsvlkr6+PllbW1OXLl3IxMSE9PT0CABt2rSJ7ty5Q+/evaPY2NgyMbBPnz5NqqqqVLduXfr48aNMxzp//jwBoJcvX8p0nNIiFAqpZ8+epKurS9HR0eWtDhH99KwMGTKEAJC1tTXduXOnwHbHjh0jBQUFatasGUVFRYmOx8TEUI0aNahevXoliuu6ffu21O5tFR1mDEjItGnTSF5evsx/2LGxsbR582aqVasWAaB69erRzp07Jf4D//LlCwGg69evS023sLAwAkCXL18Wu49QKKTw8HC6dOkSrVq1igYMGEA1a9bM83RobW1NY8aMoW3bttG9e/fyuQSJiA4ePCjqs3//fol1X716NfF4PHr+/HmhbS5dukQAyNPTk1JTU0ldXZ0WL14slvzo6GjS19enDh06FBlsJgtiYmLIwcGBOByOKFDO0tKStm/fTk2bNiUAJC8vT8rKyrR06VK6du0aHT58mDZt2kSzZ88WBdrVq1ePKlWqVGSgXfv27WnYsGGiQLtDhw6JAu2ioqLyXXuNGjVEwZjltU79/v17qlOnDqmpqeVxKUub7OxsqlKlSoV2wecSFRVFlStXpl69epWr1zMxMZEWLFhACgoKpK+vT/v37y/w9yMQCGjBggUiT9ivBn1WVha1a9eOKlWqVOiSaXF8/vxZ6vfLigozBiTg7NmzBCBftLosefbsGY0ZM4YUFRVJTk6O7OzsyNvbu8Q/1Lt37xIAqT4NCQQCUlJSoq1btxZ4Pisri968eUOHDx+mWbNmUYcOHfJEcWtpaVG7du1o5syZdPDgQfL19RUrml0oFFL9+vWpevXqpKmpSampqRLp/fbtW5KTkytyySQtLY2qVatGnTp1En3mDg4OZGRkJPbkfuvWLeJwOLRmzRqJ9CspuYF27969o9mzZ5OSkpJoGaVGjRrUrl07sra2Jk1NzQIneHV1dTIzM6PWrVvToEGDRIF2e/fuJS8vL3rx4gWFh4eXOOMgKSmJANCAAQNIR0dHylcvuS4DBw4kADRv3jzKzs6WyThLly4lVVXVCpd1VBAXL14kAFL1HopLTk4O7dmzh3R1dUlRUZGWLFlS6FJOUlIS9enThzgcDm3atCnfPXHy5MnE5/Pp3r17JdYn15O6e/fuEsv4XWDGgJh8+fKFNDU1qX///jK3mFNTU2nfvn1ka2srco2vXbs2j/urpOQ+Sf83da60WFpakqOjIyUkJND9+/fJxcWFxo4dSw0aNMgT+FW9enXq378/rVixgi5cuEChoaEl/jxzXXjq6uo0ffp0ifpmZ2eTra0t1a1bt8jlgeXLl5OcnFwe48nHx0fiWIDFixcTj8ejhw8fSqTnryQnJ1NQUBA9fPiQPD09ydXVlZYsWUITJkwQBdqZmJgUGGinoKBAOjo6xOfzic/nU4sWLWjJkiW0Y8cOmjBhAqmqqhKHwyEul0sLFy6UaWrh48ePRcaAjY2NzMYRF6FQSM7OzsTj8ah9+/YycZGHhYURl8stlwm2JEyYMIGUlZXL1D1+8+ZNsrS0JAA0YsQICgsLK7Ttly9fyNLSktTU1OjSpUv5zu/atUtqBk21atXKLBC4PGHGgBhkZmZS48aNqWrVqhQfHy+zcT5+/EjTp08nTU1N4nA41L17d7p06ZJU3cvLly8nfX39UssRCoUUGhpKFy5coBUrVpChoWGeFD55eXmytbWlsWPHkouLCz148IASEhKkcAX/o0ePHmRiYkIA6P379xL1Xbt2LXG5XPLx8Sm0TW7Q4H89B0KhkCwsLGjw4MFij5ednU0tW7YkY2Njio2NFR3PDbTz8fGhCxcuiALtJk+eTP3796fmzZtTjRo1SEVFpcBAOyMjI1Gg3bhx42jmzJnUrFkz4nA4VKtWLfLw8MgTaPfr0kH9+vVFxklSUhLNnz9fFEugr69P9+/fl+QjFZvdu3cTj8ejLl26UJ8+fWQyRkm4e/cu6erqkpGRkUxy7nv27EkNGjSQulxZkJycTDVr1qQmTZrIzFuSy4cPH6hnz56iIOiifpNERN7e3lSpUiWqVq0a+fv75zt/9+5d4vP55OTkJBX92rdvT4MGDZKKrIoMMwbEYNasWSQnJ1fsH2lJyMrKIk9PT2rfvj0BoEqVKtG8efNKvMZVHGPGjKEmTZpI1CczM5N8fX3p4MGDNGPGDGrbtm0eF7OOjg6ZmpqSmpoaHTlyhN6+fSvz/PoPHz4QADIzM6O2bdtK1Nff35/k5eWLtfZzgwYLWtPevHkzycvLF5iumJ2dLQq0u3LlCu3fv5/Wrl1LY8eOJXl5edLR0SEzM7MC3fRcLpf09PTIysqKunTpQqNGjaJ//vmHtmzZQsePH6fbt28XGGiXk5NDO3fuJC0tLdLU1CRXV9cijchnz55Rw4YNCQCNHj1a5HWKjIykAQMGiPTp0qWL1I24yZMnU926dcnCwoKmTp0qVdmlJSIigpo1a0ZycnK0a9cuqXoBc93vRcWnVCSePn1KPB6Pli9fLhP5MTEx5OTkRHw+n6pWrUqnTp0q9vPet28fycnJUZs2bejHjx/5zn/69Im0tbWpY8eOUjNixo0b91tkg5QWZgwUQ+4PeMuWLVKVGxERQcuWLcuTFnj06FGZp7C0a9eOhgwZUuj5uLg4unv3Lm3dupVGjx5NVlZWoqdFAFSzZk0aOHAgrV69mry8vCgiIoKEQiHt379fJssPheHg4CCKOzh58qTY/bKzs6lRo0ZUp04dSk9PL7Tdr0GDRD/jIr5//05v3ryhmzdvkqurK3G5XGrXrh2NGDGCOnbsSPXq1aPKlSuL1ud/fWlra1PdunVFbtC2bdvShg0b6NChQ3Tt2jXy9fUtMNBOHB4/fkw2NjYEgMaNG0ffv38Xq19OTg65ubmRtrY2aWhoiLIOiH7GU9SrV0/kgVi9erXEehVGy5Ytyc7OjtTU1MSq2VDWZGZm0tSpU0WGkrT+prOzs8nIyIgmTJggFXllwbJly6RenTAzM5O2bNlCmpqapKamRuvXry/yt0j082911qxZBIAmTJhQ4DJWYmIiWVhYUM2aNfN430rL6tWryz22pSxgxkARhIaGkpaWFvXu3VsqTwgCgYBu3rxJ/fv3Jx6PRyoqKjRp0iSx0wKlQe76l1AopM+fP9PZs2dp6dKl1KdPHzI1NRVNXoqKitSoUSOaMGEC7dixgx49elRk8NPDhw8JAL19+1bm1/Djxw9SVFSkJk2akJ6enkTr2+vXrycul0tPnjwhoVBI8fHx9OHDB7p79y6dOHGCtm3bRnPmzCFVVVWqVKkS2djYkIGBQYEV7fh8PikoKFCrVq1o0KBBNHXqVFq9ejXt3buXLl26RM+fPy8w0G769OlSyUiJjo6mMWPGEACytbUt8Q07JiaGJk6cSBwOh6ysrPLENZw8eVKUKqivr19oape4CIVCUldXp2XLlhEAOnHiRKnkyZIjR46QkpISWVtbi5VKKg7Lly8nFRWV3+YemVudsGbNmqWuySAUCuncuXNUs2ZN4nK55ODgIFZ8RkJCAnXt2pW4XC65uLgUeC/Oycmhnj17krq6On348KFUev6XY8eOEYDfIvizNPyVxsCv5Sb9vyZQSkZ+d1JWVhY1b96cTExMSm1lxsXF0ZYtW8jMzIwAkIWFBe3YsaPMPqeMjAx6+fIlubu7E4fDoZo1a+bJBa9cuTJ17tyZ/vnnHzp+/Di9e/dOYhdbdHQ0AZBpilYuq1atIkVFRVJVVS2wolhKSgoFBwfTw4cP6cyZM7Rjxw5asmQJDRw4kDgcDhkYGJCJiQkpKCjkm+AVFRVFMRsdO3akSZMm0bJly2jXrl107tw5evz4MX3+/JlSU1PJy8urRPnjGRkZ1KBBA6pVq1aJbjDZ2dnk4uJCGhoapK2tTbt375ZKXImPj49o6WDMmDGiG7VAIKDp06eLDKLmzZtTaGhoicYICQkhALRjxw4CkK88ckXDz8+PatSoQVpaWhKlzhZGeHg4cbncClG5VFxyqxNOnDixxDJevXpFbdu2JQDUuXNnsR8agoKCqE6dOqShoVFket+8efOIy+XSlStXSqxjYTx58oQAlOlDW3nw1xgDoo0oNubfiKLqfC9qvfHnRhSBUT9vzvPmzSM+n1+qm9WzZ8/I3t6elJSUSE5OjoYOHUoPHjyQaTZCTEwM3b59mzZv3kwjR44kS0tL4vP5BEDkvm7dujWtW7eOrly5QpGRkVLRRygUkoaGBq1fv14KV5GfjIwMCg0NJW9vb9LS0hJtxjNixAgaMGAAtWjRotBAOz6fT0ZGRqSsrEwqKio0evRoWrhwIbm4uNCpU6fowYMHFBAQQImJiRQcHEwKCgpiVWjMzs4mAwMDmjJlisTXExgYSKqqqjRixAiJPv8HDx5Q/fr1icPhkIODQ5EllkvCf5cOtm/fLjIMv337JqoCx+VyaeLEiRIH1F64cIEAiLJaIiIipKq/LIiPj6eePXsSh8OhZcuWSVzF7r/07t2brK2tyzWPX1Lc3NwIAF24cEGifpGRkWRvb08cDofMzc3pypUrYl/37du3SUtLi8zMzIpMhT5y5AgBIGdnZ4l0E5eoqCgCQOfOnZOJ/IrCH28MhMWm0oi9T8l0vhdVX3g5725U/3nlnu+63ov4GnolWs/MTQvMfcIyMTGhNWvWSCUt8FcEAgEFBweTp6cnLV68mHr27ElGRkaiCVBZWZmaNm1KDg4OtGvXLnry5Aldv369RJH34tKoUSMaO3as2O2zs7MpMjKSXr16JQq0W7duHU2fPp2GDBlCbdu2pTp16hSaDy8vL0/169enzp07iwLtNm/eTMeOHaPbt2+Tv78/xcTEkEAgoI0bNxKHwynWuOvZs2ehQYMFMX/+fNLU1Cx2zbMgjh49SgDowIEDxbaNjIykESNGEABq0qSJzIPQfl06sLa2pkePHonOnT9/XvSdKCkpkbOzs9ixLqtWrSItLS3asWMH8fn8Mi/EVFIEAgGtWrVKlOVTGm/h5cuXCYBMApJlRW51wsqVK4t1L0tNTaWVK1eSiooK6ejokKurq0RBxTt37iQej0edOnUqsNhYLk+fPiUFBQUaM2aMzIwroVBIysrKUo8bq2j80caAx7NQMlt8pVgj4L8vk38uUNV/ztPxpyFijxUQEEAzZswQuZi7detGFy9elMrNLi0tjZ4/f07u7u40ZcoUatGiBamqqoomRX19feratSvNnz+fTpw4QR8/fixw3MOHDxMgu4pvw4YNoxYtWtCPHz/o7du3dPPmTTpy5Ag5OzvTnDlzRIF2lpaWxQbatWvXjuzs7GjmzJm0fv16OnjwIF29epXMzMxE2/Z6eXmJpdeHDx9IQUGBZs+eXWS73GBRSZY6AgICCAB5eHiI3edX7O3tSVlZudB1zqysLNq8eTOpqalRpUqVaN++faV+MpWEwpYOUlNTydHRUfQdGhoa0vHjx4vVbdCgQdSmTRuaP38+Va1atSwuQapcu3aNtLW1qVq1avTq1asSycjJySETExOJDOeKQG51wp49exY68QoEAjp69CgZGRmRnJwczZ49WyLvUVZWFk2ePJkA0LRp04pcroyIiCADAwNq3ry5zAOv69atK7VUxYqKuPM3h4gIxZCUlAQNDQ0kJiZCXV29uOYyxfVuEJxvBJZazpzOZpjarlaB53JycnDx4kXs3LkTt2/fho6ODsaNGwcHBwdUr169ROP9+PEDvr6+opefnx8+fvwIgUAALpeL2rVrw9raWvSysrKCnp6eWLJXr14NFxcXfP/+XSKdiAiJiYmIjo5GVFQUoqKi8vw/931QUBCSk5Pz9VdTU4O+vj709PSgr68vev36Xk9PD7q6ulBQUChUj9u3b6Njx47o0qULPn78iE+fPoHH4xWpu0AgQMuWLREXFwdfX18oKSkV2C49PR0WFhaoVasWrl27Bg6HI/bn06pVKygpKeHGjRti98klNTUVDRs2hLy8PJ4+fZpHv7t372Lq1Kn4+PEjHB0dsWrVKmhpaUk8RmkRCATYu3cvFi5cCKFQiNWrV2PSpEng8Xh4/fo1RowYgffv3wMAbGxs4OzsjPbt2xcoq06dOujSpQtiYmIQHh6OBw8elOWlSIWQkBAMGDAA79+/x+7duzF69GiJZaxatQrr169HZGQkNDQ0ZKClbLh06RJ69+4NNzc3TJw4Mc+5R48eYdasWXj27Bn69++PjRs3okaNGmLLjouLw6BBg/DgwQPs2LEjn/xfSUtLQ5s2bRAdHY3nz5+LfQ8sKT179gSHw8GlS5dkOk55Ivb8LU3LQtZ4PAst8Ilff/QWUmvQg+QqmRBHToF46pVJuU5LMpzoVqSn4MSzvMFSX79+peXLl5OhoSEBoGbNmtGRI0ckchULBAIKCAigkydP0oIFC6h79+4ieQBIRUWFmjdvTpMnT6Y9e/bQs2fPJC63+1/GjRuXZzOflJQU+vTpEz169EgUaLd06VKaOHEi9e7dm5o0aUKmpqaFBtpVrVqVmjZtSn369CEHBwfq378/AaAjR47kCbSTFt27dycLCwtSVFQUu7Tv5s2bicPhFFv5b9myZSQnJ0cBAQES67V//37icDgUEiK+J+lX/Pz8SEFBgSZPnkxEP4PMcjdnad68eZ4d2MqTHz9+0IQJE/ItHWRnZ5OzszMpKCiIqh9269aN3rx5k6d/amoqcblc2rt3L7Vq1YqGDx9eHpchFdLT02ns2LEEgCZNmiTxk+nXr1+Jx+PRjh07ZKSh7Jg4cSIpKyuLfiufP3+mQYMGEQBq0KBBiYpVvX//nmrWrEna2tp09+7dItsKhUIaOnQoKSsrl9g7IylTp04lCwuLMhmrvPjjlgnCYlPJbPGVAid15drNiaeiRWq2vUi7mxNptBpBXBVN4sgpksE410KNAbPFVyg0JoVu3bpFAwYMEKUFTpw4UawbdWpqKj19+pTc3NzI0dGRmjVrlifQrUqVKtSjRw9atGgRnT59mgIDA0vsCs4NtHv27BldvHiR9uzZQ6tWraIpU6ZQ5cqVSUdHh2rWrJlnmSH3xefzqUqVKmRra0vdu3ensWPHigLtTp48Sffv36eAgABKSEgo0E34/PlzmRVVef/+PQGgYcOGEZ/Pp2/fvhXbJyAggBQVFWnmzJlFtvv06RMpKChIvNd5LsnJyaSqqkorVqwoUX+i/5VPHTFiBKmoqJCenh4dOnSoQgaZPX36VFQq297eXrR08PnzZ+rUqRMBEJU3tre3p/DwcCL639/Hs2fPyNTUVKrbaJcX7u7uJC8vT40bNy6yfG5B9O3bl+rXr18hv+OiyK1OaGtrS3PmzCF5eXkyNDSkgwcPlui+dfXqVVJXVycLCwuxUjhXr15NAOj06dMlUb9EbNmyhZSVlX+770oS/rhlgpH7fPD4cywEwvzqZkR8gIJBTXB4cqJj2XFfEblvKlTqtEClXnMKlMkBAdGBCDkwG3Xr1sXkyZMxYsSIAt17UVFR8PPzy+PqDwwMhFAoBI/Hg7m5eR4Xv5WVFSpXrlzkNeXk5ODHjx/53PMFuerj4+Pz6s7h/B97Zx0V5fb18e8E3Y1Ki4hKC3YXBtjdgi0qoCJiYFyxxcTCviq2iGICJopNWKAIqJQi0jmz3z98Z35yqQFmAO/ls9asBTMn9jPxnH322QE1NTVoamoiJiYG+vr6GDBgQJlmeyUlJTCZTEHe5jLJyMiAoqIiTp48iTFjxlR7nLKYMWMGLl++DHl5eVhYWOD06dMVtudwOHwzYnh4OKSlpctta29vj/DwcLx9+xYyMjLVkm/q1KkICgrCx48fq/Ue3rx5E8OHD0dWVhYcHBywdevWem0+5h0dLFmyBETEPzpgMpk4ceIEnJ2dkZubCzabjaKiIjg7O6Nx48aYP38+MjIyoKSkhF27dmHmzJl1fSk15unTpxg+fDhyc3Nx+vTpco9I/sn169fRr18/PHr0CO3atROxlMKjuLgYy5Ytw4YNG8Bms7F06VIsWrSoyr8dIsL27duxYMEC9O/fHydOnKh03bh06RKGDBkCT09PrFy5sgZXUTV48yYnJ4v8SKKuEHT9ZteiTNUmJiUL9z98L/d1Sa0WpZ4TU24CcVUdFH3/XG4/AgPQaI6TV4Mxul83MBgMcDgcvHv3rsSi/+rVK6SkpAD4dU5uYWGBXr16YeHChbCwsECrVq0gKSkJAOByufjx4weSk5MRERFRalH//e9v377hn7qYkpJSiYXcwsKizLN4VVVVsNlscLlcSEpKYvbs2ZgzZ0513t5KUVBQgLq6OqKja+6r8Tvfv3/HsWPHMG7cOBw8eBD79u2rtM/OnTsRGhqKu3fvVqgIBAQE4MqVKzh//ny1FQEAcHBwwMGDBxESEoKePXsK3C8hIQGurq44f/48OnTogLi4OLx586ZCmesDLBYLM2bMwLBhw7BkyRI4OTnh4MGD2L17N8aPH4++ffvC1dUVx48fh56eHrZv3w4igqqqKlJTU8HhcKCjo1PXlyEUbGxs8Pz5c4wdOxa9e/fGunXrsGjRokr9Tvr06QNdXV3s27fvj1EGbt68iQULFiAqKgrm5uaIjIxE3759q/zbKSwsxOzZs3Hw4EG4ubnBy8urUv+fiIgIjB8/HsOHD8eKFStqchlVRl9fHwDw6dOnf60yICh/hDJwIiwBLCajTKtAeRAROLk/IaZa8Y2JyQDOvUzBHf+ZePXqFSIjI5GXlwcA0NHRgbm5OaZNmwYjIyM0atQILBaLv5v/+PEjQkNDSyzwKSkpKC4uLjGHrKxsiQXeyMiozAW+Mke7skhKSkJRURH09PSq1K+qGBkZCV0Z2Lt3LxgMBr5//w5jY2N07dq1wvYxMTHw8PDAvHnz0Llz53Lb5eXlYf78+bC1tcWQIUNqJGP79u3RvHlzHDp0SCBloKCgAJs3b8batWv51pTRo0fjyZMn6NSpE5YvX47169fXSKbaQFVVFQcOHMDUqVMxZ84cdOjQAQ4ODli/fj2OHTuG8ePHY+bMmeByuRAXF8e3b9/QpUsXAICWllYdSy88VFVVce3aNaxYsQKLFy/G48ePceTIkQp3WEwmE9OmTcPatWvh7e0NRUXF2hO4irx9+xYLFy5EYGAgOnfujKdPn8LCwgKdOnXC+PHj8erVK8jKygo01rdv3zBs2DCEhYXh6NGjmDhxokB9Bg4ciGbNmuHIkSM1smBWh9+VgT9FcRMVf8QxQddNIYj/kVulPtlRIUi7sgUq/eZB1rxPhW2L0hMhdn0tNDU1oaCgAHFxcXA4HP4OPyUlBfn5+SX6SEhIlOtB//v/GhoaNdqZVsbDhw/RqVMnREZGwsTERGTzODo6IjIyEk+ePBHKeAUFBdDV1YWtrS1OnjyJzZs3Y/78+eW253K56Nq1K5KSkhAeHl7he7py5Up4eXkhKioKRkZGNZZ148aNWLFiBZKSkir0+r927RrmzZuHuLg4ODs7Y8WKFZCTk+O/vmnTJri5ueH69euwtbWtsVy1BYfDwYEDB+Dh4QEiwtq1azFjxgzk5+fD09MTW7ZsgaqqKlRVVfHu3TtYWFhg69at6N69e12LLlT8/f0xceJEaGpq4sKFC2jVqlW5bZOSkqCjowNvb284OTnVopSC8f37d6xcuRJ79+6Frq4uNm7ciKFDh/KtHjExMbCwsMC4ceOwf//+SseLiIjAwIEDkZeXh0uXLqF9+/aV9iksLESvXr3w/v17PH36tM4sSioqKliwYAE8PDzqZH5RI+j6XbtqWDXILihGQhUVgaK0z/hxaw8kmhhDxrTy3RxbsRESElPw/PlzREVFITExEQwGA61atcLYsWOxYcMGnD59Gnfu3MG7d+/w8+dP5OXlIS4uDo8fP8alS5ewb98+rFq1CrNmzcKQIUPQoUMHGBgYiFQRAID4+HgAgK6urkjnadasGaKjo0sda1SXU6dOISUlBcrKyhATE6t0F7Fr1y48ePAAhw4dqvA9/fjxI9avX49FixYJRREAgAkTJqC4uBh+fn5lvv7p0ycMHjwY/fv3h46ODsLDw7Fp06YSigAALFiwALa2tpgwYQKSkpKEIlttwGKxMHPmTERHR2P48OGYM2cObGxsEBERARcXFwCAvLw83r9/DzabDTabjR49emDAgAGIjIysY+mFx6BBg/Ds2TOIi4ujbdu2Ffq3NGrUiB+qJ6zfjDAoKCjAli1bYGhoiOPHj2P9+vV48+YNhg0bVuL4o1mzZti2bRsOHDiAy5cvVzimv78/OnToACUlJTx9+lQgRYCIMGfOHISFheHixYt1erRkYGCA2NjYOpu/3iBMb0RREPX1Z5USC2k5HSe2oiax5NWoyZyjAvd78DquVpO+CIu1a9fWSuWt8+fPEwCBK+dVBJfLJVNTU+rfvz/p6OjQlClTKmwfExNDUlJSAiUHsbOzIx0dHaEnYLK3ty9V7jQ3N5dWrlxJkpKSpKWlJVCp1pSUFNLU1KSePXv+MVn6/smjR4/IysqKn48eAMXExFDHjh2JwWCQjo4OeXh4kKGhYanIg38D2dnZNHbsWAJALi4u5Wbg42UG/T3LY13B5XLp/Pnz1LRpU2IymTRr1qxKf8tcLpcGDhxYbnZCLpdLXl5exGAwaOjQoVX6zW3fvl3gLJ2iZsSIEdSjR4+6FkNkCLp+13vLQGExV+C23PwcpJzxBDc/B+ojV4EtpyJwX2lZ+Vo/rxIGcXFxIrcKAL92CgCE4jcQFBSEyMhIdOzYEQkJCZg1a1a5bblcLhwdHdGoUSOsW7euwnF5ToPbtm0TukXG0dERz549Q0REBH+uVq1aYe3atXB2dsbbt28xYsSISp3L1NXV8ffffyM4OPiP8B0oi3bt2uHJkyfw8fHB/fv3AQA3btyAsrIyunbtiubNm8PLywtWVlZYu3Ytrly5gmbNmmHJkiXIyMioY+lrjoyMDP7++2/s2LEDO3fuRM+ePZGcnFyqXa9evWBgYCCQY6woefHiBbp3745hw4bByMgIERER8PHxqTTaicFg4MCBA2AwGHB0dCxh4cjPz8eECRPg4eGBZcuW4ezZswL/5m7dugUXFxe4urpi8uTJNbk0oaCvr49Pnz7VtRh1Tr1f/cTZgolIxYVIPbcaxelfoT5iBcQrcRz8J+vWrsGOHTtw9+5d/Pz5sxqS1g3x8fEidx4EAENDQwDCUQa8vb1hbm6Ohw8fwsrKCtbW1uW29fHxwb1793Dw4MEKbzZ5eXmYN28ebG1tMXjw4BrL+E/69+8PdXV1bN26FXZ2dnynp8jISKxbt05gJysA6NmzJ5YuXQpPT088ePBA6LLWBiwWC7NmzULfvn2hrq4OJycn3L59G0pKSrhx4waOHTuGoKAgbN68GatXr8aCBQuwY8cONG3aFNu3b0dBQUFdX0KNYDAYmDt3Lu7cuYMPHz7AysoKDx8+LNGG50h45syZUqHBtcHXr18xefJkWFtb49u3b7h+/ToCAwMr9HX4J+rq6jh48CCuXr3K9x1ISkpC165dcf78efj5+WH16tUCb6Sio6MxcuRI9OnTBxs3bqzWdQkbfX19JCQklHL8/q9R75UBPRUZVJZAlrgcfLu0AQWJ76A22B0STUqHGlY8AOHDy0dwc3NDt27doKSkBF1dXQwcOBDLly/HuXPnEBMTAy5XcCtFbREXF1cryoCUlBR0dHQQExNTo3Hevn2LwMBATJgwAdeuXcOsWbPK3U3HxsZi8eLFmDNnDrp161bhuLwUsDt37qxSymFBKSoqgoGBAY4ePYqIiAhcuHAB169fR/Pmzas1nqenJ9q3b4+xY8fix48fQpa29oiOjsawYcPw6NEjFBYW4uLFi5g2bRr69u2Lt2/fol+/fpg1axbCwsJw69YtDB06FK6urmjRogX8/Pzq5W+qKnTs2BEvXryAoaEhunXrhh07dpTYQU+ZMgXFxcU4duxYrcmUk5ODVatWwcjICFevXoWPjw/Cw8Or7bRqZ2eHGTNmwNXVFRcuXICNjQ2+fPmC+/fvY9SoUQKP8/PnTwwcOBCamprw8/OrNOSwttDX1weHw8GXL1/qWpQ6pd4rAzISbOgoVxybnR58EHkfwiBl0BqcvGxkR4WUeFSGroo0Xjx5hKysLERFReHEiRMYPXo0CgsL4evrixEjRsDIyAjy8vJo3749Zs6ciT179iA0NLTMnP21BZfLRXx8fK0cEwD/cyKsCdu2bUOjRo3w7ds3yMnJlZvEiHc8oK6uXqk5/ePHj9iwYQMWLVrEP84QFkSEixcvomXLlnj+/DkAYN26dRgyZEiNlA42m42TJ08iJycHDg4O9crJTFAKCgrw7t07mJmZwcTEBBwOB5MmTcL58+fRvHlznDt3DkePHsX169fx4cMH9OrVC4aGhnj58iVMTEwwZswYtG3bFiEhlf9G6zOampoICgrC3LlzMX/+fIwfPx45OTkAAA0NDQwePLhWHAm5XC6OHTvGP6aZM2cOPnz4gJkzZ4LNrlkU+ZYtWyAvL48RI0agUaNGePr0aYUWvX9SXFyM0aNHIzU1FZcvX65Xibd+Dy/8TyNMBwRR4ekfVWGFQgltkzJL4fIelVUy1BrkQqtXry43FW5KSgrdvHmTNm3aROPHjydTU1Nis9n88Zs2bUpDhw6lVatW0aVLl+jTp0+1kt4yKSmpWrXIq8usWbPI1NS02v1TU1NJUlKSVq9eTerq6uTk5FRu2927dxMACgoKqnBMLpfLd0QUZr0Eol9pj3kOcgMGDKCYmBhq164d9evXT2hz+Pv7EwDasWOH0MasLV6+fEkAKDQ0lJ9W+u7du5SamkqOjo78nPaPHz+m7OxscnV1JSaTSRYWFvTs2TO6e/cuv1Jl//79S9U8+BPx8/MjGRkZMjExoejoaCIiunXrFgGg+/fvi2zee/fu8atQDh8+XKD0v4LC4XDI09OTABCDwahWumkXFxdisVh069YtocklLPLz84nBYJCvr29diyIS/lW1CaKTM6sUUVDVx9iZriQtLU1iYmI0evRoun//fqWLeX5+Pr18+ZKOHDlCLi4u1KNHD1JRUeErCAoKCtS5c2dycnKiAwcO0JMnTyg3N1eo78ujR48IAIWHhwt13PLw9vYmKSmpakddrF69mqSkpMjX15cAUFRUVJntYmNjSUZGhmbNmlXpmLzF9MKFC9WSqSyys7PJ3d2dxMTESF9fny5fvsx/bf/+/cRkMoXqHT9//nwSFxen58+fC23M2uDo0aMEgDIzM+n69esEgD59+sR/PTQ0lCwtLQkAOTo6UmpqKj19+pQsLCyIyWSSq6srZWVl0dmzZ/9VkQdRUVFkZGRE8vLydOnSJeJwONS0aVMaP3680Of6+PEjDRs2jACQtbW10BWO7OxsGj58OAGgtWvX0sqVK4nFYlFoaKjAYxw8eLDeK7xaWlq0dOnSuhZDJPyrlAEiovG+jyu0DlTnYeBxlcb7PiYiovT0dPL29qZmzZoRADIzM6P9+/dXKVyGy+XSly9f6OrVq+Tl5UWjRo0iY2NjYjKZBICYTCYZGxvTqFGjyMvLi65evUpfvnypthXh1KlTBIB+/vxZrf5V5cqVKwSgyoVbiH5Vg1NXV6eZM2dSt27dqHPnzmW243A41L17d9LV1aXMzMwKx8zNzSU9PT3q27evUCwxXC6XTp8+TVpaWiQpKUmrVq0qpcBlZGSQtLS0wNUVBSE/P5+srKyoWbNmlV5zfWLBggVkYGBARL8K+zAYjFJhdsXFxeTj40OKioqkpKREe/bsoby8PNqwYQO/Qub169epoKCAdu7cSWpqaiQpKUlLliypte+1KMjIyKAhQ4YQAPLw8KB169aRhIQEff/+XSjj//z5kxYtWkTi4uLUpEkTOnbsmNBDoxMSEsjS0pJkZGT4ynZRURG1a9eOmjZtSllZWZWO8eDBAxITE6Np06bV62JAnTt3prFjx9a1GCLhX6cMVFS1sLoPo2WBlJBW0rTM4XDoxo0bNHDgQGIymaSgoEDOzs58k191yMnJoSdPntCBAwfIycmJOnfuTPLy8nwrgoqKCvXo0YNcXFzoyJEj9PLlS4FKp65fv54UFRWrLVdViY6OFsh0XxaHDh0iAHT16lUCQCdPniyzHa/K3+3btysdc8WKFSQuLl6jz4bHmzdvqGfPngSABg0aRLGxseW2nTRpEjVt2lSoN7fo6GiSlZWl8ePH1+ub5u/06tWLBg8eTEREy5cvpyZNmpTbNjU1lV8amHd08OHDB/57Pm7cOEpNTaWMjAxatmwZSUlJkYqKCm3bto0KCgpq65KECpfLpQ0bNhCTyaSuXbsSm82mrVu31mjMoqIi8vHxIVVVVZKWlqZVq1YJ/XiM6JfVUUNDg3R0dOjVq1clXouJiSEZGRmaOnVqhWPEx8eTuro6denSpd5/hhMnTqT27dvXtRgi4V+nDBARnXoSL1RlwO9JfIXzffr0iRYvXsw3//fp04f8/f2FkiyGy+XSp0+f6NKlS7Rq1SoaOnQoNW3atETZYVNTUxo/fjxt2rSJbt68yS8py2PmzJlkYWFRY1kEpbCwkFgsFu3Zs6dK/XhJhuzs7Gj+/PmkpqZWprLz6dMnkpWVpenTp1c65ocPH0hCQqLGpr3MzExauHAhsdlsMjQ0pMDAwEr73L17lwDQnTt3ajT3P/n777/rTSIWQVBXV6cVK1YQ0S8FSZCb6e9HB1OnTqXU1FQ6cuQIKSsrk4qKCr+889evX2nq1KnEZDLJwMCATp069UcmBSMiCgoK4i/eOjo61Vb2rl27Ri1btiQGg0GTJ0+mL1++CFnSXxw7dowkJCSoY8eOpe45PPbv31+hv1JWVhaZm5uTnp4effv2TSRyChNPT0/S1NSsazFEwr9SGSAi2hkcLRRFYFdwjMBz5uXl0dGjR/nOTrq6urR+/XqRfMkzMzPp4cOH5OPjQzNmzKB27dqRjIwMX0nQ1NQkW1tbcnNzIzMzM+revTsVFRUJXY7yaNasGbm4uFSpD8+BKjAwkBQVFWnx4sWl2nC5XOrZsydpa2tX+j0ThtMgl8ulEydOUKNGjUhKSorWrl0rkDWG19fQ0JAmTpxYrbkrYsqUKSQtLU1v374V+tjCJDk5mQDQuXPniIioe/fuNGrUKIH6FhcX0+7du0scHSQmJvKz+vXu3ZvvAPf69Wuyt7fnn4kHBweL7JpESUJCAhkbGxMAWrhwYZX6RkVFUd++fQkAde3aVWS+JRwOhxYvXkwAaPLkyRX+HnjZCVVVVUs5XnM4HBo6dCjJysr+MU6hPP8XUVhZ6pp/rTJA9MtCYLQssMo+BAYeV8loWWClFoGKePLkCU2aNIkkJCRIQkKCJk6cSE+ePBHi1ZWGw+FQdHQ0nT17lpYtW0b29vako6PDVxAkJCTIysqKpkyZQtu2baOQkBD68eOHSGQZMGAA2dnZValPv379yMLCgg4ePEgMBqNMT+d9+/YRALpx40al49XUaTAiIoK6dOlCAGjYsGEUH1/178PatWtJSkpK6L+J7OxsMjY2JjMzM6E7nAqTmzdvEgD+EU3Tpk2rvMilpKTQlClTCAC1bt2awsLCKDAwkHR1dUlKSoo2bdrEV3T/GXkQGRkp9GsSNXl5eaSgoMB3qMzLy6uwfWpqKs2aNYtYLBY1bdqULly4ILIjpMzMTLK3tycGg0GbN28WaJ6UlBRSV1en/v37l2i/YsUKYjAYdOnSJZHIKgru3btHAOj169d1LYrQ+VcrA0S/fAjG+z7mL/IVKQH67gGk636Fxvs+LuUjUF2+fftGGzZsID09PQJANjY2dOTIkUp/4MKCy+WSpKQkzZkzh7Zv304ODg7UunVrkpCQ4CsJ2traZGdnR0uXLqUzZ87Q+/fva3zE4ezsTEZGRgK3f/36NQGgY8eOkY2NDfXt27dUm7i4OJKVla30DJKoZk6DP3/+pPnz5xOLxaLmzZvTzZs3q9T/dz5//kxMJpP2799f7THKIzw8nCQkJGj27NlCH1tYbN68maSlpYnD4RCHwyFxcfFqe4uHhoaShYUFMRgMmjp1Kn369ImcnZ2JyWSSlZUVfyfM5XLpzJkz/Pz6Dg4Of1zkwaZNm4jFYpGkpCS1bt26RPQFj/z8fNq4cSPJy8uTgoICbdmyRaRn7rGxsWRiYkLy8vJ09erVKvXlORXzjg7PnDnDjzz4k/j8+TMBoCtXrtS1KELnX68M8IhOziRP/yjqsimY9P6hBOi5XyE9pyPUcd42ikkRjZd2cXExXb58mWxtbfnOgG5ubmX+yIVJSkpKmbvjoqIievPmDZ06dYrc3d2pX79+1LhxY76CIC0tTW3btqXp06fTrl276P79+1X6XH18fIjNZgt8NDFt2jRq1KgRPwzyn2eMXC6XevfuTVpaWgJ5j1fHaZDD4dCRI0dIXV2dZGRkaMOGDUK5ufbr14/atWtX43HKgudIyTPD1zcmTpxIbdu2JaL/5buoyU6wuLiYdu3axT862Lt3Lz169IjMzMyIxWLRwoUL+SZcXuSBqqrqHxd58O3bNxIXFycXFxfS19cnZWVlun79OhH9+i2cPXuW9PX1icVikZOTk8jP2+/evUuqqqrUtGnTau+KZ86cSdLS0nThwgWSkpKiMWPG/DFOsDx4Cu3OnTvrWhSh859RBn4nO7+Ior7+pBfxPyjq60/Kzi+iRYsWkbq6eq04H0VHR5OLiwspKioSg8Ege3t7un79ukjmfvLkCQGgFy9eCNQ+NTWVbt++TVu2bKGJEyeSubk5iYmJ8ZUEfX19Gjx4MHl6etKFCxfo48ePZf6gb9++za9SJ8icEhIStHbtWpo6dSppa2uXskwcOHCAANC1a9cqHS8mJoYkJCRo2bJlAl0z0a/EOB06dCAANHr0aKHuJM+ePSsy0yKXy6Xhw4eTgoKCyBXL6mBhYUHTpk0joqp/Fyvi96MDa2trevjwIa1bt44kJSVJX1+/hDUnIyODli5d+sdFHowZM4aMjIzo+/fv1K9fP2IwGDRz5kzq2LEjP8HVmzdvRC6Hr68viYmJUffu3WsU8pidnU36+vokJiZGrVu3rtfHWxXRrFkzcnV1rWsxhM5/UhkoC95Z0OPHj2ttzuzsbDpw4ACZm5sTAGrWrBl5e3tTenq60ObgmeNq4htQUFBA4eHhdOzYMVqwYAH16tWL1NTU+AqCnJwcdezYkWbPnk379u2jx48f07t37/ghgpXBSzIUGxtL0tLStHr16hKvx8fHk5ycHDk4OFQ6FpfLpX79+pGurq5ATj4/fvygOXPmEJPJpJYtW4rE8aygoIBUVVWrfFYuKOnp6aSnp0ft2rUrt0xuXVBYWFhiF3Xu3DkCILQYeiKihw8f8o8Opk2bRmFhYdSjRw8CQBMmTCixY/7y5UuJyAM/P796HXlw584dAkDBwcEUHx9PZmZm/N+bMJNnlUdRURE5OzsTAJo5c2aNv1t5eXlkYvIrC+z8+fOFI2Qd0KdPH36o7L+JBmXg/ykqKiIlJaUq7SaFBZfLpQcPHtCYMWNITEyMpKWladq0aaXidqvDxo0bSU5OTujmOC6XS4mJiXTt2jVav349jRkzhlq2bEksFoufjpTBYJCFhQX99ddfFBAQQAkJCaXk4CUZmjVrFu3cuZNYLBYlJiaWmMfW1paaNGkikJJ06dIlAkAXL16ssB2HwyFfX19SVVUlOTk52rp1q0gXUmdnZ1JXVxfZHI8fPyY2m11mBEZdERkZyU89TES0detWkpaWFvp3kXd0oKCgQMrKyrRnzx7y9fUlJSUlUlVVpePHj5eY85+RByEhIUKVR1hwuVxq1qwZtWrViqSkpPipuRUVFalp06YizSianp5Otra2xGKxaPfu3TUej8vl0sSJE0lCQoKmTZtGTCazStkJ6xMzZ84kc3PzuhZD6DQoA78xbty4Ov+Qk5KSaM2aNdSkSRMCQB07dqRTp05V26w5Z86cGtUJqCp5eXn07NkzOnjwIKmoqFDjxo1JUVGRb0VQVlambt260fz58+nQoUP8XObv3r2jli1b0rBhw0qMx0tRKoiFIScnh3R1dalfv34VLjhPnz6ltm3bEgAaP358CeVDVERERAikpNSEjRs3EgD+2XJdc+LEiRJWKWdnZ2revLnI5ktJSaHJkyfzF/lr167R6NGjCQDZ2tqWShB1584dsrGx4Zvc61PkAc9/hZd0bN68efz76sePH8nCwoKkpKTo+PHjQp/7/fv31Lx5c1JUVBRajYBNmzYRADpx4kSJ7IR/UiZNHhs2bCB5efk/zt+hMhqUgd/gpe2tThpdYVNUVETnzp2j7t27EwDS0NCg5cuXVzmByIABA8je3l5EUlbM0KFDqVevXsTlcik+Pp4uX75Ma9asoeHDh1OzZs2IwWDwrQj6+voEgKZNm0bXr1+npKQk+vz5M8nLy9PkyZMFmm/58uUkLi5erp/C9+/facaMGcRgMMjMzIzu3bsnzMutFGtra5F+FhwOh2xtbUlNTa1WFJzKWLx4Meno6PD/Hzp0KPXu3Vvk8/7z6ODkyZOko6ND0tLStHnz5hJOrfUx8uDOnTtkZWXFz3IpLi5OGzduLNEmJyeHJk2aRADIyclJaD4Qt27dIkVFRWrevLlQMnYSEV29epUYDAa5u7vzn/vw4QPJyMiQo6OjUOaoTXhHr2lpaXUtilBpUAZ+Iz09ndhsNvn4+NS1KCV4/fo1zZkzh2RlZYnFYtGwYcMoODhYIM20VatWFVb9EyXu7u6kq6tb7uu8PAAuLi5kaGhIkpKSJCsry7ciiIuLk4SEBDk5OdHx48cpIiKiXDN7TEwMiYuLl3nMU1xcTHv37iVlZWVSUFCgHTt21GoCJh4+Pj6ljkGETUpKCmlqalLPnj2FkgGzJvTr169Erglra+tau/kXFRXRzp07+UcH27dvp7lz5xKDwaDWrVuXcmIsKCigHTt21GnkQUxMDL9OQZs2bejhw4dE9MtiaWhoWMq/gcvl0p49e0hMTIzat29fo0yDXC6Xdu3aRSwWi2xtbYXmt/TmzRuSl5cne3v7UvLznIJFaS0TBU+fPiUA9OzZs7oWRag0KAP/oHv37tS/f/+6FqNMMjIyaNeuXdSiRQsCQC1btqTdu3eXa2rjcrkkKytLmzdvrmVJf8FLHlSe13Dfvn3JwsKCkpOTSUxMjLZs2UIcDoc+fPhAc+bMIQDUrl07fo4GnoJgYWFBkyZNoq1bt1JQUBB9+/atXKfBx48fU+vWrfnZ0pKTk2vj0sskPT2dJCUlacOGDSKd5/bt28RgMOivv/4S6TyV0aRJE/Lw8OD/r66uTqtWrapVGZKTk/lHBzY2NnT48GEyNTUlFotFbm5upb4v/4w82L59u8gjD9LT02nBggUkJiZG2tradOLEiRILJ8+5ubw6HI8fPyYtLS1SV1evlv9DYWEhzZw5kwCQs7Oz0BTltLQ0atq0KbVq1arMexSXy6VBgwaVmZ2wPvP9+3cCQGfPnq1rUYRKgzLwD7Zs2UISEhJVqkJY23C5XAoODqZhw4YRi8UiOTk5mjNnTqkwI96Xtq5i0O/fv08AyjyL/T3J0Pr160lCQoJvdvvy5QspKCiUSOP78+dPunfvHu3cuZOmTp1KNjY2JCUlxVcSeNnplixZQn5+fvTw4UP+ImBpaVlvnJXGjh1LzZs3F/l547Jly4jFYgm9VK2g8L57fn5+RPTLlwSou3oKDx48IHNzc37ComXLlpGEhAQZGBiUeS5eVuSBsD+zoqIi2rVrF6moqJCMjAytWbOmzAgYLpdLLVq0oBEjRpQ7VkpKCnXv3p1YLJbAmQGJfn1O3bp1IzExMTpw4EC1r+WfFBYWUs+ePUlFRaXMTKI8UlNTSUNDo1R2wvoMl8sleXl5kSv1tU2DMvAPeBX3/pQUmZ8/f6Zly5aRhoYGAaAePXrQ+fPnqaioiJ49e1an5qzyEh4R/S/JUF5eHunr6/MXfi6XSwMGDKBGjRpVGg5ZXFxML168IFVVVTIwMKD+/fvzHS95D11dXXJ0dKSdO3fSvXv36jzpTFBQEAHgm4BFRVFREXXq1Im0tbXr5GwzODiYAPAV1JiYGAKqV8lSWPzz6GD16tXUtWtXAkCTJk0qM+QxKiqK7Ozs+JYFYUQecLlcunr1KrVo0YIYDAY5ODhUenTk7e1NbDa7QstWUVERv2bA8OHDK3XOe/36NRkYGJCqqio/4kNYzJkzh9hstkBFunjZCevb8WxFmJub08yZM+taDKHSoAyUgZGRkUApb+sTBQUFdPLkSX5CEi0tLRozZgwBqLNqYDwNev369SWe5yUZ8vLyosDAQAJAjx49IqL/FQK5fPmyQHP87jT44MEDsrCwIOBXXvo1a9bQ5MmTydLSksTFxfkKgp6eHg0aNIhWrFhB58+fpw8fPtRavDmHwyE9PT2BcibUlISEBFJWVqZBgwbV+q5r27ZtJCEhwTc585QgQZJQiZrk5GS+852NjQ0tXbqUFBUVSU1NjU6cOFHmeyWsyIPIyEjq3bs3AaDu3bvTy5cvBeqXlpZGEhISpX5LZXH+/HmSk5MjY2PjcpMSXb16leTk5MjExKTCMtzVYe/evQSA9u7dK3CfmTNnkpSUFL17906osoiKwYMHk62tbV2LIVQalIEyWLBgAWlqatbrhCQV8fLlS5o6dSo/c+DYsWPp4cOHdWKGs7a2LrXwrVq1iqSlpSktLY0GDhxIFhYW/HK0ioqKNH78eIHG5jkNuri40MSJE/k397CwsFJtCwsLKTIykv7++29atGgR9enTh29NAUCysrLUvn17mjlzJu3Zs4dCQ0MpKytLKO/BP1m1ahXJyMiIbPzf4TlpVrceQHVxcHAgKysr/v+HDx8mALVWk0MQfj86mDBhAg0aNIgAUN++fcvM5sjlcun06dMlIg8EddpLSUmhGTNmEJPJpGbNmpG/v3+Vf48TJkwgAwMDge5LvFBdWVnZEmfbXC6XNm/ezM98KuzQvpCQEGKz2TRnzpwq9cvOziYjIyOytrauV4mzysPFxaVKtVf+BBqUgTIICQkhAPT06dO6FqVGTJs2jTQ0NMjQ0JAAkIWFBR04cKBWy2+OGTOGOnfuzP+fl2Ro9uzZFB8fT0wmk/bu3UtcLpfs7OxIQ0NDILM2LxmRkpISycvLk4qKCu3fv7/KClxycjLduHGDNm7cSOPGjSMTE5MSiZMMDQ1p2LBhtHr1avL396e4uLgaK1VxcXHEYDDo0KFDNRpHUObPn0/i4uIiK2lbFtbW1jRlyhT+/6tWrSJ1dfVam19QioqKaMeOHSQvL0/Kysrk5ORETZo0IWlpadq6dWuZERm/Rx5ISUmRh4dHucdPeXl5tH79epKTkyNFRUXy9vautkPigwcPCIDAhbOysrJo5MiRBPwqh5ydnc33o3F3dxd6tMnHjx9JRUWFevToUa0F/cmTJ8Rms+sk8VtV2bFjB4mLi/+xG8ayaFAGyqCwsJAUFRVpxYoVdS1KjRg4cCD179+fOBwOXbt2jezs7IjBYJCioiK5urrWisnW09OTNJro8GtBrPU5SkxxKXr//j0tX76c5OTkKDMzk44fP14lX421a9fyF+xZs2YJ9Vw8Pz+fXrx4QYcPHyZnZ2fq3r07KSsr860IioqK1KVLF5o7dy75+vrS06dPq5xnvXfv3tSpUyehyVwR+fn5ZGVlRc2aNauVJC/FxcUkKSlJ3t7e/OccHR3J2tpa5HNXl+TkZL51qXXr1jRy5EhiMBhkbW1dbibQiiIPeFYEPT09YrPZNG/evBqnYeZyudSqVatSibkq67N161ZisVgkLy9PYmJidOzYsRrJURaZmZlkYmJCTZs2rdFvcfXq1cRkMkXuU1NTAgICCECd56QQJg3KQDmMGTOmhJnzT8TMzKxUedvY2Fhyc3MjFRUVvkn0ypUrQt8l8KpEWq7wJ53FASXLRS8OoM4bg0hrkAuNn7OIEhMTSUlJicaOHVvpuF+/fuXvdhQVFWvNOZLL5dLnz5/pypUrtHbtWho5ciQ1b96cnziJyWRSixYtaPTo0bRu3ToKDAykr1+/lmtF4CW4ev/+fa3IHx0dTbKysjR+/HiRHxfx6lL87izYp08fGjp0qEjnFQb3798nMzMzYjAYNHjwYDI2NiYWi0WLFy8uV+H78uULOTo68iMP/vrrL37RK3t7e6Geg+/YsYPYbHaVQvFevXpF6urqxGQySU1NTeiRNcXFxWRvb0/y8vI1LpxUVFRE7du3JwMDg3qdnZAXDVXbictESYMyUA68VKo1SeRR18jLy5fKXMYjNzeXjhw5QtbW1gT8qka4cePGGu9eEtJyaLzvY9J1v0IGHldLKgH/eOi4+ZOu+xVq5bSHNAxaVjh3YWEhbd68mWRlZUlaWppYLFatLaQVkZOTQ2FhYbR//36aM2cOderUiZ9CFgCpqqpSz549ydXVlY4ePUqvXr2igoICysvLIyUlpRJZ2UQN7zst6vC+06dPEwBKTU3lP2dsbEzOzs4inVdYFBUV0fbt2/nHT4MHDyZxcXFq2rRphdEQt27d4kezSElJiSS/x48fP0hSUpLWrl0rUPuLFy+SjIwMWVpa0pMnT6hDhw4kJiZGu3fvFppS6O7uTgwGQ6CU4YLw4cMHkpWVrdfZCXNycggAHT16tK5FERoNykA5pKWlEYvFqpJHbH0iPT2dANDp06crbRsWFsYvIiIpKUmTJ0+ulr/EqSfxZLQssFIloJRSsOgSNV0SQKeexJc5blBQELVo0YKYTCZNmDCBxMTEaPny5VWWr7bgcrkUGxtLFy9epJUrV9KQIUPIwMCAryCIiYmRmZkZNW/enOTk5Oj69eslFk5RMmXKFJKWlqa3b9+KbI6lS5dSo0aN+P9zuVz+GfyfRFJSEv/owMzMjJ8ieMqUKSVM4VlZWbRs2TKSlJQkDQ0NWrhwIV/JHjBgAEVFRQlVrkmTJpGenl6F59VcLpd/lDZs2DB+3pSCggKaN28eAb+qOtbUf+jvv/8mALRp06YajfNPfH196312Qg0NDVq5cmVdiyE0GpSBCujSpUuJdKp/Ei9fviQAZXrWl0dqaiqtW7eOdHV1CQC1bduWjh07JpAH+M7g6CopAOU9dgb/Lx/658+f+UcCnTp1opcvX1K/fv1IT0+vVp0ghUVGRgY9ePCAdu/eTdOnT+eXc+U9GjVqRH379qXFixfTyZMn6fXr10JPm5ydnU3GxsZkZmYmsnry9vb2JcKu/vSMbffu3SNTU1NiMBjUtWtXkpeXJ3V1dTpx4gQdPHiQGjVqRBISEuTh4cE3bfN8BgwMDIjJZJKjo6PQrIyhoaEElF+QKjc3lx9W7OnpWabScOLECZKWliYzMzP68OFDteQICwsjCQkJmjhxokiqog4ePLheZyds164dTZo0qa7FEBqCrt8MIiJUQmZmJhQUFJCRkQF5efnKmtd7Nm/ejOXLlyMtLQ3S0tJ1LU6VuHTpEoYMGYKUlBSoq6tXqS+Hw8HVq1exe/du3Lx5E6qqqpg6dSpmzpwJXV3dUu39nibA/UKksETHXwNb4MvdM1izZg3k5eWxadMmjBs3Dv7+/hgyZAguXbqEQYMGCW2+usTCwgJqamqYPn06wsPD+Y/Pnz8DACQlJdGqVSuYm5vzH2ZmZlBSUqr2nBEREWjTpg0cHBzg4+MjrEvho6enh1GjRmHDhg0AgJcvX8LKygphYWFo06aN0OerDYqLi+Hj44Ply5eDxWJBTU0N0dHRAICBAwdix44dZf42CgsLsW/fPqxevRo5OTlwcXGBm5sbFBQUqi0LEcHc3ByGhoa4cOFCidcSExMxePBgREVF4ejRoxgxYkS540RGRmLo0KH49u0b/v77b9jZ2Qksw9evX2FjYwNdXV2EhIRAUlKy2tdTHt++fYOpqSmsrKxw9epVMBgMoc9RE8aOHYsvX77g3r17dS2KUBB4/RamZvGn8PbtWwJAAQEBdS1Kldm2bRtJSUnVWGN///49zZ8/nxQUFIjJZNKgQYPo5s2b/N1GQloOGS0LJG3Xs6TQcQxJ6lsRU/JXsSGV/s5l7v4bT91DkvpWxBCTJKakLMm06k5a8078r82iiySu3IhcXFz436WcnBzS0dH5o9KWCgLPISwlJaXE82lpaRQSEkLbtm2jKVOmkJWVFUlISPCtCDo6OmRvb0/Lli2js2fPUnR0dJXCnPbs2SOSVNU/f/4kAPT333/zn7t06RIBqLc7vKrw8OFD0tbWJgAkKSlJioqKJCMjQ9u2bavQCffnz5/k4eEhtJoHvKJCX79+5T/39OlTaty4MTVp0kTgMNL09HQaOHAgAaDly5cL5Eicm5tL1tbWpKWlJfLP9OrVq/U2O+HSpUtJS0urrsUQGg3HBBXA5XLJ0NCQpk+fXteiVBlnZ2cyNjYW2njZ2dm0b98+MjMzIwBkZGRE27Zto1F7H5CBx1VqMvMgASCWvBpJ6JiWqww0mX2EmFLyxFZsREq9ppNil4nElJQlMXV90ll08f+jDS7ToG0li7LwcslX16RZX/n+/TuJi4vTli1bKm1bVFREUVFRdOLECXJzcyNbW1tq1KgRX0GQkZGhdu3a0YwZM8jHx4cePnxYYRGr4cOHk4KCQpkJdqoLrx5FREQE/7l/Q0z2jx8/yMXFhcTExEhHR4c8PT35RwetWrUi4FelwfDw8ArH+WfkwenTp6ul3P78+ZOkpaVpzZo1RETk5+dHkpKS1LZt2ypXxeRwOLR27VpiMBhka2tboSMvl8ulMWPGkJSUVK3lrZg1a1a9zE7o6+tLDAaD8vPz61oUodCgDFSCi4sLNW7c+I/bjQ4ePJj69u0r9HG5XC7dv3+fRo8eTZIaev9zAlx4kbScjpOu+xXSnORdrjIga9mfGGwJajLrEP859dF/EQBS7utUom1Myq+FLDo6msTFxeu102BNGDlyJLVs2bLa37GUlBS6desWbd68mSZMmEBmZmbEZrP5SkLTpk1p6NChtHLlSrp48SLFxsYSl8ul9PR00tPTo3bt2gkt69vu3btJTEysxK530aJF1LRpU6GMX9sUFhbSjh07SFlZmWRlZcnLy4vva1FUVETbtm0jeXl5UlBQoMaNGxOLxaIlS5ZU6o/xz5oHguTw/ycODg6kra1NHh4eBIDGjRtXowyPN27cIBUVFdLT0yt3oec5JZ45c6ba81SVnJycepmdkJdiOzo6uvLGfwANykAl8D7w2szeJgwsLCxoxowZIp1j4akw0nMPKLXgV6QMMKUVSdq4U6nn2cpNSFLXnP+/gcdV8vSPIi6XS3379v1jnQYF4fr161V29qyMgoICevXqFR09epRcXV2pZ8+epKqqylcQ5OXlqVOnTjR8+HB+lIYw3t/p06eTmZlZiedGjRpF3bt3r/HYtQmXy6WAgAB+LompU6eWaxJPSkqiCRMm8GuCsNlsMjQ0pODg4ErnCQkJ4dc8sLOzq1LkAS9TKoPBoHXr1gllwxIXF0fW1tYkISFRKkMm77inLpKxPX36tN5lJ4yNjSUAdOPGjboWRSgIun4za+ib8MfSuXNnyMvLIyAgoK5FqRLx8fHQ09MT6RxPPueAILhTT3HWd3Bzf0Jc07DUaxKNjFCYEsv/n8MlhESnwt/fH9evX8f27dv/OCdOQenVqxe0tbVx6NAhoY0pLi4Oc3NzTJw4EVu2bMHt27eRmpqKr1+/IjAwEEuWLIGWlhZev34NIsLx48chJycHY2NjjBo1Cl5eXrh69Sq+fPkCqtx3mE9ERATMzMxKPJeQkAAdHR2hXZuoiYiIQJ8+fWBvbw8tLS28fPkSBw4cgKamZpntNTU1cezYMdy9exdKSkrgcDjIyclBjx494OjoiB8/fpQ7V7du3RAWFobTp0/jzZs3MDMzw9SpU/H169cKZUxISICzszOYTCZsbGzg7u4uFAc7XV1d3L9/HxMnToSDgwNmzJiBgoICREZGYty4cRg2bBg8PT1rPE9Vsba2hqenJ7y8vBAaGlrr85eFtrY2WCwWYmNjK2/8L+I/qwyIiYmhb9++uHLlSl2LIjAZGRlIT08XqTKQXVCMhB+5VerDyU4HALBklUu9xpJVAjc/C1RcxH8uIS0X8xe4YcCAAbC3t6+ZwPUYFouFyZMn49SpU8jNrdp7WhUYDAYaN26Mfv36wd3dHadOncKbN2+QlZWFdu3aQVpaGh07dkRycjI2btwIOzs7aGtrQ01NDT169ICLiwuOHDmCly9foqCgoNT4XC4XkZGRZSoD2traIrsuYZGSkoLp06fD0tISnz9/RkBAAG7dugVzc3OB+nfp0gUvXryAt7c3srOzISsri1OnTsHY2BhnzpwpV6liMBgYOXIk3r59C29vb/j7+6NZs2ZYunQpMjIySrUPDQ2FjY0Nfv78CXd3dzx//rxS5aEqSEpKYv/+/fD19cXRo0fRvn179O/fH4aGhjh69CiYzLpZDtzd3dG2bVtMmDABWVlZdSLD77DZbGhra+PTp091LUqt8p9VBgDA3t4ez549Q2JiYl2LIhDx8fEAUGaok9DmSMuB4PvFX1DxrwWEwRIr9RqDJV6iDfDLnp1WyMT27dvrXViRsJk8eTIyMzNx/vz5Wp9bRkYG/v7+kJWVRXx8PIKDg5Geno64uDj4+/tj/vz5UFZWxpUrVzBlyhRYWVlBVlYWpqamGD9+PDZt2oSbN2/i6dOnyMnJKbF4FhUVITExsV5bBvLz87Fu3ToYGhri/Pnz2LZtGyIjI2FnZ1fl7x2bzcb8+fPx/v17DB48GHl5eeBwOBg1ahQGDhzIDxktC3FxccybNw8fPnyAi4sLvL29YWhoiJ07d6KwsBAAcPToUXTv3h1GRkZ4+vQpFi9eDElJSRw8eLBG70FZODo64s6dO3jz5g2+fv2KRYsWQUZGRujzCAqbzcbx48eRmpoKZ2fnOpPjdwwMDBqUgf8S/fr1A5PJRGBgYF2LIhA8ZUCUloHCYm6V+zDYEgAA4hSVeo04hSXa8Jg42QFNmzathoR/FgYGBujevbtQjwqqgrq6Ov7++28EBwdj/fr1YDAY0NXVxcCBA7F8+XKcO3cOMTExyMrKQmhoKHbu3IlOnTohNjYWq1atgq2tLdq1awcA8PLygpubG06cOIHg4GAQUb1UBogIfn5+MDY2xooVKzB16lTExMRg7ty5EBMrrbBWhUaNGuH48eO4e/cuGjduDAaDgZCQELRo0QI7d+4Eh8Mpt6+CggLWrl2LmJgYDBo0CM7OzmjZsiUGDhyIyZMnY/z48QgKCoKamhrk5eUxZswY+Pr6VjhmdSAiHDp0CBwOBzY2Npg4cSLWrVsHLrfqv31h0bRpU2zfvh2HDh3CxYsX60wOHvr6+g3KwH8JFRUVdOjQ4Y/xG4iLi4OEhAQ0NDRENoc4u+pfCZbsr0Q5nOzSZ6ic7HQwJeXAYJe8CTtMmlg9Af9AHBwccOfOHXz8+LFO5u/ZsyeWLl0KT09PPHjwoMw2srKyaN++PWbOnIk9e/YgNDQUmZmZiImJwciRIyEtLQ0FBQWcOXMG48ePR9++fQEALi4umDJlCrZt24aQkJAKz9Frg8ePH6NDhw4YM2YMLCws8Pr1a3h7e0NZufQRVk3gHR1s3boVTCYTHA4H8+bNQ4cOHRAZWXGiriZNmsDX1xcPHz5EVlYWAgICoKOjgwkTJkBcXJzfbsaMGfj8+TOuXbsmVNl37dqFAwcOYP/+/QgNDYWHhwc8PDwwdOjQMo8vaospU6Zg8ODBmDZtGpKSkupMDqBBGfhPYm9vj9u3byMvL6+uRamUuLg46OjoiPRsT09Fpgqug79gy6mCKa2AwuQPpV4rSIqGuIZ+ieeICG1bGUBNTQ2dOnXC4sWLcf/+/TLPq/8NDB06FPLy8jhy5EidyeDp6Yn27dtj7NixAi/YTCYThoaGKCoqQvv27eHv74+4uDikp6dj2bJlAAAbGxtERUVhyZIl6NGjB1RUVKCtrQ07OzssXboUZ86cwfv374W+u/0nCQkJGDt2LNq3b4/8/HwEBQXh0qVLMDIyEtmcYmJicHZ2xvv37zF8+HAAv7L/WVpaYtmyZcjPzy+3b2xsLBwdHZGfn48NGzZAXV0d3bt3h729PV6/fg0AaN26NSwtLbFv3z6hyXz79m24uLjwlTgWi4U1a9bg8uXLuHPnDv/zrAsYDAb2798PNpsNR0fHKjm4Cht9fX2kpaUhMzOzzmSobf7zyoCdnR1yc3MREhJS16JUSm1EEshIsKGjXHXvfunmHZD34SmKM7/xn8uLe4XiH18hbdypRFs55KGdtSWICKGhodi4cSO6dOkCSUlJKCsro23btnB2dsbNmzf/FT9GaWlpjBkzBkeOHBH5olgebDYbJ0+eRE5ODqZMmVKjSAJFRUVIS0tDWVkZR48exdOnT5GVlYU3b97g1KlTGD9+PLhcLo4cOYJRo0bB2NgY8vLyaNu2LaZPn47du3fjwYMHQvlss7KysHTpUjRv3hwhISE4ePAgnj17hh49etR4bEH5/ejAwMAAHA4H69atg4mJCe7evVuq/Z07d9CmTRsUFhbi8ePHcHNzQ1hYGPz8/EpEHiQmJmLGjBkIDAys0CdBUGJiYjBixAj06tULGzduLPEaz39KUlISbdu2xalTp2o8X3VQU1PD4cOHce3aNezZs6dOZAB+KQMA/lvWAWHGKf6JcLlcMjAwoFmzZtW1KJXSunVrmjZtmsjn8fSPKlGhUKn3DFLoPJ5kLfsTAJI26kAKnceTQufxpO18+v8zEB7+LQPhDFLs+v8ZCNX0SGfhxf/lGVhyhTz9/xdzXVhYSI8ePSIPDw/q3LkzqampEYPBKFHoR05OjiwsLGjmzJl08eJFSk5OFvl7IGyePHlSYRGa2sLf358A0I4dOwRqn5WVVWZ55JkzZ5K5uXml/b99+0a3b9+mLVu20MSJE8nc3JzExMT4n62+vj4NHjyYPD096cKFC/Tx40eBMhoWFxeTr68vaWpqkqSkJC1btoyysrIEuiZRUlhYSFu3biUZGRl+gihHR0f68eMHERHt27eP2Gw29ejRo0SFRB4FBQW0fft2UlFRISkpKVq4cCHJyMiQp6dnjeT6+fMnGRsbU/PmzSk9Pb3cdjk5OTRu3DgCQPPnz6+zZECzZ88mSUlJkVbhrIjk5OR6X11RUBqSDlWBefPmkba2dr3PRqiiokJ//fWXyOeJTs4skTiIJa9eYnH+/dFk5kF+u0aOu0lS35IYYhLElJAhmVbdSGvu8VKJiHgZCMujoKCAwsLCyNPTk7p160bq6uqlFARpaWlq1aoVTZ48mU6ePMnPvldf4XK5ZGJiQiNGjKhrUWj+/PkkLi4uUMKtR48elZmcq3///mRvb1+t+QsKCig8PJyOHz9OCxcupN69e5O6unoJ5a9jx440e/Zs2rdvHz1+/JhfqpfoV8Iwc3Nzfna++PiyS2TXJYmJiTR27NhfqbxZLFJSUqK+ffsSAJo9e3aliyyv5oGkpCRJSkqSgoJCtZNHFRcXU9++fUlRUZHev39faXsul0u7du0iNptNHTt2rHIaZGGQk5NDzZs3p9atW9eo1kN1+VPLc5dFQ9XCKnD79m307t0bL1++hIWFRV2LUybZ2dmQk5PD33//jXHjxol8vgkHwxAamwYOV3jndiwm0MFAFccd21a5b2FhISIiInDjxg3cuXMHkZGRSE1NLWHuFhcXh66uLmxsbNCrVy+0adMGzZs3B5vNFto11ARvb28sXrwYiYmJUFVVrTM5CgoK0KFDB2RlZeH58+eQk5Mrt+3+/fsxe/ZsZGdnl6hgZ2pqiq5du2LXrl1Ckys5OblEhcfw8HC8e/cOHA6HHwVRUFCApKQkGBsbY8OGDbC3t6/X4al3797F1KlT8eHDL3+ali1b4saNG9DS0hKo/5cvX+Dk5AR/f39oampi+/btGDFiBHILOYhLy0FhMRfibCb0VGQgI1H293zhwoXYtm0brl27ht69ewsse2hoKEaMGAEul4szZ86gc+fOAvcVBs+ePUP79u2xePFi/PXXX7U6NwC0atUKPXv2xI4dO2p9bmEi6PrdoAzg10KjqqoKNzc3vmNUfeP169cwMTHBgwcP0LFjR5HP9/lHLnp530VBNUINy4KIIM5iIHhBd2hXwyehLHgZ1IKCghASEoLw8HCkpKSUUBBYLBa0tbVhZWWF7t27o02bNjA1NYWUlJRQZKgK3759Q+PGjbFlyxbMmzev1uf/nZiYGFhZWWHw4ME4duxYuQuqk5MTQkJC+E5tPBQUFLB06VK4ubmJVM78/Hw8evQIXl5eCAoKgoSEBFgsFnJycgAASkpKJUpAm5ubo1WrViIpvVsdoqOjYWdnhy9fvoDL5aKoqAji4uLYuHEj5syZI7AzsImJCb4VslGk2xZKLTuBI10yOoIBQEdZGt2bq2NcWx000/il4B05cgRTpkzB9u3bq/WdS05OxujRo/HgwQNs3rwZ8+fPr1Xla+3atVixYgXu3btXK/e93+Hlo/hTos3Ko0EZqCIjRoxAQkICwsLC6lqUMrl69Sr/ptKkSZNamdPvaQLcL1QcJlUVflzfCS9HO8yZM0dkN5T8/HxERETg/v37CAoKQnh4OJKSkkooCAwGA40aNYKlpSW6du0KGxsbWFhYQFFRUSQy/c6wYcPw4cMHvHr1qs53tCdPnsS4ceNw+PBhTJ48ucw2Xbp0QZMmTUo4lGVkZEBRURGnTp3C6NGjRSZfUVERfHx8sGrVKhQXF2Pp0qWYP38+JCQk8OXLl1JWhJiYGBARWCwWmjdvzlcSeA9NTc1afc9v3bqFkSNHQlNTEwEBAZCWloazszPOnj0LADAzM8PJkyfRqlWrCsf5/CMXE3ddw6c8STBB4FYQ78NiMsDhEjobqmKYbiFGDeiFiRMnYv/+/dW+9uLiYri7u2PLli0YNWoUfH19ISsrW62xqjN3165dkZSUhFevXtXq+jN37lwEBweXUoT/NBqUgSpy7NgxTJo0CcnJySKN468uPj4+cHZ2Rn5+fq2mDV3u9xDHw3/i13Fu1W8mRAQGgwHXXs0Qd3UvvL294ejoiN27d0NCQqLyAYRAXl4eIiIiEBoaiuDgYLx8+bLMNK+qqqowNzdHly5dYG1tDUtLSzRq1EiosvCUuufPn8PKykqoY1cHBwcHnD59Gs+fP4exsXGJ14gISkpKWLx4MZYsWcJ/PioqCqampnj48CE6dOggdJmICAEBAVi0aBE+fPiAadOmYdWqVZX+LnNychAVFVVCQYiIiOCnuFVTUyulILRo0aLGiYjKkn/Xrl1wcXFBnz59cOrUKSgoKPBfv3v3LqZMmYJPnz6ByWTC1dUVa9asKdOa4fc0AZ6XX6OYwwWnCid2LAZQXFQIlbggPD6xtUT+gupy9uxZTJkyBXp6erhw4YJIwzZ/JzY2Fubm5hgxYkStJu/aunUrli9fjuzs7DpX3GtCgzJQRb59+wYNDQ34+vrCwcGhrsUphZubGy5cuMA/e6wtpk6dihsfsiDdeTIKiooBhuCKCHE5YDMZ8BpqjlE2vzLVHT16FNOnT4e1tTXOnz9fbpEYUZObm4vw8HCEhYUhJCSk3Dzw8vLyMDU1RceOHWFtbQ0rKyvo6+tXWyErLi6Gjo4Ohg4dKtTz9uqSk5MDa2triIuL4/HjxyWOT3ihrFeuXMGAAQP4zwcGBmLAgAEiqU3w6tUrLFiwAMHBwejduze2bNkCU1PTao/H5XIRFxdXyorACxkTExNDy5YtSykJ1fXpKCwsxNy5c7F//34sWLAAGzZsAIvFKtWuqKgI3t7eWL58OQoLC6GpqQk/Pz907dqV32ZXSAw234yu3oUDABHAYGBhHyM4dW9W/XF+4+3btxgyZAgSExNx9OhRDBkyRCjjVsbhw4fh4OCA8+fPY+jQobUy56VLlzBkyJB6u0EUlAZloBp07NgRGhoauHDhQl2LUoqRI0fix48fuH37dq3NmZKSAl1dXaxatQpd+g3BEK8zkNS35Jsiy4P/evJb3FrrgGaNS55vhoWFYciQIWCxWLh48SKsra1FfSkCkZOTg1evXuHZs2e4c+cOnj17hi9fvpRqJyUlhZYtW6JDhw78xDBV2WF6eHhgz549SEpKqhdn2xEREWjTpg0cHBzg4+PDfz4gIAADBw4stejv3bsXTk5OyM/PF5pzZlJSEpYvX45Dhw6hefPm2LJlC/r16yeyHVlmZiYiIiJKKAiRkZH85GONGzcupSAYGRmVubDz+P79O4YPH47Q0FDs27cPU6ZMqVSOxMRETJ8+HVevXgXwK0HVwYMHcT0mU6hHdBuGmvIV8pqSmZnJX5jd3d2xZs0akTvpEhGGDRuGe/fuITIyUugWu7IIDw+HhYUFHj16xE/J/SfSoAxUg3Xr1mHt2rX4/v17vbhJ/07btm1hYmIiksIl5bFy5Ups2rQJX758wbJly3DmzBncfvoaFyO+ISQ6FQlpuSWKGjEA6KhIQ5uVidNrnXDhsE+5VQkTExMxZMgQREREwNfXt1YiJKpDdnY2Xr58iefPn+PBgwcICwvjKwgMBoPvi8Bms9G8eXO0b98eVlZWsLS0hJmZWZnlmWNiYmBkZISTJ09izJgxtXo95bF3717MmjUL586dw7BhwwD8ct7asmUL0tLSwGAwkFNQjLi0HGzfuRs3Aq/izZO75XqwC0peXh62bt2KdevWQVJSEqtWrcL06dOFbroXBA6Hgw8fPpSyIvA+b0lJSZiYmJRQEMzMzKCoqIjXr1/D3t4e2dnZuHDhAjp16lTJbCUJDg7GuHHjkJycDFlNXWhM2YViKl8RKkj+gIwHJ1Hw5Q2ouAhsRQ3IWvSFvPXAMttLsJm47dJVaM67RIQtW7Zg8eLF6N69O06dOgU1NTWhjF0e379/h6mpKSwsLBAYGChy0z1v3atPv9Pq0KAMVAPeWei1a9f4udfrCxoaGnBycsLy5ctrZb68vDzo6upi1KhRWLp0KfT09LB8+XIsXbqU34a3OPwe3oTiArRs2RJmZmaVeuHm5+djxowZOHbsGBYtWoR169ZVuPOqL2RlZeHly5d49uwZHj9+jEePHpVQEID/+Uro6+ujbdu2sLKygpWVFSwsLKCsrIwuXbpAQkICt27dqstL4UNEGDlyJG7duoVXr15BT08Po0aNwufMYvSZtRoh71OR8KMM5a8MD3ZB5zt16hTc3d2RnJyMuXPnYtmyZVBSUhL6tdWUtLS0UlaE169f8ysOqqurIy0tDSoqKli5ciV69+4NAwODKh8lFRUVYc2aNdgfLQ4JHVMwWGUrWnmfXiD13GqIazSFjHFnMMQlUfwzGSAulLqXfcTJYjLQwUClWmG9FRESEoJRo0ZBQkIC58+fR5s2bYQ6/j+5du0a+vfvj127dmHOnDkinQv4Vb/G1dW1xH3vT6NBGagGRAR9fX3Y2dnVi/NcHrm5uZCRkcGxY8cwYcKEWpnT19cX06dPR3R0NA4cOIA9e/YgISGhUo/7pUuXYsuWLXjz5g0MDAwqnYeIsH37dixYsAC2trY4efJkrXj1C5uMjAy+BSEsLKyEgsBbFHhV4Ro3bgwNDQ28fPkSBw4cQN++fdGkSZM6d1L6+fMnLC0toampiRP+19FryUFw1ZsLfCzU2VAVXkNMK919Pnr0CC4uLvzjoo0bN8LQ0FDYlyNSioqK8O7dO3h5ecHPzw9qampgMBhITU0FAH4p6N+tCKamppV64cekZKH3tnvlvs4tyMXX/dMh0aQF1IYsAaMKPjwAcNulCwzVBVfaBOHLly8YMWIEXrx4gR07dmD69Oki/S47OTnh4MGDePHiBVq0aCGyeQDA2toaFhYW8PX1Fek8oqRBGagmc+fOxeXLlxEXF1fnN2ce7969Q4sWLXD37l106dJF5PMREUxMTNCsWTMcPnwYOjo6cHJywrp16yrsFx0dDRMTE3h4eGDlypVVmvPWrVsYNWoU1NTU4O/vX8qz/U/k58+fePHiBZ4/f44nT54gLCyMn2OexWKVqFOgrKyM1q1b848YLC0tYWhoWKuRI8Avf44+s1ZCpc8scLhU7u60LFhMBthMBlYNbIXRZZxPx8XFwd3dHadPn4aVlRW2bt1awmHuT+J3q5aHhwfWrFkDJpOJlJSUEpEM4eHhePv2LYqLi8FgMNC0adNSvgg6Ojr8e83Ky69xPCy+XOUr62UgftzwQeOpeyCmqg1uYT4YYuICKQXE5UCnIA6n3YajcePGQn0/CgsL4erqit27d2Py5Mnw8fERWS6P3NxctG7dGtLS0nj06JFQIiXKY+TIkUhLS0NQUJDI5hA1DcpANbl58yZsbW0RERFRIy9mYXL9+nX069cP8fHxtVI//saNG+jbty/u3r2Lu3fvwsvLC3FxcRV61BIR+vbti5iYGLx+/bpaN4IPHz5g0KBB+PLlC06dOoX+/fvX5DLqJenp6Xjx4gWePXuGvXv34vPnz3ylgM1mg8Vi8as3ysjIwMLCApaWlnwloWXLliK9+fE82HnHHNXldw/2zMxMrFu3Dt7e3lBRUYGXlxcmTJhQ64qOsEhOTsbQoUPx4sULHDp0CGPHjq2wfUFBAd6+fVvKFyEtLQ3Ar8JPvIRJ9xV6Ir24fAXs20Uv5MW9gtoQD/y4uQfFP76CISYJGZPuUO45DQx2xd8NbkYyvh+ZC1dXV7i5uQn9fn78+HHMmDEDxsbGOH/+PL/gj7B5/vw52rVrBzc3N6xdu1YkcwDA4sWLcfbsWcTGxopsDlHToAxUk4KCAqiqqmLJkiXw8PCoa3EA/HLumjt3LvLy8molta6trS3S0tIQEhICPT09jB07Fjt37qywz4ULFzBs2DAEBATAzs6u2nNnZmZiwoQJCAgIwLp16+Dm5lZvLDTCJjQ0FB07dsT58+chJyeHZ8+e8Y8ZeEcMYmJiEBMTQ25uLv9/ExMTvvXA0tIS5ubmQkkCI+wkU+sGmyA74iaWLVuGrKwsLFq0CG5ubpCRkRHaHLXNy5cvMWjQIBQVFcHf37/aZ+REhMTExBLKwavX75A34K8Kv++JB51Q/DMJACBr1geSOqbIT4hE1vMASLfoArVBFWeEZAAYjkfYtW0LZGVl4enpienTpwtVwQwPD8fQoUORnp6OEydOoF+/fkIb+3e8vLywfPlykWYnFEXkTG3ToAzUgGHDhiEpKQmhoaF1LQoAYMmSJfDz86uVcpo8J8oTJ04gJSUFbm5u+PjxY4UWiZycHLRo0QLm5uZCSd3J5XLh6emJv/76C2PGjIGvr2+ZXvl/OkSEli1bwsrKCidOnCjx2vfv3/H8+XM8f/4cz549w9OnT/kKgri4OCQkJJCTkwMulwsGgwEjI6MSCoKlpWWVYuUrSz9NxUX4ef9v5LwOATc/G2JqelDsMgFS+pblD8opwtf9MzFmYB94eXkJnI+/vnL+/HlMnDgRLVq0wKVLl4R+Pa8TMzBg54MK23zdOxXFP5Mha9kPKrb/c6BLu74L2a+uo/H0fRBTrjhD6dW5naDAzYKnpycOHz6Mpk2bwsvLC8OHDxea4p2eno4JEyYgMDAQK1euxLJly4RuCeJwOOjatSsSExNFlp2QZyWNjY0VmZVD1DQoAzXg8OHDcHR0RHJyMtTV1etaHIwZMwbJyckICQkR+VyOjo64ceMG3r17h+bNm8PW1rbSrF8eHh7YunWrwE6DgnL27FlMnjwZxsbGuHTpktAT3NQHNm3ahOXLlyMpKalST/pv377xlQPeg5coSUJCAlJSUsjNzeV7uWtpafEVA94xg7a2dpk3/MoKU33z34jc9w8hbz0IbOXGyIm8jYKkGGiM8YKkdjnpdLkcmGlK4rJLnyq8I/UPIsJff/2FFStWYOTIkTh8+LDAyikRITc3FxkZGcjMzERGRka5fyfkMPFcpUeF4yX6zkbR9wRojF0PSR0T/vP5CVFIOekOlQEukDXtWeEYF2d1gKXOr+9aZGQk3N3dERgYiLZt22Ljxo1C80vicrlYu3YtPD090a9fP/z9999Cjxb59OkTzMzMMHz4cBw+fFioYwO//KCaN2+OoKAg9OhR8WdTX2lQBmpASkoKGjVqhEOHDpWbs702ad++PYyNjUXyZf+dlJQU6OjoYM2aNVBUVMTMmTPx9u1bNG/evNw+PKfBpUuXwtPTU+gyvXr1CoMHD0ZeXh7Onz9f5fjt+k5ycjK0tLSwY8cOzJ49u8r9U1JS+ArC8+fP8fTpUyQl/TIjS0pKQkZGBnl5efxjBmVl5VIWBIZiY/TdUf6OtCDxPZKPLYBidwcotP2V/Y2KC5HoOwcsGQVoTthcoYyi8GCvDYqLi5GSkoKZM2fiypUrcHBwwODBg5GZmVliMa9sof/dUfSfyMrKQkFBAfLy8pBuYoTv1tMqlCnFbzny416i8bS9EFP5n2WiKO0zEg/MglLPaZC3GVThGFfndkKrxgolngsJCcGiRYvw/Plz2NvbY/369WjZsqUA71LlXL9+HWPHjoWSkhLOnz8v9MqwosxOWFBQACkpKRw4cACOjo5CHbu2aFAGaki7du2gpaWFc+fO1bUoaNy4MaZPn15lD/2q4unpiS1btuDTp09o164dWrdujTNnzpTbnuc0+OHDB0RFRYnMe/jbt28YMWIEQkNDsXv3bkybVvEN809j0KBB+Pr1K549eyaU8ZKSkkodMaSkpAAApKWlISsri4KCAmRkZAAA1PrOgbRZH4BZdo6H9JBDyHxyCdrOfmBK/G9HnPHoDH7ePYYmsw+DLV92whkWk4EJbXWxcmDFxXiECREhPz+/wkVakJ06rzJimdfFYkFBQYH/kJeXr/Tvf/4vJydXIq9GTkExTFbeQEU35PQ7R5D5+BzUR6+FlJ45//m8uHCk+i2Fqv1CyLTqVm5/BoColbZlJovilSr28PBAfHw8HBwcsGrVKqFEHnz69AnDhg3D27dvsW/fPkycOLHGY/IgIgwfPpxf2lzYkRLa2tqYNGlSnZRRFgaCrt9/pkdELcDTjgsKCmqtoE5Z5OfnIykpCXp6eiKdJy8vD3v27MGUKVNw69YtxMbGVqoIXbhwATdv3kRAQIBISwKrqanh1q1bcHZ2xvTp0xEeHg5vb+86yVInCng7zvDwcJibm1feoRIaNWoEOzu7Eo6ciYmJfOsB74iBh4SeZbmKAAAUpsRCTLlJCUUAAMQbGfFfL08Z4HAJIdGpWAnBlAEul4usrKxqL+C8v4uKisqdQ1pausxFW0tLi/93RkYGDh8+DBaLhb/++gutW7cu0UdKSkrojq0yEmzoKEsj/kdu+W2MOyPz8TlkR9wsoQxkR9wEmCxI6FQcAaWjIl1u1kgmk4nRo0djyJAh2Lt3L9asWYMTJ05gwYIFWLRoUY02gvr6+nj48CHmzJmDSZMm4fHjx/D29hbKvZXBYGDfvn0wNTWFg4MDrl27JtTPRl9fv1b8teqaBstAOURERMDc3Bw3b95E796960wO3plVSEgIunXrJrJ5eEmG3r17h2HDhkFbWxuBgYHltuc5DVpYWODy5csik+uf7N+/H05OTujQoQPOnj0r8hSotUFRURG0tLQwZswYbNu2rVbmJCJ8/foVD588x+KnLFRUkTLRdzZYMorQGONV4vnC7wlI8p0NZds5kLOsyGOc4KTxCXlZPytdzHkVBsuCyWRWawf+z914ZUrkqVOn4ODgAAsLC1y8eLFWi2lVlmcAAL4HbkdOxC1IG3eGpI4J8hMikfvuAeTbj4BS10nl9mMygInt9AS20mRkZGDDhg3w9vaGnJwcVqxYUePIAyKCr68vnJycYGlpiXPnzgnNEZMXgr1z5044OTkJZUwAmDRpEmJiYuqNQ3lVabAM1BBTU1Noa2sjICCgTpWB+Ph4AICurq7I5iAibN26FYMGDcK7d+8QFRWFPXv2VNhn7dq1+PbtG7Zv3y4yucpi+vTpaNmyJYYOHQobGxv4+/sLZTddl4iJiWHixIk4fPgwNmzYUCuWKAaDAS0tLZgw5YCnFXuwU3EhwCq9gPJi2qm4sLLZsGqrD2QK00st0pqamgKb2mVkZEQaZsrlcrFixQqsXbsWEyZMwP79+2u9RoldC0UceRRXYRsV2zlgy6shO+I2cqMfga2gJpCvAJeAqzvc0TJ/AoYOHVppqJyCggK8vLwwe/ZsrFixAvPmzcP27dtrFHnAYDAwbdo0WFhYYNiwYbCyssLp06fRvXv3Ko/1T/r27QsnJycsWrQIPXv2FFp2Qn19fdy4cUMoY9VnGiwDFTBnzhxcu3YNHz9+rLNY9wMHDmDmzJnIz88XmVmcp1HfvXsXixYtgoSEBO7dKz8l6vv372Fqaioyp0FBSEhIwODBg/H+/XscPXoUw4cPrxM5hMXbt2/RsmVLnD17tlav5WVCOobsqXjHU3PLALClbyMM6mhWb2O1s7OzMWHCBPj7+2P9+vVYtGhRrf7mi4uLsX//fqxYsQLitq6Q0DEDVWCtqSosJgPN5LgovLkVISEh0NbWxty5czF16lSBPfyFHXnw7ds3jBkzBiEhIVi/fj0WLlxY4/dcFNkJjx49ismTJyMnJ+ePDHEWdP3+M1OA1RJ2dnb49OkT3rx5U2cyxMXFQUtLS6Tn41u3boW1tTWKiorw5MmTCpMtERHmzZsHbW1tuLlVnOBElOjo6ODBgwcYOHAgRowYgRUrVvBz//+JtGjRAu3bt6/VqpQAIM6u/BbAklUGJzu91POc7B/81ytjzMjhkJOTQ9u2bTFz5kzs27cPT5484ZcMrkvi4+PRsWNH3L59G/7+/rWe6Or27duwtLSEk5MTBg4ciIDlYyHOFm7BLjaTgQPTeyA4OBivXr1Cr169sGzZMmhpaWHOnDmIjo6udAxTU1NcvXoVQUFBKC4uRteuXTFo0CC8ffu2WjKpqanhxo0bWLx4Mdzc3DB8+HBkZmZWaywe0tLSOHHiBCIiIoTmcM0Ll46LixPKePWVBmWgArp37w5paWlcuXKlzmSIj48X6RFBZGQkbt26BVdXV6xbtw6WlpawtbUttz3PaXDHjh0idRoUBGlpaZw8eRLr1q3DX3/9hSFDhtT4ZlKXODg44MaNG/z6BbWBnopMpftPcXUDFP34Cm5BSce2wsRfC4i4RsW5JYgIxelJEBMTw5cvX3DhwgXMnj0bbdu2hZycHExNTTFx4kR4e3vjzp07+PnzZw2uqGo8fPgQNjY2yMrKwqNHj8otuS0KYmJiMHDgQPTu3RsKCgp4+vQpDh06hNbGelgl5OiL1QNb8QtImZub49ChQ0hISICbmxvOnTuH5s2bw87ODkFBQajMWNyjRw88efIEp06dQmRkJExMTDB9+nQkJiZWWS4WiwUvLy9cvHgRt2/fRps2bWq8+bKyssKqVauwYcMGPHhQ8RGYIPCSDf3bnQgblIEKkJSURO/evYWSVa+6xMXFiTSSwNvbG1paWtDR0UFQUBA8PDzK3RXl5OTA2dkZ9vb2GDBggMhkqgoMBgPu7u4ICAjAnTt30L59e3z8+LGuxaoWI0eOhJSUFI4dO1Zrc/I82CtC2rgjQFxkvbrOf46Ki5AdeQvijZuXG0nAo4mCOM6cPI558+bBysoKEhISfCsOk8lEamoqf4fYvXt3KCkpwcDAAMOHD8fatWsRGBjIz50gTI4cOYLu3bujRYsWePLkCUxMTCrvJAQyMjKwcOFCtGrVCuHh4fDz88P9+/fRunVrfpvRNjpY2MdIKPMt6tMco8ooHKWhoQFPT08kJCTg8OHD+Pz5M3r16gUzMzMcPHiwQqsNL/Lg7du32LJlC86fPw9DQ0MsX768Wgr54MGD8fTpU7DZbLRp06bCkGZBWLx4Mdq3b48JEybUeIPQuHFjiIuL/+uVgQafgUo4ePAgpk+fjpSUlCqldxUWWlpacHBwwOrVq4U+9u9JhkJDQ/Hu3Tu8fv26ROzz7yxZsgTbtm3Dmzdv6mVqznfv3mHQoEH49u0bTp8+XaeOn9Vl8uTJuH//PmJiYmqlkE90dDSm7rmBeHFdMCoIL/x2aT1yox9B3mYQ2EqNkRMZhIKkaGiMXlsiE94/KS/PQFpa2v9y8r96hVevXuH169f8BD2KiooQExNDVlYW8vPzAfxavH5PlmRlZQV9ff0qv08cDgeLFy/Gli1bMHXqVOzevVukxZ9+n9fX1xfLly9HTk4O3N3dsXDhwgotbH5PE+B5+TWKuVRhhME/4VWQXD2wVZmKQFkQEe7cuYNt27YhICAAKioqmDVrFmbNmoVGjRpV2Pfnz5/YsGEDtm3bVqPIg5ycHEydOhV+fn5wdXXFhg0bqu1n8unTJ5ibm2Po0KE4cuRItcbgYWRkBDs7O2zdurVG49QFDUmHhERycjIaNWqEY8eOYcKECbU6d2FhISQlJUWW/YqXZOjGjRvo1KkTDh8+XG7GRZ7T4LJly7BixQqhyyIsfv78iTFjxuDmzZvYvHkznJ2d/6hCR/fu3UPXrl1x584dkZb3ffjwITZt2oTLly9D08gC4kPWVNieigvx896v2gSc/GyIq+tBsfN4SBm0rrAfIHgGwt+r+/EUhFevXvGPDaSkpCAtLY38/Hx+QiB5eXl+ZUfeo0WLFuX62GRkZGDs2LG4fv06vL29MXfu3Fr5foSEhMDZ2RkRERGYMGEC1q1bhyZNKq4hwOPzj1x4XIzE/Q/fwWIyKlQKeK93NlSF1xBT/tFAVfnw4QN27NiBQ4cOobCwEGPGjIGzszMsLSuoRQHg8+fP8PT0xJEjR9C0aVOsW7cOw4YNq9J7TETYuXMnFixYgI4dO8LPz6/a4Z1HjhzBlClTcO7cOQwbNqxaYwC/irdJS0vj4sWL1R6jrmhQBoRImzZtoKenV2PTVVX5+PEjDA0Ncfv2bfTsWXG+8aqSl5cHHR0djBkzBj9+/MD9+/fx4cOHMm+iRARbW1t8/PgRr1+/rvVwq6rC4XCwZMkSbNq0CZMmTcLevXvrvcw8iAhGRkbo0KEDjh49KtSxORwOLl++jE2bNuHRo0cwNjbGwoULMX78eEz9+1WFtQmqA4vJQAcDFRx3bFvtMYgInz9/LqEghIeH84+CWCwW5OTkwOFw+DkKJCQkYGJiwq/HYGlpCTMzMyQmJmLgwIFITEzEmTNn0KeP6GsmfPz4EYsWLcLFixfRvn17bNu2rdqVDmNSsnAiLAEh0alISMstkamQgV8JhbobqWN8Ox2hpX/++fMnDh06hB07diA+Ph5dunSBi4sL7O3ty7UgAqUjDzZt2oTOnTtXae4HDx5gxIgRYDKZOHv2LDp06FBl+YWVnXDWrFl49OgRXr16Va3+dYnA6zcJQEZGBgGgjIwMQZr/61i9ejXJy8tTQUFBrc57+/ZtAkAfPnwQ+tj79+8nBoNBwcHBxGQyaefOneW2PXv2LAGgK1euCF0OUfL333+TpKQktW3blr5+/VrX4giMl5cXSUlJCe33lpubS3v27KFmzZoRAOrSpQsFBAQQh8Pht0lIyyGjpVdJZ3EA6bpfEcrDaFkgJaTlCOUa/klGRgY9ePCAdu3aRVOnTiUbGxuSkJAgAASAZGRkSF5enphMJgEgBoNBTCaT5OTkaNGiRXT79m1KS0sTiWw8+dzc3EhcXJy0tLToxIkTxOVyhTZ+dn4RRX39SS/if1DU15+UnV8ktLHLoqioiM6dO0cdO3YkAKSvr0/e3t6VfkeDgoKodevWBIAGDhxIb968qdK8iYmJ1KlTJ2Kz2bRz585qvYffvn2jRo0aUZ8+fUp856vChg0bSF5eXqifYW0h6PrdYBkQgJcvX8LKykokO/SKOHjwIKZNm4b8/HyhnmlyuVyYmJjA2NgY6urquHjxIuLi4so8u8zJyYGxsTGsrKzg7+8vNBlqi2fPnmHw4MHgcrm4ePEi2rat/i61tvj69St0dHSwZ88eTJ8+vdrjfP/+Hbt378auXbvw48cPDBs2DAsXLix3Z7ri6A0ce1dc7fn+yYahpgKfVwuD4uJixMTElLAgvHz5EqmpqQB+OZvKyMggPz8fxcW/rlNHR6eEBcHS0hJNmjSp9tEBh8PBkSNHsHTpUmRmZsLNzQ2LFi2CjIyM0K6zrnn69Cm2b9+O06dPQ0pKCo6Ojpg7d265FUu5XC5Onz6NpUuXIj4+Ho6Ojli5cqXAu/SioiK4ublh27ZtGDduHPbt21fl95NXinjHjh2YO3dulfoCvyqojhw5EmlpaVBWrjyUtj7RYBkQIlwul5o0aULOzs61Ou/y5cupSZMmQh83MDCQANDFixdJXFyc1q1bV25bd3d3kpSUpNjYWKHLUVskJSVR+/btSUJCgo4ePVrX4ghE//79qW3bttXqGxMTQ7NmzSIpKSmSkpIiJycngaxLW7ZsIdUu44RiFdgVHFMt2YVJYWEhzZkzh78r9fLyojFjxpCxsTExGIwSVgRxcXH+/8rKytS7d29avHgx+fn50fv37wXaUd69e5csLS0JAI0dO5YSEhJq4Srrjq9fv5KHhwcpKysTk8mkIUOG0N27d8vdPefn55O3tzcpKyuTtLQ0LVu2rEpryqlTp0haWppMTU0pJqbq3y8nJyeSlJSk169fV7nv06dPCQA9ffq0yn3rGkHX7wZlQEBmzJhBTZs2rVUz0YQJE6hjx45CH7d3795kbW1Nrq6upKCgQD9//iyz3bt370hMTIxWrVoldBlqm/z8fHJ0dCQA5OLiQkVFojWr1pRz584RAIqKihK4z6NHj2jo0KHEYDBITU2NVq9eTd+/fxe4/8SJE6lNmzZ06kk8GS0LJAOPq1VSAAw8rpLRskDyexJfnUsWKmlpadSzZ09is9m0d+/eUq/n5ubSkydP6MCBAzRnzhzq0KEDycjI8BUCCQkJkpSU5P8vLS1NHTp0ICcnJzp48CC9ePGCf2wYGxtLw4cPJwBkY2NDoaGhtX25dUpOTg7t27ePWrRoQQDIysqKjh07Vu6xanp6On+ToaamRrt27aLCwkKB5oqKiqJmzZqRgoICXb58ucpytmjRgiwtLat85Pv9+3cCQGfOnKlSv/pAgzIgZK5cuUIAqnzmVRM6d+5M48aNE+qYERERBID27dtHMjIytHTp0jLbcblc6t27NxkYGFBeXp5QZagruFwu7dy5k1gsFvXu3Zt+/PhR1yKVS0FBAamqqtKCBQsqbMfhcOjSpUvUqVMnAkBGRka0b98+ys3NrfKcFhYWNHXqVCL65UMw3vcx6bpfIR03/0qVAF33KzTe97HIfASqwtu3b8nQ0JCUlZUpJCRE4H4cDoc+fPhA58+fp+XLl5O9vT01adKErxCwWKwSCgKbzSZ1dXViMpmkoKBQ5Z3uvw0ul0s3btygfv36EQDS1NSk1atXU2pqapntExISaMqUKcRgMMjQ0JDOnj0r0Gbr58+fNHjwYAJAS5cupeLiYoFlfP78ObHZbFqyZInAfYh+XZucnBxt2LChSv3qAw3KgJDJzc0lKSkp2rhxY63NqaOjQx4eHkIdc8qUKaSlpUXLli0jKSmpcn+of6rToCAEBQWRiooKGRoaVstkWFs4OzuTmppambumvLw82r9/PzVv3pwAUMeOHenSpUvVdpAqLCwkcXFx2rFjR4nnhzs6keGoJdRlUzDp/UMJ0HO/Ql02BZOnfxTFpGRWa15hc+3aNVJQUKCWLVsKzfE2LS2NQkJCyNvbmyZNmkSmpqZ8x0SeksA7dmAwGGRgYECjRo2iDRs20M2bN+nbt29CkeNP4s2bNzRz5kySkpIiCQkJcnR0pMjIyDLbhoeH8xWItm3b0r179yodn8vl0vr164nJZFKfPn2qZAHz8vIiBoMh0Dy/Y25uTjNnzqxSn/pAgzIgAuzt7alz5861MldhYSExmUzav3+/0MZMSkoicXFxWr16NSkpKdH8+fPLbJeVlUVaWlo0cOBAoc1d34iNjSVTU1OSlZUlf3//uhanTHhWnIsXL/Kf+/79O61Zs4bU1dWJwWDQ0KFDhWKWjoqKIgB09+5d/nMcDofU1dXJzc2NiGrfg70qcLlc8vb2JiaTSf379xfZver+/ft873hbW1vasmULubi4ULdu3UheXr6E1YDFYvH/19DQoAEDBtCKFSvo0qVLFB8f/0d6pleV79+/07p16/gWll69etGVK1fKVFqDgoLIysqqSpEHt2/fJlVVVdLV1RX4PL+4uJg6depEurq6VfqeDB48mGxtbQVuX19oUAZEwP79+4nJZIo0JIlHbGwsAaCbN28Kbczly5eTjIwMrV69msTExMp1cPo3OA0KQlZWFg0ZMoQYDAb99ddf9fLmbGNjQ/b29vTx40dycnIiaWlpkpSUpFmzZlF0dLTQ5jl58iQBKHF08uTJk1IKQn2koKCApk6dSgBo4cKFVTIbC0p8fDyNGjWKAFDr1q3p/v37pdpwuVz6/PkzBQQE0Jo1a2jYsGGko6PDVwgYDAax2Wz+/3JyctSlSxdauHAhnThxgt68eSMS2esDhYWFdPLkSbKxseEfZ+3evZuys7NLtONwOHTy5EnS09MjJpNJ06dPp8TExArHjo+P54eW+vr6CiRPbGwsycnJ0aRJkwS+BhcXFzIyMhK4fX2hQRkQAV+/fiUA9Pfff4t8rpCQEAJA79+/F8p4ubm5pKKiQrNnzyZNTU1ydHQss93bt29JTEyMVq9eLZR56zscDodWrVpFAGjEiBGlbk51zeLFi/kx8qqqqrRy5cpyj3Zqgru7O2lra5d4buXKlaSgoCCwc1ddkJqaSp07dyZxcXE6fPiw0MfPzs6m5cuXk6SkJGlqatKhQ4eqfBSTmZlJDx8+JB8fH5o2bRpZWFiUiF743YIgISFBlpaWNGvWLDpw4AA9e/aM8vPzhX5ddQWXy6XQ0FAaMWIEMZlMUlRUJDc3t1Ibk/z8fNq6dSs/8mD58uWUmVn+UVR+fj7NmDGDANDUqVMF8nM6cuQIAaCzZ88KJPuOHTtIXFy82kdxdUWDMiAiWrduTaNHjxb5PIcPHyYAQnPe27dvHzEYDFqzZg0xmcwyd5VcLpd69epFTZs2/dc4DQrKhQsXSEZGhszNzenTp091KguHw6GAgADq0qULf0c5ePBgyskRnXNev379aMCAASWea9OmDY0YMUJkc9aUiIgI0tPTI3V1dXrw4IFQx+ZwOHTs2DFq3LgxSUhI0JIlSypcjKpKcXExvX37lvz8/Mjd3Z169OhBysrKfKXgd58EJpNJhoaGNG7cONq2bRvdu3fvX3EvjouLo0WLFpGCggKxWCwaNWoUPXr0qESb9PR0Wrx4scCRB4cOHSIJCQlq3bo1xcXFVTg/l8ulYcOGkbKyskBJyQICAggAff78WbALrCc0KAMiwtPTs1Z2S56entSoUSOhjMXhcKhFixY0aNAg0tPTo1GjRpXZ7syZMwSArl69KpR5/zQiIiJIX1+fVFVV6c6dO7U+f35+Pvn6+vJDtNq1a0fnz5+nMWPGkJGRkUiPMZo0aVLCwzolJYUYDAYdOXJEZHPWBH9/f5KVlSVzc/NKb/pV5dGjR9SmTRsCQMOGDavV47KUlBS6efMmbdy4kUaOHEn6+volciL8/nfjxo3J3t6evLy86Nq1a5ScnFxrcgqTrKws2rVrFz9DZtu2benUqVMl7rEJCQk0efJkYjAY1KxZswojD54/f056enqkrKxMN27cqHDu79+/C5yd8PXr1wSgyo6HdU2DMiAinj17RgAoODhYpPNMnjyZ2rVrJ5SxeEmGli1bRgDo1atXpdrwnAYHDRoklDn/VL5//049evQgNptNPj4+tTLnjx8/yMvLizQ1NYnBYNCgQYNK7HSDgoIIgNB3vzx4MdSnTp3iP3f06FECUO8WGJ4XOYPBoCFDhlBWVpbQxk5ISKCxY8cSALKwsKgThbAs8vLy6NmzZ+Tr60uzZs0iKyurEiGOvysISkpK1KVLF/Lw8KDz589TbGxsvfSFKQueRaxnz54EgLS0tGj9+vUlfLR+jzxo165duQtzWloa9e3bl+8PVNFCf+PGDQJQKpLmn+Tk5BCAPyZxGY8GZUBEcLlcaty4Mbm6uop0nm7dugntOKJXr15kbW1NLVu2LGUK5sEzxdW1ibw+UFRURPPnzycANGPGDJHVpIiLi6P58+eTjIwMSUhI0PTp0+ndu3el2nE4HNLT0yMHBweRyMHzT/k9zHLkyJFkbW0tkvmqS15eHo0fP56v2Arr7DYnJ4dWrlxJUlJSpK6uTgcOHKj3jnxcLpdiY2PpwoULtHz5curVqxepqqrylYLfH1JSUmRpaUmzZ8+m48ePU1RUVL1PuhUREUEODg4kISFB0tLSNGvWLHr79i3/9du3b/MjDwYNGlRm5EFxcTF5enoSALK3t6f09PRy55s7d65A2Qk1NDRo5cqV1b6uuqBBGRAh06ZNo2bNmol0Dj09PXJ3d6/xOOHh4QSAXF1dCUCZYWhv374lNpv9n3EaFJRDhw6RuLg4derUiVJSUoQ27vPnz2n06NHEYrFIWVmZli1bVukOfNWqVSQjIyPUnTCP7du3k4SEBH+BKCoqIgUFBfL09BT6XNUlKSmJ2rZtS5KSkiUsGDWBy+XSiRMnSEtLi8TFxcnNze2Pv8f9+PGD7ty5Q9u2baNRo0aRgYFBCQfF30MfmzVrRmPHjqU9e/ZQWFhYtRJViZqUlBRatWoVaWhoEADq168f3bx5k7hcrsCRB1euXCFFRUUyNDSkiIiIMufJzc2lFi1akIWFRYXKf7t27WjixIlCu77aoEEZECGXL18Wqqf/PykqKiI2m0179uyp8ViTJ08mLS0tat26NXXr1q3U6/9lp0FBCA0NJQ0NDdLW1qbnz59Xexwul0uBgYHUo0cPAn5Vfdu5c6fA0Qvx8fHEYDDo0KFD1ZahPBwdHcnKyor//7179wgAhYWFCX2u6vD8+XPS0tKiRo0a0ZMnT4QyZlhYGLVv354A0ODBg0VSGbS+UFhYSBEREXTs2DGaM2cOWVlZkbS0dCkFgcFgUJMmTWjAgAG0ceNGCgkJqXA3XZvk5+fT0aNHycLCggBQq1at6MCBA5SbmytQ5MGHDx/I3NycpKSkyo0Ge/78OYmJiVW4CRszZkyt5ZoRFg3KgAjJyckhSUlJ2rx5s0jGj4+PJwB07dq1Go2TmJhIYmJiNG3atHJzFvCcBgMDA2s017+Zz58/k7W1NUlJSVV5V1pQUECHDx8mExMTAn7lrj9z5ky1zNB9+vQRSa0KGxsbmjx5Mv//xYsXk5qaWr0IoTpz5gxJSUmRtbU1ffnypcbjffnyhSZMmEAAyNTUlIKCgoQg5Z8Hl8ulL1++0JUrV2jlypXUs2dPUldXL/OYQVlZmTp16kTu7u509erVSuP+RS33nTt3aPDgwcRgMEhFRYWWLl1KiYmJ/MgDCQmJMiMPcnJy+J/93Llzy7QArFu3jhgMRrm5NTw8PEhLS0tk1ycKGpQBETNgwIAyd9rC4O7duwSgxBlZdVi2bBnJyspSp06dyNraupQjUVZWFjVp0uQ/7zQoCLm5ufzzand390oX8/T0dNqwYQM1btyYAJCdnV2FFd0Ewc/PjwCU6VdQrHLerAAAMd1JREFUXYqLi0lKSoq2bt3Kf87U1LTOTaEcDodWrlxJAGj06NE1NmHn5ubSmjVrSFpamlRVVWnv3r313i+gLsjKyqLQ0FDatWsXjRgxgpo2bVoiURLvISMjQxYWFjRjxgzy8/OjmJiYWlceP3z4QPPnzydZWVkSExOj8ePH07Nnzyg+Pp4mTZrEjzw4d+4c/3fH5XLJx8eHxMTEqEOHDqVCCouLi6lz586kq6tbZgE3X19fYopL0ctP3+plJs6yaFAGRMyePXuIxWKJpNjNsWPHCECN4sp5SYZGjBhBAOjChQul2jQ4DVYNLpdLmzdvJiaTSQMGDCjzZpGQkECurq4kJydH4uLi5OjoKLTiVnl5eaSkpESLFy8WynhEvypTAqDbt28T0S/5AZCfn5/Q5qgqOTk5/O9tTTNDcrlcOn36NOnq6hKbzSZXV9d6Y/r+UyguLqZ3796Rn58fP5pBVla2lIIgLi5OzZo1o1GjRtG+ffsoPDy8VhJW/fz5k7Zu3Up6enoEgDp37kznz5+nFy9eUN++ffmRB79njXz06BE1adKENDQ0SkWNfPr0ieTk5EooxNHJmeTpH0XWq66SzuKA0jU6Nv6q0RGdXD9qdPxOgzIgYj5//lwqHEtYrF69mtTV1Ws0Bi/JUI8ePahFixaltPY3b94Qm82mNWvW1Gie/yLXr18nBQUFMjY25vuNvHz5ksaNG0dsNpsUFRXJw8NDJOZUJycn0tTUFJo3OO+YiJfVcO/evSJTcgXh8+fP/DPtshTYqvDs2TN+NUd7e3uR+fj8V0lNTaVbt26Rp6cn9ejRgzQ0NEqEOfISJjVp0oRsbW1p7dq1FBoaKrLkWcXFxXThwgXq3LkzASA9PT3aunUrXbp0qczIg5SUFOrevTuxWCzasmVLCaWTF1q79/hZfvXOykp617fqnTwEXb8ZRESohMzMTCgoKCAjIwPy8vKVNf/PYGVlhRYtWuDEiRNCHdfR0RFRUVEICwurVn8ul4tWrVqhcePGCA4OxrFjxzBhwgT+60SE3r17Iy4uDlFRUZCUlBSW6P8ZoqOjMXDgQHz+/BnNmzfHy5cvoaurC1dXVzg4OEBWVlYk8758+RJWVlYICAiAnZ1djcdbvnw5Dh48iMTERADAoEGDkJ6ejnv37tV47KoSFhaGwYMHQ0xMDJcvX4aFhUW1xklOToaHhweOHDmCli1bwtvbG7179xausA2USX5+Pt68eYNHjx4hJCQEr169QkJCAoqKikq0U1ZWhrGxMdq3b4/evXvDxsYGysrKQpPj+fPn2LZtG06fPg1JSUlMmTIFenp62LFjBxISEjB16lSsXLkSampqWLp0KTZu3IiRI0fi4MGDkJWVBRGh+9Sl+KRsA7aYODiVrpL/g8VkgM1kYNXAVhhtoyO0a6ougq7fDcpADVixYgV27dqF1NRUsNlsoY3bq1cvKCsr48yZM9XqHxgYiAEDBqBnz574+PEjoqOjISYmxn/9zJkzGDVqFAIDA9GvXz9hif2foaioCH5+ftiwYQNev34NABg7diyOHDlS4n0WFZaWltDX18eFCxdqPNagQYNQUFCA69evo6CgAMrKyli+fDnc3d2FIKng/P3335g6dSpat26NCxcuQENDo8pj5Ofnw9vbG15eXpCQkMDq1asxffp0of42G6g6RIT4+Hg8ffoUt2/fxpMnT/Dx40dkZWWVaCcrKwsDAwO0bt0affr0QadOndCkSRMwGIxqz52YmIg9e/Zgz549+PHjB+zs7KCtrY2TJ0+isLAQCxcuxMKFC3Hz5k1MnjwZ2trauHDhAm4nsbD5ZjSIqEbzL+xjBKfuzardXxgIun4za1Gmfx329vZIT09HaGioUMeNi4uDnp5etftv3boVZmZmCAkJgZubW4kFKjs7G66urhg8eHCDIlBFMjMzsXnzZhgYGGDixInQ0dHBrVu34O7ujpMnT8LBwQF5eXkil8PR0REBAQFITU2t8VgREREwMzMDANy9exe5ubkYMGBAjccVFC6XiyVLlmDChAkYPXo0goODq6wIEBHOnz+Pli1bYsWKFXB0dERMTAxmz57doAjUAxgMBvT09DBixAjs27cPL1++RGZmJtLT0xEcHIylS5eia9eukJGRQWRkJA4fPowxY8ZAW1sbkpKSaNq0KYYOHYpdu3bh/fv34HK5As/duHFjrFmzBp8/f8b+/fsRGxsLHx8faGtro1u3bli/fj0MDQ2RkpLCv493nrQYm29G82WvCZtvRuP004QajVFrCPPM4b8Gh8MhTU1NWrhwoVDHFBMTo927d1er/6tXrwgA/wzvn7kD3NzcSEpKqsFpsAp8/vyZFi1aRPLy8iQmJkaTJ0+myMjIEm38/Pz4IXCiLmSSlpZG4uLiNQ5t/fnzJwGg48ePExHR/PnzSUtLq9bS12ZmZtLAgQOJwWDQpk2bqjXvy5cvqWvXrgSA+vfvX+MInAbqFl5OhG3bttHgwYPJwMCgRIVH4FeVx0aNGlGPHj1oxYoV9OjRI4GzhHK5XLp58yb179+fAJCamho/d0GzZs1o+8ETpOd2qZSToK77FWrkuJukm3cktoIGMdgSxJSSJwmtVqQ2bHmFvgRGywLr1IdA0PW7wTJQA5hMJgYMGIArV64IbcykpCQUFRVBV1e3Wv23bduGxo0b4/79+1iwYEEJf4C3b99i69at8PDwqJHl4b9CZGQkJk2aBH19fezfvx+zZs3Cp0+fcPjwYZiYmJRoO2rUKDx8+BApKSmwtrYWurXod5SVlTFkyBAcOnQIVPkpX7lERkYCAN8yEBgYiP79+9d4NyQIcXFx6NixI0JCQhAQEICFCxdWad6UlBRMmzYNVlZWSElJwbVr13D16lUYGxuLUOoGRI2YmBhMTU0xf/58XLx4ER8/fkR+fj6+fv2KU6dOwcHBAa1atUJ2djaCg4OxevVqtG/fHpKSklBWVkabNm3g5OSEK1euIDs7u9T4DAYDvXv3xtWrV/Hu3TsMHz4c0dHREBcXR25uLtbe/AgCo8zvIiczFdzCPMiY9oRSr2lQ6DAKAPDt/Bpkvbpe7jUVcwkeFyOF9yaJiAafgRpy6dIlDBkyBDExMTA0NKzxeA8fPkSnTp0QFRWFVq1aValvUlISdHV10a5dO0RGRiIhIQFycnIA/uc0GB8fj8jIyAanwXIgIgQHB2Pz5s24fv06tLW14ezsjKlTpwr03U9NTcXw4cMRFhaGPXv2wMHBQSRy3rx5E7a2tnj8+DHatm1brTF8fHwwf/585OTkID4+HkZGRvD398fAgQOFLG1J7t+/j6FDh0JeXh6XL1+u0ve8oKAAO3bswJo1a8Bms7Fy5UrMmjWrVnw1Gqhf5OTk4MmTJ7h27RoeP36M9+/f4/v37yWOEWRkZKCjowNLS0v07NkTAwYMKHUM9ePHD/j6+mLnsXNg2XtWSQbicpB0xBlUXIQm0/dW2Pa2SxcYqstVaXxh0OAzUEv07t0bEhISQrMOxMXFAUC1LAM+Pj4QFxfH8+fPMW/ePL4iAABnz55FUFAQdu7c2aAIlEFRURFOnjyJ1q1bo1evXkhKSsLff/+Njx8/wtXVVWAlWF1dHbdv38aUKVPg6OiIefPmlfKkFgY9e/aEtrY2Dh06VO0xIiIi0KJFC4iLiyMwMBDi4uLo0aOHEKUszcGDB9GzZ0+0atUKYWFhAisCRIRLly6hVatWWLJkCSZNmoSYmBjMmzevQRH4jyIjI4Pu3btj48aNuHfvHlJSUlBUVISoqChs3LgRdnZ2UFNTw8ePH3Hy5Ek4OjpCU1MTEhIS0NPTw4ABA7B+/XqkpKRg0aJFmPzXQTBRNUsbg8kCW04V3ILSVojfYTEZ+Ptx/fYdaLAMCIH+/fujoKAAQUFBNR7Ly8sL3t7e+PbtW5X65ebmQkdHB02bNsXr168RHx8PFRUVAL+cBo2NjWFjY4OLFy/WWMZ/E1lZWTh48CC8vb2RkJCAPn36YNGiRejZs2eNzeV79+7F3Llz0aVLF5w5c4b/eQiLFStWYNu2bUhOToa0tHSV+3fo0AFNmzbF8ePH0adPHwC/LA6ioLi4GG5ubvD29sb06dOxc+dOiIuLC9Q3IiICLi4uCA4ORp8+fbB169YqW80a+G+TmpqKa9euISgoCC9evEB8fHyJYwQmk4kmMw+AKV+58yq3MB9UXABuQS7yYsKQHnII0i06Q23gogr76apI4+7C7jW+lqrSYBmoRezs7HDv3j1kZGTUeKy4uLhqWQWOHz+OHz9+4O3bt5gxY0aJhWfNmjX48eMHvL29ayzfv4XExEQsWbIEOjo6WLRoEbp27Yrw8HDcuHEDvXr1Esq5+cyZMxEUFISIiAjY2Njwz+iFxeTJk5GVlYXz589XuS+Xy0VkZCTMzMyQnZ2Nu3fviiyKICMjA/b29tixYwd27tyJvXv3CqQIfPv2DTNnzoSlpSW+fPmCK1eu4Pr16w2KQANVRl1dHZMmTcKxY8cQFRWFrKws5OXl4fr165g/fz6s23cCQ05doLHSg33xZcc4JO6b9ksRMGoP5T6zKu2XkJaLnILiml6KyGhQBoSAnZ0diouLcePGjRqPVZ2wQi6XC29vb7Rq1QoFBQVwdXXlv8ZzGly6dGmD0yCAN2/ewMHBAXp6eti9ezemTp2K2NhYHDt2jO9IJ0y6dOmCZ8+eQV5eHu3btxeqZcbAwAA9evSo1lFBXFwcsrOzYWZmhuDgYBQWFqJ///5Ck41HTEwM2rVrh8ePH+PatWtwcnKqVNEqLCzE1q1b0axZM/j5+WHz5s2IjIzEgAEDasW5sYH/BpKSkrC1tcW2bdtw6Mxlgb9b8jaDoD76L6gMcIGUQWsQcQFO5UeBBCAuLaeGUouOBmVACOjo6MDMzAwBAQE1His+Pr7Ki/a1a9fw/v17fP36FZMnT0aTJk0A/DpndXJygp6eHhYuXFhj2f5UiAh37tzBgAED0KpVK9y8eRNeXl74/PkzNm3aBG1tbZHOr6uri4cPH2LAgAEYOnQoVq1aVaVY6YpwcHDAnTt38PHjxyr1Cw8PB/ArkuDq1aswNDREs2bCTY4SFBSEtm3bgsvlIiwsrNIsgESEgIAAmJiYYNGiRRg7diw+fPgAFxcXgY8UGmigqhAR4j9/Fbi9mIo2pPQsIGvaE+ojPEGF+Ug9t1qgyJ7CYuH87kVBgzIgJOzt7REYGAgOh1PtMbhcLuLj46t8TODt7Q1dXV1kZGTAzc2N//zZs2cRHByMnTt3QkJCotpy/akUFxfj9OnTaNOmDbp3747Pnz/j6NGjiI2NxcKFC6GgoFBrssjIyMDPzw9r167FqlWrMHz48DJDn6rK0KFDoaCggMOHD1epX0REBFRVVaGhocHPWClMfHx8YGtrCxsbG4SFhcHIyKjC9q9fv4atrS0GDhwIHR0dvHr1Cj4+PlBVVRWqXA3898jJycGDBw+wc+dOzJo1C3369EHLli2hrq4OSUlJMJlMDB5Y/dTe0sYdUZgUg+IflSsU4uz6u+Q2pOcSEnZ2dli7di0ePXqETp06VWuMlJQUFBQUVMkyEB4ejqCgIKiqqmL06NFo2rQpgF+OcS4uLhgyZAj69u1bLXn+VLKzs3Ho0CF4e3sjLi4OvXr1wvXr19GnT586NTMzGAx4eHjA1NQU48aNQ/v27eHv7w8DA4NqjyklJYUxY8bgyJEjWLVqFVgslkD9eJkHX79+jS9fvgjtiKCoqAjz58/Hnj17MH/+fGzevLnCLIDfv3+Hp6cn9u3bB319ffj7+8Pe3r7hOKABgeByuYiLi8Pz588RERGB9+/fIz4+HsnJyUhPT0dOTk4pKxyDwYCkpCQUFBTQvHlzaGtrQ7+ZMQJAAKr+vaOigl+yFFR8BMAAoKciU+Xxa4sGZUBItGnTBurq6rhy5Uq1lYH4+HgAqJIy4O3tDWVlZXz//r1EPvk1a9YgPT39P+U0mJycjF27dsHHxweZmZkYNWoULly4AEtLy7oWrQT29vZ4/PgxBg0aBBsbG5w9e7ZGIX0ODg7Yu3cvbt26JbDiFxERAXt7e1y9ehXS0tLo2rVrtefn8ePHD4wYMQL37t3D/v37MW3atHLbFhUVwcfHBytXrgSXy8X69esxd+7c/6QFq4HyyczMRHh4OF6+fIk3b94gNjYWX758wbdv35CZmYnCwsJSfdhsNmRkZKCmpgZzc3Po6+vD2NgY5ubmsLa2hrq6epnKZsSmEMT/yC1XFk7OT7BkFEs8R5xi5EQFg8GWgJhqxUWJdFSkISNRf5fc+ivZHwYvG2FAQADWr19frTGqmmMgKSkJJ06cgJKSEgYOHAhTU1MAv5zkvL29sXLlympnMvyTePfuHbZs2YJjx45BXFwc06ZNg7OzM3R06r5iWHm0bNkST548wejRo9GnTx94e3sL5FxXFtbW1jAxMcGhQ4cEUgays7Px8eNHmJmZ4dChQ+jVq1eNF+G3b9/C3t4eP3/+xO3btytULgIDA+Hq6oro6GhMmzYNa9asgbq6YJ7cDfx7KCoqQlxcHF68eIHIyMhSu/rc3NwKd/XGxsbQ0dGBoaEhWrVqhdatW6Nly5bV/i53b66O42Hx4HDLPvtPu74LVJgLCW0TsORUwMlOR86bOyhO+wKlHo5gikuVOzaLyUB3o/r9HW9QBoSInZ0dDh8+jNjY2GqZfuPi4qCkpCRwLofdu3eDzWbj27dvWLJkCYBfzjBz58791zsNEhEePHiATZs2ISAgAI0aNcLq1asxY8YMKCoq1rV4AqGkpISrV6/C3d0d8+bN45+TV/VmxmAw4ODggMWLF+P79++VnrO/fv0aRAQ9PT2EhoZi9+7dNbkMXLt2DaNHj4a2tjaePn0KfX39Mtu9ffsWrq6uuH79Orp164bTp0/D3Ny8RnM3UD8hIqSlpeHNmzdl7uqzsrIq3NWrq6ujcePGJXb1VlZW0NTUFNkR0ri2OjjyKK7c12VadEZ2xC1kvQwENy8LTHEpiGsaQqnbFEg3qzgLKIdLGN+u/m5OgAZlQKj07t0b4uLiuHLlCubNm1fl/lWJJMjNzYWPjw/k5eXRoUMHtGvXDsCv8sTBwcG4du3av9LkyuFwcPHiRWzatAlPnjxBq1at+FXO/sTrZbPZ2Lx5M8zMzDB9+nS8ffsWFy5cgKamZpXGGT9+PBYvXoyTJ09W+t2LiIgAk8nE58+fweFwqu0vQETw9vbGokWL0L9/f5w4caJMRfbHjx9YtWoVdu/eDR0dHZw/fx5Dhgxp8Av4g8nPz0dcXBxevXqFiIgIREdHl9rVl+VdLykpCUVFxRK7ehMTE1hZWcHY2BhSUuXvrkVNMw05dDZURWhsWpnWAZmWXSHTsurHaSwmAx0MVOokFXFVaMhA+H/t3WlcU/e6L/BfQpiHMMkQSIBAmAKoVYpbj7Z+uo9eFbDO1qJW69mntrgV0Wsna/VWbTeIQ7XValVqHa91wg5atta2Vy9qVSYRUIYEGWUMg8GQdV7QZMsmCVETQPJ8X7KyVhbSrvWs9X8GAxs/fjyUSiV+/vnnJ953woQJsLKy0qsWfdeuXVi8eDEYhkF6ejpeeeUVyGQyBAcHIyoqyiCz7vuT1tZW7Nu3DykpKSgqKsLLL7+MlStXYsKECQPmpnL16lX1TfLkyZOIjIx8ov2nT5+OwsJC3Lp1S+e/SXx8PC5cuIDIyEjcvHkTWVlZT3yucrkcixcvxr59+7Bq1SqsX7++W/KiQqHAzp07sWbNGrS3t+PDDz/E0qVLqR12P6dUKlFdXY07d+7g5s2byMvLw71793D//n31U72mFttmZmaws7ODi4tLt6f6IUOGwNPTE2x2/82mBwBpXSv+uvkS5AYsAbTksJGe8BL4zk/eJdQQ9L1/05sBA4uJicHy5cvR1NT0xIFTSUmJXmu+qiZDLi4u6sYzwMBMGqyursaOHTuwY8cO1NfXY8aMGTh69CiGDx/e16dmcC+++CKuX7+OqVOnYvTo0dizZw/i4uL03n/hwoWYNGkSbty4gWHDhmn9XFZWFsLDw/Hjjz8+1SCl6upqTJ06FdeuXcM333yDuXPndvvM+fPnkZCQgLy8PCxYsADr169/4rcdxDiam5tRUlKCrKwsZGdnd3uqb2tr0/pUz+VyERISAj6fj4CAAISHh2Po0KEQiURdZqE8r/jONlgbK8a7JwzXLXRdrLjPAoEnQcGAgUVHR2PJkiU4f/48pk+frvd+DMPovUygajIEdA5+YbFY6qTBtWvXDoikwYKCAqSkpCA1NRVsNhuLFi3CsmXLtK5HDxSenp64ePEiFi9ejLlz5yIzMxOffvqpXiWD48aNA4/Hw969e7UGAwzDICsrC2FhYaipqXni/gKqKgS5XI5ffvkFf/nLX7psz8/Px4oVK3D27FmMHj0a169fxwsvvPBE30GenkKhQHl5OQoLC5GVlYXc3Fz1Wv2DBw8gk8mgUHRvictms2FnZwd3d3d4eXmpn+qHDBkCsVgMLy8vnSWiA8nsSAEeNMuRfL7gmY+1clwQZkX271wBFdP46/YiX19fhIWF4ezZs08UDNTU1KCtrU2vG3lKSgq4XC74fD6io6PVnQb9/PyQmJj4LKff5y5fvoykpCScPn0abm5uWL16Nd566y04Ozv39an1GisrK+zduxdDhgxBYmIicnJycOjQITg5Oencj8PhYP78+fjyyy+RnJyscf1VKpWisbERDQ0N4HK53W7mupw6dQpxcXEQiUQ4ffp0l2qNhoYGrFu3Dp9//jm8vLxw7NgxTJ8+fcAs4fQHDMOgvr4eEokEubm5XTLwq6qq1E/1mlhaWsLR0REhISEQCAQQiUQICwvDkCFDIBQK4ejoSH+rx8SPFcHVzhJrzuRCoWS0VhhoYsZmgcNmYV2s+LkJBAAKBowiJiYGu3fvRkdHh95NYFRlhT29Gbh16xYuXLgAoLPLG5vNxtGjR3Hx4sXnNmmwo6MDZ86cQVJSEq5cuYLg4GB89dVXiIuLM9n1ZRaLhaVLl0IsFmPmzJmIiorCmTNnEBwcrHO/BQsWYOPGjTh16hRee+21bttV+QGqjn/6PO0xDIONGzfigw8+wLRp05Camgpb287mKQqFAnv27MHq1avR1taGtWvXIiEhoU8TwZ5XcrkcZWVlKCoqQmZmZpe1etVTvaYOp2w2G7a2tvDw8FCv1YeEhGDw4MEIDg6Gt7f3c3ld6GuzIwUY5e+K909m47e7D2DGZukMClTbRwpdsGFK+HOxNPA4SiA0gsuXL2PUqFG4fPmy3k9ex44dw6xZs1BfX6+zNG7+/Pk4fvw4PDw8kJ+fj7a2NgQHB2PEiBFPNb2uL7W1tSE1NRUpKSkoLCzEmDFjsGLFCkyaNKnfJxr1pnv37mHy5MmQSqU4ePAgoqN1t04dM2YMLC0t1UmsLXIFSmpb0K5Q4kDqPuzd+hkaa6uRmpqKefPm6TxWW1sbFi1ahEOHDuGjjz7CmjVr1H+bf/7zn1i2bBlycnIwf/58bNiwATwezzC/9ACjVCpRU1MDiUSCvLw85OTkdFmrb2howMOHDzXua2FhAUdHR7i5ucHHx0e9Vh8eHg5fX18MGjSInuqNrLBKhoMZElwsqIakthWP3zRZ6GwoNDbQDXEjBP2uaoASCPtQVFQUXF1dkZaWpncwUFpaCgcHB52BQEVFBQ4dOoSOjg6sWrUKHA4H69ate+6SBh88eIAdO3Zg+/btqKurw9SpU3HgwAFERemu1TVV/v7+uHLlCubOnYvY2FisX78e7777rtYbwJtvvon/WvERlh+8gj/KH0JS9/jFKwiOi76GbUMFcixDUFglg8hd88WroqICr776KrKysnDkyBHMmjULAHD37l0kJibizJkzGDlyJK5evfrElQ8DTXNzM6RSKYqLi5Gbm9ulrr62thYymUzjcCoWi9XlqV4oFCI4OBgREREIDAwEn8+Hjc3z9YQ5EInc7fFxrBgfQ9wluLbgsOHrYtuvOwvq6/n/DfohMzMzTJw4EWlpadiwYYNe++gzuljVHMbd3R3z58/H7du3sWXLFqxdu7Zfd9tTuXv3LjZv3qweqrNw4UIkJCSo5ykQ7ezt7XHixAmsXbsW77//PjIzM7F3795uNwppXSvOyUXgLfoCJ3NqwWjqtc5iwdyJh++yanDsVjVGB7h2e635xx9/YPLkyWAYBr/99huGDx+OxsZGfPLJJ9i6dSs8PDxw+PBhzJo1a8A/lSoUClRUVEAqlaKgoKDLU71qrV5TAx0AMDc3B5fLRWhoKPh8PgIDAxEWFobQ0FD4+vrC3d1d76VE0j/YWnIg5vXekLPeQssERnL8+HHMmDEDxcXFelUITJo0CRwOB6dPn9a4vbW1FTweDzKZDElJSUhISMArr7yCsrIyZGdn9+s1wYyMDCQlJeHEiRNwdXXFkiVL8Pbbb8PFxaWvT+259N1332HevHkICgrCqVOn1IHgkWuSZ0p4WhsrxuxIAY4dO4Y33ngDYWFhOHXqFNzd3bF371588MEHaGlpwapVq7BixYoB8cTKMAwaGxshkUhQWlqK3Nxc5OXloaioSL1W39zcrHU8ra2tLVxdXbs91QuFQggEArpekj5HywR9bNy4cTA3N8fZs2cRHx/f4+dLS0t1Dqv55ptv0NjYCEdHR/ztb39TJw3+9NNP/TIQUCqVOHv2LJKSkvD7778jMDAQO3fuxNy5cym57BlNmzYNIpEIkydPxvDhw/Hdd98hU+Hx1KVQHX8GD++eyMbR0z/g1PrFmDNnDvbs2YOMjAxMnDgRmZmZiIuLw8aNG+Ht7W3g38h42tvbUVZWBolEgnv37iE3N7fbU72mUjug8w2fk5MT+Hw+BAIBAgMDIRaL1Rn5PB4P5ubmvfwbEWIcFAwYiYODA1566SW9ggGGYXQuEyiVSiQlJYHNZiMhIQEMwyAxMRFTp07F+PHjjXD2T+/hw4c4cOAANm3ahPz8fIwaNQonT55EbGwsJQUaUEREBK5du4YZM2YgZtlGOI57xyDHvdnBx7yPv8RHcf+JuLg4nDhxAlFRUbhy5Yq65XV/wTCMOimvtLQU+fn56gz88vJyPHjwAC0t2sfK2tjYgMfjqTPwQ0NDERoaqn6qd3JyGvBLIISoUDBgRDExMVi5ciVkMpnO7ly1tbVoaWnRGgz88MMPKCoqgo2NDeLj4/tl0mBtbS2+/PJLfP7556ipqcGUKVOwb9++J6pjJ0/G1dUVXx89hb+mXEIHw3S7cT0szULV4fc17usxNxmWXprKFBn8/pCH8BEvw9mSwbfffovXXnutTwK5lpYWSKXSLol5BQUFkEgkqKqqQkNDg8ZSO6Cz3M7R0RECgaBLXb1IJIJAIACfz++Xb9QI6SsUDBhRdHQ0li5divT0dEyZMkXr50pLSwFoH1382WefwczMDO+88w4qKiqwZcsWrFu3rl8kDRYXF2Pz5s34+uuvoVQq8cYbb2D58uUQiUR9fWomYU3aHbDMOGDpyBGwHxYDC8/ALj/jOHlq+TQLCiUw+L8+Q/oHk9X9BAyto6MDlZWVkEgkkEgkKCgoQF5eHoqLi9Vr9doa6ACAtbU1PD09wePx4O/vj+DgYISGhsLHxwcCgUDrzHpCiGYUDBiRUChEaGgo0tLSdAYDuhoO3bp1C7///jvMzc2xbNkyvP766/Dz88Py5cuNdNb6uX79OpKSknD8+HE4OTlh5cqVePvtt2kufS8qrJLht7sPevycJV8M2+D/0Pu4LLYZKhguKlqUCHjKWECVlCeRSFBSUoK8vDwUFhaqn+obGxs1ltoBneV2XC5XfWMXiUQQi8UQCoXw8fEBn883WpBCiKmiYMDIoqOjsX//fiiVSq2vWktKSmBnZ6ex5a4qV2DhwoX49ddf8csvv/RZ0qBSqcSPP/6IpKQkXLp0Cf7+/ti+fTvmz58/IDLLnzcHMyQ9dkVTUcpbwTK3BIutXxmbGZuFb/+/BB/Hirtta29vx/3799U3+6Kiom4Z+NpK7YDO1rgeHh7w8vKCUChESEgIgoKCIBAI4OPjAw8PDyq3I6SXUTBgZDExMfjHP/6Ba9euaW2qoxpQ9O+vNcvLy3HkyBEAwDvvvIPx48dj2rRpvZ40KJfLcfDgQWzatAm3b99GVFQUjh8/jldffZUu2n3oYn61XoFA7Q9bwbS3ASw2LPliOI1dCEtP3cs4HUoGZ28Uw6k4HXfu3OnyVN/U1KRzXy6XC19fX/j4+EAkEiEkJAR+fn7q9Xsud+DVaBPyvKNgwMhGjBgBZ2dnpKWlaQ0GSkpKNOYLbNu2DQzDYObMmUhNTUVjYyNSUlKMfcpq9fX12LlzJ7Zt24bKykrExsZi165dGDVqFK3H9rFmuQKSulbdHzIzh03QSFgLh4Ntw8WjBxI0XT2JqoOr4BGXBAsP3c2eah4CCSvfBfPoX21yORyOeq1e9VQfEBCgfqXv5eVF5XaEPIcoGDAyDoeDiRMn4uzZs/jkk080fqakpARjxozp8rOWlhZs374dDMNgzpw5mDZtWq8lDZaWlmLLli3YvXs3FAoF5s2bh8TERAQFBRn9u4l+Smtb0NM7ASvvEFh5h/zrB6Io2ASPQsXXS1B/KRXus9bp3J/FYuG9DSmIDPBU3+ydnZ0pECRkAKJgoBfExMTg22+/hUQi6XYzZxhGvUzwuP3796OlpQXjxo3D5s2bIRQKjZ40eOPGDSQnJ+PYsWPgcrlISEhAfHw83N3djfq9RD9NTU3qdforBRUAPJ74GOZOPFiLotBacBmMsqPHHILpM2djqED36GRCyPOPgoFeoBoV+/3332Px4sVdtjU0NKCpqanLMoFSqVS/RRg9ejRWr16Nc+fOGSVpkGEYnDt3DklJSbhw4QL8/PywZcsWLFiwgDK2e9GjR4/USXlSqRSFhYW4c+dOl1I7uVyu/ry5mx94Cz9/qu/iOLgCHQowj+RgWepO/LTgUKMoQkwBBQO9gMvlYsyYMUhLS+sWDGgqK/z+++9RWVmJYcOG4YsvvsC0adMwbtw4g55Te3s7Dh8+jOTkZOTk5CAyMhLHjh3DlClT9JpxT/THMAxqa2shlUrVbXFv376Ne/fuoaysDNXV1T0m5dnZ2cHLywt8Ph/+/v4QBoVgdz0DaBpE1ANFQyVYHAuwLKx0fo4FwNeFAkJCTAFd9XtJdHQ03nvvPbS0tHR54lY1HHo8GPjwww8BdI6uzcvLM2jSYGNjI3bt2oWtW7eivLwc0dHR2L59O8aMGUNrwU+pra1N3f9e1SlPlX1fWVmps/890NlAh8/ndxl24+/vDz6fDz6fDy8vL1hYWHTb73zSRZTqSCLsaG2EmU3XzP32qiK0Fl6FtXAYWCzdT/0CF5sBMZqVENIz+j+9l8TExGD58uVIT0/H5MmT1T8vKSmBtbU1XF1dAXSu22dlZcHHxwfHjx/H+vXrDZI0KJVK1UmBcrkccXFxSExMRGho6DMfeyBTKpWoqqpSN89RtcQtLi5GeXk5amtrdXbKs7CwgKurKzw8PODr64vAwEAEBQWpm+d4e3s/dY+GsUFuOJBRqrW8sObUZ2CbW8DSK+TPagIpmjN/AsvcEk4vv6Hz2GZsFsYGUgMpQkwFBQO9JCAgAEFBQUhLS8PkyZPRIlegpLYFN0rrIIgYidb2DthacvDee+8B6HwtHBAQ8MxJg5mZmUhOTsaRI0dgZ2eH+Ph4LFmyBJ6e2trRmhaZTKYedJOXl6cedFNWVoaamhrIZDKtnfJUU+1UNfQBAQHqQTeqG70xR9i+HiXA/islWrfbBI5AS+4vaLp6Csr2VpjZcGETOBLc/3gN5k48ncfuUDKIG9H37a4JIb2DgoFe9FLMLHxfIMOYpIuQ1rV2loZZRQFjoxD28TnwuBa4o/SDs18ocnNzce7cOY2vh3vCMAzS09ORlJSEn3/+GT4+PkhOTsabb74JOzs7g/9e/dWjR49QXl6unmiXk5ODu3fvQiKRoLq6Gg0NDVo75bHZbNjb20MoFMLb21vdWjowMFA96Kavp9qJ3O0xOsAVl4tqNb4dcBgeC4fhsU98XDM2CyOFLghw0z5cixAysFAw0Aukda14/2Q2fuO8CLPgDo3NYhgA9xvbYffCRLCGx8Cr9T5ChuvfTx7ovPkdPXoUycnJyMzMxAsvvIDDhw9j+vTpAy4pkGEY1NXVQSqVIj8/H9nZ2SgoKEBJSQkqKytRV1enc3ytnZ0dPDw81ONrg4KCIBaL4evrCz6fj0GDBj0XI5c3TAnHXzdf0qsTob44bBY2TAk32PEIIf3fwLpD9ENHrkmw5kwuFH9erHuq61Ztb7H1wl83X8LaWDFmR+p+XdvU1ITdu3djy5YtKCsrw4QJE5CSkoKxY8c+t0mBDx8+RFlZGe7evYvMzMxuZXYymUzr+ForKys4OTkhMDAQPj4+CAgIQFhYGAIDA8Hn8+Hh4TFggiO+sw3Wxorx7olsgx1zXawYfGeaNUGIKRkYV8R+avvFQiSfL3iqfTsYoEOhxLsnsvGgWY74sd17yd+/fx/btm3Dzp070dbWhjlz5mDFihUICwt71lM3KqVSierqahQVFSEzM1NdZieVSlFdXY3GxsYuNfWPs7CwAJfLRVBQkLrMLjQ0FGKxGD4+Ploz7wey2ZECPGiWP/V/a49bOS4Is3oIPgkhAw8FA0Zy5JrEIBdnAEg+X4BBdpbqi3R2djY2bdqEQ4cOwdraGm+99Rb+/ve/w8vLyyDf96yam5tRXFyM7OxsZGdno7CwEKWlpeoyu9bWVjBM99faHA4H9vb26nI6Pz8/BAcHIyIiAv7+/s+UeT/QxY8VwdXOUv0W6kmWDczYLHDYLKyLFVMgQIiJomDACKR1rVhzJlfjNnnlXTRc+gby+3kAAEteMJzGLoCFu1DnMT86kwtUF2D/9k346aefwOfz8emnn2LRokVGzVj/dwqFAvfv30d2djaysrKQn5/fpcyuublZY009m82Gra1ttzK7iIgIhISEgM/n9+rvMRDNjhRglL9rZ37K3Qc9jjdWbR8pdMGGKeG0NECICWMxmh7R/k1TUxO4XC4aGxvpgq2HuV9naMzwllfeRdW3/xtm9q6wH/K/wICB7MYPUD6UwXNeCsxdvLUfVNmBttJMeN75DitXrsTMmTMNPh2OYRjU19cjNzcXN2/eVM+oV5XZNTU1aXx9z2KxYG1tDUdHR7i5uanL7MRiMSIiIiAUCvs8897UFFbJcDBDgosF1ZDUtnYZasRCZ0OhsYFuiBshoKoBQgYwfe/fFAwYWGGVDP+55VeN26r/78eQ378D3n9/BTPrzn9HRXMdyr/6b1j7DsWgqe/3ePyfl42ByP3pLt5yuRz5+fm4ceMGcnNz1WV2VVVVaGho0Pr63tLSEg4ODhg0aBC8vLzg7++P4OBgDB48GCEhIc9N5r2pUvW0aFcoYcFhw9fFljoLEmIi9L1/0xXBwA5mSLS+nn0ozYW1cJg6EAAAjp0zrPhhaL13Fcr2NrAtrLUe24zNwsEMCT6OFXfbxjAMJBIJ/vjjjy5ldhUVFeoyO02v7zkcTpcyO19fXwQFBSEiIgKDBw8Gj8cbMJn3psrWkgMxj9vzBwkhJouu8gZ2Mb9a6zot0/EILE73THeWuSXQocCjmlJYegVrPXaHksHJjAKUn92KoqKiLmV2ml7fq9bpVWV2AoEAIpEI4eHhGDp0KPz9/U0u854QQkh3FAwYULNcobGhkIq5szfk5fld5sgzHY8gL88HAChktehpSHFDhzn27D8AKOSwsrJSl9l5e3ury+yGDBmC8PBwGkFMCCFELxQMGFBpbQt0JWDYvzARdee+QO0P2+AwYhrAKNF4+Sg6musBAIxCc2vcx7FYLPyemY+RIVQCRgghxDAoGDCgdoXmgTYq9kMnQtH0AE0ZJ9CS808AgIWHCA4jpqHp8lGwe5gvr2JtS9nfhBBCDIeCAQOy4PScUe/00jw4RE3Fo5pSsC1tYeHmi/pLqQAAjrN+TYP0+R5CCCFEXxQMGJCviy1YgM6lAgAws7KDGf9fFQEPS27BzN5Vd5+BP7H+/B5CCCHEUOgR04BsLTkQPGEXt5a8X9FeUQiH4bFgsXr+cwhcbKhGnBBCiEHRXcXAxga54UBGqeY+A5IcNP6/w7DyGwq2tQPay++gOSsdVsJhsI+c3OOxzdgsjA10M8ZpE0IIMWEUDBjY61EC7L9SonGbmb0LwGajKeMElO1t4Di6w3HMXDi8+GqPo42Bzj4DcSOoioAQQohhUTBgYCJ3e4wOcNU4m8DcyRPus/7PUx3XjM3CSKEL9ZEnhBBicJQzYAQbpoSDwzbsUB4Om4UNU8INekxCCCEEoGDAKPjONlirYX7As1gXK6YRs4QQQoyCggEjmR0pwIpxgQY51spxQZgVSbkChBBCjINyBowofqwIrnaWWHMmFwolo3WAkSZmbBY4bBbWxYopECCEEGJU9GbAyGZHCpCe8BJGCl0AdN7kdVFtHyl0QXrCSxQIEEIIMTp6M9AL+M42OPBmFAqrZDiYIcHFgmpIalu7dCpkobOh0NhAN8SNEFDVACGEkF7DYhimx3fXTU1N4HK5aGxshIODQ2+c14DXIlegpLYF7QolLDhs+LrYUmdBQgghBqXv/ZvuPn3E1pIDMY/b16dBCCGEUM4AIYQQYuooGCCEEEJMHAUDhBBCiImjYIAQQggxcRQMEEIIISaOggFCCCHExFEwQAghhJg4CgYIIYQQE0fBACGEEGLiKBgghBBCTBwFA4QQQoiJo2CAEEIIMXEUDBBCCCEmjoIBQgghxMRRMEAIIYSYOAoGCCGEEBPH0edDDMMAAJqamox6MoQQQggxHNV9W3Uf10avYEAmkwEA+Hz+M54WIYQQQnqbTCYDl8vVup3F9BQuAFAqlSgvL4e9vT1YLJZBT5AQQgghxsEwDGQyGXg8Hths7ZkBegUDhBBCCBm4KIGQEEIIMXEUDBBCCCEmjoIBQgghxMRRMEAIIYSYOAoGCCGEEBNHwQAhhBBi4igYIIQQQkzc/wBesOGuRO0c8AAAAABJRU5ErkJggg==" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -740,6 +711,7 @@ " rnd_clauses = kept_clauses + random.sample(drop_clauses, num_selected)\n", " rnd_graph = construct_graph(rnd_clauses)\n", " rnd_graphs_w.append(graph_weights(rnd_graph))\n", + "print('Here is the graph of the H_C of the last driving layer:')\n", "rnd_graphs_w = jnp.stack(rnd_graphs_w, axis=0)\n", "nx.draw_networkx(rnd_graph, with_labels=True, pos=pos)\n", "ax = plt.gca()\n", @@ -748,8 +720,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:26:07.185324Z", - "start_time": "2023-06-30T07:26:06.999940800Z" + "end_time": "2023-07-03T13:23:28.437985100Z", + "start_time": "2023-07-03T13:23:28.262064700Z" } } }, @@ -764,7 +736,7 @@ }, { "cell_type": "code", - "execution_count": 190, + "execution_count": 23, "outputs": [], "source": [ "def QAOAansatz_rnd(params, g, each=1, return_circuit=False):\n", @@ -807,8 +779,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:26:07.283590400Z", - "start_time": "2023-06-30T07:26:07.174051300Z" + "end_time": "2023-07-03T13:23:41.855222600Z", + "start_time": "2023-07-03T13:23:41.802298100Z" } } }, @@ -823,24 +795,23 @@ }, { "cell_type": "code", - "execution_count": 191, + "execution_count": 28, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "backend = type(K).__name__\n", "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(K.vvag(partial(QAOAansatz_rnd, g=rnd_graphs_w), argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3), jit_compile=True if backend == 'JaxBackend' else False)\n", + "QAOA_vvag = K.jit(K.vvag(partial(QAOAansatz_rnd, g=rnd_graphs_w), argnums=0, vectorized_argnums=0))\n", "\n", "params_rnd = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", - "if backend == 'JaxBackend':\n", + "if type(K).__name__ == 'JaxBackend':\n", " opt = K.optimizer(optax.adam(1e-2))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", @@ -868,63 +839,43 @@ }, { "cell_type": "code", - "execution_count": 192, + "execution_count": 29, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Circuit #0\n", - "measurement prob: 0.02918497659265995\n", - "output: 111000011000\n", - "cost: 0.03293716907501221\n", - "max prob: 0.06192261725664139\n", + "cost: 0.034298673272132874\n", + "max prob: 0.061373475939035416\n", "bit strings: ['000000111111']\n", "\n", "Circuit #1\n", - "measurement prob: 0.0033539484720677137\n", - "output: 111010100001\n", - "cost: 0.03257792443037033\n", - "max prob: 0.06247476115822792\n", - "bit strings: ['000000111111']\n", + "cost: 0.034172173589468\n", + "max prob: 0.06166590005159378\n", + "bit strings: ['000000111111', '111111000000']\n", "\n", "Circuit #2\n", - "measurement prob: 0.0022312484215945005\n", - "output: 101110000001\n", - "cost: 0.033498045057058334\n", - "max prob: 0.062363043427467346\n", - "bit strings: ['111111000000']\n", + "cost: 0.03370116278529167\n", + "max prob: 0.06229700148105621\n", + "bit strings: ['000000111111']\n", "\n", "Circuit #3\n", - "measurement prob: 0.02523483708500862\n", - "output: 111000100101\n", - "cost: 0.037150800228118896\n", - "max prob: 0.052470263093709946\n", - "bit strings: ['000000111111', '111111000000']\n", + "cost: 0.035995520651340485\n", + "max prob: 0.0600101463496685\n", + "bit strings: ['111111000000']\n", "\n", "Circuit #4\n", - "measurement prob: 0.034201640635728836\n", - "output: 111000100001\n", - "cost: 0.034923672676086426\n", - "max prob: 0.05888247489929199\n", - "bit strings: ['111111000000']\n", + "cost: 0.03770057111978531\n", + "max prob: 0.05639055743813515\n", + "bit strings: ['000000111111']\n", "\n", "Circuit #5\n", - "measurement prob: 0.03789209946990013\n", - "output: 000111011110\n", - "cost: 0.0331316813826561\n", - "max prob: 0.06241282820701599\n", + "cost: 0.042536795139312744\n", + "max prob: 0.047668762505054474\n", "bit strings: ['111111000000']\n", "\n" ] - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -934,11 +885,6 @@ " c = QAOAansatz_rnd(params=params_rnd[num_circuit], g=rnd_graphs_w, return_circuit=True)\n", " loss = QAOAansatz_rnd(params=params_rnd[num_circuit], g=rnd_graphs_w)\n", "\n", - " # measurement output\n", - " m_out, m_prob = c.sample()\n", - " m_out = ''.join(map(str, m_out.astype(int).tolist()))\n", - " print(f'measurement prob: {m_prob}\\noutput: {m_out}')\n", - "\n", " # find the states with max probabilities\n", " probs = K.numpy(c.probability())\n", " max_prob = max(probs)\n", @@ -946,26 +892,20 @@ " states = []\n", " for i in index:\n", " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')\n", - "\n", - "# plot NetworkX graph\n", - "colors = ['r' if m_out[i] == '0' else 'c' for i in hard_graph.nodes]\n", - "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", - "ax = plt.gca()\n", - "ax.set_facecolor('w')" + " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:49:27.992557200Z", - "start_time": "2023-06-30T07:48:48.070158100Z" + "end_time": "2023-07-04T01:38:27.853435600Z", + "start_time": "2023-07-04T01:37:48.381823700Z" } } }, { "cell_type": "markdown", "source": [ - "On average, QAOA with random quantum dropout improves the probability of correct solution (max prob) by more than 0.02 compared to regular QAOA.\n", + "On average, QAOA with random quantum dropout improves the probability of correct solution (max prob) by nearly 0.02 compared to regular QAOA.\n", "\n", "Compared with isotropic quantum dropout, the standard deviation of the probability of correct solution obtained by random quantum dropout is smaller, but the upper limit is lower. From the physical picture, QAOA after random quantum dropout works like a quantum interferometer. QAOA circuits with different dropouts over driving layers may work through a focusing effect on the true ground state: different clause sets lead to different energy landscapes and minima, whose configurations receive constructive interference and enhanced amplitudes. Being the only common minimum of all $\\hat{H}_{C_i}$ irrespective of the dropouts, the true ground state remains stand-out through all driving layers. Please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more analysis and details." ], @@ -975,7 +915,7 @@ }, { "cell_type": "code", - "execution_count": 193, + "execution_count": 30, "outputs": [ { "name": "stdout", @@ -1010,8 +950,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-06-30T07:49:27.995399900Z", - "start_time": "2023-06-30T07:49:27.993157500Z" + "end_time": "2023-07-04T01:40:31.531945400Z", + "start_time": "2023-07-04T01:40:31.478214100Z" } } } From 885fc05869957fcb9adb196dbba6afc417a82616 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 4 Jul 2023 09:58:18 +0800 Subject: [PATCH 521/725] update --- docs/source/tutorials/qaoa_nae3sat.ipynb | 8 ++++---- docs/source/tutorials/qaoa_quantum_dropout.ipynb | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/source/tutorials/qaoa_nae3sat.ipynb b/docs/source/tutorials/qaoa_nae3sat.ipynb index fc87efe6..340ec28b 100644 --- a/docs/source/tutorials/qaoa_nae3sat.ipynb +++ b/docs/source/tutorials/qaoa_nae3sat.ipynb @@ -21,7 +21,7 @@ "id": "b533d43e", "metadata": {}, "source": [ - "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In QAOA, the parameterized quantum circuit is regarded as an oracle, we sample the circuit to obtain the gradient of the parameters, and update them through the classical optimizer. Before this tutorial, there was already a tutorial of [QAOA for Max-Cut](qaoa.ipynb). In this tutorial, we will focus on another combinatorial optimization problem - Not-all-equal 3-satisfiability (NAE3SAT), and discuss the performance of QAOA in different hardness cases.\n" + "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In QAOA, the parameterized quantum circuit is regarded as an oracle, we sample the circuit to obtain the gradient of the parameters, and update them through the classical optimizer. Before this tutorial, there was already a tutorial of [QAOA for Max-Cut](qaoa.ipynb). In this tutorial, we will focus on another combinatorial optimization problem - Not-all-equal 3-satisfiability (NAE3SAT), and discuss the performance of QAOA in different hardness cases." ] }, { @@ -49,7 +49,7 @@ " (x_1\\lor x_2\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor \\lnot x_n).\n", "\\end{equation}\n", "$$\n", - "When $k$ is not less than 3, SAT is NP-complete. On the other hand, NAE3SAT requires the three literals in each clause are not all equal to each other, in other words, at least one is true, and at least one is false. It is different from 3-SAT, which requires at least one literal is true in each clause. However, NAE3SAT is still NP-complete, [which can be proven by a reduction from 3-SAT](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability).\n" + "When $k$ is not less than 3, SAT is NP-complete. On the other hand, NAE3SAT requires the three literals in each clause are not all equal to each other, in other words, at least one is true, and at least one is false. It is different from 3-SAT, which requires at least one literal is true in each clause. However, NAE3SAT is still NP-complete, [which can be proven by a reduction from 3-SAT](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability)." ] }, { @@ -94,7 +94,7 @@ " U(\\boldsymbol{\\beta}, \\boldsymbol{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", "\\end{equation}\n", "$$\n", - "where $U_{j}= e^{-i\\gamma_{j}\\hat{H}_{C}}$ is the driving layer and $V_{j}= e^{-i \\beta_{j} \\hat{H}_m}$ is the mixing layer. $H_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $\\hat{H}_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." + "where $U_{j}= e^{-\\text{i}\\gamma_{j}\\hat{H}_{C}}$ is the driving layer and $V_{j}= e^{-\\text{i}\\beta_{j} \\hat{H}_m}$ is the mixing layer. $H_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $\\hat{H}_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." ] }, { @@ -179,7 +179,7 @@ } ], "source": [ - "# a easy graph instance\n", + "# an easy graph instance\n", "easy_clauses = [[4, 7, 6], [0, 5, 9], [2, 6, 9], [2, 6, 7], [3, 1, 9], [5, 9, 11], [4, 8, 9], [5, 1, 9], [3, 8, 6], [2, 8, 10], [5, 6, 8], [2, 9, 6], [2, 6, 8], [5, 3, 9], [4, 11, 7], [3, 11, 10], [5, 10, 7], [3, 9, 8], [3, 6, 9], [2, 4, 7], [4, 0, 6], [3, 4, 6], [3, 11, 6], [4, 5, 6], [4, 0, 10], [5, 4, 10], [3, 7, 9], [0, 11, 6], [5, 11, 9], [3, 5, 9], [3, 4, 7], [3, 4, 7], [3, 0, 7], [1, 7, 8], [0, 3, 10], [0, 8, 9], [5, 7, 8], [2, 9, 6], [0, 8, 6], [4, 6, 8], [3, 2, 9], [4, 3, 8], [0, 2, 8], [4, 5, 10], [2, 4, 8], [5, 8, 9], [4, 8, 9], [3, 5, 11], [5, 4, 10], [2, 7, 9], [3, 0, 7], [2, 8, 6], [5, 3, 6], [0, 6, 10], [3, 2, 8], [4, 6, 9], [3, 2, 6], [1, 5, 6], [2, 8, 11], [2, 10, 8], [2, 0, 6], [2, 6, 9], [0, 8, 7], [0, 10, 8], [3, 5, 7], [2, 10, 8], [5, 7, 9], [0, 1, 6], [0, 3, 8], [0, 6, 9], [0, 5, 11], [1, 2, 10]]\n", "factor = 1 / len(easy_clauses) / 4\n", "\n", diff --git a/docs/source/tutorials/qaoa_quantum_dropout.ipynb b/docs/source/tutorials/qaoa_quantum_dropout.ipynb index 232d5331..681ebad2 100644 --- a/docs/source/tutorials/qaoa_quantum_dropout.ipynb +++ b/docs/source/tutorials/qaoa_quantum_dropout.ipynb @@ -21,7 +21,7 @@ { "cell_type": "markdown", "source": [ - "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In the [previous tutorial](qaoa_nae3sat.ipynb), we introduced solving the [Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) by QAOA and the dilemma of QAOA on the hard problem. In this tutorial, we will introduce a simple trick to alleviate this dilemma, namely quantum dropout, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more details.\n" + "Quantum Approximation Optimization Algorithm (QAOA) is a hybrid classical-quantum algorithm used for solving the combinatorial optimization problem, which is proposed by [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028). In the [previous tutorial](qaoa_nae3sat.ipynb), we introduced solving the [Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) by QAOA and the dilemma of QAOA on the hard problem. In this tutorial, we will introduce a simple trick to alleviate this dilemma, namely quantum dropout, please refer to [Wang, Zheng, Wu, and Zhang (2023)](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.023171) for more details." ], "metadata": { "collapsed": false From dae587f4968d6cfbceea1f0019ec23a71de9d486 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 4 Jul 2023 10:04:35 +0800 Subject: [PATCH 522/725] update --- docs/source/tutorials/qaoa_nae3sat.ipynb | 4 ++-- docs/source/tutorials/qaoa_quantum_dropout.ipynb | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/source/tutorials/qaoa_nae3sat.ipynb b/docs/source/tutorials/qaoa_nae3sat.ipynb index 340ec28b..1d35a53b 100644 --- a/docs/source/tutorials/qaoa_nae3sat.ipynb +++ b/docs/source/tutorials/qaoa_nae3sat.ipynb @@ -94,7 +94,7 @@ " U(\\boldsymbol{\\beta}, \\boldsymbol{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", "\\end{equation}\n", "$$\n", - "where $U_{j}= e^{-\\text{i}\\gamma_{j}\\hat{H}_{C}}$ is the driving layer and $V_{j}= e^{-\\text{i}\\beta_{j} \\hat{H}_m}$ is the mixing layer. $H_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $\\hat{H}_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." + "where $U_{j}= e^{-\\text{i}\\gamma_{j}\\hat{H}_{C}}$ is the driving layer and $V_{j}= e^{-\\text{i}\\beta_{j} \\hat{H}_m}$ is the mixing layer. $\\hat{H}_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $\\hat{H}_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." ] }, { @@ -102,7 +102,7 @@ "id": "949be36e", "metadata": {}, "source": [ - "Begin with a set of initial $\\boldsymbol{\\gamma}$ and $\\boldsymbol{\\beta}$, the quantum state is obtained from the PQC and then the expectation value of $H_C$ is calculated. A classical optimizer is then used to vary the parameters until a lower expectation value is found. This process is iterated a certain number of times until the expectation value of $H_C$ is approximated to 0. Then we perform projective measurement on the quantum state output by PQC, and obtain a bit string, which is very likely to be the solution of NAE3SAT. Since NAE3SAT is an NP-complete problem, we can verify whether the solution is correct in polynomial time on classical computer. Even if this bit string is not the correct solution, we can repeat the projective measurement and verify the obtained solution until we get the correct solution.\n", + "Begin with a set of initial $\\boldsymbol{\\gamma}$ and $\\boldsymbol{\\beta}$, the quantum state is obtained from the PQC and then the expectation value of $\\hat{H}_C$ is calculated. A classical optimizer is then used to vary the parameters until a lower expectation value is found. This process is iterated a certain number of times until the expectation value of $\\hat{H}_C$ is approximated to 0. Then we perform projective measurement on the quantum state output by PQC, and obtain a bit string, which is very likely to be the solution of NAE3SAT. Since NAE3SAT is an NP-complete problem, we can verify whether the solution is correct in polynomial time on classical computer. Even if this bit string is not the correct solution, we can repeat the projective measurement and verify the obtained solution until we get the correct solution.\n", "\n", "For other details of QAOA, such as the selection of $p$ and the overall algorithm loop, please refer to [Farhi, Goldstone, and Gutmann (2014)](https://arxiv.org/abs/1411.4028) or the tutorial of [QAOA for Max-Cut](qaoa.ipynb)." ] diff --git a/docs/source/tutorials/qaoa_quantum_dropout.ipynb b/docs/source/tutorials/qaoa_quantum_dropout.ipynb index 681ebad2..0fb26537 100644 --- a/docs/source/tutorials/qaoa_quantum_dropout.ipynb +++ b/docs/source/tutorials/qaoa_quantum_dropout.ipynb @@ -124,7 +124,7 @@ { "cell_type": "markdown", "source": [ - "We use the same NAE3SAT as the previous tutorial." + "We use the same NAE3SAT as the [previous tutorial](qaoa_nae3sat.ipynb)." ], "metadata": { "collapsed": false @@ -659,7 +659,7 @@ { "cell_type": "markdown", "source": [ - "Because the dropout of each layer is different, we need to generate $\\text{nlayers}$ graphs after dropout. In order to perform just-in-time (JIT) compilation more conveniently, here we only save the weights in the order of the edges of the original $\\text{hard\\_graph}$, instead of saving each graph after dropout." + "Because the dropout of each layer is different, we need to generate $\\text{nlayers}$ graphs after dropout. In order to perform just-in-time (JIT) compilation more conveniently, here we only save the weights in the order of the edges of the original hard graph, instead of saving each graph after dropout." ], "metadata": { "collapsed": false From b959b0afec44fe7eaa68679c1de0cbc19197e4a5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 4 Jul 2023 10:51:04 +0800 Subject: [PATCH 523/725] black --- docs/source/tutorials/qaoa_nae3sat.ipynb | 248 ++++++++++++++---- .../tutorials/qaoa_quantum_dropout.ipynb | 174 ++++++++---- 2 files changed, 332 insertions(+), 90 deletions(-) diff --git a/docs/source/tutorials/qaoa_nae3sat.ipynb b/docs/source/tutorials/qaoa_nae3sat.ipynb index 1d35a53b..46b7e327 100644 --- a/docs/source/tutorials/qaoa_nae3sat.ipynb +++ b/docs/source/tutorials/qaoa_nae3sat.ipynb @@ -136,7 +136,7 @@ "from IPython.display import clear_output\n", "import random\n", "\n", - "K = tc.set_backend('jax')\n", + "K = tc.set_backend(\"jax\")\n", "\n", "nlayers = 30 # the number of layers\n", "ncircuits = 6 # six circuits with different initial parameters are going to be optimized at the same time" @@ -180,7 +180,80 @@ ], "source": [ "# an easy graph instance\n", - "easy_clauses = [[4, 7, 6], [0, 5, 9], [2, 6, 9], [2, 6, 7], [3, 1, 9], [5, 9, 11], [4, 8, 9], [5, 1, 9], [3, 8, 6], [2, 8, 10], [5, 6, 8], [2, 9, 6], [2, 6, 8], [5, 3, 9], [4, 11, 7], [3, 11, 10], [5, 10, 7], [3, 9, 8], [3, 6, 9], [2, 4, 7], [4, 0, 6], [3, 4, 6], [3, 11, 6], [4, 5, 6], [4, 0, 10], [5, 4, 10], [3, 7, 9], [0, 11, 6], [5, 11, 9], [3, 5, 9], [3, 4, 7], [3, 4, 7], [3, 0, 7], [1, 7, 8], [0, 3, 10], [0, 8, 9], [5, 7, 8], [2, 9, 6], [0, 8, 6], [4, 6, 8], [3, 2, 9], [4, 3, 8], [0, 2, 8], [4, 5, 10], [2, 4, 8], [5, 8, 9], [4, 8, 9], [3, 5, 11], [5, 4, 10], [2, 7, 9], [3, 0, 7], [2, 8, 6], [5, 3, 6], [0, 6, 10], [3, 2, 8], [4, 6, 9], [3, 2, 6], [1, 5, 6], [2, 8, 11], [2, 10, 8], [2, 0, 6], [2, 6, 9], [0, 8, 7], [0, 10, 8], [3, 5, 7], [2, 10, 8], [5, 7, 9], [0, 1, 6], [0, 3, 8], [0, 6, 9], [0, 5, 11], [1, 2, 10]]\n", + "easy_clauses = [\n", + " [4, 7, 6],\n", + " [0, 5, 9],\n", + " [2, 6, 9],\n", + " [2, 6, 7],\n", + " [3, 1, 9],\n", + " [5, 9, 11],\n", + " [4, 8, 9],\n", + " [5, 1, 9],\n", + " [3, 8, 6],\n", + " [2, 8, 10],\n", + " [5, 6, 8],\n", + " [2, 9, 6],\n", + " [2, 6, 8],\n", + " [5, 3, 9],\n", + " [4, 11, 7],\n", + " [3, 11, 10],\n", + " [5, 10, 7],\n", + " [3, 9, 8],\n", + " [3, 6, 9],\n", + " [2, 4, 7],\n", + " [4, 0, 6],\n", + " [3, 4, 6],\n", + " [3, 11, 6],\n", + " [4, 5, 6],\n", + " [4, 0, 10],\n", + " [5, 4, 10],\n", + " [3, 7, 9],\n", + " [0, 11, 6],\n", + " [5, 11, 9],\n", + " [3, 5, 9],\n", + " [3, 4, 7],\n", + " [3, 4, 7],\n", + " [3, 0, 7],\n", + " [1, 7, 8],\n", + " [0, 3, 10],\n", + " [0, 8, 9],\n", + " [5, 7, 8],\n", + " [2, 9, 6],\n", + " [0, 8, 6],\n", + " [4, 6, 8],\n", + " [3, 2, 9],\n", + " [4, 3, 8],\n", + " [0, 2, 8],\n", + " [4, 5, 10],\n", + " [2, 4, 8],\n", + " [5, 8, 9],\n", + " [4, 8, 9],\n", + " [3, 5, 11],\n", + " [5, 4, 10],\n", + " [2, 7, 9],\n", + " [3, 0, 7],\n", + " [2, 8, 6],\n", + " [5, 3, 6],\n", + " [0, 6, 10],\n", + " [3, 2, 8],\n", + " [4, 6, 9],\n", + " [3, 2, 6],\n", + " [1, 5, 6],\n", + " [2, 8, 11],\n", + " [2, 10, 8],\n", + " [2, 0, 6],\n", + " [2, 6, 9],\n", + " [0, 8, 7],\n", + " [0, 10, 8],\n", + " [3, 5, 7],\n", + " [2, 10, 8],\n", + " [5, 7, 9],\n", + " [0, 1, 6],\n", + " [0, 3, 8],\n", + " [0, 6, 9],\n", + " [0, 5, 11],\n", + " [1, 2, 10],\n", + "]\n", "factor = 1 / len(easy_clauses) / 4\n", "\n", "# convert to a NetworkX graph\n", @@ -190,13 +263,13 @@ " easy_graph.add_edge(j, k, weight=0)\n", " easy_graph.add_edge(k, i, weight=0)\n", "for i, j, k in easy_clauses:\n", - " easy_graph[i][j]['weight'] += 1\n", - " easy_graph[j][k]['weight'] += 1\n", - " easy_graph[k][i]['weight'] += 1\n", + " easy_graph[i][j][\"weight\"] += 1\n", + " easy_graph[j][k][\"weight\"] += 1\n", + " easy_graph[k][i][\"weight\"] += 1\n", "pos_easy = nx.spring_layout(easy_graph)\n", "nx.draw_networkx(easy_graph, with_labels=True, pos=pos_easy)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ] }, { @@ -228,7 +301,7 @@ " for j in range(each):\n", " # driving layer\n", " for a, b in g.edges:\n", - " c_.RZZ(a, b, theta=g[a][b]['weight'] * params_[2 * j] * factor)\n", + " c_.RZZ(a, b, theta=g[a][b][\"weight\"] * params_[2 * j] * factor)\n", " # mixing layer\n", " for i in range(n):\n", " c_.RX(i, theta=params_[2 * j + 1])\n", @@ -249,7 +322,7 @@ " # calculate the loss function\n", " loss = 0.25\n", " for a, b in g.edges:\n", - " loss += c.expectation_ps(z=[a, b]) * g[a][b]['weight'] * factor\n", + " loss += c.expectation_ps(z=[a, b]) * g[a][b][\"weight\"] * factor\n", "\n", " return K.real(loss)" ] @@ -294,10 +367,14 @@ ], "source": [ "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3))\n", + "QAOA_vvag = K.jit(\n", + " K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3)\n", + ")\n", "\n", - "params_easy = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", - "if type(K).__name__ == 'JaxBackend':\n", + "params_easy = K.implicit_randn(\n", + " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", + ") # initial parameters\n", + "if type(K).__name__ == \"JaxBackend\":\n", " opt = K.optimizer(optax.adam(1e-2))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", @@ -311,11 +388,11 @@ " # visualise the progress\n", " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", - " plt.xlabel('Iteration')\n", - " plt.ylabel('Cost')\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Cost\")\n", " for index in range(ncircuits):\n", " plt.plot(range(i + 1), list_of_loss[index])\n", - " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " legend = [f\"circuit {leg}\" for leg in range(ncircuits)]\n", " plt.legend(legend)\n", " plt.show()" ] @@ -391,7 +468,7 @@ "source": [ "# print QAOA results\n", "for num_circuit in range(ncircuits):\n", - " print(f'Circuit #{num_circuit}')\n", + " print(f\"Circuit #{num_circuit}\")\n", " c = QAOAansatz(params=params_easy[num_circuit], g=easy_graph, return_circuit=True)\n", " loss = QAOAansatz(params=params_easy[num_circuit], g=easy_graph)\n", "\n", @@ -401,9 +478,9 @@ " index = np.where(probs == max_prob)[0]\n", " states = []\n", " for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", + " states.append(f\"{bin(i)[2:]:0>{c._nqubits}}\")\n", "\n", - " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')" + " print(f\"cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n\")" ] }, { @@ -437,17 +514,19 @@ "def b2s(bit):\n", " return 1 - 2 * int(bit)\n", "\n", + "\n", "def energy(cfg, graph, normalize=True):\n", " E = 0.25\n", " for a, b in graph.edges:\n", - " E += cfg[a] * cfg[b] * graph[a][b]['weight'] * factor\n", + " E += cfg[a] * cfg[b] * graph[a][b][\"weight\"] * factor\n", " return E if normalize else E / factor\n", "\n", + "\n", "def brutal_force(graph):\n", " num_nodes = graph.number_of_nodes()\n", - " min_cost, best_case = 1., []\n", - " for i in range(2 ** num_nodes):\n", - " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + " min_cost, best_case = 1.0, []\n", + " for i in range(2**num_nodes):\n", + " case = f\"{bin(i)[2:]:0>{num_nodes}}\"\n", "\n", " cost = energy(list(map(b2s, case)), graph)\n", "\n", @@ -496,13 +575,13 @@ "source": [ "# print BF results\n", "bf_best_cases, bf_best = brutal_force(easy_graph)\n", - "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "print(f\"cost: {bf_best:.3f}\\nbit string: {bf_best_cases}\")\n", "\n", "# plot NetworkX graph\n", - "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in easy_graph.nodes]\n", + "colors = [\"r\" if bf_best_cases[0][i] == \"0\" else \"c\" for i in easy_graph.nodes]\n", "nx.draw_networkx(easy_graph, with_labels=True, node_color=colors, pos=pos_easy)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ] }, { @@ -546,7 +625,7 @@ " else:\n", " next_state[flip_idx] = 1 - next_state[flip_idx]\n", " t += 1\n", - " return ''.join(map(str, state.tolist())), E" + " return \"\".join(map(str, state.tolist())), E" ] }, { @@ -576,7 +655,7 @@ ], "source": [ "# print SA results\n", - "sa_best_cases, sa_best, n_exp = [], float('inf'), 100\n", + "sa_best_cases, sa_best, n_exp = [], float(\"inf\"), 100\n", "for _ in range(n_exp):\n", " sa_case, sa_cost = sim_annealing(easy_graph, 200, 1)\n", " gap = sa_best - sa_cost\n", @@ -587,7 +666,7 @@ " sa_best_cases.append(sa_case)\n", "sa_prob = len(sa_best_cases) / n_exp\n", "sa_best_cases = list(set(sa_best_cases))\n", - "print(f'cost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')" + "print(f\"cost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}\")" ] }, { @@ -628,7 +707,80 @@ ], "source": [ "# a hard graph instance\n", - "hard_clauses = [[4, 1, 7], [5, 11, 8], [4, 1, 8], [4, 11, 8], [4, 1, 10], [5, 11, 8], [4, 1, 8], [1, 11, 8], [4, 1, 7], [0, 11, 8], [4, 1, 10], [4, 11, 8], [5, 0, 10], [0, 6, 7], [5, 0, 11], [0, 6, 7], [5, 0, 9], [3, 6, 7], [5, 0, 8], [5, 6, 7], [5, 0, 10], [3, 6, 7], [5, 0, 10], [1, 6, 7], [2, 4, 6], [1, 8, 11], [2, 4, 6], [2, 8, 11], [2, 4, 9], [5, 8, 11], [2, 4, 10], [2, 8, 11], [2, 4, 10], [4, 8, 11], [2, 4, 8], [4, 8, 11], [3, 0, 9], [5, 11, 7], [3, 0, 10], [2, 11, 7], [3, 0, 9], [0, 11, 7], [3, 0, 9], [5, 11, 7], [3, 0, 10], [3, 11, 7], [3, 0, 7], [4, 11, 7], [5, 0, 10], [4, 0, 10], [2, 5, 6], [2, 11, 10], [2, 6, 10], [2, 4, 9], [0, 9, 10], [3, 0, 7], [2, 5, 6], [1, 10, 9], [1, 4, 11], [5, 10, 11], [0, 4, 8], [0, 9, 8], [2, 11, 10], [2, 8, 6], [3, 6, 7], [0, 8, 10], [4, 0, 9], [3, 5, 8], [5, 11, 10], [2, 11, 10], [4, 11, 8], [1, 3, 11]]\n", + "hard_clauses = [\n", + " [4, 1, 7],\n", + " [5, 11, 8],\n", + " [4, 1, 8],\n", + " [4, 11, 8],\n", + " [4, 1, 10],\n", + " [5, 11, 8],\n", + " [4, 1, 8],\n", + " [1, 11, 8],\n", + " [4, 1, 7],\n", + " [0, 11, 8],\n", + " [4, 1, 10],\n", + " [4, 11, 8],\n", + " [5, 0, 10],\n", + " [0, 6, 7],\n", + " [5, 0, 11],\n", + " [0, 6, 7],\n", + " [5, 0, 9],\n", + " [3, 6, 7],\n", + " [5, 0, 8],\n", + " [5, 6, 7],\n", + " [5, 0, 10],\n", + " [3, 6, 7],\n", + " [5, 0, 10],\n", + " [1, 6, 7],\n", + " [2, 4, 6],\n", + " [1, 8, 11],\n", + " [2, 4, 6],\n", + " [2, 8, 11],\n", + " [2, 4, 9],\n", + " [5, 8, 11],\n", + " [2, 4, 10],\n", + " [2, 8, 11],\n", + " [2, 4, 10],\n", + " [4, 8, 11],\n", + " [2, 4, 8],\n", + " [4, 8, 11],\n", + " [3, 0, 9],\n", + " [5, 11, 7],\n", + " [3, 0, 10],\n", + " [2, 11, 7],\n", + " [3, 0, 9],\n", + " [0, 11, 7],\n", + " [3, 0, 9],\n", + " [5, 11, 7],\n", + " [3, 0, 10],\n", + " [3, 11, 7],\n", + " [3, 0, 7],\n", + " [4, 11, 7],\n", + " [5, 0, 10],\n", + " [4, 0, 10],\n", + " [2, 5, 6],\n", + " [2, 11, 10],\n", + " [2, 6, 10],\n", + " [2, 4, 9],\n", + " [0, 9, 10],\n", + " [3, 0, 7],\n", + " [2, 5, 6],\n", + " [1, 10, 9],\n", + " [1, 4, 11],\n", + " [5, 10, 11],\n", + " [0, 4, 8],\n", + " [0, 9, 8],\n", + " [2, 11, 10],\n", + " [2, 8, 6],\n", + " [3, 6, 7],\n", + " [0, 8, 10],\n", + " [4, 0, 9],\n", + " [3, 5, 8],\n", + " [5, 11, 10],\n", + " [2, 11, 10],\n", + " [4, 11, 8],\n", + " [1, 3, 11],\n", + "]\n", "factor = 1 / len(hard_clauses) / 4\n", "\n", "# convert to a NetworkX graph\n", @@ -638,13 +790,13 @@ " hard_graph.add_edge(j, k, weight=0)\n", " hard_graph.add_edge(k, i, weight=0)\n", "for i, j, k in hard_clauses:\n", - " hard_graph[i][j]['weight'] += 1\n", - " hard_graph[j][k]['weight'] += 1\n", - " hard_graph[k][i]['weight'] += 1\n", + " hard_graph[i][j][\"weight\"] += 1\n", + " hard_graph[j][k][\"weight\"] += 1\n", + " hard_graph[k][i][\"weight\"] += 1\n", "pos_hard = nx.spring_layout(hard_graph)\n", "nx.draw_networkx(hard_graph, with_labels=True, pos=pos_hard)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ] }, { @@ -690,13 +842,13 @@ "source": [ "# print BF results\n", "bf_best_cases, bf_best = brutal_force(hard_graph)\n", - "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "print(f\"cost: {bf_best:.3f}\\nbit string: {bf_best_cases}\")\n", "\n", "# plot NetworkX graph\n", - "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in hard_graph.nodes]\n", + "colors = [\"r\" if bf_best_cases[0][i] == \"0\" else \"c\" for i in hard_graph.nodes]\n", "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos_hard)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ] }, { @@ -726,7 +878,7 @@ ], "source": [ "# print SA results\n", - "sa_best_cases, sa_best, n_exp = [], float('inf'), 100\n", + "sa_best_cases, sa_best, n_exp = [], float(\"inf\"), 100\n", "for _ in range(n_exp):\n", " sa_case, sa_cost = sim_annealing(hard_graph, 200, 1)\n", " gap = sa_best - sa_cost\n", @@ -737,7 +889,7 @@ " sa_best_cases.append(sa_case)\n", "sa_prob = len(sa_best_cases) / n_exp\n", "sa_best_cases = list(set(sa_best_cases))\n", - "print(f'cost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}')" + "print(f\"cost: {sa_best:.3f}\\nprob: {sa_prob:.3f}\\nbit string: {sa_best_cases}\")" ] }, { @@ -782,10 +934,14 @@ ], "source": [ "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3))\n", + "QAOA_vvag = K.jit(\n", + " K.vvag(QAOAansatz, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3)\n", + ")\n", "\n", - "params_hard = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", - "if type(K).__name__ == 'JaxBackend':\n", + "params_hard = K.implicit_randn(\n", + " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", + ") # initial parameters\n", + "if type(K).__name__ == \"JaxBackend\":\n", " opt = K.optimizer(optax.adam(1e-2))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", @@ -799,11 +955,11 @@ " # visualise the progress\n", " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", - " plt.xlabel('Iteration')\n", - " plt.ylabel('Cost')\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Cost\")\n", " for index in range(ncircuits):\n", " plt.plot(range(i + 1), list_of_loss[index])\n", - " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " legend = [f\"circuit {leg}\" for leg in range(ncircuits)]\n", " plt.legend(legend)\n", " plt.show()" ] @@ -863,7 +1019,7 @@ "source": [ "# print QAOA results\n", "for num_circuit in range(ncircuits):\n", - " print(f'Circuit #{num_circuit}')\n", + " print(f\"Circuit #{num_circuit}\")\n", " c = QAOAansatz(params=params_hard[num_circuit], g=hard_graph, return_circuit=True)\n", " loss = QAOAansatz(params=params_hard[num_circuit], g=hard_graph)\n", "\n", @@ -873,8 +1029,8 @@ " index = np.where(probs == max_prob)[0]\n", " states = []\n", " for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')" + " states.append(f\"{bin(i)[2:]:0>{c._nqubits}}\")\n", + " print(f\"cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n\")" ] }, { diff --git a/docs/source/tutorials/qaoa_quantum_dropout.ipynb b/docs/source/tutorials/qaoa_quantum_dropout.ipynb index 0fb26537..0e812ab5 100644 --- a/docs/source/tutorials/qaoa_quantum_dropout.ipynb +++ b/docs/source/tutorials/qaoa_quantum_dropout.ipynb @@ -111,11 +111,11 @@ "from IPython.display import clear_output\n", "import random\n", "\n", - "K = tc.set_backend('jax')\n", + "K = tc.set_backend(\"jax\")\n", "\n", "nlayers = 30 # the number of layers\n", "ncircuits = 6 # six circuits with different initial parameters are going to be optimized at the same time\n", - "R = 0.5 # dropout ratio, 0 means no dropout, 1 means all dropout" + "R = 0.5 # dropout ratio, 0 means no dropout, 1 means all dropout" ], "metadata": { "collapsed": false @@ -136,7 +136,80 @@ "outputs": [], "source": [ "# a hard graph instance\n", - "hard_clauses = [[4, 1, 7], [5, 11, 8], [4, 1, 8], [4, 11, 8], [4, 1, 10], [5, 11, 8], [4, 1, 8], [1, 11, 8], [4, 1, 7], [0, 11, 8], [4, 1, 10], [4, 11, 8], [5, 0, 10], [0, 6, 7], [5, 0, 11], [0, 6, 7], [5, 0, 9], [3, 6, 7], [5, 0, 8], [5, 6, 7], [5, 0, 10], [3, 6, 7], [5, 0, 10], [1, 6, 7], [2, 4, 6], [1, 8, 11], [2, 4, 6], [2, 8, 11], [2, 4, 9], [5, 8, 11], [2, 4, 10], [2, 8, 11], [2, 4, 10], [4, 8, 11], [2, 4, 8], [4, 8, 11], [3, 0, 9], [5, 11, 7], [3, 0, 10], [2, 11, 7], [3, 0, 9], [0, 11, 7], [3, 0, 9], [5, 11, 7], [3, 0, 10], [3, 11, 7], [3, 0, 7], [4, 11, 7], [5, 0, 10], [4, 0, 10], [2, 5, 6], [2, 11, 10], [2, 6, 10], [2, 4, 9], [0, 9, 10], [3, 0, 7], [2, 5, 6], [1, 10, 9], [1, 4, 11], [5, 10, 11], [0, 4, 8], [0, 9, 8], [2, 11, 10], [2, 8, 6], [3, 6, 7], [0, 8, 10], [4, 0, 9], [3, 5, 8], [5, 11, 10], [2, 11, 10], [4, 11, 8], [1, 3, 11]]\n", + "hard_clauses = [\n", + " [4, 1, 7],\n", + " [5, 11, 8],\n", + " [4, 1, 8],\n", + " [4, 11, 8],\n", + " [4, 1, 10],\n", + " [5, 11, 8],\n", + " [4, 1, 8],\n", + " [1, 11, 8],\n", + " [4, 1, 7],\n", + " [0, 11, 8],\n", + " [4, 1, 10],\n", + " [4, 11, 8],\n", + " [5, 0, 10],\n", + " [0, 6, 7],\n", + " [5, 0, 11],\n", + " [0, 6, 7],\n", + " [5, 0, 9],\n", + " [3, 6, 7],\n", + " [5, 0, 8],\n", + " [5, 6, 7],\n", + " [5, 0, 10],\n", + " [3, 6, 7],\n", + " [5, 0, 10],\n", + " [1, 6, 7],\n", + " [2, 4, 6],\n", + " [1, 8, 11],\n", + " [2, 4, 6],\n", + " [2, 8, 11],\n", + " [2, 4, 9],\n", + " [5, 8, 11],\n", + " [2, 4, 10],\n", + " [2, 8, 11],\n", + " [2, 4, 10],\n", + " [4, 8, 11],\n", + " [2, 4, 8],\n", + " [4, 8, 11],\n", + " [3, 0, 9],\n", + " [5, 11, 7],\n", + " [3, 0, 10],\n", + " [2, 11, 7],\n", + " [3, 0, 9],\n", + " [0, 11, 7],\n", + " [3, 0, 9],\n", + " [5, 11, 7],\n", + " [3, 0, 10],\n", + " [3, 11, 7],\n", + " [3, 0, 7],\n", + " [4, 11, 7],\n", + " [5, 0, 10],\n", + " [4, 0, 10],\n", + " [2, 5, 6],\n", + " [2, 11, 10],\n", + " [2, 6, 10],\n", + " [2, 4, 9],\n", + " [0, 9, 10],\n", + " [3, 0, 7],\n", + " [2, 5, 6],\n", + " [1, 10, 9],\n", + " [1, 4, 11],\n", + " [5, 10, 11],\n", + " [0, 4, 8],\n", + " [0, 9, 8],\n", + " [2, 11, 10],\n", + " [2, 8, 6],\n", + " [3, 6, 7],\n", + " [0, 8, 10],\n", + " [4, 0, 9],\n", + " [3, 5, 8],\n", + " [5, 11, 10],\n", + " [2, 11, 10],\n", + " [4, 11, 8],\n", + " [1, 3, 11],\n", + "]\n", "cost_factor = 1 / len(hard_clauses) / 4" ], "metadata": { @@ -160,9 +233,9 @@ " graph.add_edge(j, k, weight=0)\n", " graph.add_edge(k, i, weight=0)\n", " for i, j, k in clauses:\n", - " graph[i][j]['weight'] += 1\n", - " graph[j][k]['weight'] += 1\n", - " graph[k][i]['weight'] += 1\n", + " graph[i][j][\"weight\"] += 1\n", + " graph[j][k][\"weight\"] += 1\n", + " graph[k][i][\"weight\"] += 1\n", " return graph" ], "metadata": { @@ -192,7 +265,7 @@ "pos = nx.spring_layout(hard_graph)\n", "nx.draw_networkx(hard_graph, with_labels=True, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ], "metadata": { "collapsed": false, @@ -219,18 +292,20 @@ "def b2s(bit):\n", " return 1 - 2 * int(bit)\n", "\n", + "\n", "def energy(cfg, graph, n_cls, normalize=True):\n", " factor = 1 / n_cls / 4\n", " E = 0.25\n", " for a, b in graph.edges:\n", - " E += cfg[a] * cfg[b] * graph[a][b]['weight'] * factor\n", + " E += cfg[a] * cfg[b] * graph[a][b][\"weight\"] * factor\n", " return E if normalize else E / factor\n", "\n", + "\n", "def brutal_force(graph):\n", " num_nodes, n_cls = graph.number_of_nodes(), len(hard_clauses)\n", - " min_cost, best_case = 1., []\n", - " for i in range(2 ** num_nodes):\n", - " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + " min_cost, best_case = 1.0, []\n", + " for i in range(2**num_nodes):\n", + " case = f\"{bin(i)[2:]:0>{num_nodes}}\"\n", "\n", " cost = energy(list(map(b2s, case)), graph, n_cls)\n", "\n", @@ -275,13 +350,13 @@ "source": [ "# print BF results\n", "bf_best_cases, bf_best = brutal_force(hard_graph)\n", - "print(f'cost: {bf_best:.3f}\\nbit string: {bf_best_cases}')\n", + "print(f\"cost: {bf_best:.3f}\\nbit string: {bf_best_cases}\")\n", "\n", "# plot NetworkX graph\n", - "colors = ['r' if bf_best_cases[0][i] == '0' else 'c' for i in hard_graph.nodes]\n", + "colors = [\"r\" if bf_best_cases[0][i] == \"0\" else \"c\" for i in hard_graph.nodes]\n", "nx.draw_networkx(hard_graph, with_labels=True, node_color=colors, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ], "metadata": { "collapsed": false, @@ -351,7 +426,7 @@ " sa_case, sa_cost = sim_annealing(hard_graph, 200, 1)\n", " if sa_cost > 1e-6:\n", " ll_excited.add(sa_case)\n", - "print(f'number of low-lying excited states: {len(ll_excited)}')" + "print(f\"number of low-lying excited states: {len(ll_excited)}\")" ], "metadata": { "collapsed": false, @@ -390,13 +465,14 @@ " drop.append(cls)\n", " return kept, drop\n", "\n", + "\n", "kept_clauses, drop_clauses = get_clauses(ll_excited, hard_clauses)\n", "num_selected = int((1 - R) * len(drop_clauses))\n", "num_after_drop = len(kept_clauses) + num_selected\n", "driving_factor = 1 / num_after_drop / 4\n", - "print(f'number of clauses should be kept: {len(kept_clauses)}')\n", - "print(f'number of clauses can be discarded: {len(drop_clauses)}')\n", - "print(f'number of clauses after dropout: {num_after_drop}')" + "print(f\"number of clauses should be kept: {len(kept_clauses)}\")\n", + "print(f\"number of clauses can be discarded: {len(drop_clauses)}\")\n", + "print(f\"number of clauses after dropout: {num_after_drop}\")" ], "metadata": { "collapsed": false, @@ -443,7 +519,7 @@ "iso_graph = construct_graph(iso_clauses)\n", "nx.draw_networkx(iso_graph, with_labels=True, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ], "metadata": { "collapsed": false, @@ -476,7 +552,7 @@ " for j in range(each):\n", " # driving layer\n", " for a, b in g.edges:\n", - " c_.RZZ(a, b, theta=g[a][b]['weight'] * params_[2 * j] * driving_factor)\n", + " c_.RZZ(a, b, theta=g[a][b][\"weight\"] * params_[2 * j] * driving_factor)\n", " # mixing layer\n", " for i in range(n):\n", " c_.RX(i, theta=params_[2 * j + 1])\n", @@ -497,7 +573,7 @@ " # calculate the loss function\n", " loss = 0.25\n", " for a, b in hard_graph.edges:\n", - " loss += c.expectation_ps(z=[a, b]) * hard_graph[a][b]['weight'] * cost_factor\n", + " loss += c.expectation_ps(z=[a, b]) * hard_graph[a][b][\"weight\"] * cost_factor\n", "\n", " return K.real(loss)" ], @@ -533,10 +609,14 @@ ], "source": [ "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(K.vvag(QAOAansatz_iso, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3))\n", + "QAOA_vvag = K.jit(\n", + " K.vvag(QAOAansatz_iso, argnums=0, vectorized_argnums=0), static_argnums=(1, 2, 3)\n", + ")\n", "\n", - "params_iso = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", - "if type(K).__name__ == 'JaxBackend':\n", + "params_iso = K.implicit_randn(\n", + " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", + ") # initial parameters\n", + "if type(K).__name__ == \"JaxBackend\":\n", " opt = K.optimizer(optax.adam(1e-2))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", @@ -550,11 +630,11 @@ " # visualise the progress\n", " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", - " plt.xlabel('Iteration')\n", - " plt.ylabel('Cost')\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Cost\")\n", " for index in range(ncircuits):\n", " plt.plot(range(i + 1), list_of_loss[index])\n", - " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " legend = [f\"circuit {leg}\" for leg in range(ncircuits)]\n", " plt.legend(legend)\n", " plt.show()" ], @@ -615,7 +695,7 @@ "source": [ "# print QAOA results\n", "for num_circuit in range(ncircuits):\n", - " print(f'Circuit #{num_circuit}')\n", + " print(f\"Circuit #{num_circuit}\")\n", " c = QAOAansatz_iso(params=params_iso[num_circuit], g=iso_graph, return_circuit=True)\n", " loss = QAOAansatz_iso(params=params_iso[num_circuit], g=iso_graph)\n", "\n", @@ -625,8 +705,8 @@ " index = np.where(probs == max_prob)[0]\n", " states = []\n", " for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')" + " states.append(f\"{bin(i)[2:]:0>{c._nqubits}}\")\n", + " print(f\"cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n\")" ], "metadata": { "collapsed": false, @@ -673,7 +753,7 @@ "def graph_weights(graph):\n", " gw = []\n", " for a, b in hard_graph.edges:\n", - " gw.append(graph[a].get(b, default={'weight': 0})['weight'])\n", + " gw.append(graph[a].get(b, default={\"weight\": 0})[\"weight\"])\n", " return jnp.asarray(gw)" ], "metadata": { @@ -711,11 +791,11 @@ " rnd_clauses = kept_clauses + random.sample(drop_clauses, num_selected)\n", " rnd_graph = construct_graph(rnd_clauses)\n", " rnd_graphs_w.append(graph_weights(rnd_graph))\n", - "print('Here is the graph of the H_C of the last driving layer:')\n", + "print(\"Here is the graph of the H_C of the last driving layer:\")\n", "rnd_graphs_w = jnp.stack(rnd_graphs_w, axis=0)\n", "nx.draw_networkx(rnd_graph, with_labels=True, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ], "metadata": { "collapsed": false, @@ -772,7 +852,7 @@ " # calculate the loss function\n", " loss = 0.25\n", " for a, b in hard_graph.edges:\n", - " loss += c.expectation_ps(z=[a, b]) * hard_graph[a][b]['weight'] * cost_factor\n", + " loss += c.expectation_ps(z=[a, b]) * hard_graph[a][b][\"weight\"] * cost_factor\n", "\n", " return K.real(loss)" ], @@ -808,10 +888,14 @@ ], "source": [ "# use vvag to get the losses and gradients with different random circuit instances\n", - "QAOA_vvag = K.jit(K.vvag(partial(QAOAansatz_rnd, g=rnd_graphs_w), argnums=0, vectorized_argnums=0))\n", + "QAOA_vvag = K.jit(\n", + " K.vvag(partial(QAOAansatz_rnd, g=rnd_graphs_w), argnums=0, vectorized_argnums=0)\n", + ")\n", "\n", - "params_rnd = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # initial parameters\n", - "if type(K).__name__ == 'JaxBackend':\n", + "params_rnd = K.implicit_randn(\n", + " shape=[ncircuits, 2 * nlayers], stddev=0.1\n", + ") # initial parameters\n", + "if type(K).__name__ == \"JaxBackend\":\n", " opt = K.optimizer(optax.adam(1e-2))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))\n", @@ -825,11 +909,11 @@ " # visualise the progress\n", " clear_output(wait=True)\n", " list_of_loss = np.hstack((list_of_loss, K.numpy(loss)[:, np.newaxis]))\n", - " plt.xlabel('Iteration')\n", - " plt.ylabel('Cost')\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Cost\")\n", " for index in range(ncircuits):\n", " plt.plot(range(i + 1), list_of_loss[index])\n", - " legend = [f'circuit {leg}' for leg in range(ncircuits)]\n", + " legend = [f\"circuit {leg}\" for leg in range(ncircuits)]\n", " plt.legend(legend)\n", " plt.show()" ], @@ -881,8 +965,10 @@ "source": [ "# print QAOA results\n", "for num_circuit in range(ncircuits):\n", - " print(f'Circuit #{num_circuit}')\n", - " c = QAOAansatz_rnd(params=params_rnd[num_circuit], g=rnd_graphs_w, return_circuit=True)\n", + " print(f\"Circuit #{num_circuit}\")\n", + " c = QAOAansatz_rnd(\n", + " params=params_rnd[num_circuit], g=rnd_graphs_w, return_circuit=True\n", + " )\n", " loss = QAOAansatz_rnd(params=params_rnd[num_circuit], g=rnd_graphs_w)\n", "\n", " # find the states with max probabilities\n", @@ -891,8 +977,8 @@ " index = np.where(probs == max_prob)[0]\n", " states = []\n", " for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{c._nqubits}}')\n", - " print(f'cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n')" + " states.append(f\"{bin(i)[2:]:0>{c._nqubits}}\")\n", + " print(f\"cost: {K.numpy(loss)}\\nmax prob: {max_prob}\\nbit strings: {states}\\n\")" ], "metadata": { "collapsed": false, From abf512790ec3a527bef095e5ae4a98d453426a22 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 4 Jul 2023 02:52:21 +0000 Subject: [PATCH 524/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index a5391f0a..5d9af981 100644 --- a/README.md +++ b/README.md @@ -234,6 +234,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. WiuYuan
WiuYuan
💡 Felix Xu
Felix Xu
✅ Hong-Ye Hu
Hong-Ye Hu
📖 + peilin
peilin
✅ From 9953a5e87cfb216521e14fb93a00551b8a498f75 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 4 Jul 2023 02:52:22 +0000 Subject: [PATCH 525/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 3270e04e..47b9f2b9 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -258,6 +258,15 @@ "contributions": [ "doc" ] + }, + { + "login": "PeilinZHENG", + "name": "peilin", + "avatar_url": "https://avatars.githubusercontent.com/u/45784888?v=4", + "profile": "https://github.com/PeilinZHENG", + "contributions": [ + "tutorial" + ] } ], "contributorsPerLine": 6, From 4dc813e5ba0f73df44eeff58fe54c1aafb07f9db Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 5 Jul 2023 13:09:03 +0800 Subject: [PATCH 526/725] update readme --- README.md | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/README.md b/README.md index 5d9af981..bb88e779 100644 --- a/README.md +++ b/README.md @@ -76,6 +76,32 @@ theta = tc.array_to_tensor(1.0) print(g(theta)) ``` +-
+ More highlight features for TensorCircuit (click for details) + + - Sparse Hamiltonian generation and expectation evaluation: + + ```python + n = 6 + pauli_structures = [] + weights = [] + for i in range(n): + pauli_structures.append(tc.quantum.xyz2ps({"z": [i, (i + 1) % n]}, n=n)) + weights.append(1.0) + for i in range(n): + pauli_structures.append(tc.quantum.xyz2ps({"x": [i]}, n=n)) + weights.append(-1.0) + h = tc.quantum.PauliStringSum2COO(pauli_structures, weights) + print(h) + # BCOO(complex64[64, 64], nse=448) + c = tc.Circuit(n) + c.h(range(n)) + energy = tc.templates.measurements.operator_expectation(c, h) + # -6 + ``` + +
+ ## Install The package is written in pure Python and can be obtained via pip as: From 879ce7736919678e6d37f60481a6792b91f62330 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 5 Jul 2023 13:11:36 +0800 Subject: [PATCH 527/725] update readme --- README.md | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index bb88e779..5f4a6652 100644 --- a/README.md +++ b/README.md @@ -76,31 +76,31 @@ theta = tc.array_to_tensor(1.0) print(g(theta)) ``` --
+
More highlight features for TensorCircuit (click for details) - - Sparse Hamiltonian generation and expectation evaluation: - - ```python - n = 6 - pauli_structures = [] - weights = [] - for i in range(n): - pauli_structures.append(tc.quantum.xyz2ps({"z": [i, (i + 1) % n]}, n=n)) - weights.append(1.0) - for i in range(n): - pauli_structures.append(tc.quantum.xyz2ps({"x": [i]}, n=n)) - weights.append(-1.0) - h = tc.quantum.PauliStringSum2COO(pauli_structures, weights) - print(h) - # BCOO(complex64[64, 64], nse=448) - c = tc.Circuit(n) - c.h(range(n)) - energy = tc.templates.measurements.operator_expectation(c, h) - # -6 - ``` +- Sparse Hamiltonian generation and expectation evaluation: -
+```python +n = 6 +pauli_structures = [] +weights = [] +for i in range(n): + pauli_structures.append(tc.quantum.xyz2ps({"z": [i, (i + 1) % n]}, n=n)) + weights.append(1.0) +for i in range(n): + pauli_structures.append(tc.quantum.xyz2ps({"x": [i]}, n=n)) + weights.append(-1.0) +h = tc.quantum.PauliStringSum2COO(pauli_structures, weights) +print(h) +# BCOO(complex64[64, 64], nse=448) +c = tc.Circuit(n) +c.h(range(n)) +energy = tc.templates.measurements.operator_expectation(c, h) +# -6 +``` + +
## Install From dd8451b39efe4d3eabfbc6d034377cfa751efc9e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 7 Jul 2023 10:11:03 +0800 Subject: [PATCH 528/725] add finite size scaling utilities --- tensorcircuit/applications/physics/fss.py | 70 +++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 tensorcircuit/applications/physics/fss.py diff --git a/tensorcircuit/applications/physics/fss.py b/tensorcircuit/applications/physics/fss.py new file mode 100644 index 00000000..81e12252 --- /dev/null +++ b/tensorcircuit/applications/physics/fss.py @@ -0,0 +1,70 @@ +""" +finite size scaling tools +""" +from typing import List, Tuple + +import numpy as np + + +def data_collapse( + n: List[int], + p: List[float], + obs: List[List[float]], + pc: float, + nu: float, + beta: float = 0, + obs_type: int = 1, +) -> Tuple[List[float], List[List[float]], List[List[float]], float]: + xL: List[List[float]] = [] # x=(p-pc)L^(1/\nv) + yL: List[List[float]] = [] # y=S(p,L)-S(pc,L) or S(p,L) + pc_list = [] + for n0 in range(len(n)): + xL.append([]) + yL.append([]) + for p0 in range(len(p)): + xL[n0].append((p[p0] - pc) * (n[n0] ** (1 / nu))) + pc_L = pc_linear_interpolation(p, obs[n0], pc) + if obs_type == 0: + yL[n0].append((obs[n0][p0] - pc_L) * n[n0] ** (beta / nu)) + # entanglement with only collapse and no crossing + else: + yL[n0].append(obs[n0][p0] * n[n0] ** (beta / nu)) + # tripartite mutual information + pc_list.append(pc_L) + + xL_all = np.reshape(xL, -1) + yL_ave = [] + loss = [] + for x0 in range(len(xL_all)): + ybar_list = [] + for n0 in range(len(n)): + if xL_all[x0] >= xL[n0][0] and xL_all[x0] <= xL[n0][-1]: + yinsert = pc_linear_interpolation(xL[n0], yL[n0], xL_all[x0]) + ybar_list.append(yinsert) + + ybar = np.mean(ybar_list) + mean_squared = [(ybar_list[i] - ybar) ** 2 for i in range(len(ybar_list))] + loss.append(np.sum(mean_squared)) + yL_ave.append(ybar) + loss = np.sum(loss) + + return pc_list, xL, np.array(yL), loss # type: ignore + + +def pc_linear_interpolation(p: List[float], SA: List[float], pc_input: float) -> float: + if pc_input in p: + pc_index = p.index(pc_input) + pc = SA[pc_index] + else: + pr_index = 0 + for p0 in range(len(p)): + if p[p0] > pc_input: + pr_index = p0 + break + + x = [p[pr_index - 1], p[pr_index]] + y = [SA[pr_index - 1], SA[pr_index]] + linear_model = np.polyfit(x, y, 1) + linear_model_fn = np.poly1d(linear_model) + pc = linear_model_fn(pc_input) + return pc From 5f9851f53bc84254078eae84a9b4f0c92f8aad54 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 7 Jul 2023 12:33:08 +0800 Subject: [PATCH 529/725] add some comment in vte example --- examples/variational_dynamics.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/examples/variational_dynamics.py b/examples/variational_dynamics.py index a6e8fc88..39015fbd 100644 --- a/examples/variational_dynamics.py +++ b/examples/variational_dynamics.py @@ -46,6 +46,8 @@ def lhs_matrix(theta, psi0): vij = tc.backend.vmap(ij, vectorized_argnums=0) vvij = tc.backend.vmap(vij, vectorized_argnums=1) jacobian = ppsioverptheta(theta, psi0=psi0) + # fim = tc.backend.adjoint(jacobian)@jacobian is also ok + # speed comparison? jacobian = tc.backend.transpose(jacobian) fim = vvij(jacobian, jacobian) fim = tc.backend.real(fim) @@ -62,12 +64,16 @@ def energy(theta, psi0): wl = tc.backend.reshape(wl, [1, -1]) wr = tc.backend.reshape(wr, [-1, 1]) e = wl @ h @ wr + # use sparse matrix if required return tc.backend.real(e)[0, 0] eg = tc.backend.grad(energy, argnums=0) rhs = eg(theta, psi0) rhs = tc.backend.imag(rhs) return rhs + # for ITE, imag is replace with real + # a simpler way to get rhs in ITE case is to directly evaluate + # 0.5*\nabla @tc.backend.jit From 3af21a416d47378ac4105caeaa59296764ffde9e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 7 Jul 2023 13:49:21 +0800 Subject: [PATCH 530/725] add mat prod vmap example --- CHANGELOG.md | 2 ++ examples/matprod_vmap.py | 41 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) create mode 100644 examples/matprod_vmap.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 3084e947..ac909bb0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Add multiple GPU VQE examples using jax pmap +- Add benchmark example showcasing new way of implementing matrix product using vmap + ## 0.10.0 ### Added diff --git a/examples/matprod_vmap.py b/examples/matprod_vmap.py new file mode 100644 index 00000000..e1c6954b --- /dev/null +++ b/examples/matprod_vmap.py @@ -0,0 +1,41 @@ +""" +matrix product: a new twist +rewrite matrix product in a vmap style +""" +from functools import partial + +import numpy as np +import tensorcircuit as tc + +for bk in ["jax", "tensorflow"]: + with tc.runtime_backend(bk) as K: + print("~~~~~~~~~~~~~~~~~~~~~") + print(f"using {K.name} backend") + + @partial(K.jit, jit_compile=True) + def mul(a, b): + return a @ b + + def ij(i, j): + """ + Inner product + """ + return K.tensordot(i, j, 1) + + vij = K.vmap(ij, vectorized_argnums=1) + vvij = K.vmap(vij, vectorized_argnums=0) + + @partial(K.jit, jit_compile=True) + def mul2(a, b): + b = K.transpose(b) + return vvij(a, b) + + for shape in [(256, 4096), (4096, 256), (2048, 2048)]: + print(shape) + a = K.implicit_randn(shape) + b = K.implicit_randn([shape[1], shape[0]]) + print("plain matprod") + r1, _, _ = tc.utils.benchmark(mul, a, b, tries=10) + print("vmap matprod") + r2, _, _ = tc.utils.benchmark(mul2, a, b, tries=10) + np.testing.assert_allclose(r1, r2, atol=1e-5) From ec4cdadfa207d54b024b4490ed00f3630393c0d9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 9 Jul 2023 11:19:43 +0800 Subject: [PATCH 531/725] add with_prob in general_krais --- CHANGELOG.md | 2 + examples/mipt_pideal.py | 111 +++++++++++++++++++++++++++++++++++++++ tensorcircuit/circuit.py | 13 +++-- tests/test_circuit.py | 54 +++++++++++++++++++ 4 files changed, 177 insertions(+), 3 deletions(-) create mode 100644 examples/mipt_pideal.py diff --git a/CHANGELOG.md b/CHANGELOG.md index ac909bb0..46eacacd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Add multiple GPU VQE examples using jax pmap +- Add `with_prob` option to `general_kraus` so that the probability of each option can be returned together + - Add benchmark example showcasing new way of implementing matrix product using vmap ## 0.10.0 diff --git a/examples/mipt_pideal.py b/examples/mipt_pideal.py new file mode 100644 index 00000000..2a21c02b --- /dev/null +++ b/examples/mipt_pideal.py @@ -0,0 +1,111 @@ +""" +demo example of mipt in tc style, with ideal p for each history trajectory +p is also jittable now, change parameter p doesn't trigger recompiling +""" + +from functools import partial +import time +import numpy as np +from scipy import stats +import tensorcircuit as tc + +K = tc.set_backend("jax") +tc.set_dtype("complex128") +# tf backend is slow (at least on cpu) + + +def delete2(pick, plist): + # pick = 0, 1 : return plist[pick]/(plist[0]+plist[1]) + # pick = 2: return 1 + indicator = (K.sign(1.5 - pick) + 1) / 2 # 0,1 : 1, 2: 0 + p = 0 + p += 1 - indicator + p += indicator / (plist[0] + plist[1]) * (plist[0] * (1 - pick) + plist[1] * pick) + return p + + +@partial(K.jit, static_argnums=(2, 3)) +def circuit_output(random_matrix, status, n, d, p): + """ + mipt circuit + + :param random_matrix: a float or complex tensor containing 4*4 random haar matrix wth size [d*n, 4, 4] + :type random_matrix: _type_ + :param status: a int tensor with element in 0 or 1 or 2 (no meausrement) with size d*n + :type status: _type_ + :param n: number of qubits + :type n: _type_ + :param d: number of depth + :type d: _type_ + :param p: measurement ratio + :type p: float + :return: output state + """ + random_matrix = K.reshape(random_matrix, [d, n, 4, 4]) + status = K.reshape(status, [d, n]) + inputs = None + bs_history = [] + prob_history = [] + for j in range(d): + if inputs is None: + c = tc.Circuit(n) + else: + c = tc.Circuit(n, inputs=inputs) + for i in range(0, n, 2): + c.unitary(i, (i + 1) % n, unitary=random_matrix[j, i]) + for i in range(1, n, 2): + c.unitary(i, (i + 1) % n, unitary=random_matrix[j, i]) + inputs = c.state() + c = tc.Circuit(n, inputs=inputs) + for i in range(n): + pick, plist = c.general_kraus( + [ + K.sqrt(p) * K.convert_to_tensor(np.array([[1.0, 0], [0, 0]])), + K.sqrt(p) * K.convert_to_tensor(np.array([[0, 0], [0, 1.0]])), + K.sqrt(1 - p) * K.eye(2), + ], + i, + status=status[j, i], + with_prob=True, + ) + bs_history.append(pick) + prob_history.append(delete2(pick, plist)) + inputs = c.state() + c = tc.Circuit(n, inputs=inputs) + inputs = c.state() + inputs /= K.norm(inputs) + bs_history = K.stack(bs_history) + prob_history = K.stack(prob_history) + return inputs, bs_history, prob_history, K.sum(K.log(prob_history + 1e-11)) + + +@partial(K.jit, static_argnums=(2, 3)) +def cals(random_matrix, status, n, d, p): + state, bs_history, prob_history, prob = circuit_output( + random_matrix, status, n, d, p + ) + rho = tc.quantum.reduced_density_matrix(state, cut=[i for i in range(n // 2)]) + return ( + tc.quantum.entropy(rho), + tc.quantum.renyi_entropy(rho, k=2), + bs_history, + prob_history, + prob, + ) + + +if __name__ == "__main__": + n = 12 + d = 12 + st = np.random.uniform(size=[d * n]) + ## assume all X gate instead + rm = [stats.unitary_group.rvs(4) for _ in range(d * n)] + rm = [r / np.linalg.det(r) for r in rm] + rm = np.stack(rm) + time0 = time.time() + print(cals(rm, st, n, d, 0.6)) + time1 = time.time() + st = np.random.uniform(size=[d * n]) + print(cals(rm, st, n, d, 0.1)) + time2 = time.time() + print(f"compiling time {time1-time0}, running time {time2-time1}") diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index ade0cafa..e07516cb 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -507,6 +507,7 @@ def _general_kraus_2( kraus: Sequence[Gate], *index: int, status: Optional[float] = None, + with_prob: bool = False, name: Optional[str] = None, ) -> Tensor: # the graph building time is frustratingly slow, several minutes @@ -554,16 +555,20 @@ def calculate_kraus_p(i: int) -> Tensor: k / backend.cast(backend.sqrt(w) + eps, dtypestr) for w, k in zip(prob, kraus_tensor) ] - - return self.unitary_kraus( + pick = self.unitary_kraus( new_kraus, *index, prob=prob, status=status, name=name ) + if with_prob is False: + return pick + else: + return pick, prob def general_kraus( self, kraus: Sequence[Gate], *index: int, status: Optional[float] = None, + with_prob: bool = False, name: Optional[str] = None, ) -> Tensor: """ @@ -583,7 +588,9 @@ def general_kraus( when the random number will be generated automatically :type status: Optional[float], optional """ - return self._general_kraus_2(kraus, *index, status=status, name=name) + return self._general_kraus_2( + kraus, *index, status=status, with_prob=with_prob, name=name + ) apply_general_kraus = general_kraus diff --git a/tests/test_circuit.py b/tests/test_circuit.py index ddfe30eb..c50508f4 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1573,3 +1573,57 @@ def test_fancy_circuit_indexing(backend): assert c.gate_count("h") == 4 assert c.gate_count("rzz") == 2 assert c.gate_count("rxx") == 3 + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("npb")]) +def test_general_kraus(backend): + c = tc.Circuit(2) + c.h([0, 1]) + p = 0.5 + status = [0.3, 0.8] + rs = [] + for i in range(2): + rs.append( + c.general_kraus( + [ + np.sqrt(p) * np.array([[1.0, 0], [0, 0]]), + np.sqrt(p) * np.array([[0, 0], [0, 1.0]]), + np.sqrt(1 - p) * np.eye(2), + ], + i, + status=status[i], + ) + ) + np.testing.assert_allclose(rs[0], 1) + np.testing.assert_allclose(rs[1], 2) + np.testing.assert_allclose(c.expectation_ps(z=[0]), -1, atol=1e-5) + np.testing.assert_allclose(c.expectation_ps(z=[1]), 0, atol=1e-5) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("npb")]) +def test_general_kraus_with_prob(backend): + c = tc.Circuit(2) + c.h([0, 1]) + p = 0.5 + status = [0.3, 0.8] + rs = [] + for i in range(2): + rs.append( + c.general_kraus( + [ + np.sqrt(p) * np.array([[1.0, 0], [0, 0]]), + np.sqrt(p) * np.array([[0, 0], [0, 1.0]]), + np.sqrt(1 - p) * np.eye(2), + ], + i, + status=status[i], + with_prob=True, + ) + ) + np.testing.assert_allclose(rs[0][0], 1) + np.testing.assert_allclose(rs[1][0], 2) + np.testing.assert_allclose(c.expectation_ps(z=[0]), -1, atol=1e-5) + np.testing.assert_allclose(c.expectation_ps(z=[1]), 0, atol=1e-5) + np.testing.assert_allclose(rs[0][1], [0.25, 0.25, 0.5], atol=1e-5) + np.testing.assert_allclose(rs[1][1], [0.25, 0.25, 0.5], atol=1e-5) + np.testing.assert_allclose(tc.backend.norm(c.state()), 1, atol=1e-5) From d8c5d628d1964abde80e84e64e5f0f8942494f2b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 11 Jul 2023 19:31:28 +0800 Subject: [PATCH 532/725] update readme --- README.md | 6 ++++-- README_cn.md | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 5f4a6652..1872c524 100644 --- a/README.md +++ b/README.md @@ -208,12 +208,14 @@ This project is released by [Tencent Quantum Lab](https://quantum.tencent.com/) ### Citation -If this project helps in your research, please cite our software whitepaper published in Quantum: +If this project helps in your research, please cite our software whitepaper to acknowledge the work put into the development of TensorCircuit. -[TensorCircuit: a Quantum Software Framework for the NISQ Era](https://quantum-journal.org/papers/q-2023-02-02-912/) +[TensorCircuit: a Quantum Software Framework for the NISQ Era](https://quantum-journal.org/papers/q-2023-02-02-912/) (published in Quantum) which is also a good introduction to the software. +Research works citing TensorCircuit can be highlighted in [Research and Applications section](https://github.com/tencent-quantum-lab/tensorcircuit#research-and-applications). + ### Guidelines For contribution guidelines and notes, see [CONTRIBUTING](/CONTRIBUTING.md). diff --git a/README_cn.md b/README_cn.md index c9f74ac1..558a5038 100644 --- a/README_cn.md +++ b/README_cn.md @@ -127,7 +127,7 @@ pip install tensorcircuit-nightly ### 引用 -如果该软件对您的研究有帮助, 请引用我们发表在 Quantum 期刊的白皮书文章: +如果该软件对您的研究有帮助, 请引用我们发表在 Quantum 期刊的白皮书文章来支持我们的研发付出。 [TensorCircuit: a Quantum Software Framework for the NISQ Era](https://quantum-journal.org/papers/q-2023-02-02-912/). From cdd74fabc4041de33b0af937ac49004062a0282f Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 12 Jul 2023 10:34:45 +0800 Subject: [PATCH 533/725] add imag_time_evo.ipynb --- docs/source/tutorial.rst | 1 + docs/source/tutorials/imag_time_evo.ipynb | 1132 +++++++++++++++++++++ 2 files changed, 1133 insertions(+) create mode 100644 docs/source/tutorials/imag_time_evo.ipynb diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index 6c71ea41..39ede96d 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -23,4 +23,5 @@ Jupyter Tutorials tutorials/dqas.ipynb tutorials/barren_plateaus.ipynb tutorials/qaoa_portfolio_optimization.ipynb + tutorials/imag_time_evo.ipynb tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file diff --git a/docs/source/tutorials/imag_time_evo.ipynb b/docs/source/tutorials/imag_time_evo.ipynb new file mode 100644 index 00000000..27bcd5ed --- /dev/null +++ b/docs/source/tutorials/imag_time_evo.ipynb @@ -0,0 +1,1132 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dc0db886", + "metadata": {}, + "source": [ + "# Solving the Ground State of Hamiltonian by Imaginary-time Evolution" + ] + }, + { + "cell_type": "markdown", + "id": "aecf6615", + "metadata": {}, + "source": [ + "## Overview" + ] + }, + { + "cell_type": "markdown", + "id": "b533d43e", + "metadata": {}, + "source": [ + "Imaginary-time evolution (IME) is a method to solve the ground state of the Hamiltonian, which is more efficient than naive gradient descent and will not fall into a local minimum.\n", + "\n", + "However, exact imaginary-time evolution takes exponentially more space and time to execute on a classical computer. On the other hand, it is non-unitary and also cannot be implemented on a quantum computer. Therefore, we consider the approximate imaginary-time evolution, also known as the quantum natural gradient (QNG), that is, at each step we adjust the parameters in the quantum circuit to realize the imaginary-time evolution in a very short time $\\tau$. Let the parameters in the circuit be $\\boldsymbol{\\theta}$ and the output of the circuit is $|\\psi\\rangle$, define\n", + "$$\n", + "\\begin{eqnarray}\n", + " |\\psi_\\tau\\rangle&=&e^{-\\tau\\hat{H}}|\\psi\\rangle\\approx|\\psi\\rangle-\\tau\\hat{H}|\\psi\\rangle,\\\\\n", + " |\\psi'\\rangle&=&|\\psi(\\boldsymbol{\\theta}-\\tau\\boldsymbol{\\delta})\\rangle\\approx|\\psi\\rangle-\\tau\\sum_j\\boldsymbol{\\delta}_j|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle,\n", + "\\end{eqnarray}\n", + "$$\n", + "and the overlap is\n", + "$$\n", + "\\begin{equation}\n", + " O=\\sqrt{\\frac{\\langle\\psi_\\tau\\rangle|\\psi'\\rangle\\langle\\psi'|\\psi_\\tau\\rangle}{\\langle\\psi_\\tau\\rangle|\\psi_\\tau\\rangle\\langle\\psi'|\\psi'\\rangle}}.\n", + "\\end{equation}\n", + "$$\n", + "Let $\\partial|O|^2/\\partial\\boldsymbol{\\delta}=0$, we can get $\\boldsymbol{A\\delta=C}$, then the update method is as follows\n", + "$$\n", + "\\begin{equation}\n", + " \\boldsymbol{\\theta}^{n+1}=\\boldsymbol{\\theta}^{n}-\\tau\\boldsymbol{\\delta}=\\boldsymbol{\\theta}^{n}-\\tau\\boldsymbol{A}^{-1}\\boldsymbol{C},\n", + "\\end{equation}\n", + "$$\n", + "where $\\boldsymbol{A}$ is the quantum Fisher information matrix and the matrix element\n", + "$$\n", + "\\begin{equation}\n", + " \\boldsymbol{A}_{ij}=\\Re\\left[\\frac{\\langle\\partial_{\\boldsymbol{\\theta}_{i}}\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}-\\frac{\\langle\\partial_{\\boldsymbol{\\theta}_{i}}\\psi|\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\frac{\\langle\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\right];\n", + "\\end{equation}\n", + "$$\n", + "$\\boldsymbol{C}$ is the gradient vector of energy versus parameters and the vector element\n", + "$$\n", + "\\begin{equation}\n", + " \\boldsymbol{C}_j=\\Re\\left[\\frac{\\langle\\psi|\\hat{H}|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}-\\frac{\\langle\\psi|\\hat{H}|\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\frac{\\langle\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\right].\n", + "\\end{equation}\n", + "$$\n", + "Since $|\\psi\\rangle$ is represented by quantum circuit and naturally normalized, the second term of $\\boldsymbol{C}$ vanishes. And because the global phase is not important, we can add a $U(1)$ gauge to make the second term of $\\boldsymbol{A}$ vanishes. Related theoretical work can refer to [Yuan, Endo, Zhao, Li and Benjamin](https://doi.org/10.22331/q-2019-10-07-191) and [Stokes, Izaac, Killoran and Carleo](https://doi.org/10.22331/q-2020-05-25-269), which will also show how to measure $\\boldsymbol{A}$ and $\\boldsymbol{C}$ in circuit." + ] + }, + { + "cell_type": "markdown", + "source": [ + "In fields other than quantum computation, equivalent forms of imaginary-time evolution are stochastic reconfiguration in variational Monte Carlo method and natural gradient method and Gauss-Newton method in classical optimization. In stochastic reconfiguration, $|\\psi\\rangle$ is not normalized, so $\\boldsymbol{A}$ and $\\boldsymbol{C}$ are the form shown above. In classical optimization, the second terms of $\\boldsymbol{A}$ and $\\boldsymbol{C}$ vanish automatically when the output is the classical probability distribution. Therefore, when $|\\psi\\rangle$ is similar to the classical probability distribution, that is, when there is no sign structure and phase information, the second term of $\\boldsymbol{A}$ will automatically vanish." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "In this tutorial, we solve a classical Hamiltonian and a quantum Hamiltonian by the approximate imaginary-time evolution and demonstrate various forms of code implementation." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b0def04d", + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-11T11:16:06.492676700Z", + "start_time": "2023-07-11T11:16:06.134350200Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": "('complex128', 'float64')" + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import tensorcircuit as tc\n", + "from tensorcircuit import experimental\n", + "import optax\n", + "import jax.numpy as jnp\n", + "import tensorflow as tf\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from functools import partial\n", + "from IPython.display import clear_output\n", + "\n", + "K = tc.set_backend('jax')\n", + "tc.set_dtype(\"complex128\")" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Classical Hamiltonian" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "The classical Hamiltonian is the Hamiltonian of NAE3SAT, which can be solved by QAOA. Please refer to the tutorial of [QAOA for NAE3SAT](qaoa_nae3sat.ipynb) for details.\n", + "\n", + "Let the set of clauses in the NAE3SAT be $\\mathcal{C}$. In each clause, there are three literals and each literal is represented by a spin. Spins up ($s=1$, $\\text{bit}=0$) and down ($s=-1$, $\\text{bit}=1$) represent false and true respectively. For the clause $(s_i,\\ s_j,\\ s_k)\\in\\mathcal{C}$, $s_i,\\ s_j,\\ s_k$ cannot be 1 or -1 at the same time. The Hamiltonian of the NAE3SAT is as follows\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$\n", + "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $\\hat{H}_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "id": "6e407437", + "metadata": {}, + "source": [ + "### Define the Hamiltonian" + ] + }, + { + "cell_type": "markdown", + "source": [ + "We select the hard problem in the tutorial of [QAOA for NAE3SAT](qaoa_nae3sat.ipynb). We first construct the graph by the clauses." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f1532831", + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-11T11:16:06.657240900Z", + "start_time": "2023-07-11T11:16:06.173235900Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# a classical Hamiltonian instance\n", + "clauses = [[4, 1, 7], [5, 11, 8], [4, 1, 8], [4, 11, 8], [4, 1, 10], [5, 11, 8], [4, 1, 8], [1, 11, 8], [4, 1, 7], [0, 11, 8], [4, 1, 10], [4, 11, 8], [5, 0, 10], [0, 6, 7], [5, 0, 11], [0, 6, 7], [5, 0, 9], [3, 6, 7], [5, 0, 8], [5, 6, 7], [5, 0, 10], [3, 6, 7], [5, 0, 10], [1, 6, 7], [2, 4, 6], [1, 8, 11], [2, 4, 6], [2, 8, 11], [2, 4, 9], [5, 8, 11], [2, 4, 10], [2, 8, 11], [2, 4, 10], [4, 8, 11], [2, 4, 8], [4, 8, 11], [3, 0, 9], [5, 11, 7], [3, 0, 10], [2, 11, 7], [3, 0, 9], [0, 11, 7], [3, 0, 9], [5, 11, 7], [3, 0, 10], [3, 11, 7], [3, 0, 7], [4, 11, 7], [5, 0, 10], [4, 0, 10], [2, 5, 6], [2, 11, 10], [2, 6, 10], [2, 4, 9], [0, 9, 10], [3, 0, 7], [2, 5, 6], [1, 10, 9], [1, 4, 11], [5, 10, 11], [0, 4, 8], [0, 9, 8], [2, 11, 10], [2, 8, 6], [3, 6, 7], [0, 8, 10], [4, 0, 9], [3, 5, 8], [5, 11, 10], [2, 11, 10], [4, 11, 8], [1, 3, 11]]\n", + "factor = 1 / len(clauses) / 4\n", + "\n", + "# convert to a NetworkX graph\n", + "graph = nx.Graph()\n", + "for i, j, k in clauses:\n", + " graph.add_edge(i, j, weight=0)\n", + " graph.add_edge(j, k, weight=0)\n", + " graph.add_edge(k, i, weight=0)\n", + "for i, j, k in clauses:\n", + " graph[i][j]['weight'] += 1\n", + " graph[j][k]['weight'] += 1\n", + " graph[k][i]['weight'] += 1\n", + "pos = nx.spring_layout(graph)\n", + "nx.draw_networkx(graph, with_labels=True, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Then we construct the Hamiltonian from the graph." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 15, + "outputs": [], + "source": [ + "def b2s(bit):\n", + " return 1 - 2 * int(bit)\n", + "\n", + "def energy(cfg):\n", + " E = 0.25\n", + " for a, b in graph.edges:\n", + " E += cfg[a] * cfg[b] * graph[a][b]['weight'] * factor\n", + " return E\n", + "\n", + "def construct_Ham():\n", + " num_nodes = graph.number_of_nodes()\n", + " Es = []\n", + " for i in range(2 ** num_nodes):\n", + " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + " Es.append(energy(list(map(b2s, case))))\n", + " return jnp.asarray(Es)\n", + "\n", + "Hv = construct_Ham()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T11:16:06.695590600Z", + "start_time": "2023-07-11T11:16:06.345459900Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Here we calculate $e^{-\\tau\\hat{H}}$ in advance to perform exact imaginary-time evolution for comparison with approximate imaginary-time evolution." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 16, + "outputs": [], + "source": [ + "tau_c = 0.025\n", + "exp_tauHv = K.exp(-tau_c * Hv)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T11:16:06.696505400Z", + "start_time": "2023-07-11T11:16:06.521810800Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Variational wave function" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Here we choose regular QAOA ansatz as the parameterized quantum circuit ([PQC](https://tensorcircuit.readthedocs.io/en/latest/textbook/chap5.html?highlight=变分))." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 17, + "outputs": [], + "source": [ + "nlayers = 30 # the number of layers\n", + "\n", + "@partial(K.jit, static_argnums=(1, 2))\n", + "def wfn_classical(params, each=1, return_loss=False):\n", + " n = graph.number_of_nodes() # the number of nodes\n", + "\n", + " # PQC loop\n", + " def pqc_loop(s_, params_):\n", + " c_ = tc.Circuit(n, inputs=s_)\n", + " for j in range(each):\n", + " # driving layer\n", + " for a, b in graph.edges:\n", + " c_.RZZ(a, b, theta=graph[a][b]['weight'] * params_[2 * j] * factor)\n", + " # mixing layer\n", + " for i in range(n):\n", + " c_.RX(i, theta=params_[2 * j + 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(n)\n", + " for i in range(n):\n", + " c0.H(i)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, K.reshape(params, [nlayers // each, 2 * each]), s0)\n", + " c = tc.Circuit(n, inputs=s)\n", + "\n", + " if return_loss:\n", + " loss = 0.25\n", + " for a, b in graph.edges:\n", + " loss += c.expectation_ps(z=[a, b]) * graph[a][b]['weight'] * factor\n", + " return K.real(loss)\n", + " else:\n", + " return c.state()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T11:16:06.697555Z", + "start_time": "2023-07-11T11:16:06.528407400Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Optimization" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We use two methods to calculate $\\boldsymbol{\\delta}$, one is to calculate directly according to the expressions of $\\boldsymbol{A}$ and $\\boldsymbol{C}$, and the other is to call the existing API to calculate $\\boldsymbol{A}$ and $\\boldsymbol{C}$. The former only needs to calculate the $|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle$ once, while the latter needs to calculate that twice, but the code of the latter is more concise. In each method, we set the parameter $\\text{fixed_global_phase}$ to decide whether to fix the global phase, that is, whether the second term of $\\boldsymbol{A}$ vanishes.\n", + "\n", + "Then we choose the existing optimizer, SGD, to implement the update step. Since compared with naive gradient descent, the approximate imaginary-time evolution has been corrected on the update step size, the adaptive optimizer improved for the naive gradient descent such as Adam is not suitable for the approximate imaginary-time evolution. When update by the adaptive optimizer, the loss function fluctuates greatly. On the other hand, the update method of SGD without momentum is naive update, which is convenient for comparison with the exact imaginary-time evolution." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 18, + "outputs": [], + "source": [ + "@partial(K.jit, static_argnums=(2,))\n", + "def d_params(params, psi, fixed_global_phase=False):\n", + " psi = psi[:, None]\n", + " psiHT = K.conj(K.transpose(psi))\n", + " par_psi = K.jacfwd(wfn_classical, argnums=0)\n", + " jac = par_psi(params)\n", + " jacHT = K.conj(K.transpose(jac))\n", + "\n", + " A = K.real(jacHT @ jac)\n", + " if not fixed_global_phase:\n", + " A -= K.real(jacHT @ psi @ psiHT @ jac)\n", + " # protection\n", + " A += 1e-6 * K.eye(params.shape[-1], dtype=A.dtype)\n", + "\n", + " C = K.real((psiHT * Hv) @ jac)[0]\n", + "\n", + " return K.solve(A, C, assume_a=\"sym\")\n", + "\n", + "@partial(K.jit, static_argnums=(1,))\n", + "def d_params_api(params, fixed_global_phase=False):\n", + " if fixed_global_phase:\n", + " qng = experimental.qng(wfn_classical, kernel=\"dynamics\", mode=\"fwd\")\n", + " else:\n", + " qng = experimental.qng(wfn_classical, kernel=\"qng\", mode=\"fwd\")\n", + " A = qng(params)\n", + " # protection\n", + " A += 1e-6 * K.eye(params.shape[-1], dtype=A.dtype)\n", + "\n", + " vag = K.value_and_grad(partial(wfn_classical, return_loss=True), argnums=0)\n", + " loss, C2 = vag(params)\n", + "\n", + " return loss, K.solve(A, C2 / 2, assume_a=\"sym\")\n", + "\n", + "if K.name == 'jax':\n", + " opt = K.optimizer(optax.sgd(tau_c))\n", + "else:\n", + " opt = K.optimizer(tf.keras.optimizers.SGD(tau_c))" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T11:16:06.698532100Z", + "start_time": "2023-07-11T11:16:06.565856900Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 19, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "steps_classical = 2000\n", + "\n", + "# initial parameters\n", + "params = K.implicit_randn(shape=(2 * nlayers,), stddev=0.1)\n", + "params_fgp = K.copy(params)\n", + "params_api = K.copy(params)\n", + "params_fgp_api = K.copy(params)\n", + "psi_exact = wfn_classical(params)\n", + "\n", + "losses, losses_fgp, losses_exact = [], [], []\n", + "losses_api, losses_fgp_api = [], []\n", + "\n", + "for i in range(steps_classical):\n", + " psi = wfn_classical(params)\n", + " loss = K.real(K.tensordot(K.conj(psi) * Hv, psi, 1))\n", + " delta = d_params(params, psi)\n", + " params = opt.update(delta, params)\n", + " losses.append(K.numpy(loss))\n", + "\n", + " psi_fgp = wfn_classical(params_fgp)\n", + " loss_fgp = K.real(K.tensordot(K.conj(psi_fgp) * Hv, psi_fgp, 1))\n", + " delta_fgp = d_params(params_fgp, psi_fgp, fixed_global_phase=True)\n", + " params_fgp = opt.update(delta_fgp, params_fgp)\n", + " losses_fgp.append(K.numpy(loss_fgp))\n", + "\n", + " loss_api, delta_api = d_params_api(params_api)\n", + " params_api = opt.update(delta_api, params_api)\n", + " losses_api.append(K.numpy(loss_api))\n", + "\n", + " loss_fgp_api, delta_fgp_api = d_params_api(params_fgp_api, fixed_global_phase=True)\n", + " params_fgp_api = opt.update(delta_fgp_api, params_fgp_api)\n", + " losses_fgp_api.append(K.numpy(loss_fgp_api))\n", + "\n", + " loss_exact = K.real(K.tensordot(K.conj(psi_exact) * Hv, psi_exact, 1))\n", + " psi_exact *= exp_tauHv\n", + " psi_exact /= K.norm(psi_exact)\n", + " losses_exact.append(K.numpy(loss_exact))\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " plt.plot(range(i + 1), losses_exact, c='r', label='exact')\n", + " plt.plot(range(i + 1), losses, c='b', label='unfixed GP')\n", + " plt.plot(range(i + 1), losses_fgp, c='g', label='fixed GP')\n", + " plt.plot(range(i + 1), losses_api, c='m', label='unfixed GP (API)')\n", + " plt.plot(range(i + 1), losses_fgp_api, c='y', label='fixed GP (API)')\n", + " plt.legend()\n", + " plt.show()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "id": "98a6b152", + "metadata": {}, + "source": [ + "### Results" + ] + }, + { + "cell_type": "markdown", + "source": [ + "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods are very close, which are also close to the exact final state. And the final states obtained by the same method are almost the same and the difference between them is only one global phase." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 20, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "overlap between psi_fgp and psi\n", + "|overlap|: 0.99990623547646\n", + "overlap: (-0.9503999786032177-0.31072875698220964j)\n", + "\n", + "overlap between psi_fgp_api and psi_api\n", + "|overlap|: 0.9993690598239388\n", + "overlap: (0.9469611654290884-0.31937919297062295j)\n", + "\n", + "overlap between psi_api and psi\n", + "|overlap|: 0.9657223380010587\n", + "overlap: (-0.31523027402440384-0.9128250152426423j)\n", + "\n", + "overlap between psi_fgp_api and psi_fgp\n", + "|overlap|: 0.965709942925926\n", + "overlap: (0.8020707325449846+0.5378459201860204j)\n", + "\n", + "overlap between psi_exact and psi\n", + "|overlap|: 0.8984756038763727\n", + "overlap: (-0.6177027661071913-0.6524582005803415j)\n", + "\n", + "overlap between psi_exact and psi_fgp\n", + "|overlap|: 0.8972862435422242\n", + "overlap: (0.7891754631522252+0.4269949545469905j)\n", + "\n", + "overlap between psi_exact and psi_api\n", + "|overlap|: 0.8687584965464771\n", + "overlap: (0.7726826471199991-0.3971181841232232j)\n", + "\n", + "overlap between psi_exact and psi_fgp_api\n", + "|overlap|: 0.8678331881699551\n", + "overlap: (0.8594146438993552-0.12058570537411661j)\n" + ] + } + ], + "source": [ + "psi = wfn_classical(params)\n", + "psi_fgp = wfn_classical(params_fgp)\n", + "psi_api = wfn_classical(params_api)\n", + "psi_fgp_api = wfn_classical(params_fgp_api)\n", + "\n", + "overlap = K.tensordot(K.conj(psi_fgp), psi, 1)\n", + "print(f'overlap between psi_fgp and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_fgp_api), psi_api, 1)\n", + "print(f'overlap between psi_fgp_api and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_api), psi, 1)\n", + "print(f'overlap between psi_api and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_fgp_api), psi_fgp, 1)\n", + "print(f'overlap between psi_fgp_api and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_exact), psi, 1)\n", + "print(f'overlap between psi_exact and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_exact), psi_fgp, 1)\n", + "print(f'overlap between psi_exact and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_exact), psi_api, 1)\n", + "print(f'overlap between psi_exact and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_exact), psi_fgp_api, 1)\n", + "print(f'overlap between psi_exact and psi_fgp_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T20:00:19.268174200Z", + "start_time": "2023-07-11T20:00:19.131845900Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Then we show the exact solution." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 21, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "min cost: 0.0\n", + "exact solution: ['000000111111', '111111000000']\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = [f'{bin(i)[2:]:0>{graph.number_of_nodes()}}' for i in np.where(Hv < 1e-6)[0]]\n", + "print(f'min cost: {0.}\\nexact solution: {idx}')\n", + "\n", + "# plot NetworkX graph\n", + "colors = ['r' if idx[0][i] == '0' else 'c' for i in graph.nodes]\n", + "nx.draw_networkx(graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T20:00:19.435090600Z", + "start_time": "2023-07-11T20:00:19.272569900Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Then we use the bit string with the maximum probability as the approximate solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment. Under the same learning rate ($\\tau$) and update steps, the results obtained by approximate imaginary-time evolution are similar to those obtained by Adam optimizer. The latter can be found in the tutorial of [QAOA for NAE3SAT](qaoa_nae3sat.ipynb)." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 22, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost by exact IME: 0.016369858553278067\n", + "cost: 0.027056689321034895\t0.027132044870745352 (fgp)\n", + "cost (API): 0.03343563416109707\t0.034067732605414805 (fgp)\n", + "\n", + "max prob by exact IME: 0.13846689405436738\n", + "max prob: 0.040346457516195935\t0.04024638313020584 (fgp)\n", + "max prob (API): 0.03200955784291694\t0.03179869846746198 (fgp)\n", + "\n", + "bit strings by exact IME: ['111111000000']\n", + "bit strings: ['011001011110']\t['011001011110'] (fgp)\n", + "bit strings (API): ['000000111111']\t['111111000000'] (fgp)\n" + ] + } + ], + "source": [ + "loss = K.real(K.tensordot(K.conj(psi) * Hv, psi, 1))\n", + "loss_fgp = K.real(K.tensordot(K.conj(psi_fgp) * Hv, psi_fgp, 1))\n", + "loss_api = K.real(K.tensordot(K.conj(psi_api) * Hv, psi_api, 1))\n", + "loss_fgp_api = K.real(K.tensordot(K.conj(psi_fgp_api) * Hv, psi_fgp_api, 1))\n", + "loss_exact = K.real(K.tensordot(K.conj(psi_exact) * Hv, psi_exact, 1))\n", + "print(f'cost by exact IME: {K.numpy(loss_exact)}')\n", + "print(f'cost: {K.numpy(loss)}\\t{K.numpy(loss_fgp)} (fgp)')\n", + "print(f'cost (API): {K.numpy(loss_api)}\\t{K.numpy(loss_fgp_api)} (fgp)\\n')\n", + "\n", + "# find the states with max probabilities\n", + "def find_max(psi):\n", + " probs = K.numpy(K.real(K.conj(psi) * psi))\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{graph.number_of_nodes()}}')\n", + " return max_prob, states\n", + "\n", + "prob, states = find_max(psi)\n", + "prob_fpg, states_fpg = find_max(psi_fgp)\n", + "prob_api, states_api = find_max(psi_api)\n", + "prob_fpg_api, states_fpg_api = find_max(psi_fgp_api)\n", + "prob_exact, states_exact = find_max(psi_exact)\n", + "print(f'max prob by exact IME: {prob_exact}')\n", + "print(f'max prob: {prob}\\t{prob_fpg} (fgp)')\n", + "print(f'max prob (API): {prob_api}\\t{prob_fpg_api} (fgp)\\n')\n", + "print(f'bit strings by exact IME: {states_exact}')\n", + "print(f'bit strings: {states}\\t{states_fpg} (fgp)')\n", + "print(f'bit strings (API): {states_api}\\t{states_fpg_api} (fgp)')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T20:00:19.543028600Z", + "start_time": "2023-07-11T20:00:19.434547200Z" + } + } + }, + { + "cell_type": "markdown", + "id": "4ae99ab9", + "metadata": {}, + "source": [ + "## Quantum Hamiltonian" + ] + }, + { + "cell_type": "markdown", + "id": "720dd1a4", + "metadata": {}, + "source": [ + "The quantum Hamiltonian is the Hamiltonian of the transverse and longitudinal field Ising model." + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Define the Hamiltonian" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Here we also calculate $e^{-\\tau\\hat{H}}$ in advance to perform exact imaginary-time evolution for comparison with approximate imaginary-time evolution." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "2115bb6d", + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-11T20:00:24.401402200Z", + "start_time": "2023-07-11T20:00:19.512868200Z" + } + }, + "outputs": [], + "source": [ + "N = 10\n", + "g = tc.templates.graphs.Line1D(N, pbc=False)\n", + "h = tc.quantum.heisenberg_hamiltonian(g, hzz=1, hyy=0, hxx=0, hz=0.5, hx=1, hy=0, sparse=True)\n", + "H = tc.array_to_tensor(h.todense())\n", + "\n", + "tau_q = 0.001\n", + "exp_tauH = K.expm(-tau_q * H)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Variational wave function" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Compared with the regular QAOA ansatz in the classic example, this ansatz has a higher parameter density and the initial state is $|0\\rangle$ instead of $|+\\rangle$." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 24, + "outputs": [], + "source": [ + "l = 10 # the number of layers\n", + "\n", + "@partial(K.jit, static_argnums=(1,))\n", + "def wfn_quantum(theta, each=1):\n", + " # PQC loop\n", + " def pqc_loop(s_, theta_):\n", + " c_ = tc.Circuit(N, inputs=s_)\n", + " for i in range(each):\n", + " for j in range(N):\n", + " c_.RZZ(j, (j + 1) % N, theta=theta_[i, j, 0])\n", + " for j in range(N):\n", + " c_.RX(j, theta=theta_[i, j, 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(N)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, K.reshape(theta, [l // each, each, N, 2]), s0)\n", + " c = tc.Circuit(N, inputs=s)\n", + "\n", + " return c.state()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T20:00:24.430347Z", + "start_time": "2023-07-11T20:00:24.401402200Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Optimization" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We also use two methods to calculate $\\boldsymbol{\\delta}$, but make some changes in the method of directly calling the API and the update method. When calculating $\\boldsymbol{A}$, we call $\\text{qng2}$ instead of $\\text{qng}$, and when calculating $\\boldsymbol{C}$, we call $\\text{dynamics_rhs}$ instead of calculating the energy gradient by $\\text{value_and_grad}$. For the update method, we do not call the existing optimizer but directly adopt the naive update method." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 25, + "outputs": [], + "source": [ + "@partial(K.jit, static_argnums=(2,))\n", + "def d_theta(theta, psi, fixed_global_phase=False):\n", + " psi = psi[:, None]\n", + " psiHT = K.conj(K.transpose(psi))\n", + " par_psi = K.jacfwd(wfn_quantum, argnums=0)\n", + " jac = par_psi(theta)\n", + " jacHT = K.conj(K.transpose(jac))\n", + "\n", + " A = K.real(jacHT @ jac)\n", + " if not fixed_global_phase:\n", + " A -= K.real(jacHT @ psi @ psiHT @ jac)\n", + " # protection\n", + " A += 1e-6 * K.eye(theta.shape[-1], dtype=A.dtype)\n", + "\n", + " C = K.real(psiHT @ K.sparse_dense_matmul(h, jac))[0]\n", + "\n", + " return K.solve(A, C, assume_a=\"sym\")\n", + "\n", + "@partial(K.jit, static_argnums=(1,))\n", + "def d_theta_api(theta, fixed_global_phase=False):\n", + " if fixed_global_phase:\n", + " qng = experimental.qng2(wfn_quantum, kernel=\"dynamics\", mode=\"fwd\")\n", + " else:\n", + " qng = experimental.qng2(wfn_quantum, kernel=\"qng\", mode=\"fwd\")\n", + " A = qng(theta)\n", + " # protection\n", + " A += 1e-6 * K.eye(theta.shape[-1], dtype=A.dtype)\n", + "\n", + " vag = experimental.dynamics_rhs(wfn_quantum, h)\n", + " C = vag(theta)\n", + "\n", + " return K.solve(A, C, assume_a=\"sym\")\n", + "\n", + "@K.jit\n", + "def update(theta, delta, tau):\n", + " return theta - K.cast(tau * delta, dtype=theta.dtype)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T20:00:24.430347Z", + "start_time": "2023-07-11T20:00:24.417868500Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 26, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "steps_quantum = 2000\n", + "\n", + "# initial parameters\n", + "theta = K.implicit_randn(shape=(2 * l * N,), stddev=0.1)\n", + "theta_fgp = K.copy(theta)\n", + "theta_api = K.copy(theta)\n", + "theta_fgp_api = K.copy(theta)\n", + "psi_exact = wfn_quantum(theta)[:, None]\n", + "\n", + "losses, losses_fgp, losses_exact = [], [], []\n", + "losses_api, losses_fgp_api = [], []\n", + "\n", + "for i in range(steps_quantum):\n", + " psi = wfn_quantum(theta)\n", + " loss = K.real(K.conj(psi)[None, :] @ K.sparse_dense_matmul(h, psi[:, None]))[0, 0]\n", + " delta = d_theta(theta, psi)\n", + " theta = update(theta, delta, tau_q)\n", + " losses.append(loss)\n", + "\n", + " psi_fgp = wfn_quantum(theta_fgp)\n", + " loss_fgp = K.real(K.conj(psi_fgp)[None, :] @ K.sparse_dense_matmul(h, psi_fgp[:, None]))[0, 0]\n", + " delta_fgp = d_theta(theta_fgp, psi_fgp, fixed_global_phase=True)\n", + " theta_fgp = update(theta_fgp, delta_fgp, tau_q)\n", + " losses_fgp.append(loss_fgp)\n", + "\n", + " psi_api = wfn_quantum(theta_api)\n", + " loss_api = K.real(K.conj(psi_api)[None, :] @ K.sparse_dense_matmul(h, psi_api[:, None]))[0, 0]\n", + " delta_api = d_theta_api(theta_api)\n", + " theta_api = update(theta_api, delta_api, tau_q)\n", + " losses_api.append(loss_api)\n", + "\n", + " psi_fgp_api = wfn_quantum(theta_fgp_api)\n", + " loss_fgp_api = K.real(K.conj(psi_fgp_api)[None, :] @ K.sparse_dense_matmul(h, psi_fgp_api[:, None]))[0, 0]\n", + " delta_fgp_api = d_theta_api(theta_fgp_api, fixed_global_phase=True)\n", + " theta_fgp_api = update(theta_fgp_api, delta_fgp_api, tau_q)\n", + " losses_fgp_api.append(loss_fgp_api)\n", + "\n", + " loss_exact = K.real(K.transpose(K.conj(psi_exact)) @ K.sparse_dense_matmul(h, psi_exact))[0, 0]\n", + " psi_exact = exp_tauH @ psi_exact\n", + " psi_exact /= K.norm(psi_exact)\n", + " losses_exact.append(K.numpy(loss_exact))\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Energy')\n", + " plt.plot(range(i + 1), losses_exact, c='r', label='exact')\n", + " plt.plot(range(i + 1), losses, c='b', label='unfixed GP')\n", + " plt.plot(range(i + 1), losses_fgp, c='g', label='fixed GP')\n", + " plt.plot(range(i + 1), losses_api, c='m', label='unfixed GP (API)')\n", + " plt.plot(range(i + 1), losses_fgp_api, c='y', label='fixed GP (API)')\n", + " plt.legend()\n", + " plt.show()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "### Results" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods are very close, which differ very little from the exact final state. Similarly, the final states obtained by the same method but with fixed and unfixed global phases have only one global phase difference." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 27, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "overlap between psi_fgp and psi\n", + "|overlap|: 0.9988745789696979\n", + "overlap: (-0.19668447544972692+0.979318968277934j)\n", + "\n", + "overlap between psi_fgp_api and psi_api\n", + "|overlap|: 0.9879934153835302\n", + "overlap: (0.3603519955155164-0.9199333824626641j)\n", + "\n", + "overlap between psi_api and psi\n", + "|overlap|: 0.9316780773622957\n", + "overlap: (-0.9311795508745964+0.030474314930587453j)\n", + "\n", + "overlap between psi_fgp_api and psi_fgp\n", + "|overlap|: 0.9464927401778188\n", + "overlap: (0.9373049454332234+0.13155966887970733j)\n", + "\n", + "overlap between psi_exact and psi\n", + "|overlap|: 0.8929004801904091\n", + "overlap: (-0.15813235179268223+0.8787863374226859j)\n", + "\n", + "overlap between psi_exact and psi_fgp\n", + "|overlap|: 0.8933693118434571\n", + "overlap: (0.8928470335487045-0.030543444909353012j)\n", + "\n", + "overlap between psi_exact and psi_api\n", + "|overlap|: 0.8290367234971434\n", + "overlap: (0.05352132993406158-0.8273072924548461j)\n", + "\n", + "overlap between psi_exact and psi_fgp_api\n", + "|overlap|: 0.8521917037527431\n", + "overlap: (0.8148474344143313-0.24950823347814624j)\n" + ] + } + ], + "source": [ + "psi = wfn_quantum(theta)\n", + "psi_fgp = wfn_quantum(theta_fgp)\n", + "psi_api = wfn_quantum(theta_api)\n", + "psi_fgp_api = wfn_quantum(theta_fgp_api)\n", + "\n", + "overlap = K.tensordot(K.conj(psi_fgp), psi, 1)\n", + "print(f'overlap between psi_fgp and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_fgp_api), psi_api, 1)\n", + "print(f'overlap between psi_fgp_api and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_api), psi, 1)\n", + "print(f'overlap between psi_api and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_fgp_api), psi_fgp, 1)\n", + "print(f'overlap between psi_fgp_api and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_exact[:, 0]), psi, 1)\n", + "print(f'overlap between psi_exact and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_exact[:, 0]), psi_fgp, 1)\n", + "print(f'overlap between psi_exact and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_exact[:, 0]), psi_api, 1)\n", + "print(f'overlap between psi_exact and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "overlap = K.tensordot(K.conj(psi_exact[:, 0]), psi_fgp_api, 1)\n", + "print(f'overlap between psi_exact and psi_fgp_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T21:53:21.980433500Z", + "start_time": "2023-07-11T21:53:21.909960400Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Then we compare the approximate ground state energy with the exact result. The differences are very small, but the result obtained by exact imaginary-time evolution is indeed the closest to the real ground state energy." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 28, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exact ground state energy: -12.669360644773814\n", + "\n", + "ground state energy by exact IME: -12.634412590497769\n", + "ground state energy: -12.4774432814582\t-12.481075889123861 (fgp)\n", + "ground state energy (API): -12.391673576863138\t-12.427648711247233 (fgp)\n" + ] + } + ], + "source": [ + "E = K.eigvalsh(H)[0]\n", + "print(f'exact ground state energy: {E}\\n')\n", + "loss_exact = K.real(K.transpose(K.conj(psi_exact)) @ K.sparse_dense_matmul(h, psi_exact))[0, 0]\n", + "print(f'ground state energy by exact IME: {K.numpy(loss_exact)}')\n", + "loss = K.real(K.conj(psi)[None, :] @ K.sparse_dense_matmul(h, psi[:, None]))[0, 0]\n", + "loss_fgp = K.real(K.conj(psi_fgp)[None, :] @ K.sparse_dense_matmul(h, psi_fgp[:, None]))[0, 0]\n", + "print(f'ground state energy: {K.numpy(loss)}\\t{K.numpy(loss_fgp)} (fgp)')\n", + "loss_api = K.real(K.conj(psi_api)[None, :] @ K.sparse_dense_matmul(h, psi_api[:, None]))[0, 0]\n", + "loss_fgp_api = K.real(K.conj(psi_fgp_api)[None, :] @ K.sparse_dense_matmul(h, psi_fgp_api[:, None]))[0, 0]\n", + "print(f'ground state energy (API): {K.numpy(loss_api)}\\t{K.numpy(loss_fgp_api)} (fgp)')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-11T21:53:22.388902100Z", + "start_time": "2023-07-11T21:53:21.962763600Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "89ed16e3", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "ExecuteTime": { + "end_time": "2023-07-12T01:54:11.094124500Z", + "start_time": "2023-07-12T01:54:11.065644100Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OS info: Linux-5.4.119-1-tlinux4-0010.2-x86_64-with-glibc2.28\n", + "Python version: 3.10.11\n", + "Numpy version: 1.23.5\n", + "Scipy version: 1.11.0\n", + "Pandas version: 2.0.2\n", + "TensorNetwork version: 0.4.6\n", + "Cotengra version: 0.2.1.dev15+g120379e\n", + "TensorFlow version: 2.12.0\n", + "TensorFlow GPU: []\n", + "TensorFlow CUDA infos: {'cpu_compiler': '/dt9/usr/bin/gcc', 'cuda_compute_capabilities': ['sm_35', 'sm_50', 'sm_60', 'sm_70', 'sm_75', 'compute_80'], 'cuda_version': '11.8', 'cudnn_version': '8', 'is_cuda_build': True, 'is_rocm_build': False, 'is_tensorrt_build': True}\n", + "Jax version: 0.4.13\n", + "Jax installation doesn't support GPU\n", + "JaxLib version: 0.4.13\n", + "PyTorch version: 2.0.1\n", + "PyTorch GPU support: False\n", + "PyTorch GPUs: []\n", + "Cupy is not installed\n", + "Qiskit version: 0.24.1\n", + "Cirq version: 1.1.0\n", + "TensorCircuit version 0.10.0\n" + ] + } + ], + "source": [ + "tc.about()" + ] + } + ], + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From cb82af6374393085ad959a385d9ba8f4dde3db64 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Wed, 12 Jul 2023 12:49:18 +0100 Subject: [PATCH 534/725] update the tutorials --- docs/source/tutorials/QUBO_problem.ipynb | 608 ++++++++++++++++++ .../tutorials/portfolio_optimization.ipynb | 502 +++++++++++++++ 2 files changed, 1110 insertions(+) create mode 100644 docs/source/tutorials/QUBO_problem.ipynb create mode 100644 docs/source/tutorials/portfolio_optimization.ipynb diff --git a/docs/source/tutorials/QUBO_problem.ipynb b/docs/source/tutorials/QUBO_problem.ipynb new file mode 100644 index 00000000..2eb9f49e --- /dev/null +++ b/docs/source/tutorials/QUBO_problem.ipynb @@ -0,0 +1,608 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "6ddb8a88-779a-43f7-ae14-115463bd87f5", + "metadata": {}, + "source": [ + "# Solving portfolio optimization as QUBO problem with QAOA\n", + "\n", + "## Overview\n", + "\n", + "In this tutorial we will demonstrate how to solve quadratic unconstrained binary optimization (QUBO) problems using QAOA.\n", + "\n", + "## QUBO problem\n", + "\n", + "### what is QUBO?\n", + "\n", + "Quadratic unconstrained binary optimization (QUBO) is a type of problem that aims to optimize a quadratic objective function using binary variables. The primary goal of a QUBO problem is to determine the assignments of binary variables that minimize or maximize the quadratic objective function. These variables represent choices or decision variables that can be either selected (1) or not selected (0). The objective function captures the associated costs, benefits, or constraints related to these decisions.\n", + "\n", + "From a computational perspective, solving a QUBO problem is generally considered NP-hard. This classification implies that finding the optimal solution to a QUBO instance is believed to be computationally challenging, and there is no known polynomial-time algorithm that can efficiently solve all QUBO problems.\n", + "\n", + "However, a promising approach called Quantum Approximate Optimization Algorithm (QAOA), introduced in this [this tutorial](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html), has the potential to offer significant advantages when applied to QUBO problem solving. QAOA leverages the inherent quantum parallelism and interference effects to explore the solution space more efficiently compared to classical methods. This efficiency can lead to faster and more optimal solutions. In QAOA, each qubit represents a binary variable, and the objective function is calculated as the expected value of a quantum state generated by the ansatz. The parameters in the ansatz are iteratively optimized by a classical algorithm to improve the solution quality.\n", + "\n", + "### General Case\n", + "\n", + "For the general QUBO case, we wish to minimize the cost function in the form of\n", + "\n", + "$$ x^T Q x$$\n", + "\n", + "where $x\\in\\{0,1\\}^n$ and $Q\\in\\mathbb{R}^{n\\times n}$ is a real symmetric matrix.\n", + "\n", + "This function maps to an Ising Hamiltonian \n", + "\n", + "$$\\frac{1}{2}\\left(\\sum_{i=1}^n C_{ii} + \\sum_{i{n_qubits}}\"\n", + " states.append(a)\n", + "\n", + " # Calculate the probabilities of each state using the circuit's probability method\n", + " probs = K.numpy(c.probability()).round(decimals=4)\n", + "\n", + " # Sort the states and probabilities in descending order based on the probabilities\n", + " sorted_indices = np.argsort(probs)[::-1]\n", + " if reverse == True:\n", + " sorted_indices = sorted_indices[::-1]\n", + " state_sorted = np.array(states)[sorted_indices]\n", + " prob_sorted = np.array(probs)[sorted_indices]\n", + "\n", + " print(\"\\n-------------------------------------\")\n", + " print(\" selection\\t |\\tprobability\")\n", + " print(\"-------------------------------------\")\n", + " if wrap == False:\n", + " for i in range(len(states)):\n", + " print(\"%10s\\t |\\t %.4f\" % (state_sorted[i], prob_sorted[i]))\n", + " # Print the sorted states and their corresponding probabilities\n", + " elif wrap == True:\n", + " for i in range(4):\n", + " print(\"%10s\\t |\\t %.4f\" % (state_sorted[i], prob_sorted[i]))\n", + " print(\" ... ...\")\n", + " for i in range(-4, -1):\n", + " print(\"%10s\\t |\\t %.4f\" % (state_sorted[i], prob_sorted[i]))\n", + " print(\"-------------------------------------\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "da315228", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "-------------------------------------\n", + " selection\t |\tprobability\n", + "-------------------------------------\n", + " 10\t |\t 0.8708\n", + " 11\t |\t 0.1251\n", + " 00\t |\t 0.0040\n", + " 01\t |\t 0.0001\n", + "-------------------------------------\n" + ] + } + ], + "source": [ + "c = QAOA_ansatz_for_Ising(final_params, nlayers, pauli_terms, weights)\n", + "\n", + "print_result_prob(c)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "294ea9ce-5064-4176-94d0-8dbb7d1707f8", + "metadata": {}, + "outputs": [], + "source": [ + "def print_output(c):\n", + " n = c._nqubits\n", + " N = 2**n\n", + "\n", + " # Generate labels for the x-axis representing the binary states\n", + " x_label = r\"$\\left|{0:0\" + str(n) + r\"b}\\right>$\"\n", + " labels = [x_label.format(i) for i in range(N)]\n", + "\n", + " # Create a bar plot with the probabilities of each state\n", + " plt.bar(range(N), c.probability())\n", + "\n", + " # Set the x-axis ticks to the generated labels and rotate them for better visibility\n", + " plt.xticks(range(N), labels, rotation=70)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "fc1353ab-7a7a-4cdc-931c-3b90417c4961", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_output(c)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c48e4a38", + "metadata": {}, + "source": [ + "## Improve the performance with CVaR\n", + "\n", + " Conditional Value-at-Risk (CVaR) is a risk measure that quantifies the potential loss beyond a certain threshold (alpha), considering the tail end of the distribution. In QAOA, incorporating CVaR as an objective function allows for addressing risk-averse optimization problems effectively. By optimizing for CVaR, the algorithm focuses on minimizing the expected value of the worst-case scenario, rather than solely optimizing for the mean or expected value, which usually lead to a faster convergence to a more accurate result.\n", + "\n", + " In order to showcase the performance of CVaR, a more complicated QUBO problem is used. The Q matrix is:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "02ec55b6", + "metadata": {}, + "outputs": [], + "source": [ + "Q = np.array(\n", + " [\n", + " [-60.3657, 11.68835, 12.23445, 11.7274, 11.9959, 11.80955],\n", + " [11.68835, -59.7527, 11.6231, 13.23295, 11.96335, 12.44725],\n", + " [12.23445, 11.6231, -59.69535, 11.29525, 12.00035, 11.78495],\n", + " [11.7274, 13.23295, 11.29525, -59.12165, 12.1006, 12.5461],\n", + " [11.9959, 11.96335, 12.00035, 12.1006, -60.45515, 12.07545],\n", + " [11.80955, 12.44725, 11.78495, 12.5461, 12.07545, -59.9126],\n", + " ]\n", + ")\n", + "pauli_terms, weights, offset = QUBO_to_Ising(Q)" + ] + }, + { + "cell_type": "markdown", + "id": "76879a55", + "metadata": {}, + "source": [ + "Then let's define a function to brutally calculate the costs (classical methods). The results are printed below." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "46e9cbd9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "-------------------------------------\n", + " selection\t |\t cost\n", + "-------------------------------------\n", + " 110010\t |\t-109.2784\n", + " 100011\t |\t-108.9717\n", + " 011010\t |\t-108.7296\n", + " 111000\t |\t-108.7219\n", + " 101100\t |\t-108.6685\n", + " 001110\t |\t-108.4798\n", + " 001011\t |\t-108.3416\n", + " 101001\t |\t-108.3157\n", + " ...\t |\t ...\n", + "-------------------------------------\n" + ] + } + ], + "source": [ + "def print_Q_cost(Q, wrap=False, reverse=False):\n", + " n_stocks = len(Q)\n", + " states = []\n", + " for i in range(2**n_stocks):\n", + " a = f\"{bin(i)[2:]:0>{n_stocks}}\"\n", + " n_ones = 0\n", + " for j in a:\n", + " if j == \"1\":\n", + " n_ones += 1\n", + " states.append(a)\n", + "\n", + " cost_dict = {}\n", + " for selection in states:\n", + " x = np.array([int(bit) for bit in selection])\n", + " cost_dict[selection] = np.dot(x, np.dot(Q, x))\n", + " cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1]))\n", + " if reverse == True:\n", + " cost_sorted = dict(\n", + " sorted(cost_dict.items(), key=lambda item: item[1], reverse=True)\n", + " )\n", + " num = 0\n", + " print(\"\\n-------------------------------------\")\n", + " print(\" selection\\t |\\t cost\")\n", + " print(\"-------------------------------------\")\n", + " for k, v in cost_sorted.items():\n", + " print(\"%10s\\t |\\t%.4f\" % (k, v))\n", + " num += 1\n", + " if (num >= 8) & (wrap == True):\n", + " break\n", + " print(\" ...\\t |\\t ...\")\n", + " print(\"-------------------------------------\")\n", + "\n", + "print_Q_cost(Q, wrap=True)" + ] + }, + { + "cell_type": "markdown", + "id": "04d4ea38", + "metadata": {}, + "source": [ + "The QAOA with CVaR and different alpha will be run and a callback function will be used to record the parameters during the solving prosedure." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d3b386d6", + "metadata": {}, + "outputs": [], + "source": [ + "# Set the number of layers to 2\n", + "nlayers = 2\n", + "\n", + "# Define a list of alpha values\n", + "alpha_list = [0.1, 0.25, 1]\n", + "\n", + "\n", + "# Define the callback function to record parameter values\n", + "def record_param(xk):\n", + " xk_list.append(xk)\n", + "\n", + "\n", + "# Generate initial parameters randomly for all alpha\n", + "init_params = K.implicit_randn(shape=[2 * nlayers], stddev=0.5)\n", + "\n", + "# Create an empty list to store parameter values for each alpha\n", + "params_list = []\n", + "\n", + "# Iterate over each alpha value\n", + "for alpha in alpha_list:\n", + " # Create a new empty list for callback function\n", + " xk_list = []\n", + "\n", + " # Run the QUBO_QAOA_cvar function with the specified parameters\n", + " final_params = QUBO_QAOA_cvar(\n", + " Q,\n", + " nlayers,\n", + " alpha=alpha,\n", + " callback=record_param,\n", + " maxiter=100,\n", + " init_params=init_params,\n", + " )\n", + "\n", + " # Append the parameter values for the current alpha to the params_list\n", + " params_list.append(xk_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b3da7c48", + "metadata": {}, + "outputs": [], + "source": [ + "best = 50 # Represents the binary number 110010\n", + "prob_list = [] # Create an empty list to store probabilities\n", + "loss_list = [] # Create an empty list to store loss values\n", + "\n", + "# Iterate three times\n", + "for i in range(3):\n", + " c = QAOA_ansatz_for_Ising(init_params, nlayers, pauli_terms, weights)\n", + " loss = [cvar_loss(nlayers, Q, 1000, alpha_list[i], True, init_params)]\n", + " prob = [c.probability()[best].numpy()]\n", + "\n", + " # Iterate 100 times\n", + " for j in range(100):\n", + " if j < len(params_list[i]) - 1:\n", + " params = params_list[i][j]\n", + " else:\n", + " pass\n", + " c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights)\n", + " loss.append(cvar_loss(nlayers, Q, 1000, alpha_list[i], True, params))\n", + " prob.append(c.probability()[best].numpy())\n", + "\n", + " loss_list.append(loss) # Append the loss values to the loss_list\n", + " prob_list.append(prob) # Append the probability values to the prob_list" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d1f375ce", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'loss')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for loss in loss_list:\n", + " plt.plot(loss)\n", + "plt.legend([0.1, 0.25, 1])\n", + "plt.xlabel('iterations')\n", + "plt.ylabel('loss')" + ] + }, + { + "cell_type": "markdown", + "id": "6a88dda3", + "metadata": {}, + "source": [ + "The depicted figure illustrates that the utilization of CVaR results in quicker convergence towards a lower loss." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f81fdeae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'probability of the best answer')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for prob in prob_list:\n", + " plt.plot(prob)\n", + "plt.legend([0.1, 0.25, 1])\n", + "plt.xlabel('iterations')\n", + "plt.ylabel('probability of the best answer')" + ] + }, + { + "cell_type": "markdown", + "id": "0ae45348", + "metadata": {}, + "source": [ + "The data presented in this figure indicates that QAOA with CVaR typically exhibits a higher probability of obtaining the correct measurement outcome." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tc_dev", + "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/docs/source/tutorials/portfolio_optimization.ipynb b/docs/source/tutorials/portfolio_optimization.ipynb new file mode 100644 index 00000000..3ed0f4e3 --- /dev/null +++ b/docs/source/tutorials/portfolio_optimization.ipynb @@ -0,0 +1,502 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "6ddb8a88-779a-43f7-ae14-115463bd87f5", + "metadata": {}, + "source": [ + "# Portfolio Optimization\n", + "\n", + "## Introduction\n", + "\n", + "Consider the following scenario: Xiaoming, an astute individual, possesses a sum of money represented by $B$ and is contemplating investing it in the stock market. The market comprises of $n$ shares, each having an identical price. Xiaoming's objective is to maximize returns while minimizing risk, taking into account the varying levels of risk tolerance among individuals. Xiaoming's personal risk tolerance is represented by $p$. In light of these considerations, the question arises: which shares should Xiaoming choose to construct an optimal portfolio?\n", + "\n", + "Xiaoming's predicament falls under the purview of portfolio optimization problems. These problems are classified as Quadratic Unconstrained Binary Optimization (QUBO) problems, wherein binary numbers are utilized to represent decisions. In this case, \"1\" signifies selection, while \"0\" denotes the opposite. To address the challenge of portfolio optimization, the Quantum Approximate Optimization Algorithm (QAOA) is employed.\n", + "\n", + "## Solving portfolio optimization problems with QAOA\n", + "\n", + "In a simple boolean Markowitz portfolio optimization problem, we wish to solve \n", + "\n", + "$$\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^T x$$\n", + "\n", + "subject to a constraint\n", + "\n", + "$$ 1^T x = B$$\n", + "\n", + "where \n", + "* $n$: number of assets under consideration\n", + "* $q > 0 $: risk-appetite\n", + "* $\\Sigma \\in \\mathbb{R}^{n\\times n}$: covariance matrix of the assets\n", + "* $\\mu\\in\\mathbb{R}^n$: mean return of the assets\n", + "* $B$: budget (i.e., total number of assets out of $n$ that can be selected)\n", + "\n", + "Our first step is to convert this constrained quadratic programming problem into a QUBO. We do this by adding a penalty factor $t$ and consider the alternative problem:\n", + "\n", + "$$ \\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^Tx + t(1^Tx-B)^2$$\n", + "\n", + "The variables in the linear terms $\\mu^Tx = \\mu_1 x_1 + \\mu_2 x_2+\\ldots$ can all be written in a squared form, since all boolean variables $0^2=0,\\ 1^2=1$. The same trick is applied on the middle term of $t(1^Tx-B)^2$. Then the function is written as\n", + "\n", + "$$\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\sum_{i=1}^n\\mu_i x_i^2 + t(1^Tx-B)^2$$\n", + "\n", + "which is a QUBO problem\n", + "\n", + "$$\\min_{x\\in\\{0,1\\}^n}\\quad x^T Q X + tB^2$$\n", + "\n", + "where matrix $Q$ is\n", + "\n", + "$$ Q = q\\Sigma -\\mu\\begin{pmatrix}1 & \\\\ & 1\\\\ & & \\ddots\\end{pmatrix} + t\\begin{pmatrix}1 -2B & 1 & \\ldots & 1 \\\\\n", + "1 & 1-2B & 1 & \\ldots \\\\1 & 1 & 1-2B \\\\\n", + "\\vdots\\end{pmatrix}$$\n", + "\n", + "and we ignore the constant term $t B^2$. We can now solve this by QAOA as above.\n", + "\n", + "## Set up" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "657c589a", + "metadata": {}, + "outputs": [], + "source": [ + "## delete before PR\n", + "import sys\n", + "\n", + "sys.path.append(\"D:\\OneDrive - Imperial College London\\文件\\Code\\TensorCircuit\")\n", + "sys.path.append(\"/Users/felixxu/Library/CloudStorage/OneDrive-ImperialCollegeLondon/文件/Code/TensorCircuit\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4f4feab6", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import clear_output\n", + "from functools import partial\n", + "import time\n", + "import scipy.optimize as optimize\n", + "\n", + "from tensorcircuit.templates.blocks import QAOA_ansatz_for_Ising\n", + "from tensorcircuit.templates.conversions import QUBO_to_Ising, QUBO_from_portfolio\n", + "from tensorcircuit.applications.optimization import QUBO_QAOA, QAOA_loss\n", + "from tensorcircuit.templates.conversions import StockData\n", + "\n", + "K = tc.set_backend(\"tensorflow\")\n", + "tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)" + ] + }, + { + "cell_type": "markdown", + "id": "55659298", + "metadata": {}, + "source": [ + "## Import data\n", + "\n", + "To optimize a portfolio, it is essential to utilize historical data from various stocks within the same time frame. Websites such as [Nasdaq](Nasdaq.com) and [Yahoo Finance](https://finance.yahoo.com/) provide access to such data. The next step involves transforming this data into an annualized return ($\\mu$) and covariance matrix ($\\sigma$), which can be recognized by the Quantum Approximate Optimization Algorithm (QAOA). To simplify this process, we can utilize the `StockData` class. This class performs the necessary calculations for annualized return and covariance, as outlined in this [paper](https://doi.org/10.1007/s11128-022-03766-5). They are:\n", + "\n", + "$$\n", + "\\mu = \\left[\\prod ^m_{k=1}\\left(1+r_k^{(i)}\\right)\\right]^{\\frac{252}{m}}\\\\\n", + "\\sigma_{ij}=\\frac{252}{m}\\sum^m_{k=1}\\left(r_k^{(i)}-\\overline{r^{(i)}}\\right)\\left(r_k^{(j)}-\\overline{r^{(j)}}\\right)\n", + "$$\n", + "\n", + "Here is a demonstration of how to use this class:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "62bf0673", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/felixxu/Library/CloudStorage/OneDrive-ImperialCollegeLondon/文件/Code/TensorCircuit/tensorcircuit/templates/conversions.py:163: RuntimeWarning: invalid value encountered in power\n", + " ret = np.prod(change, axis=1) ** (252 / self.n_days)\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "# randomly generate historical data of 6 stocks in 1000 days\n", + "data = [[random.random() for i in range(1000)] for j in range(6)]\n", + "stock_data = StockData(data) # Create an instance\n", + "\n", + "# calculate the annualized return and covariance matrix\n", + "mu = stock_data.get_return()\n", + "sigma = stock_data.get_covariance()\n", + "\n", + "# some other information can also be obtained from this class\n", + "n_stocks = stock_data.n_stocks # number of stocks\n", + "n_days = stock_data.n_days # length of the time span\n", + "daily_change = stock_data.daily_change # relative change of each day" + ] + }, + { + "cell_type": "markdown", + "id": "0fb1d227", + "metadata": {}, + "source": [ + "In this analysis, we have carefully chosen six prominent stocks: Apple Inc. (AAPL), Microsoft Corporation (MSFT), NVIDIA Corporation (NVDA), Pfizer Inc. (PFE), Levi Strauss & Co. (LEVI), and Cisco Systems, Inc. (CSCO). We acquired their historical data spanning from 09/07/2022, to 09/07/2023 from Yahoo finance. Here are the return and covariance associated with this dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a7eb3a74", + "metadata": {}, + "outputs": [], + "source": [ + "# real-world stock data, calculated using the class above\n", + "# stock name: aapl, msft, nvda, pfe, levi, csco\n", + "# from 09/07/2022 to 09/07/2023\n", + "mu = [1.21141, 1.15325, 2.06457, 0.63539, 0.63827, 1.12224]\n", + "\n", + "sigma = np.array(\n", + " [\n", + " [0.08488, 0.06738, 0.09963, 0.02124, 0.05516, 0.04059],\n", + " [0.06738, 0.10196, 0.11912, 0.02163, 0.0498, 0.04049],\n", + " [0.09963, 0.11912, 0.31026, 0.01977, 0.10415, 0.06179],\n", + " [0.02124, 0.02163, 0.01977, 0.05175, 0.01792, 0.02137],\n", + " [0.05516, 0.0498, 0.10415, 0.01792, 0.19366, 0.0432],\n", + " [0.04059, 0.04049, 0.06179, 0.02137, 0.0432, 0.05052],\n", + " ]\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f6dc53d4-7ed0-436d-aa1f-8674c56e756e", + "metadata": {}, + "source": [ + "Using this mean and covariance data, we can now define our portfolio optimization problem, convert it to a QUBO matrix, and then extract the pauli terms and weights" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3f6edcd5-3c10-49fc-86ea-160fc6d3187e", + "metadata": {}, + "outputs": [], + "source": [ + "q = 0.5 # the risk preference of investor\n", + "budget = 4 # Note that in this example, there are 6 assets, but a budget of only 4\n", + "penalty = 1.2\n", + "\n", + "Q = QUBO_from_portfolio(sigma, mu, q, budget, penalty)\n", + "portfolio_pauli_terms, portfolio_weights, portfolio_offset = QUBO_to_Ising(Q)" + ] + }, + { + "cell_type": "markdown", + "id": "730da712", + "metadata": {}, + "source": [ + "## Classical method\n", + "\n", + "We firstly use brutal force to calculate the cost of each combination. It will give us a clue on the performance of QAOA." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "168f7c36", + "metadata": {}, + "outputs": [], + "source": [ + "def print_Q_cost(Q, wrap=False, reverse=False):\n", + " n_stocks = len(Q)\n", + " states = []\n", + " for i in range(2**n_stocks):\n", + " a = f\"{bin(i)[2:]:0>{n_stocks}}\"\n", + " n_ones = 0\n", + " for j in a:\n", + " if j == \"1\":\n", + " n_ones += 1\n", + " states.append(a)\n", + "\n", + " cost_dict = {}\n", + " for selection in states:\n", + " x = np.array([int(bit) for bit in selection])\n", + " cost_dict[selection] = np.dot(x, np.dot(Q, x))\n", + " cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1]))\n", + " if reverse == True:\n", + " cost_sorted = dict(\n", + " sorted(cost_dict.items(), key=lambda item: item[1], reverse=True)\n", + " )\n", + " num = 0\n", + " print(\"\\n-------------------------------------\")\n", + " print(\" selection\\t |\\t cost\")\n", + " print(\"-------------------------------------\")\n", + " for k, v in cost_sorted.items():\n", + " print(\"%10s\\t |\\t%.4f\" % (k, v))\n", + " num += 1\n", + " if (num >= 8) & (wrap == True):\n", + " break\n", + " print(\" ...\\t |\\t ...\")\n", + " print(\"-------------------------------------\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "6a9d41c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "-------------------------------------\n", + " selection\t |\t cost\n", + "-------------------------------------\n", + " 111001\t |\t-24.0487\n", + " 101101\t |\t-23.7205\n", + " 111100\t |\t-23.6414\n", + " 011101\t |\t-23.6340\n", + " 101011\t |\t-23.5123\n", + " 011011\t |\t-23.4316\n", + " 111010\t |\t-23.4269\n", + " 111101\t |\t-23.3742\n", + " ...\t |\t ...\n", + "-------------------------------------\n" + ] + } + ], + "source": [ + "print_Q_cost(Q, wrap=True)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c34f3398", + "metadata": {}, + "source": [ + "### Use QAOA\n", + "\n", + "Here, a standard QAOA ansatz with 12 layers is used. This circuit will be trained for 1200 times." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9249ea96", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "iterations = 1000\n", + "nlayers = 12\n", + "loss_list = []\n", + "\n", + "# define a callback function to recode the loss\n", + "def record_loss(loss, params):\n", + " loss_list.append(loss)\n", + "\n", + "# apply QAOA on this portfolio optimization problem\n", + "final_params = QUBO_QAOA(Q, nlayers, iterations, callback=record_loss)\n", + "\n", + "p = plt.plot(loss_list)" + ] + }, + { + "cell_type": "markdown", + "id": "9126333d", + "metadata": {}, + "source": [ + "Create a function to visualize the results, listing all combinations in descending order of probability." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "4a2c60e4", + "metadata": {}, + "outputs": [], + "source": [ + "def print_result_prob(c, wrap=False, reverse=False):\n", + " states = []\n", + " n_qubits = c._nqubits\n", + " for i in range(2**n_qubits):\n", + " a = f\"{bin(i)[2:]:0>{n_qubits}}\"\n", + " states.append(a)\n", + " # Generate all possible binary states for the given number of qubits\n", + "\n", + " probs = K.numpy(c.probability()).round(decimals=4)\n", + " # Calculate the probabilities of each state using the circuit's probability method\n", + "\n", + " sorted_indices = np.argsort(probs)[::-1]\n", + " if reverse == True:\n", + " sorted_indices = sorted_indices[::-1]\n", + " state_sorted = np.array(states)[sorted_indices]\n", + " prob_sorted = np.array(probs)[sorted_indices]\n", + " # Sort the states and probabilities in descending order based on the probabilities\n", + "\n", + " print(\"\\n-------------------------------------\")\n", + " print(\" selection\\t |\\tprobability\")\n", + " print(\"-------------------------------------\")\n", + " if wrap == False:\n", + " for i in range(len(states)):\n", + " print(\"%10s\\t |\\t %.4f\" % (state_sorted[i], prob_sorted[i]))\n", + " # Print the sorted states and their corresponding probabilities\n", + " elif wrap == True:\n", + " for i in range(4):\n", + " print(\"%10s\\t |\\t %.4f\" % (state_sorted[i], prob_sorted[i]))\n", + " print(\" ... ...\")\n", + " for i in range(-5, -1):\n", + " print(\"%10s\\t |\\t %.4f\" % (state_sorted[i], prob_sorted[i]))\n", + " print(\"-------------------------------------\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "680f52d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "-------------------------------------\n", + " selection\t |\tprobability\n", + "-------------------------------------\n", + " 111001\t |\t 0.1169\n", + " 101101\t |\t 0.0872\n", + " 111100\t |\t 0.0823\n", + " 101011\t |\t 0.0809\n", + " ... ...\n", + " 000100\t |\t 0.0000\n", + " 010000\t |\t 0.0000\n", + " 000010\t |\t 0.0000\n", + " 000001\t |\t 0.0000\n", + "-------------------------------------\n" + ] + } + ], + "source": [ + "c_final = QAOA_ansatz_for_Ising(\n", + " final_params, nlayers, portfolio_pauli_terms, portfolio_weights\n", + ")\n", + "print_result_prob(c_final, wrap=True)" + ] + }, + { + "cell_type": "markdown", + "id": "71c7a0e0", + "metadata": {}, + "source": [ + "The highest probability corresponds to the best combination, thereby ensuring consistency with the classical approach.\n", + "\n", + "## Use XY mixer to improve the performance\n", + "\n", + "In the context of QAOA, XY mixers serve as a specific type of quantum gate to augment the optimization process. XY mixers, which are quantum gates introducing qubit interactions through controlled rotations, enable modification of the quantum system's state. The utilization of XY mixers in QAOA provides several advantages. They facilitate more efficient exploration of the solution space, thereby potentially improving the algorithm's overall performance. Moreover, XY mixers can amplify gradients of the objective function during optimization and enhance quantum circuit depth. Notably, in scenarios like portfolio optimization (covered in another tutorial), where constraints exist, XY mixers preserve the constraints associated with individual combinations while allowing for smooth transitions between them.\n", + "\n", + "It is crucial to consider that the choice of mixers relies on the specific problem under consideration, its unique characteristics, and the quantum hardware available." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "3d558b9f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGiCAYAAAAvEibfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6EUlEQVR4nO3de3xU5b3v8e/MZBKSMIFEIAkRkYsQRS4NRgy2qLBTtMVLt7ddc7bV1lpbT63ttlpOu/dGe7bY9lDbSi8CbqmCm3bX0x6toBRqpWigmpSKlagYQAi5EDLJhNzm9pw/kgxEQ8gks2Zlks/79XpemVnrWbN+s1qZ7+tZz1rLIckIAAAgQTjtLgAAACAahBcAAJBQCC8AACChEF4AAEBCIbwAAICEQngBAAAJhfACAAASCuEFAAAkFMILAABIKIQXAACQUOISXr7yla/owIEDamtr065du1RYWNhn/xtuuEH79u1TW1ub3nzzTV111VXxKBMAACQIY2W76aabTHt7u7ntttvM+eefbx5//HHT0NBgxo8f32v/oqIiEwgEzH333Wfy8/PNQw89ZDo6OsysWbMsrZNGo9FoNFrCNGt3sGvXLvPYY49F3jscDnPkyBHzwAMP9Np/06ZN5vnnn++xrLS01Pz85z+3+0DRaDQajUYbAi1JFnK73Zo/f75WrlwZWWaM0bZt21RUVNTrNkVFRfrhD3/YY9lLL72k6667rtf+ycnJSklJ6bEsKytLDQ0NgyseAADElcfj0dGjR8/Yz9LwMm7cOCUlJam2trbH8traWuXn5/e6TU5OTq/9c3Jyeu2/fPlyrVixIib1AgAAe+Xl5Z0xwFgaXuJh5cqVPUZqPB6PqqqqlJeXp+bmZhsrAwAA/dX9+92f325Lw0t9fb2CwaCys7N7LM/OzlZNTU2v29TU1ETV3+/3y+/3f2R5c3Mz4QUAgGHI0kulA4GAysrKtGTJksgyh8OhJUuWqLS0tNdtSktLe/SXpOLi4tP2BwAAI4+lM4Jvuukm09bWZm699VaTn59vfvGLX5iGhgYzYcIEI8n88pe/NA8//HCkf1FRkfH7/eYb3/iGmTlzpvn3f//3qC6V9ng8xhhjPB6P7bOhaTQajUaj9a9F+fttfUF33323OXjwoGlvbze7du0yF198cWTdyy+/bJ588ske/W+44QZTUVFh2tvbzd69e81VV11l1Zen0Wg0Go02BFo0v9+OrhfDhsfjkc/nU0ZGBnNeAABIENH8fvNsIwAAkFAILwAAIKEQXgAAQEIhvAAAgIRCeAEAAAmF8AIAABIK4QUAACQUwgsAAEgoCf9U6XjxjDtLV9xeolAgoBd+9HO7ywEAYMRi5KWfRo1O12W3flaX3Hid3aUAADCiEV76KdjhlyS5k1NsrgQAgJGN8NJPgY4OSZJ7FOEFAAA7EV76qTu8SFJScrKNlQAAMLIRXvqpR3hJIbwAAGAXwks/hYMhhUMhSZI7hVNHAADYhfAShUD3pF1GXgAAsA3hJQrBrlNHzHkBAMA+hJcoBPxdIy9ccQQAgG0IL1EItHddLs29XgAAsA3hJQrBrpEXrjYCAMA+hJcoRG5Ux9VGAADYhvAShe7wwsgLAAD2IbxEIcil0gAA2I7wEoVAe7skKTktzeZKAAAYuQgvUWhrPiFJSh2dbnMlAACMXISXKLT6miVJqRkZNlcCAMDIRXiJQnskvHhsrgQAgJGL8BKFyMiLZ7TNlQAAMHIRXqLQPecljZEXAABsQ3iJQlvXyMsoD+EFAAC7EF6i0NrkkySNzhprbyEAAIxghJcoNNXWSZLGTBgvh8NhczUAAIxMhJcoNB07pnA4rKTkZKUz+gIAgC0IL1EIB0Nqrj8uSRqbPcHmagAAGJkIL1FqrOk8dTQ2J9vmSgAAGJkIL1GKzHth5AUAAFsQXqJ0cuSF8AIAgB0IL1FqrKmVxGkjAADsYll4yczM1IYNG9TU1CSv16t169YpPb3vpzF/8Ytf1Msvv6ympiYZYzRmzBiryhuwk6eNxttcCQAAI5Nl4WXjxo2aNWuWiouLtWzZMi1atEhr1qzpc5u0tDS9+OKLevjhh60qa9Aip42yGXkBAMAuJtYtPz/fGGPM/PnzI8uWLl1qQqGQyc3NPeP2l112mTHGmDFjxkS9b4/HY4wxxuPxxPx7STJjc7LNqr2l5nvlO4zD4bBkHzQajUajjbQWze+3JSMvRUVF8nq9Kisriyzbtm2bwuGwFixYENN9JScny+Px9GhW8tXXKxwKKcnt1uisTEv3BQAAPsqS8JKTk6O6uroey0KhkBoaGpSTkxPTfS1fvlw+ny/SqqqqYvr5HxYOhtR8vEES814AALBDVOFl5cqVMsb02WbOnGlVraetKSMjI9Ly8vIs3+eJBq8kKT2TkRcAAOItKZrOq1at0vr16/vsU1lZqZqaGk2Y0PM+KC6XS1lZWaqpqYm6yL74/X75/f6YfuaZtHgbJUnpmWPiul8AABBleKmvr1d9ff0Z+5WWliozM1MFBQUqLy+XJC1evFhOp1O7d+8eWKVDSCS8jB1rax0AAIxElsx5qaio0JYtW7R27VoVFhZq4cKFWr16tTZt2qTq6mpJ0sSJE7Vv3z4VFhZGtsvOztbcuXM1ffp0SdLs2bM1d+5cZQ6x0zMtjU2SpNGZY+0tBACAEciy+7yUlJSooqJC27dv1+bNm7Vz507deeedkfVut1v5+flKS0uLLLvrrru0Z88erVu3TpL05z//WXv27NE111xjVZkDciJy2misrXUAADASRXXaKBper1clJSWnXX/o0CE5HI4eyx588EE9+OCDVpUUMy2EFwAAbMOzjQbgBBN2AQCwDeFlAJiwCwCAfQgvA8CEXQAA7EN4GYCWrpvUpY3JkMPJIQQAIJ745R2AlqbOkReny6W0DGufpQQAAHoivAxAOBhSR2urJGnU6NE2VwMAwMhCeBmg9uYWSdKo0ek2VwIAwMhCeBmg9pbO8JJCeAEAIK4ILwPUfqIzvKQSXgAAiCvCywB1MPICAIAtCC8D1NZ8QpI0Kp3wAgBAPBFeBqijpftqI8ILAADxRHgZoO45L1wqDQBAfBFeBqj9RNdpI0ZeAACIK8LLAHWPvKSkp9lcCQAAIwvhZYC67/OSymkjAADiivAyQB0nuFQaAAA7EF4GqK17wi6XSgMAEFeElwHqHnkZ5SG8AAAQT4SXAeqe88LICwAA8UV4GaDIfV48TNgFACCeCC8D1NHaeYfdJLdbziSXzdUAADByEF4GyN/WHnmdPGqUjZUAADCyEF4GKBQIKBwKSZKSU1NtrgYAgJGD8DII3aMvbkZeAACIG8LLIPjbO8NLcmqKzZUAADByEF4GIRAJL5w2AgAgXggvg9B92ogJuwAAxA/hZRAi4SWV8AIAQLwQXgbB39YmiQm7AADEE+FlEALtHZI4bQQAQDwRXgYhcrVRGuEFAIB4IbwMAqeNAACIP8LLIHDaCACA+CO8DMLJq424zwsAAPFCeBmEk6eNuMMuAADxQngZhJN32OW0EQAA8UJ4GQR/95wXThsBABA3hJdB4LQRAADxZ2l4yczM1IYNG9TU1CSv16t169YpPT29z/4/+clPVFFRodbWVh06dEg//vGPlZGRYWWZAxbg2UYAAMSdpeFl48aNmjVrloqLi7Vs2TItWrRIa9asOW3/iRMnauLEibrvvvt04YUX6rbbbtOVV16pJ554wsoyB6yDq40AALCFsaLl5+cbY4yZP39+ZNnSpUtNKBQyubm5/f6cG264wbS3txuXy9Wv/h6PxxhjjMfjseR7ndqmXzzfrNpbau77vxss3xeNRqPRaMO5RfP7bdnIS1FRkbxer8rKyiLLtm3bpnA4rAULFvT7c8aMGSOfz6dQKNTr+uTkZHk8nh4tXvxcbQQAQNxZFl5ycnJUV1fXY1koFFJDQ4NycnL69RlnnXWW/vVf/7XPU03Lly+Xz+eLtKqqqkHVHY2Tl0pz2ggAgHiJOrysXLlSxpg+28yZMwddmMfj0QsvvKC3335bK1as6LOejIyMSMvLyxv0vvur+/EA7hSuNgIAIF6Sot1g1apVWr9+fZ99KisrVVNTowkTJvRY7nK5lJWVpZqamj63Hz16tF588UU1NzfrM5/5jILB4Gn7+v1++f3+ftcfS37CCwAAcRd1eKmvr1d9ff0Z+5WWliozM1MFBQUqLy+XJC1evFhOp1O7d+8+7XYej0cvvfSSOjo6dM0116ijoyPaEuOme+TF5U6SM8mlcLD3eTkAACB2LJvzUlFRoS1btmjt2rUqLCzUwoULtXr1am3atEnV1dWSOi+N3rdvnwoLCyV1BpetW7cqPT1dX/jCF5SRkaHs7GxlZ2fL6Rx699MLnBKsGH0BACA+oh55iUZJSYlWr16t7du3KxwO69lnn9U999wTWe92u5Wfn6+0tDRJUkFBgS655BJJ0vvvv9/js84991wdOnTIynKjFjw1vIxKUUdLq43VAAAwMlgaXrxer0pKSk67/tChQ3I4HJH3r7zySo/3icDf1q7k1FGMvAAAECdD71xMguk+dcQjAgAAiA/CyyB1hxcezggAQHwQXgap++GMnDYCACA+CC+DxMgLAADxRXgZpMhddpnzAgBAXBBeBiky8sJpIwAA4oLwMkjdT5bmtBEAAPFBeBkkHs4IAEB8EV4Gifu8AAAQX4SXQeoOL0mcNgIAIC4IL4MUaOO0EQAA8UR4GSTu8wIAQHwRXgaJOS8AAMQX4WWQuNoIAID4IrwMUoD7vAAAEFeEl0Fi5AUAgPgivAwSE3YBAIgvwssgEV4AAIgvwssg+du65rxw2ggAgLggvAwST5UGACC+CC+D1D1hNzmV+7wAABAPhJdBYuQFAID4IrwMUvd9XpIILwAAxAXhZZAi93nhaiMAAOKC8DJI3aeNnE6nkpKTba4GAIDhj/AySN0jLxKjLwAAxAPhZZBCwaBCwaAkJu0CABAPhJcYOHmXXS6XBgDAaoSXGGDSLgAA8UN4iQHu9QIAQPwQXmKAkRcAAOKH8BIDkUcEEF4AALAc4SUGOG0EAED8EF5ioPsRAZw2AgDAeoSXGIjMeWHkBQAAyxFeYoD7vAAAED+Elxg4GV4YeQEAwGqElxjwt3XNeeG0EQAAlrM0vGRmZmrDhg1qamqS1+vVunXrlJ6e3uc2v/jFL7R//361traqrq5Ov/vd7zRz5kwryxw0Rl4AAIgfS8PLxo0bNWvWLBUXF2vZsmVatGiR1qxZ0+c2ZWVluv3223X++edr6dKlcjgc2rp1q5zOoTtI1B1ekpnzAgBAXBgrWn5+vjHGmPnz50eWLV261IRCIZObm9vvz5k9e7YxxpipU6f2q7/H4zHGGOPxeCz5Xr21JV/8nFm1t9TctGJ53PZJo9FoNNpwatH8fls2nFFUVCSv16uysrLIsm3btikcDmvBggX9+oy0tDTdfvvtqqys1OHDh3vtk5ycLI/H06PFG48HAAAgfiwLLzk5Oaqrq+uxLBQKqaGhQTk5OX1u++Uvf1nNzc1qaWnRVVddpeLiYgUCgV77Ll++XD6fL9Kqqqpi9h36qzu8JDFhFwAAy0UdXlauXCljTJ9tsBNsN27cqI997GNatGiR3n33Xf36179WymmCwcqVK5WRkRFpeXl5g9r3QDDnBQCA+EmKdoNVq1Zp/fr1ffaprKxUTU2NJkyY0GO5y+VSVlaWampq+ty+exRl//792rVrl7xerz7zmc9o06ZNH+nr9/vl9/uj/RoxxdVGAADET9Thpb6+XvX19WfsV1paqszMTBUUFKi8vFyStHjxYjmdTu3evbvf+3M4HHI4HKcdeRkKuM8LAADxY9mcl4qKCm3ZskVr165VYWGhFi5cqNWrV2vTpk2qrq6WJE2cOFH79u1TYWGhJGnKlCn61re+pYKCAk2aNElFRUX67//+b7W1tWnz5s1WlTpoQUZeAACIG0tvnlJSUqKKigpt375dmzdv1s6dO3XnnXdG1rvdbuXn5ystLU2S1N7erk984hPavHmz9u/fr1/96ldqbm7WwoULdezYMStLHRSuNgIAIH6iPm0UDa/Xq5KSktOuP3TokBwOR+R9dXW1Pv3pT1tZkiUic144bQQAgOWG7m1rE4i/vWvOCyMvAABYjvASA5HTRoy8AABgOcJLDJx62sgxhJ/BBADAcMAvbQx0j7xIkjsl2cZKAAAY/ggvMdA98iJx6ggAAKsRXmLAhMMKdt3l180jAgAAsBThJUa41wsAAPFBeIkR7vUCAEB8EF5ihHu9AAAQH4SXGOk+bZTMnBcAACxFeImR7tNGSZw2AgDAUoSXGAnwZGkAAOKC8BIjgTYm7AIAEA+ElxjpHnlhzgsAANYivMQIp40AAIgPwkuMBNq6LpXmtBEAAJYivMQIIy8AAMQH4SVGeDwAAADxQXiJER4PAABAfBBeYqSjtU2SlJKWZnMlAAAMb4SXGGlvaZEkpaQTXgAAsBLhJUY6TnSGl1Hp6TZXAgDA8EZ4iZH2rvCSMpqRFwAArER4iZHu00aMvAAAYC3CS4x0j7yMGk14AQDASoSXGOmITNglvAAAYCXCS4xE5rykpcrpctlcDQAAwxfhJUY6Wlojr7lcGgAA6xBeYiQUDEYeEcCkXQAArEN4iaHIjeqYtAsAgGUILzHUzo3qAACwHOElhiL3euFGdQAAWIbwEkM8IgAAAOsRXmKIOS8AAFiP8BJDzHkBAMB6hJcY6r7XyyjPaJsrAQBg+CK8xFBLY5MkKX3sGJsrAQBg+CK8xFCL1ytJSs8ca28hAAAMY5aGl8zMTG3YsEFNTU3yer1at26d0qOYD7J582YZY3TttddaWGXstHg7R15GE14AALCMpeFl48aNmjVrloqLi7Vs2TItWrRIa9as6de29957r4wxVpYXcye8jZIYeQEAwGrGipafn2+MMWb+/PmRZUuXLjWhUMjk5ub2ue3cuXPN4cOHTXZ2tjHGmGuvvbbf+/V4PMYYYzwejyXfq6+WO2O6WbW31Kz40wtx3zeNRqPRaIncovn9tmzkpaioSF6vV2VlZZFl27ZtUzgc1oIFC067XWpqqp555hndfffdqq2tPeN+kpOT5fF4ejS7dE/YTRuTIYfDYVsdAAAMZ5aFl5ycHNXV1fVYFgqF1NDQoJycnNNu9+ijj+q1117Tc88916/9LF++XD6fL9KqqqoGVfdgtHSdNnIlJWmUjSEKAIDhLOrwsnLlShlj+mwzZ84cUDFXX321Fi9erHvvvTeqejIyMiItLy9vQPuOhVAgELlR3eissbbVAQDAcJYU7QarVq3S+vXr++xTWVmpmpoaTZgwocdyl8ulrKws1dTU9Lrd4sWLNW3aNDU2NvZY/uyzz+rPf/6zrrjiio9s4/f75ff7o/oOVjrh9WrU6HSljx2rY/rA7nIAABh2og4v9fX1qq+vP2O/0tJSZWZmqqCgQOXl5ZI6w4nT6dTu3bt73eaRRx7RunXreix766239PWvf13PP/98tKXaoqWhUeMmnc3ICwAAFok6vPRXRUWFtmzZorVr1+quu+6S2+3W6tWrtWnTJlVXV0uSJk6cqO3bt+vWW2/V66+/rtra2l4n6X7wwQc6ePCgVaXGVOQuu1wuDQCAJSy9z0tJSYkqKiq0fft2bd68WTt37tSdd94ZWe92u5Wfn6+0tDQry4gr37HOUamM8eNsrgQAgOHJspEXSfJ6vSopKTnt+kOHDp3xkuJEu+SY8AIAgLV4tlGMNXWFlzGEFwAALEF4iTFfXdfIywTCCwAAViC8xJjv2DFJnDYCAMAqhJcYa+oaefGclSWny2VzNQAADD+Elxg70eBVKBiU0+XS6KxMu8sBAGDYIbzEmAmH1Xy8QRKnjgAAsALhxQLdk3bHZI+3uRIAAIYfwosFmLQLAIB1CC8W6J60O2YCIy8AAMQa4cUCTXWMvAAAYBXCiwUijwjgRnUAAMQc4cUCkQm7jLwAABBzhBcLNPFwRgAALEN4sYCva87L6KxMudxum6sBAGB4IbxYoLXJp0BHhyQpY/xZNlcDAMDwQnixiO/YcUmcOgIAINYILxZp8TZKktLHjrW1DgAAhhvCi0VaGhslSemZY+wtBACAYYbwYpEWb5MkRl4AAIg1wotFGHkBAMAahBeLMPICAIA1CC8WYeQFAABrEF4swtVGAABYg/BikZbG7tNGjLwAABBLhBeLRMJL5lh7CwEAYJghvFike85LaoZHDieHGQCAWOFX1SKtTT5JktPpVNqYDJurAQBg+CC8WCQcDKnN1yxJhBcAAGKI8GKhVl/n6AvhBQCA2CG8WKi1a+QlNcNjcyUAAAwfhBcLcdoIAIDYI7xYqHvSbhojLwAAxAzhxUJtkdNGjLwAABArhBcLnRx5IbwAABArhBcLtXVdbcSEXQAAYofwYqHIyAsTdgEAiBnCi4W6L5Vmwi4AALFDeLFQ98hLKiMvAADEjKXhJTMzUxs2bFBTU5O8Xq/WrVun9PT0Prd5+eWXZYzp0X7+859bWaZl2hh5AQAg5pKs/PCNGzcqNzdXxcXFcrvdevLJJ7VmzRqVlJT0ud2aNWv0b//2b5H3ra2tVpZpmcjIC+EFAICYsSy85Ofn66qrrtJFF12ksrIySdJXv/pVbd68Wffdd5+qq6tPu21ra6tqa2utKi1uukde3Ckpco9KUaC9w+aKAABIfJadNioqKpLX640EF0natm2bwuGwFixY0Oe2JSUlOnbsmPbu3auHH35YqampVpVpqY7WVoUCQUncqA4AgFixbOQlJydHdXV1PZaFQiE1NDQoJyfntNs988wzOnTokI4ePao5c+boe9/7nmbOnKnrr7++1/7JyclKSUmJvPd4htYpmlafT56zspQ2JkO+umN2lwMAQMKLOrysXLlS3/rWt/rsk5+fP+CC1q5dG3n91ltvqbq6Wn/84x81depUVVZWfqT/8uXLtWLFigHvz2ptvubO8MK8FwAAYiLq8LJq1SqtX7++zz6VlZWqqanRhAkTeix3uVzKyspSTU1Nv/e3e/duSdL06dN7DS8rV67UD3/4w8h7j8ejqqqqfn++1Vp93KgOAIBYijq81NfXq76+/oz9SktLlZmZqYKCApWXl0uSFi9eLKfTGQkk/TFv3jxJOu0EX7/fL7/f3+/Pi7eTD2dk5AUAgFiwbMJuRUWFtmzZorVr16qwsFALFy7U6tWrtWnTpkgQmThxovbt26fCwkJJ0tSpU/Wd73xHBQUFmjx5sq6++mo99dRTeuWVV7R3716rSrUUD2cEACC2LL1JXUlJiSoqKrR9+3Zt3rxZO3fu1J133hlZ73a7lZ+fr7S0NEmdoyj/8A//oK1bt6qiokKrVq3Ss88+q6uvvtrKMi0VGXkZw8gLAACxYOlN6rxeb583pDt06JAcDkfk/ZEjR3T55ZdbWVLcMfICAEBs8Wwji/FwRgAAYovwYrGTjwhg5AUAgFggvFgs8nBGLpUGACAmCC8W4+GMAADEFuHFYq1NTZKk9LFjbK4EAIDhgfBisebjXkmdp41cbrfN1QAAkPgILxZr8/kU6OiQJGWMO8vmagAASHyElzhorm+QJHnGE14AABgswksc+LqeBTVm/DibKwEAIPERXuLAd+y4JCmD8AIAwKARXuKgub4zvHDaCACAwSO8xIHvWOdpo4xxjLwAADBYhJc4OHnaiJEXAAAGi/ASB75jxyRJYyaMt7kSAAASH+ElDuoPV0mSxp0zSQ6Hw+ZqAABIbISXODh+uEqBjg4lp45SZl6u3eUAAJDQCC9xYMJh1R04JEnKmTbV5moAAEhshJc4qX3/gCQpZ/oUmysBACCxEV7ipGZ/Z3jJnkZ4AQBgMAgvcVL93vuSpLz8GTZXAgBAYiO8xMmRtyskSdlTz1Vy6iibqwEAIHERXuLEd6xeTbXH5HS5lHf+TLvLAQAgYRFe4ujw39+WJE268HybKwEAIHERXuLog7f2SZLOmUV4AQBgoAgvcXS4K7ycTXgBAGDACC9xdPjvnZN2x0+epNQMj83VAACQmAgvcdTm86nhaLUkKWc6d9oFAGAgCC9xVvNepSQp97xpNlcCAEBiIrzEWffN6ggvAAAMDOElzmr2E14AABgMwkucdY+8MOcFAICBIbzEWV3lIYUCQaVmeDQ2e4Ld5QAAkHAIL3EWCgZVd/CQJClnBqeOAACIFuHFBjVM2gUAYMAILzao5nJpAAAGjPBiA644AgBg4AgvNuh+TEDO9Kk8JgAAgCgRXmzgO1avmvcPyOly6fxPFNldDgAACYXwYpO/vbRdkrTki7cpJT3N5moAAEgcloWXzMxMbdiwQU1NTfJ6vVq3bp3S09PPuN0ll1yi7du368SJE2pqatIrr7yiUaNGWVWmbV7d9Kya6o4pZ9oUlTzyoBwOh90lAQCQECwLLxs3btSsWbNUXFysZcuWadGiRVqzZk2f21xyySV68cUXtXXrVl188cUqLCzU6tWrFQ6HrSrTNi3eRj15zwMKtHdo1uUf14WLF9ldEgAACcPEuuXn5xtjjJk/f35k2dKlS00oFDK5ubmn3a60tNQ89NBDg9q3x+Mxxhjj8Xhi/r2saFd+9U6zam+p+ZdnnzYOh8P2emg0Go1Gs6NF8/ttychLUVGRvF6vysrKIsu2bdumcDisBQsW9LrN+PHjdckll6iurk6vvvqqampq9Kc//UmXXnppn/tKTk6Wx+Pp0RLJK7/cpPYTLZo4Y7pmFF1sdzkAAAx5loSXnJwc1dXV9VgWCoXU0NCgnJycXreZOrXzQYUrVqzQ2rVrdeWVV6q8vFzbt2/X9OnTT7uv5cuXy+fzRVpVVVXsvkgctPl82v3b5yVJi/75n2yuBgCAoS+q8LJy5UoZY/psM2fOHFghzs5SHn/8ca1fv1579uzRN77xDb3zzjv6/Oc/32dNGRkZkZaXlzeg/dtp5zP/rXA4rPyPX6LsqefaXQ4AAENaUjSdV61apfXr1/fZp7KyUjU1NZowoecTk10ul7KyslRTU9PrdtXV1ZKkt99+u8fyffv26Zxzzjnt/vx+v/x+fz+qH7oajhzVW9tf0ZziK7T4jlv1X//rIbtLAgBgyIoqvNTX16u+vv6M/UpLS5WZmamCggKVl5dLkhYvXiyn06ndu3f3us3BgwdVVVX1kZGbGTNmaMuWLdGUmZC2rV2vOcVXqOBTn9S2Net17OAHdpcEAMCQZcms4c2bN5uysjJTWFhoFi5caN555x2zcePGyPqJEyeaffv2mcLCwsiyr33ta6axsdFcf/31Ztq0aeahhx4yra2tZurUqZbMVh5q7faffM+s2ltqPvsf/2Z7LTQajUajxbNF+fttTRGZmZlm48aNxufzmcbGRvPEE0+Y9PT0yPrJkycbY4y57LLLemz3wAMPmA8++MCcOHHCvPrqq+bSSy+18ssPqXb2Bflm1d5S873yHSZj/Djb66HRaDQaLV4tmt9vR9eLYcPj8cjn8ykjI0PNzc12lxO1u9f/XFPnz9MfHn9SL67u+6Z+AAAMF9H8fvNsoyFmx4ZfSZKKbrxOKWk88wgAgA8jvAwxf3/5zzp26LBGZ2Vq2TfutrscAACGHMLLEBMOhfTs//6BJGnhzf+oq+/7Kg9tBADgFISXIei9Xa/ruR/8RJJ0+edu0ecf+4FSMxLrsQcAAFiF8DJEvfLUf2nDA/+uQHuHLrjsUt37X/+p3BnT7C4LAADbEV6GsL9u3qrH/vlOHT9yVOPOOVv3bFingmVL7S4LAABbEV6GuKqKd/Wjf7pdFTt3KTl1lEpWrtA/fvs+udxuu0sDAMAWhJcE0Nrk07q7/0Vbf/6EJOnSf7peX3tmnSbOPM/mygAAiD/CS4Iw4bBe+tk6rf3y19XibVRe/gzd+1//qaV3f1GupKgeUQUAQEIjvCSYip279P3P3KK/bf2jXO4kffKuz+vrv16vsy/It7s0AADigscDJLA5xVfoH799nzxnZSkUDOpP65/R1p8/oaDfb3dpAABEhccDjBBv/uFl/eC6W/TXzVvlSkrSkjtu1dd/vV7nzJlld2kAAFiGkZdh4sLFi3T9v96vjHFnKRwKacfTv9KW1WsU7OiwuzQAAM6IkZcR6K0/7tD3r71Fbzy3RU6XS5ffdou++X83aEbRxXaXBgBATDHyMgydv+hS3fBv92ts9gRJUvnmrXru+z9W8/EGmysDAKB3jLyMcPt2vKrvX/NZ7Xj6VwqHQir41Cd1/3P/pUtuvI6HPAIAEh4jL8Pc2RfM1A3//i1N6rqU+uCevfrvh76nmvfet7kyAABOiub3m/AyAjhdLl36T9fryq/eqVHp6QoFg3p107Pa9viTamlssrs8AAAIL4SX3o3JHq/rHvi65hRfIUlq8zVr+7pf6s/P/IarkgAAtiK8EF76dN4lhbr6G/9TeefPkCT56o9rx9ObVPrr36r9RIvN1QEARiLCC+HljBwOhwqWXakr/+cXlTUxV5LUfqJFZb9/UX/57fM68vY7NlcIABhJCC+El35zJrn0sas+qcWf/x/KmT41svzou/u1d9uf9NYfd+joO+/ZWCEAYCQgvBBeouZwODT94vm6+B+v1uwll8mdkhJZ562u0f6/lKvyjb/q/bI9On74iI2VAgCGI8IL4WVQUjM8uuCyj+vCxYuUf+klSk4d1WP9iQavjr67X0cr3tPRd95TzfuVOn64ivkyAIABI7wQXmLGPSpFUz42V9Mu+pimXfQxTZp9gZLc7l77tngbVf/BER0/UqWGozXyHas/2erq5as/rlAgEOdvAABIBIQXwotlklJSlDNtivLyz9PEmecpd+Z0TTh3sjxnZfVr+xZvo5qPN6jN16zWJp9afc1q8zWrzedTq6/rfVOz2lta5G9rk7+tXR2tbZ2vW9sUDoUs/oYAADsQXggvcZeSlqazJuXprEl5GnfO2RqbPUGecWdpzITxXX/HKSk5edD7Cfr96mhtU6C9XUF/QMFAQKGuv8GAX6FAUEF/L3+DnX/DwZCMCSscCssYIxMOKxwOy4TDMmGjcDgkE/7QcmMUDoUi/U0ofMpndG/X/Rnd2535M8Kmu1/o9Ps+dfmH9xl53b1fE3ndvU8ASBTR/H4nxakmDHMdra06+s57fV6ZlJqRoTETxml0VqZSMzxKy/AobUyGUjMyuv56In9TUlOVkpam5NRRSk5LlSup8/+qScnJXSFoTJy+WWILhz4afHoGoFMC1YeDVyjUGfoCAYUDQQWDAYUCQYUCgc4WDCkU6AqQXcuDgYDCwaCCp/QL+gOdo2etrepoa+/82zWa1nHK63CQUTUA/UN4Qdy0+Xxq8/kGtK3L7VZyaqpS0lI7A01qqpLcbrncSUpKTpbL7VZSsrvn367mSu56neyWw+mS0+WUw+GUw+mQ0+WSw+GQw+WU0+GUw9ndHHI6T7539ljuksPpkMPhPPlZrq513a9PXXfqfnp8Vncfx8n9Orr6fvjzT9mv0+Xq93FzulxS/7vbqntUraO1Vf7WNrX5mnXC26gWb6NaGpvU4m3UCW+jmmrr5D1ao8aaWoWCQbvLBmADwgsSQigQUFsgMODwM9xEAo/DIYfLJWdX2OkRnPoIQH0Fsu4g50xyyZWUJJc7SS63u+u1W0nd7yPLkiJh0ZXkOrnOnSRXUpLcKSkng2daauR1SlqaUtLS5HL3HFVLH9u/UbVwOCzfsXp5j9bo+OEqVb+7X0ff3a/qd/er+XiDlYcfgM0IL0ACMsbIdE9eTvDRB1dSkpLT0roCTaqS09I0Kj1NqRkepY8dq/SssUofO0ajM8dqdFamxuZkKzM3R+5RKRqbPUFjsydoysfm9PhM37F6Hfjrm6os26MD5X/T0Xf3y4TDNn1DALHGhF0ACWn0WZnKzM1VVl6uxp97jibOmK7c86Zp3ORJcjqdPfq2NZ/Qwb/t1YGyv6myfI8Ov7VPQb/fpsoB9IarjQgvwIjlHpWisy/I19SCeZoyf66mzJujUaPTe/QJ+v06/NY+Hfjr33T47xWq2veuGqqOcoUWYCPCC+EFQBeH06mJM6ZrSsEcTSmYp6kFc5UxftxH+rU1n9DRd99T1b53dfSdzr+17x9gUjAQJ4QXwguAPpw16WxNnT9X586drbzzZyj3vGm93ocoGAio5r1K1eyvVG3lAdXsP6Da9w+o4Wg1c2iAGCO8EF4ARMGZ5NKEKecqL3+G8s6f0fl35nlKzfD02t/f1q66A4dOBpquvw1Hqjj1BAwQ4YXwAiAGsvJyNXHmDGVPO1c506Yoe9oUTZgyucdT10/V0drWGWTeq1T1/vdV8977qn6vUs31x+NcOZB4CC+EFwAWcTidysqbqJzpU5Q9dUpXsJmq7Knnyj2q91DT4m1U9f5KHd77tg7seVMH9+xVi7cxvoUDQ9yQCS+ZmZl67LHHdPXVVyscDuvZZ5/V1772NbW0tPTaf/LkyTp48GCv62688Ub95je/OeM+CS8A7OBwOnXWpDzlnjdNudOnKue8aZ2Xbp9zdq93RT528AO9t/sNvb3jNe3/yxsKtHfYUDUwdAyZ8LJ582bl5ubqS1/6ktxut5588km9/vrrKikp6bW/0+nU+PHjeyy788479c1vflO5ubmnDT2nIrwAGEqSUlKUPWWyJuafp8lzL9SUeXOUM31qjz6Bjg6989pulb+wVW+/spMggxFpSISX/Px87du3TxdddJHKysokSUuXLtXmzZt19tlnq7q6ul+fU15ervLyct1xxx396k94ATDUpWZ4NOVjc5X/8Ut0/qKFypqYG1nX3tKivdte0RvPbdb7r5czARgjxpAIL7fffrtWrVqlrKysyDKXy6X29nbdeOON+t3vfnfGzygoKFBZWZkWLlyo0tLSXvskJycr5ZTJcx6PR1VVVYQXAAkjd8Y0zbuyWAWf+qSy8k4GmYaj1Sp7/kW9/v826/jhIzZWCFgvmvBi2bONcnJyVFdX12NZKBRSQ0ODcnJy+vUZX/jCF/T222+fNrhI0vLly7VixYrBlAoAtqp+931Vv/u+tvzkFzp33hzNv/pKfezKf1DWxFwVf+l2FX/pdlWW7dHr/2+z/rZ1uzpaWu0uGbCV88xdelq5cmXnQ+H6aDNnzhx0YaNGjdItt9yiJ5544oz1ZGRkRFpeXt6g9w0Adjm45009+93va8UVy/T0fd/Rvp2lCodCmjp/nm5+6H9pxcsv6J//z//Wwpv/UTnnTZPD4bC7ZCDuoh55WbVqldavX99nn8rKStXU1GjChAk9lrtcLmVlZammpuaM+7nhhhuUlpamp556qs9+fr9ffh6wBmCYCfr92vPSdu15absyxo/T/GVLddG1n1bOtCmat3SJ5i1dIumj95apO3BIDUeOqqGqmodPYtiyfMLu/PnzVV5eLkkqLi7Wiy++2K8Juy+//LLq6+t14403RrVfJuwCGM4mzTpf+Z8o0tSCuZo8d7ZS0lJ77RcOh+WrO6bjXUHmRINXJxq8avF61dzgVUtDo9pOnJC/tU0dra3yt7XzyAPYakhM2JU6L5XOzs7WXXfdFblU+o033ohcKj1x4kRt375dt956q15//fXIdtOmTdO7776rT33qU3rppZei2ifhBcBI4XS5dNakPOVMnxq5t8y4c87WWZPyNCo9/cwf8CH+tvauINOmQHuHQoGggoGAQoFA5G/n66CCfr9CgeDJdf6AgsFAZFkoEFQoGDz5NxhUONj5eeHgR9eFAoGTy3pbHgwpFAgQsIaxITFhV5JKSkq0evVqbd++PXKTunvuuSey3u12Kz8/X2lpaT22+/znP68jR45o69atVpYHAAktHArp2MEPdOzgB9q77U891qWPHaOzJuXprLPzlDkxR+mZYzU6M1OjszKVnjVWnqxMpaSlKTktVa6kzp+C5NRRSk4dZcM36b9wOHz68POhwNQzLIV6BqfThKdwIKhgIBjpd+r2J4PUh/cTUjgckgkbmXBI4VBY4XBYJhTq/Bvufh9WuGu9OWV5OBTqfB06pS8hrU88HgAARrik5GSlpKUqOS1VKWlpSklPU5LbraTkZLncbrncSV3v3V3vT1nm/tCy5GS5kpLkcid1/k1K6lwXed3519m1vSspSc4kl5Lcbjk/1MfldsvpjPq6kmEj3B1+QuFTQlAo8j4cCskYc9rw03P7znB16vYnw5XpEap6+9zu7bqXN9c3aPu6X8b0+w6ZkRcAwNAX9PsV9PvV0thkdykf4XA6PxJ8IoHInSRnUpKSuv66kpJ6D0GnBii3S66kU7d1y5Xkirzuc9vThS+XSw6nUw6nQ06XS06nUw6ns2u5Q06nq+u9s+u1o9dHRnyY0+Xq7OeOw4GOUt2BQzEPL9EgvAAAhiwTDkfC1XDjcDo7g47LJafTEQk8ncuccjhOCTyuzr5Ol0sOh6Nrm871DufJkNT5/mS/7vXOru177rNre4ez6/P7t73D5VRro8/WY0d4AQDABiYcVigcloJBu0tJOCP3ZCIAAEhIhBcAAJBQCC8AACChEF4AAEBCIbwAAICEQngBAAAJhfACAAASCuEFAAAkFMILAABIKIQXAACQUAgvAAAgoRBeAABAQiG8AACAhDJsnyrt8XjsLgEAAPRTNL/bwy68dH/5qqoqmysBAADR8ng8am5u7rOPQ5KJTznxM3HixDN+8YHweDyqqqpSXl6eJZ+PThzn+OA4xw/HOj44zvFh5XH2eDw6evToGfsNu5EXSf364oPR3NzMfxhxwHGOD45z/HCs44PjHB9WHOf+fh4TdgEAQEIhvAAAgIRCeIlCR0eHVqxYoY6ODrtLGdY4zvHBcY4fjnV8cJzjYygc52E5YRcAAAxfjLwAAICEQngBAAAJhfACAAASCuEFAAAkFMJLP33lK1/RgQMH1NbWpl27dqmwsNDukhLKt771Lf3lL3+Rz+dTbW2tfvvb32rGjBk9+qSkpGj16tWqr69Xc3OzfvOb32jChAk9+kyaNEm///3v1dLSotraWn3/+9+Xy+WK51dJKA888ICMMXr00UcjyzjOsTNx4kQ9/fTTqq+vV2trq958803Nnz+/R58HH3xQR48eVWtrq/7whz9o+vTpPdZnZmZqw4YNampqktfr1bp165Senh7PrzGkOZ1OPfTQQ6qsrFRra6v279+v73znOx/px3GOzic+8Qk999xzqqqqkjFG11577Uf6xOKYzp49Wzt27FBbW5s++OADffOb34zZdzC0vttNN91k2tvbzW233WbOP/988/jjj5uGhgYzfvx422tLlLZlyxbzuc99zlxwwQVmzpw55ve//705ePCgSUtLi/T52c9+Zg4dOmSuuOIKU1BQYF577TWzc+fOyHqn02nefPNNs3XrVjN37lxz5ZVXmrq6OvMf//Eftn+/odguuugiU1lZafbs2WMeffRRjnOM29ixY82BAwfMf/7nf5rCwkJz7rnnmuLiYjN16tRIn/vvv994vV5zzTXXmNmzZ5vf/e535v333zcpKSmRPps3bzZ//etfzcUXX2wuvfRS8+6775qNGzfa/v2GSlu+fLk5duyY+dSnPmUmT55srr/+euPz+cxXv/pVjvMg2pVXXmm++93vmuuuu84YY8y1117bY30sjqnH4zHV1dXm6aefNhdccIG5+eabTUtLi/niF78Yi+9g/0Ec6m3Xrl3msccei7x3OBzmyJEj5oEHHrC9tkRt48aNM8YY84lPfMJIMhkZGaajo8Ncf/31kT4zZ840xhizYMECI3X+xxYMBs2ECRMifb70pS+ZxsZG43a7bf9OQ6mlp6ebd955xyxZssS8/PLLkfDCcY5dW7lypdmxY0effY4ePWr+5V/+JfI+IyPDtLW1mZtvvtlIMvn5+cYYY+bPnx/ps3TpUhMKhUxubq7t33EotOeff96sW7eux7Lf/OY35umnn+Y4x6j1Fl5icUzvuusuc/z48R7/bqxcudLs27dv0DVz2ugM3G635s+fr23btkWWGWO0bds2FRUV2VhZYhszZowkqaGhQZI0f/58JScn9zjO77zzjg4dOhQ5zkVFRdq7d6/q6uoifV566SWNGTNGs2bNimP1Q99Pf/pTvfDCC9q+fXuP5Rzn2Lnmmmv0xhtv6Ne//rVqa2tVXl6uO+64I7J+ypQpys3N7XGsfT6fdu/e3eNYe71elZWVRfps27ZN4XBYCxYsiN+XGcJee+01LVmyROedd54kac6cOfr4xz+uLVu2SOI4WyFWx7SoqEg7duxQIBCI9HnppZeUn5+vsWPHDqrGYflgxlgaN26ckpKSVFtb22N5bW2t8vPzbaoqsTkcDv3oRz/Szp079fe//12SlJOTo46ODjU1NfXoW1tbq5ycnEif3v536F6HTjfffLMKCgp6nZfFcY6dqVOn6stf/rJ++MMf6uGHH1ZhYaF+8pOfyO/366mnnoocq96O5anH+tSQKEmhUEgNDQ0c6y6PPPKIMjIyVFFRoVAoJJfLpW9/+9t65plnJInjbIFYHdOcnBwdOHDgI5/Rva6xsXHANRJeEHc//elPdeGFF+rjH/+43aUMO2effbZ+/OMfq7i4mFukW8zpdOqNN97Qt7/9bUnSnj17dOGFF+quu+7SU089ZXN1w8dNN92kkpIS3XLLLfr73/+uefPm6Uc/+pGOHj3KcR7BOG10BvX19QoGg8rOzu6xPDs7WzU1NTZVlbgee+wxLVu2TFdccYWqqqoiy2tqapSSkhI5ndTt1ONcU1PT6/8O3evQeVooOztb5eXlCgQCCgQCuvzyy3XPPfcoEAiotraW4xwj1dXVevvtt3ss27dvn8455xxJJ49VX/921NTUfORKL5fLpaysLI51lx/84Ad65JFH9Ktf/UpvvfWWNmzYoEcffVTLly+XxHG2QqyOqZX/lhBeziAQCKisrExLliyJLHM4HFqyZIlKS0ttrCzxPPbYY/rMZz6jxYsX6+DBgz3WlZWVye/39zjOM2bM0OTJkyPHubS0VLNnz9b48eMjfYqLi9XU1PSRH5GRavv27brwwgs1b968SHv99de1ceNGzZs3T2+88QbHOUZeffVVzZw5s8eyGTNm6NChQ5KkAwcOqLq6usex9ng8WrBgQY9jnZmZqYKCgkifxYsXy+l0avfu3XH4FkNfWlqawuFwj2WhUEhOZ+fPF8c59mJ1TEtLS7Vo0SIlJZ08yVNcXKyKiopBnTLqZvtM56HebrrpJtPW1mZuvfVWk5+fb37xi1+YhoaGHldj0PpuP/3pT43X6zWLFi0y2dnZkTZq1KhIn5/97Gfm4MGD5vLLLzcFBQXm1VdfNa+++mpkffclvC+++KKZM2eO+eQnP2lqa2u5hPcM7dSrjTjOsWsXXXSR8fv9Zvny5WbatGnms5/9rDlx4oS55ZZbIn3uv/9+09DQYK6++mpz4YUXmt/+9re9Xm5aVlZmCgsLzcKFC80777wzoi/h/XB78sknzeHDhyOXSl933XWmrq7OPPLIIxznQbT09HQzd+5cM3fuXGOMMffee6+ZO3eumTRpUsyOaUZGhqmurja//OUvzQUXXGBuuukmc+LECS6Vjme7++67zcGDB017e7vZtWuXufjii22vKZHa6Xzuc5+L9ElJSTGrV682x48fNydOnDDPPvusyc7O7vE555xzjnnhhRdMS0uLqaurMz/4wQ+My+Wy/fsN5fbh8MJxjl379Kc/bd58803T1tZm3n77bXPHHXd8pM+DDz5oqqurTVtbm/nDH/5gzjvvvB7rMzMzzcaNG43P5zONjY3miSeeMOnp6bZ/t6HSRo8ebR599FFz8OBB09raavbv32+++93vfuSyfY5zdO2yyy7r9d/kJ598MqbHdPbs2WbHjh2mra3NHD582Nx///0xqd/R9QIAACAhMOcFAAAkFMILAABIKIQXAACQUAgvAAAgoRBeAABAQiG8AACAhEJ4AQAACYXwAgAAEgrhBQAAJBTCCwAASCiEFwAAkFAILwAAIKH8f9rNGcxO0L85AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "loss_list = []\n", + "final_params = QUBO_QAOA(Q, nlayers, iterations, mixer=\"XY\", callback=record_loss)\n", + "\n", + "p = plt.plot(loss_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "d83fc94c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "-------------------------------------\n", + " selection\t |\tprobability\n", + "-------------------------------------\n", + " 111001\t |\t 0.1553\n", + " 001001\t |\t 0.1260\n", + " 101001\t |\t 0.1180\n", + " 111000\t |\t 0.0934\n", + " ... ...\n", + " 100110\t |\t 0.0000\n", + " 000111\t |\t 0.0000\n", + " 000101\t |\t 0.0000\n", + " 000100\t |\t 0.0000\n", + "-------------------------------------\n" + ] + } + ], + "source": [ + "c_final = QAOA_ansatz_for_Ising(\n", + " final_params, nlayers, portfolio_pauli_terms, portfolio_weights, mixer='XY'\n", + ")\n", + "print_result_prob(c_final, wrap=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tc_dev", + "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 44783675609fe7169d19fe303b606e9929940c7b Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Wed, 12 Jul 2023 12:50:20 +0100 Subject: [PATCH 535/725] add functions relavent of QAOA --- docs/source/tutorials/QAOA_funcs.py | 439 +++++++++++++++++++++ tensorcircuit/applications/__init__.py | 2 + tensorcircuit/applications/optimization.py | 328 +++++++++++++++ tensorcircuit/templates/__init__.py | 1 + tensorcircuit/templates/blocks.py | 96 ++++- tensorcircuit/templates/conversions.py | 202 +++++++++- 6 files changed, 1066 insertions(+), 2 deletions(-) create mode 100644 docs/source/tutorials/QAOA_funcs.py create mode 100644 tensorcircuit/applications/optimization.py diff --git a/docs/source/tutorials/QAOA_funcs.py b/docs/source/tutorials/QAOA_funcs.py new file mode 100644 index 00000000..87d35d59 --- /dev/null +++ b/docs/source/tutorials/QAOA_funcs.py @@ -0,0 +1,439 @@ +### +### functions for QAOA problems +### + +from typing import List, Tuple, Callable, Any +import tensorcircuit as tc +import numpy as np +import tensorflow as tf +import matplotlib.pyplot as plt +from IPython.display import clear_output +from functools import partial +import scipy.optimize as optimize + +Array = any +Tensor = Any + + +# moved +def QUBO_to_Ising(Q: List[list]) -> Tuple[List[list], list, float]: + """ + Cnvert the Q matrix into a the indication of pauli terms, the corresponding weights, and the offset. + The outputs are used to construct an Ising Hamiltonian for QAOA. + + :param Q: The n-by-n square and symmetric Q-matrix. + :return pauli_terms: A list of 0/1 series, where each element represents a Pauli term. + A value of 1 indicates the presence of a Pauli-Z operator, while a value of 0 indicates its absence. + :return weights: A list of weights corresponding to each Pauli term. + :return offset: A float representing the offset term of the Ising Hamiltonian. + """ + + # input is n-by-n symmetric numpy array corresponding to Q-matrix + # output is the components of Ising Hamiltonian + + n = Q.shape[0] + + # square matrix check + if Q[0].shape[0] != n: + raise ValueError("Matrix is not a square matrix.") + + offset = ( + np.triu(Q, 0).sum() / 2 + ) # Calculate the offset term of the Ising Hamiltonian + pauli_terms = [] # List to store the Pauli terms + weights = ( + -np.sum(Q, axis=1) / 2 + ) # Calculate the weights corresponding to each Pauli term + + for i in range(n): + term = np.zeros(n) + term[i] = 1 + pauli_terms.append( + term.tolist() + ) # Add a Pauli term corresponding to a single qubit + + for i in range(n - 1): + for j in range(i + 1, n): + term = np.zeros(n) + term[i] = 1 + term[j] = 1 + pauli_terms.append( + term.tolist() + ) # Add a Pauli term corresponding to a two-qubit interaction + + weight = ( + Q[i][j] / 2 + ) # Calculate the weight for the two-qubit interaction term + weights = np.concatenate( + (weights, weight), axis=None + ) # Add the weight to the weights list + + return pauli_terms, weights, offset + + +def Ising_loss(c: tc.Circuit, pauli_terms: List[list], weights: list) -> float: + """ + computes the loss function for the Ising model based on a given quantum circuit, + a list of Pauli terms, and corresponding weights. + The offset is ignored. + + :param c: A quantum circuit object generating the state. + :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :return loss: A real number representing the computed loss value. + """ + loss = 0.0 + for k in range(len(pauli_terms)): + term = pauli_terms[k] + index_of_ones = [] + + for l in range(len(term)): + if term[l] == 1: + index_of_ones.append(l) + + # Compute expectation value based on the number of qubits involved in the Pauli term + if len(index_of_ones) == 1: + delta_loss = weights[k] * c.expectation_ps(z=[index_of_ones[0]]) + # Compute expectation value for a single-qubit Pauli term + else: + delta_loss = weights[k] * c.expectation_ps( + z=[index_of_ones[0], index_of_ones[1]] + ) + # Compute expectation value for a two-qubit Pauli term + + loss += delta_loss + + return K.real(loss) + + +def QAOA_loss( + nlayers: int, pauli_terms: List[list], weights: list, params: list +) -> float: + """ + computes the loss function for the Quantum Approximate Optimization Algorithm (QAOA) applied to the Ising model. + + :param nlayers: The number of layers in the QAOA ansatz. + :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :param params: A list of parameter values used in the QAOA ansatz. + :return: The computed loss value. + """ + c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights) + # Obtain the quantum circuit using QAOA_from_Ising function + + return Ising_loss(c, pauli_terms, weights) + # Compute the Ising loss using Ising_loss function on the obtained circuit + + +def QUBO_QAOA( + Q: List[list], + ansatz: Callable[[list, int, List[list], list], tc.Circuit], + nlayers: int, + iterations: int, + vvag: bool = False, + ncircuits: int = 10, +) -> list: + """ + Performs the QAOA on a given QUBO problem. + + :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. + :param ansatz: The ansatz function to be used for the QAOA. + :param nlayers: The number of layers in the QAOA ansatz. + :param iterations: The number of iterations to run the optimization. + :param vvag (optional): A flag indicating whether to use vectorized variational adjoint gradient. Default is False. + :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. Default is 10. + :return params: The optimized parameters for the ansatz circuit. + """ + try: + K + except NameError: + print("select a backend and assign it to K.") + + pauli_terms, weights, offset = QUBO_to_Ising(Q) + learning_rate = 1e-2 + + loss_val_grad = K.value_and_grad(partial(ansatz, nlayers, pauli_terms, weights)) + params = K.implicit_randn(shape=[2 * nlayers], stddev=0.5) + # Initialize the parameters for the ansatz circuit + + if vvag == True: + loss_val_grad = tc.backend.vvag(loss_val_grad, argnums=0, vectorized_argnums=0) + params = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) + # Use vectorized variational adjoint gradient (vvag) if vvag flag is set to True + + loss_val_grad_jit = K.jit(loss_val_grad, static_argnums=(1, 2)) + + opt = K.optimizer(tf.keras.optimizers.Adam(learning_rate)) + # Define the optimizer (Adam optimizer) with the specified learning rate + + for i in range(iterations): + loss, grads = loss_val_grad_jit(params) + # Calculate the loss and gradients using the loss_val_grad_jit function + + params = opt.update(grads, params) + # Update the parameters using the optimizer and gradients + + if i % 100 == 0: # print the cost every 100 iterations + print(K.numpy(loss)) + + return params + + +# calcelled +def print_result_prob(c: tc.Circuit, wrap: bool = False, reverse: bool = False) -> None: + """ + Print the results and probabilities of a given quantum circuit. + The default order is from the highest probability to the lowest one + + :param c: The quantum circuit to print the results and probabilities. + :param wrap (optional): A flag indicating whether to wrap the output. Default is False. + :param reverse (optional): A flag indicating whether to reverse the order of the output. Default is False. + """ + try: + K + except NameError: + print("select a backend and assign it to K.") + + states = [] + n_qubits = c._nqubits + for i in range(2**n_qubits): + a = f"{bin(i)[2:]:0>{n_qubits}}" + states.append(a) + # Generate all possible binary states for the given number of qubits + + probs = K.numpy(c.probability()).round(decimals=4) + # Calculate the probabilities of each state using the circuit's probability method + + sorted_indices = np.argsort(probs)[::-1] + if reverse == True: + sorted_indices = sorted_indices[::-1] + state_sorted = np.array(states)[sorted_indices] + prob_sorted = np.array(probs)[sorted_indices] + # Sort the states and probabilities in descending order based on the probabilities + + print("\n-------------------------------------") + print(" selection\t |\tprobability") + print("-------------------------------------") + if wrap == False: + for i in range(len(states)): + print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) + # Print the sorted states and their corresponding probabilities + elif wrap == True: + for i in range(4): + print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) + print(" ... ...") + for i in range(-4, -1): + print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) + print("-------------------------------------") + + +# calcelled +def print_result_cost( + c: tc.Circuit, Q: List[list], wrap: bool = False, reverse: bool = False +) -> None: + """ + Print the results and costs of a given quantum circuit. + Specificly designed for the variational circuit. + The default order is from the highest probability to the lowest one. + + :param c: The quantum circuit to print the results and probabilities. + :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. + :param wrap (optional): A flag indicating whether to wrap the output. Default is False. + :param reverse (optional): A flag indicating whether to reverse the order of the output. Default is False. + """ + cost_dict = {} + states = [] + n_qubits = c._nqubits + for i in range(2**n_qubits): + a = f"{bin(i)[2:]:0>{n_qubits}}" + states.append(a) + # Generate all possible binary states for the given number of qubits + for selection in states: + x = np.array([int(bit) for bit in selection]) + cost_dict[selection] = np.dot(x, np.dot(Q, x)) + cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1])) + if reverse == True: + cost_sorted = dict( + sorted(cost_dict.items(), key=lambda item: item[1], reverse=True) + ) + num = 0 + print("\n-------------------------------------") + print(" selection\t |\t cost") + print("-------------------------------------") + for k, v in cost_sorted.items(): + print("%10s\t |\t%.4f" % (k, v)) + num += 1 + if (num >= 8) & (wrap == True): + break + print("-------------------------------------") + + +# cancelled +def print_Q_cost(Q: List[list], wrap: bool = False, reverse: bool = False) -> None: + n_stocks = len(Q) + states = [] + for i in range(2**n_stocks): + a = f"{bin(i)[2:]:0>{n_stocks}}" + n_ones = 0 + for j in a: + if j == "1": + n_ones += 1 + states.append(a) + + cost_dict = {} + for selection in states: + x = np.array([int(bit) for bit in selection]) + cost_dict[selection] = np.dot(x, np.dot(Q, x)) + cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1])) + if reverse == True: + cost_sorted = dict( + sorted(cost_dict.items(), key=lambda item: item[1], reverse=True) + ) + num = 0 + print("\n-------------------------------------") + print(" selection\t |\t cost") + print("-------------------------------------") + for k, v in cost_sorted.items(): + print("%10s\t |\t%.4f" % (k, v)) + num += 1 + if (num >= 8) & (wrap == True): + break + print("-------------------------------------") + + +# moved +class StockData: + """ + convert real-world stock data to the inputs of QAOA. + """ + + def __init__(self, data: Tensor) -> None: + """ + stock data object + + :param data: real-world stock data, in the form of several lists of daily price. + """ + self.data = data # add data + self.n_stocks = len(data) # num of stocks + self.n_days = len(data[1]) + + # check the number of days + n_days = [len(i) for i in data] + if max(n_days) != (sum(n_days) / len(n_days)): + raise Exception("timespan of stocks should be the same") + + # calculate the daily percentage price change + self.daily_change = [] # daily percentage price change + for i in range(self.n_stocks): + each_stcok = [] + for j in range(self.n_days - 1): + each_stcok.append((data[i][j + 1] - data[i][j]) / data[i][j]) + self.daily_change.append(each_stcok) + + def get_return(self) -> Array: + """ + :return ret: annualized return (mu) + """ + ret = np.mean(self.daily_change, axis=1) + return ret + + def get_covariance(self) -> Array: + """ + :return cov: symmetric annualized covariance matrix (sigma) + """ + return np.cov(self.daily_change) + + def get_pentalty( + self, cov: Array, ret: Array, risk_pre: float, budget: int + ) -> float: + """ + calculate the pentalty using the method in https://link.springer.com/article/10.1007/s11128-022-03766-5 + brutal force is used + + :param cov: symmetrix annualized covariance matrix (sigma) + :param ret: annualized return (ret) + :param risk_pre: risk preference of the investor + :param budge: the number of assets to be chosen for the portfolio + """ + # get all fesible and unfeasible states + self.f_state = [] # feasible states (num of '1's equal to budge) + self.uf_state = [] # unfeasible states + self.all_state = [] + for i in range(2**self.n_stocks): + state = f"{bin(i)[2:]:0>{self.n_stocks}}" + n_ones = 0 + for j in state: + if j == "1": + n_ones += 1 + self.all_state.append(state) + if n_ones == budget: + self.f_state.append(state) + else: + self.uf_state.append(state) + + # determine the penalty factor + mark = False + penalty = 0 # initial value + while mark == False: + R = np.diag(ret) + S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( + np.ones(self.n_stocks) + ) + Q = risk_pre * cov - R + penalty * S + F = [] + for state in self.f_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) + Fmin = np.amin(F) + Fbar = np.mean(F) + F = [] + for state in self.uf_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) + Fmin_uf = np.amin(F) + location = np.where(F == Fmin_uf)[0][0] + if Fmin_uf < 0.5 * (Fmin + Fbar): + n_ones = 0 + for j in self.uf_state[location]: + if j == "1": + n_ones += 1 + penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 + # mark = True + else: + mark = True # ready to return the penalty + return penalty + + +# moved +def QUBO_from_portfolio(cov: Array, mean: Array, q: float, B: int, t: float) -> Tensor: + """ + convert portfolio parameters to a Q matrix + :param cov: n-by-n covariance numpy array + :param mean: numpy array of means + :param q: the risk preference of investor + :param B: budget + :param t: penalty factor + :return Q: n-by-n symmetric Q matrix + """ + n = cov.shape[0] + R = np.diag(mean) + S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n)) + + Q = q * cov - R + t * S + return Q + + +def print_output(c): + n = c._nqubits + N = 2**n + # Calculate the total number of states based on the number of qubits + + x_label = r"$\left|{0:0" + str(n) + r"b}\right>$" + labels = [x_label.format(i) for i in range(N)] + # Generate labels for the x-axis representing the binary states + + plt.bar(range(N), c.probability()) + # Create a bar plot with the probabilities of each state + + plt.xticks(range(N), labels, rotation=70) + # Set the x-axis ticks to the generated labels and rotate them for better visibility diff --git a/tensorcircuit/applications/__init__.py b/tensorcircuit/applications/__init__.py index 70d128b0..200fcbe6 100644 --- a/tensorcircuit/applications/__init__.py +++ b/tensorcircuit/applications/__init__.py @@ -3,3 +3,5 @@ the code inside is subject to change, be caution to use. Most of the useful code is and will be refactored and copied to other parts of tensorcircuit. """ + +from . import optimization \ No newline at end of file diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py new file mode 100644 index 00000000..fd05b693 --- /dev/null +++ b/tensorcircuit/applications/optimization.py @@ -0,0 +1,328 @@ +""" +modules for QUBO problems in QAOA +""" + +from typing import List, Callable, Any + +import tensorcircuit as tc +import numpy as np +from functools import partial +import tensorflow as tf +import scipy.optimize as optimize + +from ..cons import backend +from ..templates.blocks import QAOA_ansatz_for_Ising +from ..templates.conversions import QUBO_to_Ising +from tensorflow.python.ops.numpy_ops import np_config + +np_config.enable_numpy_behavior() + +Circuit = Any +Tensor = Any + + +def Ising_loss(c: Circuit, pauli_terms: List[list], weights: list) -> float: + """ + computes the loss function for the Ising model based on a given quantum circuit, + a list of Pauli terms, and corresponding weights. + The offset is ignored. + + :param c: A quantum circuit object generating the state. + :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :return loss: A real number representing the computed loss value. + """ + loss = 0.0 + for k in range(len(pauli_terms)): + term = pauli_terms[k] + index_of_ones = [] + + for l in range(len(term)): + if term[l] == 1: + index_of_ones.append(l) + + # Compute expectation value based on the number of qubits involved in the Pauli term + if len(index_of_ones) == 1: + delta_loss = weights[k] * c.expectation_ps(z=[index_of_ones[0]]) + # Compute expectation value for a single-qubit Pauli term + else: + delta_loss = weights[k] * c.expectation_ps( + z=[index_of_ones[0], index_of_ones[1]] + ) + # Compute expectation value for a two-qubit Pauli term + + loss += delta_loss + + return backend.real(loss) + + +def QAOA_loss( + nlayers: int, pauli_terms: List[list], weights: list, params: list, mixer: str = "X" +) -> float: + """ + computes the loss function for the Quantum Approximate Optimization Algorithm (QAOA) applied to the Ising model. + + :param nlayers: The number of layers in the QAOA ansatz. + :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :param params: A list of parameter values used in the QAOA ansatz. + :return: The computed loss value. + """ + c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights, mixer=mixer) + # Obtain the quantum circuit using QAOA_from_Ising function + + return Ising_loss(c, pauli_terms, weights) + # Compute the Ising loss using Ising_loss function on the obtained circuit + + +def QUBO_QAOA( + Q: List[list], + nlayers: int, + iterations: int, + vvag: bool = False, + ncircuits: int = 10, + init_params: list = None, + mixer: str = "X", + learning_rate: float = 1e-2, + jit: bool = True, + callback: callable = None, +) -> list: + """ + Performs the QAOA on a given QUBO problem. + Adam optimizer from TensorFlow is used. + + :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. + :param nlayers: The number of layers (depth) in the QAOA ansatz. + :param iterations: The number of iterations to run the optimization. + :param vvag (optional): A flag indicating whether to use vectorized variational adjoint gradient. Default is False. + :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. Default is 10. + :param init_params (optional): The initial parameters for the ansatz circuit. Default is None, which initializes the parameters randomly. + :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "X", "XY", "XY_full", and "ZZ". + :param learning_rate (optional): The learning rate for the Adam optimizer. Default is 1e-2. + :param jit (optional): A flag indicating whether to use just-in-time compilation. Default is True. + :param callback (optional): A callback function that is executed during each iteration. Default is None. + :return params: The optimized parameters for the ansatz circuit. + """ + if backend != tc.set_backend("tensorflow"): + raise ValueError("`QUBO_QAOA` is designed for tensorflow backend.") + # Check if the backend is set to TensorFlow. Raise an error if it is not. + + pauli_terms, weights, offset = QUBO_to_Ising(Q) + + loss_val_grad = backend.value_and_grad( + partial(QAOA_loss, nlayers, pauli_terms, weights, mixer=mixer) + ) + # Define the loss and gradients function using value_and_grad, which calculates both the loss value and gradients. + + if init_params is None: + params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) + if vvag == True: + loss_val_grad = tc.backend.vvag( + loss_val_grad, argnums=0, vectorized_argnums=0 + ) + params = backend.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) + # If init_params is not provided, initialize the parameters randomly. + # If vvag flag is set to True, use vectorized variational adjoint gradient (vvag) with multiple circuits. + else: + params = init_params + # If init_params is provided, use the provided parameters. + # Initialize the parameters for the ansatz circuit. + + if jit == True: + loss_val_grad = backend.jit(loss_val_grad, static_argnums=(1, 2)) + # Use just-in-time compilation (jit) if jit flag is set to True. + # This can improve the performance by pre-compiling the loss and gradients function. + + opt = backend.optimizer(tf.keras.optimizers.Adam(learning_rate)) + # Define the optimizer (Adam optimizer) with the specified learning rate. + + for i in range(iterations): + loss, grads = loss_val_grad(params) + # Calculate the loss and gradients using the loss_val_grad_jit function. + + params = opt.update(grads, params) + # Update the parameters using the optimizer and gradients. + + if callback is not None: + callback(loss, params) + # Execute the callback function with the current loss and parameters. + + return params + # Return the optimized parameters for the ansatz circuit. + + +def cvar_value(r: list, p: list, percent: float) -> float: + """ + Calculate the Conditional Value at Risk (CVaR) according to the measurement results. + + :param r: The results showing after measurements. + :param p: Probabilities corresponding to each result. + :param percent: The cut-off percentage of CVaR. + :return: The calculated CVaR value. + """ + sorted_indices = np.argsort(r) + p = np.array(p)[sorted_indices] + r = np.array(r)[sorted_indices] + + sump = 0.0 # The sum of probabilities. + count = 0 + cvar_result = 0.0 + + # Iterate over the sorted results and calculate CVaR. + while sump < percent: + if round(sump + p[count], 6) >= percent: + # Add the remaining portion of the last result that exceeds the cut-off percentage. + cvar_result += r[count] * (percent - sump) + count += 1 + break + else: + # Add the entire result to the CVaR calculation. + sump += p[count] + cvar_result += r[count] * p[count] + count += 1 + + cvar_result /= percent + return cvar_result + +def cvar_from_circuit( + circuit: Circuit, nsamples: int, Q: Tensor, alpha: float +) -> float: + """ + Directly calculate the Conditional Value at Risk (CVaR) from a circuit. + The CVaR depends on a bunch of measurements. + + :param circuit: The quantum circuit used to prepare the state. + :param nsamples: The number of samples to take for measurements. + :param Q: The Q-matrix representing the Quadratic Unconstrained Binary Optimization (QUBO) problem. + :param alpha: The cut-off percentage for CVaR. + :return: The calculated CVaR value. + """ + s = circuit.state() + results = tc.quantum.measurement_results( + s, counts=nsamples, format="count_dict_bin" + ) # Get readouts from the measurements. + results = {k: v / nsamples for k, v in results.items()} # Normalize the results. + values = [] # List to store the measurement values. + probabilities = [] # List to store the corresponding probabilities. + + # Iterate over the measurement results and calculate the values and probabilities. + for k, v in results.items(): + x = np.array([int(bit) for bit in k]) + values.append(np.dot(x, np.dot(Q, x))) + probabilities.append(v) + + cvar_result = cvar_value(values, probabilities, alpha) + # Calculate the CVaR using the cvar_value function. + + return cvar_result + + +def cvar_from_expectation(circuit, Q, alpha: float) -> float: + """ + Calculate the Conditional Value at Risk (CVaR) from the expectation values of a quantum circuit. + + :param circuit: The quantum circuit. + :param Q: The Q-matrix representing the Quadratic Unconstrained Binary Optimization (QUBO) problem. + :param alpha: The cut-off percentage for CVaR. + :return: The calculated CVaR value. + """ + prob = circuit.probability() # Get the probabilities of the circuit states. + prob /= np.sum(prob) + states = [] + + # Generate all possible binary states based on the length of Q. + for i in range(2 ** len(Q)): + a = f"{bin(i)[2:]:0>{len(Q)}}" + states.append(a) + + values = [] + for state in states: + x = np.array([int(bit) for bit in state]) + values.append(np.dot(x, np.dot(Q, x))) + # Calculate the values by taking the dot product of each state with the Q-matrix. + + cvar_result = cvar_value(values, prob, alpha) + # Calculate the CVaR using the cvar_value function. + + return cvar_result + + +def cvar_loss(nlayers, Q, nsamples, alpha, fake, params): + """ + Calculate the CVaR loss for a given QUBO problem using the QAOA ansatz. + + :param nlayers: The number of layers (depth) in the QAOA ansatz. + :param Q: The Q-matrix representing the Quadratic Unconstrained Binary Optimization (QUBO) problem. + :param nsamples: The number of samples to take for measurements in the CVaR calculation. + :param alpha: The cut-off percentage for CVaR. + :param fake: A flag indicating the type of CVaR ansatz (circuit-based or expectation-based). + :param params: The parameters for the QAOA ansatz circuit. + :return: The calculated CVaR loss. + """ + pauli_terms, weights, offset = QUBO_to_Ising(Q) + + c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights) + # Generate the QAOA ansatz circuit for the given parameters. + + if fake == False: + return cvar_from_circuit(c, nsamples, Q, alpha) + # Calculate CVaR using circuit-based measurement results. + elif fake == True: + return cvar_from_expectation(c, Q, alpha) + # Calculate CVaR using expectation values of the circuit. + else: + raise ValueError("Invalid CVaR ansatz type.") + # Raise an error if an invalid CVaR ansatz type is provided. + + +def QUBO_QAOA_cvar( + Q: List[list], + nlayers: int, + alpha: int, + nsamples: int = 1000, + callback: callable = None, + fake: bool = False, + maxiter: int = 1000, + init_params: list = None, +) -> list: + """ + Perform the QUBO QAOA optimization with CVaR as the loss function. + + :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. + :param ansatz: The ansatz function to be used for QAOA. + :param nlayers: The number of layers (depth) in the QAOA ansatz. + :param alpha: The cut-off percentage for CVaR. + :param nsamples: The number of samples for measurements in the CVaR calculation. Default is 1000. + :param callback: A callback function to be called after each iteration. Default is None. + :param fake: A flag indicating the type of CVaR ansatz (circuit-based or expectation-based). Default is False. + :param maxiter: The maximum number of iterations for the optimization. Default is 1000. + :return: The optimized parameters for the ansatz circuit. + """ + loss = partial(cvar_loss, nlayers, Q, nsamples, alpha, fake) + + f_scipy = tc.interfaces.scipy_interface( + loss, shape=[2 * nlayers], jit=False, gradient=False + ) + + if init_params is None: + params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) + # If init_params is not provided, initialize the parameters randomly. + else: + params = init_params + # If init_params is provided, use the provided parameters. + + # Initialize the parameters for the ansatz circuit. + params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) + + r = optimize.minimize( + f_scipy, + params, + method="COBYLA", + callback=callback, + options={"maxiter": maxiter}, + # bounds=[(0, (2 - np.mod(i, 2))*np.pi) for i in range(2*nlayers)] + ) + # Perform the optimization using the COBYLA method from scipy.optimize. + + return r.x + # Return the optimized parameters for the ansatz circuit. diff --git a/tensorcircuit/templates/__init__.py b/tensorcircuit/templates/__init__.py index 85f350ea..be2236ab 100644 --- a/tensorcircuit/templates/__init__.py +++ b/tensorcircuit/templates/__init__.py @@ -4,5 +4,6 @@ from . import dataset from . import graphs from . import measurements +from . import conversions costfunctions = measurements diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index eacc2b42..655ac21e 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -5,7 +5,7 @@ # pylint: disable=invalid-name from functools import wraps -from typing import Any, Callable, Optional, Sequence, Tuple +from typing import Any, Callable, Optional, Sequence, Tuple, List import numpy as np @@ -200,3 +200,97 @@ def qft( for i in range(len(index) // 2): c.swap(index[i], index[len(index) - 1 - i]) return c + + +def QAOA_ansatz_for_Ising( + params: list, + nlayers: int, + pauli_terms: Tensor, + weights: list, + mixer: str = "X", + gap: int = 5, +) -> Circuit: + """ + Construct the QAOA ansatz for the Ising Model. + The number of qubits is determined by `pauli_terms`. + + :param params: A list of parameter values used in the QAOA ansatz. + :param nlayers: The number of layers in the QAOA ansatz. + :pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :param mixer: mixer type. The options are "X", "XY_ring", "XY_par_ring", "XY_full", and "QAMPA". + """ + nqubits = len(pauli_terms[0]) + c = Circ(nqubits) + for i in range(nqubits): + c.h(i) # Apply Hadamard gate to each qubit + + for j in range(nlayers): + # cost terms + for k in range(len(pauli_terms)): + term = pauli_terms[k] + index_of_ones = [] + for l in range(len(term)): + if term[l] == 1: + index_of_ones.append(l) + if len(index_of_ones) == 1: + c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) + # Apply Rz gate with angle determined by weight and current parameter value + elif len(index_of_ones) == 2: + c.exp1( + index_of_ones[0], + index_of_ones[1], + unitary=G._zz_matrix, + theta=weights[k] * params[2 * j], + ) + # Apply exp1 gate with a custom unitary (zz_matrix) and angle determined by weight and current parameter value + else: + raise ValueError("Invalid number of Z terms") + + # standard mixer + if mixer == "X": + for i in range(nqubits): + c.rx( + i, theta=params[2 * j + 1] + ) # Apply Rx gate with angle determined by current parameter value + # Parity ring XY mixer + elif mixer == "XY": + pairs = [] + for index in [0, 1]: + while index + 2 <= nqubits: + pairs.append([index, index + 1]) + index += 2 + for pair in pairs: + c.exp1(pair[0], pair[1], unitary=G._xx_matrix, theta=params[2 * j + 1]) + c.exp1(pair[0], pair[1], unitary=G._yy_matrix, theta=params[2 * j + 1]) + c.exp1(nqubits - 1, 0, unitary=G._xx_matrix, theta=params[2 * j + 1]) + c.exp1(nqubits - 1, 0, unitary=G._yy_matrix, theta=params[2 * j + 1]) + + # XY mixer with full couplings + elif mixer == "XY_full": + for q0 in range(nqubits - 1): + for q1 in range(q0 + 1, nqubits): + c.exp1(q0, q1, unitary=G._xx_matrix, theta=params[2 * j + 1]) + c.exp1(q0, q1, unitary=G._yy_matrix, theta=params[2 * j + 1]) + + # Parity ring ZZ mixer + elif mixer == "ZZ": + pairs = [] + for index in [0, 1]: + while index + 2 <= nqubits: + pairs.append([index, index + 1]) + index += 2 + for pair in pairs: + c.exp1(pair[0], pair[1], unitary=G._zz_matrix, theta=params[2 * j + 1]) + c.exp1(nqubits - 1, 0, unitary=G._zz_matrix, theta=params[2 * j + 1]) + + # ZZ mixer with full couplings + elif mixer == "ZZ_full": + for q0 in range(nqubits - 1): + for q1 in range(q0, nqubits): + c.exp1(q0, q1, unitary=G._zz_matrix, theta=params[2 * j + 1]) + + else: + raise ValueError("Invalid mixer type.") + + return c diff --git a/tensorcircuit/templates/conversions.py b/tensorcircuit/templates/conversions.py index 2fc92463..513a79a5 100644 --- a/tensorcircuit/templates/conversions.py +++ b/tensorcircuit/templates/conversions.py @@ -2,11 +2,13 @@ helper functions for conversions """ -from typing import Any, Tuple +from typing import Any, Tuple, List +from ..cons import backend import numpy as np Tensor = Any +Array = Any def get_ps(qo: Any, n: int) -> Tuple[Tensor, Tensor]: @@ -36,3 +38,201 @@ def get_ps(qo: Any, n: int) -> Tuple[Tensor, Tensor]: res.append(res_t) wts.append(w) return np.array(res), np.array(wts) + + +def QUBO_to_Ising(Q: List[list]) -> Tuple[List[list], list, float]: + """ + Cnvert the Q matrix into a the indication of pauli terms, the corresponding weights, and the offset. + The outputs are used to construct an Ising Hamiltonian for QAOA. + + :param Q: The n-by-n square and symmetric Q-matrix. + :return pauli_terms: A list of 0/1 series, where each element represents a Pauli term. + A value of 1 indicates the presence of a Pauli-Z operator, while a value of 0 indicates its absence. + :return weights: A list of weights corresponding to each Pauli term. + :return offset: A float representing the offset term of the Ising Hamiltonian. + """ + + # input is n-by-n symmetric numpy array corresponding to Q-matrix + # output is the components of Ising Hamiltonian + + n = Q.shape[0] + + # square matrix check + if Q[0].shape[0] != n: + raise ValueError("Matrix is not a square matrix.") + + offset = ( + np.triu(Q, 0).sum() / 2 + ) # Calculate the offset term of the Ising Hamiltonian + pauli_terms = [] # List to store the Pauli terms + weights = ( + -np.sum(Q, axis=1) / 2 + ) # Calculate the weights corresponding to each Pauli term + + for i in range(n): + term = np.zeros(n) + term[i] = 1 + pauli_terms.append( + term.tolist() + ) # Add a Pauli term corresponding to a single qubit + + for i in range(n - 1): + for j in range(i + 1, n): + term = np.zeros(n) + term[i] = 1 + term[j] = 1 + pauli_terms.append( + term.tolist() + ) # Add a Pauli term corresponding to a two-qubit interaction + + weight = ( + Q[i][j] / 2 + ) # Calculate the weight for the two-qubit interaction term + weights = np.concatenate( + (weights, weight), axis=None + ) # Add the weight to the weights list + + return pauli_terms, weights, offset + + +def QUBO_from_portfolio(cov: Array, mean: Array, q: float, B: int, t: float) -> Tensor: + """ + convert portfolio parameters to a Q matrix + :param cov: n-by-n covariance numpy array + :param mean: numpy array of means + :param q: the risk preference of investor + :param B: budget + :param t: penalty factor + :return Q: n-by-n symmetric Q matrix + """ + n = cov.shape[0] + R = np.diag(mean) + S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n)) + + Q = q * cov - R + t * S + return Q + + +class StockData: + """ + A class for converting real-world stock data to an annualized covariance matrix and annualized return. + + Attributes: + - data: A list of continuous stock data in the same time span. + - n_stocks: The number of stocks in the data. + - n_days: The number of trading days in the data. + + Methods: + - __init__(self, data): Initializes the StockData object. + - get_return(self, decimals=5): Calculates the annualized return. + - get_covariance(self, decimals=5): Calculates the annualized covariance matrix. + - get_penalty(self, cov, ret, risk_pre, budget, decimals=5): Calculates the penalty factor. + """ + + def __init__(self, data): + """ + Initializes the StockData object. + + :param data: A list of continuous stock data in the same time span. + """ + self.data = data + self.n_stocks = len(data) + + # Check the number of days + n_days = [len(i) for i in data] + if max(n_days) != (sum(n_days) / len(n_days)): + raise Exception("Timespan of stocks should be the same") + self.n_days = len(data[1]) + + # Calculate the daily percentage price change + self.daily_change = [] + for i in range(self.n_stocks): + each_stock = [] + for j in range(self.n_days - 1): + each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j + 1]) + self.daily_change.append(each_stock) + + def get_return(self, decimals=5): + """ + Calculates the annualized return (mu). + + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The annualized return as an array rounded to the specified number of decimals. + """ + change = [[j + 1 for j in i] for i in self.daily_change] + ret = np.prod(change, axis=1) ** (252 / self.n_days) + return ret.round(decimals) + + def get_covariance(self, decimals=5): + """ + Calculates the annualized covariance matrix (sigma). + + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The annualized covariance matrix rounded to the specified number of decimals. + """ + mean = np.mean(self.daily_change, axis=1) + relative_change = [ + [j - mean[i] for j in self.daily_change[i]] for i in range(6) + ] + cov = 252 / self.n_days * np.dot(relative_change, np.transpose(relative_change)) + return cov.round(decimals) + + def get_penalty(self, cov, ret, risk_pre, budget, decimals=5): + """ + Calculates the penalty factor. + + :param cov: The annualized covariance matrix. + :param ret: The annualized return. + :param risk_pre: The risk preference factor. + :param budget: The budget (number of stocks to select). + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The penalty factor rounded to the specified number of decimals. + """ + # Get all feasible and unfeasible states + self.f_state = [] # Feasible states (number of '1's equal to budget) + self.uf_state = [] # Unfeasible states + self.all_state = [] + for i in range(2 ** self.n_stocks): + state = f"{bin(i)[2:]:0>{self.n_stocks}}" + n_ones = 0 + for j in state: + if j == "1": + n_ones += 1 + self.all_state.append(state) + if n_ones == budget: + self.f_state.append(state) + else: + self.uf_state.append(state) + + # Determine the penalty factor + mark = False + penalty = 0 # Initial value + while mark == False: + R = np.diag(ret) + S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( + np.ones(self.n_stocks) + ) + Q = risk_pre * cov - R + penalty * S + F = [] + for state in self.f_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget ** 2) + Fmin = np.amin(F) + Fbar = np.mean(F) + F = [] + for state in self.uf_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget ** 2) + Fmin_uf = np.amin(F) + location = np.where(F == Fmin_uf)[0][0] + if Fmin_uf < 0.5 * (Fmin + Fbar): + n_ones = 0 + for j in self.uf_state[location]: + if j == "1": + n_ones += 1 + penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 + else: + mark = True # Ready to return the penalty + return round(penalty, decimals) + + From dc187da929959a590290f28b994eed22801faaec Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Wed, 12 Jul 2023 12:50:20 +0100 Subject: [PATCH 536/725] add functions relavent of QAOA --- docs/source/tutorials/QAOA_funcs.py | 439 +++++++++++++++++++++ tensorcircuit/applications/__init__.py | 2 + tensorcircuit/applications/optimization.py | 328 +++++++++++++++ tensorcircuit/templates/__init__.py | 1 + tensorcircuit/templates/blocks.py | 96 ++++- tensorcircuit/templates/conversions.py | 202 +++++++++- 6 files changed, 1066 insertions(+), 2 deletions(-) create mode 100644 docs/source/tutorials/QAOA_funcs.py create mode 100644 tensorcircuit/applications/optimization.py diff --git a/docs/source/tutorials/QAOA_funcs.py b/docs/source/tutorials/QAOA_funcs.py new file mode 100644 index 00000000..87d35d59 --- /dev/null +++ b/docs/source/tutorials/QAOA_funcs.py @@ -0,0 +1,439 @@ +### +### functions for QAOA problems +### + +from typing import List, Tuple, Callable, Any +import tensorcircuit as tc +import numpy as np +import tensorflow as tf +import matplotlib.pyplot as plt +from IPython.display import clear_output +from functools import partial +import scipy.optimize as optimize + +Array = any +Tensor = Any + + +# moved +def QUBO_to_Ising(Q: List[list]) -> Tuple[List[list], list, float]: + """ + Cnvert the Q matrix into a the indication of pauli terms, the corresponding weights, and the offset. + The outputs are used to construct an Ising Hamiltonian for QAOA. + + :param Q: The n-by-n square and symmetric Q-matrix. + :return pauli_terms: A list of 0/1 series, where each element represents a Pauli term. + A value of 1 indicates the presence of a Pauli-Z operator, while a value of 0 indicates its absence. + :return weights: A list of weights corresponding to each Pauli term. + :return offset: A float representing the offset term of the Ising Hamiltonian. + """ + + # input is n-by-n symmetric numpy array corresponding to Q-matrix + # output is the components of Ising Hamiltonian + + n = Q.shape[0] + + # square matrix check + if Q[0].shape[0] != n: + raise ValueError("Matrix is not a square matrix.") + + offset = ( + np.triu(Q, 0).sum() / 2 + ) # Calculate the offset term of the Ising Hamiltonian + pauli_terms = [] # List to store the Pauli terms + weights = ( + -np.sum(Q, axis=1) / 2 + ) # Calculate the weights corresponding to each Pauli term + + for i in range(n): + term = np.zeros(n) + term[i] = 1 + pauli_terms.append( + term.tolist() + ) # Add a Pauli term corresponding to a single qubit + + for i in range(n - 1): + for j in range(i + 1, n): + term = np.zeros(n) + term[i] = 1 + term[j] = 1 + pauli_terms.append( + term.tolist() + ) # Add a Pauli term corresponding to a two-qubit interaction + + weight = ( + Q[i][j] / 2 + ) # Calculate the weight for the two-qubit interaction term + weights = np.concatenate( + (weights, weight), axis=None + ) # Add the weight to the weights list + + return pauli_terms, weights, offset + + +def Ising_loss(c: tc.Circuit, pauli_terms: List[list], weights: list) -> float: + """ + computes the loss function for the Ising model based on a given quantum circuit, + a list of Pauli terms, and corresponding weights. + The offset is ignored. + + :param c: A quantum circuit object generating the state. + :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :return loss: A real number representing the computed loss value. + """ + loss = 0.0 + for k in range(len(pauli_terms)): + term = pauli_terms[k] + index_of_ones = [] + + for l in range(len(term)): + if term[l] == 1: + index_of_ones.append(l) + + # Compute expectation value based on the number of qubits involved in the Pauli term + if len(index_of_ones) == 1: + delta_loss = weights[k] * c.expectation_ps(z=[index_of_ones[0]]) + # Compute expectation value for a single-qubit Pauli term + else: + delta_loss = weights[k] * c.expectation_ps( + z=[index_of_ones[0], index_of_ones[1]] + ) + # Compute expectation value for a two-qubit Pauli term + + loss += delta_loss + + return K.real(loss) + + +def QAOA_loss( + nlayers: int, pauli_terms: List[list], weights: list, params: list +) -> float: + """ + computes the loss function for the Quantum Approximate Optimization Algorithm (QAOA) applied to the Ising model. + + :param nlayers: The number of layers in the QAOA ansatz. + :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :param params: A list of parameter values used in the QAOA ansatz. + :return: The computed loss value. + """ + c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights) + # Obtain the quantum circuit using QAOA_from_Ising function + + return Ising_loss(c, pauli_terms, weights) + # Compute the Ising loss using Ising_loss function on the obtained circuit + + +def QUBO_QAOA( + Q: List[list], + ansatz: Callable[[list, int, List[list], list], tc.Circuit], + nlayers: int, + iterations: int, + vvag: bool = False, + ncircuits: int = 10, +) -> list: + """ + Performs the QAOA on a given QUBO problem. + + :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. + :param ansatz: The ansatz function to be used for the QAOA. + :param nlayers: The number of layers in the QAOA ansatz. + :param iterations: The number of iterations to run the optimization. + :param vvag (optional): A flag indicating whether to use vectorized variational adjoint gradient. Default is False. + :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. Default is 10. + :return params: The optimized parameters for the ansatz circuit. + """ + try: + K + except NameError: + print("select a backend and assign it to K.") + + pauli_terms, weights, offset = QUBO_to_Ising(Q) + learning_rate = 1e-2 + + loss_val_grad = K.value_and_grad(partial(ansatz, nlayers, pauli_terms, weights)) + params = K.implicit_randn(shape=[2 * nlayers], stddev=0.5) + # Initialize the parameters for the ansatz circuit + + if vvag == True: + loss_val_grad = tc.backend.vvag(loss_val_grad, argnums=0, vectorized_argnums=0) + params = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) + # Use vectorized variational adjoint gradient (vvag) if vvag flag is set to True + + loss_val_grad_jit = K.jit(loss_val_grad, static_argnums=(1, 2)) + + opt = K.optimizer(tf.keras.optimizers.Adam(learning_rate)) + # Define the optimizer (Adam optimizer) with the specified learning rate + + for i in range(iterations): + loss, grads = loss_val_grad_jit(params) + # Calculate the loss and gradients using the loss_val_grad_jit function + + params = opt.update(grads, params) + # Update the parameters using the optimizer and gradients + + if i % 100 == 0: # print the cost every 100 iterations + print(K.numpy(loss)) + + return params + + +# calcelled +def print_result_prob(c: tc.Circuit, wrap: bool = False, reverse: bool = False) -> None: + """ + Print the results and probabilities of a given quantum circuit. + The default order is from the highest probability to the lowest one + + :param c: The quantum circuit to print the results and probabilities. + :param wrap (optional): A flag indicating whether to wrap the output. Default is False. + :param reverse (optional): A flag indicating whether to reverse the order of the output. Default is False. + """ + try: + K + except NameError: + print("select a backend and assign it to K.") + + states = [] + n_qubits = c._nqubits + for i in range(2**n_qubits): + a = f"{bin(i)[2:]:0>{n_qubits}}" + states.append(a) + # Generate all possible binary states for the given number of qubits + + probs = K.numpy(c.probability()).round(decimals=4) + # Calculate the probabilities of each state using the circuit's probability method + + sorted_indices = np.argsort(probs)[::-1] + if reverse == True: + sorted_indices = sorted_indices[::-1] + state_sorted = np.array(states)[sorted_indices] + prob_sorted = np.array(probs)[sorted_indices] + # Sort the states and probabilities in descending order based on the probabilities + + print("\n-------------------------------------") + print(" selection\t |\tprobability") + print("-------------------------------------") + if wrap == False: + for i in range(len(states)): + print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) + # Print the sorted states and their corresponding probabilities + elif wrap == True: + for i in range(4): + print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) + print(" ... ...") + for i in range(-4, -1): + print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) + print("-------------------------------------") + + +# calcelled +def print_result_cost( + c: tc.Circuit, Q: List[list], wrap: bool = False, reverse: bool = False +) -> None: + """ + Print the results and costs of a given quantum circuit. + Specificly designed for the variational circuit. + The default order is from the highest probability to the lowest one. + + :param c: The quantum circuit to print the results and probabilities. + :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. + :param wrap (optional): A flag indicating whether to wrap the output. Default is False. + :param reverse (optional): A flag indicating whether to reverse the order of the output. Default is False. + """ + cost_dict = {} + states = [] + n_qubits = c._nqubits + for i in range(2**n_qubits): + a = f"{bin(i)[2:]:0>{n_qubits}}" + states.append(a) + # Generate all possible binary states for the given number of qubits + for selection in states: + x = np.array([int(bit) for bit in selection]) + cost_dict[selection] = np.dot(x, np.dot(Q, x)) + cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1])) + if reverse == True: + cost_sorted = dict( + sorted(cost_dict.items(), key=lambda item: item[1], reverse=True) + ) + num = 0 + print("\n-------------------------------------") + print(" selection\t |\t cost") + print("-------------------------------------") + for k, v in cost_sorted.items(): + print("%10s\t |\t%.4f" % (k, v)) + num += 1 + if (num >= 8) & (wrap == True): + break + print("-------------------------------------") + + +# cancelled +def print_Q_cost(Q: List[list], wrap: bool = False, reverse: bool = False) -> None: + n_stocks = len(Q) + states = [] + for i in range(2**n_stocks): + a = f"{bin(i)[2:]:0>{n_stocks}}" + n_ones = 0 + for j in a: + if j == "1": + n_ones += 1 + states.append(a) + + cost_dict = {} + for selection in states: + x = np.array([int(bit) for bit in selection]) + cost_dict[selection] = np.dot(x, np.dot(Q, x)) + cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1])) + if reverse == True: + cost_sorted = dict( + sorted(cost_dict.items(), key=lambda item: item[1], reverse=True) + ) + num = 0 + print("\n-------------------------------------") + print(" selection\t |\t cost") + print("-------------------------------------") + for k, v in cost_sorted.items(): + print("%10s\t |\t%.4f" % (k, v)) + num += 1 + if (num >= 8) & (wrap == True): + break + print("-------------------------------------") + + +# moved +class StockData: + """ + convert real-world stock data to the inputs of QAOA. + """ + + def __init__(self, data: Tensor) -> None: + """ + stock data object + + :param data: real-world stock data, in the form of several lists of daily price. + """ + self.data = data # add data + self.n_stocks = len(data) # num of stocks + self.n_days = len(data[1]) + + # check the number of days + n_days = [len(i) for i in data] + if max(n_days) != (sum(n_days) / len(n_days)): + raise Exception("timespan of stocks should be the same") + + # calculate the daily percentage price change + self.daily_change = [] # daily percentage price change + for i in range(self.n_stocks): + each_stcok = [] + for j in range(self.n_days - 1): + each_stcok.append((data[i][j + 1] - data[i][j]) / data[i][j]) + self.daily_change.append(each_stcok) + + def get_return(self) -> Array: + """ + :return ret: annualized return (mu) + """ + ret = np.mean(self.daily_change, axis=1) + return ret + + def get_covariance(self) -> Array: + """ + :return cov: symmetric annualized covariance matrix (sigma) + """ + return np.cov(self.daily_change) + + def get_pentalty( + self, cov: Array, ret: Array, risk_pre: float, budget: int + ) -> float: + """ + calculate the pentalty using the method in https://link.springer.com/article/10.1007/s11128-022-03766-5 + brutal force is used + + :param cov: symmetrix annualized covariance matrix (sigma) + :param ret: annualized return (ret) + :param risk_pre: risk preference of the investor + :param budge: the number of assets to be chosen for the portfolio + """ + # get all fesible and unfeasible states + self.f_state = [] # feasible states (num of '1's equal to budge) + self.uf_state = [] # unfeasible states + self.all_state = [] + for i in range(2**self.n_stocks): + state = f"{bin(i)[2:]:0>{self.n_stocks}}" + n_ones = 0 + for j in state: + if j == "1": + n_ones += 1 + self.all_state.append(state) + if n_ones == budget: + self.f_state.append(state) + else: + self.uf_state.append(state) + + # determine the penalty factor + mark = False + penalty = 0 # initial value + while mark == False: + R = np.diag(ret) + S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( + np.ones(self.n_stocks) + ) + Q = risk_pre * cov - R + penalty * S + F = [] + for state in self.f_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) + Fmin = np.amin(F) + Fbar = np.mean(F) + F = [] + for state in self.uf_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) + Fmin_uf = np.amin(F) + location = np.where(F == Fmin_uf)[0][0] + if Fmin_uf < 0.5 * (Fmin + Fbar): + n_ones = 0 + for j in self.uf_state[location]: + if j == "1": + n_ones += 1 + penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 + # mark = True + else: + mark = True # ready to return the penalty + return penalty + + +# moved +def QUBO_from_portfolio(cov: Array, mean: Array, q: float, B: int, t: float) -> Tensor: + """ + convert portfolio parameters to a Q matrix + :param cov: n-by-n covariance numpy array + :param mean: numpy array of means + :param q: the risk preference of investor + :param B: budget + :param t: penalty factor + :return Q: n-by-n symmetric Q matrix + """ + n = cov.shape[0] + R = np.diag(mean) + S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n)) + + Q = q * cov - R + t * S + return Q + + +def print_output(c): + n = c._nqubits + N = 2**n + # Calculate the total number of states based on the number of qubits + + x_label = r"$\left|{0:0" + str(n) + r"b}\right>$" + labels = [x_label.format(i) for i in range(N)] + # Generate labels for the x-axis representing the binary states + + plt.bar(range(N), c.probability()) + # Create a bar plot with the probabilities of each state + + plt.xticks(range(N), labels, rotation=70) + # Set the x-axis ticks to the generated labels and rotate them for better visibility diff --git a/tensorcircuit/applications/__init__.py b/tensorcircuit/applications/__init__.py index 70d128b0..200fcbe6 100644 --- a/tensorcircuit/applications/__init__.py +++ b/tensorcircuit/applications/__init__.py @@ -3,3 +3,5 @@ the code inside is subject to change, be caution to use. Most of the useful code is and will be refactored and copied to other parts of tensorcircuit. """ + +from . import optimization \ No newline at end of file diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py new file mode 100644 index 00000000..fd05b693 --- /dev/null +++ b/tensorcircuit/applications/optimization.py @@ -0,0 +1,328 @@ +""" +modules for QUBO problems in QAOA +""" + +from typing import List, Callable, Any + +import tensorcircuit as tc +import numpy as np +from functools import partial +import tensorflow as tf +import scipy.optimize as optimize + +from ..cons import backend +from ..templates.blocks import QAOA_ansatz_for_Ising +from ..templates.conversions import QUBO_to_Ising +from tensorflow.python.ops.numpy_ops import np_config + +np_config.enable_numpy_behavior() + +Circuit = Any +Tensor = Any + + +def Ising_loss(c: Circuit, pauli_terms: List[list], weights: list) -> float: + """ + computes the loss function for the Ising model based on a given quantum circuit, + a list of Pauli terms, and corresponding weights. + The offset is ignored. + + :param c: A quantum circuit object generating the state. + :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :return loss: A real number representing the computed loss value. + """ + loss = 0.0 + for k in range(len(pauli_terms)): + term = pauli_terms[k] + index_of_ones = [] + + for l in range(len(term)): + if term[l] == 1: + index_of_ones.append(l) + + # Compute expectation value based on the number of qubits involved in the Pauli term + if len(index_of_ones) == 1: + delta_loss = weights[k] * c.expectation_ps(z=[index_of_ones[0]]) + # Compute expectation value for a single-qubit Pauli term + else: + delta_loss = weights[k] * c.expectation_ps( + z=[index_of_ones[0], index_of_ones[1]] + ) + # Compute expectation value for a two-qubit Pauli term + + loss += delta_loss + + return backend.real(loss) + + +def QAOA_loss( + nlayers: int, pauli_terms: List[list], weights: list, params: list, mixer: str = "X" +) -> float: + """ + computes the loss function for the Quantum Approximate Optimization Algorithm (QAOA) applied to the Ising model. + + :param nlayers: The number of layers in the QAOA ansatz. + :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :param params: A list of parameter values used in the QAOA ansatz. + :return: The computed loss value. + """ + c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights, mixer=mixer) + # Obtain the quantum circuit using QAOA_from_Ising function + + return Ising_loss(c, pauli_terms, weights) + # Compute the Ising loss using Ising_loss function on the obtained circuit + + +def QUBO_QAOA( + Q: List[list], + nlayers: int, + iterations: int, + vvag: bool = False, + ncircuits: int = 10, + init_params: list = None, + mixer: str = "X", + learning_rate: float = 1e-2, + jit: bool = True, + callback: callable = None, +) -> list: + """ + Performs the QAOA on a given QUBO problem. + Adam optimizer from TensorFlow is used. + + :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. + :param nlayers: The number of layers (depth) in the QAOA ansatz. + :param iterations: The number of iterations to run the optimization. + :param vvag (optional): A flag indicating whether to use vectorized variational adjoint gradient. Default is False. + :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. Default is 10. + :param init_params (optional): The initial parameters for the ansatz circuit. Default is None, which initializes the parameters randomly. + :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "X", "XY", "XY_full", and "ZZ". + :param learning_rate (optional): The learning rate for the Adam optimizer. Default is 1e-2. + :param jit (optional): A flag indicating whether to use just-in-time compilation. Default is True. + :param callback (optional): A callback function that is executed during each iteration. Default is None. + :return params: The optimized parameters for the ansatz circuit. + """ + if backend != tc.set_backend("tensorflow"): + raise ValueError("`QUBO_QAOA` is designed for tensorflow backend.") + # Check if the backend is set to TensorFlow. Raise an error if it is not. + + pauli_terms, weights, offset = QUBO_to_Ising(Q) + + loss_val_grad = backend.value_and_grad( + partial(QAOA_loss, nlayers, pauli_terms, weights, mixer=mixer) + ) + # Define the loss and gradients function using value_and_grad, which calculates both the loss value and gradients. + + if init_params is None: + params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) + if vvag == True: + loss_val_grad = tc.backend.vvag( + loss_val_grad, argnums=0, vectorized_argnums=0 + ) + params = backend.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) + # If init_params is not provided, initialize the parameters randomly. + # If vvag flag is set to True, use vectorized variational adjoint gradient (vvag) with multiple circuits. + else: + params = init_params + # If init_params is provided, use the provided parameters. + # Initialize the parameters for the ansatz circuit. + + if jit == True: + loss_val_grad = backend.jit(loss_val_grad, static_argnums=(1, 2)) + # Use just-in-time compilation (jit) if jit flag is set to True. + # This can improve the performance by pre-compiling the loss and gradients function. + + opt = backend.optimizer(tf.keras.optimizers.Adam(learning_rate)) + # Define the optimizer (Adam optimizer) with the specified learning rate. + + for i in range(iterations): + loss, grads = loss_val_grad(params) + # Calculate the loss and gradients using the loss_val_grad_jit function. + + params = opt.update(grads, params) + # Update the parameters using the optimizer and gradients. + + if callback is not None: + callback(loss, params) + # Execute the callback function with the current loss and parameters. + + return params + # Return the optimized parameters for the ansatz circuit. + + +def cvar_value(r: list, p: list, percent: float) -> float: + """ + Calculate the Conditional Value at Risk (CVaR) according to the measurement results. + + :param r: The results showing after measurements. + :param p: Probabilities corresponding to each result. + :param percent: The cut-off percentage of CVaR. + :return: The calculated CVaR value. + """ + sorted_indices = np.argsort(r) + p = np.array(p)[sorted_indices] + r = np.array(r)[sorted_indices] + + sump = 0.0 # The sum of probabilities. + count = 0 + cvar_result = 0.0 + + # Iterate over the sorted results and calculate CVaR. + while sump < percent: + if round(sump + p[count], 6) >= percent: + # Add the remaining portion of the last result that exceeds the cut-off percentage. + cvar_result += r[count] * (percent - sump) + count += 1 + break + else: + # Add the entire result to the CVaR calculation. + sump += p[count] + cvar_result += r[count] * p[count] + count += 1 + + cvar_result /= percent + return cvar_result + +def cvar_from_circuit( + circuit: Circuit, nsamples: int, Q: Tensor, alpha: float +) -> float: + """ + Directly calculate the Conditional Value at Risk (CVaR) from a circuit. + The CVaR depends on a bunch of measurements. + + :param circuit: The quantum circuit used to prepare the state. + :param nsamples: The number of samples to take for measurements. + :param Q: The Q-matrix representing the Quadratic Unconstrained Binary Optimization (QUBO) problem. + :param alpha: The cut-off percentage for CVaR. + :return: The calculated CVaR value. + """ + s = circuit.state() + results = tc.quantum.measurement_results( + s, counts=nsamples, format="count_dict_bin" + ) # Get readouts from the measurements. + results = {k: v / nsamples for k, v in results.items()} # Normalize the results. + values = [] # List to store the measurement values. + probabilities = [] # List to store the corresponding probabilities. + + # Iterate over the measurement results and calculate the values and probabilities. + for k, v in results.items(): + x = np.array([int(bit) for bit in k]) + values.append(np.dot(x, np.dot(Q, x))) + probabilities.append(v) + + cvar_result = cvar_value(values, probabilities, alpha) + # Calculate the CVaR using the cvar_value function. + + return cvar_result + + +def cvar_from_expectation(circuit, Q, alpha: float) -> float: + """ + Calculate the Conditional Value at Risk (CVaR) from the expectation values of a quantum circuit. + + :param circuit: The quantum circuit. + :param Q: The Q-matrix representing the Quadratic Unconstrained Binary Optimization (QUBO) problem. + :param alpha: The cut-off percentage for CVaR. + :return: The calculated CVaR value. + """ + prob = circuit.probability() # Get the probabilities of the circuit states. + prob /= np.sum(prob) + states = [] + + # Generate all possible binary states based on the length of Q. + for i in range(2 ** len(Q)): + a = f"{bin(i)[2:]:0>{len(Q)}}" + states.append(a) + + values = [] + for state in states: + x = np.array([int(bit) for bit in state]) + values.append(np.dot(x, np.dot(Q, x))) + # Calculate the values by taking the dot product of each state with the Q-matrix. + + cvar_result = cvar_value(values, prob, alpha) + # Calculate the CVaR using the cvar_value function. + + return cvar_result + + +def cvar_loss(nlayers, Q, nsamples, alpha, fake, params): + """ + Calculate the CVaR loss for a given QUBO problem using the QAOA ansatz. + + :param nlayers: The number of layers (depth) in the QAOA ansatz. + :param Q: The Q-matrix representing the Quadratic Unconstrained Binary Optimization (QUBO) problem. + :param nsamples: The number of samples to take for measurements in the CVaR calculation. + :param alpha: The cut-off percentage for CVaR. + :param fake: A flag indicating the type of CVaR ansatz (circuit-based or expectation-based). + :param params: The parameters for the QAOA ansatz circuit. + :return: The calculated CVaR loss. + """ + pauli_terms, weights, offset = QUBO_to_Ising(Q) + + c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights) + # Generate the QAOA ansatz circuit for the given parameters. + + if fake == False: + return cvar_from_circuit(c, nsamples, Q, alpha) + # Calculate CVaR using circuit-based measurement results. + elif fake == True: + return cvar_from_expectation(c, Q, alpha) + # Calculate CVaR using expectation values of the circuit. + else: + raise ValueError("Invalid CVaR ansatz type.") + # Raise an error if an invalid CVaR ansatz type is provided. + + +def QUBO_QAOA_cvar( + Q: List[list], + nlayers: int, + alpha: int, + nsamples: int = 1000, + callback: callable = None, + fake: bool = False, + maxiter: int = 1000, + init_params: list = None, +) -> list: + """ + Perform the QUBO QAOA optimization with CVaR as the loss function. + + :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. + :param ansatz: The ansatz function to be used for QAOA. + :param nlayers: The number of layers (depth) in the QAOA ansatz. + :param alpha: The cut-off percentage for CVaR. + :param nsamples: The number of samples for measurements in the CVaR calculation. Default is 1000. + :param callback: A callback function to be called after each iteration. Default is None. + :param fake: A flag indicating the type of CVaR ansatz (circuit-based or expectation-based). Default is False. + :param maxiter: The maximum number of iterations for the optimization. Default is 1000. + :return: The optimized parameters for the ansatz circuit. + """ + loss = partial(cvar_loss, nlayers, Q, nsamples, alpha, fake) + + f_scipy = tc.interfaces.scipy_interface( + loss, shape=[2 * nlayers], jit=False, gradient=False + ) + + if init_params is None: + params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) + # If init_params is not provided, initialize the parameters randomly. + else: + params = init_params + # If init_params is provided, use the provided parameters. + + # Initialize the parameters for the ansatz circuit. + params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) + + r = optimize.minimize( + f_scipy, + params, + method="COBYLA", + callback=callback, + options={"maxiter": maxiter}, + # bounds=[(0, (2 - np.mod(i, 2))*np.pi) for i in range(2*nlayers)] + ) + # Perform the optimization using the COBYLA method from scipy.optimize. + + return r.x + # Return the optimized parameters for the ansatz circuit. diff --git a/tensorcircuit/templates/__init__.py b/tensorcircuit/templates/__init__.py index 85f350ea..be2236ab 100644 --- a/tensorcircuit/templates/__init__.py +++ b/tensorcircuit/templates/__init__.py @@ -4,5 +4,6 @@ from . import dataset from . import graphs from . import measurements +from . import conversions costfunctions = measurements diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index eacc2b42..655ac21e 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -5,7 +5,7 @@ # pylint: disable=invalid-name from functools import wraps -from typing import Any, Callable, Optional, Sequence, Tuple +from typing import Any, Callable, Optional, Sequence, Tuple, List import numpy as np @@ -200,3 +200,97 @@ def qft( for i in range(len(index) // 2): c.swap(index[i], index[len(index) - 1 - i]) return c + + +def QAOA_ansatz_for_Ising( + params: list, + nlayers: int, + pauli_terms: Tensor, + weights: list, + mixer: str = "X", + gap: int = 5, +) -> Circuit: + """ + Construct the QAOA ansatz for the Ising Model. + The number of qubits is determined by `pauli_terms`. + + :param params: A list of parameter values used in the QAOA ansatz. + :param nlayers: The number of layers in the QAOA ansatz. + :pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :param mixer: mixer type. The options are "X", "XY_ring", "XY_par_ring", "XY_full", and "QAMPA". + """ + nqubits = len(pauli_terms[0]) + c = Circ(nqubits) + for i in range(nqubits): + c.h(i) # Apply Hadamard gate to each qubit + + for j in range(nlayers): + # cost terms + for k in range(len(pauli_terms)): + term = pauli_terms[k] + index_of_ones = [] + for l in range(len(term)): + if term[l] == 1: + index_of_ones.append(l) + if len(index_of_ones) == 1: + c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) + # Apply Rz gate with angle determined by weight and current parameter value + elif len(index_of_ones) == 2: + c.exp1( + index_of_ones[0], + index_of_ones[1], + unitary=G._zz_matrix, + theta=weights[k] * params[2 * j], + ) + # Apply exp1 gate with a custom unitary (zz_matrix) and angle determined by weight and current parameter value + else: + raise ValueError("Invalid number of Z terms") + + # standard mixer + if mixer == "X": + for i in range(nqubits): + c.rx( + i, theta=params[2 * j + 1] + ) # Apply Rx gate with angle determined by current parameter value + # Parity ring XY mixer + elif mixer == "XY": + pairs = [] + for index in [0, 1]: + while index + 2 <= nqubits: + pairs.append([index, index + 1]) + index += 2 + for pair in pairs: + c.exp1(pair[0], pair[1], unitary=G._xx_matrix, theta=params[2 * j + 1]) + c.exp1(pair[0], pair[1], unitary=G._yy_matrix, theta=params[2 * j + 1]) + c.exp1(nqubits - 1, 0, unitary=G._xx_matrix, theta=params[2 * j + 1]) + c.exp1(nqubits - 1, 0, unitary=G._yy_matrix, theta=params[2 * j + 1]) + + # XY mixer with full couplings + elif mixer == "XY_full": + for q0 in range(nqubits - 1): + for q1 in range(q0 + 1, nqubits): + c.exp1(q0, q1, unitary=G._xx_matrix, theta=params[2 * j + 1]) + c.exp1(q0, q1, unitary=G._yy_matrix, theta=params[2 * j + 1]) + + # Parity ring ZZ mixer + elif mixer == "ZZ": + pairs = [] + for index in [0, 1]: + while index + 2 <= nqubits: + pairs.append([index, index + 1]) + index += 2 + for pair in pairs: + c.exp1(pair[0], pair[1], unitary=G._zz_matrix, theta=params[2 * j + 1]) + c.exp1(nqubits - 1, 0, unitary=G._zz_matrix, theta=params[2 * j + 1]) + + # ZZ mixer with full couplings + elif mixer == "ZZ_full": + for q0 in range(nqubits - 1): + for q1 in range(q0, nqubits): + c.exp1(q0, q1, unitary=G._zz_matrix, theta=params[2 * j + 1]) + + else: + raise ValueError("Invalid mixer type.") + + return c diff --git a/tensorcircuit/templates/conversions.py b/tensorcircuit/templates/conversions.py index 2fc92463..513a79a5 100644 --- a/tensorcircuit/templates/conversions.py +++ b/tensorcircuit/templates/conversions.py @@ -2,11 +2,13 @@ helper functions for conversions """ -from typing import Any, Tuple +from typing import Any, Tuple, List +from ..cons import backend import numpy as np Tensor = Any +Array = Any def get_ps(qo: Any, n: int) -> Tuple[Tensor, Tensor]: @@ -36,3 +38,201 @@ def get_ps(qo: Any, n: int) -> Tuple[Tensor, Tensor]: res.append(res_t) wts.append(w) return np.array(res), np.array(wts) + + +def QUBO_to_Ising(Q: List[list]) -> Tuple[List[list], list, float]: + """ + Cnvert the Q matrix into a the indication of pauli terms, the corresponding weights, and the offset. + The outputs are used to construct an Ising Hamiltonian for QAOA. + + :param Q: The n-by-n square and symmetric Q-matrix. + :return pauli_terms: A list of 0/1 series, where each element represents a Pauli term. + A value of 1 indicates the presence of a Pauli-Z operator, while a value of 0 indicates its absence. + :return weights: A list of weights corresponding to each Pauli term. + :return offset: A float representing the offset term of the Ising Hamiltonian. + """ + + # input is n-by-n symmetric numpy array corresponding to Q-matrix + # output is the components of Ising Hamiltonian + + n = Q.shape[0] + + # square matrix check + if Q[0].shape[0] != n: + raise ValueError("Matrix is not a square matrix.") + + offset = ( + np.triu(Q, 0).sum() / 2 + ) # Calculate the offset term of the Ising Hamiltonian + pauli_terms = [] # List to store the Pauli terms + weights = ( + -np.sum(Q, axis=1) / 2 + ) # Calculate the weights corresponding to each Pauli term + + for i in range(n): + term = np.zeros(n) + term[i] = 1 + pauli_terms.append( + term.tolist() + ) # Add a Pauli term corresponding to a single qubit + + for i in range(n - 1): + for j in range(i + 1, n): + term = np.zeros(n) + term[i] = 1 + term[j] = 1 + pauli_terms.append( + term.tolist() + ) # Add a Pauli term corresponding to a two-qubit interaction + + weight = ( + Q[i][j] / 2 + ) # Calculate the weight for the two-qubit interaction term + weights = np.concatenate( + (weights, weight), axis=None + ) # Add the weight to the weights list + + return pauli_terms, weights, offset + + +def QUBO_from_portfolio(cov: Array, mean: Array, q: float, B: int, t: float) -> Tensor: + """ + convert portfolio parameters to a Q matrix + :param cov: n-by-n covariance numpy array + :param mean: numpy array of means + :param q: the risk preference of investor + :param B: budget + :param t: penalty factor + :return Q: n-by-n symmetric Q matrix + """ + n = cov.shape[0] + R = np.diag(mean) + S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n)) + + Q = q * cov - R + t * S + return Q + + +class StockData: + """ + A class for converting real-world stock data to an annualized covariance matrix and annualized return. + + Attributes: + - data: A list of continuous stock data in the same time span. + - n_stocks: The number of stocks in the data. + - n_days: The number of trading days in the data. + + Methods: + - __init__(self, data): Initializes the StockData object. + - get_return(self, decimals=5): Calculates the annualized return. + - get_covariance(self, decimals=5): Calculates the annualized covariance matrix. + - get_penalty(self, cov, ret, risk_pre, budget, decimals=5): Calculates the penalty factor. + """ + + def __init__(self, data): + """ + Initializes the StockData object. + + :param data: A list of continuous stock data in the same time span. + """ + self.data = data + self.n_stocks = len(data) + + # Check the number of days + n_days = [len(i) for i in data] + if max(n_days) != (sum(n_days) / len(n_days)): + raise Exception("Timespan of stocks should be the same") + self.n_days = len(data[1]) + + # Calculate the daily percentage price change + self.daily_change = [] + for i in range(self.n_stocks): + each_stock = [] + for j in range(self.n_days - 1): + each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j + 1]) + self.daily_change.append(each_stock) + + def get_return(self, decimals=5): + """ + Calculates the annualized return (mu). + + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The annualized return as an array rounded to the specified number of decimals. + """ + change = [[j + 1 for j in i] for i in self.daily_change] + ret = np.prod(change, axis=1) ** (252 / self.n_days) + return ret.round(decimals) + + def get_covariance(self, decimals=5): + """ + Calculates the annualized covariance matrix (sigma). + + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The annualized covariance matrix rounded to the specified number of decimals. + """ + mean = np.mean(self.daily_change, axis=1) + relative_change = [ + [j - mean[i] for j in self.daily_change[i]] for i in range(6) + ] + cov = 252 / self.n_days * np.dot(relative_change, np.transpose(relative_change)) + return cov.round(decimals) + + def get_penalty(self, cov, ret, risk_pre, budget, decimals=5): + """ + Calculates the penalty factor. + + :param cov: The annualized covariance matrix. + :param ret: The annualized return. + :param risk_pre: The risk preference factor. + :param budget: The budget (number of stocks to select). + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The penalty factor rounded to the specified number of decimals. + """ + # Get all feasible and unfeasible states + self.f_state = [] # Feasible states (number of '1's equal to budget) + self.uf_state = [] # Unfeasible states + self.all_state = [] + for i in range(2 ** self.n_stocks): + state = f"{bin(i)[2:]:0>{self.n_stocks}}" + n_ones = 0 + for j in state: + if j == "1": + n_ones += 1 + self.all_state.append(state) + if n_ones == budget: + self.f_state.append(state) + else: + self.uf_state.append(state) + + # Determine the penalty factor + mark = False + penalty = 0 # Initial value + while mark == False: + R = np.diag(ret) + S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( + np.ones(self.n_stocks) + ) + Q = risk_pre * cov - R + penalty * S + F = [] + for state in self.f_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget ** 2) + Fmin = np.amin(F) + Fbar = np.mean(F) + F = [] + for state in self.uf_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget ** 2) + Fmin_uf = np.amin(F) + location = np.where(F == Fmin_uf)[0][0] + if Fmin_uf < 0.5 * (Fmin + Fbar): + n_ones = 0 + for j in self.uf_state[location]: + if j == "1": + n_ones += 1 + penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 + else: + mark = True # Ready to return the penalty + return round(penalty, decimals) + + From 1fd57f719b3a5967e6129383ef7e364a845945f3 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Jul 2023 10:13:58 +0800 Subject: [PATCH 537/725] add keras3 example --- CHANGELOG.md | 2 + examples/keras3_tc_integration.py | 95 +++++++++++++++++++++++++++++++ 2 files changed, 97 insertions(+) create mode 100644 examples/keras3_tc_integration.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 46eacacd..9fd51e43 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,8 @@ - Add benchmark example showcasing new way of implementing matrix product using vmap +- Add keras3 example showcasing integration with tc + ## 0.10.0 ### Added diff --git a/examples/keras3_tc_integration.py b/examples/keras3_tc_integration.py new file mode 100644 index 00000000..ba45363c --- /dev/null +++ b/examples/keras3_tc_integration.py @@ -0,0 +1,95 @@ +""" +keras3 is excellent to use together with tc, we will have unique features including: +1. turn OO paradigm to functional paradigm, i.e. reuse keras layer function in functional programming +2. batch on neural network weights +""" + +import os + +os.environ["KERAS_BACKEND"] = "jax" +import keras_core as keras +import numpy as np +import optax +import tensorcircuit as tc + +K = tc.set_backend("jax") + +batch = 8 +n = 6 +layer = keras.layers.Dense(1, activation="sigmoid") +layer.build([batch, n]) + +data_x = np.random.choice([0, 1], size=batch * n).reshape([batch, n]) +# data_y = np.sum(data_x, axis=-1) % 2 +data_y = data_x[:, 0] +data_y = data_y.reshape([batch, 1]) +data_x = data_x.astype(np.float32) +data_y = data_y.astype(np.float32) + + +print("data", data_x, data_y) + + +def loss(xs, ys, params, weights): + c = tc.Circuit(n) + c.rx(range(n), theta=xs) + c.cx(range(n - 1), range(1, n)) + c.rz(range(n), theta=params) + outputs = K.stack([K.real(c.expectation_ps(z=[i])) for i in range(n)]) + ypred, _ = layer.stateless_call(weights, [], outputs) + return keras.losses.binary_crossentropy(ypred, ys), ypred + + +# common data batch practice +vgf = K.jit( + K.vectorized_value_and_grad( + loss, argnums=(2, 3), vectorized_argnums=(0, 1), has_aux=True + ) +) + +params = K.implicit_randn(shape=[n]) +w = K.implicit_randn(shape=[n, 1]) +b = K.implicit_randn(shape=[1]) +opt = K.optimizer(optax.adam(1e-2)) +# seems that currently keras3'optimizer doesn't support nested list of variables + +for i in range(100): + (v, yp), gs = vgf(data_x, data_y, params, [w, b]) + params, [w, b] = opt.update(gs, (params, [w, b])) + if i % 10 == 0: + print(K.mean(v)) + +m = keras.metrics.BinaryAccuracy() +m.update_state(data_y, yp[:, None]) +print("acc", m.result()) + + +# data batch with batched and quantum neural weights + +vgf2 = K.jit( + K.vmap( + K.vectorized_value_and_grad( + loss, argnums=(2, 3), vectorized_argnums=(0, 1), has_aux=True + ), + vectorized_argnums=(2, 3), + ) +) + +wbatch = 4 +params = K.implicit_randn(shape=[wbatch, n]) +w = K.implicit_randn(shape=[wbatch, n, 1]) +b = K.implicit_randn(shape=[wbatch, 1]) +opt = K.optimizer(optax.adam(1e-2)) +# seems that currently keras3'optimizer doesn't support nested list of variables + +for i in range(100): + (v, yp), gs = vgf2(data_x, data_y, params, [w, b]) + params, [w, b] = opt.update(gs, (params, [w, b])) + if i % 10 == 0: + print(K.mean(v, axis=-1)) + +for i in range(wbatch): + m = keras.metrics.BinaryAccuracy() + m.update_state(data_y, yp[0, :, None]) + print("acc", m.result()) + m.reset_state() From acf53b9310206c82a0b552ce9012cfd70c674378 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Thu, 13 Jul 2023 15:35:05 +0800 Subject: [PATCH 538/725] update imag_time_evo.ipynb --- docs/source/tutorials/imag_time_evo.ipynb | 324 ++++++++++++---------- 1 file changed, 182 insertions(+), 142 deletions(-) diff --git a/docs/source/tutorials/imag_time_evo.ipynb b/docs/source/tutorials/imag_time_evo.ipynb index 27bcd5ed..5d53e17d 100644 --- a/docs/source/tutorials/imag_time_evo.ipynb +++ b/docs/source/tutorials/imag_time_evo.ipynb @@ -77,24 +77,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "b0def04d", - "metadata": { - "ExecuteTime": { - "end_time": "2023-07-11T11:16:06.492676700Z", - "start_time": "2023-07-11T11:16:06.134350200Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": "('complex128', 'float64')" - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, + "outputs": [], "source": [ "import tensorcircuit as tc\n", "from tensorcircuit import experimental\n", @@ -104,11 +90,25 @@ "import networkx as nx\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "import cotengra as ctg\n", + "import time\n", "from functools import partial\n", "from IPython.display import clear_output\n", "\n", "K = tc.set_backend('jax')\n", - "tc.set_dtype(\"complex128\")" + "tc.set_dtype(\"complex128\")\n", + "\n", + "# cotengra package to speed up the calculation\n", + "opt_ctg = ctg.ReusableHyperOptimizer(\n", + " methods = [\"greedy\", \"kahypar\"],\n", + " parallel = True,\n", + " minimize = \"combo\",\n", + " max_time = 20,\n", + " max_repeats = 128,\n", + " progbar = True\n", + ")\n", + "\n", + "tc.set_contractor(\"custom\", optimizer=opt_ctg, preprocessing=True)" ] }, { @@ -159,19 +159,19 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 3, "id": "f1532831", "metadata": { "ExecuteTime": { - "end_time": "2023-07-11T11:16:06.657240900Z", - "start_time": "2023-07-11T11:16:06.173235900Z" + "end_time": "2023-07-13T02:33:37.851074700Z", + "start_time": "2023-07-13T02:33:37.537921300Z" } }, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgQAAAGFCAYAAACCBut2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVhUXdfG7wm6QQEl7QBbUcSmFLDz8bFRsbAD48HuwsbuDmxFUQwMsAULwSBUVLpjZn1/+DIfSM0MM2Ds33VxAefss/Y6zDD7PmuvvTaHiAgMBoPBYDD+arjl7QCDwWAwGIzyhwkCBoPBYDAYTBAwGAwGg8FggoDBYDAYDAaYIGAwGAwGgwEmCBgMBoPBYIAJAgaDwWAwGAD44jQSCoX49OkTNDQ0wOFw5O0Tg8FgMBgMGUBESE5ORuXKlcHlFh8DEEsQfPr0CSYmJjJxjsFgMBgMRtkSGRkJY2PjYtuIJQg0NDREBjU1NUvvGYPBYDAYDLmTlJQEExMT0TheHGIJgtxpAk1NTSYIGAwGg8H4zRBnup8lFTIYDAaDwWCCgMFgMBgMBhMEDAaDwWAwwAQBg8FgMBgMMEHAYDAYDAYDTBAwGAwGg8EAEwQMBoPBYDDABAGDwWAwGAwwQcBgMBgMBgNMEDAYDAaDwQATBAwGg8FgMMAEAYPBYDAYDDBBwGAwGAwGA0wQMBgMBoPBABMEDAaDwWAwwAQBg8FgMBgMAPzydoDB+N1IzczBh9hUZOUIocjnwlxPDWpK7F+JwWD83rBPMQZDDN7GJONgYAT833xFRFwaKM85DgBTXVW0r6WPf5ubooaBRnm5yWAwGFLDISIqqVFSUhK0tLSQmJgITU3NsvCLwfgliIxLwyyfYNwO+w4elwOBsOh/l9zzratXwJLu9WCiq1qGnjIYDEZBJBm/WQ4Bg1EERx5EwG7tTdx9FwsAxYqBvOfvvouF3dqbOPIgQu4+MhgMhqxgUwYMRiFs9H+LVVdCpbpWICQIhASPU8H4npKJce1ryNg7BoPBkD0sQsBg/MSRBxFSi4GfWXUlFEdZpIDBYPwGsAgBg5GHyLg0zD37osjzwqx0JAWeQuanN8j6HAphRgr0nCZCvb5dkdd4nn2BltUqsJwCBoPxS8MiBAxGHmb5BCOnmFwBYVoSEu8cRnZsJBT0q4hlM0dImOUTLCsXGQwGQy6wCAGD8T/exiTjdtj3Ytvw1HVhPG4/eOo6yPz8Fl/2TirRrkBIuB32HWFfk1Fdny1JZDAYvyYsQsBg/I+DgRHgcTnFtuHwFcBT15HYNo/LwYH7LJeAwWD8ujBBwGD8D/83X0tcWigtAiHBP/SrXGwzGAyGLGCCgMEAkJKZg4i4NLn2ERGbhtTMHLn2wWAwGNLCBAGDAeBjbCrkExv4fwjAh9hUOffCYDAY0sEEAYMBICtH+Ef1w2AwGJLCBAGDAUCRXzb/CmXVD4PBYEgK+3RiMACY66mh+PUFpYfzv34YDAbjV4QJAgYDgJoSH6ZyriQoSIzBqOFDceDAAcTExMi1LwaDwZAUVpiIwfgf7WvpY3/gxxKXHiY9OgdhRioEKXEAgPSwIOQk/yhopNmkM7jKBaMAXA5QU0uAF/df4MCBAwCAhg0bwtHREY6OjrCxsYGioqKM74jBYDDEh0NEJSZXS7KfMoPxu/I2Jhn2XrdKbBe1eRgESYXXFDAatRN8bYNCz/lNaoPq+hr4+vUrrl69Cl9fX1y5cgUxMTFQU1ND+/bt4eDgAEdHR9SoUQMcjrwnMRgMxp+OJOM3EwQMRh4G7gzE3Xexsi1QREI0N9fG0VGtC5wSCoV4/vw5rly5Al9fXwQEBCArKwvm5uZwdHSEg4MDbG1toaWlJTt/GAzGXwMTBAyGlETGpcFu7U1kymx5IIFyspF5ag42r1yIHj16FNs6NTUVN27cgK+vL3x9fREaGgoej4cWLVqIpheaNGkCHo8nI/8YDMafjCTjN0sqZDDyYKKriqH1ZLkSgINp7c3Qol4N9OzZE//88w++fy96AyU1NTU4Oztj/fr1ePPmDd6/f4/NmzfDwMAAq1evRvPmzaGvr4++ffti165diIqKkqGvDAbjb4ZFCBiMPNy8eROdO3eGaaeRSKnavtT2Uu8ehiU3GmfPnsXZs2fh7u4OBQUFeHt7o3v37hLZysnJQWBgoGh6ISgoCEQECwsLUe5BmzZtoKKiUmq/GQzGnwGbMmAwpODChQvo1asXbGxscPr0aZx/FYc5Ps+RnSMAhyfBghwSQkmBjwVdLGCUGQEnJyfUq1cPFy9eRHp6OkaNGoUzZ86gX79+2LBhAypUqCCVv3FxcfDz8xNNL0RHR0NZWRlt2rQR5R9YWFiw5EQG4y+GCQIGQ0KOHDmCgQMHwtnZGUeOHIGysjLS0tJQt1lrqLUfjlQNU/C4nGKTDXPPp79/jI2DbNDbqQMAICgoCI6OjqhevTp8fX2ho6ODQ4cOlSpa8DNEhFevXonEwc2bN5GRkQEjIyNR9MDOzg56enql6ofBYPxeMEHAYEjAtm3bMGrUKPz777/YtWsXFBQUAABz587FsmXLEBISAmga4mBgBPxDvyIiNi3/RkhEUMxOQv+2DfBvc1P829kWABAYGCh6On/y5Ans7e1hbGyMq1evomLFivj8+TNGjRqFs2fPol+/fti4caPMBuz09HTcvn1bNL0QEhICDoeDpk2bipITmzdvLrpXBoPxZyLR+E1ikJiYSAAoMTFRnOYMxm/DihUrCACNHTuWBAKB6Hh4eDgpKSnRrFmzClzz6FkIKehXoT3nblBIdAJN9ZhNhoaGJBQKiYjI39+fANDRo0fzXRcSEkIGBgZUp04d+vTpExERCYVC2r9/P+no6JC+vj6dOnVKLvcZFRVFu3btor59+5Kuri4BIE1NTerevTtt2bKF3r17J5d+GQxG+SLJ+M0EAeOvRCgU0uzZswkAzZo1SzSY59KlSxcyNjamlJSUAtfeuXOHANDLly+JiMjHx4cAUGRkpKiNi4sLVa1alTIzM/Nd++bNGzIyMqLq1avTx48fRcc/ffpEnTt3JgD0zz//0Pfv32V5u/nIycmhoKAgWrhwIbVq1Yp4PB4BoBo1atC4cePo3LlzlJycLLf+GQxG2cEEAYNRDAKBgMaNG0cAaPny5QXOX7hwgQDQsWPHCr3+3LlzBIA+f/5MRETR0dEEgE6ePClqExISQlwul9avX1/g+vDwcDI3NyczMzMKDw8XHS+raMHPJCQkkI+PD40aNYqqVKlCAEhBQYHatWtHS5cupcePH+eLnjAYjN8HJggYjCLIzs6mgQMHEofDIW9v7wLnMzIyqHr16tShQ4cCUYNc9u7dSwAoIyNDdMzY2JhmzJiRr52rqytVqFCBEhISCtiIiIigGjVqkJGREb1+/TrfubKMFvyMUCik0NBQ2rBhA3Xu3JnU1NQIAOnr69OAAQNo37599OXLlzLzh8FglA4mCBiMQkhPT6du3boRn8+nQ4cOFdpmyZIlxOfz6cWLF0XaWbt2LampqeU71qNHD2rfvn2+Y1FRUaSiolJoHgLRj4G/bt26ZGBgQMHBwfnO5Y0WGBgYkI+Pjxh3KHsyMzPJ39+fPDw8qFGjRgSAAFDDhg1pxowZdO3atXzCiMFg/FowQcBg/ERycjLZ2tqSsrIynTt3rtA2kZGRpKqqSpMmTSrWlqenJ5mYmOQ7tmzZMtLQ0KCcnJx8x2fNmkUqKioUFRVVqK2vX79SgwYNSE9Pjx4/flzgfN5oQf/+/cs0WlAYMTExdODAARo4cCAZGBgQAFJTUyNnZ2dav349vXnzpsjICoPBKHuYIGAw8hAXF0ctWrQgdXV18vf3L7Jd3759ycDAoNAQf17GjRtH9evXz3fs+vXrBKBAZCEhIYEqVKhArq6uRdqLjY2lZs2akba2Nt2/f7/AeaFQSPv27SNtbe1yjRb8jEAgoCdPntDy5cupQ4cOpKioSADI3NycRo4cSSdPnizxb8lgMOQLEwQMxv/48uUL1a9fn3R1dSkoKKjIdrkD+t69e0u02b9/f2rXrl2+Y4mJicThcGj37t0F2q9fv564XC6FhIQUaTMhIYFatmxJGhoadPv27ULb/GrRgp9JSUmh8+fPk7u7O9WsWZMAEI/HIxsbG5o/fz7dv3+/QASFwWDIF0nGb1aYiPHH8vHjR9jb2yMlJQVXrlyBpaVloe2ys7PRqFEjaGlp4fbt2+Byi9/zq1OnTlBVVcXJkyfzHbewsEDbtm2xefPmfMezsrJQt25d1KlTB+fOnSvSbkpKCrp06YLAwECcPXsWtra2BdoQEQ4cOIDx48dDSUkJW7duRdeuXYv1t7z48OGDqDDStWvXkJiYCF1dXdjZ2YlKKxsbG5e3mwzGHw0rTMT463n9+jWZmJhQlSpVKCwsrNi2a9euJQ6HU+gcfmE0b96chg8fXuD4kCFDqEmTJoVec/ToUQJQ7JQFEVFaWho5OjqSkpISXbhwoch20dHR5OLi8stGC34mOzubAgICyNPTk5o3b04cDocAUN26dWnSpEl0+fJlSktLK283GYw/DjZlwPirefLkCVWsWJHq1q1bZDJfLp8/fyZNTU0aPXq02PZr1KhB06ZNK3B88+bNxOfzKT09vcA5oVBIzZo1o2bNmpWYdJeRkUFdu3YlBQWFYmsR/JxbcPr0abHvobyJjY2lo0eP0rBhw8jIyIgAkJKSEtnb29OqVasoODiYJScyGDKACQLGX0tAQABpaWlRkyZN6Nu3byW2Hzx4MOnp6VFsbKzYfejp6dHSpUsLHH/48CEBoHv37hV63Y0bNwotaVwYWVlZ1KdPH+LxeHT48OFi2+aNFvz7778S3cuvgFAopBcvXtCaNWvI0dGRlJWVCQAZGRnR0KFD6fDhw798BITB+FVhgoDxV+Lr60uqqqrUpk0bsd6ruSWIt27dKnYfAoGAuFxuoddkZmaSkpISrVu3rsjriyppXBi5RZS4XC7t2bOn2LZCoZD27t37W0YLfiYtLY2uXLlCU6ZMIUtLSwJAHA6HmjVrRnPmzKHbt29TVlZWebvJYPwWMEHA+Os4efIkKSoqkpOTk1hz0Tk5OdSoUSNq3LixRJnvCQkJBICOHz9e6PkWLVrQv//+W+T1uSWNixMNeREIBDRixAgCUGhlxZ+Jjo4mZ2fn3zZaUBi5GzP169eP9PT0RBszdevWjW3MxGCUABMEjL+KPXv2EJfLpb59+4r15E1E5O3tTQDo7t27EvX17t07AkB+fn6Fnh8/fjzVqFGjWBvFlTQuDKFQSO7u7gSAvLy8xGr/p0QLfqa4jZnGjh1LZ8+eZRszMRh5YIKA8dewbt06AkAjRowQ+0n/+/fvpKurS0OGDJG4v9w8gaJWJBw4cIAAFPtkXlJJ48IQCoU0ffp0AlBo/kJh5I0WDBgw4I+IFvxMSRszPXr0iG3MxPirYYKA8ccjFAppwYIFBICmTp0qUUb6qFGjSFNTU6pNeq5cuUIA6MOHD4WeDw0NJQDk6+tbrJ2SShoXhlAopLlz5xIAmjt3rlj3LBQKac+ePaSlpUWGhoZ05swZsfv73ShuY6Z///2XbczE+CthgoDxRyMUCmny5MkEgBYtWiSRGHj06BFxOByxQu+FkVtPICkpqUjftLW1aeHChcXaEaekcVEsXbqUAND06dPFvveoqKg/PlrwM8VtzDR9+nS2MRPjr4AJAsYfS05ODrm6uhIAWr9+vUTXCgQCsra2JktLS8rOzpaq/y1bthCPxyt2IHZwcKDOnTuXaEucksZF4eXlRQDI3d1d7JD4z9GCs2fPStzv70xhGzOpqqqSs7MzrVu3jl6/fs1qHzD+OJggYPyRZGZmUp8+fYjL5Yq158DP7NmzR6xqgcWxePFiqlixYrFt5syZQwYGBiUOLpmZmVStWjVycXGRypfcxMgRI0ZINE8eFRVFTk5Of1W04GeK2pjJzMyMbczE+KNggoDxx5GamkqdOnUiRUXFYqv3FUVCQgLp6+tTv379SuXHlClTqFatWsW2OXv2LAGgjx8/lmhP3JLGRZG7wmLgwIESRT3+9mjBzxS1MVPLli3ZxkyM3xomCBh/FAkJCdS6dWtSVVWlK1euSGVj4sSJpKamRpGRkaXyZdiwYWRtbV1sm8+fPxdbqyAvkpQ0LoojR44Qj8ej3r17S1ywh0ULCuf9+/e0detW6tGjB2lpaREA0tHRod69e9OOHTtK/T5iMMoKJggYfwzfvn2jxo0bk7a2Nt25c0cqGyEhIcTj8cRerlcc3bp1IycnpxLbmZqa0tSpU8WyKUlJ46I4deoUKSgoUNeuXSVOlBMKhbR7927S0tKiSpUq/fXRgp/Jzs6mO3fuiDZm4nK5bGMmxm8DEwSMP4KoqCiqU6cO6evr09OnT6WyIRQKqX379lSjRg2ZZJS3adOGBgwYUGK7Xr16UZs2bcS2K0lJ46K4cOECKSkpUceOHaUaoPJGCwYOHEhxcXFS+/InwzZmYvxOMEHA+O0JCwsjc3NzMjExoTdv3khtJ3eO/tKlSzLxy9LSksaPH19iuxUrVpCqqqrY8/qSljQuCj8/P1JVVaX27dtLVbGPRQsko6iNmSpXrkxDhgxhGzMxyh0mCBi/NcHBwWRoaEg1a9YUKzGvKJKTk8nY2Ji6du0qM9+MjIxo3rx5JbbLnQZ4/vy52LYlLWlcFLdu3SINDQ2ysbGR2lbeaMGgQYNYtEBMituYafbs2XTr1i22MROjTGGCgPHbEhgYSDo6OtSgQYNSV5WbOXMmKSkpyXTzGxUVFbGe4pOTk4nL5dKOHTvEti1NSeOiuH//Pmlra1PTpk2lThT8OVpw7ty5Uvv1t1HSxkzh4eHl7SLjD4cJAsZvyfXr10ldXZ2sra1L/UT65s0bUlBQoLlz58rGOfrx9AeA9u/fL1Z7S0tLGjlypER9SFPSuCgeP35Menp61KBBA/r69avUdiIjI6lTp04sWlBKitqYqXr16r/NxkwpGdkUEp1Ajz/GUUh0AqVkSFfgi1F2SDJ+c4iIUAJJSUnQ0tJCYmIiNDU1S2rOYEjMuXPn0Lt3b7Rp0wY+Pj5QU1OT2hYRwcnJCa9fv8bLly+hoqIiEx8/ffoEIyMjXLhwAU5OTiW2d3V1xePHj/HkyROx+0hMTET16tXRtWtX7NixozTuAgBevHgBW1tb6Orq4tq1a6hUqZJUdogIe/bswaRJk6Cqqopt27bBxcWl1P79zSQmJsLf3x++vr7w9fXF+/fvoaCgABsbGzg4OMDR0RENGzYEl8stVz/fxiTjYGAE/N98RURcGvIOGBwAprqqaF9LH/82N0UNA43ycpNRBJKM3+X7TmMwABw6dAjdu3eHk5MTzp07VyoxAPwQF5cvX8batWtlJgYAID4+HgCgq6srVnsrKysEBwcjLS1N7D60tLTg6emJ3bt348WLF1L5mRcLCwvcunULSUlJaNOmDSIjI6Wyw+FwMHToUISEhKBhw4bo3LkzBg8eLPqbMCRHS0sL3bp1w5YtWxAeHo7Q0FCsWbMGGhoaWLx4MZo0aYJKlSphwIAB2L9/P758+VKm/kXGpWHgzkDYe93C/sCP+PiTGAB+bA7xMS4N+wM/wt7rFgbuDERknPjvd8avBYsQMMoVb29vjBkzBoMGDcKOHTvA5/NLZS8jIwN169ZFjRo1cPnyZXA4HBl5Cty+fRtt2rTB69evUatWrRLbP3nyBI0bN0ZAQABsbGzE7icrKwt169ZFnTp1cO7cudK4LOLdu3ewtbUFAFy/fh1VqlSR2lZutGDixIlQV1fHtm3b4OzsLBM/GT/IysrC3bt3RdGD3ChTgwYN4OjoCEdHR9jY2EBJSUku/R95EIG5Z18gR0gQCEscIkTwuBzwuRzM72KBfs1M5eIbQzJYhIDxW7B8+XKMHj0a48aNw65du0otBgBg5cqViIqKwvr162UqBgAgLi4OgPgRAktLSygrKyMoKEiifhQVFbFkyRKcP38eN27ckNTNQqlatSpu3boFPp+P1q1bIzQ0VGpbudGCFy9eoH79+nBxcWHRAhmjqKiIdu3aYenSpXj8+DFiYmJw4MAB1K9fH3v37hVNAzk7O2P9+vV48+YNxHi2E4uN/m/hcSoYmTlCicQAAAiEhMwcITxOBWOj/1uZ+MMoO1iEgFHmEBFmz56NpUuX4r///sP8+fNlMnh/+PABderUwfjx47F8+XIZeJqf3bt3Y9iwYcjOzhZbvNjY2MDU1BSHDx+WqC8iQvPmzQEAgYGBMhM3nz9/hq2tLeLi4nDt2jVYWFiUyh6LFpQ9QqEQz58/x5UrV+Dr64uAgABkZWXBzMwMjo6OcHBwgK2tLbS1tSW2feRBBDxOBcvM1+U96qEvixSUKyxCwPhlEQqFGDt2LJYuXYpVq1ZhwYIFMhvspkyZAl1dXcyZM0cm9n4mPj4empqaEkUyrKysJI4QAD+ewleuXIkHDx7g+PHjEl9fFJUqVcKNGzdgYGCAdu3a4enTp6WyV1i0YMiQISxaIEe4XC4aNmyI6dOn49q1a4iLi8P58+fRpUsX3Lx5E7169UKFChVgY2ODBQsWIDAwEAKBoES7kXFpmHu26LyV7LhofDuzHFGbBiNiVU9EbxuFhIDDEGZnFHmN59kXLKfgN4IJAkaZkZ2djUGDBsHb2xvbtm3DlClTZGb7ypUrOHXqFFatWgUNDflkOsfFxUFHR0eia6ysrPDu3Tt8//5d4v7atm0LFxcXzJw5E1lZWRJfXxT6+vrw9/eHubk52rdvL5Vg+RljY2NcvHgRO3fuhI+PDywtLXHhwgUZeMsoCTU1NdHUwevXr/H+/Xts3rwZhoaGWLNmDVq0aIGKFSuiT58+2LlzJ6Kiogq1M8snGDlFTBHkJH3Dl72TkRn9BhqNXaBjNwJKRrWRGHAQ38+sLNK3HCFhlo/sIg4M+cIEAaNMyMjIQK9evXD06FEcPnwYI0aMkJntrKwsjB8/Hm3atEG/fv1kZvdn4uLixM4fyMXKygoA8ODBA6n6XLZsGT58+ABvb2+pri8KXV1d+Pn5oW7durCzs0NAQECpbXI4HAwbNgwhISH5ogUJCQmld5ghNubm5hg5ciROnjyJ79+/486dO3B3d0dERARGjhwJExMTWFhYYNKkSbh8+TLS0tLwNiYZt8O+F5kzkBriD2FmKvR7z4WWdW9oNOyICs4ToWbZAelhgRBkpBR6nUBIuB32HWFfk+V5ywwZwQQBQ+6kpKTA2dkZV65cwZkzZ9C3b1+Z2l+3bh3CwsKwYcMGmScS5kUaQVC1alXo6upK/RRuYWGBoUOHYuHChUhMTJTKRlFoaWnB19cXTZs2haOjI65duyYTuyYmJvmiBRYWFrh48aJMbDMkg8/no2XLlpg/fz7u37+Pb9++4ejRo2jRogWOHz+OTp06QVdXF71nrQenwKLC/0eY9SPsz1PTznecp64LcLjgcIueRuNxOThwP0Im98OQL0wQMORKXFwc7Ozs8ODBA/j6+opV0EcSPn36hAULFmDs2LGoX7++TG3/THx8vMSCgMPhSJ1HkMv8+fORmpqKFStWSG2jKNTV1XHhwgW0bt0azs7OuHTpkkzs5o0W1KtXD87Ozhg6dCiLFpQzurq6oqmDyMhIvHjxAkuXLkWqljkIRYtpZdN6AIDYi+uRFfMOOUnfkPrqFpKfXIRGk87gKioXea1ASPAP/Srze2HIHiYIGHLjy5cvaNeuHcLCwnD9+nW0adNG5n1Mnz4dKioqmD9/vsxt/4w0OQTA/ycWSrsszMjICJMmTcLatWsRHR0tlY3iUFFRwZkzZ+Do6IiuXbvi9OnTMrNtYmKCS5cuYceOHTh16hSLFvxCcDgc1K1bFyPGuCNHSbvYtipVm0Cr9QBkfHiKz7vHI3rzUHw/swIaTTpD167k6b+I2DSkZubIyHOGvGCCgCEXPnz4gFatWiE2Nha3bt1C06ZNZd7HrVu3cPDgQSxbtkyqJVaSIs2UAfBDEHz//h0fPnyQuu/p06dDTU0Nc+fOldpGcSgpKeHEiRPo1q2bKNdDVnA4HLi6urJowS/Kx9jUYiYL/h++lgGUTCyg23EcKnafBbX69ki6ewxJj0ounkUAPsSmltpXhnxhgoAhc16/fo3WrVuDiBAQEIC6devKvI+cnBy4u7vDysoKQ4YMkbn9wpBWEDRr1gwASjVtIOuSxoWhoKCAQ4cOoX///ujfvz/27t0rU/s/RwssLS1ZtOAXICtHWGKb1Jc3EXd5I/Q6jYdGw45QrdUSFZwmQK2eLRJu7IEgPUkm/TDKFyYIGDLl8ePHaN26NbS0tHD79u1SlcgtDm9vbwQHB2Pjxo1lsvmLQCBAYmKiVIJAX18f5ubmpV7e5+bmhipVqsDDw6NUdoqDz+djz549GDZsGIYMGYJt27bJ1H7eaIGlpSWLFvwCKPJL/v9JfnwRigZVwdeskO+4anUrUHYmsmLeyaQfRvnCXiGGzAgICED79u1RpUoV3Lx5E5UrV5ZLP1+/fsV///2H4cOHi56+5U1iYiKISKocAkD6AkV5kUdJ48LgcrnYunUrxo0bBzc3N6xbt07mfRQWLZBVQiNDPGJiYrBhwwaM+rdnifktgrQEEBV8wifh/woeCYsvfMQBYK5Xuk3LGPKHCQKGTPD19YWDgwMaNWqEa9euQU9PT259zZo1CxwOB0uWLJFbHz8j6T4GP2NlZYVHjx4hJ6d0iVW9e/dGs2bNMH36dJnVri8MLpeL9evXY9q0aZg4cSKWLVsm8z5+jhY4OTlh2LBhLFogJ759+4bdu3ejY8eO0NHRgaGhIcaPH4+AG9dAycWvAlDQqYysmHBkx+VPak19eRPgcKFQ0bzY6031VKGmVPq9Shjyhb1CjFJz4sQJ9O/fH46Ojjh27JhMtxz+maCgIOzcuRObNm1ChQoVSr5ARshCEKSnp+PFixdo0KCB1H7kljRu164djh8/jj59+khtS5y+li9fDlVVVcycORMZGRmYO3euzGs95EYLdu7cicmTJ+PKlSvYvn07OnXqJNN+/ja+f/8OPz8/HD16FAEBAfmqZWpqasLe3h49evSAUCjEuoB3yFCvAA6XV6gtzeY9kf7uEb4cmAGNJs7gqWgiLSwIGe8eQb2BA/gaRT8A8LgctK+pL/P7Y8getrkRo1Ts2rULI0aMQN++fbF3714oKCjIrS+hUIgWLVogOzsbDx8+BI9X+IeXPPD19UXHjh0RGRkJY2Njia9PTU2FpqYmvL29ZVKlsXPnznj58iVevXoFRUXFUtsriWXLlmHmzJmYPn06li1bJrcCUBERERgxYgSuXLmCoUOHYs2aNWWyguRPIDY2Fjdu3MDJkyfh7++PL1++iM4pKyujYcOG6NmzJ3r37g1lZWV4e3tj8+bN+Pr1K0wsmoHbufgVLJmf3iAh4BCyY95BkJ4MvrYB1C1todmiZ5FCIhe/SW1QXV8+JcUZxSPJ+M0iBAyp8fLywqRJk+Dm5oZNmzbJfYDevXs3Hjx4gICAgDIVA8D/RwikzSFQU1ODpaUlgoKCZCIIli1bhvr168Pb2xvjx48vtb2S8PDwgLKyMiZNmoSMjAx4eXnJRRSYmpri8uXLLFogBnFxcbh16xbOnz8PX1/ffHsU8Hg8WFhYoEuXLujduzcaNGgALpeLp0+fYt68eTh06JCoTXJyMlI/h8NCMQ3ROWpFli9WqlwLBn0kq/fB43LQsqoeEwO/CUwQMCSGiLBgwQLMmzdP7k+MucTHx8PDwwMDBgyAjY2NXPsqjLi4OCgqKkJVVVVqG7JILMwlb0njwYMHQ0tLSyZ2i2PixIlQVlbG6NGjkZGRgS1btshlhQeHw8Hw4cPh4OCA4cOHi3ILVq9e/VdHC+Lj43H79m1cuXIFFy9exPv37/OdNzMzQ6dOndCzZ0/Y2NiIpu4EAgHOnTsHLy8v3LhxA0ZGRnB2dsadO3cQHByMCRMmYObMmUgWKsJu7c0iBYE08LkcLOleT2b2GPKFJRUyJIKIMHnyZMybNw9LlizB8uXL5S4GAMDT0xMZGRlyKd8rDrk1CEpzr1ZWVggJCUFqqmwKtMizpHFRjBo1Crt378aOHTswdOjQUidJFoepqSl8fX2xbds2HD9+/K9biZCYmIjz589j4sSJqFWrFnR1ddG1a1ds2rQJ79+/h56eHvr27YujR4/i27dv+PDhA7Zs2QI7OzuoqKggOTkZ69evR61atdCtWzdkZGRg6tSpUFNTw+nTp+Ho6IjQ0FAsX74c2traMNFVxfwuFjK9hwVdLGCiK72IZpQtLELAEBuBQICRI0di165d2LRpE8aMGVMm/T579gybN2/GihUrUKlSpTLp82ek2cfgZ6ysrCAUCkW1GkqLkZERJk+ejDVr1mDMmDEwMjIqtU1xGDJkCJSVlTFgwABkZGTgwIEDcssd4XA4GDFiBBwdHf/4aEFSUhJu374Nf39/XL58GS9fvgQRgcPhgIigoqKC1q1bo2vXrnBwcEC1atUKFajv37/Hhg0bsHPnTqSlpaF3796YOXMm9u7di1WrVsHW1hZHjhxBo0aNClybFuyH+Ju+0Gk7qNT3M82hFvo2My21HUbZwSIEDLHIzMxEv379sHfvXuzfv7/MxAARYdy4cahVq1aZzJUXhbT7GOTFwsICqqqqMps2AORf0rgo+vXrh+PHj8PHxwe9e/dGZmamXPsrLFpw+fJlufYpb5KTk3Hp0iXMmDEDjRo1gra2NlxcXODl5YUXL16Ay+XCyspKtFNhUlISfH19MWbMGFSvXj2fGCAi3Lp1Cz169ED16tWxd+9ejB07Fv7+/hAIBBg+fDgSEhJw6dIlXL16tVAxcO3aNbi5uaFfPW0s7V4PfA6BBJJFgHhcDpT4XCzvUQ9j21cv9d+IUbawCAGjRNLS0tCjRw/4+/vj5MmT6Nq1a5n1fejQIQQEBODq1atyXcFQEtKWLc4Ln89HkyZNZCoINDU14enpiYkTJ2LixImwtLSUme2S6N69O06fPo0ePXqgW7duOHXqlFyXnP4cLejUqROGDRuGNWvWlEkORWlJSUnBnTt34O/vj2vXruHx48cQCoXg8/miqZeaNWvCyckJ9vb2aNOmDdTV1Yu1mZmZiaNHj8LLywtPnjxB7dq1sXnzZjg5OWH16tXo0KEDKlasiF27dmHQoEFFJuO+fPkSPXv2RIcOHbBx40bweDwsGjcACk37IV3LDDwOICgmtYCEAnC4PLSsqocl3euxaYLfFRKDxMREAkCJiYniNGf8QSQkJFCrVq1ITU2N/Pz8yrTvxMREMjQ0pF69epVpv4VhY2NDgwcPLrWdKVOmkLm5eekdykNmZiZVq1aNnJ2dZWpXXPz8/EhVVZXat29PycnJZdKnUCikbdu2kYaGBhkbG9OlS5fKpF9JSElJIV9fX5o5cya1aNGCeDweASBFRUXicrkEgPT19WnQoEG0f/9++vTpk9i2Y2JiaMGCBWRoaEgAqGPHjnT58mVKSUmh5cuXk5aWFmloaNDixYspNTW1WFtfvnwhc3NzsrS0pISEBCIiOnHiBAGg27dvU+iXJHLdfJkqj9xGpjPOkZnHedGXucd5arPiOlXtPYNc+g8v1d+LIR8kGb+ZIGAUydevX6lRo0akra1N9+7dK/P+p06dSioqKvTx48cy7/tn6tatS5MmTSq1naNHjxIAiomJkYFXBe36+/vL1K643Lp1izQ0NMjGxkY0qJQFHz9+JHt7ewJAw4YNK9O+fyY1NZWuXr1Ks2fPppYtW4oEgJKSEikqKhIAUlVVJRcXF/Ly8qIXL16QUCiUqI9nz57RsGHDSElJiVRUVGjUqFH08uVLEggEtG/fPjIxMSE+n09jx44V6z2WlpZGzZs3J0NDQ9H/mUAgoPr165Otra2o3bp160hBQYE4Csp08OJNevwxjkKiEyglI5uIiDZs2EA8Ho+ioqIkuh+G/GGCgFFqIiMjqXbt2mRgYEDPnj0r8/5fvXpFfD6fFi1aVOZ9F4ahoSEtWLCg1Hbev39PAOj8+fMy8Or/EQqF1KxZM2rWrJnEg4ysuH//Pmlra1OzZs0oNjZWrGtSMrIpJDqhwAAjCUKhkLZu3Urq6upkbGxMly9fltiGNKSlpdG1a9dozpw51KpVK+Lz+QSAlJWVSU1NjQAQj8cja2tr8vT0pFu3blFmZqbE/QgEAjp79ix16NCBAJCRkREtW7ZM9De+evUqNWzYkABQjx496M2bN2Lb7dWrF6moqNCDBw9Ex0+ePEkA6NatW6Jjw4cPp2rVqhEACg0NLWArMTGR1NXVac6cORLfH0O+MEHAKBWhoaFkZmZGpqamhf7zyxuhUEh2dnZUtWpVSk9PL/P+C/NHUVGRNm7cKBNbFStWJE9PTxl4lp8bN24QADp69KjMbYvL48ePSU9Pjxo0aEBfv34ttE3olySaeyaE2qy4TuZ5ws95Q9Bzz4RQ6Jckifr+8OED2dnZEQBydXWVebQgPT2d/P39ydPTk9q0aUMKCgoEgFRUVEhHR4c4HA4BoFq1atHYsWPp9OnTpfIhOTmZNmzYQNWrVycAZGVlRYcPH6asrCwiInr+/Dl17NiRAJC1tTUFBARIZH/GjBnE4XDIx8dHdEwgEFCDBg2oQ4cO+do2b96cWrduTQAoPj6+UHvjxo0jfX19ysjIkMgPhnxhgoAhNc+fPycDAwOqVasWRURElIsPuU8o586dK5f+fyYlJYUA0KFDh2Riz9nZmTp27CgTWz/j4uJCVatWlepJVFYEBweTgYEB1a1bN9+8eERsKg3YcZ/MPM5T1VkX8gmBn79yzw/YcZ8iYoufA8+LLKMFGRkZdOPGDZo3bx61bdtWFPZXUVEhfX19kSCoWLEi/fPPP7Rz506ZTG+9f/+epkyZQlpaWsTj8ahv3775puyioqJo2LBhxOVyqXr16nTixAmJo0Lbtm0jALRmzZp8x318fAgA3bx5U3RMIBCQmpoadevWjRQUFIrs69WrVwSA9u/fL5EvDPkiyfjN9jJgiLh//z6cnJxgZmYGX19f6OuX/YYkaWlpqFOnDurVq4fz58+Xef+FERUVBRMTE1y+fBmOjo6ltrdgwQKsW7cO379/l3lRpxcvXqB+/fpYu3ZtuS7TfPPmDWxtbaGqqopr167hzhfC3LMvkCMkiSrh8bgc8LkczO9igX4SrGn/+PEjhg8fDj8/P7i6umL16tUlrkTIzMxEUFAQ/P39cePGDdy7dw8ZGRlQVVWFrq4uEhISkJKSAmVlZbRp0wb29vaws7ND/fr1S12xkYhw584deHl5wcfHB1paWhg5ciTGjh0LExMTAD8+h1esWIE1a9ZATU0Nnp6ecHNzk3gvi6tXr6JTp05wc3PDxo0bRe9BIkLjxo2hra0Nf39/Uft3796hWrVq+Pfff3H9+nV8+vSpSNsODg5ITExEYGCgFH8FhjxgexkwJOb69evo0qULGjZsiPPnz5db0Zdly5bhy5cvuHbtWrn0Xxil3cfgZ6ysrBAXFyf6oJUl5VHSuDBq1aqFW7duoUOHDmg9ajFQv7NUdgT/ExAep4LxPSUT49rXEOs6MzMz0T4IU6ZMga+vL3bs2JFP0GVlZeHBgwciAXD37l2kp6dDTU0N+vr60NTUREZGBtLT02FgYIABAwbA3t4eLVu2hLKyslT38zNZWVk4duwYvLy88OjRI9SqVQsbN27EoEGDoKamBgDIzs7Gtm3bMH/+fCQnJ2PSpEmYMWOGVK9tSEgIevXqBQcHB6xbty6fID179iyePn2aTwwAQHBwMIAfy2YrVqxYrH13d3d06dIFQUFBsLKyktg/RvnCChMxcObMGTg5OcHGxga+vr7lJgbCw8OxYsUKTJs2DdWr/zpFTUq79fHPNGvWDABkWo8gL+VR0rgwqlatiunep6UWAz+z6koojj6IELs9h8PByJEjERISgtq1a6Njx47o0qULPD094eDgAB0dHbRq1QrLli1DZGQkDAwMwOPxRKWlu3XrhmPHjuHbt294+PAhli5dig4dOshEDHz//h2LFy+Gubk5Bg4cCD09PVy8eBEvX77E6NGjoaamBiLCqVOnYGFhAXd3dzg7O+Pt27dYsmSJVGLgy5cvcHZ2hrm5OY4ePQo+//+fB4kI8+fPR9u2bdGuXbt81wUHB0NHRwdpaWklCgInJydUqVIFGzdulNg/RvnDBMFfzsGDB9GzZ0+4uLjg7NmzoqeS8mDSpEnQ19fHzJkzy82HwpC1INDT00O1atXkJghySxqvXbsW0dHRculDHCLj0rDuzmex2ibePYqPy1zwaUfxFTA9z75AZFyaWDazs7Nx//59HD58GBwOB4qKijh37hwWLlyIN2/ewMzMDKqqqkhNTcW3b9/QpEkTbNq0CWFhYXj37h22bt2K3r17Q09PT6z+xCEkJAQjRoyAiYkJFi1ahM6dOyMkJAS+vr7o1KmTaOrh3r17aN26NXr27ImqVaviyZMn2L17t1RbbwM/puI6d+6M7OxsXLhwARoa+XcfPH/+PJ48eVJoxcvg4GDUq1cP3759K1EQ8Hg8jBkzBkePHsXXr1+l8pVRfjBB8BezefNmDBw4EIMGDcKRI0egpKRUbr5cvHgR586dE82P/krEx8eDw+HINPwuy50PC6O8ShrnZZZPMHLEyBfISfqOxHvHwFEo+ck7R0iY5RNc+LmcHAQFBWH58uXo1KkTdHV1YW1tjYULFyImJgb16tUTDe4RERFISEjAlClTEBQUhG/fvuHEiRNwc3OT+TSOUCjEhQsXYG9vj3r16uHixYvw9PREZGQktm7dCguL/99Q6O3bt+jVqxdatmyJlJQUXLlyBZcvX0aDBg1K1f+AAQPw8uVLnD9/voCoICLMmzcPrVu3LhAdACQTBAAwbNgw8Hg8bNu2TWqfGeUDEwR/KUuXLsXYsWMxfvx47NixI1/4sKzJzMzEhAkTYGtri549e5abH0URFxcHLS2tIsu+SoOVlRUeP36M7OxsmdnMS25J4927dyMkJEQufRTH25hk3A77LlYCYbz/TihVrgVFw5KniQRCwu2w7wj7moycnBw8ePAAK1euhLOzM3R1ddG8eXMsWLAA3759Q8OGDVGtWjWkpaXh+fPnyM7OxuDBg3Hx4kWsW7cOycnJ2LNnD+Lj42X62uaSkpKCzZs3o06dOnBxcUFCQgIOHjyI9+/fY+bMmahQoYKo7bdv3zB+/HjUrVsXgYGB2Lt3Lx49egR7e/tS+zFjxgycPn0aR44cQePGjQucv3DhAh4/fox58+YVSHLNzMxEaGioRIJAV1cXAwYMgLe3t9ze3wz5wATBXwYRwcPDA7NmzcLcuXOxdu1auexpLwlr1qzBhw8fsH79+jLZSllSZLGPwc9YWVkhIyNDroO1m5sbqlSpAg8PD7n1URQHAyPA45b8WmZEhCDt9R3o2I4U2zYHhD6zN0JPTw9WVlaYO3cuYmNj0aJFCzRu3Bg5OTl49OgR3r9/j9atW+PgwYP48uULnj17htWrV6NTp04YP348goODUbNmTTg6OmLEiBFISkoqzS2LiIiIwPTp02FiYgJ3d3c0aNAAd+7cQVBQEPr3759vVUB6ejqWLl0q2pBo4cKFCA0NLXbfAUnw9vbGqlWr4OXlhc6dC+Zy5OYOtGrVCu3bty9w/tWrVxAIBLCwsEBsbKxYggAAxo0bh+joaJw+fbq0t8AoQ9gqg78IoVCIsWPHwtvbG2vWrMGkSZPK2yVERkZi0aJFoqejXxF5CIJGjRqBx+MhKCio0J3nZIGioiKWLFmCvn374saNG4WGg+WF/5uvJUYHSChA3FVvqDdwgKK+udi2CRwkqhmjXbt2SExMxLNnzxAYGAgNDQ20a9cOQ4YMgb29PWrVqlWswDQ3N8fVq1exbds2TJ06VbQSwcHBQWxfRD4R4d69e/Dy8sKpU6egrq4uWjZoZmZWoL1AIMD+/fvx33//4cuXLxgzZgz++++/fFGD0nL58mWMGzcO7u7uRS5BvXjxIh4+fIirV68W+rfKXWFgbGwMgUAgtiCoX78+2rRpgw0bNqB3797S3wSjTGERgr+E7OxsDBw4ENu2bcPOnTt/CTEAAFOnToWGhka5znWXRHx8vMwFgYqKCurXry/XPAIA6N27N5o1a4Zp06ZBKBTKta9cUjJzECFG4l/Kk0vISfoG7TYDJe4jR1kHF69cQ05ODiZMmICAgADExsbi7NmzcHd3R+3atcWKNnE4HLi5ueWLFowcOVLsaEF2djYOHTqE5s2bw8bGBk+fPsW6desQFRWFFStWFCoGrly5gsaNG2Po0KFo0aIFXr16hXXr1slUDDx//hx9+vRBp06dsHbt2kLb5EYHbGxsYGtrW2ib4OBgmJmZISMjAwDEFgTAjyWIt2/fxrNnzyS/AUa5wATBX0BGRgZ69uyJ48eP48iRIxg2bFh5uwTgR+2DY8eOYeXKlb90wau4uDiZ1SDIi7wTC4EfA97KlSvx8OFDHD9+XK595fIxNhUlZQ4I0pOQcPsgtFv2BU9V8mRNDoeDO89DERAQgHnz5sHGxqZU22PnRgu2bNmCw4cPw9LSEleuXCmyfWxsLJYuXQpzc3P8+++/0NLSwvnz5/H69WuMHTu20G2Lnz17BkdHRzg6OkJDQwP37t3D8ePHZb7E9tOnT3B2dkb16tVx+PDhIqceLl++jAcPHmDu3LlFiqe8CYWAZIKga9euMDIyYksQfyOYIPjDSU5OhpOTE/z8/HD27NlfJnyXnZ0Nd3d32NjYYMCAAeXtTrHIY8oA+CEIXrx4geTkZJnbzkvbtm3h4uKCWbNmISsrS659AUBWTsmRiIRb+8FVUYdGU+lrFCgoqUh9bWFwOByMGjUKwcHBqFGjRqHRgpcvX8LNzQ3GxsaYP38+nJycEBwcjKtXr8LZ2bnQfJzIyEgMGTIEjRo1wocPH3Dq1Cncvn0bLVq0kKn/AJCamorOnTuDiHDu3LlChQnw/9EBa2tr2NnZFWmvNIJAQUEBo0ePxsGDB0VLdxm/NkwQ/MHExsbC1tYWjx49gq+vLzp27FjeLonYuHEjXr9+na906q+KPAUBEeHx48cyt/0zy5Ytw4cPH+Dt7S33vhT5xX+sZMdFI+WpLzSadIEgOQ45CTHISYgBCbJBQgFyEmIgSC9ZJJXUj7SYm5vDz89PFC2wsLDA4sWL4ejoCAsLC5w7dw5z5sxBZGQktm/fDktLy0LtJCYmYubMmahZsyYuXryIjRs3IiQkBN27d5fLe14gEKB///4IDQ3FhQsXYGRkVGRbX19fBAYGFhsdiI+PR3R0tEgQcLlcif8PRowYAYFAgF27dkl0HaN8YILgD+Xz589o164d3r9/D39/f7Ru3bq8XRLx5csXzJ07F6NGjULDhg3L250SkUcOAQDUqVMHampqcp82APKXNE5MTJRrX+Z6aihuuBMkxwIkRLzfVkR7u4q+sj69QU5cNKK9XZF453CxfXD+14+84HA4GDhwIDw8PBAXF4c5c+bg8ePH2LZtGz58+IDZs2cX+bSclZWF9evXo1q1ali3bh2mTp2KsLAwjBkzplTTGiUxdepUnD9/HkePHi22bkFudKBFixbFJlDmJhTmCoIKFSpIvCJJX18fffv2xaZNmyAQCCS6llH2sFUGfyDv37+HnZ0dMjMzcfv2bdSuXbu8XcqHh4cHFBUVsXDhwvJ2pUSys7ORlJQklxwCHo+Hpk2bltlGMPPnz8ehQ4ewYsUKLF68WG79qCnxYaqrio9FJBYqVDRDxR6zCxxPuLUfwqx06NqNBF+7UrF9mOqpQk1JPh9fkZGR2LRpE7Zt24bExER069YN5ubm8Pb2xqJFi2Bubl5ofQAiwsmTJzFz5ky8e/cOQ4cOxfz584t9UpcVGzduhJeXFzZu3AgnJ6di2169ehX379/HpUuXio1UBAcHQ0FBAbVq1RK7BkFhuLu7Y//+/bhw4QK6dOkilQ1G2cAiBH8Yr169QuvWrcHhcBAQEPDLiYG7d+9i7969WLJkiVyeumVNQkICANmVLf6ZskgszEXeJY2JCC9evPhR9Cf0PkhY+BMhT1ULqjWtC3xxVTTBVVSBak3r4pchkhDVVTMhxkatEnH//n3069cPVapUwZYtWzBs2DCEh4fj5MmTWL16NV68eIHq1avDwcEBbm5u+XIL7ty5g5YtW6J3796oUaMGnj59ih07dpSJGLhw4QImTJiAiRMnYuzYscW2za1KaGVlVeLOncHBwahduzYUFBTw9etXqQVBs2bN0Lx5c5Zc+BvABMEfxKNHj9C6dWvo6Ojg9u3bMDc3L2+X8iEQCDBu3Dg0adIErq6u5e2OWMh6H4OfsbKyQmRkJD5/Fq/mf2mRdUnjz58/Y//+/Rg8eDCMjY1haWn5o49Pj8Hhyr76HwCAw8U+zxGwsLDA5s2bkZKSIrWp7OxsHDlyBC1atIC1tTUePXoELy8vREVFYdWqVfn+h3JXImzevBkHDx5EvXr1sHv3bvTo0QOtWrVCZmYm/Pz8cPHiRdSrV08GN1oyT58+Rb9+/eDi4oJVq1aV2N7Pzw/37t0rtCrhz+QmFAIoVYQA+FGo6OrVq3j9+rXUNhjyhwmCP4Tbt2+jQ4cOqFatGm7evIlKlYoPuZYH27dvx5MnT7Bx40a5lIqVB2UhCADgwYMHcrH/M6UtaZySkoKLFy9i0qRJsLS0ROXKlTFo0CA8e/YM/fv3h6+vL2JjY9HfpQMyPz4FCXLEtm347zJUHr652DY8DtCqegVcOb4PderUgbu7O4yMjDBx4kS8fftW7L7i4uKwfPlyVK1aFf/88w/U1NRw9uxZvHnzBuPGjSuw+U8uXC4Xo0ePxo0bNyAQCDBs2DBRcaOHDx8WuZ5fHkRHR8PFxQU1a9bEoUOHSvyfys0daNasWYkJxkSEkJAQmQmC3r17Q19fn0UJfnGYIPgDuHTpEhwcHNC0aVP4+fn9kqH42NhYzJ49W1SM5XchPj4eAOSSQwAAJiYmMDAwKLNpA0CyksY5OTm4f/8+Fi1ahLZt20JXVxfOzs44efIkmjdvjkOHDiEmJgZPnz7FypUrYWRkhPbt22PMmDH4fnGDWOWLxYWIkJOdhc6GyWjfvj1OnjyJ9+/fY8yYMThw4ABq1qwJJycnXLp0qcgiTK9evcLo0aNhbGyMuXPnwsHBAc+ePcO1a9fQuXPnEpPm0tLSsGjRIrRv3x4pKSno3r07hEIhFi1ahOvXr8vsXksiJSUFLi4u4HK5OHfunFgbgl27dg137twpdmVBLhEREUhKSpKZIFBSUoKbmxv27t0rsxLRDNnDBMFvzrFjx9ClSxc4ODgUuq3pr8Ls2bMhEAiwdOnS8nZFInIjBPISBBwOp0zzCID/L2l84cIF3LhxI985IsLbt2+xefNm9OjRAxUqVIC1tTVWrlwJHR0drF27Fq9fv8bHjx+xc+dO/PPPP9DX10dGRgb+++8/NGzYEI8fP4aOjg5OH9yJJT0bysxvDocDg8gb+KezA+bMmYOcnByYmppi6dKliIyMxK5du/Dlyxc4OTmhdu3aWLduHRITE0FEou2F69atCx8fH8ycORMRERHYuXMn6tevX2LfAoEAO3fuRI0aNbBgwQKMGDEC4eHhOHXqFEJCQlCtWjXY29vDzc1N7nUlBAIB+vXrh/DwcJw/fx6VK1cu8Zrc6EDTpk1LTDoE8q8wICJ8//69VIIA+CFEMzIysHfv3lLZYcgREoPExEQCQImJieI0Z5QRO3bsIC6XS//++y9lZWWVtztF8vDhQ+JwOLRu3brydkVi1q1bRyoqKnLtY+HChaStrU0CgUCu/eRFKBRSs2bNqGnTpvTlyxc6cuQIubq6kpmZGQEgPp9PrVq1ovnz59Pdu3cpOzu7SFvXr1+natWqEZfLJQDUpUsX+vr1q+j8huuhZOZxnkxnnCMzj/NSf228/pZycnJoyZIlxOPxyMbGhj5+/FjgvgICAqhfv37E4/FIUVGRdHR0CAA1atSI9u7dSxkZGRL9nS5evEiWlpYEgPr27Uvh4eEF2gkEAtq0aROpqamRqakpXb16Vew+JMXd3Z14PB5dvnxZ7GuuXbtGAOjcuXNitV+yZAlpaWmRUCik+Ph4AkBHjx6V1mURffr0oZo1a5bpe/1vR5Lxm0UIflPWrFmD4cOHw83NDfv27ZPr+ubSIBQKMW7cOFhYWGDMmDHl7Y7EyKsoUV6srKyQkJCAsLAwufaTS3p6Oq5du4bq1avj4cOHMDQ0RL9+/XDv3j107doV586dQ1xcHG7fvg1PT09YW1sXuj12bGwshg0bhg4dOiAqKgrKysrYs2cPTp8+ne9pckzbatB5exEcQTZ4Es4g8LgcKPG5WN6jHsa2rw4ej4eZM2fi1q1biIqKQoMGDeDj4yNqz+FwYG5ujipVqkBDQwNZWVlIS/ux/FFHRwdaWlpib/X9+PFj2Nvbw8nJCTo6OggMDMSRI0dQtWrVAm25XC7GjBmD4OBgVK1aFfb29hg1apTMowXr16/Hhg0bsGnTphJXCeRC/4sONGnSBM7OzmJdExwcDEtLS3A4HKmqFBaFu7s7QkNDcfXq1VLbYsgBWSsMhnwRCoXk6elJAMjDw4OEQmF5u1Qsu3fvJgB048aN8nZFKsaPH0+WlpZy7SM2NpYA0P79++ViXyAQ0KNHj2j58uVkZ2dHysrKBIAMDQ3JyMiIKlasSO/evRPbnlAopAMHDlCFChVISUmJAFDr1q3p/fv3hbZfu3YtAaDjF6/TgB33yczjPFWddaHYaEDu+QE77lNEbGqhduPi4qhnz54EgMaMGUO3bt2if/75h/h8PmloaNCkSZMoPDycMjIy6MCBA9S8eXMCQObm5rRixQqKjY0t1O6HDx9owIABBIBq165NZ86ckej/TF7RgjNnzhCHw6GpU6dKdN3169cJAJ05c0bsaywtLWnUqFFERHTnzh0CQMHBwRL1WxhCoZAaNmxILi4upbbFEA9Jxm8mCH4jBAIBjR8/ngDQ0qVLy9udEklISCB9fX36559/ytsVqRkwYAC1adNG7v3UqFGD3N3dZWbvw4cPtH37durTpw/p6ekRAFJVVaVOnTrRmjVrKDg4mIRCIYWEhBCXyxV7Oic8PJwcHBwIAGlpaZGCggKtXLmScnJyCm0fGhpKKioq+e4t9EsSzT0TQm1WXiezn6YRzD3OU5uV12numRB6G5NUoj9ZWVk0fPhw4nA4BIBMTExo3bp1RX5WBQUF0cCBA0lRUZGUlZXJ1dWVnj59SkRE8fHxNG3aNFJSUiIDAwPy9vYudqqkJN69e0ft2rUjAOTm5kZJSSXfT1E8fPiQVFVVqUePHhKH29u2bUuNGjUSW9RkZmYSn8+nTZs2ERHR6dOnCQB9+fJFYr8LY8eOHcThcAqdemHIHiYI/kCys7NpyJAhxOFwaMuWLeXtjlhMnDiR1NTUKCoqqrxdkRonJyfq1q2b3Pv5999/qXnz5lJfHx8fT6dOnaLRo0dT9erVCQBxuVxq3rw5zZ49m27cuEGZmZmFXuvq6koVKlSghISEIu1nZWXR8uXLSUVFhbS1tYnP51O9evXo2bNnRV6Tk5NDNjY2VK1aNUpJSSm0TZMWLamv2xRauHk/KehXodjEwtv9TFxcHK1YsYJMTEwIADVr1oyMjY1JRUWFdu7cWeLgFxMTQ4sWLSIjIyMCQFWrViV1dXVSVVWluXPnlmrwzkveaIGZmRn5+flJbCMiIoIqVapEzZo1o9TUwqMlReHv708A6PTp02JfExwcTADo1q1bRES0fft2AlAqcZSXtLQ00tXVpcmTJ8vEHqN4mCD4w8jIyKAePXoQj8ejgwcPlrc7YhEcHEw8Ho+WLVtW3q6UihYtWtCwYcPk3s+6detIUVGxyEH7ZzIzM+nGjRs0e/Zsat68uSihr3r16jR69Gg6efIkxcXFiWUrKiqKVFRUaNasWYWeDwoKogYNGhCXyxUNoNOmTSsxOW/NmjUEgG7evFlkG3Nzc5o5cyZdvnyZANCHDx+Ktfn69WsaM2YMqaqqkqKiIg0ZMoSePHlCRESpqak0YsQIAkD//PNPiZ9XuVMf+vr6BEA0jbJo0SKKiYkp9lpJCQ8PF0ULRo0aJbbgSEpKovr165OpqSl9/vxZ4n7btWtHDRs2lGjK49ChQwRA9P5ZsmQJ6erqStx3cUyfPp20tbWLFIoM2cEEwR9ESkoKOTg4kJKSEp09e7a83RELoVBI7dq1o5o1a0qU0f0rUqtWLZoyZYrc+7l37x4BoAcPHhR6XigUUnBwMK1Zs4acnJxITU2NAJCenh716dOHtm/fXuQcvjjMnj2bVFRU8kVzkpKSaPz48cThcMjMzIxUVVXJzMxMrHyQN2/ekLKyMo0fP77Ydurq6rR69Wp6/vw5AaC7d+8WaCMUCunKlSvk5OREAEhfX5/mzZtXZAj7yJEjpKmpSVWrVqWgoKBC29y8eZOaNWtGAMjFxYVevHhBT58+JVdXV1JWViZFRUUaNGhQka+HNAgEAtq4caPY0YLs7Gzq1KkTaWpqSjV/f/PmTQJAPj4+El03c+ZMMjY2Fv0+adIkqlWrlsT9F8f79++Jy+XS1q1bZWqXURAmCP4Q4uPjqWXLlqSurk7Xr18vb3fE5siRIwRAomVRvyoVK1akxYsXy72f9PT0fPO2RETR0dG0d+9eGjBgABkaGhIAUlJSIjs7O1q2bBk9evRIZsu3EhMTqUKFCuTq6kpEPxLYjI2NSVVVVbTkbvDgwWJ9BuTk5JC1tXWxUwVEP+4ZAO3bt4++f/9OAOjEiROi82lpabRt2zaysLAgANSgQQPas2ePWCIzPDycrKysiM/n08qVK0V/p5cvX1KXLl0IADVp0oT8/f0LXBsbG0srVqwQLcFs3rw5HThwQOzojTi+lRQtEAqFNHr0aOLxeHTlyhWp+unQoQM1aNBA4sRjFxcX6tixo+j3AQMGUKtWraTyoTi6du1KlpaWv3xi9O8OEwR/ADExMdSwYUPS0dGh+/fvl7c7YpOcnExGRkZlMu8ub4RCIfF4vDLL2WjYsCF16NCBJkyYQHXr1hWFsRs1akTTp0+nK1euUFpamtz6X79+PXG5XLKzsxMNmBUqVCA9PT06efKk2HZWrVpFHA5HNAddFJGRkQSALl68SEKhkBQVFWn9+vUUHR1Ns2fPJj09PeJwONS1a1fy9/eXeODIysqi6dOnEwBq3749DRo0iHg8Hpmbm9OhQ4dKFFM5OTl0+vRpsrW1JQBkYGBAnp6eFB0dLZEfhZEbLciNuly7di3f+dzplm3btkll/9atWwRAotctFzMzM5o2bZrod0dHR+revbtUfhSHn5/fb70C6XeBCYLfnIiICKpZsyYZGhrKZKlPWeLh4UHKysoSLWP7Vcl938uiIEthZGdn0927d2n+/PnUunVrUR6Aqakpubq60pEjR/IV+JEnAoGANmzYQBwOhxQVFUWDoJOTk0Rz169fvyZlZWWaOHFiiW0fP36cb5qkUqVKZGFhQXw+n9TV1WnChAkUFhYm9T0R/RCoAwYMIA6HQxwOh0aNGiXVNNaLFy9o9OjRpKamRnw+n/r160d37twp9dNteHg4tW3bNl+0wMfHhzgcDs2YMUNqu7a2tlSvXj2JI0i57/l9+/aJjjVu3JhGjhwptS9FIRQKqU6dOtSzZ0+Z22b8P0wQ/Ma8efOGTE1NydzcvNQfhmXNmzdvSEFBgebNm1fersiEDx8+EACpQ7Y/IxQK6fXr17Rx40bq2rUraWpqipbvde/enQYOHEgAKD4+Xib9iUtISAi1bNlSFBXInZrw9vaWaMDLnSqoUaOGWNnwV65cIQC0adMmsrGxIQCkrq5Oa9euLXbFgzhkZ2fTtm3byNDQkBQVFWnUqFHUtm1b4nA4NGvWLKkre8bHx9PatWtFKzkaN25Mu3btovT0dKl9zRstMDQ0JCUlJerVq5fU00EBAQEFpl/EJbfmQG6iJhGRiYkJzZkzRypfSmLTpk3E4/EoIiJCLvYZTBD8tjx79oz09fWpdu3aFBkZWd7uSIRQKKSOHTuSubm5XMPaZUnuE+zDhw+ltvH161c6dOgQDRs2TLRETkFBgdq0aUMLFy6ke/fuiZZzvXjxggAUCB/Li/T0dJozZw4pKChQzZo1aeDAgcThcEhNTY0sLS0lHpBWrlxJHA6HAgICSmwbHx9P/fv3F02LtG3blqytrcnOzk7a2yGiH+/Dc+fOiaZc+vfvL4pWCQQCWrp0KfF4PLK2ti5xRUNxCAQCunDhAnXq1EmU3Onh4VGglLIk3Lp1ixQVFQkAjRgxgpKTk6WyY29vL9XrR0Tk7e1NPB5PFEURCoWkrKwst7LjycnJpKmpWeQKF0bpYYLgN+Tu3bukra1NjRs3LrMwsSw5c+aMVBnNvzK5c5ySTH+kpaWRr68vTZ06lRo2bCga8CwsLGjixIl04cKFIj/oc3JySENDo0yKTl2/fp1q1KhBioqKNHbsWGrUqBHx+XxasGCBqO79kSNHxLb36tUrUlJSokmTJhXbLjQ0lMaNG0dqamrE4/GIy+WKBJe7uztZWFhIfU8PHjwQJeu1a9euyBUCd+/eJTMzM9LW1pbqKfpnQkNDacKECaSpqUlcLpd69Oghcc5DQkICWVpakrm5OS1ZsoRUVVXJ3NxcYnGY+4R/7NgxSW+DiIjGjh1LderUEf2enJxMAOjQoUNS2ROH8ePHU4UKFUoVZWEUDRMEvxlXr14lNTU1at26dalDpeVBWloaValShRwdHf+ojOFjx44RgGJfk5ycHHr48CEtXbqUOnToICrlW6lSJRo0aBDt27ePPn36JHaf7du3l0sCVy7fv3+noUOHisoNz5w5k5SVlal27dr5BlAXFxeqWrWqWJn1OTk51KJFiyKnCoRCIfn5+ZGLiwtxOByqWLEieXp60sSJE8nExETUbunSpaSjoyPxPb1//57++ecfAkB169al8+fPl/g+jI+Pp169eonm7mUR1UpKSqJNmzZRnTp1CABZWlqSt7d3iWvts7KyyN7enrS0tOjly5dERBQWFibKLRg9erTY0QIHBweysLCQerqhTZs21KdPH9Hv7969IwBy3azpzZs3BID27Nkjtz7+Zpgg+I3w8fEhRUVF6tSpk8RVyH4V5s+fTwoKCvT69evydkWmbN26lbhcboEP13fv3tG2bduod+/epKurSwBITU2NnJ2dycvLi0JCQqQWRjNmzCAjIyNZuJ+PvPsPaGlp0fLly0WJg+7u7gXee5KUNF6xYkWhUwVpaWm0Y8cO0bLFevXq5ZtvHzVqFDVq1EjUfu/evQRA7ME5NjaWpkyZQoqKilSpUiXavn27RNX0hEIhbd26lZSVlcnS0pJevHgh9rUl2b169Sp17dqVOBwOaWtr0+TJkwst1SsUCmnkyJHE5/MLRANyEz3FjRbcvXu3VEmwQqGQdHR0aOHChaJjgYGBBEBU3lledOzYkZo0afJHPVD8KjBB8Juwb98+4vF41Lt3b5mtcS5r3r9/T8rKyqXKiP5VWbp0Kenp6VFcXBydOHGCRo0aRdWqVROVBW7RogX9999/dOvWLZm9fidPniQAMi33nHf/gb59+9KWLVtIW1ubKleuXGzCpKurK+np6RUbIXn58iUpKSnlK0P76dMn+u+//6hChQrE4XCoc+fOdO3atQIf9j179iQHBwfR71evXiUAJda4z8jIoFWrVpGOjg6pqanR/PnzS1XxLjg4mCwsLEhFRYW2b98u00Hp/fv3NG3aNNLR0SEOh0MuLi7k6+sr6mPlypUEgHbt2lWkjbCwMGrTpo1oE6eiogWOjo5Ut25dqaMDUVFRBcocnz9/ngDIZKllceT2c+/ePbn28zfCBMFvwMaNGwkAubq6FrkxzO9A9+7dqXLlylInQP2KZGRkkL+/P7Vo0YKUlJREywFr1qxJY8aMIR8fH7mtBMhdmy+LXIy8+w+YmprS0aNHRaH1vn37FrnbXy4llTTOzs4mKysrqlmzJqWlpdGjR49o4MCBpKCgQGpqauTu7k6hoaFF2m/bti31799f9HtuUuXt27cLbS8QCOjgwYNkbm5OPB6PRo0aJbMNd1JTU2nkyJGiv42sp+5SU1Np+/btVL9+fQJAtWrVIldXVwIgVkKdQCCg9evXi6IFPxcqu3//vsR5Hz9z6dKlAoIsd7dSeT+wCAQCqlatWr73A0M2MEHwCyMUCmnx4sUEgCZPnvxbh8hy688fPny4vF0pFUKhkJ49e0arV6+mjh07kqqqKgEgZWVl0tPTo507d5Yqe1xSXypVqkQzZ84slZ28+w9MnjyZzp49S0ZGRqStrS1RglhhJY1zWbZsGXE4HFqyZAm1bt2aAJCZmRmtXr1aLMFUt25dmjBhguj3+Pj4IkPe169fFy2J7Nq1K7169Urse5CEY8eOkaamJlWpUkUuBcGEQiHdvHmTOnToQACIz+fTuHHjxJ5uKypa0KlTJ6pTp06pHi5WrFhBampq+SIMy5cvJy0tLaltSsKaNWtIQUFBqj0bGEXDBMEvilAopGnTphEAWrBgwW8tBjIzM6lmzZrUtm3b3/I+oqKiaPfu3dS/f38yMDAQCQB7e3tasWIFPXnyhLp3756vhGtZ0bVrV7K1tZXq2rz7DzRq1IgCAgJEW2bb2tpKvN7755LGudy/f594PJ6olkKrVq3o5MmTEs3h6+vr55uvFgqFpKKiQl5eXqJjISEh5OzsTADIysqq2I2SZMW7d++oefPmxOfzacWKFTIrD53L+/fvSV9fn5o2bUozZsygihUrEgBycHCgc+fOldhf3mhBlSpVaNOmTTJZCTBw4MACO25OnTqVqlevXiq74hIfH0+qqqo0f/78Munvb4EJgl+QnJwcUUhSXmt6y5IVK1YQj8ej58+fl7crYpGYmEhnz54ld3d3URY4h8OhJk2a0IwZM8jPz6/Asqd27dqVSwhz8eLFpKmpKfFAlHf/gdWrV9P9+/epTp06pKysTF5eXlIPbLkljYODg+nt27c0btw40TTKP//8I9UGQAKBgHg8Hnl7e+c7Xq1aNZo+fTp9+vSJhg8fTlwul6pWrUpHjx4tU+GZlZVFHh4eBIAcHR1lNjURHx9PdevWpapVq4qWF6enp9PevXupadOmBPzYilmcKEveaIG2tnappzkaNmxIw4cPz3ds8ODBZG1tXSq7kuDm5kaVKlX6bXOqfkWYIPjFyMrKon79+hGXy6Xdu3eXtzulJioqitTV1Uvcya48ycrKooCAAJo3bx7Z2NgQn88nAGRubk4jRoygo0eP0rdv34q1Ub9+fRo3blwZefz/5CbXiRsWj46Opp49exIA6tSpE719+5YWLVpEfD6fGjVqVOrs+YyMDKpcuTIZGBiIChcBKNXum7GxsYVW02vRogXVq1ePVFVVSVdXl9auXVuuO2b6+vqSvr4+GRgYlLpiZVZWFtna2pKOjk6hUwRCoZDu3btH/fv3JwUFBVJVVSU3N7diy5fn5g4oKipSlSpVpN4ELTs7m5SUlAo8rDg5OVGXLl2ksikNwcHBpc6FYOSHCYJfiLS0NHJ2diYFBQWpNhr5Fenfvz9VrFixzEvsFodQKKRXr17R+vXrqUuXLqShoSF6curRowdt2bKFwsLCJHrKNDY2Jk9PTzl6XTgJCQkEgPbu3VtsO4FAQFu2bCFNTU3S19enI0eOUGhoKFlbWxOXy6XZs2eX6kkrPT2ddu3aJUqEA0BDhgwhBQWFfJvfSMPr168JgGgKIDs7m7Zs2ULKysrE5XJp+vTpv8z768uXL+Tg4EAcDoc8PDykKnssFArJ1dWVFBQUCt1h8Wc+f/5M8+fPp0qVKokKLRU2JePi4kK1atWiN2/eiLUSoShevnxJAESCIiUjm0KiE6ihbTfqM3IypWSIPxVUWtq1a0c2NjZl1t+fDhMEvwiJiYnUtm1bUlFRIV9f3/J2Rybk7rFe3DKpsuLLly908OBBGjJkCBkbG4vKArdr144WLVpEgYGBpUqyUlNTo7Vr18rOYQmoXbs2jR07tsjzefcfGDFiBMXGxtK2bdtITU2NqlatSnfu3JG678+fP9PcuXNJX1+fAJCzszNduXKFmjRpQqqqqlSrVq1SV5XLrbcfEhJCp0+fplq1ahEAqlOnDlWrVq1UtuWBQCCg5cuXE5/PpxYtWtD79+8lun7p0qViibyfyczMpMOHD4tea1NTU1q6dCl9+/aNHjx4QABo//79Ih/XrVtHKioqVKVKFbGERy5Hjx4lBT0Tmn70AbVZcZ3MPc6TWZ4vc4/z1GbFdZp7JoRCvxTcrlmW5C69ffz4sVz7+VtgguAX4Pv379S0aVPS0tISq7b770B2djbVq1ePmjdvLvNEK3FITU2lS5cu0ZQpU/I9tdarV48mT55MFy9eLNV69LxkZGRI9QEuKwYNGkTNmjUrcDzv/gO1atWimzdv0ufPn8nFxaXUNfCfPHlCgwcPJkVFRVJVVaWxY8fSmzdvROeHDx9OAPIlAkqLj48PASBra2tRwuPjx49pxYoVpKmpWWr78uL+/ftkbm5OWlpaYpcHPnr0KAEodbTp0aNHNGTIEFJSUiIlJSUyMTEhMzOzAlGDt2/filZ9jB07tsT3Q0RsKrXwOEBmHuep6qwL+YTAz1+55wfsuE8RsfIppJadnU0mJiY0bNgwudj/22CCoJyJjo6munXrUsWKFfPtGva7s379euJwOFIlkUlDTk4OBQUF0eLFi6l9+/aijV8qV65MgwcPpgMHDshtidLnz58JAJ07d04u9kti48aNpKCgkG/+PO/+A3PnzqWMjAzy8fGhChUqkL6+vlS+5uTkkI+Pj6hMrqmpKa1cuZLi4uLytQsODiZFRUWqVq2a2CWNiyI8PJyaNWsmKu976dIl0VTOgQMHCMAvXdciPj6eevfuTQDIzc2t2MqKd+/eJSUlJerfv7/MkiK/fv1KY8eOFQliGxsbOnLkSL6pDHGjBYeDPlLNORfJbMbZYoVAYcKg5pyLdDhIPstxlyxZQsrKyvT9+3e52P+bYIKgHAkPD6cqVaqQsbHxH1XKNyYmhrS0tOSyL3pewsPDydvbm3r27Ek6OjoE/NgSt3PnzrRu3Tp6+fJlmWSb5xbJKU3ovTQEBQURAAoMDCyw/8DLly8pMTFRdKxbt24Sb4iVmJhIa9eupSpVqogGlePHjxe6bDArK4uaNGlCderUoUePHold0vhnvn//ThMnTiQFBQXS1NQkNTW1AlM6169fJwDFFjT6FRAKhbRt2zZSUVEhCwsLCgkJKdAmPDycKlasSK1atZJ5YmSXLl2oevXqdOzYMdGGTpUqVaL58+fnWxGRN1owbty4fEJrw/VQiURAUV8brsv+tfr27RspKSnRsmXLZG77b4MJgnLixYsXVLlyZapRo0aptlb9FRk2bBjp6OiUmJkvKbGxsXT8+HEaOXKkaHDi8XjUsmVLmjt3Lt2+fVvqvetLQ+4cd+5mM2VNRkYGKSoq0qBBg0T7D2zbto0EAgHdvHmTzM3NSV1dnXbt2iWRQAoPD6cJEyaQhoYG8fl86t+/PwUGBhZ7zaJFi4jL5YraDR8+vMSSxnlJT08XFbjR0NCgRYsWkbu7O9WqVatA25+TDX91QkJCRGWPt27dKnot4uLiqHbt2lS9enWZ/8/kbsuddzrr+fPnNHLkSFJRUSEFBQX6999/RYWVCosWHA76KBMxkPt1RA6RgiFDhpCpqalEtS0YBWGCoBx48OAB6enpUf369WW2ZvlXIXeDk82bN5faVkZGBl27do08PDyoadOmxOFwRKVcx40bR2fOnPkldnw8e/YsASi31zI8PFxU9Kdv3770+fNnysjIoOnTpxOHw6FWrVqJvS2zUCikGzduULdu3YjD4ZCuri7NmjVLrP0Snj9/TgoKCuTh4SE6Fh0dXWxJ41wEAgHt27ePTE1Nic/n09ixYykmJoaIfhTBadWqVYFrkpKSfrvql2lpaTRq1CgCQL1796aYmBhq37496erqyiXS0a1bN6pevXqhA2VcXBytWrVKJK6bNWtG+/bto4yMDFG0gK9lQFVmnCGTycdJy+YfUq7SmLjK6gSA9JwmFhjsDQetJvVGTqRoUI3A5f2oSPlTm5pzLso8p+DRo0cyK+P9N8MEQRlz48YN0tDQoBYtWhSYe/3dEQgE1LRpU2rYsKFUGfsCgYCePn1KK1euJAcHB1JRUSEApK+vT/3796ddu3ZJXD2vLNizZ0+Z1HD/mbz7D6irq5OxsTER/RiY69evTwoKCrRs2TKxXouMjAzas2cPNWzYkIAfWwNv27ZN7F01s7KyqHHjxlS3bt0CIe/Zs2eTsrIyRUZGFnqtn58fNWrUiABQjx498iUnEv0otdutW7dCr1VTU6PVq1eL5eOvxPHjx0lTU5PU1dVJQUGBbt26JfM+njx5QgBKrGeSk5ND586dE21qpa+vT3PmzKGIiAhq7XmMTKefIaNRO39E5DQrkpJpvSIFgZbNPwQunxQNqxNf16hQQVB11gUasEP2pZ6tra2pQ4cOMrf7NyHJ+M0Fo1RcuHABHTt2hJWVFa5evQodHZ3ydkmm7Nq1Cw8fPsTGjRvB4/HEuiYyMhK7d+9G//79UalSJTRs2BCenp7gcDhYuHAhnj59is+fP+PgwYMYOnQoTExM5HwXkhMXFwd1dXUoKiqWWZ8PHjxAs2bNMHPmTIwePRpr1qxBVFQUFi1ahKZNm0IoFCIoKAgzZswo9rWIiYnB/PnzYWZmhiFDhqBSpUrw9fVFSEgIRowYAVVVVbH8Wb58OZ49e4Y9e/ZASUkp37np06dDXV0dc+fOzXc8ODgYnTp1gp2dHZSVlREQEICTJ0+iZs2a+dp9+/YNFStWLLTfypUr49OnT2L5+CvRq1cvjBgxAikpKRAIBLh79y6EQqFM+1iwYAGqVq2KAQMGFNuOx+PBxcUFvr6+ePXqFfr06QMvLy/UaNoGEVmq4HB54KnrwnjcfhiP2Q2d9sOKtKXR2Akmk46i0hAvqJg3LLSNQEi4HfYdYV+TS3N7BXB3d8f169fx4sULmdplFA4TBKXg6NGj6NatGzp27Ijz589DXV29vF2SKXFxcfDw8MDAgQNhY2NTZLvExEScOXMG7u7uqF27NkxNTeHq6oq3b9/C1dUV169fR1xcHC5fvowpU6agQYMG4HJ/7bdefHx8mYm75ORkTJgwAc2bNweXy0VQUBBWr16NatWqAQD+++8/uLu748GDB2jYsGGRdp49e4Zhw4bB1NQUK1asQI8ePfDq1StcvHgRDg4O4HA4Yvv0/PlzLFiwANOnT0ezZs0KnNfU1ISnpyf27NmDkJAQREdHw9XVFQ0bNkRYWBhOnDiBO3fuFPm++f79OypUqFDoud9VEBw+fBirV6+Gp6cnZsyYgZkzZ6Jjx4748uWLTOw/f/4cPj4+mDNnDvh8vtjX1a5dGxs2bEB0dDQ6uS8GhAIAAIevAJ56ye9xnpoOuApKJbfjcnDgfoTYfolDz549YWhoiE2bNsnULqNwxH9XMfKxfft2uLm5YcCAAdi1a5dE/6C/C56ensjKysLy5cvzHc/OzkZgYCCuXr2Kq1evIigoCAKBAFWrVoWdnR0WLVqEDh06QFdXt5w8Lz1xcXFl4v/Zs2cxduxYxMXFYdWqVRg/fjx4PB727duHcePGgcPhYNiwYVi1alWh1wsEAly4cAFeXl7w9/eHsbExFi5ciOHDh0vtf3Z2NoYMGYKaNWsWiADkxc3NDWvXrkX37t0RHR0NVVVVeHl5wc3NrcTIyp8WIQgICMCQIUMwcOBAzJs3DxwOBx06dMCAAQPQoEED7N+/Hw4ODqXqY8GCBahSpUqJ0YGi0NTURJxSJSA1rVR+FIVASPAP/Yp5sJCZTUVFRbi5uWHVqlVYunQptLS0ZGabUZBf+zHtF2XVqlUYOXIkxowZgz179vyRYuDp06fYsmUL5s2bB0NDQ7x8+RLr169H586doauri9atW2PDhg0wMjLC5s2bER4ejvDwcGzduhW9evX6rcUAIH9B8OnTJ/Tq1Qtdu3ZFvXr18OLFC0yePBkJCQno3bs3Bg8ejO7du6Nt27b4/v17geuTk5Oxfv161KpVC127dkV6ejqOHj2Kd+/eYfr06aXyfdmyZXj+/HmhUwW5ZGdnY/v27YiNjUVYWBi6d++O8PBwuLu7lygG0tPTkZqa+sdECMLCwtCtWzdYW1tj+/btokiMnZ0dnj17hkaNGsHR0REeHh7Izs6Wqo/nz5/j5MmTmD17NhQUFKSykZKZg4g4+YiBXCJi05CamSNTm25ubsjMzMTu3btlapdRECYIJICIMGfOHEybNg2zZ8/Ghg0bfvnQtzQQEUaOHAlDQ0M8ffoUJiYmsLCwwLRp05CamopZs2bhwYMH+PbtG44fP46RI0eiatWq5e22TJGXIBAKhfD29kadOnVw+/ZtHDlyBBcuXIC5uTkuXbqEevXqwd/fH8ePH8fevXvRsmVLBAYGgogAAO/fv8eUKVNgbGyMyZMno1mzZrh37x7u3buHPn36SD1Y5PL8+XMsXLgQM2bMQNOmTQucJyL4+PjA0tIS7u7u6N69O+rXr4/Q0FBoaGiI1UeuwPkTIgRxcXFwdnaGnp4eTp06VUBAGRgY4OLFi1i5ciVWr16N1q1b4/379xL3s3DhQpibm2PQoEFS+/oxNhUk9dXiQQA+xKbK1GalSpXQu3dvbNq0SeY5GYz8/HmPtnJCKBRiwoQJ2LhxI1asWIFp06aVt0syJTU1Fbdu3cLVq1dx4sQJREZGAvgxQPTr1w/29vZo3bq12Alpvzvx8fEyT3Z88eIFRo4cibt372L48OFYvnw5dHV1kZqaiqlTp8Lb2xsdO3bErl27UKlSJQCAlZUVlixZglOnTuHQoUM4ffo0tLS0MGbMGIwdOxbGxsYy8y87OxuDBw9GrVq14OnpWeD8vXv3MG3aNNy5cwcODg44duwYGjRogJs3b6Jdu3Y4fvw4+vbtW2I/uYKguAhBamoqkpOTxRYZ5UFmZia6d++OuLg43L9/v0gByeVyMXXqVLRp0wb9+vVDw4YNsX37dvTp00esfkJCQnDixAls375dLMGXnZ2NhIQEJCQkID4+XvT9xZdUAAaS3KJUZOXIftAeN24cbGxs4Ovri06dOsncPuMHTBCIQU5ODlxdXbF//35s3boVI0eOLG+XSo1AIMCjR49EeQB3795FdnY2jIyMEBcXh+bNm+PMmTMwMJD/B8iviCwjBBkZGVi8eDGWL1+OqlWr4ubNm2jTpg0AIDAwEAMHDkRUVBQ2b96MUaNGiULOWVlZiIj4kaTVq1cv1K5dG5s3b8aAAQOgpqYmE9/ysmTJEgQHByMwMDDfk25YWBhmzpyJEydOoH79+vD19c03H962bVu4uLhg1qxZ6N69u1j5A0DxEQLgx7RKrVq1SntbcoGIMGLECNy/fx/Xr18XJYAWh5WVFZ48eQI3Nzf07dsXfn5+8PLyKiCyiQhpaWmigXz8+PHQ19cHl8vF+vXrER8fn2+gz/2e+5WaWvgTuoJ+FVQetkEm918cinzZR02tra3RuHFjbNiwgQkCOcIEQQlkZmaiX79+OH/+PA4dOoR+/fqVt0tSQUQIDw/H1atX4efnh+vXryMhIQEaGhpo37491qxZA3t7e2zfvh1btmzBsWPH/loxAMhOEPj7+8PNzQ0fPnzArFmzMHPmTCgpKSE7OxuLFi3C4sWL0aRJE5w/f160NO/bt2/w9vbG5s2b8eXLFygpKaFLly44cuSI3Kaonj59ikWLFmHmzJlo0qQJgB9P8gsWLMCWLVtgaGiIPXv2YMCAAYUueVy2bBnq168Pb29vjB8/vti+SooQ5EZHfmVBsHDhQuzfvx+HDh0qdCWFQCBAYmJioYN248aNkZycjF27duHo0aOoV68ecnJy8g30heUauLq6QlFREaqqqlBUVASHwwERITs7GxkZGUhPT8/XXllZGQYGBqhcuTLMzMxgZF4VJ0AAxF9tIikcAOZ6sherHA4H7u7uGDp0KMLCwlC9enWZ98FggqBYUlNT0a1bNwQEBOD06dNwdnYub5ckIjY2FteuXROJgA8fPoDP56NFixaYOHEi7O3tYWVlJUqKfPXqFdatW4d58+bB1NS0nL0vP4RCIeLj40slCGJjYzFt2jTs3r0brVu3xpkzZ1CnTh0AwJs3bzBgwAA8efIEnp6emDVrFvh8PoKDg7Fu3TocOHAAXC4XgwYNwvjx4/Hff//h+/fvchMDWVlZGDJkCOrUqYP//vsP6enp8PLywrJlywD8GPwmTJgAFRWVIm1YWFhg2LBhWLBgAQYPHlxsNvi3b9+goqJSZJQjryAoTzIyMvIN5Lk/X7lyBfv27YONjQ38/Pxw/PjxAk/siYmJRdrV0tKCjo4OatSogcjISNy7dw/16tVD3bp1IRAIkJ2djbS0NCQlJSE0NBTp6emiHJKsrCxkZWWhQoUKMDIygrGxcZHfNTU1Cyw1fbDSHx/lmFhoqqcKNSX5DCt9+/bF1KlTsWnTJqxdu1YuffztMEFQBPHx8XB2dkZwcDAuXbqEdu3albdLJZKRkYE7d+6IpgGePHkCIkKdOnXQpUsX2NnZoV27doXOyxIRxo8fDzMzM0yZMqUcvP91SEpKAhFJVYeAiHDo0CFMnDgR2dnZ2LZtG1xdXcHlckFE2LRpE6ZPnw4TExPcu3cPTZo0wcWLF+Hl5YVr167ByMgI8+bNw4gRI6CnpwfgR6h58eLFEAgEYheHkoQlS5YgJCQE9+7dw+HDhzFnzhx8+fIFY8aMwZw5c4oM7f/M/PnzcfDgQaxYsQKLFy8usl1xNQgAQF1dHZqamqUWBEKhEMnJyYUO6uIcy8jIKNK2srIyvn37hpycHOjo6MDQ0BB16tSBjo4OtLW1oaOjAw0NDQiFQmRmZiI1NRWJiYmIjY3Fp0+fEB0djaioKGRnZ0MoFOLZs2d49uwZeDweKlWqBCMjI1SsWBFPnz5Fjx490LNnTxgbG8PY2BiVK1eGsrKyVH+TdrUqYv+9DxD+L0qQ9OgchBmpEKTEAQDSw4KQk/wjgqPZpDO4ymrISfyKlJDrAIDML2EAgIQ7RwAAfC19qFt2APCjDkH7mvpS+SUOKioqGDFiBDZv3oyFCxf+cXVffgWYICiEmJgYODg4ICoqCtevXy+0MMuvQO4HiZ+fH65evYrbt28jIyMDBgYGsLOzw/jx42FraytW4tmpU6fg5+eH8+fPS/1h86cQF/fjw1HSCMG7d+8wevRoXLlyBX379oWXlxcMDQ0B/HjaHTp0KK5cuYKxY8fC09MTx44dw7///ou3b9/CysoKhw8fRs+ePQskjllZWSE5ORlv3rxB3bp1ZXOT/+Pp06dYvHgx+vbtixEjRuDZs2fo1asXli5dKnFYtnLlypg8eTJWr16N0aNHF/m+K64GQV5bnz59QnZ2tsQDee7PiYmJRWalq6urQ0dHJ98AXqNGjQLHcr/r6OggLi4O3bp1Q4MGDXDq1Cl8+/YNUVFRosE9KioKL1++FB378uWL6Mke+DGg5T69m5qaomXLlqLf37x5g6VLl0JbWxtHjhyBtbU1/vnnH5iYmODw4cOlrpiZk5ODAwcOYPuy9VDsvlB0PCnQB4Kkr6Lf00LvAqF3f/yNLNr/EAQJX5B4+0A+e7m/K5lYigSBQEgY0EK+kcXRo0djxYoVOHDgAEaNGiXXvv5GOJT3HVsESUlJ0NLSQmJiIjQ1NcvCr3IjIiICdnZ2SElJwdWrV2FhIbsiG7IgIiJCFAG4du0avn//DlVVVbRt2xZ2dnawt7eHpaWlRFXp0tLSULt2bTRo0ADnzp2To/e/Bw8fPkSzZs3w5MmTYisD5pKdnY21a9di3rx5qFixIjZv3pxveunYsWMYNWoUlJWVRWv8d+zYgZSUFPTq1QsTJ05EixYtirSflJQEbW1t7Nq1C0OGDJHBHf4gKysLlpaW+Pz5M1JSUmBjY4NVq1YV60tJJCUloVq1aujSpQt27twJIkJqamq+wdrDwwNJSUkYPnx4kYP627dvIRAIkJNT+Jp2Ho9X6KAtzjFtbe0ia4cQEeLj4/MN9NHR0QgLC4OPjw8EAgGUlZULTAno6OiUGMLX0dEp9v/y48eP6N+/PwIDA+Hu7o5169aJEk2lJTMzEzt37sTcuXNFuRt1xmxGppYpBDJcg8jjctCyqh72uzaXndEi6NGjB0JDQxEcHCzR59zfiiTjN4sQ5OHNmzewt7cHn89HQEDAL7G2PiEhATdu3BCJgLdv34LL5aJp06Zwc3ODnZ0drK2tiywgIw5Lly5FTEwMvLy8ZOf4b4wkEYIHDx5gxIgRCA4OxsSJEzF//nxRKDMhIQHjxo3DwYMH0b59e2hoaGDo0KHQ1NSEm5sbxo4dK1auhqamJurUqYOgoCCZCYLIyEh07twZb9++hampKfbt24du3boV+gErEAjyLWMr6elcTU0Nu3btgo+PD5KTk4sc1GfNmlVg0DY3NxcNnCkpKfD09Cx0UFdXV5d4MBAIBIiJicHjx4/zDfa5T/e5P+edKuBwODAwMEBKSgpycnLQt29f1K1bt8CAL4vluGZmZrh58ybmzZuHxYsXQ0lJSeqM+tTUVHh7e2Px4sWIj48HANja2mL9+vXQMDSH3dqbEGQLABkNqHwuB0u615OJrZJwd3dHhw4d4O/vjw4dOpRJn38LLELwP54+fQoHBwdUrFgRV65cgZGRUbn4kZWVhfv374umAYKCgiAUClGtWjXY29vD3t4e7du3l1md/fDwcNStWxfTp0/HwoULS77gL+Do0aPo168fkpKSilwHn5ycjDlz5mDDhg2ideW52fkAcP36dQwaNAhxcXEwNDTE+/fvUatWLUyYMAGDBg2SeNng0KFD8fz5czx69Eiqe0pPT0d8fDwiIyOxceNGHD16FNnZ2ahbty569+6NpKSkIgf65OTCN6zhcDiiBLm8g7WmpiZOnToFQ0NDjB8/vsATe5cuXWBvb4+NGzcW6e+MGTNw8uRJhIWFiXV/GRkZiI6OLjDQ5/3++fNnCAQC0TWKioolPtUbGBhg6NChOHXqFPz9/UsVPRGX169fo27dutDQ0ICysjL27dsHR0dHsa5NSEjAhg0bsHLlStHr1qZNG6xduxaNGzcWtTvyIAIep4Jl5vPyHvXQt1nZJCITEerVq4eaNWvi1KlTZdLn78xfGyFIzczBh9hUZOUIocjnwlxPTayM17t378LJyQk1atTApUuXik14kjVEhJcvX4pWAty4cQOpqanQ09ODra0thg0bBjs7O1SpUkUu/U+aNAmGhoaYOXOmXOz/jsTFxYHP5xeZtJR3/4GVK1diwoQJohB0RkYGJk2aBG9vbygqKiIrKws1atTApk2b4OjoKPVKgaZNm2L//v149eoVMjIyJJpPT0hIQGZmZqF2w8LC4O3tnW/QNjIygoWFRYmhd01NzSLvp2PHjqKn6Z8TcuPj40UrCYqiUqVK+PTpkygxsKhBPvf7z+WdNTU1RYN63bp1YW9vX2DAr1ChQolRhrlz5+LQoUM4duxYmYgBAFi0aBEqV66Me/fuwc3NDR07dsS0adOwaNGiInMJvn79ijVr1mDDhg2iVQktWrTAqlWrCl0W2dWyIkZN3A/tNgOl9pOIwOFwMM2hVpmJAeCHEB03bhzGjh2Ljx8/wszMrMz6/tP57QXB25hkHAyMgP+br4iIS8tXmpMDwFRXFe1r6ePf5qaoYVDwae/q1avo1q0bmjVrhrNnz5ZJBOTz58+iCICfnx8+f/4MJSUltGrVCv/99x/s7OzQqFEjuZdFvnDhAs6dO4cTJ078sRUIpRGJuTUIfh4sPn36hPHjx+PkyZPo1KkTNm/eDHNzc9H5EydOYMSIEUhISACfz8egQYMwceJEUR5KVlaWxAN53gQ5Iio0qVBDQ6PAoF2nTh1oa2tDW1sbHz58wMWLF/H161c4OTlBR0cHhw8fRkBAgNwGud69e2PVqlWYNm0aAgMDRe9loVCI2NhYVKhQAUKhsEBiXu73x48fIz09HZqamgUK7ejr64sG9byJeXm/y6LC4b59+7BgwQIsW7YMvXv3LrU9cXjz5g0OHz6M9evXw8TEBOfPn8fatWvh4eGBGzdu4MiRI/mmMiMjI7Fq1Sps3boVOTk5EAgEaNSoEVauXIkOHToUKXhevnyJxLtHMX38aOwNSUOOkCAQip9UwONyQAIBvl/aDPNW7gDKti7AgAED4OHhgS1btoiWxzJKz287ZRAZl4ZZPsG4HfYdPC6n2Ddz7vnW1StgSfd6MNH9MfidOnUK//zzD+zt7XH8+PFi11mXhpSUFNy8eVMkAnL39m7YsKFoGqBVq1Zy678wMjIyYGlpCXNzc1y9evWPSs4prUicMmUKLl68iFevXgH4MYht3boVM2bMgJKSEubNm4dWrVohISEBcXFxuHnzJg4ePCiqFVCjRg2YmZkhNTU136D+c+GYXPh8fomJcerq6pgwYQJGjBiBYcOGic5raWkVmSB3584dTJs2Dffu3UOnTp2wfPlyZGVloXnz5vjvv/+K3cmwtGRlZcHHxwf9+vUTLWeNiorCu3fvcObMGVSsWLFAAR4+n4/KlSvD2NgYSkpK8Pf3x7Rp09CkSRPRQF+pUqVS5cuIy40bN+Dg4IBBgwbl27BI3gwcOBDXr19HeHh4vtU+Dx48QL9+/fD9+3ds27YNTZo0wbJly7B3715wOBxkZ2fDwsICS5cuhYuLS4n+7tmzB0OHDkVycjLis7iiz1IOCFRM4aK8n6ULu9TFpJGD4Ofnh4CAADRo0EBmfwdxmDx5Mvbt24fIyMgy/ez83ZBk/P4tBcGRBxGYe/aFVKqWz+VgfhcLZL70x7Bhw9C7d2/s27ev1Mt68pKTk4OHDx+KIgD37t1DdnY2TExMRALA1tZW7PXd8mDJkiWYO3cunj17JvOlbOWFJCKRywGEBNTR4aBrpVRw0uJET+U+Pj6IjY1F48aN8enTJ4SHhyMjI0NUGa4olJWVUaVKFejp6YmV9Z77s5qamlgDjrW1NapWrYqDBw8W2y40NBQeHh7w8fERPS3a2toiMzMTTZs2BZ/PR1BQkPS75qWklBjCj4mJyXeNmpqaKNP+/v37+Pfffws83eeW5wV+LOGsVq0arl69Cjs7O6n8lJbXr1/D2toaTZo0waVLl0q9YZS4hIaGok6dOli3bh3GjRtX4HxSUhL69euHS5cuAQCUlJSQmZmJGjVqYNGiRejVq5fYUcUpU6bg9OnTCA8PFx17G5OMQQu34yuvAoSqegWFtJ4q2tfUx4AWpqiu/0NIp6amok2bNvj69SuCgoJKnAqSJWFhYahZsyZ27tyJoUOHllm/vxt/tCDY6P8Wq66EltpO/M196GuphS1btpS62AsRISwsTLQSwN/fX/S36tChg2g5YI0aNX6JJ/GIiAjUrl0bY8aMwapVq8rbHYkgIlGCXN6nb7/36Tj/WQVCcIp9wilgT5ADEgqQcG0b+B+DoKOjg9jYWPD5fOjr6+P169fQ1tZGr1690KhRIwgEAty6dQuXL19GSkoKuFwuKlasiGPHjqF169ZyvHNgwoQJuHjxIt6+fVvo+a9fv2L+/PnYunUrjIyMsHjxYvTv3180SMyZMwfLly/Hw4cPC32aIyLExsYWmX2f+z0pKSnfdXp6eoUm5BkbGyM9PR3du3fH2rVrMWHCBAQEBKB169Z4+fKlqHJjYaSnp0NVVRV79+4t1Q5/kvLt2ze0aNECysrKuHPnDrS1tcus78GDB8PPz69AdAAAgoKCsHjxYpw9e1aUm8Ln8zF37lx4eHhIvAW7g4MDVFVVcfr06XzHq1Spgm7dumHRspViT7V9+vQJVlZWMDQ0xM2bN+Wyz0ZRODs74/Pnz3j06NEv8dn6K/LHJhUeeRAhEzEAADptB6FDj3pSi4Fv377h+vXrIhEQEREBPp8Pa2trTJkyBfb29qKnsV+NqVOnQktLq9Ad7coCoVCIxMREqebTExISkJWVlc+epnUf6LQdJEpykgQOjw8Ojw/dju6Y6lAT49rXQP369fHhwweEhYXB09MTHh4eePLkCby8vHDy5EmoqalBX18fycnJGDJkCNauXVsmu/JZWVlh/fr1BfZZSEtLw9q1a7F8+XJwuVwsXboU7u7u+QaV+/fvY+nSpRg2bBjevn2LGzduFBjso6Oj8yUfcrlcVK5cWTTA16lTp8DAX7ly5RLDta6urli4cCGGDBlS4j4GuaioqEBHR6dMyxdnZGSga9euSElJwbVr18pUDLx9+xYHDhzA2rVrRa8bEeHGjRtYsmQJ/Pz8oKWlBQ6HAz09PYwYMQKnTp3CokWLoKenl29TLHEIDg7G8OHD8x379OkTPnz4ABsbG6gp8WFRuejy03mpXLkyzp8/j1atWmHgwIE4ceJEmW0L7+7ujk6dOuHevXto2bJlmfT5J/PbRAgi49Jgt/YmMgvZWjPr20ckBhxC1pcwCFITwFFQgoKeCTSb94BqjaILZSjxufCb1FaUU1Ac6enpCAgIEE0DPHnyBMCPGu65EYC2bdv+8uU0r127Bjs7O+zfvx8DBgyQ2k5mZqZU5WDj4+NFpYELQ0tLS6wwe+73wO88rLv3vVBblJONhNsHkPrCH8KMFChUNId2m4FQqdKoyPuqlfgQV7bMQ+XKlXHp0iW8ePECXl5eCAoKQo0aNdC+fXucOnUKHA4HO3bsQJcuXaT+G0rK27dvUbNmTVy+fBmOjo4QCATYu3cv5syZg+/fv6Nr167o0KEDkpKSCjzlf/78OZ8tZWXlYpfbGRkZwcDAQCaC9tOnT6hevTomTZoEc3NzuLm5ITs7u0QxbmlpCVtbW6xbt67UPpSEUChE//79cebMGdy8eRNWVlZy7zMvQ4YMga+vL969ewdlZWVcuHABS5Yswb1791ChQgUkJCRAW1sbs2bNwqhRo6CiooKMjAxRbf8ePXpgx44dYi1H/v79OypWrIijR4/m24L5+PHj6NOnDz59+iRV6P/8+fPo2rUrpkyZghUrVkh8vTQIhULUrl0bTZo0weHDh8ukz9+NP3LKYODOQNx9F1vovHB6+AMkPTwHJaPa4KnrgrIzkfbmLjKjXkC34zhoNOxYqM3iqmsJhUI8ffpUFAEICAhAZmYmDA0NYW9vDzs7O9jZ2Ym2av0dyM7ORoMGDaCnp4ebN28iJSVF4nKwuT8XVeddQUFB7IpxPx/T0tKSKGJTnEgEgG9nViDtzR1oNu0Kvm5lpAb7IfPzWxj8swTKJgUrUBIRIMhG0uFpaFzLDG/evEF0dDTs7OwwcuRIXL58Gbt27UKXLl2wfft26OvLr257rj8JCQmiwT0yMhLu7u6wsLAAh8NBSEhIocsJtbW1RSF7IyMjvHnzBvfu3cP69evRqlUrsarmyZo5c+Zg9erVmDBhAnbs2FFgmWBhODg4QEtLC8ePH5e7f7Nnz8bSpUtx/Phx9OzZU+795SU8PBy1atXCypUrYWRkhCVLluDZs2cwMjLCt2/foKysjOnTp2PChAmFPnD4+PjA1dUVGhoaRe6+mJfcgj4/T9tMnDgRZ8+exbt376S+l/Xr12PChAnYtm0bRowYIbUdSVi3bh2mTp2Kjx8//lafx2XFHycI3sYkw97rlkTXkFCAz3smgnKyYTTSu9i2fpPaoLq+Bj58+CBaCXDt2jXExsZCTU0Nbdu2FYmA3A/jX4Hs7GyJns5fv36NqKgoaGlpITk5udg675KWg839WVVVtewysosRiZmf3uDLvinQbj8MWs17AAAoJwufdowFT00LhgOLyJ0gIdI/PEXcyR+79k2YMAGJiYkYNGgQvn37Bi8vLwwbNqzU95hbNa+4xLyoqKh8KxM4HA74fD6EQiEEAgEqVaqE7t27o0WLFqLB38jIKN8c7sOHD9GiRQvMnTsX//33X6l8Lg25JY0NDAwgEAhEKziKY/DgwQgLC8OdO3fk6tuuXbvg6uqKlStXYurUqXLtqzCGDBmC06dPo2LFiggLC0PVqlXx+fNncDgcTJo0CVOmTCnxyT8iIgL9+/fH/fv3sWDBAsyYMaNIcb1+/XpMnz4dKSkp+SJAzZo1Q+3atbF//36p74WI4O7ujq1bt+LSpUtlkhCamJgIIyMjTJ06FfPmzZN7f78bf1wOwcHAiBKzxn+Gw+WBr1EBmV8KT8DKhQuC67K9+HRuHcLCwsDlcmFlZYXRo0fD3t4eLVq0kOkKhLwQEdLS0qQOvf+8PjuX3DrveQdtFRUVxMTEoFGjRujTp0+Rg7qWllaZZVWXhrcxybgdVvRTZtqbOwCHmy86xOErQr2BPRJu7kNO0jfwNQtZ5cHhQqVKY3iu3owZowZj7ty5WL58OVq2bAk/Pz+xyllnZmYWWzUvN4RfXNW8pk2b5vsdADZu3IhDhw6Bx+Ph9OnT6NKlS7HCJDMzE0OGDEGDBg3g4eFRot/yRFNTE56enpgwYYJY+0MAP+amb92S7EFAUq5duwY3Nze4ubmV+S6f6enpWL58Ofbu3QsAMDIygqamJqKjozF27FjMmDFD7CiUqakpbty4gfnz52POnDm4du0aDhw4UGjoPzg4GHXq1MknBlJTU/HkyRO4urqW6p44HA68vLwQHh6OXr164d69e8Umj8oCLS0tDBo0CFu3bsWsWbPk9nn9N/BbCAL/N1/FEgPCrAxQTiaEmWlIfxuI9HePoFqn+MxvITj4mK0OZwcHrFixAu3bt5comUggEBSbIFfcoP7zOuy85CZV5R20zczM0LBhwxKf2DU0NAoMFLl71Pv5+Um8i9+vSEkiMSvmHRR0jcBVyp8folippuh8oYIAP6JLT5M10Lx5c7x48QJLlizBtGnTwOPxRPPzxT3VF1c1r3bt2rCzsyswZ19U1byEhAQsWbIE69evh5aWFkaPHo0tW7agYcOGJUYp5s+fj9DQUDx69OiXEHlubm7w8PAQO1Ewd8dDaZJFxeHVq1fo2bMnbG1tsXHjxjKLbCUnJ2PLli1Ys2YNYmJiwOfzoaGhgdDQUIwYMQKzZ8+WqnQ6n8/HwoUL0b59ewwYMAANGjTA3r17C+yHEBwcjHr18u87EBQUBIFAUOJ0g7h+HD16FDY2NnB2dkZgYKDcl1iPGzcOW7ZswYkTJ9C/f3+59vUn88sLgpTMHETEpYnVNv76DqQ8vfzjFw4XqjWtoeswusTrOOoVMXnUTGSmJuHly5cSPbH/vARLZPN/dd5/HrSNjY3FCr3LsvjKnTt3sG/fPmzbtu2PEANAySJRkBIHnnrBMCtPXVd0vig4XB7uRyQjKyoKHTt2hJ+fH/bu3YuoqCikpKTka6uvry8a1K2trWVWNS8rK0u073tGRgZmzJiBqVOnIjU1FVu2bEFQUFCxJVsfPHiA5cuXY8GCBQU+/MsLRUVFGBoa4t27d7hx40aBksY/U7lyZWRlZSEuLg56enoy9SUmJgZOTk4wNTXFsWPHymQ1UGxsLDZs2ID169cjJSUFDRo0QExMDAQCAbp27QpPT0+ZlCjv0KEDnj17hiFDhsDJyQlTpkzBkiVLoKioCKFQiJCQkAJ5Enfu3IGWlpbMdnfV1NTE+fPn0bx5c3Tr1g3Xrl2T67bqdevWha2tLTZs2MAEQSn45QXBx9hUiDtRoNmsK1Rrt4IgORZprwNAJAQEhT+B54UA1LFqg+yv7/Md5/P50NTUhIaGBjQ0NEQ/16hRQ/R73vO5x7S0tKCmpiZaelPYk8fPxzgcDrKyshATE4OYmBixrympjVAoxPDhw2FhYQFra2u8evVKKjuyuEZWbdKyBCWKRMrJAngFn4o5fMX/P18MfJ1K4GloIzY2FkZGRqhfv36BwV4eVfOICMeOHcOsWbPw4cMHuLq6Yt68eaJkKQ0NDZiamiIoKKjIcroZGRkYPHgwGjVqhBkzZsjUv9KSk5ODSpUqFShpXBi59/zp0yeZCoL09HR07doVGRkZuHnzptzzoj5//ow1a9Zgy5YtEAqFaNOmDd68eYOHDx9CSUkJ9+7dQ6NGRa98kYaKFSvi3LlzWLduHWbMmIGbN2/iyJEj4HA4SE1NLSAS79y5A2tra5kuFzQzM8PZs2fRrl07DB06FIcOHZJrFMbd3R3dunXDw4cP0bRpU7n18yfzywuCrCIyyAtDQc8ECnomAAD1eraIOfIfvp5YAMNBa0p8I3IKGTxycnIQFxcn2g73d+dXeVIsLQr6VVB52IZi23D4ioWKwVwhkCsMiryew8HFgIdir8WWBbdv38bUqVMRFBQEFxcXnD17ttAnNisrKwQFBRVpZ968eQgPD8ejR49+uToYsbGxGDx4MDZv3ozjx4+jb9++RbbNKwhk9d4VCoUYNGgQnj9/jlu3bom1/bS0fPjwAStXrsTOnTuhpKQER0dHvHjxAr6+vrC1tUVUVBQWLVokczGQC5fLxaRJk9C6dWv069cPjRo1EmX+5/17CoVC3Lt3Ty4JlVZWVti/fz969eqFmjVrYv78+TLvIxcXFxeYmZlh48aN2LNnj9z6+ZP5tT4tCkGRL71iVa1tg7jLG5ETFw0FPeNi23IhRMWKFaGnpwc9PT1UqFABurq6qFChguhY7u+5c/SFLdD4+Zg0bWRlNz4+Hv369UObNm0wa9asX84/aduEJwiw7LGgwPG88NR1IUiOLXA8d6ogd+qgOCQRo6Xh9evXmDFjBs6ePYsmTZrg+vXraN++fZHtraysMG/ePOTk5BQY8AMDA7Fy5UosXLgQlpaW8nZdItLT05Gamgpra2tERERg1qxZ6N69e5FJYIaGhgBQoIZCaZg1axZOnjyJU6dOye0p8vXr11i2bBkOHjwIbW1t9O3bF8+ePcOpU6dgZ2eHPXv2YNeuXXj+/DlGjy55SrO0NG3aFI8fP8bo0aOxZs0aKCoqQkvr/4XuixcvkJiYKJP8gcLo2bMnli1bBg8PD9SoUaNU9U+Kg8fjYcyYMfD09MTKlSvLtTT878ovLwjM9dTAAcSeNsgLZf9Yoy3MLDwbP09LLJs9BfHfvuDLlx9fMTExePbsGWJiYgpsSqOoqAgDAwMYGBjA0NCw2O+amprltkzRzc0NXC4Xu3btkvua+bKk8qdELHscUGwbRf2qSPr4HMLMtHyJhVmfflS6VDQoebXArh3b4NCsLpo0aSKX9c1fvnzB/PnzsX37dpiYmODQoUPo27dviWFbKysrpKWl4dWrV/me9DIyMjBkyBA0btwY06dPl7m/pSVvlcJly5ahfv36+D/2rjueyvd/X+dw7D0TItqlokI7LWnSHkZ7a0ehNBQq7a1FgzSotPcuSoMW7RKysznO+/eH33m+5OAcjurz+XS9XudVnue+7+d+znju636P671z507MmjVLYHtpaWloaGiITa3Q398fvr6+WL9+PWxtbcUyZmk8efIEq1evxokTJ6Cjo4MpU6YgKioKgYGB6NChA65fv45u3brh48eP2L9/P1avXv3LZH6VlJRw6NAhxMXF4fHjx2jXrh2Cg4PRqlUr3L17FxISErUqxuTi4oLY2FhMmDABBgYGtSbzPWHCBHh6emLPnj1/S7pXA388IZCXlkQ9NTl8qsRnXJyTAQl5lTLHqJiLnJhrYElKg6NRuVlQXZowwcleoOgHESErKwtJSUkMUfj53+fPn+Py5ctITEwsJ6srIyNTJWng/ytOlcNHjx7B398fmzZt+leRAUA4kijXpCN+RJxE1tMLpXQIipAdfRlSdRtXmGHAgAhBuzdj68qSxahOnTpo06YN2rZtizZt2tSIJOTk5MDPzw9r1qwBh8OBr68vZs6cKXQ8Qps2bcBmsxEREVGGEHh6euL9+/eIior641wFQIncN1Di327evDnGjx+PFStWMBkwgqCjoyMWQnD58mVMmzYN06dPx5w5c2o8Xmncu3cPq1atwrlz52BkZIRFixYhIiIC27Ztg5mZGc6dO4c+ffowGwNvb2+oqKhg+vTpYp1HVWCxWMjOzsbIkSPx4sULWFhYYP369UwMQ22SExaLhR07duDDhw+ws7PDgwcP0KCB+Esmq6urY/To0dixYwcWLlz4R/4O/mT8I4SJlp1+gYMPP1UYVf79hBeoMBfS+i0goaiO4ux05Ly8AW7qV6h2nwAlc7uKB+cV40fUWeTeDkDPnj1hZ2eHgQMHVsvcRETIzMwUSBx+PpaUlAQul1umv7y8vFDEoU6dOpXqx/N4PHTs2BE5OTl/7OJQU3Rde71SkggAyWE+yI29D6V2gyCpWhc50VdRkBAL7ZGrIFOvcnO6gbocbszvhs+fP+Px48fM69GjR0hNLXFFiEoSuFwu9u/fj6VLlyItLQ3Ozs5wc3OrVuaHiYkJOnTogF27dgEoqVXQsWNHeHl5/bE7o0uXLsHa2hofP36EgYFBGUnjVatWCezTp08fyMnJ4eTJk9W+bkxMDDp27IiOHTvi9OnTYvk9EBGuXLmCVatW4ebNm2jWrBns7e1x7949hIeHo1mzZli5ciXs7OzKWAg/f/6MBg0awMvL65dbcQoKCiAvL49t27bByckJLi4u2LJlC+Tk5ODg4ICdOysXcBMH0tPT0b59exAR7t+/XytZT0+fPoWpqSmOHz/+y1Un/0T855QKc17eRPbzyyhM/gheXhbYUrKQqtMAim0GVFrLgI8Dw4zx5OZ5hIWF4c6dElN0x44dYWdnB1tbW7GkAv0MHo+H9PT0Cq0Opf/9/v17OVVBJSWlCslCTEwMNm3ahJCQEAwcOPCX1I//1aiKJAIlAYQZt0pqGRTnZ0NKyxAqne0ha9Sm8sF5xRjb0RjLBgqWN/6ZJDx+/Jgxh/NJQmmioKOjg7Nnz8LV1RUvX77EqFGjsGrVqhp9ryZMmICoqCg8efIE+fn5MDU1haKiIu7du/fHEsDDhw/D3t4eOTk5kJMrcePwJY3j4uKgp1c+zmf8+PF4+fIlHjx4UK1rJiYmwsLCAioqKrhz506Ni1DxeDycPn0aq1evRmRkJNq2bYuxY8fi1q1bCAkJgbGxMZYtW4ZRo0YJVAqcNm0ajh8/jg8fPvzyuif8hfLu3btMIaD9+/dj/PjxUFdXR1hYGDp16lTr83j79i0sLS1hYmKCixcv1oqQUOfOnSEpKYnr16+Lfex/Gv51hACoXKa2uqBiLjR56bi4eACT1vT9+3ecOXMGYWFhuHz5MgoKCtCqVSuGHLRs2fKXxwQUFxcjNTW1QmtD6X9TUlLKBeKpqKgIJA4/H9PS0vojBGyEQXXkrEVBn+JI+LjNEUqkiojw5csXPHr0SCBJ4JerNTAwgLOzM0aNGlXjmIRdu3ZhxowZ+PHjB5YtW4ZNmzbhyZMnaNasWY3GrU1s2rQJixcvRm7u/yw7fEnjgQMHYu/eveX6eHh4IDAwEJ8/fxb5erm5uejWrRvi4+Px8OFDgYRDWHC5XBw9ehTe3t548eIFunTpggkTJuD69esIDAxE3bp1sXTpUowdO7bC3xDfOrBixYrfohx58OBBODo6lnmOHz9+HMOGDUO7du3w+PFjLF++HIsXL65xSfiqcOfOHfTo0QNjxozB3r17xf5MPXr0KEaOHInnz5//a7Krqot/JSGoqpCNqCAisHhcpB2aC07BD6xatQqTJk0q80PIysrChQsXEBYWhvDwcPz48YOpF25nZ4cOHTrU+g9HVMyaNQt79uxBWFgYeDxepdYHvum7NNTV1YVyWWhqav72ex+8+Rqi4rMBthjnwSsGJ+0Dvh1xg4yMDJYsWYLp06eLvIv58OEDUyxGXV0dBgYG+Pz5s0BLQml3g7APxidPnsDMzAw7d+7E9OnTsXr16j9Oc+BneHh44ODBg/j06VOZ41u2bMGcOXPw7NmzcpkR27dvx+zZs1FQUCBSjjyPx8PQoUNx6dIl3Lp1C2ZmZtWac0FBAQIDA+Hr64t3797BxsYGkydPxqVLl5jqgu7u7pg8eXKVwjvTp09HSEgIPnz48EvKZf8MFxcXhISE4OPHj8yxuXPnIiwsDHFxcVi5ciVWrlyJbt264dChQ7VeKIhvMfL29hY7QSoqKoKhoSH69+/PuNX+q/hXEgIACI78jEUno8U2XsHtfeDF3UHr1q1x6dIltG7dGlu2bBFoNissLMSNGzcQGhqKU6dOISEhAZqamhg4cCDs7OzQo0ePWlXiEgbR0dEwNTXF6tWrhfJPFhYWIjk5uUqrQ1JSEjIyMsr0ZbFY0NTUrNLqUKdOHairq4u9Pvrhw4cxbaEH1Ow3CBQgqja4hRgo+RyLZ02Gp6cn9u7dC0NDQ3h7e2PYsGFVLthpaWlYvXo1tmzZAjU1NaxYsQLjxo2DpKQkY0koHY9Q2pKgra1dJh6hMpJQVFTEiGLVr18fd+/e/WNdBXxMnToVkZGRePz4cZnjhYWFaNasGZo0aYLw8PAy58LCwmBnZ4ekpCSRgmMXLlyI9evX49SpU+jfv7/Ic83JyYG/vz/WrVuHb9++YciQIZg6dSrOnz+Pbdu2QVZWFi4uLnB2dhYqGO/Lly9o0KABli1b9ttiPGxsbCApKYkzZ84wx8zNzdGoUSMcOnQIAHDjxg2MGTMGhYWFOHDgAPr161erc1q2bBmWL1+OY8eOYejQoWIde+XKlfDx8cHXr1+FKgv9b8W/lhAAwNbrcVh3KbbG4yzs3RiDm8jDwcEB165dg6OjI6KjoxEVFYUxY8ZgzZo1FTJkHo+HiIgIhIaGIjQ0FHFxcVBQUICNjQ3s7OzQt2/fCqOmawtEBCsrKyQkJCA6Olrsfrn8/Hx8//69UuLA/39WVlaZvhISEtDS0hIqYFJNTa3SRTcvL4+xgtjb26PH5KVYdq7m3wc+cq/vhsvQzoxIy4sXL+Dq6oqzZ8/CwsIC69atE0gYCwoKsHXrVqxatQqFhYVwcXHBvHnzqvQT/0wS+EShNEkQFLjIYrGgq6uLxMRExMTE1HoBGXFgyJAhyMnJwYULF8qdO3bsGIYPH86k5vEREREBCwsLPH36FK1atRLqOjt37sS0adOwefNmODs7izTHzMxMbNu2DRs2bEB6ejrGjBmD6dOnIzw8HBs3bgSLxcK8efMwd+5ckX7jM2bMQHBwMD5+/PhbrAMAoKenB0dHR6xevRpAiUtFWVkZmzdvLqOHkJKSgrFjx+Ls2bOYN28evL29a7XA25gxYxAaGoqbN2+KNfUxMTER9erVg4+PD+bNmye2cf9p+FcTAqDEUuB5+gW4PBIppkCCzYIkm4UVA5tjRLuSVEQejwdfX18sWbIE5ubmGDhwIPz8/JCfn48lS5Zgzpw5lf4YiAivXr1iyAG/kEz37t2ZjAVBFcfEjeDgYIwaNQoXL15E7969a/16lSE3N7fKQEn+v6X9yQDA4XCgpaUl0NpQXFyMrVu34tu3b1i7di2mT58ONpstNpI4v2dDzOrZGHv27ClX9e369etYsGABoqKiYGtrCx8fHzRu3Bg8Hg9Hjx6Fm5sbvnz5gkmTJsHT05MR1akOBJGEx48fM2l72traMDIywv3796GgoIDXr1+L5G74XejatSv09fWZ3WhpEBEsLS3B4/HKSBp//foV9YwaYufhE2hn0R5SkmwYqstDXlqwNeTChQvo378/pk+fjs2bNws9N35p661bt6KgoADjx4/H9OnTcfr0aaxduxYFBQWYOXMmXFxcoKGhIdJ9f/36FcbGxli6dCnc3d1F6isupKenQ01NDUeOHMGoUaMAlFgDrKys8OzZM7Rs2bJMeyLCpk2b4OLigpYtWyI4OLhW0gSBks1Gjx498O7dOzx8+LDSGh2iwt7eHvfv30dsbOxvd3H+LvzrCQFQElPgFhqN229TqiyNzD/fuYEGVtuZQF9Nrlybe/fuYfTo0cjIyMCmTZsQFRWFbdu2wdjYGBs3bixXMazCeX35grCwMISFheHmzZvg8XiwtLRk4g4aNmxY7XuuCNnZ2WjcuDEsLCxqlJ71O5CdnS2U1SE+Pr5cmqa0tDRDGAr02iDdqBfAlgBLhJgC4hVDRoqDFQObo6eRPDQ0NHDy5EnY2ZVPVeXxeAgODoabmxu+fv2Kfv364fPnz3j69CkGDhwIHx+fWtupExG+fv2KR48e4cGDB9i6dSvy8/OZ7BO+JaF0hsOfRhKaNWsGa2trbNiwQeD5mzdvolu3bggODoZZt744/PAzrr1JwqfU3DL3wQJQT00OVo21MMaiHhpql+y4nz9/jk6dOqFr164ICwsTagH4+vUr/Pz8sHv3brBYLEydOhUzZszAqVOn4O3tjfT0dEyZMgVubm7VJvbOzs44fPgwPn78+Nuen7du3ULXrl0RHR3NxGmsWrUKa9asQVpaWoXv1ePHjzFy5EgkJiZi586dGDNmTK3MLzk5GRYWFpCTk2MKLYkDDx8+hKWlJcLDw2vd/fGn4j9BCPiIS8rC4YefcT32Oz6n5pYRqyEiGGrIw6qRFuwt66GBVuWmuvT0dEyaNAknTpzA1KlTMX78eLi4uODGjRsYMGAANmzYAGNjY6HnlpqaivDwcISFheHixYvIy8tD8+bNGXJgZmYmlgf24sWLsXHjRrx69QqGhoY1Hu9PQl5eHmbPng1/f38MHz4crq6uZUjE169fce7cOcTExEC5rhGUekwBW7c5iFdcKTFgEQ/EYiP/41O05cXCfc5U5ObmomfPnrhx4wa6du1aYd8nT55gzJgxePXqFdhsNsaNG4fNmzczqXS1jfnz52Pbtm04ffo0rK2t4eHhASISaEn4OXBRV1f3t5EELS0tzJ49u9JdsvXg0XijbAbUaSoS0Z/dQQt2vbtAU1MTt27dqtJV8+7dO/j6+uLAgQOQl5fHrFmzMG3aNJw6dQorV65EYmIixo4diyVLltRoxxofHw8jIyMsWbIEHh4e1R6npti2bRvmzp2LnJwcJguib9++4PF4Al04pZGVlYXp06fj0KFDGDt2LLZs2VIrKZOvXr1C+/btmQVcXHoR5ubmUFdXr/I+/60Qaf0mIZCZmUkAKDMzU5jmvw3Z+UUUE59BUZ/SaFfIWWJxZOj9+/cijcHj8WjHjh0kIyNDLVq0oJiYGDp69Cjp6emRtLQ0ubu7U3Z2tshzy8nJodDQUHJ0dCRVVVUCQPr6+uTs7EzXrl2joqIikcckInrz5g1xOBxavnx5tfr/yXj16hWZmJiQjIwM7d27l3g8XpnzT548oRYtWpCUlBT5+flRcXExERG9Scgk15BH1H7VBTJYFF725XqGGsw9RI1GuZNOE1NisViEEtFD5iUnJ0cNGjSgjh070pAhQ2j69Om0YsUKWrNmDfXu3ZtYLBbp6enR9u3bac6cOcThcKhu3bq0d+9e4nK5tfqe3Llzh1gsFq1Zs4Z4PB6pq6vTsmXLmPM8Ho8+f/5MoaGh5OHhQX369CFNTU3m3rS0tKhv3760ZMkSCgsLoy9fvpR7X2sDxcXFxGazadeuXRW2CYr4RA3dz1K9hWHlP7dKXkaLw8lgYSjpdR1OX79+rXQeMTExNGbMGGKz2aSlpUU+Pj6UlpZGAQEBZGRkRCwWi0aNGkVv3rwRy307OzuTiooKZWRkiGW86mLKlClkYmLC/F1cXEwqKiq0YsUKoccICAggeXl5aty4MT158qQWZkl05coVkpSUpGnTpontexkQEEAA6PXr12IZ758GUdbvfxUhKI34+HgCQKGhodXq//z5c2ratCnJysqSv78/ZWVlkbu7O0lJSZGenh4FBwdX+wtbWFhIV69epZkzZ5Kenh4BIDU1NXJycqKwsDDKyckRahwej0fW1tZkaGhIubm51ZrLn4pDhw6RvLw8NWnShJ4/f17mHJfLJR8fH+JwONSqVaty50uDTxKXbtpHUtpG9CO3oMz5tLQ0UlVVpWHDhtHq1asJAHl4eNDChQvJwcGBevfuTS1atCB5eflyxAEAKSsrk5GREbPoqqurk5OTE/n7+1N4eDhFRkbSly9fqKCgoIIZCo+cnBxq2LAhWVpaMsTDxsaG+vbtW2m/n0mCjY1NOZJgY2NTqyQhJSWFANCJEycEnt9yLVYkEvDzq57rGTJYFE5brsUKHD8yMpJsbW0ZIr5lyxbKzs6mkJAQatKkCQEgW1vbSr9LoiI+Pp6kpaVFWnRrCx06dKDRo0czf0dHRxMAunr1qkjjvH79mlq3bk1SUlK0ZcuWWiGT/v7+BIA2btwolvHy8vJIU1OTZs2aJZbx/mn4Swio5CGooaFRo51zTk4OTZo0iQDQiBEjKCMjg96+fUsDBw4kANStW7caP0B4PB5FRkaSm5sbNWvWjNmh2tnZUWBgIKWmplbYNywsjABQWFhYjebwJyE3N5d5z+3t7SkrK6vM+ffv31OnTp2IxWKRq6sr5efnCzVuSEgIAaD09PRy59atW0cSEhK0bt06AsAQsqKiItqxYwdpa2uTtLQ0LViwgN68eUNPnz6lCxcuUEBAAPn6+tK8efNo9OjR1K5dO5KTkxNIHPikr2nTpmRlZUUjR46kOXPmkLe3N+3fv5/OnTtHUVFR9O3btwqtRXPnziVpaWl69eoVc8zT05M0NDREfjALIglaWlrlSIKHh4dYSMKrV68IAN26davcuaCITzUiAz+/giM+Mfd448YN6t27NwGghg0b0t69eyk/P5/Cw8OpdevWBICsra0pIiKi2vdWEWbPnv1HWAd4PB4pKSmRt7c3c2znzp0kISFRLWtnfn4+zZo1iwDQoEGDKCUlRZzTJSIiFxcXYrFYdPr0abGM5+bmRoqKivTjxw+xjPdPwl9C8P/o0aMHDR48uMbjBAcHk5KSEtWvX58ePnxIRETnz5+nRo0akYSEBDk7O1NaWlqNr0NU4gLw8fEhS0tLAkASEhLUo0cP2rJlC3358oVpl5ubS4aGhtSnT59fYvL9FXj9+nWFLgIej0f79u0jBQUFMjQ0FLiwVIbLly8TAIEupLy8PNLT0yNTU1OSlpam4uJiOnXqFLNztLe3p48fPwp1HR6PR2FhYdSoUSMCQP369aOAgADat28feXt70+zZs2nkyJHUrVs3atq0KeM+Kv1isVikqalJLVq0oJ49e9KYMWNo5MiRBIBGjRpFFy9epGfPnlFiYiKdPn26wvsSFTwej758+SIUSQgNDRWJJNy+fZsA0MuXL8sc/5yaQ408zpH+vGOk3HEUydQ3I7aMQom1pe8cgQt+3Yk7SKa+GbE4MsSWUSD55lakN+swc76RxzkKPHGWOnbsSACoZcuWFBwcTFwul65evUrt27cnANSlSxeRv0fC4tu3byQjI1PGnfO78PHjRwJA4eHhzDEHBwdq06ZNjcY9deoUqampkZ6entjfx+LiYho8eDDJy8uLxT3x5csXkpCQoK1bt9Z8cv8w/CUE/4+5c+eSsbGxWMZ69+4dmZubk6SkJK1Zs4aKi4upoKCAfH19SUFBgTQ0NMjf31+sPuT4+HjasWMH9e7dmyQlJQkAtWvXjlatWkUzZswgDocjNl/n78bhw4crdBEkJSXRoEGDCACNHz++Wt/DyMhIAkBRUVECz+/du5dxAXTp0oUAUPfu3enx48fVup/CwkLavn07aWlpkYyMDC1atKjCnWJ+fj59/vyZIiIi6MyZM+Tv709eXl40c+ZMGjZsGHXs2JE4HA5JSEiUIw9sNpsAkIGBAfXu3ZscHR3JxcWF/Pz86PDhw3TlyhWKiYmh5ORkJsZCFPBJQlhYmFAk4fPnzwJJwsmTJwkAJScnlzluv+cBGbmdJd2pJe+/hJImSdczqZAQ6E4/QGxZJZJU0SHVnpNJpYsjsWUUiKNVn+otDC1p53KKtEasIAsLCzp9+jTxeDy6d+8ede/enfkNXbx4sVaJ9Jw5c0hZWVmgRepXIzw8nADQp0+fmGNGRkZiMaF/+fKFunTpQmw2m1asWCHW519OTg61bduWdHV1q4wNEQZDhw6lJk2a/Gs2UMLiLyH4fxw4cIAAiM1MVFBQQC4uLoyZMTExkYhKFm57e3sCQG3atKH79++L5XqlkZ6eTocPH6ahQ4cyZmk1NTVydXWlBw8eVOth/yegKhfB6dOnSUtLizQ0NKodD0JE9Pbt20p9pm/evCEpKSkCQC1atKBz586J5cHx48cPWrJkCcnKypKGhgZt3rxZ5HiC2bNnk4yMDL1584Zyc3Ppw4cP9ODBAwoLC6Ndu3aRiooKtWrVigYPHkwdO3YkY2NjgTEPkpKSVLduXTIzMyMbGxsaN24cLVq0iDZu3EhBQUF0/fp1evnyJaWlpVV676VJwpIlS8qRBE1NzXIkYdeuXcRiscosGLGJP/4XA7AglPRmHiSDReFUx2lDhYRAwbQvsSSlSXfaPuaY1kivkt9Dn5ll2sYm/qCoqCjq168fASATExMKCwur9QUhISGBZGRkyNPTs1avIyy8vb1JWVmZue+EhAQCQEePHhXL+Fwul5YtW0ZsNpu6desmlsWbj2/fvjHWu5+fDaLixo0bBIAuX74sptn9M/CXEPw/njx5QgDo7t27Yh33woULpKWlRdra2mW+XHfu3GH8kk5OTpSQkCDW6/IxYMAAUlNTIwcHB9LQ0CAAVLduXZo2bRpdunRJLAFsvwKvX7+mli1bkoyMDO3Zs6fMgzorK4shCv3792fIV3WRmppKAOj48eNljqekpDCZAnxCcPHixRpdSxDi4+NpwoQJxGazqUGDBnTs2DGhFqZbt24Ri8UiPz+/CtuMGDGCOnXqVO54VlYWvX37lu7evUsnTpyg7du309KlS2nKlCk0aNAgsrS0JENDQ5KRkSlHHqSkpEhfX5/atm1L/fv3p4kTJ5K7uztt2bKFQkJC6NatW/TmzRvKzMwkHo9XjiT07du3DEmQl5cnDodThiQsPRVNRm5nyy36lRECtpwKyTXpVO64pJouyRi0Yv6uvzic2k1dw8QOBAUF/TLSPHfuXFJSUhKbG7GmGD16NHXs2JH5+/jx4wRArAs3UcmCq6urS+rq6nTmzBmxjfv06VNSUFCggQMH1sgCwePxyMTEhAYOHCi2uf0T8JcQ/D/y8/NJUlKStm/fLvaxExISqGfPnsRisWjx4sVUWFhIRCVseefOnaSmpkaKiork5+fHnBMHLly4QAAoODiYud7Nmzdpzpw5ZGBgwJi9x4wZQ8eOHasxq64t8F0EjRs3LuciuHv3LhkZGZG8vDzt3r1bLDs6LpdLAGjPnj1EVBI34OvrS8rKyqSgoEBeXl5kbW1Nqqqq1LZt21rbRT5//pxsbGwIALVv375SspqdnU3GxsbUsWPHSh+Efn5+JCsrW+3UVR6PR5mZmRQbG0u3bt2iY8eO0ZYtW8jd3Z0mTpxI/fv3p3bt2pG+vj5Dmkq/ZGRkyNDQkCwsLGjQoEE0efJkWrp0KW3dupV2795N3t7e1KpVK5KTkyNtbW2mn/70vQJjBCoiBLozSix+Kt3Glusj39yK2DKKZTMPZuyjvXv3Vvt9qQ4SExNJVlaWlixZ8suuWRVMTExo6tSpzN9z584lAwODWrlWcnIy9e/fnwDQnDlzhA76rQpnz54lNptN8+fPr9E4u3fvJhaLRR8+fBDLvP4J+EsISsHExISmTJlSK2MXFxeTt7c3SUhIkKWlZZkvWWpqKk2fPp3YbDY1adKELl26VOPrFRQUUKNGjahbt24CFywej0dPnjyhpUuXUsuWLQkASUtL04ABA2jv3r30/fv3Gs+hpijtIhgzZkwZwlJQUEBubm7EZrOpffv2FBcXJ9ZrKykpka+vLx08eJDq1atHEhISNH36dEpKSiKiktQsa2trAkDHjh0T67V/xpUrVxhr0uDBgyk2tny63KxZsxhXQWXgB+w9ffq0tqbLgMfjUVpaGr169YquX79OwcHBtHHjRlq8eDGNGzeO+vbtS2ZmZqSrq8vEvZR+ycvLk4GBATVu0YoM/j9VUFhCwBzvP69cHyWLwQSA6i0IZY4ZLgqn7PxfRwaIiObPn09KSkqVZgf9ShQWFhKHw6Ft27Yxx8zNzcukIIobPB6PNm3aRFJSUmRmZibwu10dbNmyhQDQzp07qz1GdnY2qaio0MKFC8Uyp38C/hKCUrC3t6f27dvX6jXu3btHBgYGpKysXG4hefLkCXXu3JkAkJ2dXY2Yqa+vL0lISFB0dLRQ7d++fUt+fn5Mmh6bzaYuXbrQhg0bfgtDrsxF8OLFCzI1NSVJSUlatWpVrezq+G4e/mfxs1BJ06ZNae7cudSnTx9q1KhRre8si4uLKTAwkPT19UlSUpJmzpzJkLabN28SAFq/fn2V42RnZ5OEhATt3r27VucrKoqLiyklJYViYmKoXbt21LZtW/Lz8yMXFxcaPH5WhWmDFREC7TE+BIA0BrmW66PcoSQLQ39OcJnjMfG/LuWPbx3w8PD4ZdesCny9gZs3bxJRSaCepKRkGYJQW4iKiqKGDRuSgoICHTx4UCxjOjs7k4SERI02WPPnzydVVVWh9V7+6RBl/RZvTdo/EC1btsTz588ZzffaQPv27fH06VP06tULw4YNw9SpU5GXlwcAaN26NW7evIkjR47g4cOHaNq0KZYtW8acFxbx8fFYsWIFZs6cWa5mfEUwNjbGvHnzcPv2bSQkJGDXrl1QUFCAq6sr6tevDzMzM6xYsQLR0dGgqhWsa4SgoCC0bdsWBQUFiIiIwIQJE8BiscDj8bBp0yaYmZkhPz8fDx8+hJubm1hL+cbExKBv3774/v07AOD27ds4efIkGjduXKZdWloa1NTUsHr1asTGxmL//v1im4MgsNlsODg44M2bN/Dy8kJgYCCMjY2xbNkyODk5oWPHjpg1a1aV48jLy6NFixaIiIio1fmKCjabDXV1dTRv3hw8Hg9mZmaYN28efH194eG5TOTxWJLSAAAqLip3jooLy7Tho5Bbe7/7n7Fu3TpISkpi7ty5v+yaVSE6uqRcvImJCQAgMjISXC4XHTt2rPVrm5qa4vHjxxg8eDAcHBzg5OSE7OzsGo25fv16WFtbY+jQoXjx4kW1xpg+fToyMjJw5MiRGs3l34h/PSFo1aoVcnJy8P79+1q9joqKCkJCQrBr1y4EBATA3Nyc+cKyWCyMGjUKb968wZw5c7B69Wo0bdoUJ06cEHohXrhwIeTl5bFs2bJqzU9bWxsTJ07E2bNnkZKSgqNHj6Jx48ZYt24dWrZsiYYNG2LBggW4e/cuiouLq3UNQcjLy8OUKVMwevRoDBo0CI8ePWIeTl++fEHv3r0xZ84cTJ06FY8fP4aZmZnYrh0fH48JEyagVatWiI2NRbNmzWBlZSWwfDERMYTA1NQUo0aNqhZxqw5kZWXh6uqKd+/eYfz48Vi5ciU+ffqEAQMGCD2Gubn5H0cISiMlJaVMlUApSdEfPRIKJTXti7PTyp0rzk4HW0YRLElOmePVuU518P37d2zfvh2zZs2CmpraL7mmMIiOjoauri5UVUveu7t370JJSUnoTUVNoaioiICAAAQGBuLEiRNo06YNnjx5Uu3xJCUlERwcDAMDA/Tr1w9JSUkij2FkZIR+/fph69attb4R+qfhP0EIAODZs2e1fi0Wi4XJkycjMjISPB4P7dq1w549e5gvnYKCAry9vfHixQs0b94cQ4cORa9evfDy5ctKx7158yaCgoLg6+sLFRWVGs9TUVERw4cPR1BQEJKTk3H+/Hn06NEDhw4dQqdOnVC3bl1MnjwZ586dQ0FBQbWv8+bNG1haWiIwMBB79uzBwYMHmaIoR44cgYmJCV6/fo3Lly9j48aNkJWVrfG9ASXFPDw8PNCwYUOcOnUKGzduxMuXL9G4cWNkZGQI7JOTk4OioiLmYb5ixQp8//4dW7ZsEcuchIGGhgbs7OzA4/HQsmVLLFq0CG3atMGlS5eq7Gtubo6YmBjk5OT8gpmKjuTk5DKEgH58ByDaw1hSUQNsOWUUJr4td64gIRZS2vXLHiTCpROHa91CCAB+fn5gs9l/lHUAKCEEfAIOlBACS0vLX14K2MHBAVFRUZCXl4elpSU2b95c7cVYUVER4eHhKCgogK2tbbVIu7OzM549e4Y7d+5Uaw7/VvzrCYG2tja0tbV/CSHgo0WLFoiMjIS9vT0mTZqEkSNHIjMzkznfsGFDnD17FmfOnMHHjx/RsmVLzJ07t0wbPrhcLmbOnAlLS0s4OjqKfa7S0tLo06cPdu3ahW/fvuHu3btwcnLC9evX0a9fP2hqamLkyJEIDg7Gjx8/hB6X7yLguwH4LoK0tDSMHDkSY8aMQd++fREdHY2ePXuK5V6Kioqwfft2NGjQAH5+fpg9ezbevXsHZ2dnSElJQVVVFenp6QL78o/zd1INGjTA5MmTmRK4vwLZ2dkYP348OnfujKioKNy/fx8KCgqwtraGtbU1nj9/XmFfc3Nz8Hg8REVF/ZK5ioLc3Fzk5uYiISEBs2fPRqNGjWDStBG46YkijyXXuAPy3kaC+yOZOZb38Sm4afGQa1LW8iORlw7X+XPQqlUrqKmpoV+/fvDx8cGdO3dqRHR/RnJyMrZu3QpnZ2eoq6uLbVxxoDQh4PF4uHfv3i9xFwhCo0aNcP/+fUyfPh2zZ8/GoEGDkJqaWq2x6tWrh9OnT+PZs2cYN26cyISvZ8+eaNy48S8l/P8IiDso4U9E7969f1vu6dGjR0lJSYkMDQ3pwYMH5c7n5+fT6tWrSU5OjrS0tGjfvn1l8qU3bdpELBaLHj169CunTTwej6Kjo2nlypVkZmbG5Kbb2NjQrl27KtQFyM3NpcmTJxMAGj16dBlRqEuXLlHdunVJRUWFgoKCxDrXkydPUqNGjYjFYpGTkxN9/vy5XLv58+dTo0aNBI7x9OlTAlBG0z4hIYHk5ORo0aJFYptrZZgxYwbJysqWya7g31vDhg2JxWLR2LFjy0hY81FUVERycnK0bt26XzJXYRAXF0ebN2+mbt26/S/VUF+fJk+eTKGhobT4eFQZHQLVXlNIubM9KZj2JQAk16gDKXe2J+XO9qQ/5+j/KxXuL6VUOIVUuv6/UqGmYZkMAyO3s+R5KoZycnLo+vXrtHLlSurduzcpKCgw2TedO3emxYsX07lz52pUb8DV1ZUUFBTKqTD+bvCf24GBgURUUukRAF25cuU3z6xEcExdXZ10dXWZgMfq4MSJE8RisaoVyLllyxaSkJAQux7Dn4a/WQY/YeHChWRoaPjbrv/+/XtG9tjX11egQMqXL18YvXoLCwuKiIigpKQkUlZWrrW0SVHw6dMn2rRpE3Xr1o3YbDaxWCzq0KEDrV27lt6+fUtEJWp//CwCf39/JosgJyeHnJ2dCQD16tVL4IJWXdy7d4/RrO/Vq1eluucrV64kLS0tgeeuXbtGAJh74cPd3Z1kZWUpPj5ebHOu7PqbNm0SeL6wsJC2bt1KmpqaJCsrS25ubuV+j507d6bhw4fX6jwrQ25uLp07d46cnZ2pQYMGBIA4HA61a9eOUcYrnVlSWqnQYFE4SSj9T8jo55fu1P9pFuhM2EYy9U2JxZEmtrQ8yTfvRnrOB8tlHsQllVcoLSoqosePH9PGjRtpyJAhjHgSi8WiVq1a0cyZM+no0aNCf97JyckkLy//y0ijKLh79y4BYH4Tu3btIgkJiT9Gm+Tr16/UtWtXYrPZtGzZsmqLDq1ZUyJAFRAQIFK/zMxMUlBQ+KOyQmoDfwnBTzh48CAB+K1VxwoLCxnZ4969e1e4w75x4waZmJgQi8WiRo0akYqKSq1UE6sJkpOTaf/+/TRo0CBG5U5PT4+kpKTIwMCgTD58ZGQkNWnShGRkZGjz5s1iU4uLi4ujoUOHElBSvEYYdcGtW7cSh8MRqOHAV2/7WV0uIyOD1NTUapWUZWVlkaGhIXXp0qXK9yczM5Pc3NxIRkaGNDU1aevWrYzw1fz583858Y2NjaVNmzZRnz59mO9CvXr1aMqUKRQWFkY/fvxgxLQEFYji1zIQZ7VDI7ezZL+nvDVOEHg8HsXGxtLevXtp3LhxDJEBQEZGRkwp69evXwv83ixatIjk5eX/OOsA0f8qGvLFgRwdHcnMzOw3z6osuFwuLV++nEmJrs5mgcfj0cSJE4nD4dCNGzdE6jtz5kzS0tISm4DSn4i/hOAnPH/+nADBpVd/NS5evMjkw1eUS1tUVEQLFiwgACQrK0sbN278pWproiA5OZkpL8vhcAgoKbTj7OxM48aNIwkJCWrTpk25Knc1uZ6zszNJSkqSnp4eHThwQOidxeHDhwmAwJKv/v7+xGKxBC7I/PLItVVIavr06SQnJ1fOOlEZvnz5QmPHjiUWi0UNGzakEydOUHBwMAFghJZqAzk5OXT27FmaOXMmGRsbM66kHj160Lp16+jFixflFs5Dhw4RAIF5359SsqmBW3iFIkXVeTXyOEefU6ufY/7t2zc6duwYzZo1i0xNTZkCUpqammRnZ0fr16+niIgISkxMJAUFBXJxcan2tWoTM2bMoKZNmzJ/Gxsbk7Oz82+cUcW4efMm6enpkZqaWrVKHhcWFlL37t1JVVVVpN8pvyy3uHQS/kT81SH4CU2aNIGUlNQvDSysCL1798azZ8/QsmVLWFtbY/HixSgqKptXzWKxcP36dZiYmMDe3h5z585F69atcf369d80a8GIjY1Fz549cevWLfj7+yM7OxuXL19Gp06dsHPnTuzfvx9SUlJo0aIF4uLiapTCl5eXBx8fHxgbG+PAgQNYsWIFYmNj4eTkJHTEND9gUFCmQVpaGlRUVMBml/9JzJgxAzo6OliyZEm1518Rrl27hu3btzP3Jiz09PSwf/9+PH36FEZGRhgyZAjWrVsHoCTXXFwgIsTGxmLTpk3o06cP1NXV0a9fP5w5cwa9evXCqVOnkJqaiitXrmD+/Plo1qwZWCxWmTGSk5MhKysLOTm5Msfv3LkDh8F9kRi+GfipT02wYmBz6KvJVd2wAujo6GDo0KHYtGkToqKikJ6ejgsXLmDy5MlIS0uDm5sbzM3Noa+vj9zcXAAlnyP//38KSgcUJiUl4d27d78toLAqdOnSBU+fPkWnTp0wcOBAzJ49W6TATw6Hg+PHj0NbWxv9+/cXOlixSZMm6NWr19/gQj7EzTD+VLRu3ZomTpz4u6fBoLi4mHx8fATKHu/evZsA0J07d4iI6PHjx9ShQwcCQMOGDStTxvR34ciRI6SgoECNGjWiZ8+eEVGJ6W7nzp0kJydHxsbGtGfPHlq8eDE1adKEka0dMmQIHTx4UOjCL1wulw4cOEB6enokKSlJzs7O1ZZgvnfvHgEQqPTo6upaaalsfnlkcQZ38l0FXbt2rbEr5dKlS9SqVSsCQE2bNq2R7HNOTg6Fh4fTjBkzyMjIiLEC9OzZk/z8/Ojly5ci1Xpwd3enevXqMX9HRkZSnz59CAC1atWKzpw5Q5uvxtbMMvD/FgafM0+qfd/CIj8/n86dO0dSUlJkbGxMqqqqBJRUk7SwsKD58+dTWFjYb3Uj8Hg8UlVVpZUrVxJRSfAdALHG79QGeDwebdmyhaSkpMjU1FRkq9zbt29JQ0ODunTpInSRt9OnTxMAevjwYXWm/Mfjr8tAAJycnKhdu3a/exrlUFr2OCQkhFJTU0ldXZ0cHR3LtOPxeBQYGEh16tQhWVlZWrlyJeXl5f3y+ebm5tKUKVMIAI0aNYrJIkhISKC+fUuiw6dMmVIucOnVq1fk7e1N5ubmzMOzZ8+etG3btgqjfEsvckOHDq2xJjrfPCjIdTRp0qRKvx9FRUXUtGlT6tWrV43mUBrTpk0jOTk5evfunVjG43K51KpVK5KRkSEOh0OzZs0SalHi8Xj0+vVr2rBhA/Xu3ZukpaUJABkaGtK0adPo9OnTNQpEmzx5MpmZmVF0dDTZ2dkRAGrSpAmFhISUIUJBEZ+okcc5kWMKjNzOUkP3s1S381CysLCg3Nzcas9VWLi7u5OcnBwlJSVRcXExRUdH0/bt22nUqFGkp6fHxCE0bdqUJk+eTIGBgfThw4daL73Mx9evXwkAhYWFERHRvHnzaq2gUW3gyZMn1KhRI5KXlxc5WPDOnTskJSVFTk5OQr3fXC6X6tevTw4ODtWd7h+Nv4RAANavX0+ysrI1Kp9ZW0hPT6dhw4YRAGrWrBkpKChUWDo5MzOTFixYQJKSklS/fv1fUt+djzdv3jALTukqhCdOnCB1dXXS1tam8PDwKsf5+vUrbdu2jXr27MkUwDE3Nydvb2969eoVPX36lIlL6NChA927d08s809MTCQAdOrUqXLnhg4dSr179660/8mTJ8WWtnX16lUCQFu2bKnxWKWxfPlyUlVVpVWrVpGioiIpKSmRj49PuUUyOzubzpw5Q9OnT6f69eszVoBevXrR+vXr6dWrV2L7XvXu3Zt0dHSIxWJR/fr1KSAgoMLf4efUHLLf86BkoV9cNREwWBRO9nse0OfUHIqMjCQ5OTkaPHhwrZY6Tk1NJUVFRVqwYEGFbT5+/EgHDx6kKVOmULNmzRiCoKenRyNHjqRt27bR8+fPa22e58+fJwAM2bSwsKjVgka1gaysLHJyciIA5ODgUCaFuSrw44VWrVolVPu1a9eSlJRUrcbf/C78JQQCcOXKFQJQrqDNnwIej0ceHh4EgOrUqUMxMTGVtn/16hWzaFpbW9f6fQUFBZVzEWRkZDA/WDs7u2qZ8tPS0ujgwYM0ZMgQJkodAKmqqpKvr69YCVx+fn6F6Undu3enkSNHVtqfx+ORhYVFjcsj//jxgwwMDKhbt25iXxD4C0FcXBx9//6dZs6cyQRg+vj4kJ+fH/Xq1YuxAtSvX5+mT59OZ86cERhsWRN8+vSJJkyYwATH7ty5U2gzbmziD3LaHE51J+8uRwQMF4VTl7XXyPNUTLnUwlOnThGLxapxmdzKsGTJEpKVla0wU0gQkpOT6dSpU7RgwQKytLRkiLCKigr169ePfHx86M6dO2KLdl+zZg3Jy8tTcXEx5ebmlqt4+E/CwYMHSUFBgRo2bEiPHz8Wut/y5cuZdNeqkJqaylhe/234SwgEIDk5Wegvx+8Aj8ejjh07kpGRETVr1oxkZWXL7MIr6hMWFkb169cnSUlJWrBggdg/o7y8PJo6dWo5F8GNGzfIwMCAFBUV6cCBAzVaIDMyMmjx4sUkIyNDysrKZGlpSWpqaiX557q6NGPGDLp8+TKTXlcT8LM2fkbr1q1p+vTpVfa/fv06ATUrjzx16lSSl5en9+/fV3uMipCSkkIA6PDhw5SdnU2nT5+mUaNGkZycHJNv37ZtW9q4cSO9efOmVqxLCQkJ5OzsTFJSUqSpqUlaWlo0c+ZMkcfx8vIiZWVlysorpJj4DIr6lEYx8RlVljTevHkzAaCtW7dW9xYqRFpaGikpKdG8efNqNE5OTg5du3aNVqxYQb169SJ5eXkCQDIyMtSlSxdyc3Oj8+fPV/v37ODgQBYWFkT0v8qZv6I8dm0hNjaWzMzMiMPh0MaNG4X63vJ4PLK3tydpaWm6f/9+le0nTZpEurq6YnnO/En4SwgqQN26dcnNze13T0Mg+FoJV69epZycHEbtb9iwYZSenl5p39zcXFqxYgXJyspSnTp1KDAwUCwPer6LQFpamiEn+fn5tHDhQmKxWNSlS5calVEuKCigzZs3k4aGBsnKypK7uzvzHSsqKqIbN27Q7NmzqV69esxuyt7enk6cOFHt3WzdunXJ09Oz3PF69eoJLVBSk/LIly9fJgC1slvj8Xj08uVLUldXJ319fZKSkmLy6WfMmEFr165lYjj69OlDz58/F+v1U1JSyMXFhWRlZUlFRYVWrVpFWVlZpKGhQV5eXiKPN3jwYLKysqrWXObMmUNsNpvOnDlTrf4VYenSpSQrK1uhS6+6KCoqokePHtGGDRto8ODBjGASm82m1q1bk7OzM4WEhNC3b9+EGq90EPXq1atJSUnpj3SXioL8/HyaO3cuAaD+/fsLFR+Tn59PnTp1Ik1NzSoJ+LNnzwgAhYSEiGvKfwT+EoIKYGNjQ/369fvd0yiHzMxMqlOnTjmVuZCQEEb2WBiG++nTJyYWoUOHDiKZ135GaRcBf2fx7NkzMjExISkpKVq7dm21HzA8Ho+OHTtGDRo0IBaLRePHj680+pnH41FUVBQtWbKETExMmJ3UwIEDaf/+/SJFczdv3pxmz55d7riioiL5+fkJNUZUVBQBoN27dwt9XaKSz7levXpkZWUlNldBVlYWnTp1iqZOnUoGBgbMIqKsrCzQCsDj8ej48ePUoEEDYrPZNH78+BpLt2ZmZpKnpycpKiqSvLw8eXh4MCSWy+USm82mXbt2iTyuoaFhtU3/XC6XbG1tSU5OTmyZIenp6aSsrExz584Vy3iVgcfj0Zs3b2jPnj00duxYRvMBABkbG9PYsWNpz549Aq08RUVFJC0tzahe9uvXr8r4mH8SwsPDSUNDg+rWrUvXr1+vsn1ycjJjea1KnK5Lly7UuXNnMc30z8BfQlABFi1aRHp6er97GuUwf/58kpOTE6i///79e7KwsCBJSUny8fERaiG5evUqNW/enFgsFk2ePFmkBVOQi4DL5dKaNWtISkqKTExMmBiC6uDOnTvUvn37Gu1S4+LiaO3atdSxY0disVjEZrOpW7dutGnTJoFqeKXRsWPHchkchYWFBID2798v9BxGjRpFdevWFSmiffLkyTV2FfB4PHrx4gWtW7eOevTowVgBjI2NaebMmXT27Fny9fUlaWnpSk2ffOuMuro6ycrKkoeHh0hBW0QlgYm+vr6kpqZGMjIyNH/+/HJxJHxX3YkTJ0QaOzU1lXF9VBc5OTnUrl07qlOnjlhSdT09PUlGRkbs1gFhER8fTyEhIeTs7EytW7cmFotFAEhLS4sGDx5MGzZsoEePHjFCbNeuXaPi4mJSVVWl5cuX/5Y51xa+fv1K3bp1IxaLRUuXLq3SWvfq1StSUVGhXr16Vfq7OHbs2D/evfIz/hKCChAUFEQAKDU19XdPhcGLFy9IUlKy0mjYwsJCcnV1JaBEr1+YYKbCwkLauHEjKSsrk6qqKm3durXKH01sbGw5F8GHDx+oS5cuxGKxaOHChdUOenrz5g2Tcta6dWu6fPlytcb5GQkJCbRr1y6ysbFhlBLNzMxoxYoVFB0dXW731L9/fxowYECZY0lJSRVmH1SEuLg4pjaFMLh06RIBoO3btwt9DT6ysrIoLCyMpkyZwrhPZGRkyMbGhjZv3lxOc4CvYS+MhSgjI4MWLVpEMjIypKWlRdu3b6/Sh5qfn0+bN28mbW1t4nA4NG3atAqtDJWlelYGcQUBJyYmkqGhIbVo0aJG0uV864Ag69LvQkZGBp0/f57c3NyoS5cuTKAoPzjX1dWV9u3bJ7bMmD8NXC6XVq5cSWw2mzp37ixwQ1UaV69eJUlJSZoyZUqFLtXCwkLS1dX9ozRraoq/hKACvHjxggAIZWb6FeDxeNSjRw9q0KCBUAutMLLHPyMpKYkmTJhALBaLWrZsWWFlseDg4DIuAh6PRwcOHCBFRUUyMDAQWSO89PWnT59OEhISpK+vT4GBgbWWapWZmUlBQUE0YsQIUlRUJADUoEEDWrBgAd29e5eKi4vJwcGBOnXqVKYff9G6ffu2SNebPn06qaioVCmylJmZSfr6+tS9e3eh7p3H41FMTAytXbuWunfvzhCdhg0b0qxZs+j8+fOVWiZyc3NJQkKCduzYIfS9fP78mRwdHYnFYlHjxo0FprMWFhaSv78/6evrE5vNprFjx1Zp7bh16xYBEFm6es2aNaSgoCCW78rLly9JRUWFevbsWe2AseXLl5OMjIzQPvzfgfz8fLpz5w51796dpKWlSUVFhXEztGvXjhYsWECnTp3642qj1BS3bt1iZI+rIvV8grR+/foK23h5eZGsrOwftXGsCf4SggrA960JijL/HeCbp86ePSt0n4SEBOrVqxezAxD2ARcREcEElI0cOZLx2QtyESQnJ9PgwYMJADk5OVXrc8/JySEvLy9SVFQkZWVl8vX1/aVCSnw1uUmTJjEBWtra2tSiRQsyMDAok/7GVzCsKtXzZwhbHnnSpEmkoKBQaQDmjx8/KDQ0lCZPnkz6+vrMTq9v3760ZcsWkeocEBGZmprSuHHjROpDVCII07NnTwJAnTt3pgcPHhCXy6VDhw4xhX9GjBhBr169Emo8vnaDqKp9I0eOLEfcaoJr164Rh8Oh8ePHixxwm5GRQSoqKjRr1iyxzac2MWjQIOrVqxcVFxfTwIEDSV9fn0aOHEm6uroMQWjWrBlNmTKFDh48WKWb7Z+A1NRUsrW1JQDk7Oxc6bNm0aJFxGKxGNGmn5GUlMTESf0b8JcQVII2bdpU60EpbmRnZ5O+vn4587UwKC4uJl9fX0YqVVifdHFxMe3bt4+0tLRIXl6e5s2bx7gIdu3aRTwej8LDw0lbW5vU1dVF9vsSlZjx9u7dS3Xr1iUOh0Nz5sz57TsSLpdLd+7cofnz5zMys0pKSjRy5Eg6evQohYSEEIBq7f6qKo988eJFAlBut87j8Sg6OprWrFlDVlZWIlsBqsKUKVOoefPm1erL4/Ho/PnzTACnkpISAaABAwaI7FvdtWsXsVgskQNQGzVqJPYFODAwkACInPGwYsUKkpaWrvUS2OKCkZERkxbZoEEDpqAR3wUYGBhIkydPpqZNmzIEQV9fn0aNGkXbt2+n6OjoWhV2qi3weDzaunUrSUtLU6tWrSp0NxUXF9OQIUNITk6uQreag4MDGRoa/uMzM4j+EoJKMX78+D+iBKiHhwdJS0uLvPMrjfv375OhoSEpKSmJlCqTkZHByAxzOBzavHkzZWVlMZLEffv2FTlw6udFZMSIETW6t9rC+vXrSUZGhpYvX06mpqYEgBGJ2b59u0hiM0SVl0fOyMggfX196tmzJ/F4PMrMzKSTJ0/SpEmTGHlbWVlZ6tevH23dulWs79fevXuJxWKJHChI9L/P0szMjACQtLQ0SUpKVovcrVq1ijQ0NETqw3/eHDhwQKR+woAvVnPo0CGh56KqqvrHVgn8GVlZWUyALF+ZMzg4uML2ycnJFBYWRvPnzydzc3Pmt6Cqqkr9+/cnX19funv3rtCCUn8Cnj59So0bNyZ5efkKNVL4Aad169YVmOEUEREhclzRn4q/hKASbNq0iaSlpX9rOeG4uDiSkpKiJUuW1His0rLHkydPFlhitjRKuwhsbGyoa9euBIDk5ORIRkaGdu7cKbJJNSoqinr06FHGzPyn4sCBAwSAecB9+PCBbG1tic1mE5vNJhaLRZ06dSI/Pz+hawzwyyP/XGthwoQJjEuhW7duzMO2cePGNGfOHLp48WKtuVGio6OrFS9z48YN6tSpEwGgjh070vXr1xn3j4KCAikrK9OaNWuEnvecOXOoSZMmIs2BH3cgbp0EohKy4+TkRFJSUhXG05SGl5cXSUlJ1Tg181fhwYMHBJQU4eK7a0QpaJSdnU1Xr16lZcuWUc+ePcsIJnXt2pXc3d3pwoULf/xakJ2dTePGjSMANGbMGIHEOCEhgerVq0etW7cWWKvDwsJCrLVLfhf+EoJKwFeaE9VfLE7079+f6tWrV+XiLSx4PB7t3r2bZGRkqHnz5hXeW2xsLLVu3ZpxERQUFJC7uzuxWCySkpIiDodDixYtErqQzadPn8jBwYFYLBY1adKETp069cvqKlQXp06dIgBlNMs9PT1JV1eXvn//Tvv27aMBAwYwEdstW7akpUuX0pMnTyq8t7y8PNLT06Phw4dTZmYmnThxgqnmxydb/fv3p23btomtkFFV4HK5JC8vL3QWxMOHD5nYlDZt2tD58+fL3W/pAFEDAwM6dOhQlaZle3t7kfO6N27cSDIyMrVG2gsKCqh79+6kqqpaaRYD3zowY8aMWplHbcDf35/YbDbl5ubS/Pnzy1SZrA4KCwspMjKS1q9fT3Z2dqSpqcloXZiamtKsWbPo2LFjvy0VsyocPnyYFBUVqUGDBgL1KJ4/f06Kioo0YMCAcu4BvlicsPEyfyr+EoJKkJaWRgDoyJEjv+X6Z86cIQB0/PhxsY8dExNDzZs3JxkZGSYmgI/g4GBSVFSkhg0b0tOnT+nly5fUpk0bkpSUpBUrVlBmZiYtXbqUpKWlSVdXl44cOVLhApienk4uLi4kLS1NWlpatGPHjt9qcREFfBnX0guBs7MzmZiYlGmXlZVFx48fpzFjxpCysjIBJdX/5syZQzdv3mQeHjwej549e0ZDhgwhACQhIcG4IerVq1erVoCq0LVrVxoyZEilbZ4+fUoDBw5kAs1OnDhRJal7/fo1E8BlZmZG165dq7CttbU12dnZiTRvR0dHMjc3F6mPqEhPT6dmzZqRkZFRhQVtVq1aRVJSUn98yeDSmDVrFjVq1IiIiCwtLWnUqFFiHZ9fGdPf35+cnJyY8tj8jJ5x48bR3r17KTY29o/ZHMTFxVGbNm2Iw+HQ+vXry83r3LlzxGazywlO5efnk5aW1j+KEArCX0JQBfT19cnV1fWXXzcvL4+MjY0Zn3JtICcnh4kFGDZsGCUkJNC0adOY7IKMjAzavHkzycjIUOPGjSkyMrJM//fv3zN6AZ07dy4TRFZQUEAbNmwgNTU1kpOTo6VLl1bLR/07wRdtKa38OGbMGOratWuFfQoKCujSpUs0bdo00tHRIQCkqKhIjRo1InV1dSYWQEFBgZo0aULDhg0jRUVFsYjh1AQLFy4kfX19gedev35NI0aMYESNDh06JHIA1a1bt8jCwoIAUL9+/QRaptq0aUOTJ08WadwWLVrQ1KlTRepTHXz8+JG0tbUFlkz+8eMHqampCVXf4k+ClZUVDRkyhCloVBv1HH5GfHw8HT16lGbOnEmtWrViBJO0tbVpyJAhtHHjRnr8+PFv3TQUFBTQ/PnzmRipnwW0tm3bJlAnZMmSJaSgoPCPXvv+EoIq0L9/f+rTp88vv66XlxdJSkqKnJNdHYSEhJCioiJxOBzicDi0a9cu+vLlC2MWdnZ2rtRlcenSJWrSpAmx2WyaNm0a7dmzh4yMjIjNZtPEiRP/MRHXP+PLly8EgM6fP88cs7GxqXQXy+Px6OnTp+Tt7U1dunRhrAB8lUAZGRmys7Oj2bNnM7slUWWNawP8tNbS2RMfPnygsWPHEpvNJn19ffL3969RMRcej0dHjx4t890ofb169eqJVD8kJyeH2Gz2L3v/KiqZvHr1auJwOFWK3fxJ4PF4pKGhQcuWLWPiMJ48efLL55GRkUHnzp2jxYsXU+fOnRn3m6KiIvXu3ZtWrlxJ169fr1EWTXVx9uxZ0tDQIB0dnXKWrdmzZ5OEhESZZ8PXr19JUlKSNm/ezBzLzi8SqdjW78ZfQlAF3N3dSUdH55de89OnTyQrK1tpDXVxIjg4mOTl5UlGRoYkJCRo1KhRpKysTHXr1hVa1KiwsJBmzJhBbDabANRYtvhPAD8Ku7TLyNLSksaPH1+mXXp6OoWEhND48eOpbt26BIDk5eVp4MCBtGPHDkZT4OXLl7R69Wpq164dQwYkJCRo69atv500ffr0iYmUjo+Pp2nTphGHwyFtbW3atGmTWF0Z+fn55axHWVlZJCcnRxs2bBB6nNJBcb8KP5dMzsrKInV19V9ipRAnEhISCCiRifb29iZFRcU/Im0uLy+Pbt++Td7e3tS3b1/GBcfhcMjS0pIWLlxIp0+f/mVCQPHx8dS9e3disVi0ZMkSxnLB5XKpX79+pKioSNHR0Uz74cOHU4M2nWnpqWjqsuYaGQoqx72mpBx3bOKfZzH9SwiqAD/v/GezUW1i6NChpKOjU+vvYV5eHuMiGDFiBMXFxTH5xtra2kJbJ169esX4lk1MTKh3794EgExNTenOnTu1eg+1CR6PR5KSkmWqDTZq1Ijmz59PUVFRtGrVKurUqRNjBWjWrBnNnz+frly5UqWa5PDhwxk9AT6JsrS0JB8fH3rz5k1t31o58Hg80tTUJAsLC5KRkSFVVVXy8fGpdqVIYZCenk4LFy5k4ktETR/ctm0bSUpKVlsiu7rgl0zetm0b+fj4EIfD+e0uH1HBl8eOjY2l/v37/7ER8lwul549e0Zbt26lESNGMIQbADVv3pymTp1Khw8frtX3n8vlkpeXF0lISFCnTp2Ya/348YNatWpF9erVo4SEBPqcmkP91p0ng0XhVP8nIvDzy8jtLBksCif7PQ/oc6p4AsbFgb+EoAq8fv2aAIhNT78q8HXZhc19ri7i4uKYLIKdO3fSpUuXSFdXl1RUVGjx4sWkra1NWlpadPHixQrHSEhIoKlTpzKR5IcPH2ZMqffu3aM2bdoQALK3t/+jZVwrg6amJnl5eTFWAGlpaUbqWF5engYNGkQ7d+4UScHt7NmzBID8/f2pT58+ZGxsTPv37yc7OzuSlZVlyIWbmxtFRkbWesBVeno6eXh4kISEBElISJCnp2eNtPxFxcePH5lYlHr16tHp06eFuucJEyZQ69atf8EMy2POnDnEYrFISUlJoK7En47169eTrKwsFRYWkpqaGi1btux3T0ko8Hg8ev/+PQUEBNCkSZOoSZMmDEGoV68ejRkzhnbs2EExMTFiF0y6c+cO1atXj1RVVSk0NJSISmS8dXR0qMWgKdTI4xyz0Av7MnI7S408zlFQxJ9BKP8SgirA5XJJVlZW6HK3NUFhYSE1bdqUOnXqVKuLwNGjR5ksgvv37zP+7B49ejB+0MTERGan7+LiUsZ3nJ2dTcuXLyd5eXlSUVGhdevWCTQpc7lc8vf3Jw0NDVJQUKA1a9b8Y0RL+GWU1dXVSVdXl7ECACVFo65evVqte0lPT6e6deuStbU1c43ScQQ5OTkUFhZGTk5OpKamRgBIT0+PZs6cSVevXq2RD/9nZGVl0apVq0hFRYVkZWWpU6dOpKSk9FuU5x49ekQAGHdK165dKSIiotI+pqam5dw3vwpcLpeaN29OACg8PPy3zKEmGDduHLVt25Zevnz5Szc8tYHv379TaGgozZs3j9q1a8f8VtXU1GjAgAG0Zs0aunfvnliePWlpaQx5nTFjBuXl5dGigzdKFnjXMyKRgZ9fW67FVj2BWsZfQiAEzM3Ny5XBrQ34+fkRm82utXKaeXl5NH36dMZFcPPmTWratCnJyMjQxo0byy0EP8sex8bGkr+/P+no6JCUlBTNnz9fKF9eWloaOTs7E5vNpsaNG9OFCxdq5f5qirS0NAoODqaxY8dSnTp1GHO+gYEB7dq1i2JiYggAHT16tNrXGDt2LCkpKZVJT6uoPHJRURFdu3aNnJ2dmZoFqqqq5OjoSKGhodXWpsjLy6MNGzaQlpYWSUlJkbOzM3379o2RTv4dLosLFy4QAPr48SOdPXuWWWxHjhwpUG47Pz//l0XGC0J2djZpaGiQpqYm6ejo/ONcBm3btqVx48YxWgT/tAygypCdnU1XrlwhT09P6tGjB8nJyTHZPd26dSMPDw+6ePFite+Zx+PR9u3bSVpampr0HV8jEvDzK/g3Wwr+EgIhMGnSJGrVqlWtXuPbt2+kqKhIM2fOrJXx4+LiyNTUlKSlpWnbtm20cuVKkpSUJFNTU3rx4kWlfe/fv0/a2tqMr3vUqFFC10QojefPnzNqhwMHDvxlwjsVobi4mB49ekQrV66kDh06MPfXokULWrhwIV27do169epFgwcPJqKSqPua7KbCw8MJAO3du7fMcWHKI/N4PHr06BF5eHgwi6WsrCzZ2trSgQMHhCJmBQUFtHPnTsbiMWHChDKujtTUVAJABw8erNb91QR8YRc+ySkqKipDPufNm1fmHh8/fkwA6N69e798rkREa9euJUlJSYqIiBBLyeRfCb7Vc/369TR27FgyNTX93VOqVRQWFtLDhw/Jz8+PbG1tSUNDgyH7ZmZmNHv2bDp+/LjIUuQX7z4mg4WhVE+AZaCO03pSNOtHHI16xOJIk4SSJsk16UR1J++qlBA08jj3W2MK/hICIbB161bicDi1au52cHAgDQ2NKsvjVgd8F0GDBg3o9OnT1L59e2Kz2eTu7l7lPT169IisrKwIAKM8NmnSpGrvTvmpZ3p6eiQtLU0eHh5iU2EUBqmpqRQUFESOjo6kra3NpDjZ2dnR7t27y6WOjRw5krp3705E/1uEKipyUhnS0tJIR0eHbGxsBLqDhC2PzEdsbCytWbOG2rdvz2QrdO/enTZv3lzuHrhcLgUEBFD9+vWJxWLR6NGjy0kn89GwYcPfosW/YcMGkpOTK3c8OzubVqxYQfLy8qSqqkrr1q2j/Px8Zmf7K787peekqalJEydOJCLxlEz+lYiNjWWIbcOGDWttE/Kngsfj0atXr2j37t3k4OBA9evXZ9yBDRs2pPHjx9O+ffsoLi6uUtet/Z4HZLRY8MIu17gDScirkmKbAaRm40zKne2JLa9CLI4M6UzYWmlMgf2e3yfn/pcQCIHbt28TgFpLo+OP7+/vL9Zxf3YRbNq0ieTl5cnIyIju3r1bad8PHz7Q6NGjCQA1bdqUzpw5Q8XFxeTv70+ysrLUrFmzMuk2oiI7O5vc3d1JSkqK9PX16ejRo7USN8G3AqxYsYIhQvxsCBcXF7p+/XqlpGjatGnMDury5csEoNLSxBXB0dGRlJWVK1SyE7Y8siB8+/aNdu7cSdbW1kzmQps2bWjlypW0fv16aty4MQEgOzu7KjX/x4wZQxYWFiLPoaZwc3OrVDo3MTGRCWA1NDSknj17VrtCY02xbt06kpSULGMlq0nJ5F+NEydOEACmhkVQUNDvntJvx9evXyk4OJhmzJhBLVu2ZAST6tSpQ0OHDqVNmzZRVFQUk5oZm/ij0p2+tv1aqrcwtMyxupN3ESQ4JN+8W5Wug7ik3+PC+UsIhEBGRgYBoMDAQLGPzeVyqVWrVtSuXTuxBnOVdhH4+vpSv379mN19ZfUH0tLSaP78+SQlJUV16tSh3bt3l1MNKy17XJ0CR6Xx9u1bGjBgAAEgKyurGpEMPlJSUujIkSPk6OjIpLMpKirS4MGDyd/fXyR52cWLF5OhoSER/S8FVVTT8OnTpwkA7du3r9J2VZVHFgYZGRl0+PBh6tSpE0N+5OTkyNHRke7du1fld2zTpk0kJSX1y4M/J0+eTG3atKmy3cuXL5kUV3V1dbpx48YvmN3/kJOTQ1paWjRhwoRy5/glk1etWvVL5yQqli1bRhoaGkxBo3+SoNKvQnp6Op09e5YWLVpEnTp1YoTFFBUVydramvou2U/1K7AOVPaS0jYmKW3jKjMPPE/9nvo5oqzfbPxHoaysDENDQzx//lzsY+/atQvPnj3D1q1bwWaL5y0+duwYzMzMkJWVBW9vb6xduxaRkZE4c+YMdu/eDQUFhXJ9CgoK4OfnB2NjY+zcuRNubm6Ii4vDpEmTICkpWaZt8+bNERkZibFjx2Lq1KkYPnw4MjIyqjVXY2NjnD59GufOncPXr1/RunVrzJ49W6TxeDweIiMjsWLFCrRv3x5aWloYPXo0nj59inHjxuHGjRtITU3FiRMnMHHiROjp6Qk9tqqqKtLT0wEAaWlpkJCQgJKSktD909PTMWXKFPTt2xdjx46ttO3ChQshKyuLFStWCD3+z3j8+DG2bt2KO3fuoEOHDvD19cXo0aNx/vx5dOjQAXp6epg2bRouXryIwsLCcv0tLCxQWFhYK9/1ypCcnAwNDY0q2zVt2hQnTpyAlJQU5OTk0K1bNwwcOBCvXr36BbMEdu7cidTUVLi5uZU75+DggOXLl8Pd3R1Hjhz5JfOpDqKjo2FiYoJ79+5BX18f+vr6v3tKfxxUVFTQt29feHt74/bt28jMzMStW7ewePFisNlsPE8pBo9EG5OIUJybAbZc5c+PYh7heuz3Gsz+1+A/SwgAoFWrVnj27JlYx0xJSYGHhwcmTJgAc3PzGo+Xn5+PmTNnYvjw4ejVqxcsLCwwb948dOrUCTExMejfv3+5PjweD0FBQWjSpAlcXV0xfPhwvH37Fp6engKJAx+ysrLYsWMHjh07hsuXL6N169a4f/9+teduY2ODmJgYrF69Gvv27UPDhg2xZ88e8Hg8ge1TU1Nx5MgRODg4oE6dOjA3N4efnx90dXWxe/dufP36Fc+ePYOPjw+6du0KDodTrXmpqqrix48f4PF4SEtLg6qqKlgsltD9Z8+ejdzcXOzevbvKfsrKynBzc8OePXsQFxcn0jzv37+PHj16oEePHuByubh06RJu3boFFxcX+Pv7IyEhAbdu3cKoUaNw8eJF9OnTB1paWhgzZgyOHTuG7OxsACXfcw6Hg4iICJGuX1OkpKRAU1NTqLavX79GYWEhAgMDERQUxCxwU6dORWJiYq3NMTc3F2vWrIGjoyOMjIwEtlmyZAmcnJwwbtw43Lp1q9bmUhPw36+7d++iY8eOv3s6/wjIyMigc+fOWLx4MUJCT0NSuY7IY+S8uIHirFTIN+lcZdvPqbnIKeBWZ6q/DH8JgZgJgbu7O4gI3t7eNR7r7du36NChA/bs2YP58+fj8ePHOHXqFPbt24eTJ08KfNjeuHEDFhYWGD16NFq2bIno6Gjs3LkTdeoI/2UfOnQonj59irp166Jz587w8fGpcBGvClJSUnBxccGbN2/Qp08fTJo0CRYWFnj48CF4PB4iIiKwfPlyWFpaQlNTE2PGjEF0dDQmTJiAmzdvIiUlBcePH8eECROgq6tbrTn8DFVVVRARMjMzkZaWBjU1NaH7njlzBgcPHsTGjRuFns+MGTOgo6MDDw8Podo/efIE/fv3R4cOHZCcnIywsDA8fPgQvXr1KkNAJCQk0LlzZ/j5+eHdu3d4+vQp5s6dixcvXmD48OHQ0NDAgAEDcPjwYTRr1uyXEwJhLQQAEBUVBQAwMzPDyJEj8fr1a6xZswYhISFo0KABVqxYgZycHLHPcffu3UhJSYG7u3uFbVgsFnbv3o1OnTrB1tYWb968Efs8aoK8vDy8ffsWTZo0wePHj/8SgmrgU2oORDQOoCj1C9Iu74C0bhPIm/Sosj0B+Jgq/u+wOPGfJwTfv38X2w7k0aNH8Pf3x8qVK4XeGVUEvovgx48fGDVqFNavXw99fX08f/4c48aNK7czffnyJQYMGAArKyuwWCzcuHEDp06dQtOmTat1fUNDQ9y8eRMuLi5wc3ODtbV1jd6nunXr4uDBgwgPD8f3799haWkJOTk5WFhYYMOGDdDX18eePXsQHx+Pp0+fwtvbG126dKm2FaAyqKioACgx/aenp0NVVVWofmlpaZg8eTL69esHJycnoa8nIyOD5cuXIyQkBI8fP66w3cuXLzFs2DCYmZkhLi4OQUFBePr0KQYNGlSlJYLFYqFVq1bw9PTE06dP8e7dO3h7eyMzMxOTJk3C8+fPERISgg0bNuDDhw9Cz70mEMVCEBUVhYYNGzKuG2lpacybNw/v3r3D1KlTsWrVKjRo0AD+/v7gcsWzy8rLy4Ovry8cHBxgbGxcaVspKSmcOHECOjo66Nu3L75//3PMvy9fvgSPxwObzUZhYeF/nhAUFBQgISEB0dHROHfuHHbs2IElS5Zg0qRJsLW1RefOndGiRQsYGBhAXV0d8vLyaGfRXqRrFGen4/ux5WBLy0PDdjFYbAmh+hVyq7ex+lVgEVGVxOjHjx9QVlZGZmamSL7WPx3v3r1DgwYNcOHCBVhbW9doLB6Phw4dOiAvLw+PHz8u56MXFvn5+ViwYAG2bdsGa2trxMfH482bN1i5ciUWLFgACYmyX7yEhAR4enpi7969MDAwgLe3N4YNGya22AUAuHLlCuzt7UFECAwMFOm9Ki4uxqNHj3D+/HmcP38ekZGRICLo6ekhJSUFbDYby5cvx+zZs2tl8ReEqKgotGnTBo8fP4aXlxfy8/Nx7ty5Kvs5ODggPDwcL168QN26dUW6JpfLRcuWLaGnp4dLly6VOff+/XssW7YMhw8fhr6+Pjw9PeHg4FDt79DP+P79OxYtWoT9+/dDWloaBQUFaNWqFezs7GBnZwcTExORXCbCoLi4GBwOBzt37sTkyZOrbN+lSxfUrVsXwcHBAs9/+PAB7u7uCAoKQvPmzeHr64u+ffvWaN6bNm3C/Pnz8fr1azRo0ECoPh8/foSlpSXq16+Pa9euQVZWttrXFxcOHDiAcePGYfny5Vi7di3S09PF9t35XSgqKkJGRgbS09ORlpaGpKQkfPnyBfHx8UhMTERycjJSU1ORkZGBrKws5OTkIC8vD0VFRVVaM9lsNjgcDmRkZCAvLw9FRUXI6zVGaruqv6cAwMvPQeKRxSj+kQxte19IadQT+r7OOndC87rKQrcXB0RZv//Z35oaon79+lBQUMCzZ89qTAgCAgLw8OFD3Lx5s9o/xnfv3mH48OF48eIFBg8ejDNnzqBx48aIiIhA69aty7TNzs7G2rVrsW7dOsjIyMDPzw/Tpk2DtLR0je5DEHr27Ilnz57ByckJffr0wcKFC+Hl5QUpKSmB7ZOTk3Hx4kWcP38ely5dQkpKCpSVldG7d29MnToVffr0gY6ODlJTU7FkyRK4urpi37592Lx5M3r27Cn2+f8MvkWA/7ARJiDx9OnTOHToEAICAkQmAwAgKSmJVatWYfDgwbh69Sp69OiBr1+/YuXKldi3bx80NTWxZcsWTJw4scL3tbrQ0tLCwoULsX//fhw/fhx5eXkICwvD+vXrsWzZMhgZGcHW1ha2trbo0KFDOdJZHaSnp4OIhLIQ8Hg8xk1SEerXr48jR45g3rx5WLBgAfr37w8rKyusXbsWbdq0EXl++fn58PX1hb29vdBkACixnIWHh6Nr165wcHBASEiIWMl3dRAdHQ0jIyM8evQIlpaWfwwZKC4uRmZmJmOJS0tLQ1paGr59+4Zv374xC3taWlqZhT0/P19oK5CUlBSzsGtpaUFVVRVqamrQ1NSEjo4O6tatCz09PdSvXx86OjpQU1MT+PvKKeCixbKLVboNiFuI78dXgJseD+2RXiKRARYAQ3V5odv/DvwZ35zfBDabDRMTkxrHEWRkZMDV1RWjR49Gly5dqjXGsWPHMHHiRKipqaFFixYIDQ3FvHnz4OXlBRkZGaYdl8vF3r174enpiYyMDMyaNQuLFy8W2uxdXWhra+PcuXPw8/ODm5sbbt68iaCgIBgZGaG4uBiRkZGMFeDRo0cgIpiammLy5MmwsbER+KBSV1fH9u3bMXnyZDg7O6NXr14YPHgw/Pz8YGhoWGv3UtplkJaWhpYtW1baPjU1FVOmTEH//v3h4OBQ7eva2trCwsICCxYsQNeuXbFz504oKCjAx8cH06ZNg5ycXLXHrgqNGzeGoqIiYmJisGjRIgwbNgyFhYW4fv06wsLCcOTIEaxfvx5aWloYOHAgbG1t0aNHjzLfPVGQnJwMAELFELx9+xbZ2dkwMzOrsm3btm1x/fp1nD17Fi4uLmjbti3GjBkDLy8vkb4z/v7+SEpKqjR2oLI5BAUFwdbWFq6urli7dq3IY4gT/IDCO3fuYObMmWIdm4iQlZWFtLQ0ZmHn/25SUlLw7ds3JCUlMQt7ZmYms7AXFBQIfR0JCQnIyspCXl4eOjo6UFFRgbq6OjQ1NVGnTh3o6upCX18fdevWhYaGBjQ0NKCkpCQWMkZEiH0ZDTleLnLYFf8GiVeM5DBfFHx7Da0hHpDWFc0dW09dDvLSf/aS+2fP7hegVatWuHPnTo3G8PT0RF5eXrUeDAUFBZg/fz62bdsGc3NzvHr1CsXFxbh69SqsrKyYdkSEM2fOwNXVFa9fv4a9vT28vLxgYGBQo7mLAjabjYULF6JLly4YPnw4WrRoAVNTU7x58wapqalQUVFB7969MX36dFhbW0NHR0eocVu3bo1bt24hKCgICxcuRNOmTbFo0SK4uLjUiklWWVkZLBZL6BiCWbNmIT8/H7t27aqRiTojIwPGxsY4cuQI3rx5A3d3d8yZMweKiorVHlNYsNlstGvXrkxgoZSUFKytrWFtbY1t27YhIiICoaGhCA0NxZ49e6CgoAAbGxvY2dmhb9++UFYW3tSZkpICAEJZCPgBhaampkKNzWKx0L9/f/Tp0wf79u3D0qVLcezYMcyaNQtubm5Vfp75+fnw8fHBmDFj0LBhQ6Gu+TMGDhyITZs2YdasWahfvz6mT59erXHEgejoaNja2iI1NVVg/AARITc3t8xi/vOu/fv37/j+/Xu5hT03NxdCeJXLQEZGBgoKCtDV1YWKigo0NDTKLOy6urrQ0NCAuro68/odrpeEhAQcOXIEAQEBiI6ORt0Bs8Fp1gNgCSYZ6df2Iu/tQ8g2MEdxXjayY66XOa/QwkpgPwCQYLNg1UhLrPOvFYhb2OCfhh07dtSo/vqzZ8+IzWbTmjVrRO779u1bMjMzIykpKTI1NSUA5ODgUE4kJyIigrp06UIAqHv37tWS2a0puFwu3bt3j5YsWUJt27ZlZEEBUOvWrenKlSvlxI6qgx8/fpCrqytxOBwyMDCgEydO1IpKnIqKCq1Zs4bk5ORo48aNFbYLDQ2tsYDVjx8/aMWKFaSsrExycnJkZGREDRo0EMv7JQoWLVpEurq6Vbbj8Xj04sUL8vLyYspdczgcsra2pp07dwpV9pqvnJecnFxl24ULF5KBgYEwtyAQWVlZ5OnpSXJycqSmpkbr16+v9Pe8ZcsWYrPZYin4NHv2bGKz2b+kOmJ+fj59+/aNXrx4QXfu3KEzZ87Q1q1bGRVLADR8+HDq1asXtW7dmgwMDEhFRYUkJSXL/F5Lv/jqfYJeEhISpKSkRPr6+mRiYkLdu3enkSNH0pw5c2jNmjW0f/9+On36NN29e5dev35NycnJjOrfn4rc3FwKCgoiGxsbYrPZJCUlRUOGDKFZs2aRgYlFpeJC0votKnyvAPwrlAr/00GFQEmud4cOHRAVFSX0DoUPIkK3bt2QlJSE58+fi+T75bsI5OXlUVhYCCLCrl27MHToUKbN+/fv4ebmhqNHj6JFixZYs2YN+vTpI/YAsIqQlJRUJhaAn7Pfu3dv2NjYoHfv3jh37hycnZ1Rv359BAcHw8TERCzXjouLw5w5c3Du3Dn07NkTmzdvrnbGhCAYGRlh6NChWLt2LQIDAwW6AlJTU9G8eXOYm5vj1KlTIr/veXl52LZtG3x8fJCdnY1p06Zh0aJF+PbtG8zMzLB7925MmjRJXLdUJUJDQzF48GB8/fpVpBTOL1++ICwsDGFhYbh58yZ4PB4sLS1hZ2cHW1tbgbvs3bt3Y9q0aSgsLKwyJqFHjx5QVlbGyZMnRb6n0hAUYDt8+PAyn1t+fj4aNGgAKysrHDx4sEbXA0r85EOGDMGVK1dw69atKt0ePwfLCdq18/9OTU1FSkoK0tLS8OPHj0pN8CwWq9KdvKysLJSUlKCqqgoNDQ1oaWmhTp060NbWLrNTL/2Sl5f/Zc+a2gQR4e7duwgMDERISAgyMzPRvn17ODg4gMPhYM2aNYiLi8OwYcNQ1Gkqniflo1hUhaJKIMFmoYOROg5OsBDbmKJApPVb3Azjn4asrCwCQPv37xe5b1BQEAGgixcvCt0nPz+fZsyYQQDI2NiYAFCfPn3K7LpSUlJozpw5xOFwSEdHh/bs2fNLmDeXy6W7d++Sh4cHs+PA/+8+PDw86O7duwJ3tS9evKAWLVqQjIwM7dixQ6w7+jNnzpCxsTFJSkrSvHnzxPYdbN3WggaPn0VSOo1oR3A4ZeeXv69Ro0aRqqqqUDvi0igoKKCtW7eSjo4OSUpK0pQpU8pJyVZUHrk28fXrVwJAoaGh1R4jJSWFDhw4QLa2tiQrK0sAqHnz5uTh4UGPHj1iPnsvLy/S0NCocjwej0cqKiq0cuXKas/pZ8TExFD//v0JAJmbm9OtW7eYc1u3biU2m02vX7+u9vhcLpdSU1Pp7du3FBkZSadOnSIjIyNSUlIiFxcXWrBgAU2YMIEGDx5M3bp1o1atWpGenh7Jy8tXuLvk71alpaVJSkqKkagW1E5FRYWMjIzI3NycmjVrRhISEqSiokLt27enPXv2UGhoKN26dYtevHhBiYmJ/4jiTLWB9+/f0/Lly5nnbL169cjDw4Nev35NoaGh1KJFyY6/X79+FBUVRUREn1NzqJHHObGWP/4nVTv8z1sIAKBBgwYYMGAANmzYIHSf7OxsNG7cGJaWljhx4oRQffhZBNHR0VBRUUFWVhbWr1+PqVOngsViIT8/H1u2bMGqVatQXFwMV1dXzJ07F/LytReZmpSUhAsXLjBWgPT0dKipqTFWAGtra2hra1c5Tl5eHubNm4edO3diyJAh8Pf3F1ugY35+PtavX49Vq1ZBUVERPj4+cHR0FDmgKC4pC4cffsb1N9/xKTUHKLX7YQGopyYHq8ZaGGNRDzH3rmDw4ME4ePAg7O3thRqfy+Xi4MGDWL58OT5//gx7e3t4enoKzHF/+/YtmjZtilWrVsHFxUWk+6gJdHV14eTkhNWrV9d4rNzcXFy6dAmhoaE4c+YM0tPTUa9ePdja2iI+Ph4vXryoUn74w4cPMDIywtmzZ9G3b98az6k0rl+/joULF+Lx48cYNGgQVq5cib59+6JLly44dOgQsrKyKt2pC9q1p6enIzMzs8LdOIvFgqysLNhsNogIXC63wp29rKwsVFVVoampyQTKCdqplz6upKRUZtc+adIkPHjwADExMThy5AhGjRol1vfwn4YfP37g2LFjCAwMxK1btyAvL49hw4bB0dERXbp0wdWrV+Hh4YHIyEh0794dXl5eaN++rAZBcORnLDoZLbY5+Q42wYh2wmcjiBuirN9/CQGAIUOGID09HdeuXRO6z6JFi7Bp0ya8fv1aqMA+vtqehIQEMjMz0bZtWxw8eBCNGjUCj8fDkSNH4O7ujvj4eEyZMgVLly4VaiEWFVwuFw8fPmQyAvgBXW3btoWNjQ1sbGxgbm5e7dSzEydOYMKECVBRUUFQUFC5H1tN8OXLFyxcuBBHjx6FpaUltmzZgrZt21bdLy0XbqHRuP02BRJsVqXmQP754q8xaJ4XjfPHDlZpNuXxeAgJCYGnpydiY2MxdOhQLF++HM2aNau034wZM3DkyBG8f/++1rNE+LCzs0NWVhauXLki1nGLiopw+/ZthIaGIiwsDF+/foWkpCTGjBkDOzs79O7dW2Dg2IkTJzB06FAkJCSIpKYJVB4sVzpg7unTp3jy5Any8/MBlASVZmdno7i4uNyYLBYL0tLSkJKSgoSEBFgsFng8HrOwFxUVCZyLqqoqFBUVER8fD1VVVdjY2EBTU7PCBV5NTa3aGRylYWlpCVlZWdy4cQOfPn1CvXq/b+H5XSguLsaVK1cQGBiI0NBQ5Ofno0ePHnB0dMTgwYMhLy+P27dvw93dHbdv34alpSVWrVqF7t27Vzjm1utxWHcptsZzW9i7MWZYCZ/WWhv4SwhExIoVK7B582YkJycL5TN78+YNTExM4OHhgaVLl1batqCgAAsWLMDWrVuhqqqKzMxMeHp6ws3NDZKSkrh69SoWLlyIJ0+ewNbWFj4+PmjcuLG4bg0AkJiYyFgBLl++zFgBrK2tGSuAlpb4ImA/fvyI0aNHIyIiAitXroSrq6tYc7Vv3rwJZ2dnxMTEYPz48fD29q4wmj048jM8T78Al0ci+QWJVwwZjiSWD2qBkRWweyLC6dOnsWTJEkRHR6Nfv35YuXKl0LEoiYmJMDY2xqxZs8QidS0MvL294ePjg/T09FrLnycidOjQgbnGq1evICcnB2tra9jZ2aF///4MAXJ3d8e+ffsQFRUlcDde1a5dUDEnoCTSXUZGhlnYeTwevn//zuzsK/K5S0lJVbpbF/RSUVFhCPT169dhbW0NR0dH+Pv716oPnsfjQUlJCW3btsW7d+/w5cuXWrvWn4gXL14gMDAQhw4dwrdv39CkSRM4OTlhzJgxTHGnyMhILFmyBBcvXkTr1q3h5eUltKBVdZ8dEmwWJNksrBjY/LdaBvj4SwhExKlTp2BraytUsBURoU+fPoiLi8OLFy8qTZd59+4dRowYgWfPnoHFYsHQ0BCHDx9Gu3btEBMTAxcXF5w/fx6WlpZYu3YtOnXqJJb74XK5ePDgAWMFePLkCVgsVhkrQLt27cQiQFMRioqKsGzZMnh7e6NHjx44ePCgyDvAysDlcrFz504sWbIERIQVK1Zg+vTpZbQOxMXyF/RuhJlW/wucIyJcuXIFHh4eiIiIgJWVFby8vNChQweRx/bw8MD69evx9u3bagkeiYqrV6+iZ8+eePXqFZo0aSK2cX8OlrO3t4eBgQHs7OwQFxeHqKgovHnzhtEnkJeXh6SkJLKysipUlpOWloa8vDyzY2ez2WCxWCguLgaXy0V+fj5yc3ORl5cnsL+ysjKzaOfk5DDS0F+/fkVERASUlJQwfvx4jBw5ElpaWlBXV4ecnFyNF/GDBw/C0dERq1atElhBUVx4//49jI2N0bRpU7Rs2bJClcd/E5KTkxEcHIyAgAA8fvwYampqGDVqFBwdHdGuXTvms4uJicGSJUsQFhaGpk2bYsWKFRg8eLDIJLg61sXODTSw2s4E+mq1pysiCv4SAhHx8eNH1K9fXyg/ZlhYGOzs7HDq1CkMHDiwwnbHjx/H+PHjweVykZeXhxkzZmDNmjVIT0/H0qVLceDAAdSvXx8+Pj4YMmRIjR9CCQkJZawAGRkZUFdXL2MFqGl9hergypUrcHBwAI/HE1n2WBgkJyfDw8MD/v7+aN68ObZs2YJu3brVmh/wzp07cHd3x61bt4QyPVaFzMxMGBkZYdiwYdi5c6fY5lvZ9VRUVBAQEABHR8cy535WlhNlp56VlSXwehwOB4qKipCTk4OMjAxYLBays7ORlZXFVGNks9mQlpZGYWGhQDO+pKRklb71n19qamoMOSwsLETDhg3RoUMHBAUFAaj9DJ7ly5czctSjR48Wy5g/g7+R4XA48PPzg7Ozc61c53ejsLAQZ8+eRUBAAM6ePQsA6NevHxwdHdGvX78y6qxxcXHw9PREcHAw6tevj2XLlmH06NE13vww8Uex3/E5NbeMoiELJaJDVo20YG9ZDw20al9XRBT8zTIQETwej5SUlGj16tWVtsvNzSUDAwOysbGpMJI+Pz+fZs6cyeRua2tr04ULF+jHjx/k4eFBsrKypK6uTps2baKCgoJqz7moqIhu3bpFixcvptatWzM5xebm5uTp6UkPHjz4Y3KCk5KSyNramgDQwoULa3TfFeHRo0fUvn17AkADR4+nhu5nBUb8yrfoUWkuse6MAwL7NXQLJ6sBwxjdhfDwcLFlU6xbt44kJCQoNja2xmPxeDzKzMykjx8/UlRUFF29epWOHz9Ou3fvJl9fX1q0aBGpqKiQsbEx9ezZk9q0aUP169cnFRWVCnPSJSQkSE1NjerVq0dNmjShVq1aUbt27cjCwoIsLCyobdu21LJlS2rUqBHp6emRkpJShe+vgoICGRgYkJmZGfN51alThzgcDgEgHR0dGj58OO3fv5/evn1LmZmZNX6fd+3aRSwWi168eFHu3MOHD6lz584EgHr06MFEm9cUPB6PHB0dSUpKqkyWgzixcuVKUlRUJAC/RZukNsHj8ejhw4c0Y8YMUlNTY7KdNm/eTN+/fy/X/uPHjzRhwgSSkJAgXV1d2rVrV61lV2TnF1FMfAZFfUqjmPgMgRlKfxL+ZhlUA507d0YdPQMs89uGQi4PUpJsGKrLl5Ga5JvAY2JiBOZev3v3DkOHDsXz58/B4/EwdOhQbNmyBSdPnsSyZcuQlZWFOXPmYNGiRSKpvvHx7du3MlaAzMxMaGhoMFaA3r17/xYrgDDg8XhYv349Fi9eDFNTUwQHB1dYf74m1zh06BDcrySCrdNEYAWygvhXKEr/uWojIe3iNkgqa6PuxO0Cx6ZiLiRS32GNTb1qmR4rQ35+PrODPXr0qFDBchX9PyMjo8JgOWVlZeZ3XFRUBFNTU0hJSTG74uLiYhQWFiIvLw85OTnIyspCRkaGQJM8m82GmpqawN25oqIili1bhlmzZmHw4MFldu2ld3NnzpzBwIED8fnzZ2hoaODq1asIDQ3F6dOnkZKSgrp162LQoEGws7ND165dq1XjgW8dsLS0xNGjRwW2of+PBXF1dUVsbCyjAlrTAL3CwkL06dMHz549w71798QeGzRixAhERkbi+/fvyMjI+GNqGNQEX79+ZWqGvH79GnXr1oW9vT0cHR3RvHnzcu0TEhKwevVq7Nq1CyoqKnBzc8PUqVPFErD5b8Ffl4EI4JuCQu6+QC5LrsJUtK56Eujb0RRz584VmLJ14sQJODk5IT8/H7KystixYwfk5eWxaNEixMXFwcHBAV5eXkywizAoKirC/fv3mVgAfiyCubk5EwvQpk2bWo0FEDciIiIwatQopKSkYPfu3RgxYoRYx49LykKvjbdE6pP/5QWSDrtCpYsjlDsMr7TtlbldhDYJFhQUCG12f/PmDd6+fQt1dXVkZWVVGCynqKgIVVVVqKioQEFBAXJycpCWloakpCST6vbzwv7jxw/mOoLIgqysrNABdHwzvbKycoWk6NOnTzA0NKyyiujy5cuxdetWfP/+vYypnsvl4t69e4yM8qdPn6CsrIz+/fvDzs4O1tbWUFBQEOoz8Pf3x+TJkxEdHY0WLVpU2raoqAh79uzBsmXLkJmZiTlz5mDx4sXVIu98ZGRkoGPHjsjPz8eDBw/EStibNWuGvLw8GBsbiz1r5FciJycHoaGhCAgIwNWrVyEjIwM7Ozs4OjqiZ8+eAp9vqamp8PX1xdatWyEtLQ0XFxc4OzsL/b34L+EvIRAC1QkWoW8vcWnVODTW+1/BloKCAsydOxc7duwAUGJpmDdvHvz8/HDnzh306tULa9asKVetsCLEx8eXsQL8+PEDmpqaZawAwhSM+ZORmZmJKVOm4OjRo5g4cSI2bdoktsI+y06/wMGHn0SKCk69uB3ZT85Dd+oeSKpUnOrJZgFddIDe6plCLfQVBbvx88/V1NSYdDUZGRlcuXIF8vLy6N27N4CShbH0ws7376ekpFTos+drx1e2qCcnJ2PmzJk4ffo0evToIfaiSo8fP0bbtm3x+PHjSpX7Bg0ahPz8fFy8eLHCNkSEZ8+eMemMz58/h4yMDHr16gU7OzsMGDCgwt9DYWEhGjdujHbt2iEkJETo+WdlZTGVROXk5LBkyRJMmzat2lUoa6NkckFBAeTl5SEjI4P58+dj+fLlNR7zV4LH4+HWrVsICAjA8ePHkZ2djS5dusDR0RHDhg2rcJ3JzMzE+vXrsWHDBhAR5s6di3nz5jEFy/6iPP4SgipQ3XQSNggcSQksH9gcI9vVw/v379G/f3+8fv0aEhISWLBgAeLi4nDixAmYmJhg7dq1VQbRFRUV4d69e4wV4Pnz52CxWLCwsChjBfjdJVbFDSLCvn374OzsDENDQxw9elQsssdd117Hp7Rc4edRzMXXrY7gqOuhjv2aKtsXpX3Dt92TweFwmAWdv7irqKhAVlYW0tLSTA47/b84UroltgAAO+VJREFUDX9hz87ORkZGBlJTU5mXIGsAh8MROoCO/1JVVRXKbFxQUAAlJSX4+fmJvToeAFy4cAE2NjZV5sXr6+vD3t5epJTLd+/e4dSpUwgNDcXdu3fBYrHQuXNnRka5tCbInj17MGnSJDx//rxa361v375h6dKl2L9/P+rXrw9vb28MHTq0WoGHjx49QteuXWFjYyOWkslPnz5l0lsvXrzIkMg/HXFxcQgMDMTBgwfx6dMnGBkZwcnJCfb29pW6EHNycrBlyxasWbMGeXl5mDlzJlxcXP5YF+mfhL+EoBKIKxWtj04hDriMQkFBAYyNjWFpaYmQkBBoaWnBy8sLDg4OFZry4+PjGQJw5coVxgrQp08fxgqgrq5e4zn+E/Dy5UuMHDkScXFxZVQbfwb9fxnWynbmyek/cEXFpozbpyrkvo1A8vEVUOs9HYpmQijlEaFP9mXkZKYxevP8V0ZGhsDcdkVFRaEi5NXU1DBp0iSw2WxERkbWKgm0sLBA48aNERgYKPaxDx06BAcHB+Tk5FRoffj+/Tu0tbUREhKCYcOGVes6SUlJOHPmDEJDQ3HlyhUUFhbC1NQUdnZ26NevH4YMGYI2bdrg+PHjNbkdREdHw9XVlUkRXrduncCqglXh1KlTsLOzw/z582tcMpmf2shisZCRkfFHP5fT09MREhKCgIAA3L9/H0pKShgxYgQcHR3RsWPHSglWfn4+du/ejdWrVyMtLQ2TJk2Cu7v7L0nR/bdAlPX7nx+FIgKCIz9XSAYKEt8i42YgCuJLpFal6zaBqtU4SGkLZq0XEqTAadwF7ZTy8Pz5c5w+fRrLly/H7Nmzyz0Ei4qKcPfuXYYEREdHg81mw8LCAgsWLICNjQ3MzMz+dVaAn/FzsBx/QZ8xYwYCAwMxffp0rFu3DqampsjOzi7TriL/N1BiJldVVYVivaZAe9F2bzkvbwJsScg1FVIDgsXC9Ucx0JQsgLq6Opo1a1bpDl5NTU0kU/OGDRtgZWWF0NBQDBkyRKR7EQXm5ua4fPlyrYydnJwMOTm5Sl0RT548AYAqiwFVBm1tbUycOBETJ05EVlYWzp8/j9DQUKxdu5YRDOvSpQvu3r0LS0vLasfamJiY4Ny5c4yIWKdOnWBnZwcfHx80atRI6HEGDRqEjRs3Yvbs2TAyMsK0adOqNR+ghKQoKCjA2Nj4jyQDRUVFuHTpEgICAnD69GkUFRXB2toaQUFBGDRoUJVuk6KiIhw4cAArV65EfHw8nJycsHTpUhgaGv6aG/iP4j9jIfiSloueG26igFteBKUg8S2SDrlAQlEDiq37gEDIijoHXn4WdBzXg6OuV64PEQHFRUjaPxOTRw/BkiVLypivvn79WsYKkJWVBS0trTJWADU1tVq959qCKMFyP/9dUbCcgoICZGRkkJaWBg6HAwsLCzRs2LCMSV7Q/5WVlZkH/ZPP6bDbcU/o++AV5uHrFnvI1GsJrWGeQvdb3lEBnZrqoU6dOrVSZ8LGxgYfPnxATExMrUWO83eY6enpYve/uru74/Dhw/j48WOFbby9veHr64v09HSxq/llZ2ejYcOGkJGRQV5eHpKSkqCtrY2BAwfCzs4O3bt3L5PtIApKy4x/+/YNU6ZMgaenp0im6zlz5mDLli04c+ZMtes32NjY4Pbt23BycsK2bduqNUZt4NmzZwgICMDhw4fx/ft3tGjRglEP1NHRqbJ/cXExgoKCsGzZMrx79w4jR47EsmXLxJ6h8V/CXwuBALiFRoNbQbxA5u1DYElKoY7jOkjIlrxh8s2t8G33FGTcDITm4PJqYywWC5CQRF/PQ9jsbIXCwkJcv36dIQExMTFgs9mwtLSEi4sLbGxsYGpq+sdYAbhcbrXS2oQJliu9aDds2LDMAi5ocVdRUQGHwwFQEqE+evRo3L17F9bW1nB1dRV6ZyclKdp7mxv7AFRUAPnm3UTqN2nCOBR9/wCgxB1Qp06dci8dHZ0yf2tqagq9uK9evRpmZmY4cOAAJk6cKNLchIW5uTmAEmnXXr16iXXs5OTkKgNf+eXGa0Pa99ixY0hMTMTTp09hYmKCBw8eMBkL/v7+UFRURN++fWFnZwcbGxuRNjlsNhv29vYYOnQoNm/ejNWrVyMwMBCLFi3CnDlzhArQ9PPzw8ePHzF8+HDcvn1b5LLrQMnCm5OTUy3XhbiRmJiII0eOICAgAM+fP4empibGjBkDR0dHtG7dWqjPmIhw8uRJLF26FC9fvsTAgQNx8uRJtGzZ8hfcwV/w8Z+wEFSVivZ5/TDIGrWBpu2iMse/H1uOvI9PoD87CGypik1cTd8fx51zJZGy2trajBWgV69etWoF4PF4yMzMrNZOvTJluaoWcEH/V1VVFVvuL5fLxbJly7B69Wp0794dBw8eFGp3kVPARYtlFyFsmGhSiCcKvr6EnvNBsDnCzZ0F4PhIA2SkJCExMbHMKyEhgfl/ampqmX5sNhuamppVEoc6depASUkJY8aMwa1btxAXFyeWqPSfwePxoKamhoULF8Ld3V2sYw8ePBh5eXk4f/58hW2MjY1ha2sLPz8/sV6by+WiSZMmaNmyJU6ePFnmHBHhxYsXCAsLQ2hoKKKioiAlJYUePXrA1tYWgwYNErmgWEpKCry8vLB9+3ah4of4yMnJgZWVFb5+/YqHDx+KlI7Mr0UClGQwCFNcTdzIz8/H6dOnERAQgIsXL0JCQgIDBgyAk5MT+vTpwxD8qkBEuHDhAjw8PBAVFYVevXrBy8uLIax/UXP8tRD8hMMPP1eaWkjFRWBJlvfzsjjSQDEXRcmfIK0rWPedeMX4Im2IRYsWwcbGBq1btxbJClBRsJwwO/WKyrCy2exyi7a2tjaaNm1a5UIvDi33mkJSUhJeXl6wsrKCvb09WrVqhcDAQPTp06fSfvLSkqinJidUlkFxbibyPz6FfNMuQpMBoESitE2rFgAqz2kvLCzE9+/fyxEF/is2Nha3bt1CQkICU4WPD74uwLdv39CuXTt06dJFIHnQ1taudiocm81Gu3btEBERUa3+lSE5OblSX296ejrev39fo/iBinD48GG8e/dOYCAhi8VCixYt0KJFC3h4eODTp09MxsK0adMwdepUdOjQAba2trCzsxNYtvpnaGhoYOPGjXB2dsbixYsxbtw4bNiwAWvXrq008l9eXh5nzpyBpaUl+vbtizt37lSqd5BTwMXH1BwUcnmIef4ULI4MNFWVfml1QyLC/fv3ERAQgKNHjyIzM5OpOjpixAiRNz83btyAh4cH7t69i06dOuHGjRvo2rVrLc3+L4TBf4IQXH/zvdL0Qo6aHgq+vQHxihl1OyouQsG3NwAAblYqKvI4stgSUG/ZBXOmmSM9PR0vXrwQaacuTLBc6UXbyMioyp26oqLiH+OaqAl69OiBZ8+ewcnJCTY2NliwYAFWrVpV6SJo1VhLKB2CnFe3AF6xSO4CCTYLVo2EqwopJSUFPT096OmVjz8pDT4hFEQcwsLCEBsbCxaLheTk5DLV+vhQV1cXymWhpqZWjuiZm5tj7969ICKxksCUlBS0a9euwvPiCCgUBC6Xi5UrV2LQoEFC6X4YGBhg1qxZmDVrFlJSUhAeHo7Q0FAsWbIECxcuRIsWLWBnZwc7O7sqTd/GxsYICQnBgwcPsGDBAlhbW6N3795Ys2YNWrVqJbCPtrY2zp07hw4dOmDYsGE4e/ZsmZ01o5//5js+p5XVz9efdwwyRVlYfuYlxljUQ0Pt2tPP//jxIw4ePIjAwEC8ffsW+vr6mDFjBhwdHavl23/48CE8PDxw5coVtGnTBhcuXEDv3r1/+0bkL/4DhCC7gIvPVewYFc36Iu3idqSe2wwlyyEA8ZB57yiKs9MBAMQVHAjHx8eUHCiqaoCK8sudU1BQKLdom5iYVLlTLx0s91+GlpYWzp49y8ge37x5s1LZ4zEW9XDg/scqx815cQNsORXIGLYWei7FPIK9pXh3ZCwWC0pKSlBSUioXsT579mwYGxujf//+8Pb2BpfLRUpKSoVWhy9fviAiIgKJiYnlXEIcDqccacjMzERSUhL27NmDFi1aMMdr6qKoKoYgKioKcnJyIkXoC4MjR47g3bt3IokQ8aGhoYGxY8di7NixyMnJwcWLFxEaGootW7Zg5cqVMDAwYCwHHTt2rDAexNLSErdv30ZYWBhcXV1hamoKR0dHeHl5CSSHTZs2xcmTJ2FtbY1p06bB398fX9PzqhRNY7FYKJBSwsGHn3Dg/kexV9jLysrC8ePHERAQgJs3b0JeXh5Dhw7Frl270K1bt2ptOJ49e4YlS5bgzJkzaN68OU6ePAlbW9u/ROAPwr8+huDFt0z023KnynbpNwPx4+FJgMcFAEjVaQgZIzP8uHcUmoPdIdeofaX9le9vhwplQ0FBAUpKSlBWVoaKigrk5eUhKysLGRkZyMrKlvn/z//+fExYP9x/BXzZ4+TkZOzevRsjR44U2M5h70Pce58qkuhUVZBgs9DBSB0HJ1iIbUxhUN3yyDk5OUhKSqqQPCQmJiI+Ph4JCQnl+iopKQmMbfjZ8qChoVGOtBYXF4PD4WDXrl2YNGmSwLmNHj0anz59wt27d0V7MyoBl8tFs2bN0LRpU5w6dUps4xYVFeHmzZsICwtDWFgY4uPjoa6uzmQs9OzZs0ICVVRUhN27d2P58uXIysrC3Llz4erqKtA1EBgYCCcnJzgs24mH3Hoii6ZJsFmQZLMY0bTqoLi4GNeuXUNAQABOnjyJ/Px8WFlZwcnJCYMHD662LPDr16/h6emJkJAQNGjQAMuXL8eIESP+bnh+Ef4KE5WCKKloxfnZKEr+BLa0PKS0DJF+MwA/7h+DzsTtkNKo/Edm9PYE2OmfkZeXh/z8fOTl5ZX5f35+PgoKCkSau4SEhFDEoapzoo7xJ/9Qf/z4gSlTpiA4OBgTJkzApk2byqX+VZZiWl1IS7JxZW7XX17jvLbLI+vp6cHOzg5TpkyplDwkJCQgPT29TF82mw0tLa0yJEFJSQmbNm3C/PnzMWjQIOa4goICsxNs0qQJevXqhS1btojtPvhplI8ePUKbNm3ENm5p8Hg8PHr0iAlKfP36NeTl5dGnTx9GDElQCuePHz/g6+uL9evXQ0FBAZ6enpgyZUo5wj94yW5EcXVRUhiy+rvmBb0bYaZV+eJrFeHVq1cICAjAoUOHEB8fj0aNGjHqgTWJUfjw4QOWL1+OgwcPQldXF56ennB0dPy70fnF+EsISkFYC4EgJATMRXF2OnSn7wOLVbmJ7KxzJzSvW3kRFB6Ph/z8/DIkQRBxqOiYqO35/y8qKhLpvjkcTo1JhajHZGRkhDZDEhH279+PmTNnVih7HBz5GYtORot035XBd7AJRlRz51VT+Pn5wdXVFa9evRJYZbMmGDJkCNLS0nD9+vUq2xYUFDBWh8rcFvHx8eX6ysnJMemXDx8+RPfu3WFlZVXO8qClpSXyglFcXIxmzZqhUaNGOHPmjEh9a4LXr18z5CAiIgKSkpKwsrJiMhZ0dXXLtP/69SuWLFmCgIAANGjQAD4+PrCzswOLxfrl39fU1FQEBQUhICAAjx49gqqqKkaOHAknJyeYm5vXyIwfHx8PLy8v7NmzB+rq6nB3d8fkyZOrrf3wFzXDX0JQCqKmojH9Xt1Cyqk1ULUaDyWLwZW2ZQGIWWZdplTyn4Ti4uJaIRpVHasoWLIiSElJiUQ0cnNzcenSJaSlpaF///7o1q0b00ZWVhY3U2QQ/rnmwZU594Jw1HM8unfvXuOxqoOfyyOLE76+vvDy8kJGRoZYLEO3bt1C165d8fDhQygpKZUjD8+ePcPFixfRsGFDZGZmIjk5uVygpIaGRoUpmaWPqaiogMVi4fDhw7C3t0dkZCTatm1b43uoDuLj45mMhRs3boDL5cLCwoKJOygdfPf8+XO4uLjg4sWL6NChA1yW+8LlZpZAi1b+p+dICiqvgwIAdRzWVZj9JMiiVVhYiHPnziEgIABnz54FEaFv375wdHRE//79a7xgJycnw8fHB9u3b4ecnBxcXV0xc+ZMsRfP+gvR8JcQ/ISqCt7kf45B5t0gyNQ3BVtWCYXfXiP7+RXI1DeF1tClTOZBRTBQl8PNBVbinvY/HkVFRbVOPnJzc5GUlIScnBxISEiUIyEKLXtDtdcUsNgSYEmIQNh4xQDxoPnpOj5dD0Jqaiq6d+8OIyMjsbhmpKSkRNqF7du3DxMmTBC7Sfz69evo3r07YmJiBNabFxUnT57EkCFDkJKSIrAex+bNm+Hi4oKsrCxwOBwUFRUhOTm5Qj2H0sdycnLKjCUlJQVtbW0kJydDWVkZtra2AsmDtra22DQyhEF6ejrOnj2L0NBQXLhwAbm5uWjSpAmTsdC2bVuwWCxcvnwZCxcuREKTIZA1bA0IsELyCYFimwGQ0ikbhClrZAYJOcFWSX7MS+B4czx+/BgBAQEICir5HpuamsLJyQmjRo2ClpZwWTOVISMjA+vWrcPGjRvBZrMxf/58zJ079x+5Vvwb8VeH4CdUlYomoagOsNn48fAkeIV5kFTRhkoXByiZ21ZJBkRJRfuvgcPhgMPhQFGx9lKi+Dh58iQmTJgAJSUlBAQEwNTUlCENH77/wMZ7SXiWVAg2C6gsVosFAoEF9eJUGKdFApQCbXNzPHjwAFevXsWnT5/A4XAEEh1RwGKxRCIVUlJSUFNTw9ChQzF+/Phqu2Z+Nse3adMGLBYLERERYiEEycnJjA6GIERFRaFly5bMPDgcDurWrStUwGR2dnY5knD16lWcOnUKZmZmiIyMRGJiIpKSksoRQxUVlUrFoPjH1NXVa5yyq6qqCnt7e9jb2yMvLw+XL19GaGgodu/eDW9vb+jq6sLW1ha2trY4dOYK+m9/WOWY0vrNId9EyHobKMmIuf02Bc0su+N1xA3UqVMH48aNg6Ojo1iqigIln8emTZuwbt06FBQUYNasWVi4cOF/pjDbvxH/CQtBVUqFNcWVuV3QQKv2F72/qBx82eOHDx9ixYoV5WSPmbzu2O/4nFo2r5uFEtEhq0ZasLesV+7zLCgowPDhw3HhwgWcOHEC/fv3L3OeiFBQUCB2a0jpc9+/f0d8fDxUVVXB4/GQl5dXYW2IiiAhIVGOLHz+/BnKyspo2rRpjWNGDh06hMOHD+PZs2cCA1VbtmyJDh06iCVAsri4GC1atED9+vVx7ty5MsdTU1OrtDokJiYiIyOj3Pujra0tFHkQtY4Fl8vFnTt3mLiDz58/o06/WZBu0VOgdQD4n4VAw3YRZOubgcWRrnKTwgfxiqGTHYdlA5qjZ8+eYquLkZeXh507d8Lb2xuZmZmYOnUqFi9ejDp16ohl/L8QL/66DATg35SK9hcVo7TssZWVFQ4dOiRQ9ri08puUJBuG6vJVxoAUFhZi5MiRCA8PR0hICGxtbWvpLgSDiNC+fXvweDw8fPgQLBarXKBqdchHeHg4kpOT0adPH6HHEDVQVVJSEjIyMsjOzoaamho0NTVrHJz68OFDeHt7Y9++fWjXrp3AMara7fOLHwlDHn4mXwoKCpUSB/5xQXUsiAhPnjyB47EPyEbF7gw+IWBJyYIK8wAWG9L6zaFqNf7/2rvzuJrT93/gr/fp1GmhVLKLbGVL0YKQaETDDDNDJEPTZwwfa4VhlCTiY2f4GutkMJhpaux79i1KMhliMBFaLC1KdXpfvz9m6jdNdTrndKK4nv/Mo3Pe93XuzKPeV/f7vq8LsoYVbzDV5OPM/Px8bNmyBfPnz8fTp0/h7e2NwMDAN1otkamOE4IyvEtH0VjFoqKiMHLkSBQWFmLr1q0YMGCARuIWFBRg5MiRiIyMxK5du6q0RXFZTp06BRcXF4SHh2vss9etW4fJkycjMzNT6aJEcrm8zBMzM2bMwJMnT/C///2vVDJx+/ZtrF69Gt7e3jAxMVE5gcnNzYUoqvbzW7RRtbKnZnR1dVFYWIjc3Fy8evUKr169QmZmJl6+fFlcfTQ9PR2pqaml+lgIglCij0VR8mBSryH+L60lFB0xfP3od2RdiYReCztI9I1QkJ6EzOhIUMFrNPBaAp0Gissra2LDc2FhIbZv347g4GA8ePAAnp6emDt3Llq1aqV2TPbmcEJQjnfpKBqrWGpqKsaMGYNDhw7B398foaGhatf+/ye5XI5Ro0bh559/xo4dO+Dh4aGB2SpP0+2RY2JiYGdnhwsXLqBbN8UFuCri5uaGWrVq4Zdffin13nfffYdJkyYhKytL7U1+RRtVd+7cWVyPwtLSsspP0Sjxa7IEmUwGHR0daGtrQyKRFG8gFUURcrkcBQUFEI0aof7olar/G7x4jCebJ0HWtD3qe8yr8HpljkSXRRRFhIeHIygoCLdu3cInn3yC4OBgdOiguI8Hq154U2E5htubIz07D0uPJlY61vR+lpwMVHP16tXD/v37sWLFCsycObO47LEyTWsUkUql2LZtG6RSKTw9PVFYWAhPT08Nzbpimm6P3LFjR8hkMkRHR1c6IUhPT4eFhUWZ78XGxqJ9+/aV2vGvra0NLS0trFq1Cm5ubm8kGSMi5OfnazzReCExwkM15qNt3Ah6rR2Rk3ihRP+V8uSruCpKRDhw4AACAgJw/fp1DBgwANu3b6+ygk+s+nivEgIAmOjSGnVryRC0N0Ht8qDzPmrPyUANUXQMqlevXhg+fDhsbW2xfv16jBgxolJxpVIpwsLCIJVKMWrUKMjlcnz++ecamrVitra2GDFiBObOnYuRI0dWuveAjo4ObG1tNdL5UFEfg9jYWI00NAoPD8fNmzexadOmSsdShiAIkMlkkMlkCjsSqqoyRdOkhnWBQjmoIA+CTPEjSx2p8qcmTpw4gYCAAFy6dAnOzs44e/YsevRQ/nQDq9lqfks8NQy3N8dxX2d0b/HX8RgtieLz4EXvd29hiuO+zpwM1ED29va4du0aBg4cCE9PT/j4+JQ6164qLS0tbN68GV988QXGjBmDLVu2aGi2FZs3bx5SUlKwZs0ajcRzcHDQSEKQnp4OMzOzUq/n5+fjxo0blU4IRFHEvHnz8MEHH1R6NeNta25qoHaBYvnLpxCkOhB0FK+2CH9/TkUuXLiAPn36wNXVFaIo4tixYzh58iQnA++Z9zIhAICmJvrY5uOIY1N7YZRjMzQz1S/1wyngr126oxyb4bhvL2zzceQNhDWYoaEhduzYgS1btmDXrl2ws7NDfHx8pWJKJBKsX78e48aNg4+PDzZs2KCh2SrWqlUrjB07FgsXLix1dE4dDg4OuHv3Lp4/f652jFevXiE3N7fMFYKbN28iPz+/0glBREQEEhISEBQUVKk41YGBTArzCn6fFOZklHotP+Uecu5EQ7e5bYUl1c1N9RVuKIyNjcWHH34IJycnPHv2DHv27MGlS5fg6urKXQjfQ+/dI4N/a12/NuZ+1B5z0V6to2isZhEEAd7e3ujatSuGDx8OBwcHLF++HOPHj1f7F6BEIsHatWshlUrx1VdfoaCgABMmTNDwzEsLDAxEWFgYFi9ejNDQ0ErFcnBwAABcuXIFbm5uasVIT08HgDJXCGJjYyEIAjp16qT2HEVRRHBwMFxdXeHk5KR2nOqkoqJpab/+DxJtHcgat/37lMFDZF8/DEFbBuPeYxTGVlQ07ebNm5gzZw5++eUXtGnTBrt27cLQoUMrXZSJ1Wz8f/8fDGRStG9kBFtzY7RvZMTJwDusbdu2uHTpEnx8fDBhwoTiJj/qEgQBq1atgq+vLyZOnIhVq1ZpcLZla9CgAXx9fbFy5Uo8fvy4UrFatWqFOnXqVOqxQVpaGgCUuUIQExMDKysrlYv5/FNkZCR+++23d2J1oMhIR3OF+5j023RFYU4mMqN/xfOj65Bz6yz023RHwzEroF23qcLYhSLBq2vJx5t//PEHRo0ahQ4dOiAmJgbff/89EhIS4OHhwckA4xUC9v7S09PD2rVr4erqii+++AI2NjbYuXOn2n99CoKAZcuWQVtbG1OnToVcLoe/v7+GZ13S9OnTsW7dOoSEhGDdunVqxxEEodL7CCpaIajM44KivQN9+vR5p55rt65fGzYNZIh7nAOUcVrA0O4jGNp9pHLcoqJpRRU3Hz58iJCQEGzZsgX169fH2rVr4ePjo5FjuOzdwSkhe+8NGTIE169fh7m5OZydnbFgwQKVOzUWEQQBixYtwjfffINp06Zh0aJFGp5tSUZGRvjmm2+wceNG3Llzp1KxHB0dER0drfKZ+yLlrRDI5XJcv369UgnBnj17EB8f/06tDsjlcixatAhH53sDpLmCaQAglQgIHdIRKSkpmDp1Klq1aoXIyEgsXrwYd+/exfjx4zkZYKVwQsAYAHNzc5w6dQqzZs1CYGAg+vXrp/YyvCAImD9/PoKCgjBr1izMnz9fw7MtacKECWjYsCECAgIqFcfBwQGpqalISkpSa3x6ejoMDAxKHYO8ffs2cnNz1U4IivYOuLi4oFevXmrFqG5u376NHj16YPbs2Zj0hSdCBmum4VCRr/s2x/8tCUGLFi0QFhaGwMBA3Lt3D35+fpU+psreXfzIgLG/SaVShISEwMXFBV5eXujUqRO2bt0Kd3d3lWMJgoC5c+dCKpUiMDAQcrkcQUFBVbJzW1dXF8HBwfDx8cGMGTPULiBjb28PAIiOjkazZs1UHl9eDYLY2FgAgI2NjVrz2rt3L65fv45Tp06pNb46EUURq1evxqxZs9C0aVOcO3eu+PhkRp6okaJpXaTJ8P34r4JZU6dOxbRp08rtPsnYP/EKAWP/0qdPH1y/fh329vb48MMP4e/vr3JXwSIBAQFYuHAhgoODERgYqPZyfEU+//xztG3bFrNmzVI7Rv369dGsWTO19xGUV4MgNjYWLVu2RJ06dVSOSUQIDg5G79694ezsrNa8qot79+7BxcUFvr6+GDt2LOLi4krUUpjo0hqLPukImVRSYW2Uf9OSAFoQ8frMZhxYMhk+Pj64d+8eFixYwMkAUxonBIyVwczMDPv378eyZcvw7bffwsnJCXfv3lUr1syZM7F06VIsWLAAM2fOrJKkQCqVYsGCBTh27BhOnDihdpzKbCxUtEKg7qrF3r17ERcXV6P3DhARvvvuO1hbWyMpKQknT57EqlWroK9fugaBukXTCh4mIHnjOAyxro+7d+9i+fLlqFev7COHjJWHEwLGyiGRSODn54cLFy7gxYsX6Ny5M3bu3KlWLH9/f6xcuRKLFy+Gv79/lSQFgwcPhqOjI2bNmqV2fAcHB1y9ehVyuVzlsWWtEIiiiGvXrqm1f6BodaBXr17o3bu3yuOrg4cPH8LNzQ3jx4+Hl5cX4uPjK/xelC2aZqwth/z3KDzZ9F/0kdzEzeizWLduHZo0aVJV3w5715ESMjIyCABlZGQoczlj75yMjAzy9PQkAOTt7U3Z2dlqxVmzZg0BoEmTJpEoihqeJdHJkycJAIWHh6s1/vTp0wSA4uPjVR5raWlJvr6+JV5LTEwkAHT06FGV4+3du5cAUFRUlMpj3zZRFGnLli1kaGhIjRs3psOHD1cqXvbrAvot+SXFPHhGSzfvolZW7QkADR06lG7evKmhWbN3kSr3b04IGFOSKIr0/fffk76+PllZWVFcXJxacdavX08AaPz48VRYWKjhWRL179+fLC0tqaCgQOWxWVlZJJFIaNOmTSqPNTU1pdDQ0BKv7dq1iwBQWlqaSrFEUaTOnTtTz549qyRxqkqPHz+mgQMHEgAaPXo0vXjxotIxRVGkyMhI6tChAwGggQMH0rVr1yodl737OCFgrAr9/vvvZG1tTTKZjNasWaPWDWvz5s0kCAJ9+eWXGk8KYmNjCQBt3LhRrfEdO3aksWPHqjRGLpeTIAi0YcOGEq/PmDGDzM3NVZ7Dvn37CAAdP35c5bFviyiK9OOPP5KxsTHVr1+f9uzZo5GYR44cIXt7ewJAffv2pQsXLmhgtux9wQkBY1UsNzeXJkyYQABo8ODB9OzZM5VjhIWFkSAI5O3tTXK5XKPzGzFiBDVu3JhycnJUHuvj40M2NjYqjUlNTSUAFBkZWeJ1V1dXGjx4sEqxRFEkOzs7cnJyqjGrA6mpqfTZZ58RAPLw8KD09PRKxzxz5gz17NmTAFC3bt1q5KMT9vZxQsDYGxIREUHGxsbUtGlTOnv2rMrjd+zYQRKJhEaNGqXRpODOnTsklUpp8eLFKo9dv349aWlp0atXr5Qek5CQQABK/BuIokgmJiY0b948lT7/wIEDBICOHTum0ri3JSIigszMzMjU1JR2795d6XjR0dHk5uZGAMjW1pYOHDhQYxIjVv1wQsDYG/Tnn39Sjx49SCKRUEhIiMo39l27dpGWlhaNGDFCref+5fnvf/9LxsbGKj/DvnbtGgGgc+fOKT2maDPirVu3il978OABAaD9+/crHUcURbK3t6fu3btX+5vg8+fPaeTIkQSAPv74Y3r69Gml4sXHx9PgwYMJALVt25bCw8OrZI8Je79wQsDYG1ZQUECBgYEkCAK5uLhQcnKySuPDw8NJKpXS0KFDKT8/XyNzevLkCenr69OsWbNUGpefn096enq0fPlypceEh4cTgBJL5REREQSAHj9+rHScgwcPEgA6cuSISnN+0w4cOEANGzYkIyMj+uGHHyqVvCQmJtKIESNIEARq0aIF/fDDDxp/hMTeX5wQMPaWREVFUcOGDalu3boq/WVMRPTrr7+StrY2DRkyhPLy8jQyn9mzZ5Oenp7KCYqTkxMNHz5c6eu/++47kkgkJf6iDQgIoAYNGigdQxRFcnR0pG7dulXb1YGMjAzy8fEhAOTm5kYPHz5UO9aDBw/oiy++IC0tLWrSpAmtX79eY8kgY0U4IWDsLUpNTSV3d3cCQH5+fird3Pft20c6Ojo0aNAgev36daXn8vLlSzIxMaFx48apNM7X15datGih9PUhISFkZmZW4jV3d3dyd3dXOsahQ4cIQKXP7FeV48ePk7m5OdWqVYs2bNigdtLy+PFjmjhxImlra1O9evVo5cqVlJubq+HZMvYXTggYe8sKCwtp+fLlpK2tTV26dKE7d+4oPfbQoUMkk8nI3d1dIzeKpUuXkpaWFiUmJio9ZufOnSrVD5gyZQq1a9eu+GtRFKl+/foUEBCg1HhRFKlr167k6OhY7VYHsrOzi0+UuLi40P3799WKk56eTtOnTyc9PT2qU6cOhYaGUlZWlmYny9i/cELAWDVx9epVatmyJdWqVYt27Nih9LijR4+Srq4uubm5qXV08J9yc3OpSZMm5OHhofSYP/74gwDQwYMHlbre09OTevXqVfx1cnIyAaCIiAilxh85coQA0KFDh5Se45tw9uxZatmyJenp6dHq1avV2uT38uVLmjNnDtWuXZtq1apFgYGBGilWxJgyOCFgrBpRt+zxiRMnSF9fn1xdXVU6AliWzZs3EwC6evWqUteLokimpqY0d+5cpa7v168fffrpp8VfFxUWevDggVKf1a1bN3JwcKg2qwM5OTnk7+9PgiBQ9+7dVVpdKZKdnU0LFy4kY2Nj0tXVpWnTpqlcsZGxyuKEgLFq5p9ljy0tLZUuO3v69GkyMDCg3r17V2p5uaCggNq2bUv9+vVTesyAAQOU3gNga2tLX331VfHXwcHBZGJiotQN/ujRowSADhw4oPTcqtLly5fJysqKZDIZLVmyROUd/7m5ubRy5UqqV68eaWtr04QJE1Q6acGYJqly/+Zuh4y9AYIgYMyYMYiJiYGuri66du2KNWvWVNiVsFevXjhy5AiuXr0Kd3d3ZGVlqfX5Re2Rjx49iqioKKXGFLVCrmiOQOlOh7GxsejcuTMEQXH7Xvq7o6GdnR0GDBig1LyqSl5eHmbPno3u3bujVq1aiI2NxbRp06ClpaXU+IKCAmzcuBGtW7eGn58fBg4ciMTERKxZswYNGzas4tkzpgGazjAYY4rl5ubSxIkTiwvaKFP2+OLFi2RoaEjdu3dX++ew6Fifvb29Un+5F1UMvHfvXoVxdXV1aeXKlcWvNW3alGbMmFHhZxw/flzl4kVV4dq1a2RtbU1SqZRCQkJUOv4nl8tp27Zt1LJlSwJAw4cPp9u3b1fhbBlTHj8yYKwGiIyMVKnscXR0NNWpU4ccHR3V3pSmSnvkov4Eu3btUnhddnY2AaDt27eXGFdRGV9RFKlHjx5kZ2f31vYO5Ofn07x580gqlZK1tbVKHQRFUaTw8HBq165dcXJ3/fr1qpssY2rghICxGiIpKam47PG8efMqfF4dExNDxsbGZGdnp1ZDJSLV2iNbWFiQn5+fwmvu379forpg0YmBio5anjhxggDQ3r17lZ+8BiUkJJCdnR1paWnR7Nmzla4XIYoiHTx4kDp37kwAqF+/fnT58uUqni1j6uGEgLEapKCggObMmUOCIFDv3r3p0aNHCq+Pi4sjU1NTsrGxUaurnirtkT08PKhHjx4Kr7ly5QoBoJiYGCIiWrhwIRkaGio8oieKIvXq1Ys6d+78xlcH5HI5LV68mGQyGVlZWal0Mz958iQ5OTkRAOrRowedPn26CmfKWOVxQsBYDRQVFUWNGjUiU1PTCp+px8fHk5mZGVlbW1NqaqrKn6Vse+Rly5aRnp6ewtWEov4DSUlJREQ0dOhQcnZ2Vhg3KiqKANCePXtUnntlJCYmUvfu3UkQBPL391e6xsPFixfJ1dWVAJCdnR0dPny42hyRZEwRPmXAWA3k4uKCuLg4ODo6YuDAgfDz80NeXl6Z13bs2BGnTp1CSkoKXFxckJKSotJnzZs3DykpKVizZo3C6xwcHJCbm4uEhIRyr0lPTwcA1K1bF8D/P2GgSHBwMGxtbTFo0CCV5q0uURTx7bffolOnTkhJScGZM2ewdOlS6OnpKRwXFxeHQYMGoVu3bnj69CkiIyMRHR0NNze3Ck9QMFbjaDrDYIxVjiiKSpc9/v3336lhw4ZkZWWl8ll3ZdojZ2dnk5aWFq1fv77ca5YtW0YGBgZERPTixQsCQNu2bSv3+qKNjb/++qtK81XX/fv3ycXFhQDQhAkTlCoM9fvvv9OwYcMIALVu3Zp+/PFH7kDIaiReIWCsBhMEAb6+vrh48SIyMjJga2uLHTt2lHmtlZUVTp8+jaysLPTu3RvJyclKf05gYCDy8vKwePHicq8xMDBAhw4dEB0dXe416enpxasDcXFxAKBwhSA4OBg2Njb46KOPlJ6rOogIGzduRMeOHfHHH3/g+PHjWLNmDQwMDModc//+fYwZMwbt27fHpUuXsGnTJty8eRMjRoxQuh4BYzUVJwSMVVNdunRBbGwsPv74Y3h5ecHb2xvZ2dmlrmvdujVOnz6N169fw9nZGQ8fPlQqfoMGDeDr64uVK1fi8ePH5V5XVKCoPGlpacVFiWJjY6GnpwdLS8syrz1z5gxOnTqFOXPmVOmS+6NHj+Du7o6xY8fCw8MDN27cQN++fcu9Pjk5GePHj0ebNm1w5MgRrFq1ComJifDx8YFUKq2yeTJWrWh6yYExplmiKFJYWFiFZY/v379PzZs3JwsLC6V6CBAp1x5548aNJJFIyi2dPHjwYOrfvz8REY0cOZK6detWbqw+ffqQtbW1Wk2ClCGKIm3dupWMjIyoYcOGFZZDTk1NJT8/P9LV1SUTExNavHhxpftGMFad8CMDxt4hgiBg9OjRiI2Nha6uLhwdHcsse9y8eXOcPn0agiDA2dkZ9+7dqzC2kZERvvnmG2zcuBF37twp8xoHBweIoojY2Ngy3//3CkF5jwvOnj2LqKgoBAUFQSLR/K+elJQUDBkyBKNHj8bAgQPx22+/wd3dvcxrX7x4gYCAAFhYWGDTpk2YNWsW7t+/j+nTp0NfX1/jc2OsRtB0hsEYqzq5ubk0adKk4sp4ZdUhePjwIbVu3ZqaNm1aYXGgopiK2iMXFBSQvr4+LVmypMz3LS0tydfXl7Kzs0kQBNq8eXOZ1/Xt25c6duxYJasDP/30E5mampKZmZnClstZWVk0f/58qlOnDunp6dHXX3+tVi0HxmoKrkPA2Dvu119/JRMTE2rSpAmdOXOm1PvJyclkaWlJjRo1UqqufkXtkXv27ElDhw4t8z0TExMKDQ2lc+fOEYAyH2kUvffzzz9XOBdVpKenk4eHBwGgTz/9tNyaDDk5ObRs2TKqW7cu6ejo0OTJk+nJkycanQtj1REnBIy9B5KSkqhnz57llj1+8uQJtWvXjho0aEA3b95UGKui9sj+/v7UrFmzMscJgkAbNmyg1atXk46OTpklgD/44APq0KGDRlcH9uzZQ/Xr1ydjY2P68ccfyywUlJeXR+vWraNGjRqRlpYWffnll/Tnn39qbA6MVXecEDD2nqio7HFKSgp16NCB6tWrR7/99pvCWBEREQSATpw4Ueq93bt3EwB6+vRpqfgAKDIyksaMGUNdunQpNfb8+fMEgH766Sc1vsPSXrx4QZ9//jkBoIEDB5ZZf0Eul1NYWBhZWFiQIAjk5eWl1OMTxt41nBAw9p45efJkcdnjffv2lXgvLS2NOnXqRHXr1lXYjU9Re+SiBkb/jp2QkEAA6OzZs2RtbU1ffvllqbj9+vWj9u3ba2R14PDhw9S4cWMyNDSkLVu2lJpnYWEh7d69m6ysrIofI1SUCDH2LuNTBoy9Z3r37o3r16+ja9euGDRoEHx9fYvLHtetWxdRUVEwNzeHi4sLrl27VmYMQRCwaNEiXLlyBRERESXea9asGczMzErVI0hLSwMAGBoaIiEhodQJg4sXL+Lo0aOYM2dOpU4WZGVl4auvvkL//v3Rrl073LhxA97e3sW1DIgI+/fvR+fOneHh4QELCwtcvXoV4eHhaN++vdqfy9h7RdMZBmPs7RFFkVasWEHa2trUuXNnSkxMLH7v+fPnZG9vT3Xq1KErV66UG6O89sgffvghubm5lXgtPDycANDRo0cJQKnOgW5ubtSuXbtKrQ6cPHmSmjdvTgYGBrRu3boSqwKiKNLx48epa9euBIB69+5N586dU/uzGHvX8AoBY+8pQRAwdepUXLx4EZmZmejcuTO2b98OADA2NsaxY8dgZWUFV1dXXL58ucwYoaGhuH37NsLCwkq8XlSxkP5R/yAtLQ0SiQR3796FlpYWrK2ti9+7fPkyjhw5gsDAQLVWB3JycjBlyhS4uLjA3Nwc8fHxGDduXPGqwIULF9CnTx+4urpCFEUcO3YMUVFRcHJyUvmzGGPgFQLG3lWZmZnk5eVFAGj06NHFlQYzMjLIycmJateuTefPny9zbFntkQ8dOkQASmzOCwkJITMzMxo7dixZW1uXiDFgwACysrJSqynQ+fPnqXXr1qSrq0srVqwoscIQExNDAwYMIADUqVMn2rt3L7ciZqwcvELAGEPt2rWxbds2bN26FeHh4ejSpQvi4uJgaGiIw4cPw9bWFm5ubjh79mypsWW1R7a3tweAEvsIiqoU/rtCYXR0NA4dOoQ5c+ao1BTo9evX+Prrr9GzZ0+YmJggLi4OU6dOhUQiQUJCAj777DN06dIF9+7dw+7duxEbG4tBgwZxK2LGNEHTGQZjrPq5desW2djYkI6ODq1evZpEUaTs7Gzq06cP6evr08mTJ0uNKas9csuWLWnKlCnFX3t6elKPHj2K4xZxd3dXeXXg6tWr1K5dO9LR0aGFCxcW72G4e/cueXl5kSAI1Lx5cwoLCyu1v4ExVjZeIWCMlWBpaYmLFy9i3LhxmDx5MgYPHozXr19j3759cHJygru7O06cOFFiTFntkf/d+TAtLQ0ymQz5+fnFKwRXrlzBwYMHERAQoNTqQH5+PoKCguDo6AiZTIaYmBjMnDkTT548wdixY2FpaYmoqCisXbsWt2/fxujRo7kDIWNVQdMZBmOsetuzZ09x2ePTp09Tbm4u9e/fn3R1denw4cMlrp09ezbp6elRcnIyERGtWLGCZDIZvcjKod+SX1LH3oOo64ChJNHRK96jMHDgQGrTpo1SqwPx8fFkY2NDUqmUgoKCKD8/n54+fUpTpkwhHR0dqlu3Li1btqzEXgbGmPJUuX8LRP9qmVaGzMxMGBkZISMjA4aGhlWfpTDGqtSjR4/g6emJ8+fPIygoCNOmTYOHhweOHTuGiIiI4i6BGRkZaNGiBYYNGwa/uYuxdM9l7I+9D23jRiUDEqGZqQHaGRM2zxyDLStD4eXlVe7ny+VyLFmyBEFBQWjTpg22bt0KCwsLLFmyBKtXr4a2tjamT5+OyZMno3bt2lX5T8HYO02V+zcnBIy9p+RyOebPn4+QkBD07NkTW7ZsgZ+fHw4dOoTw8HAMGjQIADBn8WpsiM2EroUttASgUNFvDBIBQQKnlqZY9Ik1mpqUbiV869YtjB49GlevXsX06dPh7++PdevWYdmyZSgsLMTUqVPh7+8PY2PjKvrOGXt/qHL/5j0EjL2npFIp5s6dixMnTuDOnTtwcHDAmDFjMGjQIHzyySeIjIzEritJ2J3VGrJmf9UXUJgMAIDw16+US/efw3XFaey6klT8VmFhIZYvXw5bW1u8fPkSJ06cgKmpKdq2bYvQ0FD85z//wb179zB//nxOBhh7C3iFgDGG9PR0eHt7Y//+/Zg0aRKePHmC40+kMOpZ/rK/sqb1a4MB5hKMGTMG586dw8SJE4sfD6Snp+M///kPAgIC0LhxYw18J4yxf+JHBowxlRERvv32W0yfPh0t+41CTochGouddXwdDNMTMGzYMOzatQuPHj3CqFGjEBQUBAsLC419DmOsJE4IGGNqO3Q2GuP3JYMk2uUW/Ml7ehcZ535E3qObIHkBpHXqo5ZNfxjafVTqWiKChOSQHArFvRtXMGzYMMydOxdt27at6m+FsfeeKvdvPszLGCvhx0SCllSn3P0CufdjkRo+Dzr1W8Ko+3AIOrqQv3yKwqz0Mq8XBAGiKMCg1xe49sMG2NjYVN3kGWNq44SAMVbsTkoWzt4t+8YOAGJeDtL3L4deS3uYDZkFQVBuX7KgJUV27aao1ailpqbKGNMwPmXAGCu243IStCTl9wV4dfMUxFcvYdzrcwiCBGL+axCJSsXWkgjYfimp4gsZY28FrxAwxoqdvJ2KQrH8bUWvH8RBkOlDnv0MqRHzIX+eDEFbFwYdXGDS90sIUp1yxxaKhJOJqZiL9lUxdcZYJXFCwBgDAGTnyZH0PEfhNQXPHwNiIdJ+CUEt637QdR6N10k3kBWzD+LrVzD7eIbC8UnPcvAqTw4DGf/qYay64Z9KxhgA4M9nr1DRkSMqeA0qyEMt2wEw+eArAIC+ZXdQYQGy4w6joOdIaJuUX0+AADx49grtGxlpbuKMMY3gPQSMMQBAvrzivQBFjwQM2jqXeN2gXW8AQF7yLY18DmPszeOEgDEGANCRVvzrQKuW6V//NahT8nWDv/7iF19na+RzGGNvHv9kMsYAAM1NDVD++YK/6DT469igPOtZidflWc8BAFr6ih8FCH9/DmOs+uGEgDEGADCQSWFeRnfCEtdY9QQAZMcfLfF6dvxRQKIFmXlHhePNTfV5QyFj1RT/ZDLGirlY1sO2y3+We/RQp0FLGFh/gFfxx5AmitA174DXSTeQc+scDLsNhbS2abmxtSQCXNrUq6qpM8YqiRMCxlixkY7mCLv4QOE1pm4TIDU0Q3b8ceQkXoTUyAzGfb+Eof3HCscVigSvruYanC1jTJM4IWCMFWtdvzZ6tqqLC/eelbtKIGhJUaeHJ+r08FQ6rpZEQPcWpmhVr7ampsoY0zDeQ8AYKyF0SEdIFZQvVodUIiB0iOL9BYyxt4sTAsZYCU1N9BH8kWbLC8/7qD2aVrBhkTH2dnFCwBgrZbi9Oab1a6ORWNP7WcLDnvcOMFbd8R4CxliZJrq0Rt1aMgTtTYBcJIVNj/5NSyJAKhEw76P2nAwwVkPwCgFjrFzD7c1x3NcZ3Vv8XaGwgr0FRe93b2GK477OnAwwVoPwCgFjTKGmJvrY5uOIOylZ2HE5CScTU5H0LKdEIyQBfxUdcmlTD15dzfk0AWM1kEBEFa4DZmZmwsjICBkZGTA0NHwT82KMVWOv8uR48OwV8uUidKQSNDc14AqEjFVDqty/+SeYMaYyA5mUWxgz9o7hPQSMMcYY44SAMcYYY5wQMMYYYwycEDDGGGMMnBAwxhhjDJwQMMYYYwycEDDGGGMMnBAwxhhjDJwQMMYYYwycEDDGGGMMnBAwxhhjDJwQMMYYYwycEDDGGGMMnBAwxhhjDJwQMMYYYwycEDDGGGMMgFSZi4gIAJCZmVmlk2GMMcaY5hTdt4vu44oolRBkZWUBAJo2bVqJaTHGGGPsbcjKyoKRkZHCawRSIm0QRRGPHz9G7dq1IQiCxibIGGOMsapDRMjKykKjRo0gkSjeJaBUQsAYY4yxdxtvKmSMMcYYJwSMMcYY44SAMcYYY+CEgDHGGGPghIAxxhhj4ISAMcYYY+CEgDHGGGMA/h9PKG8N4ZfesAAAAABJRU5ErkJggg==" }, "metadata": {}, "output_type": "display_data" @@ -209,8 +209,16 @@ }, { "cell_type": "code", - "execution_count": 15, - "outputs": [], + "execution_count": 4, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ] + } + ], "source": [ "def b2s(bit):\n", " return 1 - 2 * int(bit)\n", @@ -234,8 +242,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T11:16:06.695590600Z", - "start_time": "2023-07-11T11:16:06.345459900Z" + "end_time": "2023-07-13T02:33:37.975017500Z", + "start_time": "2023-07-13T02:33:37.740165Z" } } }, @@ -250,7 +258,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "outputs": [], "source": [ "tau_c = 0.025\n", @@ -259,8 +267,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T11:16:06.696505400Z", - "start_time": "2023-07-11T11:16:06.521810800Z" + "end_time": "2023-07-13T02:33:37.999586200Z", + "start_time": "2023-07-13T02:33:37.923540200Z" } } }, @@ -284,10 +292,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "outputs": [], "source": [ - "nlayers = 30 # the number of layers\n", + "nlayers = 20 # the number of layers\n", "\n", "@partial(K.jit, static_argnums=(1, 2))\n", "def wfn_classical(params, each=1, return_loss=False):\n", @@ -324,8 +332,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T11:16:06.697555Z", - "start_time": "2023-07-11T11:16:06.528407400Z" + "end_time": "2023-07-13T02:33:38.001837Z", + "start_time": "2023-07-13T02:33:37.969064900Z" } } }, @@ -351,11 +359,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "outputs": [], "source": [ - "@partial(K.jit, static_argnums=(2,))\n", - "def d_params(params, psi, fixed_global_phase=False):\n", + "@partial(K.jit, static_argnums=(3,))\n", + "def d_params(params, psi, eps=1e-6, fixed_global_phase=False):\n", " psi = psi[:, None]\n", " psiHT = K.conj(K.transpose(psi))\n", " par_psi = K.jacfwd(wfn_classical, argnums=0)\n", @@ -366,21 +374,21 @@ " if not fixed_global_phase:\n", " A -= K.real(jacHT @ psi @ psiHT @ jac)\n", " # protection\n", - " A += 1e-6 * K.eye(params.shape[-1], dtype=A.dtype)\n", + " A += eps * K.eye(params.shape[-1], dtype=A.dtype)\n", "\n", " C = K.real((psiHT * Hv) @ jac)[0]\n", "\n", " return K.solve(A, C, assume_a=\"sym\")\n", "\n", - "@partial(K.jit, static_argnums=(1,))\n", - "def d_params_api(params, fixed_global_phase=False):\n", + "@partial(K.jit, static_argnums=(2,))\n", + "def d_params_api(params, eps=1e-6, fixed_global_phase=False):\n", " if fixed_global_phase:\n", - " qng = experimental.qng(wfn_classical, kernel=\"dynamics\", mode=\"fwd\")\n", + " qng = experimental.qng(wfn_classical, kernel=\"dynamics\", postprocess=None, mode=\"fwd\")\n", " else:\n", - " qng = experimental.qng(wfn_classical, kernel=\"qng\", mode=\"fwd\")\n", - " A = qng(params)\n", + " qng = experimental.qng(wfn_classical, kernel=\"qng\", postprocess=None, mode=\"fwd\")\n", + " A = K.real(qng(params))\n", " # protection\n", - " A += 1e-6 * K.eye(params.shape[-1], dtype=A.dtype)\n", + " A += eps * K.eye(params.shape[-1], dtype=A.dtype)\n", "\n", " vag = K.value_and_grad(partial(wfn_classical, return_loss=True), argnums=0)\n", " loss, C2 = vag(params)\n", @@ -395,22 +403,29 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T11:16:06.698532100Z", - "start_time": "2023-07-11T11:16:06.565856900Z" + "end_time": "2023-07-13T02:33:38.002380500Z", + "start_time": "2023-07-13T02:33:37.969607700Z" } } }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 8, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1999: 6.1109702587127686\tTotal: 12327.309196949005\n" + ] } ], "source": [ @@ -426,24 +441,27 @@ "losses, losses_fgp, losses_exact = [], [], []\n", "losses_api, losses_fgp_api = [], []\n", "\n", + "eps = 1e-6\n", + "t0 = ts = time.time()\n", + "\n", "for i in range(steps_classical):\n", " psi = wfn_classical(params)\n", " loss = K.real(K.tensordot(K.conj(psi) * Hv, psi, 1))\n", - " delta = d_params(params, psi)\n", + " delta = d_params(params, psi, eps)\n", " params = opt.update(delta, params)\n", " losses.append(K.numpy(loss))\n", "\n", " psi_fgp = wfn_classical(params_fgp)\n", " loss_fgp = K.real(K.tensordot(K.conj(psi_fgp) * Hv, psi_fgp, 1))\n", - " delta_fgp = d_params(params_fgp, psi_fgp, fixed_global_phase=True)\n", + " delta_fgp = d_params(params_fgp, psi_fgp, eps, fixed_global_phase=True)\n", " params_fgp = opt.update(delta_fgp, params_fgp)\n", " losses_fgp.append(K.numpy(loss_fgp))\n", "\n", - " loss_api, delta_api = d_params_api(params_api)\n", + " loss_api, delta_api = d_params_api(params_api, eps)\n", " params_api = opt.update(delta_api, params_api)\n", " losses_api.append(K.numpy(loss_api))\n", "\n", - " loss_fgp_api, delta_fgp_api = d_params_api(params_fgp_api, fixed_global_phase=True)\n", + " loss_fgp_api, delta_fgp_api = d_params_api(params_fgp_api, eps, fixed_global_phase=True)\n", " params_fgp_api = opt.update(delta_fgp_api, params_fgp_api)\n", " losses_fgp_api.append(K.numpy(loss_fgp_api))\n", "\n", @@ -452,6 +470,8 @@ " psi_exact /= K.norm(psi_exact)\n", " losses_exact.append(K.numpy(loss_exact))\n", "\n", + " eps *= 0.999\n", + "\n", " # visualise the progress\n", " clear_output(wait=True)\n", " plt.xlabel('Iteration')\n", @@ -462,7 +482,11 @@ " plt.plot(range(i + 1), losses_api, c='m', label='unfixed GP (API)')\n", " plt.plot(range(i + 1), losses_fgp_api, c='y', label='fixed GP (API)')\n", " plt.legend()\n", - " plt.show()" + " plt.show()\n", + "\n", + " te = time.time()\n", + " print(f'Epoch {i}: {te - ts}\\tTotal: {te - t0}')\n", + " ts = te" ], "metadata": { "collapsed": false @@ -479,7 +503,7 @@ { "cell_type": "markdown", "source": [ - "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods are very close, which are also close to the exact final state. And the final states obtained by the same method are almost the same and the difference between them is only one global phase." + "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods but with the same parameter of $\\text{fixed_global_phase}$ are almost the same, which are also close to the exact final state. And the final states obtained by the same method but with the different parameter of $\\text{fixed_global_phase}$ has a global phase difference." ], "metadata": { "collapsed": false @@ -487,43 +511,43 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 9, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "overlap between psi_fgp and psi\n", - "|overlap|: 0.99990623547646\n", - "overlap: (-0.9503999786032177-0.31072875698220964j)\n", + "|overlap|: 0.9184369993048669\n", + "overlap: (-0.4580633040968157+0.7960556080651879j)\n", "\n", "overlap between psi_fgp_api and psi_api\n", - "|overlap|: 0.9993690598239388\n", - "overlap: (0.9469611654290884-0.31937919297062295j)\n", + "|overlap|: 0.9184279183739732\n", + "overlap: (-0.4588479071459403+0.7955931368209131j)\n", "\n", "overlap between psi_api and psi\n", - "|overlap|: 0.9657223380010587\n", - "overlap: (-0.31523027402440384-0.9128250152426423j)\n", + "|overlap|: 0.999999996801054\n", + "overlap: (0.999999545918014-0.0009496135391365943j)\n", "\n", "overlap between psi_fgp_api and psi_fgp\n", - "|overlap|: 0.965709942925926\n", - "overlap: (0.8020707325449846+0.5378459201860204j)\n", + "|overlap|: 0.9999999922593946\n", + "overlap: (0.9999999907968652+5.408381530766986e-05j)\n", "\n", "overlap between psi_exact and psi\n", - "|overlap|: 0.8984756038763727\n", - "overlap: (-0.6177027661071913-0.6524582005803415j)\n", + "|overlap|: 0.8876639929202528\n", + "overlap: (-0.45130602703961775+0.7643757153944926j)\n", "\n", "overlap between psi_exact and psi_fgp\n", - "|overlap|: 0.8972862435422242\n", - "overlap: (0.7891754631522252+0.4269949545469905j)\n", + "|overlap|: 0.9290015132797724\n", + "overlap: (0.9278995939751679-0.04523444679473629j)\n", "\n", "overlap between psi_exact and psi_api\n", - "|overlap|: 0.8687584965464771\n", - "overlap: (0.7726826471199991-0.3971181841232232j)\n", + "|overlap|: 0.8876569548840061\n", + "overlap: (-0.45202998890392976+0.7639396302624046j)\n", "\n", "overlap between psi_exact and psi_fgp_api\n", - "|overlap|: 0.8678331881699551\n", - "overlap: (0.8594146438993552-0.12058570537411661j)\n" + "|overlap|: 0.9290084278770248\n", + "overlap: (0.9279048483224752-0.04526865942553761j)\n" ] } ], @@ -553,15 +577,15 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T20:00:19.268174200Z", - "start_time": "2023-07-11T20:00:19.131845900Z" + "end_time": "2023-07-13T05:59:13.932343300Z", + "start_time": "2023-07-13T05:59:13.843507900Z" } } }, { "cell_type": "markdown", "source": [ - "Then we show the exact solution." + "Then we show the exact solution by the brutal force method." ], "metadata": { "collapsed": false @@ -569,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "outputs": [ { "name": "stdout", @@ -582,7 +606,7 @@ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -601,15 +625,15 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T20:00:19.435090600Z", - "start_time": "2023-07-11T20:00:19.272569900Z" + "end_time": "2023-07-13T05:59:14.080058300Z", + "start_time": "2023-07-13T05:59:13.925677800Z" } } }, { "cell_type": "markdown", "source": [ - "Then we use the bit string with the maximum probability as the approximate solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment. Under the same learning rate ($\\tau$) and update steps, the results obtained by approximate imaginary-time evolution are similar to those obtained by Adam optimizer. The latter can be found in the tutorial of [QAOA for NAE3SAT](qaoa_nae3sat.ipynb)." + "Then we use the bit string with the maximum probability as the approximate solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment. For the hard problem with rough energy landscape, approximate imaginary-time evolution with 20-layer ansatz gives mediocre results, similar to those obtained by the Adam optimizer with 30-layer ansatz, which can be found in the tutorial of [QAOA for NAE3SAT](qaoa_nae3sat.ipynb). However, this does not mean that approximate imaginary-time evolution is more practical than Adam optimizer because under the same ansatz, the former consumes much more time for each step update than the latter. In contrast, the exact imaginary-time evolution gives excellent results but takes exponential time to compute on a classical computer." ], "metadata": { "collapsed": false @@ -617,22 +641,22 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "cost by exact IME: 0.016369858553278067\n", - "cost: 0.027056689321034895\t0.027132044870745352 (fgp)\n", - "cost (API): 0.03343563416109707\t0.034067732605414805 (fgp)\n", + "cost by exact IME: 0.01636900218695893\n", + "cost: 0.03377396891545763\t0.02951298530564577 (fgp)\n", + "cost (API): 0.033775089880425574\t0.0295121140061756 (fgp)\n", "\n", - "max prob by exact IME: 0.13846689405436738\n", - "max prob: 0.040346457516195935\t0.04024638313020584 (fgp)\n", - "max prob (API): 0.03200955784291694\t0.03179869846746198 (fgp)\n", + "max prob by exact IME: 0.13847431901217763\n", + "max prob: 0.03930045644879558\t0.05100224184204695 (fgp)\n", + "max prob (API): 0.03929777441862845\t0.05100594691342963 (fgp)\n", "\n", "bit strings by exact IME: ['111111000000']\n", - "bit strings: ['011001011110']\t['011001011110'] (fgp)\n", + "bit strings: ['111111000000']\t['000000111111'] (fgp)\n", "bit strings (API): ['000000111111']\t['111111000000'] (fgp)\n" ] } @@ -672,8 +696,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T20:00:19.543028600Z", - "start_time": "2023-07-11T20:00:19.434547200Z" + "end_time": "2023-07-13T05:59:14.197783300Z", + "start_time": "2023-07-13T05:59:14.080058300Z" } } }, @@ -713,12 +737,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 13, "id": "2115bb6d", "metadata": { "ExecuteTime": { - "end_time": "2023-07-11T20:00:24.401402200Z", - "start_time": "2023-07-11T20:00:19.512868200Z" + "end_time": "2023-07-13T06:54:56.088379500Z", + "start_time": "2023-07-13T06:54:55.808504500Z" } }, "outputs": [], @@ -752,7 +776,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 14, "outputs": [], "source": [ "l = 10 # the number of layers\n", @@ -780,8 +804,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T20:00:24.430347Z", - "start_time": "2023-07-11T20:00:24.401402200Z" + "end_time": "2023-07-13T06:54:58.940024800Z", + "start_time": "2023-07-13T06:54:58.920216200Z" } } }, @@ -805,11 +829,11 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 15, "outputs": [], "source": [ - "@partial(K.jit, static_argnums=(2,))\n", - "def d_theta(theta, psi, fixed_global_phase=False):\n", + "@partial(K.jit, static_argnums=(3,))\n", + "def d_theta(theta, psi, eps=1e-6, fixed_global_phase=False):\n", " psi = psi[:, None]\n", " psiHT = K.conj(K.transpose(psi))\n", " par_psi = K.jacfwd(wfn_quantum, argnums=0)\n", @@ -820,21 +844,21 @@ " if not fixed_global_phase:\n", " A -= K.real(jacHT @ psi @ psiHT @ jac)\n", " # protection\n", - " A += 1e-6 * K.eye(theta.shape[-1], dtype=A.dtype)\n", + " A += eps * K.eye(theta.shape[-1], dtype=A.dtype)\n", "\n", " C = K.real(psiHT @ K.sparse_dense_matmul(h, jac))[0]\n", "\n", " return K.solve(A, C, assume_a=\"sym\")\n", "\n", - "@partial(K.jit, static_argnums=(1,))\n", - "def d_theta_api(theta, fixed_global_phase=False):\n", + "@partial(K.jit, static_argnums=(2,))\n", + "def d_theta_api(theta, eps=1e-6, fixed_global_phase=False):\n", " if fixed_global_phase:\n", - " qng = experimental.qng2(wfn_quantum, kernel=\"dynamics\", mode=\"fwd\")\n", + " qng = experimental.qng2(wfn_quantum, kernel=\"dynamics\", postprocess=None, mode=\"fwd\")\n", " else:\n", - " qng = experimental.qng2(wfn_quantum, kernel=\"qng\", mode=\"fwd\")\n", - " A = qng(theta)\n", + " qng = experimental.qng2(wfn_quantum, kernel=\"qng\", postprocess=None, mode=\"fwd\")\n", + " A = K.real(qng(theta))\n", " # protection\n", - " A += 1e-6 * K.eye(theta.shape[-1], dtype=A.dtype)\n", + " A += eps * K.eye(theta.shape[-1], dtype=A.dtype)\n", "\n", " vag = experimental.dynamics_rhs(wfn_quantum, h)\n", " C = vag(theta)\n", @@ -848,22 +872,29 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T20:00:24.430347Z", - "start_time": "2023-07-11T20:00:24.417868500Z" + "end_time": "2023-07-13T06:55:01.610891800Z", + "start_time": "2023-07-13T06:55:01.549133100Z" } } }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 16, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGwCAYAAACpYG+ZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABq30lEQVR4nO3dd3gU5d7G8e/spndKKoQSQhWkCoLYEAVEBSuHA0pTBCygoMirIthAUcSC7UixY0dFBAFB6U2KdAihJwQSkpBedt4/FlYiLYSESbk/1zXX7s48M/ObTMjezDwzY5imaSIiIiJSAdisLkBERETkUlHwERERkQpDwUdEREQqDAUfERERqTAUfERERKTCUPARERGRCkPBR0RERCoMN6sLKG0cDgeHDh3C398fwzCsLkdEREQKwTRNjh8/TkREBDbb2Y/rKPj8y6FDh4iMjLS6DBERESmC/fv3U7169bNOV/D5F39/f8D5gwsICLC4GhERESmM1NRUIiMjXd/jZ6Pg8y8nT28FBAQo+IiIiJQx5+umos7NIiIiUmEo+IiIiEiFoeAjIiIiFYb6+IiISKHl5+eTm5trdRlSAbm7u2O32y96OQo+IiJyXqZpEh8fT3JystWlSAUWFBREWFjYRd1nT8FHRETO62ToCQkJwcfHRzd4lUvKNE0yMjJISEgAIDw8vMjLUvAREZFzys/Pd4WeKlWqWF2OVFDe3t4AJCQkEBISUuTTXurcLCIi53SyT4+Pj4/FlUhFd/J38GL6mSn4iIhIoej0llitOH4HFXxERESkwlDwERERkQpDwUdEREQqDAWfS2T3Xxv5Ysxoq8sQEZFLzDAMZs6caXUZcoKCzyWwYNrnxMZeT3iriaz6aa7V5YiIiFRYCj6XwFV3307OsUAMv3QO7BhpdTkiIhfPNCE93ZrBNC+oVIfDwbhx46hduzbe3t40bdqUb7/9FtM06dixI506dcI8scykpCSqV6/O6NHOI/T5+fkMGDDANW/9+vV58803T1vH1KlTueyyy/D09CQ8PJyHH34YgFq1agFw++23YxiG67NYRzcwvAS8/HzITXsMr7zHqNxqA1OfHET/V9+3uiwRkaLLyAA/P2vWnZYGvr6Fbj5u3Dg+++wz3n//ferWrcuff/5J7969CQ4O5uOPP6ZJkya89dZbDB06lEGDBlGtWjVX8HE4HFSvXp1vvvmGKlWqsGzZMgYOHEh4eDj33HMPAO+99x6PP/4448ePp0uXLqSkpLB06VIAVq9eTUhICNOmTaNz587F8qwpuTiGaV5gdC7nUlNTCQwMJCUlhYCAgGJd9sdP3UTNzvNwJAVRs+ZC6rRsVqzLFxEpCVlZWcTGxlK7dm28vLycI9PTy0Twyc7OpnLlysyfP5+2bdu6xt9///1kZGTwxRdf8M0333DfffcxbNgw3n77bdatW0fdunXPusyHH36Y+Ph4vv32WwCqVatGv379ePHFF8/Y3jAMfvjhB7p37174bZQzOuPv4gmF/f7WEZ9L6OZB01m/5Arcqx9i+U+PUKflYqtLEhEpGh8fZwCxat2FtGvXLjIyMrjxxhsLjM/JyaF58+YA3H333fzwww+MHz+e995777TQM3nyZKZOncq+ffvIzMwkJyeHZs2aAc7HJxw6dIgbbrjh4rZJLhkFn0souFYEcf/rQ43q46h2zTJ+eestuj76qNVliYhcOMO4oNNNVkk7Ec5++eUXqlWrVmCap6cnABkZGaxduxa73c7OnTsLtJkxYwYjRozg9ddfp23btvj7+zNhwgRWrlwJ/PP8KCk71Ln5ErvvpZc5tro5ht2Bw/4uebl5VpckIlJuNWrUCE9PT/bt20d0dHSBITIyEoDhw4djs9n49ddfeeutt/j9999d8y9dupR27doxZMgQmjdvTnR0NDExMa7p/v7+1KpViwULFpy1Bnd3d/Lz80tuI+WC6IiPBSpFPIOZ8x/8L9vOJ/83mP4T/md1SSIi5ZK/vz8jRozgsccew+Fw0L59e1fn44CAAKpWrcrUqVNZvnw5LVq04IknnqBPnz5s3LiRSpUqUbduXT755BPmzp1L7dq1+fTTT1m9ejW1a9d2rWPMmDEMGjSIkJAQunTpwvHjx1m6dCmPPPIIgCsYXXXVVXh6elKpUiWrfhyCjvhY4rped7BvQQcAalwxk6Ox+y2uSESk/HrhhRd49tlnGTduHA0bNqRz58788ssv1KpViwEDBjBmzBhatGgBwNixYwkNDWXQoEEAPPjgg9xxxx306NGDNm3akJiYyJAhQwosv0+fPkyaNIl3332Xyy67jFtuuaXAKbPXX3+defPmERkZ6epXJNbRVV3/UpJXdZ3q4I49bNvYEnvVJHb9fAv3v/5zia1LRORinOtKGpFLqTiu6tIRH4tUq1eL2JVdAIi69g92r/jL4opERETKPwUfC/33uQ/JPRCBLeA4f/74pNXliIiIlHsKPhby8fNh39+3A1Dz2iWsnzXH4opERETKNwUfi/V5cRKZO+pgeGWzec2Z7/opIiIixUPBx2Ju7m4cPfhfACKuWsmyz7+xuCIREZHyS8GnFLh37POkbamH4Z5H7I63rC5HRESk3FLwKSWSEu4GnEd9/pr5i8XViIiIlE8KPqXEf58ZS8b2OhgeuWxeM8HqckRERMolBZ9Sws3NzuG93QCo3n4Fm+ctsrYgERFxWbp0KU2aNMHd3Z3u3buzaNEiDMMgOTm5RNdrGAYzZ84s0XVUNAo+pci9z79KVkwtDK9sVi94yepyRETkhMcff5xmzZoRGxvL9OnTadeuHXFxcQQGBlpdGvHx8QwdOpTo6Gi8vLwIDQ3lqquu4r333iMjI8PVrlatWhiGgWEY+Pr60qJFC775puJdUKPgU4q4udk5uLMzADXareTQxq0WVyQiIgAxMTF06NCB6tWrExQUhIeHB2FhYRiGYWldu3fvpnnz5vz222+8/PLLrFu3juXLl/Pkk08ya9Ys5s+fX6D9888/T1xcHOvWreOKK66gR48eLFu2zKLqraHgU8r0Gv0GefEh2AKOM3vas1aXIyJSptWqVYtJkyYVGNesWTPGjBnj+mwYBh999BG33347Pj4+1K1bl59++gmAPXv2YBgGiYmJ9O/fH8MwmD59+mmnuvr378/ll19OdnY2ADk5OTRv3pz77rvPtZ4ff/yRFi1a4OXlRVRUFGPHjiUvL881fefOnVxzzTV4eXnRqFEj5s2bd97tGzJkCG5ubqxZs4Z77rmHhg0bEhUVRbdu3fjll1+49dZbC7T39/cnLCyMevXqMXnyZLy9vfn554r1rEgFn1LGy8eLPWuvBqDmFUvJSUu3uCIRkdOZJqSnWzOUxKO1x44dyz333MPGjRu5+eab6dWrF0lJSURGRhIXF0dAQACTJk0iLi6OHj16nDb/W2+9RXp6Ok899RQATz/9NMnJybzzzjsALF68mPvuu4+hQ4eyZcsWPvjgA6ZPn85LLzm7NTgcDu644w48PDxYuXIl77//PiNHjjxnzYmJifz222889NBD+Pr6nrHNuY5Iubm54e7uTk5OTqF+RuWFm9UFyOk6PTCBXTvm4B4Rz+djRtDvtfesLklEpICMDPDzs2bdaWlwlu/5Iuvbty89e/YE4OWXX+att95i1apVdO7c2XVKKzAwkLCwsDPO7+fnx2effca1116Lv78/kyZNYuHCha6nhI8dO5annnqKPn36ABAVFcULL7zAk08+yXPPPcf8+fPZtm0bc+fOJSIiwlVHly5dzlrzrl27ME2T+vXrFxhftWpVsrKyAHjooYd45ZVXTps3JyeH119/nZSUFDp06HCBP62yTcGnFIqsV5uFH19JjRsXEFznd+d/byw+jywiUp5dfvnlrve+vr4EBASQkJBwQcto27YtI0aM4IUXXmDkyJG0b9/eNW3Dhg0sXbrUdYQHID8/n6ysLDIyMti6dSuRkZGu0HNyeUWxatUqHA4HvXr1cp16O2nkyJE888wzZGVl4efnx/jx4+natWuR1lNWKfiUUtGtnyA7bxF+DXfww7hXuP3/nrK6JBERFx8f55EXq9ZdWDabDfNf58Zyc3NPa+fu7l7gs2EYOByOC6rL4XCwdOlS7HY7u3btKjAtLS2NsWPHcscdd5w2n5eX1wWt56To6GgMw2D79u0FxkdFRQHg7e192jxPPPEEffv2xc/Pj9DQUMs7Z1tBwaeUatetE9++0oyqbdaSnfcToOAjIqWHYRT/6aaSEBwcTFxcnOtzamoqsbGxJbKuCRMmsG3bNv744w86derEtGnT6NevHwAtWrRg+/btREdHn3Hehg0bsn//fuLi4ggPDwdgxYoV51xflSpVuPHGG3nnnXd45JFHztrP51RVq1Y9aw0VhTo3l2I5+d0BCG39F7v+XGVtMSIiZVCHDh349NNPWbx4MX///Td9+vTBbrcX+3rWrVvH6NGj+eijj7jqqquYOHEiQ4cOZffu3QCMHj2aTz75hLFjx7J582a2bt3KjBkzeOaZZwDo2LEj9erVo0+fPmzYsIHFixfz9NNPn3e97777Lnl5ebRq1YqvvvqKrVu3sn37dj777DO2bdtWItta1in4lGL3PDmKnH3VMbyyWTRznNXliIiUOaNGjeLaa6/llltuoWvXrnTv3p06deoU6zqysrLo3bs3ffv2dV0+PnDgQK6//nruvfde8vPz6dSpE7NmzeK3337jiiuu4Morr+SNN96gZs2agPOU3A8//EBmZiatW7fm/vvvL9Af6Gzq1KnDunXr6NixI6NGjaJp06a0atWKt99+29XfSAoyzH+f/KzgUlNTCQwMJCUlxdUb30r/e+Ie6nb9hpz9EXS4ezduXp5WlyQiFUxWVhaxsbHUrl27yP1RRIrDuX4XC/v9rSM+pdwN972ImemFR+QhvnpBNzQUERG5GAo+pVxUk3rEr2oJgFfA/PO0FhERkXNR8CkDPIOcN9Wq3HIj63+aY3E1IiIiZZeCTxlwx9CHyNwZheGWz5pF71pdjoiISJml4FNGHNjRGoAazdaRl3P6zbdERETk/BR8yogO947GzPbAo8YBZo4//bkrIiIicn4KPmVEncsbcnSd81kyOQ718xERESkKBZ8yJCPjRgDCW67n6K6SueW6iIhIeabgU4b0eOo58hOqYvin8+M7z1tdjoiISJmj4FOGePl4sn9dCwCCo/TsLhGR8zFNk4EDB1K5cmUMw2D9+vVcd911DBs2rETXO2bMGJo1a1ai65CiKVPB588//+TWW28lIiICwzCYOXNmgemmaTJ69GjCw8Px9vamY8eO7Ny505piS0i1y+4HwL/xVlZ89aPF1YiIlG5z5sxh+vTpzJo1i7i4OBo3bsz3339fap5h9d1339GhQwcqVaqEt7c39evXp3///qxbt87VZvr06RiGgWEY2Gw2qlevTr9+/UhISLCw8rKrTAWf9PR0mjZtyuTJk884/dVXX+Wtt97i/fffZ+XKlfj6+tKpUyeysrIucaUl58bed5O+LRrDZrJpxTSryxERKdViYmIIDw+nXbt2hIWF4ebmRuXKlfH397e6NEaOHEmPHj1o1qwZP/30E9u3b+eLL74gKiqKUaNGFWgbEBBAXFwcBw4c4H//+x+//vor9957r0WVl3FmGQWYP/zwg+uzw+Eww8LCzAkTJrjGJScnm56enuaXX35Z6OWmpKSYgJmSklKc5RarD0fcZS5ciPnr/2qbpsNhdTkiUs5lZmaaW7ZsMTMzM60u5YL06dPHBFxDzZo1TdM0zWuvvdYcOnSoaZqmuXXrVtPb29v8/PPPXfN99dVXppeXl7l582bTNE3z2LFj5oABA8yqVaua/v7+5vXXX2+uX7++wLrGjRtnhoSEmH5+fmb//v3NkSNHmk2bNj1rbcuXLzcB88033zzjdMcpf9unTZtmBgYGFpj+0ksvmTabzczIyCjkT6N8ONfvYmG/v8vUEZ9ziY2NJT4+no4dO7rGBQYG0qZNG5YvX37W+bKzs0lNTS0wlHZXdhuBmW/DKzqW3975yOpyRKQCMk2T9Jx0SwbTNAtV45tvvsnzzz9P9erViYuLY/Xq1ae1adCgAa+99hpDhgxh3759HDhwgEGDBvHKK6/QqFEjAO6++24SEhL49ddfWbt2LS1atOCGG24gKSkJgK+//poxY8bw8ssvs2bNGsLDw3n33XPfZf/LL7/Ez8+PIUOGnHG6YRjnnN/b2xuHw0FeXl5hfhRyCjerCygu8fHxAISGhhYYHxoa6pp2JuPGjWPs2LElWltxa9K+DT++2ZDApps5uP874AGrSxKRCiYjNwO/cX6WrDttVBq+Hr7nbRcYGIi/vz92u52wsLCzthsyZAizZ8+md+/eeHh4cMUVV/DII48AsGTJElatWkVCQgKenp4AvPbaa8ycOZNvv/2WgQMHMmnSJAYMGMCAAQMAePHFF5k/f/45u1ns2LGDqKgo3Nz++RqeOHEio0ePdn0+ePAggYGBp827c+dO3n//fVq1alUqTtmVNeXmiE9RjRo1ipSUFNewf/9+q0sqlISDzie2V7/8bz3CQkTkIk2dOpWNGzfy119/uToTA2zYsIG0tDSqVKmCn5+fa4iNjSUmJgaArVu30qZNmwLLa9u27QXX0L9/f9avX88HH3xAenrBI1spKSn4+fnh4+ND/fr1CQ0N5fPPP7+ILa64ys0Rn5Np/vDhw4SHh7vGHz58+JyXFHp6erpSfFlyU7+n2b1vBu7VD/HzaxO5/f9GWl2SiFQgPu4+pI1Ks2zdxW3Dhg2kp6djs9mIi4tzfY+kpaURHh7OokWLTpsnKCioyOurW7cuS5YsITc3F3d3d9fygoKCOHDgwGnt/f39+euvv7DZbK4rl6Voys0Rn9q1axMWFsaCBQtc41JTU1m5cmWRkndpV7NhPZI2XAZAWroeYSEil5ZhGPh6+FoynK//y4VKSkqib9++PP300/Tt25devXqRmZkJQIsWLYiPj8fNzY3o6OgCQ9WqVQFo2LAhK1euLLDMFStWnHOdPXv2JC0t7bx9gU6y2WxER0cTFRWl0HORytQRn7S0NHbt2uX6HBsby/r166lcuTI1atRg2LBhvPjii9StW5fatWvz7LPPEhERQffu3a0rugQlJ11JFdYR0XwjOekZePgW//+CRETKu0GDBhEZGckzzzxDdnY2zZs3Z8SIEUyePJmOHTvStm1bunfvzquvvkq9evU4dOgQv/zyC7fffjutWrVi6NCh9O3bl1atWnHVVVfx+eefs3nzZqKios66zrZt2zJ8+HCGDx/O3r17ueOOO4iMjCQuLo4pU6a47tkjxa9M/VTXrFlD8+bNad68OQCPP/44zZs3d3UGe/LJJ3nkkUcYOHAgV1xxBWlpacyZMwcvLy8ryy4x3YY+h5nug71qEt+9PN7qckREypxPPvmE2bNn8+mnn+Lm5oavry+fffaZ6145hmEwe/ZsrrnmGvr160e9evX4z3/+w969e10X0/To0YNnn32WJ598kpYtW7J3714GDx583nW/9tprfPHFF6xbt45bbrmFunXrcvfdd+NwOFi+fDkBAQElvfkVkmEW9rrACiI1NZXAwEBSUlLKxC/dN+NbEXzlWg7Mu47eLy20uhwRKYeysrKIjY2ldu3a5fY/klI2nOt3sbDf32XqiI+cLjWlNQDhl28mNyPb4mpERERKNwWfMu7Wh57GzPLEHnqEHydMtLocERGRUk3Bp4wLqV6NpI3Ou4tmZM23uBoREZHSTcGnHDiW6LyZYUSTLbqZoYiIyDko+JQDnQY8hZntgVtEPL9MetvqckREREotBZ9yILJeHZI3NQTgWKJuZigiInI2Cj7lxNH4ZgBENN4MukOBiIjIGSn4lBMdeg3HzHXDI/IQcyd/YHU5IiIipZKCTzlRp1kTjm+tB8CBPbMsrkZERKR0UvApRw7vbQxAWPR2iysREREpnRR8ypFG7fsB4FMvhk3zfre4GhGR8mPp0qU0adIEd3d3unfvzqJFizAMg+Tk5BJdr2EYzJw5s0TXcT7PPvssAwcOLPH1XHnllXz33Xclvh4Fn3Lkqts7kx1TC8NmsvzXj6wuR0Sk3Hj88cdp1qwZsbGxTJ8+nXbt2hEXF0dgYKDVpREfH8/QoUOJjo7Gy8uL0NBQrrrqKt577z0yMjJc7WrVqoVhGBiGga+vLy1atOCbb74577LffPNNnn766dOmLV++HLvdTteuXU+btmfPHte6DMOgSpUq3HTTTaxbt87V5rrrrmPYsGGuz8888wxPPfUUDoejCD+FwlPwKWcO7WgAQJWILRZXIiJSfsTExNChQweqV69OUFAQHh4ehIWFYRiGpXXt3r2b5s2b89tvv/Hyyy+zbt06li9fzpNPPsmsWbOYP7/gHf2ff/554uLiWLduHVdccQU9evRg2bJlZ13+Rx99RLt27ahZs+Zp06ZMmcIjjzzCn3/+yaFDh844//z584mLi2Pu3LmkpaXRpUuXsx4l69KlC8ePH+fXX38t/A+gCBR8yhn/qp0BqNR4G4l79llcjYiUV6Zpkp+eb8lgXsAtO2rVqsWkSZMKjGvWrBljxoxxfTYMg48++ojbb78dHx8f6taty08//QT8c+QiMTGR/v37YxgG06dPP+1UV//+/bn88svJznY+LDonJ4fmzZtz3333udbz448/0qJFC7y8vIiKimLs2LHk5eW5pu/cuZNrrrkGLy8vGjVqxLx58867fUOGDMHNzY01a9Zwzz330LBhQ6KioujWrRu//PILt956a4H2/v7+hIWFUa9ePSZPnoy3tzc///zzWZc/Y8aM05YBkJaWxldffcXgwYPp2rUr06dPP+P8VapUISwsjFatWvHaa69x+PBhVq5ceca2drudm2++mRkzZpx3uy+GW4kuXS65bo8+xJ8/vYA9OJFZ70+gz3jdyVlEip8jw8Fiv8WWrPvqtKux+9qLdZljx47l1VdfZcKECbz99tv06tWLvXv3EhkZSVxcHPXr1+f555+nR48eBAYGnvbl/dZbb9G0aVOeeuop3njjDZ5++mmSk5N55513AFi8eDH33Xcfb731FldffTUxMTGufjPPPfccDoeDO+64g9DQUFauXElKSkqB00BnkpiY6DrS4+vre8Y25zoi5ebmhru7Ozk5OWecnpSUxJYtW2jVqtVp077++msaNGhA/fr16d27N8OGDWPUqFHnXJ+3tzfAWdcH0Lp1a8aPH3/W6cVBR3zKGXdPNw5vcj601N17rcXViIiUDX379qVnz55ER0fz8ssvk5aWxqpVq7Db7a5TWoGBgYSFhbm+wE/l5+fHZ599xuTJkxk9ejSTJk3i008/JSAgAHAGq6eeeoo+ffoQFRXFjTfeyAsvvMAHHzjvuzZ//ny2bdvGJ598QtOmTbnmmmt4+eWXz1nzrl27ME2T+vXrFxhftWpV/Pz88PPzY+TIkWecNycnh3HjxpGSkkKHDh3O2Gbfvn2YpklERMRp06ZMmULv3r0B6Ny5MykpKfzxxx9nrTU5OZkXXngBPz8/WrdufdZ2ERER7N+/v0T7+eiITzmUldUaWExo423kZWfj5ulpdUkiUs7YfGxcnXa1Zesubpdffrnrva+vLwEBASQkJFzQMtq2bcuIESN44YUXGDlyJO3bt3dN27BhA0uXLuWll15yjcvPzycrK4uMjAy2bt1KZGRkgZDRtm3bIm3LqlWrcDgc9OrVy3Xq7aSRI0fyzDPPkJWVhZ+fH+PHjz9j52SAzMxMALy8vAqM3759O6tWreKHH34AnEeOevTowZQpU7juuusKtG3Xrh02m4309HSioqL46quvCA0NPWvt3t7eOBwOsrOzzxgwi4OCTzl0y0NPsnnTu9irHGPW25PoPuLMiV9EpKgMwyj2000lwWazndYnKDc397R27u7uBT4bhnHBRx0cDgdLly7Fbreza9euAtPS0tIYO3Ysd9xxx2nz/TtYFFZ0dDSGYbB9e8F7t0VFRQGcMTg88cQT9O3bFz8/P0JDQ895aqpq1aoAHDt2jODgYNf4KVOmkJeXVyCkmaaJp6cn77zzToEr3b766isaNWpElSpVCAoKOu82JSUl4evrW2KhB3Sqq1wKqRHiemhpcuL887QWESm/goODiYuLc31OTU0lNja2RNY1YcIEtm3bxh9//MGcOXOYNm2aa1qLFi3Yvn070dHRpw02m42GDRuyf//+ArWuWLHinOurUqUKN954I++88w7p6emFqrFq1apER0cX6oq0OnXqEBAQwJYt/1wlnJeXxyeffMLrr7/O+vXrXcOGDRuIiIjgyy+/LLCMyMhI6tSpU6jQA7Bp0yaaN29eqLZFpeBTTh095LyLc2j0TosrERGxTocOHfj0009ZvHgxf//9N3369MFuL/4jVevWrWP06NF89NFHXHXVVUycOJGhQ4eye/duAEaPHs0nn3zC2LFj2bx5M1u3bmXGjBk888wzAHTs2JF69erRp08fNmzYwOLFi89475x/e/fdd8nLy6NVq1Z89dVXbN26le3bt/PZZ5+xbdu2i9pWm81Gx44dWbJkiWvcrFmzOHbsGAMGDKBx48YFhjvvvJMpU6YUeX3g7AR+0003XdQyzkfBp5y6/HrnXZy96+xl04IFFlcjImKNUaNGce2113LLLbfQtWtXunfvTp06dYp1HVlZWfTu3Zu+ffu6Lv0eOHAg119/Pffeey/5+fl06tSJWbNm8dtvv3HFFVdw5ZVX8sYbb7juj2Oz2fjhhx/IzMykdevW3H///QX6A51NnTp1WLduHR07dmTUqFE0bdqUVq1a8fbbb7v6G12M+++/nxkzZrhO+02ZMoWOHTue8caNd955J2vWrGHjxo1FWtfBgwdZtmwZ/fr1u6iaz8cwL+SGCBVAamoqgYGBpKSkuHrjl1Vzp9TGs84edv7yXx6Y8LnV5YhIGZWVlUVsbCy1a9cucn8UKZtM06RNmzY89thj9OzZs0TXNXLkSI4dO8aHH3541jbn+l0s7Pe3jviUY4d3OC9xDKq61eJKRESkLDIMgw8//LDAjRZLSkhIyEUfoSoMXdVVjtk8rgLmUqXRTrLT0/D09bO6JBERKWOaNWtGs2bNSnw9w4cPL/F1gI74lGu3DR2GedwPm38aP73zmtXliIiIWE7BpxwLqOrPsc3Oh5ampSw5T2sREZHyT8GnnEuMcz6+Iix613laioiIlH8KPuXcZe2dTwb2jtrL1j8XWVuMiIiIxRR8yrl2d99ATkxtAJb98j+LqxEREbGWgk8FEL+jHgABVXRZu4iIVGwKPhWB3fmE3yoNd5KbnWlxMSIiItZR8KkAug0bhpnm67ys/c03rC5HROSSMU2TgQMHUrlyZQzDYP369Vx33XUMGzasRNc7ZsyYS3Lvm3NJTEwkJCSEPXv2lOh65syZQ7NmzS74afZWUfCpAAJDAkneFg1AylFd1i4iFcecOXOYPn06s2bNIi4ujsaNG/P9999fkjsEF8Z3331Hhw4dqFSpEt7e3tSvX5/+/fuzbt06V5vp06djGAaGYWCz2ahevTr9+vUjISHhnMt+6aWX6NatG7Vq1TptWqdOnbDb7axevfq0aX379nWtz8PDg+joaJ5//nnX3ZsXLVqEYRgkJycD0LlzZ9zd3fn887LxaCQFnwriaFxdAEJq7ra4EhGRSycmJobw8HDatWtHWFgYbm5uVK5cGX9/f6tLY+TIkfTo0YNmzZrx008/sX37dr744guioqIYNWpUgbYBAQHExcVx4MAB/ve///Hrr79y7733nnXZGRkZTJkyhQEDBpw2bd++fSxbtoyHH36YqVOnnnH+zp07ExcXx86dOxk+fDhjxoxhwoQJZ11f3759eeuttwq55dZS8KkgajbuBoBvvRgObY2xuBoRKetM0yQ/P92SobDP1u7bty+PPPII+/btwzAM15GPU091bdu2DR8fH7744gvXfF9//TXe3t5s2bIFgOTkZO6//36Cg4MJCAigQ4cObNiwocC6xo8fT2hoKP7+/gwYMICsrKxz1rZixQpeffVVJk6cyMSJE7n66qupUaMGLVu25JlnnuHXX38t0N4wDMLCwoiIiKBLly48+uijzJ8/n8zMM/fbnD17Np6enlx55ZWnTZs2bRq33HILgwcP5ssvvzzjMjw9PQkLC6NmzZoMHjyYjh078tNPP511e2699VbWrFlDTEzp/37Rs7oqiA739mTRd4/jFnqEudPfpt8rk6wuSUTKMIcjg8WLrXn+39VXp2G3+5633ZtvvkmdOnX48MMPWb16NXa7/bQ2DRo04LXXXmPIkCG0b98em83GoEGDeOWVV2jUyHkD2Lvvvhtvb29+/fVXAgMD+eCDD7jhhhvYsWMHlStX5uuvv2bMmDFMnjyZ9u3b8+mnn/LWW28RFRV11tq+/PJL/Pz8GDJkyBmnG4Zxzm3z9vbG4XCc9eGhixcvpmXLlqeNN02TadOmMXnyZBo0aEB0dDTffvvtOY8enVxfYmLiWafXqFGD0NBQFi9eTJ06dc65LKvpiE8F4eZm58gO5y+ju/uG87QWESn7AgMD8ff3x263ExYWRnBw8BnbnQw9vXv3pm/fvlxxxRU88sgjACxZsoRVq1bxzTff0KpVK+rWrctrr71GUFAQ3377LQCTJk1iwIABDBgwgPr16/Piiy+6QtPZ7Nixg6ioKNzc/jn+MHHiRPz8/FxDSkrKGefduXMn77//Pq1atTrrKbu9e/cSERFx2vj58+eTkZFBp06dAOjduzdTpkw5a52maTJ//nzmzp1Lhw4dzrlNERER7N2795xtSgMd8alA0lMvA1YQUlePrxCRi2Oz+XD11WmWrbu4TZ06lXr16mGz2di8ebPriMuGDRtIS0ujSpUqBdpnZma6Tuts3bqVQYMGFZjetm1bFi5ceEE19O/fn9tuu42VK1fSu3fvAqf0UlJS8PPzw+FwkJWVRfv27fnoo4/OuqzMzEy8vLzOuJ09evRwBa6ePXvyxBNPEBMTU+BIzaxZs/Dz8yM3NxeHw8F///tfxowZc876vb29ycjIuKBttoKCTwXSrvsDHM6eikfNA6z+YR5X3H6j1SWJSBllGEahTjeVFRs2bCA9PR2bzUZcXBzh4eEApKWlER4ezqJFi06bJygoqMjrq1u3LkuWLCE3Nxd3d3fX8oKCgjhw4MBp7f39/fnrr7+w2WyEh4fj7e19zuVXrVqVY8eOFRiXlJTEDz/8QG5uLu+9955rfH5+PlOnTuWll15yjbv++ut577338PDwICIiosCRqbNJSko661G10kSnuiqQRle1ITu2BgAb/iwblx2KiJS0pKQk+vbty9NPP03fvn3p1auXq8NvixYtiI+Px83Njejo6AJD1apVAWjYsCErV64ssMwVK1acc509e/YkLS2Nd999t1A12mw2oqOjiYqKOm/oAWjevLmrc/ZJn3/+OdWrV2fDhg2sX7/eNbz++utMnz6d/Px8V1tfX1+io6OpUaNGoUJPVlYWMTExNG/evFDbYyUFnwomfrfzUGZgVT2+QkQEYNCgQURGRvLMM88wceJE8vPzGTFiBAAdO3akbdu2dO/end9++409e/awbNkynn76adasWQPA0KFDmTp1KtOmTWPHjh0899xzbN68+ZzrbNu2LcOHD2f48OE8/vjjLFmyhL1797JixQqmTJniumdPUXXq1InNmzcXOOozZcoU7rrrLho3blxgGDBgAEePHmXOnDlFXt+KFSvw9PSkbdu2RV7GpaLgU8HY3Z29/Ks02Elu9pmvBhARqSg++eQTZs+ezaeffoqbmxu+vr589tlnrnvlGIbB7Nmzueaaa+jXrx/16tXjP//5D3v37iU0NBSAHj168Oyzz/Lkk0/SsmVL9u7dy+DBg8+77tdee40vvviCdevWccstt1C3bl3uvvtuHA4Hy5cvJyAgoMjb1aRJE1q0aMHXX38NwNq1a9mwYQN33nnnaW0DAwO54YYbztnJ+Xy+/PJLevXqhY9P8fe/Km6GWdgbIlQQqampBAYGkpKSclG/dKXVsfh41q+vheGVTeqa97htxKDzzyQiFVpWVhaxsbHUrl37jB1mpXT65ZdfeOKJJ9i0adNFHT06n6NHj1K/fn3WrFlD7dq1S2w9cO7fxcJ+f+uITwVTKSyM1B3Oe0scOfibxdWIiEhJ6dq1KwMHDuTgwYMlup49e/bw7rvvlnjoKS66qqsCOnKgDoGXbyWkhi5rFxEpz0r6YawArVq1olWrViW+nuKiIz4VUFjtGwDwa7CDo3uOWFyNiIjIpaPgUwF1un8IjuQADO9sfn13stXliEgZoS6hYrXi+B1U8KmA3N09OLrTeS7W4VhtcTUiUtqdvMFeWbgrr5RvJ38HT/5OFoX6+FRQKYl1CGEDIbVL/5N0RcRadrudoKAgEhISAPDx8TnvQzRFipNpmmRkZJCQkEBQUNAZHzhbWAo+FVT91rfj4Hu86sWwZ20MtVqW7qfpioi1wsLCAFzhR8QKQUFBrt/FotJ9fP6lvN/H5ySHw8Hv3wfjVjWJPT8/Sd/XX7G6JBEpA/Lz88nNzbW6DKmA3N3dz3mkp7Df3zriU0HZbDaO7qxNWNUk7G7rrC5HRMoIu91+UacZRKymzs0V2PGUegCE1NltcSUiIiKXhoJPBdbsuv8A4Fknlq1/brS4GhERkZJXroLPmDFjMAyjwNCgQQOryyq1ruh8GzmHQsHuYNkPU60uR0REpMSVuz4+l112GfPnz3d9dnMrd5tYrI7E1KZaxGG8fXTER0REyr9ylwrc3Nwu6FK37OxssrOzXZ9TU1NLoqxSKzO9AbCCqtG6n4+IiJR/5epUF8DOnTuJiIggKiqKXr16sW/fvnO2HzduHIGBga4hMjLyElVaOrS9+T4APGrv46/Zyy2uRkREpGSVq/v4/Prrr6SlpVG/fn3i4uIYO3YsBw8eZNOmTfj7+59xnjMd8YmMjCz39/E51dyPI/GseYBdPw7i/jfes7ocERGRC1Yh7+PTpUsX1/vLL7+cNm3aULNmTb7++msGDBhwxnk8PT3x9PS8VCWWSgm7axFZ8wB+AZusLkVERKRElbtTXacKCgqiXr167Nq1y+pSSrXcnMsAqFpX/XxERKR8K9fBJy0tjZiYGMLDw60upVS79u4HMPNtuFWPY9k3v1ldjoiISIkpV8FnxIgR/PHHH+zZs4dly5Zx++23Y7fb6dmzp9WllWp1WrQkK7YGAFuWfWlxNSIiIiWnXPXxOXDgAD179iQxMZHg4GDat2/PihUrCA4Otrq0Ui8hthY1o/cQUHmb1aWIiIiUmHIVfGbMmGF1CWVYU2ARVervIj/fgd1erg4GioiIAOXsVJcU3U33DcbMdcMecpRFn3xndTkiIiIlQsFHAAivX5+MXbUBiP17prXFiIiIlBAFH3FJ2FsLgKCQHdYWIiIiUkIUfMTF3b0FAJXrxpCXl29xNSIiIsVPwUdcOvUfhJnjjq3KMRZM+crqckRERIqdgo+4BNeuRfqJfj77t/1icTUiIiLFT8FHCjiy33kjw0ohOy2uREREpPgp+EgBHl7NAahUL4bc7DyLqxERESleCj5SQJcBD5/o55PE/P+pn4+IiJQvCj5SQOXqNUiLqQXAwV2zrS1GRESkmCn4yGmO7K8JQOWQXRZXIiIiUrwUfOQ0Xj7Ofj5B9XeRk6V+PiIiUn4o+Mhputz/qKufz7z3v7a6HBERkWKj4COnqRRWnbTdztNdcTHq5yMiIuWHgo+c0cn7+VQOUz8fEREpPxR85Iy8/JzP7Qqqv4vsDPXzERGR8kHBR86oy4BHMXPcsFVNZN5k9fMREZHyQcFHzqhSSCTHT/Tzid87x+JqREREioeCj5zVkYMn+vmE77C4EhERkeKh4CNn5RPQEnD288lKUz8fEREp+xR85Ky69B+KmXuin8/b6ucjIiJln4KPnFVQleocj3H28zm8X/18RESk7FPwkXM6cigSgCoROy2uRERE5OIp+Mg5+Vb6p59PZkquxdWIiIhcHAUfOafOfZ39fIzgo/z2pvr5iIhI2abgI+cUVCmS47HOy9qPHPrN4mpEREQujoKPnNeRgyf6+VRTPx8RESnbFHzkvPyqnOjn02An6Unq5yMiImWXgo+cV6c+j7n6+cybpH4+IiJSdin4yHkFBVYnNdZ5uivx8DyLqxERESk6BR8pFNf9fKqrn4+IiJRdCj5SKP7Bzn4+gQ12kHZU/XxERKRsKlLwSU9PL+46pJS7qffjmLl25/18Jqqfj4iIlE1FCj6hoaH079+fJUuWFHc9UkpVCqxO6h7n6a5jRxZYXI2IiEjRFCn4fPbZZyQlJdGhQwfq1avH+PHjOXToUHHXJqXMkThn8KkaucPiSkRERIqmSMGne/fuzJw5k4MHDzJo0CC++OILatasyS233ML3339PXl5ecdcppYB/SCsAAhrsICUu2+JqRERELtxFdW4ODg7m8ccfZ+PGjUycOJH58+dz1113ERERwejRo8nIyCiuOqUUuLHnY85+PiFHmP/Gt1aXIyIicsEuKvgcPnyYV199lUaNGvHUU09x1113sWDBAl5//XW+//57unfvXkxlSmlQOTDS1c8nOUn9fEREpOxxK8pM33//PdOmTWPu3Lk0atSIIUOG0Lt3b4KCglxt2rVrR8OGDYurTikljsRXJ7DuHqpG6n4+IiJS9hQp+PTr14///Oc/LF26lCuuuOKMbSIiInj66acvqjgpfQLDWwFLCGi4nWP7sqhUw8vqkkRERArNME3TvNCZMjIy8PHxKYl6LJeamkpgYCApKSkEBARYXU6pc+z4AdavqIXhnk/iT59x58ReVpckIiJS6O/vIh3xycvLIzU19bTxhmHg6emJh4dHURYrZUAl/+qk7K1OUPReUlJ+BxR8RESk7ChS5+agoCAqVap02hAUFIS3tzc1a9bkueeew+FwFHe9UgocPVwNQP18RESkzCnSEZ/p06fz9NNP07dvX1q3bg3AqlWr+Pjjj3nmmWc4cuQIr732Gp6envzf//1fsRYs1guq1hpYhn+jbSTuzqBKVPk87SkiIuVPkfr43HDDDTz44IPcc889BcZ//fXXfPDBByxYsIBPP/2Ul156iW3bthVbsZeC+vic37HjB1m/siaGWz5Hv/+Cu97qaXVJIiJSwRX2+7tIp7qWLVtG8+bNTxvfvHlzli9fDkD79u3Zt29fURYvpVwl/2qk7IsAIDV1ocXViIiIFF6Rgk9kZCRTpkw5bfyUKVOIjHTe4C4xMZFKlSpdXHVSarn6+dTQc7tERKTsKFIfn9dee427776bX3/91XUfnzVr1rBt2za+/db5KIPVq1fTo0eP4qtUShX/6q2AFfg33M6R7RkE11c/HxERKf2K1McHYM+ePXzwwQds374dgPr16/Pggw9Sq1at4qzvklMfn8JJSIll85poDLuDozO+4a7377K6JBERqcBK7D4+ubm5dO7cmffff59x48ZdVJFSdoUE1mb5/nACax0kNe13QMFHRERKvwvu4+Pu7s7GjRtLohYpYxISnB2cg2uqn4+IiJQNRerc3Lt37zN2bpaKJaB6CwD8Gm4j7u80i6sRERE5vyI/smLq1KnMnz+fli1b4uvrW2D6xIkTi6U4Kd3a3/wYO/76EKP6QZZOms9dU7pbXZKIiMg5FSn4bNq0iRYtnP/b37Gj4GkOwzAuviopE6oF1WfNwVACI+NJzVgAdLe6JBERkXMqUvBZuLB037Ru8uTJTJgwgfj4eJo2bcrbb7/terSGFK+EhHACI+MJrrnd6lJERETOq0h9fE7atWsXc+fOJTMzE4AiXhlfrL766isef/xxnnvuOf766y+aNm1Kp06dSEhIsLq0csnvRD8f/0bbOPjXcYurERERObciBZ/ExERuuOEG6tWrx80330xcXBwAAwYMYPjw4cVa4IWaOHEiDzzwAP369aNRo0a8//77+Pj4MHXq1DO2z87OJjU1tcAghdeu41BMhwE19rPszUVWlyMiInJORQo+jz32GO7u7uzbtw8fn3/u2NujRw/mzJlTbMVdqJycHNauXUvHjh1d42w2Gx07dnQ9Q+zfxo0bR2BgoGs4+cgNKZyaVZpwPK4qAMczSvcpUBERkSIFn99++41XXnmF6tWrFxhft25d9u7dWyyFFcXRo0fJz88nNDS0wPjQ0FDi4+PPOM+oUaNISUlxDfv3778UpZYrh4+EAxBca5vFlYiIiJxbkTo3p6enFzjSc1JSUhKenp4XXdSl5OnpWeZqLm18qzUHNuLfaCv7VqZSo40e9SEiIqVTkY74XH311XzyySeuz4Zh4HA4ePXVV7n++uuLrbgLVbVqVex2O4cPHy4w/vDhw4SFhVlUVfnX+tqHnG9q72HFpKXWFiMiInIORQo+r776Kh9++CFdunQhJyeHJ598ksaNG/Pnn3/yyiuvFHeNhebh4UHLli1ZsGCBa5zD4WDBggW0bdvWsrrKuzrBrUiNrwJAWtbvFlcjIiJydkUKPo0bN2bHjh20b9+ebt26kZ6ezh133MG6deuoU6dOcdd4QR5//HH+97//8fHHH7N161YGDx5Meno6/fr1s7Su8swwDBISTvTzqa1+PiIiUnoVqY8PQGBgIE8//XRx1lIsevTowZEjRxg9ejTx8fE0a9aMOXPmnNbhWYqX834+m/BvtJXYxSnUvjrQ6pJEREROY5hFvOtgcnIyq1atIiEhAYfDUWDafffdVyzFWSE1NZXAwEBSUlIICFAn3cLal7iO3X+3AIfBoXdn8d9vb7a6JBERqUAK+/1dpCM+P//8M7169SItLY2AgIACz+cyDKNMBx8pmhpVmrMhoTL+IUlk5vwBKPiIiEjpU6Q+PsOHD6d///6kpaWRnJzMsWPHXENSUlJx1yhlxNEjEQCE1tJzu0REpHQqUvA5ePAgjz766Bnv5SMVV1BN54Ng/RpvYdeCYxZXIyIicroiBZ9OnTqxZs2a4q5Fyri2Vz3mfBO9i+Xv/GFtMSIiImdQpD4+Xbt25YknnmDLli00adIEd3f3AtNvu+22YilOypawSo1ZFV+FgLBE8vkD6G51SSIiIgUUKfg88MADADz//POnTTMMg/z8/IurSsqshKORBIQlEl5vK458E5vdOP9MIiIil0iRTnU5HI6zDgo9FVtofecjSzybr2fz1wkWVyMiIlLQBQWfm2++mZSUFNfn8ePHk5yc7PqcmJhIo0aNiq04KXuuvupJHLl2CDvMui/mWF2OiIhIARcUfObOnUt2drbr88svv1zg8vW8vDy2b9elzBVZkE8YCfudd8n2DNADS0VEpHS5oODz75s8F/Gmz1LOHcuoDkBwo81kJuvUp4iIlB5F6uMjci4NWtwBgK3Zela8vc/iakRERP5xQcHHMIwCj6c4OU7kVO1aDyUnzRt8M4hd+Z3V5YiIiLhc0OXspmnSt29fPD09AcjKymLQoEH4+voCFOj/IxWXp5sXh/aHUqvhHqpErLW6HBEREZcLCj59+vQp8Ll3796ntdEDSgXA9KgL7CHw8r+J25RFeGMvq0sSERHBMNVDuYDCPtZezm177Fzi9naGfBtHP/mDuz5ub3VJIiJSjhX2+1udm6VE1K/dieNHgsDuID3lF6vLERERARR8pATFx0cAEFrnbxz5OrAoIiLWU/CREhNSox0AXs3Xs+m7ZGuLERERQcFHStC1HUbjyLdB9YP89clsq8sRERFR8JGSE+QfyZETj6/wCfjD4mpEREQUfKSEpWTUBCC4yUbSD+daXI2IiFR0Cj5Sopq17QeA0Xw9S1/dZnE1IiJS0Sn4SIlq2XQAGcf8wCubwzu+t7ocERGp4BR8pETZbXb2HQgHIDh6LaZDl7WLiIh1FHykxAVWaQGAV6u1bP0p1eJqRESkIlPwkRLXsdOLOHLtUO0Qf308y+pyRESkAlPwkRIXXCWauH3Oy9q9/X+3uBoREanIFHzkkjieWQOAypdvIGVvjsXViIhIRaXgI5dEu6sGAWA03cCfr/1tcTUiIlJRKfjIJdG46b2kHQ0E9zxSDnxrdTkiIlJBKfjIJWGz2ThwoDoAoY3W4Mh1WFyRiIhURAo+csnUqNkBAPc2K1n/WYLF1YiISEWk4COXTIcuL5Fz3AcCjrN59idWlyMiIhWQgo9cMl5e/uyJqQZAlcjFmKbu4iwiIpeWgo9cUu6eDQHwabOKPX+kW1yNiIhUNAo+ckl1vfUl8rM8IDSBFVO+trocERGpYBR85JIKqd6Y/TERAHj7z7G4GhERqWgUfOSSy0x33sU5qNUaErdnW1yNiIhUJAo+csl1vnYYZp4NomJZ9NY8q8sREZEKRMFHLrnarbsTH+s83eXI/cbiakREpCJR8JFLzzBIPHzisvYWK8k4kmdxQSIiUlEo+IglrmvVFzPfwNZgOwvfWWp1OSIiUkEo+IglGt/4AEdjnUd9jidMs7gaERGpKBR8xBp2Owf3Oh9aGnz5CnLT8y0uSEREKgIFH7FM60a3YjoM7A23s/T9VVaXIyIiFYCCj1im7e2Pc3S383TX4ZgPLa5GREQqAgUfsYzh5cX+E5e1BzdZQV6GTneJiEjJUvARS11VpzOmw8DWcBt/TF5hdTkiIlLOKfiIpVrf+TiJJ053HYn9yOJqRESkvFPwEUsZgYEcjAkDIKTxSnLTdLpLRERKjoKPWO76mp2cp7sabWWBbmYoIiIlSMFHLHd5j+Gu013JB3S6S0RESo6Cj1ivUiUObXfezDCkxRJyUvTsLhERKRnlKvjUqlULwzAKDOPHj7e6LCmEznW7Yea6YYuKZd6bP1pdjoiIlFPlKvgAPP/888TFxbmGRx55xOqSpBDq9RjMgS21AMg5/om1xYiISLnlZnUBxc3f35+wsDCry5ALFRjIsZhqRDbdRVDrpSTvTCeorq/VVYmISDlT7o74jB8/nipVqtC8eXMmTJhAXt65+4tkZ2eTmppaYBBr9G7Zk7w0H4zgROa+r0dYiIhI8StXwefRRx9lxowZLFy4kAcffJCXX36ZJ5988pzzjBs3jsDAQNcQGRl5iaqVf6t8x3+J3VAbAD+/nzBN0+KKRESkvDHMUv7t8tRTT/HKK6+cs83WrVtp0KDBaeOnTp3Kgw8+SFpaGp6enmecNzs7m+zsbNfn1NRUIiMjSUlJISAg4OKKlwv2xcAbifjvfMj0oprHNureUNPqkkREpAxITU0lMDDwvN/fpT74HDlyhMTExHO2iYqKwsPD47TxmzdvpnHjxmzbto369esXan2F/cFJycif8QW/2R/BOziJgz88Rq83J1pdkoiIlAGF/f4u9Z2bg4ODCQ4OLtK869evx2azERISUsxVSUmx39adXc9NpEnXJELqzsWR58DmVq7OyIqIiIXKzTfK8uXLmTRpEhs2bGD37t18/vnnPPbYY/Tu3ZtKlSpZXZ4Ulo8PLZKiMfNtuDfewuKpc62uSEREypFyE3w8PT2ZMWMG1157LZdddhkvvfQSjz32GB9+qKuDypqreg0kfksdAI7Gvm9xNSIiUp6U+lNdhdWiRQtWrFhhdRlSHK67jripwYQ32Unl1n+SHJNMUJ0gq6sSEZFyoNwc8ZFyxGajf0RbcpICMSolM/eD162uSEREygkFHymVgvr0Y8fqaAAqhc3CzC/VFx+KiEgZoeAjpdNllxG9zgcAj2YbWDZlvsUFiYhIeaDgI6VW5853cHhrFNhMjsZMtrocEREpBxR8pPTq2ZP9v1cGIPCq3zmy8qDFBYmISFmn4COlV2goD+TVIONIJQg4zpIvJlhdkYiIlHEKPlKqBQ68n79WRAEQdPnPZB3KsrgiEREpyxR8pHS76SY6znPgyPbAqLOb3yd9ZHVFIiJShin4SOlmt3Plnd3YvM55abu7/1fkZ+ZbXJSIiJRVCj5S+vXvT8B3dgDc2y1jzfsLLC5IRETKKgUfKf0iI7kvOJKDO2qA3UFi3DuYpm5oKCIiF07BR8oEY+AD7JkVAYDP9fPY8/MmiysSEZGySMFHyoauXXl0dTzH9oeCdxYbF79sdUUiIlIGKfhI2eDujv/gfqz7rR4Age1nc2T9PouLEhGRskbBR8qOBx/kwW93kJlQBQJT+ePLsVZXJCIiZYyCj5QdoaFUu+tG1s27HIAqrWdy/NBRi4sSEZGyRMFHypZHHuGOT3eQe6QyRpUkfvvoSasrEhGRMkTBR8qW1q1p0LQaK+e0BqBykx9Ii9NRHxERKRwFHyl7HnmETp/HkHM4GKNSMvOmDLe6IhERKSMUfKTsufturqh0nOUnjvoENZlJ8sFDFhclIiJlgYKPlD2enjBsGHd8vpnsQ6EYganMn/a41VWJiEgZoOAjZdOgQTTxSmTVrDYAVGn+M/E7t1pclIiIlHYKPlI2BQbCoEH0/GotmbE1MHwzWPH9o1ZXJSIipZyCj5Rdw4YR7XaEP79qC0Bgq9/ZsniOxUWJiEhppuAjZVdEBNx7L8PmLuDoX00w7A52r3/K6qpERKQUU/CRsm3ECEKNRLZ93Bgzz45fkw0s+GKi1VWJiEgppeAjZVuDBnDPPTyx8Tt2L7waAIcxgZzMNIsLExGR0kjBR8q+0aPxNHJx/8AHx9HKuIfHM/t/fa2uSkRESiEFHyn7GjWC//yHexNns3DmrQAENvyRnRt+t7gwEREpbRR8pHx49lkMw+CuL5aTuq4JhnseO1YNxjRNqysTEZFSRMFHyoeGDaFnT5qaO1g7sztmlie+dXfw8yeDra5MRERKEQUfKT9GjwabjVF/vsrGmbcD4B86ne+XvG1xYSIiUloo+Ej5Ub8+3H8/XmRz2Z+BZG68DMMrG9v2VxmzaLTV1YmISCmg4CPly9ix4OtLx60fsOrXCZjpPgTVOUDO8k/5ZvM3VlcnIiIWU/CR8iUsDJ54AoAR25/k72nOIz03tjrAGz8+xJYjW6ysTkRELKbgI+XP8OEQFoZv7CZaV6tJ+tKrMdzzGF3H5L9fdSM1O9XqCkVExCIKPlL++Pk5T3kBV346hO2HPsJxOASv0KMMNXLpM/M+HKbD4iJFRMQKCj5SPvXvD02bwrFjPJr1On9+PBVy3ah92V6qx65m9EJ1dhYRqYgUfKR8cnODyZOdb6d+yOCHw9g11dn3545Wh1m2fDKfbvjUygpFRMQCCj5Sfl11FfTpA0DoswOp3/c5ji+4CcMtn6eb5vDS7MEs2bfE4iJFRORSUvCR8u2VVyAwEP76i6tjpnDQ/SvyNl+G3S+DiXU8uffrbsQkxVhdpYiIXCIKPlK+hYbCiy86348axYP90li+7AfM+FB8QpKYWM2g33c3kZSZZG2dIiJySSj4SPk3eDC0aQOpqRiDHmTU9Gj+nPoVJFWiUngiT0fu44kfryIjN8PqSkVEpIQp+Ej5Z7fD1Kng4QGzZ+P21ec8/t21zBv9K2xsgqdXHveGbePduU3IyVP4EREpzxR8pGJo1Aiee875/tFH8U+P59EFrZn/4gz43vlA01Z+u/npj1pkZOy2sFARESlJCj5ScTzxBLRoAceOwcCBhIbAoL8asmTay/Ds85jH/ahqP8LSlZeRmrrS6mpFRKQEKPhIxeHuDtOmOU95/fwzvPce1asb/HddfRb/dRfGA//D3NoAdyOL1X9dR3KyLnUXESlvFHykYrn8cnj1Vef74cNh0yaiog16bWzAHxnNMR6fiLmuKXay+Gv9DRw79ru19YqISLFS8JGK59FHoUsXyMqCnj0hM5OoOgYPbK3HIp9ojFHjYXUrbOSwbkNnEhN/sbpiEREpJgo+UvEYBkyf7rzHz6ZNMGwYABHVDB7ZEc3s0Ibw9EuwtB02ctmw8TYOH/7C0pJFRKR4KPhIxRQSAp984gxBH34IU6YAUKWKwdhtNZl/RVNyxjwH8zpiMxxs2dKLAwffs7hoERG5WAo+UnHddBM8/7zz/ZAhsGoVAN7e8MKSULb2a8PR14bDzG4YBuzaOYSY2DGYpmlh0SIicjEUfKRi+7//g27dICcH7rwTEhIA54GgoR8G4vbe9WycOgg+6wXA/r1j2bC+B/n5WVZWLSIiRaTgIxWbzeY85VW/Phw44AxBmZmuyd37e9J1zU3MXdAXJj4GeXaSU75h6fw2ZGfHW1e3iIgUSZkJPi+99BLt2rXDx8eHoKCgM7bZt28fXbt2xcfHh5CQEJ544gny8vIubaFS9gQEwI8/QqVKsGIF3HsvOByuyXXq2RizrSM/efbgyNhRkOqPw3MjS+c2JvHAIuvqFhGRC1Zmgk9OTg533303gwcPPuP0/Px8unbtSk5ODsuWLePjjz9m+vTpjB49+hJXKmVS/fowc6bz5obffee8y/MpPD1h4jdtMB8fxNy3BmDurYEtIJGN229gw5wX1O9HRKSMMMwy9hd7+vTpDBs2jOTk5ALjf/31V2655RYOHTpEaGgoAO+//z4jR47kyJEjeHh4FGr5qampBAYGkpKSQkBAQHGXL6Xdl1/Cf//rfP/aa86bHP7LkWNZ9H/sCQbX/gufa5cBkLWlA23v/IrA0KqXsloRETmhsN/fZeaIz/ksX76cJk2auEIPQKdOnUhNTWXz5s1nnS87O5vU1NQCg1RgPXvCuHHO9yNGwHunX8IeXMmLn6a9xW/V7uLvb26EHHe8Gv3OmgVNmTF2DtnZl7hmEREptHITfOLj4wuEHsD1OT7+7J1Qx40bR2BgoGuIjIws0TqlDBg5Ep56yvl+yBDnzQ7/xTAMJt3/GM2fHMuHc1uRdzgYe8Qhwtp3ZcbwAQx/4Di//w5l63iqiEj5Z2nweeqppzAM45zDtm3bSrSGUaNGkZKS4hr2799fouuTMsAw4OWXYehQ5+cBA+Czz87YtH3Ntrzz4iz+l9GGvWsagt1BzbumcvNVTfh0yK9c1dZk8eJLWLuIiJyTm5UrHz58OH379j1nm6ioqEItKywsjFUnbkB30uHDh13TzsbT0xNPT89CrUMqEMOAN95wPs/rgw/gvvvg+HE4Q+f6yt6VmdH3JyavnszUXydx3+VHcau1lz6Tb+HIjD480PEV6ncO5pVXoEEDC7ZFRERcLA0+wcHBBAcHF8uy2rZty0svvURCQgIhISEAzJs3j4CAABo1alQs65AKxjDg3XfB3R3eecd52is5GUaNOkNTg4dbP8yu6M48/MN93HHoIPUu20dwr2m8d/0cVr49hqsv68OdD3gyZgycI4uLiEgJKjN9fPbt28f69evZt28f+fn5rF+/nvXr15OWlgbATTfdRKNGjbj33nvZsGEDc+fO5ZlnnuGhhx7SER0pOpsN3noLnnnG+fn//s95pVd+/hmbR1eO5pd+i0lvMYxJa6uQdSwAIyKOK8c9yIwxHbHNXELjOnmMHQsnfnVFROQSKjOXs/ft25ePP/74tPELFy7kuuuuA2Dv3r0MHjyYRYsW4evrS58+fRg/fjxuboU/sKXL2eWsXnvtn/v7dOvm7Pfj53fW5nuT9/LUvKFEH15GhwaJGG4OyPIk89t7mPLl0yz1rctjI2wMHgz+/pdoG0REyqnCfn+XmeBzqSj4yDl9/rmzs3N2NjRrBj//DNWrn3OW+bvnM/73B+ntnUitainOkcmBJH38AO/9PJT1ARE8+piNRx6Bs9yUXEREzkPBp4gUfOS8li+H7t2dDzQNDYUvvoAOHc45S54jj+nrpjFr7Sj6VM2mUuUT57kOVCPp4/uZ9nt/lvlW5/7BNh5+GHRXBRGRC6PgU0QKPlIoe/fCbbfBxo3OfkBjxjj7/9jt55wtPSedSctfY8u21+ldLRdvvxNPeT8YQepnfflmXj9+NWtww10eDBsGV17p7GMtIiLnpuBTRAo+UmgZGfDoozBlivPzjTfCxx9DePh5Z01IT+DVxWNIOjiVu8NNvH1ynBPiwsib0ZNFc3vzfXY0fq38eehhg7vvBh+fEtwWEZEyTsGniBR85IJ98onz/j4ZGc4nvL/zjvPRF4U4VHM47TCTlo/j0P4PuCfMge/JAJQSALNuYffMXsw6ejmr/EK57V537r8fWrQo4e0RESmDFHyKSMFHimTLFudNDteudX6+807nPYBO3FPqfBIzEnl75Wvs3vcWt1bJJdgv1zkhzw4Lryf3hztYuvVqZhOOo3llBjxg0LOnOkOLiJyk4FNECj5SZLm5zgecvvAC5OU5U8lLL8GDD563789JmbmZfLHxMxZufZG2Pge5rPIp9wvaXRtm38zReV2Zm1qfP91DaXyrL716QdeuoNtViUhFpuBTRAo+ctHWrXNe8r5unfNz8+bOoz9XXlnoRZimyR97/+DLtWOpmvcH11YBD7cT/1Rz3GFJe5h3I7Grr2VhfgRr/EK46j8+9OoFV19d6JwlIlJuKPgUkYKPFIv8fHj/fecdn5OTnePuucd5NKhevQtaVHxaPF9u+JDt+96lld9hok+92WFKACy6DhbcwI5NV7LIDGVLpaq07O5D99sNOnYEb+/i2igRkdJLwaeIFHykWCUkwFNPwfTpYJrOQzH33w+jR0NExAUtyjRNVh5cyQ8bXsVxfDbtKuVQyfOUf76HQ5whaOlV7N/cimWOENZ6ViWycwC3drfRqVOhLjgTESmTFHyKSMFHSsSGDfD00/DLL87Pnp7Qrx+MGAF16lzw4nLyc5gfM5fFO97CLeMPrqyUi6/7KQ2SA2F5W1h6FSlrrmRldjVWUpnMRpVo39WDTp2gfXv1CxKR8kPBp4gUfKRELVnifLr7kiXOzzYb3HUXPPkktGxZpEVm5WUxZ+dPrNn1Du7ZK2kZmIPfqSEoyxM2NIW1LWFNK3bGNmEtldnkWYkq1wVyw812rrsOGjd2liMiUhYp+BSRgo+UONOExYvhlVdg9ux/xl95JQwa5OwLVMSOOXmOPJbs/YPluz4gI2UejXyTCf/3ohIrO0PQ2pbkbGjGpsP12EgQe/0DCb4mgHYd3bjuOrj8cgUhESk7FHyKSMFHLqkNG+DVV+Hrr52XwIPzMvg+faBvX2ja9KKeWbH96HYW7ZhG3NGf8c/fTuOAfDz/fcVXQjD83QT+bkL+302I2dOYTY7KxPgE4ntFAI2u9eTKtgatW0PlykUuRUSkRCn4FJGCj1ji8GGYOhU+/BD27PlnfMOG8N//OoeoqItaRW5+LqsPLmNt7MckH5tPsO0A0X4mbv8+qpPmC5svg+31YXt9UrZfxrbEKHbgx/Fwfypf6U/j6z1pdYVBkybg63tRZYmIFAsFnyJS8BFL5efDb785n/81axZkZ/8z7YornA9Gve02aNLkop9empWXxZoDS9i0/xuOpfyJT34M9Xzz8HY7w5+ExMquIMTOuqTsrsuOhGhiTX8yQn3xbexL9at8uby1naZNoVo1PVxVRC4tBZ8iUvCRUiMlBX74Ab74AhYsAIfjn2k1a8Ktt0Lnzs47FhbD76ppmuxK2s6a2K+IT/odR/Y2qhhHqeHjOHNfn0wv2FMLYmtDbG0ce2pxOLY+MYm1iPfyw6zhi38Db8JaeVO3hTsNGkCtWrq5ooiUDAWfIlLwkVIpPt55BOjnn2HePMjM/Gea3e48GtShg3No27bYHuWe78hn+5ENbD7wE/FJf5KfvYVKxlEivBy428/ypyPdBw5Wg0MRcKA6HKxG2sHqHDhYlwPJNciq6oN7bW/863sT0sSLGk3ciapjUKMGeHgUS9kiUgEp+BSRgo+UehkZziNAs2Y5X2NiCk53c3N2ir7ySufQpg1ERxfbuSfTNIk7foCtcfM5kLiY42kbMXL3UJkUQr3zzn0lWLoPxIdBQohzOBxKTkIISUfDOJxQk2NpUeRX8cMj0hO/Ol4E1fcirJEH1WrZqFbN2blap9BE5EwUfIpIwUfKnL17YeFC+P13ZxA6dOj0NlWqQLNmzmvUmzZ1vjZsCF5exVaGMxDtY9fhxRw6tprUtC3kZsfimXeUSrZMKvvknD+05NvgaFXnkFgFjlWCpMpkJAeRmlyFY8mhHE+vRk5+LeyV/fGq5olfTQ8CantQpY4HwbXshIYaVK3qzH8iUnEo+BSRgo+UaaYJ+/fDihX/DH/9VbCT9El2OzRoAI0aOZ8fVq8e1K3rfK1SpdhLO5oex66EP4k7toGU9B1kZe2DnMP45B3H355JgHc29rOdPjuTlABICYTUf14dqQFkpvmRkeZPekYgWVmVyMoNId8Mw+ZZDc9KgXiGuOMT5o5/uBuBEW5UinSjSpiNSpWKNQeKyCWm4FNECj5S7uTkwMaNzmHDhn9ejx07+zyVKzsDUFQU1Kjxz1CzpvO1BP5tZOVmsO/YBg4lrSMxbQfpmfvIzo7HyEzCIzcNLzLw9sjC1zsL24UEpFNle0C672lDfoY3uZneZGf6kJPtTXaWD9m5/uTm+5Fn+pNv9we3AOzuAbh7VcbLpzK+QYH4VLbjU9WOXxU7/iHOIaCKga+voVNyIpeYgk8RKfhIhWCazlNiGzbA9u2wY8c/w4ED558/MNAZgKpVg9BQCAsrOJwcFxRU7J1y8vJzSTi+i/iULSSlxXI88yCZ2fHkZB6FzBRs2WnY8jPwMLLwdMvC0ysbT68sjOK+C3WeHbK8INPb+ZrtCVlemFle5Gd7kJftSV6uO3l5buTlu5Ofd2JwuJPv8HAOpicmHph4YxqeYPPG5nZicPfFzcMXN09fPL0C8PTxxds3AB8/Hzx97Xj6Gnj62vDwMfDys+HpZzjHeRq647ZUSAo+RaTgIxVeRgbs2uUMRHv3Ood9+/4ZkpIKvywPD6ha1XkE6eRQpUrBzyeHSpWcR5ICAsDf3/kE1WIKTfmOPI5lHCApfR/HM+NJyz5MZvZRMrOOkpuRTF56KnmZaZjZ6djyM7GThbs9C3e3HNzsubi55+LmnofNMweb3XH+FZYkhwF5bmcdzHw7Zp7d+Zpvx3FinCPfhiPfDdNhw5FvJz/fDYfDjiPf7nx12DFNGw5s4LDjMG2YOMc5X+2Y2AHbP6+GG2AHwzkYhhsYbhi2E59t7hg2N7C5YZwYbHYPbPYT793csdvcsbk7X+3ubrjZ3LC7u+Pu5obN7o7d3Y673c05zd0NNzfnq7u7G27u7s5XDztu7jbsHgZ2N7C7G9jdna+GHQybAQYYOgxXrin4FJGCj8h5HD/u7Ee0bx/ExTkvtT982Pl66pCScnHrcXP7JwT5+xd8f/Kzr6/z0n1v78K/ens7O/MU8bBIbl4madlHSM9OJCM7iYycRDJzk8nKTCYrPYXM1ONkpx8nLysDR04mZm425OdgmLkYZi42crEZedhtudhs+dhtedjdcrHZ87Hb87C55WF3z8PmnofhlofNI/fifo4VSb4NTAMcNudw8v2JV/PUz6YBDgPTtJ3y3gDTdsr7E6+ntHONdxjAKW1MgBPvwTn+xOup713jMDDNk+NO1HNqG05Zl2seTrTlxHpOWQ6nrsP4Zx2nznty2r/mKzDNNd/JkHhyGTZXXfy73anvjRNtzBNNTZtrOa5pGPz3//6Hl49n0ff1GRT2+1vXPYjIhfH3d3aIbtTo3O2yspyBKDHReZTo1OFM45KSnKEqPd05f17eP+NLgpeX84iUp+eZX88yzd3Dg0oeHlQ6U3u3yuAW4gxtJwcP94KfTw7uhRtv2u04bHnk2PLINDPJIoscM5tcM5scRxa5udnk5GSTlZFJTkY22VlZ5GZlk5uTTV52Dvm52eTn5eLIy8HMzwEzFzM/D8ORB+RimHkY5IGZj418TBwY5J8YTAzbiVfDgWHkYzNOvncONpsDwzAxbCfG2U7MY5jYTr63OadjczjbnRgo8GqCYYLhgBPvDdsF/r/cdTQu/4yTz3S8R8eArJGV/U6xB5/CUvARkZLh5eXsDF2z5oXNl5/vDD+pqc4gdPL1TO/T0503c8zIOPPrv8flnnL0JCvLOZRyBmAHvE8MZ2WzOa/UK/ZXt/O3O3UwDOdw8v2/Xws5zbQZ5BsmDpuBacP53v7Pq+PEax6QY0KuYSPfNMnFRq4J+aZBnmniwEYuBg5MHIADZyxyfTadyzIBh2liYjo/m2CeGO+MX44T03HOaTic70/MAyYn3zlbnBraHCfG4uxfZ7g+YZonAt+JYywn2xgnD5oYpmv+ExNxNTQcJ4/HnFgGruUYJ5bpbGueOGt84piNa30F5zWME+MM/pnGiRD672Vinvh8oq3rPa7tOZkqjQLrdfJoZV38UPARkdLFbv+nr09xy8v7JxBlZjqveMvOvrDXs03LzXUu/9/D2cafb9qp03MLcbrL4Sj4WJMyzkBfUOXaUAUfEZGS5+b2Tx+hssbh+CcQ5ec7P5e2V9P85/XU9xc6rjiWUVLrgn+mFeZzUeYpjmWU5nnA0luwK/iIiJQFNts/fYlEpMh0twcRERGpMBR8REREpMJQ8BEREZEKQ8FHREREKgwFHxEREakwFHxERESkwlDwERERkQpDwUdEREQqDAUfERERqTAUfERERKTCUPARERGRCkPBR0RERCoMBR8RERGpMBR8REREpMJws7qA0sY0TQBSU1MtrkREREQK6+T39snv8bNR8PmX48ePAxAZGWlxJSIiInKhjh8/TmBg4FmnG+b5olEF43A4OHToEP7+/hiGUWzLTU1NJTIykv379xMQEFBsyy0tyvv2QfnfxvK+fVD+t1HbV/aV920sye0zTZPjx48TERGBzXb2njw64vMvNpuN6tWrl9jyAwICyuUv80nlffug/G9jed8+KP/bqO0r+8r7NpbU9p3rSM9J6twsIiIiFYaCj4iIiFQYCj6XiKenJ8899xyenp5Wl1Iiyvv2QfnfxvK+fVD+t1HbV/aV920sDdunzs0iIiJSYeiIj4iIiFQYCj4iIiJSYSj4iIiISIWh4CMiIiIVhoLPJTJ58mRq1aqFl5cXbdq0YdWqVVaXdF7jxo3jiiuuwN/fn5CQELp378727dsLtLnuuuswDKPAMGjQoAJt9u3bR9euXfHx8SEkJIQnnniCvLy8S7kpZzVmzJjT6m/QoIFrelZWFg899BBVqlTBz8+PO++8k8OHDxdYRmnevlq1ap22fYZh8NBDDwFlc//9+eef3HrrrURERGAYBjNnziww3TRNRo8eTXh4ON7e3nTs2JGdO3cWaJOUlESvXr0ICAggKCiIAQMGkJaWVqDNxo0bufrqq/Hy8iIyMpJXX321pDcNOPf25ebmMnLkSJo0aYKvry8RERHcd999HDp0qMAyzrTfx48fX6BNadw+gL59+55We+fOnQu0Kc37D86/jWf6N2kYBhMmTHC1Kc37sDDfDcX1t3PRokW0aNECT09PoqOjmT59+sVvgCklbsaMGaaHh4c5depUc/PmzeYDDzxgBgUFmYcPH7a6tHPq1KmTOW3aNHPTpk3m+vXrzZtvvtmsUaOGmZaW5mpz7bXXmg888IAZFxfnGlJSUlzT8/LyzMaNG5sdO3Y0161bZ86ePdusWrWqOWrUKCs26TTPPfecedlllxWo/8iRI67pgwYNMiMjI80FCxaYa9asMa+88kqzXbt2rumlffsSEhIKbNu8efNMwFy4cKFpmmVz/82ePdt8+umnze+//94EzB9++KHA9PHjx5uBgYHmzJkzzQ0bNpi33XabWbt2bTMzM9PVpnPnzmbTpk3NFStWmIsXLzajo6PNnj17uqanpKSYoaGhZq9evcxNmzaZX375pent7W1+8MEHlm5fcnKy2bFjR/Orr74yt23bZi5fvtxs3bq12bJlywLLqFmzpvn8888X2K+n/rstrdtnmqbZp08fs3PnzgVqT0pKKtCmNO8/0zz/Np66bXFxcebUqVNNwzDMmJgYV5vSvA8L891QHH87d+/ebfr4+JiPP/64uWXLFvPtt9827Xa7OWfOnIuqX8HnEmjdurX50EMPuT7n5+ebERER5rhx4yys6sIlJCSYgPnHH3+4xl177bXm0KFDzzrP7NmzTZvNZsbHx7vGvffee2ZAQICZnZ1dkuUWynPPPWc2bdr0jNOSk5NNd3d385tvvnGN27p1qwmYy5cvN02z9G/fvw0dOtSsU6eO6XA4TNMs+/vv318qDofDDAsLMydMmOAal5ycbHp6eppffvmlaZqmuWXLFhMwV69e7Wrz66+/moZhmAcPHjRN0zTfffdds1KlSgW2ceTIkWb9+vVLeIsKOtOX5r+tWrXKBMy9e/e6xtWsWdN84403zjpPad6+Pn36mN26dTvrPGVp/5lm4fZht27dzA4dOhQYV1b2oWme/t1QXH87n3zySfOyyy4rsK4ePXqYnTp1uqh6daqrhOXk5LB27Vo6duzoGmez2ejYsSPLly+3sLILl5KSAkDlypULjP/888+pWrUqjRs3ZtSoUWRkZLimLV++nCZNmhAaGuoa16lTJ1JTU9m8efOlKfw8du7cSUREBFFRUfTq1Yt9+/YBsHbtWnJzcwvsuwYNGlCjRg3XvisL23dSTk4On332Gf379y/wAN6yvv9OFRsbS3x8fIF9FhgYSJs2bQrss6CgIFq1auVq07FjR2w2GytXrnS1ueaaa/Dw8HC16dSpE9u3b+fYsWOXaGsKJyUlBcMwCAoKKjB+/PjxVKlShebNmzNhwoQCpxBK+/YtWrSIkJAQ6tevz+DBg0lMTHRNK2/77/Dhw/zyyy8MGDDgtGllZR/++7uhuP52Ll++vMAyTra52O9OPaS0hB09epT8/PwCOxcgNDSUbdu2WVTVhXM4HAwbNoyrrrqKxo0bu8b/97//pWbNmkRERLBx40ZGjhzJ9u3b+f777wGIj48/47afnGa1Nm3aMH36dOrXr09cXBxjx47l6quvZtOmTcTHx+Ph4XHaF0poaKir9tK+faeaOXMmycnJ9O3b1zWurO+/fztZ05lqPnWfhYSEFJju5uZG5cqVC7SpXbv2acs4Oa1SpUolUv+FysrKYuTIkfTs2bPAAx8fffRRWrRoQeXKlVm2bBmjRo0iLi6OiRMnAqV7+zp37swdd9xB7dq1iYmJ4f/+7//o0qULy5cvx263l6v9B/Dxxx/j7+/PHXfcUWB8WdmHZ/puKK6/nWdrk5qaSmZmJt7e3kWqWcFHCuWhhx5i06ZNLFmypMD4gQMHut43adKE8PBwbrjhBmJiYqhTp86lLvOCdenSxfX+8ssvp02bNtSsWZOvv/66yP+oSqspU6bQpUsXIiIiXOPK+v6ryHJzc7nnnnswTZP33nuvwLTHH3/c9f7yyy/Hw8ODBx98kHHjxpX6RyH85z//cb1v0qQJl19+OXXq1GHRokXccMMNFlZWMqZOnUqvXr3w8vIqML6s7MOzfTeUZjrVVcKqVq2K3W4/rTf74cOHCQsLs6iqC/Pwww8za9YsFi5cSPXq1c/Ztk2bNgDs2rULgLCwsDNu+8lppU1QUBD16tVj165dhIWFkZOTQ3JycoE2p+67srJ9e/fuZf78+dx///3nbFfW99/Jms717y0sLIyEhIQC0/Py8khKSioz+/Vk6Nm7dy/z5s0rcLTnTNq0aUNeXh579uwBSv/2nSoqKoqqVasW+J0s6/vvpMWLF7N9+/bz/ruE0rkPz/bdUFx/O8/WJiAg4KL+Y6rgU8I8PDxo2bIlCxYscI1zOBwsWLCAtm3bWljZ+ZmmycMPP8wPP/zA77//ftph1TNZv349AOHh4QC0bduWv//+u8AfqpN/qBs1alQidV+MtLQ0YmJiCA8Pp2XLlri7uxfYd9u3b2ffvn2ufVdWtm/atGmEhITQtWvXc7Yr6/uvdu3ahIWFFdhnqamprFy5ssA+S05OZu3ata42v//+Ow6HwxX82rZty59//klubq6rzbx586hfv77lp0lOhp6dO3cyf/58qlSpct551q9fj81mc50iKs3b928HDhwgMTGxwO9kWd5/p5oyZQotW7akadOm521bmvbh+b4biutvZ9u2bQss42Sbi/7uvKiu0VIoM2bMMD09Pc3p06ebW7ZsMQcOHGgGBQUV6M1eGg0ePNgMDAw0Fy1aVOCSyoyMDNM0TXPXrl3m888/b65Zs8aMjY01f/zxRzMqKsq85pprXMs4ecniTTfdZK5fv96cM2eOGRwcXGou9x4+fLi5aNEiMzY21ly6dKnZsWNHs2rVqmZCQoJpms5LMmvUqGH+/vvv5po1a8y2bduabdu2dc1f2rfPNJ1XEdaoUcMcOXJkgfFldf8dP37cXLdunblu3ToTMCdOnGiuW7fOdVXT+PHjzaCgIPPHH380N27caHbr1u2Ml7M3b97cXLlypblkyRKzbt26BS6HTk5ONkNDQ817773X3LRpkzljxgzTx8fnklwqfK7ty8nJMW+77TazevXq5vr16wv8uzx5JcyyZcvMN954w1y/fr0ZExNjfvbZZ2ZwcLB53333lfrtO378uDlixAhz+fLlZmxsrDl//nyzRYsWZt26dc2srCzXMkrz/jvfNp6UkpJi+vj4mO+9995p85f2fXi+7wbTLJ6/nScvZ3/iiSfMrVu3mpMnT9bl7GXJ22+/bdaoUcP08PAwW7duba5YscLqks4LOOMwbdo00zRNc9++feY111xjVq5c2fT09DSjo6PNJ554osB9YEzTNPfs2WN26dLF9Pb2NqtWrWoOHz7czM3NtWCLTtejRw8zPDzc9PDwMKtVq2b26NHD3LVrl2t6ZmamOWTIELNSpUqmj4+Pefvtt5txcXEFllGat880TXPu3LkmYG7fvr3A+LK6/xYuXHjG38s+ffqYpum8pP3ZZ581Q0NDTU9PT/OGG244bdsTExPNnj17mn5+fmZAQIDZr18/8/jx4wXabNiwwWzfvr3p6elpVqtWzRw/frzl2xcbG3vWf5cn7820du1as02bNmZgYKDp5eVlNmzY0Hz55ZcLBIfSun0ZGRnmTTfdZAYHB5vu7u5mzZo1zQceeOC0/ySW5v13vm086YMPPjC9vb3N5OTk0+Yv7fvwfN8Npll8fzsXLlxoNmvWzPTw8DCjoqIKrKOojBMbISIiIlLuqY+PiIiIVBgKPiIiIlJhKPiIiIhIhaHgIyIiIhWGgo+IiIhUGAo+IiIiUmEo+IiIiEiFoeAjIiIiFYaCj4jIKWrVqsWkSZOsLkNESoiCj4hYpm/fvnTv3h2A6667jmHDhl2ydU+fPp2goKDTxq9evZqBAwdesjpE5NJys7oAEZHilJOTg4eHR5HnDw4OLsZqRKS00REfEbFc3759+eOPP3jzzTcxDAPDMNizZw8AmzZtokuXLvj5+REaGsq9997L0aNHXfNed911PPzwwwwbNoyqVavSqVMnACZOnEiTJk3w9fUlMjKSIUOGkJaWBsCiRYvo168fKSkprvWNGTMGOP1U1759++jWrRt+fn4EBARwzz33cPjwYdf0MWPG0KxZMz799FNq1apFYGAg//nPfzh+/HjJ/tBEpEgUfETEcm+++SZt27blgQceIC4ujri4OCIjI0lOTqZDhw40b96cNWvWMGfOHA4fPsw999xTYP6PP/4YDw8Pli5dyvvvvw+AzWbjrbfeYvPmzXz88cf8/vvvPPnkkwC0a9eOSZMmERAQ4FrfiBEjTqvL4XDQrVs3kpKS+OOPP5g3bx67d++mR48eBdrFxMQwc+ZMZs2axaxZs/jjjz8YP358Cf20RORi6FSXiFguMDAQDw8PfHx8CAsLc41/5513aN68OS+//LJr3NSpU4mMjGTHjh3Uq1cPgLp16/Lqq68WWOap/YVq1arFiy++yKBBg3j33Xfx8PAgMDAQwzAKrO/fFixYwN9//01sbCyRkZEAfPLJJ1x22WWsXr2aK664AnAGpOnTp+Pv7w/Avffey4IFC3jppZcu7gcjIsVOR3xEpNTasGEDCxcuxM/PzzU0aNAAcB5lOally5anzTt//nxuuOEGqlWrhr+/P/feey+JiYlkZGQUev1bt24lMjLSFXoAGjVqRFBQEFu3bnWNq1Wrliv0AISHh5OQkHBB2yoil4aO+IhIqZWWlsatt97KK6+8ctq08PBw13tfX98C0/bs2cMtt9zC4MGDeemll6hcuTJLlixhwIAB5OTk4OPjU6x1uru7F/hsGAYOh6NY1yEixUPBR0RKBQ8PD/Lz8wuMa9GiBd999x21atXCza3wf67Wrl2Lw+Hg9ddfx2ZzHtj++uuvz7u+f2vYsCH79+9n//79rqM+W7ZsITk5mUaNGhW6HhEpPXSqS0RKhVq1arFy5Ur27NnD0aNHcTgcPPTQQyQlJdGzZ09Wr15NTEwMc+fOpV+/fucMLdHR0eTm5vL222+ze/duPv30U1en51PXl5aWxoIFCzh69OgZT4F17NiRJk2a0KtXL/766y9WrVrFfffdx7XXXkurVq2K/WcgIiVPwUdESoURI0Zgt9tp1KgRwcHB7Nu3j4iICJYuXUp+fj433XQTTZo0YdiwYQQFBbmO5JxJ06ZNmThxIq+88gqNGzfm888/Z9y4cQXatGvXjkGDBtGjRw+Cg4NP6xwNzlNWP/74I5UqVeKaa66hY8eOREVF8dVXXxX79ovIpWGYpmlaXYSIiIjIpaAjPiIiIlJhKPiIiIhIhaHgIyIiIhWGgo+IiIhUGAo+IiIiUmEo+IiIiEiFoeAjIiIiFYaCj4iIiFQYCj4iIiJSYSj4iIiISIWh4CMiIiIVxv8DuVAzrm6fHjAAAAAASUVORK5CYII=" }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1999: 0.9534459114074707\tTotal: 1922.968999862671\n" + ] } ], "source": [ @@ -879,28 +910,31 @@ "losses, losses_fgp, losses_exact = [], [], []\n", "losses_api, losses_fgp_api = [], []\n", "\n", + "eps = 1e-6\n", + "t0 = ts = time.time()\n", + "\n", "for i in range(steps_quantum):\n", " psi = wfn_quantum(theta)\n", " loss = K.real(K.conj(psi)[None, :] @ K.sparse_dense_matmul(h, psi[:, None]))[0, 0]\n", - " delta = d_theta(theta, psi)\n", + " delta = d_theta(theta, psi, eps)\n", " theta = update(theta, delta, tau_q)\n", " losses.append(loss)\n", "\n", " psi_fgp = wfn_quantum(theta_fgp)\n", " loss_fgp = K.real(K.conj(psi_fgp)[None, :] @ K.sparse_dense_matmul(h, psi_fgp[:, None]))[0, 0]\n", - " delta_fgp = d_theta(theta_fgp, psi_fgp, fixed_global_phase=True)\n", + " delta_fgp = d_theta(theta_fgp, psi_fgp, eps, fixed_global_phase=True)\n", " theta_fgp = update(theta_fgp, delta_fgp, tau_q)\n", " losses_fgp.append(loss_fgp)\n", "\n", " psi_api = wfn_quantum(theta_api)\n", " loss_api = K.real(K.conj(psi_api)[None, :] @ K.sparse_dense_matmul(h, psi_api[:, None]))[0, 0]\n", - " delta_api = d_theta_api(theta_api)\n", + " delta_api = d_theta_api(theta_api, eps)\n", " theta_api = update(theta_api, delta_api, tau_q)\n", " losses_api.append(loss_api)\n", "\n", " psi_fgp_api = wfn_quantum(theta_fgp_api)\n", " loss_fgp_api = K.real(K.conj(psi_fgp_api)[None, :] @ K.sparse_dense_matmul(h, psi_fgp_api[:, None]))[0, 0]\n", - " delta_fgp_api = d_theta_api(theta_fgp_api, fixed_global_phase=True)\n", + " delta_fgp_api = d_theta_api(theta_fgp_api, eps, fixed_global_phase=True)\n", " theta_fgp_api = update(theta_fgp_api, delta_fgp_api, tau_q)\n", " losses_fgp_api.append(loss_fgp_api)\n", "\n", @@ -909,6 +943,8 @@ " psi_exact /= K.norm(psi_exact)\n", " losses_exact.append(K.numpy(loss_exact))\n", "\n", + " eps *= 0.999\n", + "\n", " # visualise the progress\n", " clear_output(wait=True)\n", " plt.xlabel('Iteration')\n", @@ -919,7 +955,11 @@ " plt.plot(range(i + 1), losses_api, c='m', label='unfixed GP (API)')\n", " plt.plot(range(i + 1), losses_fgp_api, c='y', label='fixed GP (API)')\n", " plt.legend()\n", - " plt.show()" + " plt.show()\n", + "\n", + " te = time.time()\n", + " print(f'Epoch {i}: {te - ts}\\tTotal: {te - t0}')\n", + " ts = te" ], "metadata": { "collapsed": false @@ -937,7 +977,7 @@ { "cell_type": "markdown", "source": [ - "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods are very close, which differ very little from the exact final state. Similarly, the final states obtained by the same method but with fixed and unfixed global phases have only one global phase difference." + "We first show the overlap between the final states obtained by different methods. Similar to the classical example, all final states obtained by approximate imaginary-time evolution are close to the exact final state. However, the final states obtained by the same method but with fixed and unfixed global phases are closer and have only one global phase difference." ], "metadata": { "collapsed": false @@ -945,43 +985,43 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 17, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "overlap between psi_fgp and psi\n", - "|overlap|: 0.9988745789696979\n", - "overlap: (-0.19668447544972692+0.979318968277934j)\n", + "|overlap|: 0.9946308905819007\n", + "overlap: (-0.740140807928335-0.6644412637238422j)\n", "\n", "overlap between psi_fgp_api and psi_api\n", - "|overlap|: 0.9879934153835302\n", - "overlap: (0.3603519955155164-0.9199333824626641j)\n", + "|overlap|: 0.9989073073947322\n", + "overlap: (0.027072660263567746+0.9985403746633621j)\n", "\n", "overlap between psi_api and psi\n", - "|overlap|: 0.9316780773622957\n", - "overlap: (-0.9311795508745964+0.030474314930587453j)\n", + "|overlap|: 0.9986726114097008\n", + "overlap: (-0.7188677460240553+0.6932359976993155j)\n", "\n", "overlap between psi_fgp_api and psi_fgp\n", - "|overlap|: 0.9464927401778188\n", - "overlap: (0.9373049454332234+0.13155966887970733j)\n", + "|overlap|: 0.9997543606572588\n", + "overlap: (0.9987177429478946+0.04551539930910164j)\n", "\n", "overlap between psi_exact and psi\n", - "|overlap|: 0.8929004801904091\n", - "overlap: (-0.15813235179268223+0.8787863374226859j)\n", + "|overlap|: 0.8722054344579724\n", + "overlap: (-0.6784167782997877-0.5481724134059986j)\n", "\n", "overlap between psi_exact and psi_fgp\n", - "|overlap|: 0.8933693118434571\n", - "overlap: (0.8928470335487045-0.030543444909353012j)\n", + "|overlap|: 0.8783189735765569\n", + "overlap: (0.8783163699487184-0.002138603442025992j)\n", "\n", "overlap between psi_exact and psi_api\n", - "|overlap|: 0.8290367234971434\n", - "overlap: (0.05352132993406158-0.8273072924548461j)\n", + "|overlap|: 0.8763977936851081\n", + "overlap: (0.08830490967227977+0.8719376902645599j)\n", "\n", "overlap between psi_exact and psi_fgp_api\n", - "|overlap|: 0.8521917037527431\n", - "overlap: (0.8148474344143313-0.24950823347814624j)\n" + "|overlap|: 0.8776241084735666\n", + "overlap: (0.876306874146697-0.048065976503842395j)\n" ] } ], @@ -1011,8 +1051,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T21:53:21.980433500Z", - "start_time": "2023-07-11T21:53:21.909960400Z" + "end_time": "2023-07-13T07:30:17.637583800Z", + "start_time": "2023-07-13T07:30:17.598679600Z" } } }, @@ -1027,7 +1067,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 18, "outputs": [ { "name": "stdout", @@ -1035,9 +1075,9 @@ "text": [ "exact ground state energy: -12.669360644773814\n", "\n", - "ground state energy by exact IME: -12.634412590497769\n", - "ground state energy: -12.4774432814582\t-12.481075889123861 (fgp)\n", - "ground state energy (API): -12.391673576863138\t-12.427648711247233 (fgp)\n" + "ground state energy by exact IME: -12.635107323414964\n", + "ground state energy: -12.455023327986686\t-12.457418138786805 (fgp)\n", + "ground state energy (API): -12.454034180766776\t-12.456395342061295 (fgp)\n" ] } ], @@ -1056,14 +1096,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-11T21:53:22.388902100Z", - "start_time": "2023-07-11T21:53:21.962763600Z" + "end_time": "2023-07-13T07:30:28.049137Z", + "start_time": "2023-07-13T07:30:27.749665300Z" } } }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 12, "id": "89ed16e3", "metadata": { "collapsed": false, @@ -1071,8 +1111,8 @@ "outputs_hidden": false }, "ExecuteTime": { - "end_time": "2023-07-12T01:54:11.094124500Z", - "start_time": "2023-07-12T01:54:11.065644100Z" + "end_time": "2023-07-13T06:54:06.262972100Z", + "start_time": "2023-07-13T06:54:06.180740100Z" } }, "outputs": [ From 8c72db13f2219698c8115dfa2a21cba0450d98af Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Thu, 13 Jul 2023 15:40:41 +0800 Subject: [PATCH 539/725] update imag_time_evo.ipynb --- docs/source/tutorials/imag_time_evo.ipynb | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) diff --git a/docs/source/tutorials/imag_time_evo.ipynb b/docs/source/tutorials/imag_time_evo.ipynb index 5d53e17d..2542b985 100644 --- a/docs/source/tutorials/imag_time_evo.ipynb +++ b/docs/source/tutorials/imag_time_evo.ipynb @@ -209,16 +209,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" - ] - } - ], + "execution_count": null, + "outputs": [], "source": [ "def b2s(bit):\n", " return 1 - 2 * int(bit)\n", @@ -240,11 +232,7 @@ "Hv = construct_Ham()" ], "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-07-13T02:33:37.975017500Z", - "start_time": "2023-07-13T02:33:37.740165Z" - } + "collapsed": false } }, { From 4ab0baa2b5cf3b34bddc68687f0e84cc8773a0fc Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Jul 2023 16:14:54 +0800 Subject: [PATCH 540/725] black --- docs/source/tutorials/imag_time_evo.ipynb | 306 ++++++++++++++++------ 1 file changed, 224 insertions(+), 82 deletions(-) diff --git a/docs/source/tutorials/imag_time_evo.ipynb b/docs/source/tutorials/imag_time_evo.ipynb index 2542b985..ee58b0ea 100644 --- a/docs/source/tutorials/imag_time_evo.ipynb +++ b/docs/source/tutorials/imag_time_evo.ipynb @@ -95,17 +95,17 @@ "from functools import partial\n", "from IPython.display import clear_output\n", "\n", - "K = tc.set_backend('jax')\n", + "K = tc.set_backend(\"jax\")\n", "tc.set_dtype(\"complex128\")\n", "\n", "# cotengra package to speed up the calculation\n", "opt_ctg = ctg.ReusableHyperOptimizer(\n", - " methods = [\"greedy\", \"kahypar\"],\n", - " parallel = True,\n", - " minimize = \"combo\",\n", - " max_time = 20,\n", - " max_repeats = 128,\n", - " progbar = True\n", + " methods=[\"greedy\", \"kahypar\"],\n", + " parallel=True,\n", + " minimize=\"combo\",\n", + " max_time=20,\n", + " max_repeats=128,\n", + " progbar=True,\n", ")\n", "\n", "tc.set_contractor(\"custom\", optimizer=opt_ctg, preprocessing=True)" @@ -179,7 +179,80 @@ ], "source": [ "# a classical Hamiltonian instance\n", - "clauses = [[4, 1, 7], [5, 11, 8], [4, 1, 8], [4, 11, 8], [4, 1, 10], [5, 11, 8], [4, 1, 8], [1, 11, 8], [4, 1, 7], [0, 11, 8], [4, 1, 10], [4, 11, 8], [5, 0, 10], [0, 6, 7], [5, 0, 11], [0, 6, 7], [5, 0, 9], [3, 6, 7], [5, 0, 8], [5, 6, 7], [5, 0, 10], [3, 6, 7], [5, 0, 10], [1, 6, 7], [2, 4, 6], [1, 8, 11], [2, 4, 6], [2, 8, 11], [2, 4, 9], [5, 8, 11], [2, 4, 10], [2, 8, 11], [2, 4, 10], [4, 8, 11], [2, 4, 8], [4, 8, 11], [3, 0, 9], [5, 11, 7], [3, 0, 10], [2, 11, 7], [3, 0, 9], [0, 11, 7], [3, 0, 9], [5, 11, 7], [3, 0, 10], [3, 11, 7], [3, 0, 7], [4, 11, 7], [5, 0, 10], [4, 0, 10], [2, 5, 6], [2, 11, 10], [2, 6, 10], [2, 4, 9], [0, 9, 10], [3, 0, 7], [2, 5, 6], [1, 10, 9], [1, 4, 11], [5, 10, 11], [0, 4, 8], [0, 9, 8], [2, 11, 10], [2, 8, 6], [3, 6, 7], [0, 8, 10], [4, 0, 9], [3, 5, 8], [5, 11, 10], [2, 11, 10], [4, 11, 8], [1, 3, 11]]\n", + "clauses = [\n", + " [4, 1, 7],\n", + " [5, 11, 8],\n", + " [4, 1, 8],\n", + " [4, 11, 8],\n", + " [4, 1, 10],\n", + " [5, 11, 8],\n", + " [4, 1, 8],\n", + " [1, 11, 8],\n", + " [4, 1, 7],\n", + " [0, 11, 8],\n", + " [4, 1, 10],\n", + " [4, 11, 8],\n", + " [5, 0, 10],\n", + " [0, 6, 7],\n", + " [5, 0, 11],\n", + " [0, 6, 7],\n", + " [5, 0, 9],\n", + " [3, 6, 7],\n", + " [5, 0, 8],\n", + " [5, 6, 7],\n", + " [5, 0, 10],\n", + " [3, 6, 7],\n", + " [5, 0, 10],\n", + " [1, 6, 7],\n", + " [2, 4, 6],\n", + " [1, 8, 11],\n", + " [2, 4, 6],\n", + " [2, 8, 11],\n", + " [2, 4, 9],\n", + " [5, 8, 11],\n", + " [2, 4, 10],\n", + " [2, 8, 11],\n", + " [2, 4, 10],\n", + " [4, 8, 11],\n", + " [2, 4, 8],\n", + " [4, 8, 11],\n", + " [3, 0, 9],\n", + " [5, 11, 7],\n", + " [3, 0, 10],\n", + " [2, 11, 7],\n", + " [3, 0, 9],\n", + " [0, 11, 7],\n", + " [3, 0, 9],\n", + " [5, 11, 7],\n", + " [3, 0, 10],\n", + " [3, 11, 7],\n", + " [3, 0, 7],\n", + " [4, 11, 7],\n", + " [5, 0, 10],\n", + " [4, 0, 10],\n", + " [2, 5, 6],\n", + " [2, 11, 10],\n", + " [2, 6, 10],\n", + " [2, 4, 9],\n", + " [0, 9, 10],\n", + " [3, 0, 7],\n", + " [2, 5, 6],\n", + " [1, 10, 9],\n", + " [1, 4, 11],\n", + " [5, 10, 11],\n", + " [0, 4, 8],\n", + " [0, 9, 8],\n", + " [2, 11, 10],\n", + " [2, 8, 6],\n", + " [3, 6, 7],\n", + " [0, 8, 10],\n", + " [4, 0, 9],\n", + " [3, 5, 8],\n", + " [5, 11, 10],\n", + " [2, 11, 10],\n", + " [4, 11, 8],\n", + " [1, 3, 11],\n", + "]\n", "factor = 1 / len(clauses) / 4\n", "\n", "# convert to a NetworkX graph\n", @@ -189,13 +262,13 @@ " graph.add_edge(j, k, weight=0)\n", " graph.add_edge(k, i, weight=0)\n", "for i, j, k in clauses:\n", - " graph[i][j]['weight'] += 1\n", - " graph[j][k]['weight'] += 1\n", - " graph[k][i]['weight'] += 1\n", + " graph[i][j][\"weight\"] += 1\n", + " graph[j][k][\"weight\"] += 1\n", + " graph[k][i][\"weight\"] += 1\n", "pos = nx.spring_layout(graph)\n", "nx.draw_networkx(graph, with_labels=True, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ] }, { @@ -215,20 +288,23 @@ "def b2s(bit):\n", " return 1 - 2 * int(bit)\n", "\n", + "\n", "def energy(cfg):\n", " E = 0.25\n", " for a, b in graph.edges:\n", - " E += cfg[a] * cfg[b] * graph[a][b]['weight'] * factor\n", + " E += cfg[a] * cfg[b] * graph[a][b][\"weight\"] * factor\n", " return E\n", "\n", + "\n", "def construct_Ham():\n", " num_nodes = graph.number_of_nodes()\n", " Es = []\n", - " for i in range(2 ** num_nodes):\n", - " case = f'{bin(i)[2:]:0>{num_nodes}}'\n", + " for i in range(2**num_nodes):\n", + " case = f\"{bin(i)[2:]:0>{num_nodes}}\"\n", " Es.append(energy(list(map(b2s, case))))\n", " return jnp.asarray(Es)\n", "\n", + "\n", "Hv = construct_Ham()" ], "metadata": { @@ -285,6 +361,7 @@ "source": [ "nlayers = 20 # the number of layers\n", "\n", + "\n", "@partial(K.jit, static_argnums=(1, 2))\n", "def wfn_classical(params, each=1, return_loss=False):\n", " n = graph.number_of_nodes() # the number of nodes\n", @@ -295,7 +372,7 @@ " for j in range(each):\n", " # driving layer\n", " for a, b in graph.edges:\n", - " c_.RZZ(a, b, theta=graph[a][b]['weight'] * params_[2 * j] * factor)\n", + " c_.RZZ(a, b, theta=graph[a][b][\"weight\"] * params_[2 * j] * factor)\n", " # mixing layer\n", " for i in range(n):\n", " c_.RX(i, theta=params_[2 * j + 1])\n", @@ -312,7 +389,7 @@ " if return_loss:\n", " loss = 0.25\n", " for a, b in graph.edges:\n", - " loss += c.expectation_ps(z=[a, b]) * graph[a][b]['weight'] * factor\n", + " loss += c.expectation_ps(z=[a, b]) * graph[a][b][\"weight\"] * factor\n", " return K.real(loss)\n", " else:\n", " return c.state()" @@ -368,12 +445,17 @@ "\n", " return K.solve(A, C, assume_a=\"sym\")\n", "\n", + "\n", "@partial(K.jit, static_argnums=(2,))\n", "def d_params_api(params, eps=1e-6, fixed_global_phase=False):\n", " if fixed_global_phase:\n", - " qng = experimental.qng(wfn_classical, kernel=\"dynamics\", postprocess=None, mode=\"fwd\")\n", + " qng = experimental.qng(\n", + " wfn_classical, kernel=\"dynamics\", postprocess=None, mode=\"fwd\"\n", + " )\n", " else:\n", - " qng = experimental.qng(wfn_classical, kernel=\"qng\", postprocess=None, mode=\"fwd\")\n", + " qng = experimental.qng(\n", + " wfn_classical, kernel=\"qng\", postprocess=None, mode=\"fwd\"\n", + " )\n", " A = K.real(qng(params))\n", " # protection\n", " A += eps * K.eye(params.shape[-1], dtype=A.dtype)\n", @@ -383,7 +465,8 @@ "\n", " return loss, K.solve(A, C2 / 2, assume_a=\"sym\")\n", "\n", - "if K.name == 'jax':\n", + "\n", + "if K.name == \"jax\":\n", " opt = K.optimizer(optax.sgd(tau_c))\n", "else:\n", " opt = K.optimizer(tf.keras.optimizers.SGD(tau_c))" @@ -449,7 +532,9 @@ " params_api = opt.update(delta_api, params_api)\n", " losses_api.append(K.numpy(loss_api))\n", "\n", - " loss_fgp_api, delta_fgp_api = d_params_api(params_fgp_api, eps, fixed_global_phase=True)\n", + " loss_fgp_api, delta_fgp_api = d_params_api(\n", + " params_fgp_api, eps, fixed_global_phase=True\n", + " )\n", " params_fgp_api = opt.update(delta_fgp_api, params_fgp_api)\n", " losses_fgp_api.append(K.numpy(loss_fgp_api))\n", "\n", @@ -462,18 +547,18 @@ "\n", " # visualise the progress\n", " clear_output(wait=True)\n", - " plt.xlabel('Iteration')\n", - " plt.ylabel('Cost')\n", - " plt.plot(range(i + 1), losses_exact, c='r', label='exact')\n", - " plt.plot(range(i + 1), losses, c='b', label='unfixed GP')\n", - " plt.plot(range(i + 1), losses_fgp, c='g', label='fixed GP')\n", - " plt.plot(range(i + 1), losses_api, c='m', label='unfixed GP (API)')\n", - " plt.plot(range(i + 1), losses_fgp_api, c='y', label='fixed GP (API)')\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Cost\")\n", + " plt.plot(range(i + 1), losses_exact, c=\"r\", label=\"exact\")\n", + " plt.plot(range(i + 1), losses, c=\"b\", label=\"unfixed GP\")\n", + " plt.plot(range(i + 1), losses_fgp, c=\"g\", label=\"fixed GP\")\n", + " plt.plot(range(i + 1), losses_api, c=\"m\", label=\"unfixed GP (API)\")\n", + " plt.plot(range(i + 1), losses_fgp_api, c=\"y\", label=\"fixed GP (API)\")\n", " plt.legend()\n", " plt.show()\n", "\n", " te = time.time()\n", - " print(f'Epoch {i}: {te - ts}\\tTotal: {te - t0}')\n", + " print(f\"Epoch {i}: {te - ts}\\tTotal: {te - t0}\")\n", " ts = te" ], "metadata": { @@ -546,21 +631,37 @@ "psi_fgp_api = wfn_classical(params_fgp_api)\n", "\n", "overlap = K.tensordot(K.conj(psi_fgp), psi, 1)\n", - "print(f'overlap between psi_fgp and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_fgp and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_fgp_api), psi_api, 1)\n", - "print(f'overlap between psi_fgp_api and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_fgp_api and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_api), psi, 1)\n", - "print(f'overlap between psi_api and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_api and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_fgp_api), psi_fgp, 1)\n", - "print(f'overlap between psi_fgp_api and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_fgp_api and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_exact), psi, 1)\n", - "print(f'overlap between psi_exact and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_exact and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_exact), psi_fgp, 1)\n", - "print(f'overlap between psi_exact and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_exact and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_exact), psi_api, 1)\n", - "print(f'overlap between psi_exact and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_exact and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_exact), psi_fgp_api, 1)\n", - "print(f'overlap between psi_exact and psi_fgp_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}')" + "print(\n", + " f\"overlap between psi_exact and psi_fgp_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\"\n", + ")" ], "metadata": { "collapsed": false, @@ -601,14 +702,14 @@ } ], "source": [ - "idx = [f'{bin(i)[2:]:0>{graph.number_of_nodes()}}' for i in np.where(Hv < 1e-6)[0]]\n", - "print(f'min cost: {0.}\\nexact solution: {idx}')\n", + "idx = [f\"{bin(i)[2:]:0>{graph.number_of_nodes()}}\" for i in np.where(Hv < 1e-6)[0]]\n", + "print(f\"min cost: {0.}\\nexact solution: {idx}\")\n", "\n", "# plot NetworkX graph\n", - "colors = ['r' if idx[0][i] == '0' else 'c' for i in graph.nodes]\n", + "colors = [\"r\" if idx[0][i] == \"0\" else \"c\" for i in graph.nodes]\n", "nx.draw_networkx(graph, with_labels=True, node_color=colors, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ], "metadata": { "collapsed": false, @@ -655,9 +756,10 @@ "loss_api = K.real(K.tensordot(K.conj(psi_api) * Hv, psi_api, 1))\n", "loss_fgp_api = K.real(K.tensordot(K.conj(psi_fgp_api) * Hv, psi_fgp_api, 1))\n", "loss_exact = K.real(K.tensordot(K.conj(psi_exact) * Hv, psi_exact, 1))\n", - "print(f'cost by exact IME: {K.numpy(loss_exact)}')\n", - "print(f'cost: {K.numpy(loss)}\\t{K.numpy(loss_fgp)} (fgp)')\n", - "print(f'cost (API): {K.numpy(loss_api)}\\t{K.numpy(loss_fgp_api)} (fgp)\\n')\n", + "print(f\"cost by exact IME: {K.numpy(loss_exact)}\")\n", + "print(f\"cost: {K.numpy(loss)}\\t{K.numpy(loss_fgp)} (fgp)\")\n", + "print(f\"cost (API): {K.numpy(loss_api)}\\t{K.numpy(loss_fgp_api)} (fgp)\\n\")\n", + "\n", "\n", "# find the states with max probabilities\n", "def find_max(psi):\n", @@ -666,20 +768,21 @@ " index = np.where(probs == max_prob)[0]\n", " states = []\n", " for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{graph.number_of_nodes()}}')\n", + " states.append(f\"{bin(i)[2:]:0>{graph.number_of_nodes()}}\")\n", " return max_prob, states\n", "\n", + "\n", "prob, states = find_max(psi)\n", "prob_fpg, states_fpg = find_max(psi_fgp)\n", "prob_api, states_api = find_max(psi_api)\n", "prob_fpg_api, states_fpg_api = find_max(psi_fgp_api)\n", "prob_exact, states_exact = find_max(psi_exact)\n", - "print(f'max prob by exact IME: {prob_exact}')\n", - "print(f'max prob: {prob}\\t{prob_fpg} (fgp)')\n", - "print(f'max prob (API): {prob_api}\\t{prob_fpg_api} (fgp)\\n')\n", - "print(f'bit strings by exact IME: {states_exact}')\n", - "print(f'bit strings: {states}\\t{states_fpg} (fgp)')\n", - "print(f'bit strings (API): {states_api}\\t{states_fpg_api} (fgp)')" + "print(f\"max prob by exact IME: {prob_exact}\")\n", + "print(f\"max prob: {prob}\\t{prob_fpg} (fgp)\")\n", + "print(f\"max prob (API): {prob_api}\\t{prob_fpg_api} (fgp)\\n\")\n", + "print(f\"bit strings by exact IME: {states_exact}\")\n", + "print(f\"bit strings: {states}\\t{states_fpg} (fgp)\")\n", + "print(f\"bit strings (API): {states_api}\\t{states_fpg_api} (fgp)\")" ], "metadata": { "collapsed": false, @@ -737,7 +840,9 @@ "source": [ "N = 10\n", "g = tc.templates.graphs.Line1D(N, pbc=False)\n", - "h = tc.quantum.heisenberg_hamiltonian(g, hzz=1, hyy=0, hxx=0, hz=0.5, hx=1, hy=0, sparse=True)\n", + "h = tc.quantum.heisenberg_hamiltonian(\n", + " g, hzz=1, hyy=0, hxx=0, hz=0.5, hx=1, hy=0, sparse=True\n", + ")\n", "H = tc.array_to_tensor(h.todense())\n", "\n", "tau_q = 0.001\n", @@ -767,7 +872,8 @@ "execution_count": 14, "outputs": [], "source": [ - "l = 10 # the number of layers\n", + "l = 10 # the number of layers\n", + "\n", "\n", "@partial(K.jit, static_argnums=(1,))\n", "def wfn_quantum(theta, each=1):\n", @@ -838,10 +944,13 @@ "\n", " return K.solve(A, C, assume_a=\"sym\")\n", "\n", + "\n", "@partial(K.jit, static_argnums=(2,))\n", "def d_theta_api(theta, eps=1e-6, fixed_global_phase=False):\n", " if fixed_global_phase:\n", - " qng = experimental.qng2(wfn_quantum, kernel=\"dynamics\", postprocess=None, mode=\"fwd\")\n", + " qng = experimental.qng2(\n", + " wfn_quantum, kernel=\"dynamics\", postprocess=None, mode=\"fwd\"\n", + " )\n", " else:\n", " qng = experimental.qng2(wfn_quantum, kernel=\"qng\", postprocess=None, mode=\"fwd\")\n", " A = K.real(qng(theta))\n", @@ -853,6 +962,7 @@ "\n", " return K.solve(A, C, assume_a=\"sym\")\n", "\n", + "\n", "@K.jit\n", "def update(theta, delta, tau):\n", " return theta - K.cast(tau * delta, dtype=theta.dtype)" @@ -909,24 +1019,32 @@ " losses.append(loss)\n", "\n", " psi_fgp = wfn_quantum(theta_fgp)\n", - " loss_fgp = K.real(K.conj(psi_fgp)[None, :] @ K.sparse_dense_matmul(h, psi_fgp[:, None]))[0, 0]\n", + " loss_fgp = K.real(\n", + " K.conj(psi_fgp)[None, :] @ K.sparse_dense_matmul(h, psi_fgp[:, None])\n", + " )[0, 0]\n", " delta_fgp = d_theta(theta_fgp, psi_fgp, eps, fixed_global_phase=True)\n", " theta_fgp = update(theta_fgp, delta_fgp, tau_q)\n", " losses_fgp.append(loss_fgp)\n", "\n", " psi_api = wfn_quantum(theta_api)\n", - " loss_api = K.real(K.conj(psi_api)[None, :] @ K.sparse_dense_matmul(h, psi_api[:, None]))[0, 0]\n", + " loss_api = K.real(\n", + " K.conj(psi_api)[None, :] @ K.sparse_dense_matmul(h, psi_api[:, None])\n", + " )[0, 0]\n", " delta_api = d_theta_api(theta_api, eps)\n", " theta_api = update(theta_api, delta_api, tau_q)\n", " losses_api.append(loss_api)\n", "\n", " psi_fgp_api = wfn_quantum(theta_fgp_api)\n", - " loss_fgp_api = K.real(K.conj(psi_fgp_api)[None, :] @ K.sparse_dense_matmul(h, psi_fgp_api[:, None]))[0, 0]\n", + " loss_fgp_api = K.real(\n", + " K.conj(psi_fgp_api)[None, :] @ K.sparse_dense_matmul(h, psi_fgp_api[:, None])\n", + " )[0, 0]\n", " delta_fgp_api = d_theta_api(theta_fgp_api, eps, fixed_global_phase=True)\n", " theta_fgp_api = update(theta_fgp_api, delta_fgp_api, tau_q)\n", " losses_fgp_api.append(loss_fgp_api)\n", "\n", - " loss_exact = K.real(K.transpose(K.conj(psi_exact)) @ K.sparse_dense_matmul(h, psi_exact))[0, 0]\n", + " loss_exact = K.real(\n", + " K.transpose(K.conj(psi_exact)) @ K.sparse_dense_matmul(h, psi_exact)\n", + " )[0, 0]\n", " psi_exact = exp_tauH @ psi_exact\n", " psi_exact /= K.norm(psi_exact)\n", " losses_exact.append(K.numpy(loss_exact))\n", @@ -935,18 +1053,18 @@ "\n", " # visualise the progress\n", " clear_output(wait=True)\n", - " plt.xlabel('Iteration')\n", - " plt.ylabel('Energy')\n", - " plt.plot(range(i + 1), losses_exact, c='r', label='exact')\n", - " plt.plot(range(i + 1), losses, c='b', label='unfixed GP')\n", - " plt.plot(range(i + 1), losses_fgp, c='g', label='fixed GP')\n", - " plt.plot(range(i + 1), losses_api, c='m', label='unfixed GP (API)')\n", - " plt.plot(range(i + 1), losses_fgp_api, c='y', label='fixed GP (API)')\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Energy\")\n", + " plt.plot(range(i + 1), losses_exact, c=\"r\", label=\"exact\")\n", + " plt.plot(range(i + 1), losses, c=\"b\", label=\"unfixed GP\")\n", + " plt.plot(range(i + 1), losses_fgp, c=\"g\", label=\"fixed GP\")\n", + " plt.plot(range(i + 1), losses_api, c=\"m\", label=\"unfixed GP (API)\")\n", + " plt.plot(range(i + 1), losses_fgp_api, c=\"y\", label=\"fixed GP (API)\")\n", " plt.legend()\n", " plt.show()\n", "\n", " te = time.time()\n", - " print(f'Epoch {i}: {te - ts}\\tTotal: {te - t0}')\n", + " print(f\"Epoch {i}: {te - ts}\\tTotal: {te - t0}\")\n", " ts = te" ], "metadata": { @@ -1020,21 +1138,37 @@ "psi_fgp_api = wfn_quantum(theta_fgp_api)\n", "\n", "overlap = K.tensordot(K.conj(psi_fgp), psi, 1)\n", - "print(f'overlap between psi_fgp and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_fgp and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_fgp_api), psi_api, 1)\n", - "print(f'overlap between psi_fgp_api and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_fgp_api and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_api), psi, 1)\n", - "print(f'overlap between psi_api and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_api and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_fgp_api), psi_fgp, 1)\n", - "print(f'overlap between psi_fgp_api and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_fgp_api and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_exact[:, 0]), psi, 1)\n", - "print(f'overlap between psi_exact and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_exact and psi\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_exact[:, 0]), psi_fgp, 1)\n", - "print(f'overlap between psi_exact and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_exact and psi_fgp\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_exact[:, 0]), psi_api, 1)\n", - "print(f'overlap between psi_exact and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n')\n", + "print(\n", + " f\"overlap between psi_exact and psi_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\\n\"\n", + ")\n", "overlap = K.tensordot(K.conj(psi_exact[:, 0]), psi_fgp_api, 1)\n", - "print(f'overlap between psi_exact and psi_fgp_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}')" + "print(\n", + " f\"overlap between psi_exact and psi_fgp_api\\n|overlap|: {K.abs(overlap)}\\noverlap: {overlap}\"\n", + ")" ], "metadata": { "collapsed": false, @@ -1071,15 +1205,23 @@ ], "source": [ "E = K.eigvalsh(H)[0]\n", - "print(f'exact ground state energy: {E}\\n')\n", - "loss_exact = K.real(K.transpose(K.conj(psi_exact)) @ K.sparse_dense_matmul(h, psi_exact))[0, 0]\n", - "print(f'ground state energy by exact IME: {K.numpy(loss_exact)}')\n", + "print(f\"exact ground state energy: {E}\\n\")\n", + "loss_exact = K.real(\n", + " K.transpose(K.conj(psi_exact)) @ K.sparse_dense_matmul(h, psi_exact)\n", + ")[0, 0]\n", + "print(f\"ground state energy by exact IME: {K.numpy(loss_exact)}\")\n", "loss = K.real(K.conj(psi)[None, :] @ K.sparse_dense_matmul(h, psi[:, None]))[0, 0]\n", - "loss_fgp = K.real(K.conj(psi_fgp)[None, :] @ K.sparse_dense_matmul(h, psi_fgp[:, None]))[0, 0]\n", - "print(f'ground state energy: {K.numpy(loss)}\\t{K.numpy(loss_fgp)} (fgp)')\n", - "loss_api = K.real(K.conj(psi_api)[None, :] @ K.sparse_dense_matmul(h, psi_api[:, None]))[0, 0]\n", - "loss_fgp_api = K.real(K.conj(psi_fgp_api)[None, :] @ K.sparse_dense_matmul(h, psi_fgp_api[:, None]))[0, 0]\n", - "print(f'ground state energy (API): {K.numpy(loss_api)}\\t{K.numpy(loss_fgp_api)} (fgp)')" + "loss_fgp = K.real(\n", + " K.conj(psi_fgp)[None, :] @ K.sparse_dense_matmul(h, psi_fgp[:, None])\n", + ")[0, 0]\n", + "print(f\"ground state energy: {K.numpy(loss)}\\t{K.numpy(loss_fgp)} (fgp)\")\n", + "loss_api = K.real(\n", + " K.conj(psi_api)[None, :] @ K.sparse_dense_matmul(h, psi_api[:, None])\n", + ")[0, 0]\n", + "loss_fgp_api = K.real(\n", + " K.conj(psi_fgp_api)[None, :] @ K.sparse_dense_matmul(h, psi_fgp_api[:, None])\n", + ")[0, 0]\n", + "print(f\"ground state energy (API): {K.numpy(loss_api)}\\t{K.numpy(loss_fgp_api)} (fgp)\")" ], "metadata": { "collapsed": false, From 883dae26f2ea9dc806d166a399a12aaaf29b35af Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Thu, 13 Jul 2023 20:40:08 +0800 Subject: [PATCH 541/725] update imag_time_evo.ipynb --- docs/source/tutorials/imag_time_evo.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/source/tutorials/imag_time_evo.ipynb b/docs/source/tutorials/imag_time_evo.ipynb index 2542b985..eb371bbf 100644 --- a/docs/source/tutorials/imag_time_evo.ipynb +++ b/docs/source/tutorials/imag_time_evo.ipynb @@ -337,7 +337,7 @@ { "cell_type": "markdown", "source": [ - "We use two methods to calculate $\\boldsymbol{\\delta}$, one is to calculate directly according to the expressions of $\\boldsymbol{A}$ and $\\boldsymbol{C}$, and the other is to call the existing API to calculate $\\boldsymbol{A}$ and $\\boldsymbol{C}$. The former only needs to calculate the $|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle$ once, while the latter needs to calculate that twice, but the code of the latter is more concise. In each method, we set the parameter $\\text{fixed_global_phase}$ to decide whether to fix the global phase, that is, whether the second term of $\\boldsymbol{A}$ vanishes.\n", + "We use two methods to calculate $\\boldsymbol{\\delta}$, one is to calculate directly according to the expressions of $\\boldsymbol{A}$ and $\\boldsymbol{C}$, and the other is to call the existing API to calculate $\\boldsymbol{A}$ and $\\boldsymbol{C}$. The former only needs to calculate the $|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle$ once, while the latter needs to calculate that twice, but the code of the latter is more concise. In each method, we set the parameter fixed_global_phase to decide whether to fix the global phase, that is, whether the second term of $\\boldsymbol{A}$ vanishes.\n", "\n", "Then we choose the existing optimizer, SGD, to implement the update step. Since compared with naive gradient descent, the approximate imaginary-time evolution has been corrected on the update step size, the adaptive optimizer improved for the naive gradient descent such as Adam is not suitable for the approximate imaginary-time evolution. When update by the adaptive optimizer, the loss function fluctuates greatly. On the other hand, the update method of SGD without momentum is naive update, which is convenient for comparison with the exact imaginary-time evolution." ], @@ -491,7 +491,7 @@ { "cell_type": "markdown", "source": [ - "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods but with the same parameter of $\\text{fixed_global_phase}$ are almost the same, which are also close to the exact final state. And the final states obtained by the same method but with the different parameter of $\\text{fixed_global_phase}$ has a global phase difference." + "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods but with the same parameter of fixed_global_phase are almost the same, which are also close to the exact final state. And the final states obtained by the same method but with the different parameter of fixed_global_phase has a global phase difference." ], "metadata": { "collapsed": false @@ -809,7 +809,7 @@ { "cell_type": "markdown", "source": [ - "We also use two methods to calculate $\\boldsymbol{\\delta}$, but make some changes in the method of directly calling the API and the update method. When calculating $\\boldsymbol{A}$, we call $\\text{qng2}$ instead of $\\text{qng}$, and when calculating $\\boldsymbol{C}$, we call $\\text{dynamics_rhs}$ instead of calculating the energy gradient by $\\text{value_and_grad}$. For the update method, we do not call the existing optimizer but directly adopt the naive update method." + "We also use two methods to calculate $\\boldsymbol{\\delta}$, but make some changes in the method of directly calling the API and the update method. When calculating $\\boldsymbol{A}$, we call qng2 instead of qng, and when calculating $\\boldsymbol{C}$, we call dynamics_rhs instead of calculating the energy gradient by value_and_grad. For the update method, we do not call the existing optimizer but directly adopt the naive update method." ], "metadata": { "collapsed": false From 467399f65c4a6df5cd7c85a642bc2be6c4ebf366 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Jul 2023 20:46:06 +0800 Subject: [PATCH 542/725] update readme --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 1872c524..eb0f7f1f 100644 --- a/README.md +++ b/README.md @@ -346,6 +346,8 @@ Reference paper: https://arxiv.org/abs/2303.14877. - GSQAS: Graph Self-supervised Quantum Architecture Search: https://arxiv.org/abs/2303.12381. +- Practical advantage of quantum machine learning in ghost imaging: https://www.nature.com/articles/s42005-023-01290-1 (published in communications physics). + If you want to highlight your research work here, feel free to add by opening PR. From 6c192063de3600192c08af9a145e1ae7aea4e358 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 13 Jul 2023 21:10:40 +0800 Subject: [PATCH 543/725] update readme --- README.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/README.md b/README.md index eb0f7f1f..392ab96a 100644 --- a/README.md +++ b/README.md @@ -100,6 +100,17 @@ energy = tc.templates.measurements.operator_expectation(c, h) # -6 ``` +- Large-scale simulation with tensor network engine + +```python +# tc.set_contractor("cotengra-30-10") +n=500 +c = tc.Circuit(n) +c.h(0) +c.cx(range(n-1), range(1, n)) +c.expectation_ps(z=[0, n-1], reuse=False) +``` + ## Install From 260c11ad9308efe98ff739dd5c30c9ebc90ddc59 Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Fri, 14 Jul 2023 00:03:28 +0800 Subject: [PATCH 544/725] Updated mac install guide and sklearn svm tutorial --- docs/source/contribs/development_Mac.md | 80 ++++++ docs/source/contribs/development_MacARM.md | 3 + docs/source/contribs/development_MacM1.rst | 2 +- docs/source/contribs/development_MacM2.md | 3 + docs/source/contribs/development_Mac_cn.md | 80 ++++++ docs/source/quickstart.rst | 4 +- docs/source/tutorial.rst | 3 +- docs/source/tutorial_cn.rst | 3 +- docs/source/tutorials/sklearn_svc.ipynb | 303 +++++++++++++++++++++ docs/source/tutorials/sklearn_svc_cn.ipynb | 303 +++++++++++++++++++++ 10 files changed, 779 insertions(+), 5 deletions(-) create mode 100644 docs/source/contribs/development_Mac.md create mode 100644 docs/source/contribs/development_Mac_cn.md create mode 100644 docs/source/tutorials/sklearn_svc.ipynb create mode 100644 docs/source/tutorials/sklearn_svc_cn.ipynb diff --git a/docs/source/contribs/development_Mac.md b/docs/source/contribs/development_Mac.md new file mode 100644 index 00000000..00e03c92 --- /dev/null +++ b/docs/source/contribs/development_Mac.md @@ -0,0 +1,80 @@ +# Tensorcircuit Installation Guide on MacOS + +Contributed by [_Mark (Zixuan) Song_](https://marksong.tech) + +Apple has updated Tensorflow (for MacOS) so that installation on M-series (until M2) and Intel-series Mac can follow the exact same procedure. + +## Starting From Scratch + +For completely new Macos or Macos without Xcode and Homebrew installed. + +### Install Xcode Command Line Tools + +Need graphical access to the machine. + +Run `xcode-select --install` to install if on optimal internet. + +Or Download it from [Apple](https://developer.apple.com/download/more/) Command Line Tools installation image then install it if the internet connection is weak. + +## Install Miniconda + +Due to the limitation of MacOS and packages, the latest version of Python does not always function as desired, thus miniconda installation is advised to solve the issues. + +```bash +curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh +bash ~/miniconda.sh -b -p $HOME/miniconda +source ~/miniconda/bin/activate +conda install -c apple tensorflow-deps +``` + +## Install TC Backends + +There are four backends to choose from, Numpy, Tensorflow, Jax, and Torch. + +### Install Jax, Pytorch, Qiskit, Cirq (Optional) + +```bash +pip install [Package Name] +``` + +### Install Tensorflow (Optional) + +#### Installation + +For Tensorflow version 2.13 or later: +```bash +pip install tensorflow +pip install tensorflow-metal +``` + +For Tensorflow version 2.12 or earlier: +```bash +pip install tensorflow-macos +pip install tensorflow-metal +``` + +#### Verify Tensorflow Installation + +```python +import tensorflow as tf + +cifar = tf.keras.datasets.cifar100 +(x_train, y_train), (x_test, y_test) = cifar.load_data() +model = tf.keras.applications.ResNet50( + include_top=True, + weights=None, + input_shape=(32, 32, 3), + classes=100,) + +loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) +model.compile(optimizer="adam", loss=loss_fn, metrics=["accuracy"]) +model.fit(x_train, y_train, epochs=5, batch_size=64) +``` + +## Install Tensorcircuit + +```bash +pip install tensorcircuit +``` + +Until July 2023, this has been tested on Intel Macs running Ventura, M1 Macs running Ventura, M2 Macs running Ventura, and M2 Macs running Sonoma beta. \ No newline at end of file diff --git a/docs/source/contribs/development_MacARM.md b/docs/source/contribs/development_MacARM.md index 1ead5993..73c63948 100644 --- a/docs/source/contribs/development_MacARM.md +++ b/docs/source/contribs/development_MacARM.md @@ -2,6 +2,9 @@ Contributed by Mark (Zixuan) Song +.. warning:: + This page is deprecated. Please visit `the update tutorial `_ for the latest information. + ## Starting From Scratch For completely new macos or macos without xcode and brew diff --git a/docs/source/contribs/development_MacM1.rst b/docs/source/contribs/development_MacM1.rst index 3df9c949..8ce9f058 100644 --- a/docs/source/contribs/development_MacM1.rst +++ b/docs/source/contribs/development_MacM1.rst @@ -4,7 +4,7 @@ Contributed by (Yuqin Chen) .. warning:: - This page is deprecated. Please visit `the update tutorial `_ for latest information. + This page is deprecated. Please visit `the update tutorial `_ for the latest information. Why We Can't Run TensorCircuit on TensorlowBackend with Apple M1 diff --git a/docs/source/contribs/development_MacM2.md b/docs/source/contribs/development_MacM2.md index 28c77bc3..b3daf5fb 100644 --- a/docs/source/contribs/development_MacM2.md +++ b/docs/source/contribs/development_MacM2.md @@ -2,6 +2,9 @@ Contributed by [Hong-Ye Hu](https://github.com/hongyehu) +.. warning:: + This page is deprecated. Please visit `the update tutorial `_ for the latest information. + The key issue addressed in this document is **how to install both TensorFlow and Jax on a M2 chip MacOS without conflict**. ## Starting From Scratch diff --git a/docs/source/contribs/development_Mac_cn.md b/docs/source/contribs/development_Mac_cn.md new file mode 100644 index 00000000..2188a67b --- /dev/null +++ b/docs/source/contribs/development_Mac_cn.md @@ -0,0 +1,80 @@ +# MacOS Tensorcircuit 安装教程 + +[_Mark (Zixuan) Song_](https://marksong.tech) 撰写 + +由于苹果更新了Tensorflow，因此M系列（直到M2）和英特尔系列Mac上的安装可以遵循完全相同的过程。 + +## 从头开始 + +对于全新的Macos或未安装Xcode和Homebrew的Macos。 + +### 安装Xcode命令行工具 + +需要对机器的图形访问。 + +如果网络良好，请运行`xcode-select --install`进行安装。 + +或者，如果网络连接较弱，请从[苹果](https://developer.apple.com/download/more/)下载命令行工具安装映像，然后进行安装。 + +## 安装Miniconda + +由于MacOS和软件包的限制，因此建议安装miniconda以解决问题。 + +```bash +curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh +bash ~/miniconda.sh -b -p $HOME/miniconda +source ~/miniconda/bin/activate +conda install -c apple tensorflow-deps +``` + +## 安装TC后端 + +有四个后端可供选择，Numpy，Tensorflow，Jax和Torch。 + +### 安装Jax，Pytorch，Qiskit，Cirq（可选） + +```bash +pip install [Package Name] +``` + +### 安装Tensorflow（可选） + +#### 安装步骤 + +Tensorflow版本2.13或之后： +```bash +pip install tensorflow +pip install tensorflow-metal +``` + +Tensorflow版本2.12或之前： +```bash +pip install tensorflow-macos +pip install tensorflow-metal +``` + +#### 验证Tensorflow安装 + +```python +import tensorflow as tf + +cifar = tf.keras.datasets.cifar100 +(x_train, y_train), (x_test, y_test) = cifar.load_data() +model = tf.keras.applications.ResNet50( + include_top=True, + weights=None, + input_shape=(32, 32, 3), + classes=100,) + +loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) +model.compile(optimizer="adam", loss=loss_fn, metrics=["accuracy"]) +model.fit(x_train, y_train, epochs=5, batch_size=64) +``` + +## 安装Tensorcircuit + +```bash +pip install tensorcircuit +``` + +直到2023年7月，这已在运行Ventura的英特尔i9 Mac、运行Ventura的M1 Mac、运行Ventura的M2 Mac、运行Sonoma测试版的M2 Mac上进行了测试。 \ No newline at end of file diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 9767d08f..c3b3131f 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -5,7 +5,7 @@ Quick Start Installation -------------- -- For x86 Linux or Mac, +- For x86 Linux, ``pip install tensorcircuit`` @@ -29,7 +29,7 @@ For more details on docker setup, please refer to `docker readme `_ or `TC via WSL `_. -- For Mac with M series chips (arm architecture), please refer to `TC on Mac M series `_. +- For MacOS, please refer to `TC on Mac `_ or `在Mac上安装TC `_. Overall, the installation of TensorCircuit is simple, since it is purely in Python and hence very portable. As long as the users can take care of the installation of ML frameworks on the corresponding system, TensorCircuit will work as expected. diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index 39ede96d..8d5105c2 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -24,4 +24,5 @@ Jupyter Tutorials tutorials/barren_plateaus.ipynb tutorials/qaoa_portfolio_optimization.ipynb tutorials/imag_time_evo.ipynb - tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file + tutorials/qcloud_sdk_demo.ipynb + tutorials/sklearn_svc.ipynb \ No newline at end of file diff --git a/docs/source/tutorial_cn.rst b/docs/source/tutorial_cn.rst index a6f4d03f..956d03b6 100644 --- a/docs/source/tutorial_cn.rst +++ b/docs/source/tutorial_cn.rst @@ -19,4 +19,5 @@ tutorials/optimization_and_expressibility_cn.ipynb tutorials/vqex_mbl_cn.ipynb tutorials/dqas_cn.ipynb - tutorials/barren_plateaus_cn.ipynb \ No newline at end of file + tutorials/barren_plateaus_cn.ipynb + tutorials/sklearn_svc_cn.ipynb \ No newline at end of file diff --git a/docs/source/tutorials/sklearn_svc.ipynb b/docs/source/tutorials/sklearn_svc.ipynb new file mode 100644 index 00000000..4d187215 --- /dev/null +++ b/docs/source/tutorials/sklearn_svc.ipynb @@ -0,0 +1,303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Support Vector Classification with SKLearn\n", + "\n", + "Authored by [_Mark (Zixuan) Song_](https://marksong.tech)\n", + "- - -\n", + "\n", + "In order to improve the simplicity of code, I used the SKLearn library to implement SVC." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "\n", + "The aim of this tutorial is to implant a quantum machine learning (QML) transformer into SVC pipeline. And this is a general introduction to connect `tensorcircuit` with `scikit-learn`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "Install `scikit-learn` and download dataset that is going to be used in this model [`GCN`](https://archive.ics.uci.edu/dataset/144/statlog+german+credit+data) as `german.data-numeric`.\n", + "\n", + "```bash\n", + "pip install scikit-learn\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import tensorflow as tf\n", + "from sklearn.svm import SVC\n", + "from sklearn import metrics\n", + "from time import time\n", + "from math import ceil, sqrt\n", + "\n", + "K = tc.set_backend(\"tensorflow\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Preprocessing\n", + "\n", + "The data has 24 variables and each is a integer value. In order for the model to use the data, we need to first convert the data into a matrix of either 4x6 or 5x5 (the case of this tutorial) and then normalize the data to between 0 and 1." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def load_GCN_data():\n", + " f = open(\"german.data-numeric\")\n", + " line = f.readline()\n", + " X = []\n", + " while line:\n", + " ll = line\n", + " while ' ' in ll:\n", + " ll = ll.replace(' ',' ')\n", + " if ll[0]==' ':\n", + " ll = ll[1:]\n", + " if ll[-1]=='\\n':\n", + " ll = ll[:-1]\n", + " if ll[-1]==' ':\n", + " ll = ll[:-1]\n", + " x = ll.split(' ')\n", + " x_int = []\n", + " for i in x:\n", + " x_int.append(int(i))\n", + " X.append(x_int)\n", + " line = f.readline()\n", + " f.close()\n", + " X_temp = K.convert_to_tensor(X)\n", + " X = []\n", + " Y = []\n", + " X_temp_transpose = K.transpose(K.convert_to_tensor(X_temp))\n", + " X_temp_max = []\n", + " for i in range(len(X_temp_transpose)):\n", + " X_temp_max.append(max(X_temp_transpose[i]))\n", + " X_temp_max = K.convert_to_tensor(X_temp_max)\n", + " final_digit = K.cast([0],'int32')\n", + " for i in X_temp:\n", + " Y.append(i[-1]-1)\n", + " X.append(K.divide(K.concat([i[:24],final_digit],0), X_temp_max))\n", + " Y = K.cast(K.convert_to_tensor(Y),'float32')\n", + " X = K.cast(K.convert_to_tensor(X),'float32')\n", + " return (X[:800],Y[:800]),(X[800:],Y[800:])\n", + "\n", + "(x_train, y_train), (x_test, y_test) = load_GCN_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum Model\n", + "\n", + "This quantum model takes in 5x5 matrices as input and output the state of 5 qbits. The model is shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def quantumTran(inputs):\n", + " size = len(inputs)\n", + " size_1d = ceil(sqrt(size))\n", + " c = tc.Circuit(size_1d)\n", + " cnot_start_first = size_1d % 2\n", + " for i in range(size_1d):\n", + " if i%2 == 0:\n", + " for j in range(size_1d):\n", + " c.rx(j, theta=(0 if i*size_1d+j >= size else inputs[i*size_1d+j]))\n", + " else:\n", + " for j in range(size_1d):\n", + " c.rz(j, theta=(0 if i*size_1d+j >= size else inputs[i*size_1d+j]))\n", + " if (cnot_start_first+i)%2 != 0:\n", + " for j in range(size_1d-1):\n", + " c.cnot(j, j+1)\n", + " return c.state()\n", + "\n", + "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Wrapping Quantum Model into a SVC\n", + "\n", + "Convert quantum model into svc that can be trained." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def quantum_kernel(quantumTran, data_x, data_y):\n", + " def kernel(x,y):\n", + " x = K.convert_to_tensor(x)\n", + " y = K.convert_to_tensor(y)\n", + " x_qt = None\n", + " for i, x1 in enumerate(x):\n", + " if i == 0:\n", + " x_qt = K.convert_to_tensor([quantumTran(x1)])\n", + " else:\n", + " x_qt = K.concat([x_qt,[quantumTran(x1)]],0)\n", + " y_qt = None\n", + " for i, x1 in enumerate(y):\n", + " if i == 0:\n", + " y_qt = K.convert_to_tensor([quantumTran(x1)])\n", + " else:\n", + " y_qt = K.concat([y_qt,[quantumTran(x1)]],0)\n", + " data_ret = K.cast(K.power(x_qt @ K.transpose(y_qt), 2), \"float32\")\n", + " return data_ret\n", + " clf = SVC(kernel=kernel)\n", + " clf.fit(data_x, data_y)\n", + " return clf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create Traditional SVC" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def standard_kernel(data_x, data_y, method):\n", + " methods = ['linear', 'poly', 'rbf', 'sigmoid']\n", + " if method not in methods:\n", + " raise ValueError(\"method must be one of %r.\" % methods)\n", + " clf = SVC(kernel=method)\n", + " clf.fit(data_x, data_y)\n", + " return clf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test\n", + "\n", + "Test the accuracy of the quantum model SVC with the test data and compare it with traditional SVC." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Accuracy:(linear as kernel) 0.79\n", + "time: 0.009181022644042969 seconds\n", + "\n", + "Accuracy:(poly as kernel) 0.77\n", + "time: 0.011379241943359375 seconds\n", + "\n", + "Accuracy:(rbf as kernel) 0.775\n", + "time: 0.012501955032348633 seconds\n", + "\n", + "Accuracy:(sigmoid as kernel) 0.565\n", + "time: 0.01753401756286621 seconds\n", + "\n", + "WARNING:tensorflow:You are casting an input of type complex64 to an incompatible dtype float32. This will discard the imaginary part and may not be what you intended.\n", + "WARNING:tensorflow:You are casting an input of type complex64 to an incompatible dtype float32. This will discard the imaginary part and may not be what you intended.\n", + "Accuracy:(qml as kernel) 0.625\n", + "time: 6.15038275718689 seconds\n" + ] + } + ], + "source": [ + "methods = ['linear', 'poly', 'rbf', 'sigmoid']\n", + "\n", + "for method in methods:\n", + " \n", + " print()\n", + " t = time()\n", + "\n", + " k = standard_kernel(data_x=x_train, data_y=y_train, method=method)\n", + " y_pred = k.predict(x_test)\n", + " print(\"Accuracy:(%s as kernel)\" % method,metrics.accuracy_score(y_test, y_pred))\n", + "\n", + " print(\"time:\",time()-t,'seconds')\n", + "\n", + "print()\n", + "t = time()\n", + "\n", + "k = quantum_kernel(quantumTran=func_qt, data_x=x_train, data_y=y_train)\n", + "y_pred = k.predict(x_test)\n", + "print(\"Accuracy:(qml as kernel)\",metrics.accuracy_score(y_test, y_pred))\n", + "\n", + "print(\"time:\",time()-t,'seconds')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Issue with `SKLearn`\n", + "\n", + "Due to the limitation of `SKLearn`, `SKLearn`'s `SVC` is not fully compatible with quantum machine model (QML). \n", + "\n", + "This is because QML outputs a result as complex number (coordinate on the bloch sphere) whereas SKLearn only accept float. This is causing the result output by QML must be converted into float before it can be used in SVC, leading to a potential loss of accuracy.\n", + "\n", + "## Conclusion\n", + "\n", + "Due to the present limitation of SKLearn, quantum SVC is worse than traditional SVC in both accuracy and speed. However, if the limitation is removed, quantum SVC might be able to outperform traditional SVC in both accuracy." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tc2", + "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.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/tutorials/sklearn_svc_cn.ipynb b/docs/source/tutorials/sklearn_svc_cn.ipynb new file mode 100644 index 00000000..a5799c27 --- /dev/null +++ b/docs/source/tutorials/sklearn_svc_cn.ipynb @@ -0,0 +1,303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 结合SKLearn实现的支持向量分类\n", + "\n", + "[_Mark (Zixuan) Song_](https://marksong.tech) 撰写\n", + "- - -\n", + "\n", + "为代码简洁，本示例结合了`sklearn`库中的`SVC`类，实现了支持向量分类。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 概述\n", + "\n", + "本示例的目的是将量子机器学习（QML）转换器嵌入到SVC管道中并且介绍`tensorcircuit`与`scikit-learn`的一种连接方式。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 设置\n", + "\n", + "安装`scikit-learn`。下载数据集[`GCN`](https://archive.ics.uci.edu/dataset/144/statlog+german+credit+data)并存储为`german.data-numeric`。\n", + "\n", + "```bash\n", + "pip install scikit-learn\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorcircuit as tc\n", + "import tensorflow as tf\n", + "from sklearn.svm import SVC\n", + "from sklearn import metrics\n", + "from time import time\n", + "from math import ceil, sqrt\n", + "\n", + "K = tc.set_backend(\"tensorflow\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 数据处理\n", + "\n", + "数据集包含24个变量，每个变量都是整数值。为了使模型能够使用数据，我们需要首先将数据转换为4x6或5x5的矩阵（本教程的情况），然后将数据归一化为0到1之间。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def load_GCN_data():\n", + " f = open(\"german.data-numeric\")\n", + " line = f.readline()\n", + " X = []\n", + " while line:\n", + " ll = line\n", + " while ' ' in ll:\n", + " ll = ll.replace(' ',' ')\n", + " if ll[0]==' ':\n", + " ll = ll[1:]\n", + " if ll[-1]=='\\n':\n", + " ll = ll[:-1]\n", + " if ll[-1]==' ':\n", + " ll = ll[:-1]\n", + " x = ll.split(' ')\n", + " x_int = []\n", + " for i in x:\n", + " x_int.append(int(i))\n", + " X.append(x_int)\n", + " line = f.readline()\n", + " f.close()\n", + " X_temp = K.convert_to_tensor(X)\n", + " X = []\n", + " Y = []\n", + " X_temp_transpose = K.transpose(K.convert_to_tensor(X_temp))\n", + " X_temp_max = []\n", + " for i in range(len(X_temp_transpose)):\n", + " X_temp_max.append(max(X_temp_transpose[i]))\n", + " X_temp_max = K.convert_to_tensor(X_temp_max)\n", + " final_digit = K.cast([0],'int32')\n", + " for i in X_temp:\n", + " Y.append(i[-1]-1)\n", + " X.append(K.divide(K.concat([i[:24],final_digit],0), X_temp_max))\n", + " Y = K.cast(K.convert_to_tensor(Y),'float32')\n", + " X = K.cast(K.convert_to_tensor(X),'float32')\n", + " return (X[:800],Y[:800]),(X[800:],Y[800:])\n", + "\n", + "(x_train, y_train), (x_test, y_test) = load_GCN_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 量子模型\n", + "\n", + "这个量子模型是输入为5x5矩阵，并输出为5个量子比特的状态。模型如下所示：" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def quantumTran(inputs):\n", + " size = len(inputs)\n", + " size_1d = ceil(sqrt(size))\n", + " c = tc.Circuit(size_1d)\n", + " cnot_start_first = size_1d % 2\n", + " for i in range(size_1d):\n", + " if i%2 == 0:\n", + " for j in range(size_1d):\n", + " c.rx(j, theta=(0 if i*size_1d+j >= size else inputs[i*size_1d+j]))\n", + " else:\n", + " for j in range(size_1d):\n", + " c.rz(j, theta=(0 if i*size_1d+j >= size else inputs[i*size_1d+j]))\n", + " if (cnot_start_first+i)%2 != 0:\n", + " for j in range(size_1d-1):\n", + " c.cnot(j, j+1)\n", + " return c.state()\n", + "\n", + "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 将量子模型打包成SVC\n", + "\n", + "将量子模型打包成`SKLearn`能使用的SVC模型。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def quantum_kernel(quantumTran, data_x, data_y):\n", + " def kernel(x,y):\n", + " x = K.convert_to_tensor(x)\n", + " y = K.convert_to_tensor(y)\n", + " x_qt = None\n", + " for i, x1 in enumerate(x):\n", + " if i == 0:\n", + " x_qt = K.convert_to_tensor([quantumTran(x1)])\n", + " else:\n", + " x_qt = K.concat([x_qt,[quantumTran(x1)]],0)\n", + " y_qt = None\n", + " for i, x1 in enumerate(y):\n", + " if i == 0:\n", + " y_qt = K.convert_to_tensor([quantumTran(x1)])\n", + " else:\n", + " y_qt = K.concat([y_qt,[quantumTran(x1)]],0)\n", + " data_ret = K.cast(K.power(x_qt @ K.transpose(y_qt), 2), \"float32\")\n", + " return data_ret\n", + " clf = SVC(kernel=kernel)\n", + " clf.fit(data_x, data_y)\n", + " return clf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 创建传统SVC模型" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def standard_kernel(data_x, data_y, method):\n", + " methods = ['linear', 'poly', 'rbf', 'sigmoid']\n", + " if method not in methods:\n", + " raise ValueError(\"method must be one of %r.\" % methods)\n", + " clf = SVC(kernel=method)\n", + " clf.fit(data_x, data_y)\n", + " return clf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 测试对比\n", + "\n", + "测试量子SVC模型并于传统SVC模型进行对比。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Accuracy:(linear as kernel) 0.79\n", + "time: 0.009181022644042969 seconds\n", + "\n", + "Accuracy:(poly as kernel) 0.77\n", + "time: 0.011379241943359375 seconds\n", + "\n", + "Accuracy:(rbf as kernel) 0.775\n", + "time: 0.012501955032348633 seconds\n", + "\n", + "Accuracy:(sigmoid as kernel) 0.565\n", + "time: 0.01753401756286621 seconds\n", + "\n", + "WARNING:tensorflow:You are casting an input of type complex64 to an incompatible dtype float32. This will discard the imaginary part and may not be what you intended.\n", + "WARNING:tensorflow:You are casting an input of type complex64 to an incompatible dtype float32. This will discard the imaginary part and may not be what you intended.\n", + "Accuracy:(qml as kernel) 0.625\n", + "time: 6.15038275718689 seconds\n" + ] + } + ], + "source": [ + "methods = ['linear', 'poly', 'rbf', 'sigmoid']\n", + "\n", + "for method in methods:\n", + " \n", + " print()\n", + " t = time()\n", + "\n", + " k = standard_kernel(data_x=x_train, data_y=y_train, method=method)\n", + " y_pred = k.predict(x_test)\n", + " print(\"Accuracy:(%s as kernel)\" % method,metrics.accuracy_score(y_test, y_pred))\n", + "\n", + " print(\"time:\",time()-t,'seconds')\n", + "\n", + "print()\n", + "t = time()\n", + "\n", + "k = quantum_kernel(quantumTran=func_qt, data_x=x_train, data_y=y_train)\n", + "y_pred = k.predict(x_test)\n", + "print(\"Accuracy:(qml as kernel)\",metrics.accuracy_score(y_test, y_pred))\n", + "\n", + "print(\"time:\",time()-t,'seconds')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `SKLearn`的局限性\n", + "\n", + "因为`SKLearn`的局限性，`SKLearn`的`SVC`并不完全兼容量子机器学习（QML）。\n", + "\n", + "这是因为QML输出的为复数（布洛赫球上的坐标），而`SKLearn`只接受浮点数。这导致QML输出的结果必须在使用SVC之前转换为浮点数，从而可能导致精度损失。\n", + "\n", + "## 结论\n", + "\n", + "由于`SKLearn`的局限性，量子SVC在准确性和速度上都不如传统SVC。但是，如果这种局限性被消除，量子SVC可能会在准确性上都优于传统SVC。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tc2", + "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.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From aea9dabc5bd63d899fc9f1decf32baddd5c5d906 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Jul 2023 11:00:57 +0800 Subject: [PATCH 545/725] update readme --- README.md | 4 ++-- README_cn.md | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 392ab96a..1ed96c87 100644 --- a/README.md +++ b/README.md @@ -37,7 +37,7 @@ TensorCircuit is built on top of modern machine learning frameworks: Jax, Tensor Please begin with [Quick Start](/docs/source/quickstart.rst) in the [full documentation](https://tensorcircuit.readthedocs.io/). -For more information on software usage, sota algorithm implementation and engineer paradigm demonstration, please refer to 60+ [example scripts](/examples) and 30+ [tutorial notebooks](https://tensorcircuit.readthedocs.io/en/latest/#tutorials). API docstrings and test cases in [tests](/tests) are also informative. +For more information on software usage, sota algorithm implementation and engineer paradigm demonstration, please refer to 70+ [example scripts](/examples) and 30+ [tutorial notebooks](https://tensorcircuit.readthedocs.io/en/latest/#tutorials). API docstrings and test cases in [tests](/tests) are also informative. The following are some minimal demos. @@ -357,7 +357,7 @@ Reference paper: https://arxiv.org/abs/2303.14877. - GSQAS: Graph Self-supervised Quantum Architecture Search: https://arxiv.org/abs/2303.12381. -- Practical advantage of quantum machine learning in ghost imaging: https://www.nature.com/articles/s42005-023-01290-1 (published in communications physics). +- Practical advantage of quantum machine learning in ghost imaging: https://www.nature.com/articles/s42005-023-01290-1 (published in Communications Physics). diff --git a/README_cn.md b/README_cn.md index 558a5038..80f93107 100644 --- a/README_cn.md +++ b/README_cn.md @@ -35,7 +35,7 @@ TensorCircuit 现在支持真实量子硬件连接和实验，并提供优雅的 请从 [完整文档](https://tensorcircuit.readthedocs.io/zh/latest/) 中的 [快速上手](/docs/source/quickstart.rst) 开始。 -有关软件用法，算法实现和工程范式演示的更多信息和介绍，请参阅 60+ [示例脚本](/examples) 和 30+ [案例教程](https://tensorcircuit.readthedocs.io/zh/latest/#tutorials)。 [测试](/tests) 用例和 API docstring 也提供了丰富的使用信息。 +有关软件用法，算法实现和工程范式演示的更多信息和介绍，请参阅 70+ [示例脚本](/examples) 和 30+ [案例教程](https://tensorcircuit.readthedocs.io/zh/latest/#tutorials)。 [测试](/tests) 用例和 API docstring 也提供了丰富的使用信息。 以下是一些最简易的演示。 From 89210eb3bc2caed0ccb9575f6cb0cc4ad494ae14 Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Fri, 14 Jul 2023 14:53:22 +0800 Subject: [PATCH 546/725] updated svc instructions for clearity --- docs/source/tutorials/german.data-numeric | 1000 ++++++++++++++++++++ docs/source/tutorials/sklearn_svc.ipynb | 37 +- docs/source/tutorials/sklearn_svc_cn.ipynb | 37 +- 3 files changed, 1030 insertions(+), 44 deletions(-) create mode 100644 docs/source/tutorials/german.data-numeric diff --git a/docs/source/tutorials/german.data-numeric b/docs/source/tutorials/german.data-numeric new file mode 100644 index 00000000..723307e1 --- /dev/null +++ b/docs/source/tutorials/german.data-numeric @@ -0,0 +1,1000 @@ + 1 6 4 12 5 5 3 4 1 67 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 48 2 60 1 3 2 2 1 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 12 4 21 1 4 3 3 1 49 3 1 2 1 1 0 0 1 0 0 1 0 1 0 1 + 1 42 2 79 1 4 3 4 2 45 3 1 2 1 1 0 0 0 0 0 0 0 0 1 1 + 1 24 3 49 1 3 3 4 4 53 3 2 2 1 1 1 0 1 0 0 0 0 0 1 2 + 4 36 2 91 5 3 3 4 4 35 3 1 2 2 1 0 0 1 0 0 0 0 1 0 1 + 4 24 2 28 3 5 3 4 2 53 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 36 2 69 1 3 3 2 3 35 3 1 1 2 1 0 1 1 0 1 0 0 0 0 1 + 4 12 2 31 4 4 1 4 1 61 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 30 4 52 1 1 4 2 3 28 3 2 1 1 1 1 0 1 0 0 1 0 0 0 2 + 2 12 2 13 1 2 2 1 3 25 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 + 1 48 2 43 1 2 2 4 2 24 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 2 12 2 16 1 3 2 1 3 22 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 24 4 12 1 5 3 4 3 60 3 2 1 1 1 1 0 1 0 0 1 0 1 0 2 + 1 15 2 14 1 3 2 4 3 28 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 + 1 24 2 13 2 3 2 2 3 32 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 4 24 4 24 5 5 3 4 2 53 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 30 0 81 5 2 3 3 3 25 1 3 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 24 2 126 1 5 2 2 4 44 3 1 1 2 1 0 1 1 0 0 0 0 0 0 2 + 4 24 2 34 3 5 3 2 3 31 3 1 2 2 1 0 0 1 0 0 1 0 0 1 1 + 4 9 4 21 1 3 3 4 3 48 3 3 1 2 1 1 0 1 0 0 1 0 0 1 1 + 1 6 2 26 3 3 3 3 1 44 3 1 2 1 1 0 0 1 0 1 0 0 0 1 1 + 1 10 4 22 1 2 3 3 1 48 3 2 2 1 2 1 0 1 0 1 0 0 1 0 1 + 2 12 4 18 2 2 3 4 2 44 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 + 4 10 4 21 5 3 4 1 3 26 3 2 1 1 2 0 0 1 0 0 1 0 0 1 1 + 1 6 2 14 1 3 3 2 1 36 1 1 1 2 1 0 0 1 0 0 1 0 1 0 1 + 4 6 0 4 1 5 4 4 3 39 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 3 12 1 4 4 3 2 3 1 42 3 2 1 1 1 0 0 1 0 1 0 0 0 1 1 + 2 7 2 24 1 3 3 2 1 34 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 + 1 60 3 68 1 5 3 4 4 63 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 + 2 18 2 19 4 2 4 3 1 36 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 24 2 40 1 3 3 2 3 27 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 18 2 59 2 3 3 2 3 30 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 12 4 13 5 5 3 4 4 57 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 3 12 2 15 1 2 2 1 2 33 1 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 2 45 4 47 1 2 3 2 2 25 3 2 1 1 1 0 0 1 0 0 1 0 1 0 2 + 4 48 4 61 1 3 3 3 4 31 1 1 1 2 1 0 0 1 0 0 0 0 0 1 1 + 3 18 2 21 1 3 3 2 1 37 2 1 1 1 1 0 0 0 1 0 1 0 0 1 2 + 3 10 2 12 1 3 3 2 3 37 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 9 2 5 1 3 3 3 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 30 2 23 3 5 3 2 3 30 1 1 1 1 1 0 0 1 0 0 1 0 0 0 1 + 2 12 2 12 3 3 1 1 3 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 18 3 62 1 3 3 4 1 44 3 1 2 2 1 0 0 1 0 0 1 0 1 0 1 + 1 30 4 62 2 4 4 4 3 24 3 2 1 1 1 0 1 1 0 1 0 0 0 1 1 + 1 48 4 61 1 5 2 4 4 58 2 2 1 1 1 0 1 1 0 0 0 0 1 0 2 + 4 11 4 14 1 2 2 4 3 35 3 2 1 1 1 1 0 1 0 0 1 0 0 0 1 + 4 36 2 23 3 5 3 4 3 39 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 6 2 14 3 1 2 2 2 23 3 1 1 2 1 0 1 1 0 1 0 1 0 0 1 + 4 11 4 72 1 3 3 4 2 39 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 + 4 12 2 21 2 3 2 2 1 28 3 1 1 1 1 0 0 0 1 0 1 0 0 1 1 + 2 24 3 23 5 2 3 2 2 29 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 27 3 60 1 5 3 2 3 30 3 2 1 2 1 0 1 1 0 0 1 0 0 0 1 + 4 12 2 13 1 3 3 2 3 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 34 5 3 3 1 2 31 3 1 1 2 1 0 1 1 0 0 1 0 0 1 1 + 2 36 3 22 1 5 3 4 4 57 1 2 1 2 1 1 0 1 0 0 0 0 0 1 2 + 4 6 1 8 5 3 3 2 1 26 2 1 2 1 1 1 0 0 0 0 1 0 1 0 1 + 2 12 2 65 5 1 3 1 4 52 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 36 4 96 1 3 2 2 3 31 2 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 3 18 2 20 1 5 2 2 3 23 3 1 1 1 1 1 0 1 0 0 1 0 0 0 1 + 1 36 4 62 1 2 2 4 4 23 3 2 1 2 1 0 0 0 1 1 0 0 1 0 2 + 2 9 2 14 1 3 4 1 1 27 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 15 4 15 5 5 3 4 1 50 3 2 1 2 1 0 0 0 0 0 1 0 0 1 1 + 2 36 0 20 1 5 3 4 4 61 3 1 1 2 1 0 0 1 0 0 0 0 0 0 2 + 2 48 0 144 1 3 3 2 3 25 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 24 2 32 1 2 2 4 2 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 27 2 52 5 5 3 4 2 48 3 4 2 2 1 0 0 1 0 0 1 0 0 1 1 + 4 12 2 22 1 2 2 2 3 29 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 12 2 10 4 3 4 1 1 22 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 36 2 18 1 3 3 4 4 37 2 1 1 2 1 0 0 1 0 0 0 0 0 1 2 + 4 36 2 24 5 3 2 4 3 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 36 2 81 1 3 2 2 2 30 1 1 1 1 1 0 1 1 0 0 1 0 0 1 1 + 4 7 4 7 5 5 3 2 2 46 3 2 1 2 1 0 0 1 0 1 0 0 1 0 1 + 1 8 4 12 1 5 3 4 4 51 1 2 2 2 1 0 0 1 0 0 0 0 0 0 1 + 2 42 4 60 1 4 2 1 1 41 1 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 36 2 20 5 5 3 4 4 40 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 1 12 4 15 1 5 3 4 4 66 3 2 1 1 1 0 1 1 0 0 0 0 0 0 1 + 1 42 2 40 1 2 3 3 3 34 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 11 3 48 1 4 3 4 2 51 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 54 0 94 5 3 3 2 2 39 3 1 2 1 1 0 1 1 0 0 1 0 1 0 1 + 2 30 2 38 1 2 4 1 2 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 59 5 2 2 1 3 44 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 15 2 12 3 5 3 3 2 47 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 16 2 3 2 4 2 24 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 1 24 2 18 1 5 2 4 1 58 3 1 1 2 1 0 0 0 0 0 1 0 1 0 1 + 1 10 2 23 1 5 3 4 1 52 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 12 4 14 1 3 2 2 1 29 3 2 1 2 1 0 0 0 0 0 1 0 0 0 1 + 2 18 4 13 1 2 2 1 2 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 36 2 126 2 3 3 4 4 47 3 1 2 2 1 0 0 1 0 0 0 0 0 1 2 + 1 18 2 22 2 4 3 3 3 30 3 1 2 2 1 1 0 1 0 0 1 0 0 0 1 + 1 12 0 11 1 4 3 3 1 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 12 4 6 1 5 3 4 1 56 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 4 14 1 5 3 3 1 54 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 + 4 12 4 8 5 5 2 3 2 33 1 1 2 1 1 0 0 1 0 0 1 0 1 0 2 + 3 24 4 36 5 5 3 4 4 20 3 2 1 1 1 0 0 0 1 1 0 0 0 1 1 + 2 12 2 13 4 5 3 4 1 54 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 2 54 0 159 1 2 3 4 4 58 3 1 1 2 1 0 0 1 0 1 0 0 0 1 2 + 4 12 4 20 5 4 2 2 3 61 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 18 2 26 2 3 3 4 3 34 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 36 4 23 1 5 3 4 1 36 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 20 3 71 5 4 3 4 2 36 1 2 2 2 1 0 1 1 0 1 0 0 0 0 1 + 4 24 2 15 2 5 4 4 1 41 3 1 1 1 1 1 0 1 0 1 0 0 1 0 1 + 2 36 2 23 1 4 3 4 3 24 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 4 6 3 9 1 3 2 2 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 9 4 19 1 4 3 3 3 35 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 4 12 2 24 5 2 4 4 3 26 3 1 1 2 1 0 1 1 0 1 0 0 0 1 1 + 2 24 4 119 1 3 3 3 3 39 3 2 2 2 1 0 0 0 1 0 1 0 0 0 2 + 4 18 1 65 1 5 3 4 4 39 1 2 2 2 1 1 0 1 0 0 1 0 0 0 2 + 2 12 2 61 1 4 3 2 3 32 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 24 2 77 5 2 2 2 2 30 3 1 1 2 2 0 0 1 0 0 1 0 0 1 1 + 2 14 2 14 3 5 4 2 1 35 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 6 3 14 2 5 1 2 3 31 1 2 2 1 1 0 0 1 0 0 1 0 0 1 1 + 3 15 2 4 1 2 2 4 2 23 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 2 18 2 63 1 4 3 3 1 28 3 1 1 1 1 1 0 1 0 1 0 0 1 0 1 + 4 36 4 79 1 3 2 2 1 25 2 2 1 2 1 1 0 1 0 0 1 0 0 1 2 + 1 12 2 17 3 5 4 1 1 35 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 48 4 36 5 5 3 1 1 47 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 42 2 72 5 4 2 3 3 30 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 1 10 4 21 5 2 2 3 1 27 3 2 1 1 2 0 0 0 1 1 0 0 0 1 1 + 1 33 4 43 3 3 2 4 3 23 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 12 4 24 3 4 1 3 3 36 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 + 1 21 2 18 1 3 2 2 1 25 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 24 4 39 1 5 2 2 3 41 3 2 1 2 1 0 1 1 0 1 0 0 0 0 1 + 4 12 2 18 1 3 3 2 1 24 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 3 10 4 8 1 5 3 4 4 63 3 2 1 2 1 1 0 1 0 0 0 0 0 1 1 + 2 18 2 19 5 2 2 3 1 27 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 1 12 4 21 1 3 3 2 2 30 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 12 2 7 1 3 4 2 1 40 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 12 2 6 1 3 3 2 3 30 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 12 4 19 1 1 3 2 3 34 3 2 1 2 1 0 1 1 0 0 1 0 0 0 1 + 1 12 4 35 1 3 2 2 1 29 3 2 1 1 1 1 0 0 1 0 1 0 0 1 2 + 2 48 2 85 5 4 2 2 3 24 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 36 3 69 1 3 3 3 2 29 2 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 15 2 27 1 2 3 3 2 27 1 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 18 2 20 1 3 3 4 4 47 1 2 1 1 1 0 0 1 0 0 0 0 0 1 1 + 4 60 2 101 2 4 2 4 1 21 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 12 4 12 5 5 2 2 1 38 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 27 3 86 4 3 3 2 3 27 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 + 2 12 2 8 3 3 3 3 1 66 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 2 15 4 27 5 4 3 2 1 35 1 3 1 2 1 0 0 0 0 0 1 0 0 1 1 + 3 12 2 19 1 3 2 2 3 44 3 1 1 2 1 0 0 1 0 1 0 0 1 0 1 + 3 6 2 7 4 2 4 2 1 27 3 1 1 1 2 1 0 1 0 0 1 1 0 0 1 + 2 36 2 48 1 2 2 1 4 30 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 1 27 2 34 1 3 3 2 3 27 3 1 1 1 1 0 0 1 0 0 1 0 0 0 1 + 1 18 2 25 1 3 3 2 3 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 21 4 23 1 2 2 4 2 23 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 48 1 36 2 4 3 2 3 30 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 6 4 9 1 5 2 4 4 39 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 12 4 7 2 4 2 3 3 51 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 1 36 4 54 1 3 3 2 2 28 3 2 1 1 1 0 0 0 0 0 1 0 0 1 1 + 4 18 4 16 4 5 3 4 3 46 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 6 2 13 2 5 3 4 4 42 1 1 2 2 1 0 0 1 0 0 0 0 0 1 1 + 4 10 2 19 1 3 3 4 2 38 3 1 1 2 2 0 0 1 0 0 1 0 0 1 1 + 3 36 2 58 1 3 3 1 3 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 24 4 78 4 5 2 4 4 29 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 + 2 24 3 70 2 4 3 4 3 36 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 + 1 12 2 13 1 3 2 4 3 20 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 1 9 4 13 2 5 3 4 1 48 3 2 2 1 2 0 0 0 0 0 1 0 0 1 1 + 1 12 1 3 1 5 4 1 3 45 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 24 2 35 2 4 3 3 3 38 1 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 6 4 19 5 3 3 2 1 34 3 2 2 1 1 0 0 1 0 0 1 0 1 0 1 + 4 24 4 29 2 5 3 4 1 36 3 1 2 2 1 0 0 1 0 0 1 0 0 1 1 + 4 18 4 11 1 2 2 1 2 30 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 15 2 13 3 4 3 3 2 36 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 10 2 73 1 1 3 4 4 70 1 1 1 2 1 1 0 1 0 0 0 0 0 0 1 + 4 36 2 9 3 5 3 4 2 36 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 6 2 30 3 3 3 2 3 32 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 18 2 11 1 1 2 2 3 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 11 2 16 4 2 2 1 1 20 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 40 1 4 2 4 2 25 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 2 24 4 19 1 5 1 4 1 31 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 + 1 15 0 10 1 5 3 3 3 33 3 2 2 1 1 1 0 1 0 1 0 0 0 1 2 + 4 12 2 8 1 3 2 1 1 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 24 3 21 1 1 2 2 2 34 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 2 8 2 14 1 3 3 2 1 33 3 1 1 1 2 0 0 0 0 0 1 0 0 1 1 + 1 21 3 34 1 2 3 1 2 26 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 30 1 75 5 1 2 1 1 53 1 1 1 2 1 0 1 1 0 0 1 0 0 0 2 + 1 12 2 26 1 3 1 1 3 42 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 6 4 3 3 5 3 4 3 52 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 12 2 20 1 4 3 2 3 31 3 2 2 2 1 0 0 1 0 1 0 0 0 0 1 + 1 21 4 6 1 5 3 4 1 65 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 36 3 96 1 2 1 1 3 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 36 3 45 1 3 1 2 1 30 2 2 1 2 1 0 0 1 0 0 1 0 0 0 2 + 1 21 1 16 5 3 3 2 2 40 3 2 2 1 1 1 0 1 0 0 1 0 1 0 2 + 4 24 4 38 4 3 3 4 1 50 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 18 4 9 1 5 3 4 3 36 1 1 2 2 1 1 0 1 0 0 1 0 0 1 2 + 4 15 4 14 1 3 3 2 2 31 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 9 1 51 1 5 2 4 4 74 1 1 2 2 1 0 1 1 0 0 0 0 0 0 2 + 2 16 4 12 1 1 3 3 3 68 3 3 1 2 1 1 0 1 0 0 0 1 0 0 1 + 1 12 2 7 2 4 4 1 2 20 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 18 0 32 1 3 2 4 3 33 1 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 46 4 3 3 3 2 54 3 3 1 2 1 0 0 1 0 0 1 0 0 0 2 + 2 48 0 38 2 4 3 4 4 34 3 1 2 1 1 0 0 1 0 0 0 0 1 0 2 + 2 27 2 39 1 3 3 2 3 36 3 1 2 2 1 0 0 1 0 0 1 0 0 1 2 + 4 6 2 21 1 4 4 2 1 29 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 2 45 2 30 2 3 3 4 2 21 3 1 1 1 1 0 0 0 0 1 0 0 0 1 2 + 2 9 4 15 1 5 2 3 3 34 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 6 4 14 1 3 2 1 3 28 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 12 2 10 2 2 2 4 3 27 1 4 1 1 1 0 0 1 0 1 0 0 0 1 2 + 2 24 2 28 5 5 3 4 4 36 1 1 1 2 1 0 1 1 0 0 0 0 0 1 1 + 2 18 3 43 1 5 1 3 4 40 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 9 4 9 3 5 3 2 3 52 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 12 2 12 1 3 4 3 1 27 3 1 1 1 1 1 0 1 0 0 1 0 1 0 1 + 4 27 3 51 1 4 3 4 3 26 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 2 9 1 4 4 4 2 21 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 4 12 4 15 1 5 3 1 1 38 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 + 1 30 4 106 1 5 3 4 4 38 3 3 2 2 1 0 1 1 0 0 0 0 0 0 1 + 4 12 4 19 1 5 3 4 1 43 3 3 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 12 4 14 1 4 3 3 2 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 24 2 66 1 3 4 2 3 21 2 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 12 2 14 4 4 3 2 2 55 3 1 1 1 2 0 1 1 0 0 1 0 0 1 1 + 4 9 4 31 5 3 3 2 1 33 3 2 2 1 1 0 0 1 0 0 1 0 0 1 1 + 4 36 2 38 5 5 2 4 1 45 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 + 1 27 0 53 1 1 3 4 2 50 2 2 1 2 1 0 0 1 0 0 1 0 0 1 2 + 3 30 3 19 1 5 3 4 1 66 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 36 4 33 5 5 3 2 3 51 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 6 4 9 5 4 2 3 2 39 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 18 0 31 1 4 3 1 2 31 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 3 36 2 39 1 3 3 2 1 23 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 24 2 30 1 3 1 2 1 24 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 4 10 2 14 1 3 2 4 3 64 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 2 12 2 6 1 2 4 1 1 26 1 1 1 1 1 0 0 0 0 0 1 0 1 0 1 + 1 12 2 12 5 3 2 4 2 23 1 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 4 12 2 7 1 3 3 2 1 30 1 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 3 30 5 3 3 4 1 32 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 + 4 15 2 47 1 3 3 2 3 30 3 1 1 2 1 0 1 1 0 0 1 0 0 1 1 + 4 36 0 26 1 3 3 2 3 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 48 2 110 4 4 3 2 4 27 1 2 1 2 1 0 0 0 1 0 1 0 0 1 2 + 1 12 2 79 1 5 3 4 4 53 3 1 1 2 1 0 0 1 0 0 0 0 0 0 2 + 4 9 2 15 1 4 3 2 3 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 24 2 31 1 2 3 1 4 22 1 1 1 1 1 0 0 1 0 0 0 0 0 1 1 + 3 36 2 42 1 3 3 2 3 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 9 2 25 3 5 3 4 4 51 3 1 1 1 1 1 0 1 0 0 0 0 1 0 1 + 4 12 2 21 2 4 3 1 4 35 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 18 2 9 1 3 4 2 1 25 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 + 4 4 4 15 1 4 3 1 1 42 3 3 2 1 1 0 0 1 0 0 1 0 1 0 1 + 1 24 2 18 1 1 3 2 3 30 2 1 2 1 1 0 0 1 0 0 1 0 0 0 2 + 2 6 2 146 5 1 3 2 2 23 3 1 1 2 1 1 0 1 0 0 1 1 0 0 2 + 2 21 2 28 2 5 1 2 3 61 1 2 1 1 1 0 0 1 0 1 0 0 1 0 2 + 4 12 4 13 1 3 2 2 2 35 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 30 2 25 1 5 3 3 2 39 3 1 2 1 1 0 0 0 0 0 1 0 0 1 1 + 1 24 2 9 5 5 2 2 3 29 1 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 6 2 16 1 4 3 2 2 51 3 1 2 1 1 0 0 1 0 0 1 0 0 1 1 + 1 48 0 46 1 5 3 4 4 24 3 2 2 1 1 0 1 1 0 0 0 0 0 1 2 + 4 12 4 12 1 3 2 2 1 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 12 1 34 3 3 2 3 1 35 3 1 2 1 1 0 0 1 0 0 1 0 1 0 1 + 4 24 2 13 1 4 3 1 1 25 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 12 4 7 1 5 3 4 1 52 3 3 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 6 0 12 2 3 3 1 4 35 1 1 1 1 2 1 0 1 0 1 0 0 0 1 1 + 3 24 2 19 1 3 3 2 1 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 4 1 1 2 4 1 22 3 1 1 1 1 0 0 0 1 1 0 0 0 1 2 + 1 6 4 7 4 4 2 4 1 39 3 2 1 2 1 1 0 1 0 0 1 0 1 0 1 + 3 12 2 23 1 3 2 2 3 46 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 30 2 22 1 3 2 2 4 24 1 1 1 1 1 1 0 0 0 0 1 0 0 1 2 + 4 24 3 42 2 3 3 3 2 35 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 9 2 20 5 4 3 1 3 24 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 60 3 74 5 3 3 1 1 27 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 24 4 27 1 3 3 2 1 35 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 12 1 21 1 3 1 1 4 29 3 1 1 1 1 0 0 1 0 0 0 0 0 1 2 + 4 15 2 38 2 2 2 4 3 23 3 1 1 2 1 0 1 1 0 0 1 0 0 1 1 + 4 11 4 12 2 1 2 4 1 57 3 3 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 12 2 17 1 3 3 2 1 27 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 24 2 16 1 5 2 4 3 55 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 18 4 53 1 5 3 4 4 36 3 3 1 2 1 1 0 1 0 0 0 0 0 0 1 + 4 12 4 27 1 5 2 4 4 57 1 3 1 1 1 0 0 1 0 0 0 0 1 0 1 + 4 10 4 12 1 5 3 4 1 32 3 2 2 1 2 1 0 1 0 0 1 0 1 0 1 + 2 15 2 8 1 5 3 3 3 37 3 1 2 1 1 0 0 1 0 0 1 0 0 1 2 + 4 36 4 63 5 5 3 4 1 36 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 15 1 2 2 3 3 38 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 14 2 90 1 5 1 4 2 45 3 1 1 2 2 1 0 1 0 0 1 0 0 0 2 + 4 24 2 10 5 5 3 2 3 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 27 5 4 3 3 2 32 3 1 1 1 2 1 0 1 0 0 1 0 0 1 1 + 4 12 4 14 3 4 2 4 3 37 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 2 48 1 122 5 1 3 4 4 36 3 1 1 2 1 1 0 0 1 0 0 0 0 0 1 + 2 48 2 31 1 4 3 4 1 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 30 2 120 1 2 1 1 4 34 3 1 1 2 1 0 0 1 0 0 1 0 1 0 2 + 4 9 2 27 1 3 3 2 1 32 3 1 2 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 4 24 1 3 2 2 3 26 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 2 13 5 5 1 4 2 49 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 + 4 6 2 46 1 2 2 4 2 32 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 24 2 19 2 3 3 4 3 29 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 + 4 15 4 34 4 5 3 4 4 23 3 2 1 2 1 0 1 1 0 1 0 0 0 1 1 + 4 12 2 16 1 3 3 2 1 50 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 3 18 1 14 5 4 3 4 3 49 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 15 4 15 5 5 3 4 2 63 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 24 4 39 2 2 1 2 3 37 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 1 47 2 107 1 2 2 1 1 35 3 1 1 2 1 1 0 1 0 0 1 0 1 0 1 + 1 48 2 48 1 4 3 3 2 26 3 1 2 1 1 0 1 1 0 0 1 0 0 1 1 + 2 48 3 76 2 1 3 4 4 31 3 1 1 2 1 0 0 1 0 0 0 0 0 0 1 + 2 12 2 11 1 3 2 4 1 49 3 2 1 2 1 0 0 0 0 0 1 0 0 1 1 + 1 24 3 10 1 2 4 4 1 48 2 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 12 2 11 1 3 4 2 1 26 3 1 1 2 2 0 0 1 0 0 1 0 0 1 1 + 2 36 2 94 1 2 4 4 3 28 3 1 1 2 1 0 1 1 0 1 0 0 0 0 2 + 1 24 4 64 1 5 2 4 4 44 3 2 2 2 1 0 1 1 0 0 0 0 0 0 1 + 3 42 4 48 1 5 3 4 4 56 3 1 1 1 1 0 1 1 0 0 0 0 0 1 1 + 4 48 4 76 5 5 1 2 3 46 1 2 2 1 1 0 0 1 0 0 1 0 0 0 1 + 2 48 2 100 1 2 2 2 3 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 12 2 47 5 2 2 4 3 20 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 + 4 10 2 13 5 5 3 2 2 45 3 1 1 1 2 1 0 0 1 0 1 0 1 0 1 + 4 18 2 25 1 3 3 4 1 43 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 21 4 27 4 4 3 2 3 32 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 6 2 7 1 1 2 4 1 54 3 1 1 2 1 1 0 1 0 0 1 1 0 0 1 + 2 36 0 38 1 3 2 1 3 42 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 3 24 4 13 5 4 3 2 1 37 1 2 2 1 1 1 0 1 0 0 1 0 1 0 2 + 1 10 4 10 1 4 3 3 2 49 3 2 1 2 1 1 0 0 1 0 1 0 0 1 1 + 4 48 4 101 3 3 3 2 4 44 1 1 1 1 1 1 0 1 0 0 0 0 0 1 2 + 4 6 2 15 4 3 1 2 1 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 30 2 48 5 4 2 4 2 24 2 1 1 1 1 0 1 1 0 1 0 0 1 0 1 + 1 12 2 7 2 2 4 3 4 33 3 1 1 2 1 0 0 1 0 0 1 0 1 0 2 + 2 8 2 12 1 3 2 4 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 9 2 3 1 3 4 4 1 22 3 1 1 1 1 1 0 1 0 1 0 0 1 0 1 + 2 48 2 54 5 1 3 4 4 40 1 1 1 2 1 0 0 1 0 0 0 1 0 0 1 + 4 24 2 55 2 3 3 1 3 25 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 3 24 2 37 1 2 2 4 3 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 12 2 7 1 4 4 3 3 25 1 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 3 4 2 15 5 2 3 2 1 29 3 1 2 1 2 1 0 1 0 0 1 0 1 0 1 + 1 36 1 27 1 5 3 4 3 31 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 12 2 7 1 3 3 3 2 38 3 1 2 1 1 0 0 0 0 0 1 0 1 0 1 + 2 24 2 44 5 3 2 4 2 48 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 + 4 12 4 7 1 3 3 2 3 32 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 15 3 36 1 5 2 4 2 27 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 30 4 42 1 1 4 2 3 28 3 2 1 1 1 1 0 1 0 0 1 0 0 0 2 + 1 24 2 19 1 2 1 3 2 32 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 24 2 29 1 4 3 1 4 34 3 1 1 2 1 0 1 1 0 0 0 0 0 0 1 + 1 18 2 27 4 3 3 2 3 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 4 10 1 3 2 3 1 36 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 8 4 34 1 4 3 4 1 39 3 2 1 1 2 1 0 1 0 0 1 0 1 0 1 + 4 12 4 58 5 5 3 4 2 49 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 4 24 2 15 4 4 2 3 3 34 3 1 2 2 1 1 0 1 0 0 1 0 0 1 1 + 3 36 2 45 1 5 3 2 3 31 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 6 2 11 1 5 3 4 3 28 3 1 2 1 1 0 0 1 0 0 1 0 0 1 1 + 1 24 4 66 1 1 3 4 4 75 3 2 1 2 1 0 1 1 0 0 0 0 0 0 1 + 4 18 4 19 2 3 2 2 1 30 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 60 2 74 2 2 2 2 2 24 3 1 1 1 1 1 0 1 0 0 1 0 0 0 2 + 4 48 4 116 2 3 2 4 3 24 1 2 1 1 1 0 1 1 0 1 0 0 1 0 2 + 1 24 0 41 1 5 3 4 4 23 1 2 2 1 1 0 0 1 0 1 0 0 0 1 2 + 1 6 4 34 1 3 1 4 1 44 3 1 1 2 1 0 0 1 0 1 0 0 0 0 2 + 2 13 2 21 1 2 2 4 2 23 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 + 1 15 2 13 5 3 2 2 3 24 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 1 24 2 42 1 3 3 4 2 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 10 2 15 1 3 1 2 3 31 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 24 4 57 1 2 2 4 4 24 3 2 1 2 1 0 0 1 0 0 0 0 0 1 1 + 1 21 2 36 1 4 2 4 3 26 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 2 18 2 32 3 2 4 3 1 25 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 2 18 2 44 1 5 3 1 1 33 1 1 1 2 1 0 0 0 1 0 1 0 0 0 1 + 3 10 2 39 1 2 3 1 2 37 3 1 2 1 1 1 0 0 0 0 1 0 1 0 1 + 4 15 4 15 1 3 2 2 3 43 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 13 4 9 1 2 3 4 1 23 3 2 1 1 1 0 0 0 0 0 1 0 0 1 1 + 2 24 2 38 3 1 2 4 4 23 3 1 1 1 1 0 0 1 0 1 0 1 0 0 1 + 4 6 3 17 2 3 3 2 1 34 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 9 4 11 4 5 3 3 4 32 3 2 2 1 1 0 0 1 0 0 0 0 0 1 2 + 4 9 2 12 1 2 2 4 1 23 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 2 9 2 10 1 3 2 2 3 29 3 1 1 1 2 0 0 1 0 0 1 0 0 1 2 + 4 18 4 32 5 1 3 4 4 38 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 1 12 0 62 1 3 3 2 2 28 3 2 1 2 1 0 0 1 0 1 0 0 0 1 2 + 4 10 2 7 3 5 3 4 4 46 3 1 1 2 1 0 0 1 0 0 0 0 0 1 1 + 2 24 2 12 1 2 3 2 1 23 2 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 4 12 4 23 5 5 3 4 1 49 3 1 1 2 1 0 0 0 1 0 1 0 0 1 1 + 4 36 3 45 1 3 3 2 3 26 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 12 2 8 1 3 4 2 1 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 30 2 24 1 4 2 4 1 23 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 2 18 2 12 5 3 3 4 4 61 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 + 3 12 2 34 5 5 3 3 3 37 3 1 1 1 1 0 0 1 0 0 1 0 0 0 1 + 3 12 3 22 1 3 2 2 3 36 2 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 6 2 18 1 3 4 2 2 21 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 1 18 2 25 1 1 3 1 3 25 3 1 1 1 1 0 0 1 0 0 1 1 0 0 2 + 4 12 2 15 1 4 3 4 3 36 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 18 4 38 1 4 3 1 3 27 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 + 1 18 2 36 1 2 2 4 3 22 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 1 36 2 34 1 5 3 2 3 42 3 1 2 1 1 0 0 1 0 0 1 0 0 1 2 + 2 18 2 30 1 4 2 4 1 40 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 4 36 2 31 5 3 3 4 1 36 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 18 4 61 1 5 3 4 3 33 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 10 4 21 1 2 2 3 1 23 3 2 1 1 1 0 0 1 0 1 0 0 0 1 1 + 4 60 4 138 5 5 3 4 4 63 1 1 1 2 1 1 0 1 0 0 0 0 0 0 1 + 2 60 1 148 2 5 2 4 4 60 1 2 1 2 1 0 0 1 0 0 0 0 0 0 2 + 1 48 1 77 1 4 2 4 3 37 3 1 1 1 1 0 0 0 0 1 0 0 0 1 2 + 4 18 3 23 1 1 4 3 1 34 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 7 3 8 5 5 3 4 4 36 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 + 2 36 2 143 1 5 3 2 4 57 3 1 1 2 1 1 0 1 0 0 0 0 0 0 2 + 4 6 4 4 2 3 2 4 3 52 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 + 1 20 2 22 5 4 3 4 3 39 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 18 2 130 1 1 2 4 4 38 3 1 1 2 1 0 1 1 0 0 0 0 0 0 2 + 4 22 2 13 5 4 2 4 2 25 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 + 3 12 2 13 1 2 3 1 1 26 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 30 3 43 2 3 3 2 2 26 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 18 4 22 1 3 2 1 3 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 11 5 2 2 2 1 21 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 2 18 4 74 1 1 3 4 2 40 2 2 1 2 1 0 0 1 0 0 1 0 0 0 1 + 2 15 4 23 3 3 3 4 3 27 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 9 2 14 1 4 2 2 3 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 18 1 3 4 2 2 30 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 + 2 12 2 10 4 2 2 4 1 19 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 1 36 2 32 1 4 3 4 4 39 1 1 2 2 1 1 0 1 0 0 0 0 0 0 1 + 1 6 4 20 1 4 2 4 3 31 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 9 4 24 1 1 3 3 3 31 3 1 1 1 1 0 0 1 0 0 1 0 0 0 1 + 2 39 3 118 2 4 3 3 4 32 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 1 12 2 26 1 1 2 4 4 55 3 1 1 1 1 0 0 1 0 0 0 0 0 0 1 + 1 36 4 23 1 3 4 2 2 46 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 12 2 12 1 5 1 1 1 46 3 2 1 1 1 1 0 1 0 1 0 0 0 1 2 + 4 24 4 15 4 3 2 1 1 43 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 18 2 15 1 2 4 4 1 39 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 18 4 19 5 3 4 4 1 28 1 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 3 86 1 2 3 2 3 27 1 2 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 14 3 8 1 3 3 2 3 27 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 + 2 18 3 29 5 5 3 4 3 43 3 1 2 1 1 1 0 1 0 0 1 0 0 1 1 + 2 24 2 20 1 2 4 1 2 22 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 24 4 22 5 4 3 4 3 43 3 2 2 2 1 0 1 1 0 0 1 0 0 1 1 + 1 15 2 11 1 2 4 2 1 27 3 1 1 1 2 0 0 1 0 0 1 0 0 1 1 + 4 24 2 32 3 5 1 2 3 26 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 3 12 4 9 3 4 4 2 1 28 3 3 1 2 1 1 0 1 0 0 1 0 0 1 2 + 2 24 2 20 1 5 2 4 3 20 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 33 4 73 1 4 3 2 3 35 3 2 1 2 1 0 1 1 0 0 1 0 0 0 1 + 4 12 4 23 1 1 3 2 3 42 2 2 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 10 2 16 3 3 3 2 4 40 3 1 2 1 2 1 0 1 0 1 0 0 1 0 1 + 1 24 2 14 5 3 2 2 2 35 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 36 4 58 1 5 3 2 2 35 3 2 2 2 1 0 1 1 0 0 1 0 0 1 1 + 1 12 2 26 1 2 3 1 1 33 3 1 2 1 1 1 0 1 0 0 1 0 1 0 2 + 1 18 3 85 5 3 2 2 3 23 3 2 1 2 1 0 0 1 0 1 0 0 0 1 1 + 4 21 2 28 3 4 2 2 3 31 1 1 1 1 1 1 0 1 0 0 1 0 0 0 1 + 2 18 2 10 5 3 2 2 2 33 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 15 2 32 4 4 2 3 3 20 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 + 2 12 2 20 5 3 3 2 3 30 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 + 2 12 4 10 1 4 3 3 1 47 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 + 4 21 3 16 2 4 3 3 1 34 3 2 1 1 1 0 0 1 0 0 1 0 0 0 1 + 2 12 2 28 5 5 2 2 2 25 1 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 2 18 2 28 1 3 4 3 3 21 3 1 1 2 1 0 1 1 0 1 0 0 0 1 1 + 4 28 4 27 1 5 3 2 3 29 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 4 11 4 3 3 3 1 46 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 9 2 13 1 5 3 4 3 20 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 18 4 12 1 1 2 4 4 55 3 3 2 1 1 0 0 1 0 0 0 1 0 0 2 + 4 5 2 34 1 4 3 4 1 74 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 24 2 113 1 3 3 3 3 29 1 2 1 2 1 0 0 0 1 0 1 0 0 0 2 + 1 6 4 19 1 1 3 4 4 36 3 3 1 2 1 0 0 1 0 0 0 0 0 0 1 + 4 24 4 21 1 3 1 2 1 33 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 9 2 21 1 3 3 2 1 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 12 2 15 5 3 4 1 1 25 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 6 2 7 3 4 4 4 1 23 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 4 24 4 13 4 5 2 4 1 37 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 1 42 4 34 1 1 3 4 3 65 3 2 1 1 1 0 0 0 1 0 1 1 0 0 1 + 3 12 1 6 1 2 2 1 1 26 3 1 1 1 1 0 0 1 0 0 1 1 0 0 2 + 4 12 2 19 1 5 3 4 3 39 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 + 1 12 2 16 1 3 2 3 2 30 3 1 1 1 1 0 0 0 1 0 1 0 0 1 1 + 2 20 3 26 1 3 3 3 3 29 1 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 12 2 7 1 5 3 4 3 41 1 1 2 1 1 0 0 1 0 0 1 0 1 0 2 + 2 48 4 51 1 3 2 3 3 30 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 9 4 12 5 5 2 4 2 41 3 2 1 1 1 0 0 1 0 1 0 0 1 0 1 + 1 36 2 18 1 2 2 4 3 34 3 1 1 2 1 1 0 1 0 0 1 0 0 1 2 + 2 7 2 26 1 3 3 2 1 35 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 + 3 12 2 14 5 5 2 4 1 55 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 2 15 3 15 4 3 4 3 2 61 2 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 36 4 111 5 3 3 2 3 30 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 4 6 2 5 1 3 2 1 1 29 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 12 0 28 1 5 3 4 2 34 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 27 1 5 3 4 3 35 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 1 24 2 48 1 4 3 3 2 31 3 1 1 2 1 1 0 0 1 0 1 0 0 1 2 + 4 24 2 27 1 2 2 1 4 29 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 1 11 4 39 1 3 3 2 1 36 3 2 2 1 1 1 0 1 0 1 0 0 0 1 1 + 1 12 2 34 1 5 3 4 4 35 3 1 1 2 1 0 1 1 0 0 0 0 0 1 2 + 1 6 2 3 1 2 2 1 1 27 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 46 1 2 3 2 3 32 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 36 2 36 1 3 3 2 2 37 3 1 2 1 1 0 0 0 0 0 1 0 0 1 1 + 1 15 2 17 1 2 3 3 1 36 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 2 12 2 30 1 2 2 1 1 34 3 1 1 1 1 0 0 1 0 1 0 0 0 0 1 + 2 12 2 8 5 5 3 4 2 38 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 20 1 4 3 1 3 34 2 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 24 2 29 1 3 3 4 4 63 1 1 2 2 1 0 1 0 0 0 1 0 0 1 1 + 1 24 3 17 1 2 2 2 3 29 3 1 1 2 1 0 0 1 0 1 0 0 1 0 2 + 4 48 3 72 5 5 3 3 3 32 1 2 2 1 1 0 0 1 0 0 1 0 0 1 1 + 4 33 3 28 1 3 2 2 3 26 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 24 3 47 1 4 3 3 3 35 3 2 1 2 1 0 1 1 0 0 1 0 1 0 1 + 2 24 2 31 2 2 4 2 3 22 3 1 1 2 1 0 0 1 0 1 0 0 0 1 2 + 1 6 2 4 1 2 2 4 2 23 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 9 2 7 1 3 3 3 3 28 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 4 6 2 12 5 1 3 4 2 36 3 1 2 2 1 0 0 1 0 0 1 0 0 0 1 + 2 18 4 12 1 3 4 2 3 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 18 0 31 1 2 2 4 2 26 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 4 39 2 26 3 3 3 4 3 24 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 + 3 24 2 52 1 4 3 2 3 25 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 12 2 10 2 4 3 4 1 39 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 15 4 15 1 5 3 4 3 44 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 + 2 12 4 36 1 3 2 1 1 23 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 24 2 12 1 2 3 1 2 26 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 30 2 36 4 5 2 4 2 57 3 2 1 2 1 0 0 1 0 1 0 0 0 1 1 + 4 15 3 10 4 4 2 2 2 30 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 12 4 12 3 3 3 4 1 44 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 2 6 3 12 1 1 3 4 2 47 3 1 1 2 1 1 0 1 0 0 1 0 0 0 2 + 4 12 2 31 1 3 3 4 3 52 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 38 1 5 2 4 4 62 3 1 1 2 1 1 0 0 1 0 0 0 0 1 1 + 4 10 2 14 2 3 3 2 1 35 3 1 1 1 2 1 0 1 0 1 0 0 1 0 1 + 4 6 2 35 1 3 3 3 2 26 3 1 1 1 1 1 0 0 0 1 0 0 0 1 1 + 4 12 4 19 1 5 3 2 4 26 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 27 0 83 1 5 2 4 4 42 3 2 1 2 1 0 0 1 0 0 0 0 0 0 2 + 4 6 4 12 2 3 2 1 2 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 6 2 4 5 5 3 4 2 38 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 4 21 1 3 3 2 1 39 3 2 2 1 2 1 0 1 0 1 0 0 1 0 1 + 1 24 2 30 5 3 4 4 3 20 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 36 2 90 2 2 3 1 4 29 3 1 1 2 1 0 0 0 1 1 0 0 0 0 2 + 4 24 4 16 1 4 3 3 2 40 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 18 2 13 1 5 4 2 1 32 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 + 3 6 4 13 2 5 1 4 3 28 3 2 2 2 1 1 0 1 0 0 1 0 0 1 1 + 1 24 2 31 1 2 2 1 2 27 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 1 36 2 55 1 5 3 4 4 42 3 1 2 1 1 0 1 1 0 0 0 0 0 1 1 + 3 9 2 11 2 5 1 4 1 49 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 24 4 12 2 2 3 4 4 38 1 2 2 1 1 0 0 1 0 0 1 0 0 1 2 + 1 24 2 12 1 2 2 4 2 24 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 + 4 10 2 13 5 3 3 4 2 27 3 1 1 1 1 1 0 0 0 0 1 0 1 0 2 + 3 15 4 24 3 3 3 2 3 36 3 1 1 2 1 0 1 1 0 0 1 0 0 1 1 + 2 15 1 68 2 1 3 2 2 34 3 1 2 2 1 1 0 1 0 0 1 0 0 0 2 + 4 24 2 14 1 3 4 2 2 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 39 2 86 2 5 3 2 3 45 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 1 12 2 8 1 4 3 2 1 26 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 36 2 47 1 3 3 2 4 32 3 1 1 2 1 0 1 1 0 0 0 0 0 0 1 + 3 15 2 27 1 4 3 4 2 26 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 2 12 3 6 1 3 4 4 1 20 3 2 1 1 1 0 0 0 1 1 0 0 0 1 1 + 4 24 2 23 5 2 3 1 2 54 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 6 4 6 1 4 2 3 2 37 3 2 1 1 2 1 0 1 0 0 1 0 0 1 1 + 1 6 4 14 1 2 3 4 1 40 3 1 2 1 2 1 0 1 0 0 1 0 1 0 1 + 4 36 4 71 1 2 2 4 2 23 3 2 1 2 1 0 0 1 0 1 0 0 0 1 2 + 1 6 2 12 2 5 3 2 2 43 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 6 4 7 5 5 3 4 4 36 3 2 1 1 1 0 0 1 0 0 0 0 0 1 1 + 4 24 4 55 1 5 3 4 4 44 3 2 1 1 1 0 0 1 0 0 0 0 0 1 1 + 1 18 2 32 1 3 2 2 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 48 0 71 1 3 3 4 4 53 3 2 2 1 1 0 0 1 0 0 0 0 0 1 2 + 4 24 2 35 2 4 2 4 3 23 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 + 2 18 2 11 1 3 2 4 1 26 3 1 2 1 1 0 0 0 0 0 1 0 1 0 1 + 2 26 2 80 1 2 3 3 3 30 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 + 4 15 4 15 2 3 2 3 3 31 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 4 4 15 1 4 3 1 1 42 3 2 2 1 1 0 0 1 0 0 1 0 1 0 1 + 1 36 2 23 1 3 1 4 3 31 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 1 6 2 7 1 2 3 4 1 41 3 1 2 2 1 1 0 1 0 0 1 0 1 0 1 + 2 36 2 23 1 4 3 1 3 32 3 2 2 1 1 0 0 1 0 0 1 0 0 1 1 + 2 15 2 26 2 3 2 4 3 28 3 2 1 2 1 1 0 1 0 1 0 0 0 1 2 + 4 12 3 15 1 3 4 4 1 41 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 + 4 24 2 13 2 4 4 3 2 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 31 5 2 3 2 3 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 3 21 4 23 1 2 1 1 3 33 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 1 6 2 14 5 1 2 3 2 75 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 + 2 18 4 36 1 5 2 4 2 37 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 48 2 78 1 5 3 4 4 42 1 1 1 1 1 1 0 1 0 0 0 0 0 0 2 + 3 18 2 30 1 2 2 1 2 45 2 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 12 2 15 1 2 4 1 1 23 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 4 24 3 20 1 5 3 4 4 60 3 2 1 2 1 1 0 1 0 0 0 0 0 1 1 + 1 30 2 64 5 5 3 4 2 31 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 3 18 2 29 1 3 3 1 1 34 3 1 2 1 1 0 0 1 0 0 1 0 1 0 2 + 4 12 4 13 1 5 3 4 1 61 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 + 1 24 3 13 1 1 3 2 1 43 3 2 2 1 1 1 0 1 0 0 0 0 0 1 2 + 4 24 4 20 1 3 2 4 3 37 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 24 2 16 1 4 3 1 3 32 1 1 2 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 1 6 1 3 2 4 1 24 1 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 4 48 4 89 5 4 3 1 4 35 3 2 1 2 1 0 1 1 0 0 0 0 0 1 1 + 4 12 4 10 5 4 2 4 1 23 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 6 1 18 3 5 3 4 2 45 1 1 2 1 1 0 0 1 0 0 1 0 1 0 1 + 1 48 2 70 1 4 4 1 1 34 3 2 1 2 1 0 0 0 0 0 1 0 0 1 2 + 2 12 4 20 2 2 3 1 3 27 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 2 9 2 12 1 4 2 4 2 67 3 2 1 2 1 0 0 1 0 0 1 0 0 0 1 + 2 12 2 13 1 2 3 1 3 22 2 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 18 0 23 2 2 2 3 3 28 3 2 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 21 0 50 5 3 2 4 2 29 1 2 1 2 1 1 0 1 0 0 1 0 0 1 2 + 1 24 1 36 1 4 3 4 3 27 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 18 4 19 1 2 3 2 1 31 3 2 1 1 1 0 0 1 0 0 1 0 1 0 2 + 1 24 2 30 5 5 3 4 4 49 1 1 2 2 1 0 1 1 0 0 0 0 0 1 1 + 1 24 1 15 1 4 3 4 3 24 1 1 1 1 1 0 0 0 0 1 0 0 1 0 2 + 3 6 3 7 1 2 2 1 2 29 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 36 2 124 5 3 3 4 4 37 3 1 1 2 1 1 0 1 0 0 0 0 0 1 2 + 2 24 3 47 5 3 3 2 2 37 1 2 1 2 1 0 0 1 0 0 1 0 0 0 1 + 2 24 3 16 2 4 2 2 2 23 3 2 1 2 1 0 0 1 0 1 0 0 0 1 1 + 1 12 2 14 1 4 1 3 3 36 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 24 4 26 4 5 3 2 3 34 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 48 2 40 5 4 3 1 3 41 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 + 1 48 2 68 1 3 2 2 3 31 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 1 24 2 32 1 2 2 4 1 23 3 1 1 2 1 0 0 1 0 1 0 0 1 0 2 + 4 30 4 60 1 4 3 2 3 38 3 1 1 1 1 0 0 0 1 0 1 0 0 1 1 + 4 24 2 54 5 1 2 4 2 26 3 1 1 2 1 0 1 1 0 1 0 0 0 0 1 + 1 15 2 8 1 3 2 4 2 22 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 9 2 11 1 5 3 4 3 27 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 15 4 28 1 4 2 3 3 24 1 2 1 1 1 0 0 0 1 0 1 0 0 1 1 + 2 12 2 29 1 4 2 1 1 27 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 4 19 5 3 2 2 3 33 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 36 4 28 1 2 1 4 3 27 3 2 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 24 2 9 1 2 4 3 3 27 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 18 4 11 1 5 3 3 1 30 1 2 1 1 1 1 0 0 0 0 1 0 0 1 2 + 2 12 4 31 1 2 3 3 1 49 1 2 2 1 1 1 0 1 0 0 1 0 1 0 1 + 4 9 2 14 1 3 2 2 1 26 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 2 36 2 24 1 2 3 1 4 33 3 1 1 1 1 0 0 1 0 1 0 0 1 0 2 + 4 12 2 21 5 5 2 4 4 52 3 1 1 2 1 1 0 1 0 0 0 0 0 0 1 + 1 18 2 20 1 3 2 4 1 20 1 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 1 9 4 28 1 3 3 2 1 36 3 2 2 1 1 1 0 1 0 1 0 0 0 1 1 + 1 12 2 13 1 3 3 1 2 21 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 + 1 18 2 12 1 3 4 3 1 47 3 1 1 2 1 0 0 1 0 0 1 0 1 0 2 + 1 12 4 22 1 5 3 3 2 60 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 12 4 4 1 4 2 3 1 58 3 4 1 2 1 0 0 1 0 0 1 0 1 0 1 + 2 24 3 20 5 3 2 4 3 42 3 2 1 2 1 1 0 1 0 1 0 0 0 1 1 + 4 21 2 16 4 5 2 4 1 36 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 24 2 27 1 3 2 4 2 20 3 1 1 2 1 1 0 1 0 1 0 0 1 0 2 + 1 24 1 14 5 5 3 3 3 40 2 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 2 6 1 9 2 2 2 1 2 32 2 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 1 24 2 14 1 4 2 4 3 23 3 2 1 1 1 1 0 1 0 1 0 0 0 1 2 + 2 24 0 42 1 3 3 4 1 36 3 3 1 2 1 0 0 1 0 0 1 0 1 0 2 + 4 18 4 28 1 4 3 2 2 31 1 2 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 24 3 39 1 3 3 2 4 32 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 + 2 7 2 23 1 2 2 1 1 45 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 + 2 9 2 9 1 3 2 1 2 30 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 24 1 18 1 4 2 4 4 34 1 1 1 1 1 0 0 1 0 0 0 0 1 0 2 + 4 36 2 33 1 3 2 2 3 28 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 3 10 2 13 1 2 2 2 2 23 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 24 1 28 3 3 3 4 1 22 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 24 4 45 1 3 3 2 1 74 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 2 36 2 27 2 3 2 4 4 50 3 1 1 1 1 0 0 0 1 0 0 0 0 1 2 + 4 18 2 21 1 2 3 1 1 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 15 2 13 5 5 3 4 4 45 1 1 2 1 1 0 1 1 0 0 0 0 0 1 1 + 1 12 2 7 2 1 2 3 2 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 3 10 2 12 2 5 2 4 4 48 3 1 2 1 1 1 0 1 0 0 0 0 1 0 2 + 1 21 2 34 4 2 2 2 3 29 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 24 1 36 1 3 2 4 3 22 1 1 1 1 2 0 1 0 0 1 0 0 0 1 1 + 4 18 3 18 1 4 2 1 1 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 48 0 122 5 3 3 2 3 48 1 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 2 60 3 92 5 3 3 2 4 27 3 1 1 1 1 0 0 1 0 0 0 0 0 0 1 + 1 6 4 37 1 3 3 3 1 37 3 3 2 1 1 1 0 1 0 1 0 0 0 1 1 + 2 30 2 34 2 3 2 4 3 21 3 1 1 1 1 0 0 0 1 1 0 0 0 1 2 + 4 12 2 6 1 3 1 2 1 49 3 1 1 1 1 1 0 1 0 0 1 0 1 0 1 + 2 21 4 37 1 4 3 3 2 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 18 4 15 1 3 3 2 2 32 1 2 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 48 2 39 5 3 1 2 1 38 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 12 2 19 1 2 2 1 3 22 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 1 18 2 26 1 3 3 4 4 65 3 2 1 1 1 0 0 1 0 0 0 0 0 1 2 + 4 15 2 20 5 5 3 2 3 35 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 3 6 2 21 1 3 3 2 1 41 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 9 1 14 2 4 3 3 4 29 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 42 4 40 3 3 3 4 1 36 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 9 2 38 5 5 3 4 1 64 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 24 2 37 1 3 2 4 3 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 18 1 16 1 3 3 3 3 44 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 15 2 14 5 2 3 1 2 23 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 9 2 20 1 2 2 2 3 19 3 2 1 1 1 0 0 0 1 1 0 0 0 1 2 + 2 24 2 14 1 2 2 4 3 25 3 1 1 2 1 1 0 1 0 0 1 0 1 0 2 + 4 12 2 14 1 5 3 4 2 47 1 3 2 2 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 14 3 4 2 1 3 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 60 3 157 1 4 3 4 3 21 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 12 2 15 1 2 2 3 3 34 3 1 2 1 1 0 0 1 0 0 1 0 0 1 1 + 1 42 3 44 1 4 3 2 2 26 1 2 2 2 1 0 0 1 0 0 1 0 0 1 2 + 1 18 2 8 1 1 2 1 1 27 3 1 1 1 1 0 0 1 0 0 1 1 0 0 2 + 2 15 2 13 1 5 3 4 3 38 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 15 2 46 2 3 3 2 2 40 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 24 4 19 1 4 4 2 3 33 3 2 1 2 1 0 0 0 0 0 1 0 0 1 1 + 1 18 4 19 1 4 4 1 2 32 3 2 1 2 1 0 0 1 0 0 1 0 0 0 1 + 4 36 3 80 5 2 3 4 3 27 3 2 1 2 1 0 0 1 0 1 0 0 0 1 2 + 1 30 0 46 1 3 1 2 1 32 3 2 1 1 1 0 0 0 0 0 1 0 0 1 1 + 4 12 2 14 3 3 2 2 2 26 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 3 24 2 9 1 4 3 3 4 38 1 1 2 1 1 1 0 1 0 0 0 0 0 1 2 + 1 12 2 7 1 3 3 4 3 40 3 1 2 1 1 0 0 1 0 1 0 0 1 0 2 + 1 48 2 75 1 4 3 1 4 50 3 1 1 2 1 0 0 1 0 0 0 0 0 0 1 + 2 12 2 19 1 3 3 2 2 37 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 1 24 2 23 1 5 3 1 1 45 3 1 1 1 1 1 0 0 1 0 1 0 0 1 2 + 2 36 3 81 2 5 3 4 3 42 3 4 1 2 1 1 0 1 0 0 1 0 0 0 2 + 4 24 4 23 1 4 3 3 3 35 3 2 1 2 1 0 1 1 0 0 1 0 0 1 1 + 1 14 2 40 1 1 3 4 4 22 3 1 1 1 1 1 0 1 0 0 0 0 0 1 1 + 2 12 2 9 1 5 3 4 3 41 1 1 2 1 1 1 0 1 0 0 1 0 1 0 2 + 4 48 2 102 5 4 3 3 3 37 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 30 0 42 1 3 2 1 3 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 18 4 64 1 5 3 1 4 41 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 3 12 2 13 1 3 4 4 1 23 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 1 12 2 9 5 3 4 2 3 23 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 21 2 22 1 5 3 2 1 50 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 6 3 10 1 1 3 1 2 35 2 2 1 2 1 0 0 1 0 0 1 0 0 0 1 + 3 6 4 10 1 3 2 4 2 50 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 24 4 63 1 1 3 2 4 27 1 2 1 2 1 0 0 0 1 0 1 0 0 0 1 + 2 30 1 35 4 3 3 2 3 34 2 1 2 2 1 0 0 1 0 0 1 0 0 1 1 + 4 48 1 36 1 3 2 1 1 27 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 4 48 1 5 3 4 2 43 3 2 1 2 1 1 0 0 1 1 0 0 0 1 2 + 3 30 4 30 1 5 3 4 2 47 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 4 41 2 3 3 3 2 27 3 2 1 2 1 0 0 1 0 0 1 0 1 0 1 + 4 36 2 57 2 4 3 2 3 31 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 60 2 104 1 5 3 4 2 42 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 + 4 6 4 21 3 3 4 2 3 24 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 21 3 26 3 2 3 2 1 41 1 1 2 1 1 0 0 1 0 0 1 0 1 0 2 + 4 30 4 45 1 4 2 4 3 26 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 + 4 24 4 52 1 5 3 4 3 33 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 72 2 56 2 3 4 2 3 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 24 2 24 1 5 3 4 1 64 1 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 4 18 2 15 1 2 2 1 1 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 6 2 15 1 2 2 2 4 56 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 12 2 23 5 3 3 4 4 37 3 1 1 2 1 0 0 1 0 0 0 0 0 1 1 + 4 15 3 15 1 3 4 3 1 33 1 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 4 51 1 2 4 3 4 47 3 3 1 2 1 0 0 1 0 0 0 0 0 1 1 + 2 36 3 99 2 4 3 3 2 31 3 2 2 2 1 0 0 1 0 0 1 0 1 0 1 + 4 60 2 65 5 3 3 4 4 34 3 1 2 2 1 1 0 1 0 0 0 0 0 1 1 + 3 10 4 13 5 4 3 2 2 27 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 36 3 29 2 5 3 3 4 30 3 1 1 1 1 1 0 1 0 0 0 0 0 1 1 + 4 9 2 28 2 5 3 4 3 35 3 1 1 2 1 0 0 0 1 0 1 0 0 1 1 + 1 12 2 37 4 3 3 3 2 31 3 1 2 1 1 1 0 1 0 0 1 0 0 1 1 + 1 15 4 10 1 3 1 3 2 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 15 2 26 2 3 2 2 1 25 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 24 2 29 2 2 3 1 3 29 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 6 4 47 5 2 3 3 1 44 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 + 4 24 2 23 1 4 3 2 3 28 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 6 2 12 3 3 3 4 2 50 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 + 2 12 2 11 1 4 3 3 1 29 3 2 1 1 2 0 0 0 0 0 1 0 0 1 1 + 4 12 4 9 1 1 2 2 2 38 3 1 1 1 1 1 0 1 0 0 1 1 0 0 1 + 4 18 4 18 1 3 3 2 3 24 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 3 15 2 19 1 5 3 4 3 40 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 + 4 12 2 11 3 3 2 4 3 29 3 1 1 1 1 0 0 1 0 1 0 0 1 0 2 + 1 48 4 63 1 5 3 4 4 46 3 2 1 2 1 0 1 1 0 0 0 0 0 1 2 + 3 24 2 14 2 5 2 2 4 47 3 1 1 2 1 0 0 1 0 0 0 0 0 1 1 + 2 30 3 25 2 5 3 2 2 41 2 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 27 2 25 1 2 2 1 2 32 3 1 2 2 1 0 0 1 0 0 1 0 0 1 1 + 4 15 2 53 3 5 2 4 4 35 3 1 1 1 1 1 0 1 0 0 0 0 0 1 1 + 2 48 2 66 2 4 3 2 2 24 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 + 2 12 0 30 1 2 2 3 2 25 3 2 1 1 1 0 0 1 0 1 0 0 0 1 2 + 2 9 2 12 1 5 2 4 1 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 9 2 21 1 3 3 2 1 37 3 1 2 1 1 0 0 1 0 0 1 0 1 0 1 + 4 18 4 6 3 5 3 3 2 32 1 2 1 2 1 0 0 1 0 0 1 0 0 0 1 + 1 6 1 12 1 5 2 4 4 35 3 1 1 1 1 0 0 1 0 0 0 0 0 1 2 + 4 21 2 25 5 5 3 4 1 46 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 1 9 4 11 1 3 3 4 1 25 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 60 2 140 1 4 3 2 4 27 3 1 1 2 1 1 0 1 0 0 1 0 0 0 2 + 4 30 4 76 5 5 3 4 3 63 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 + 4 30 4 31 5 5 3 2 3 40 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 15 1 3 3 2 4 32 3 1 1 2 1 0 0 1 0 0 0 0 0 0 1 + 3 24 4 31 5 3 3 2 3 31 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 20 0 61 2 5 4 4 3 31 1 2 1 2 1 0 1 1 0 0 1 0 0 1 1 + 3 9 0 13 1 2 3 2 3 34 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 + 2 6 1 4 4 2 2 2 2 24 1 1 2 1 1 0 0 1 0 1 0 0 0 1 2 + 1 12 2 12 1 3 2 2 1 24 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 2 9 2 8 3 3 2 3 1 66 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 27 2 26 1 3 2 3 1 21 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 + 4 6 4 2 4 3 2 2 1 41 1 2 1 1 1 1 0 1 0 0 1 0 1 0 1 + 4 15 4 13 3 3 4 2 2 47 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 18 2 19 1 3 2 4 3 25 1 2 1 1 1 0 0 1 0 1 0 0 0 1 2 + 2 48 1 64 1 5 2 3 4 59 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 3 24 4 13 4 3 1 4 1 36 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 24 3 64 1 2 3 2 3 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 24 2 20 1 3 3 4 1 21 3 1 2 1 1 0 0 1 0 1 0 0 1 0 2 + 2 8 2 8 1 4 2 2 1 44 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 + 4 24 2 26 4 3 2 4 3 28 3 1 1 2 1 0 1 1 0 1 0 0 0 1 1 + 4 4 4 34 1 4 2 1 1 37 3 1 2 1 1 1 0 1 0 0 1 0 0 1 1 + 2 36 1 40 5 2 2 2 4 29 1 1 1 1 1 0 0 1 0 0 1 1 0 0 1 + 2 24 2 116 1 3 2 4 3 23 3 2 1 1 1 0 1 1 0 1 0 0 0 0 2 + 1 18 2 44 2 3 3 4 3 35 3 1 2 2 1 1 0 1 0 0 1 0 1 0 1 + 4 6 4 68 1 4 3 3 4 45 3 2 2 2 1 1 0 1 0 0 1 0 0 0 1 + 2 30 0 43 2 3 2 4 3 26 3 2 1 1 1 0 0 1 0 1 0 0 1 0 2 + 1 24 1 23 2 4 3 3 3 32 1 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 2 10 1 10 1 3 3 4 1 23 2 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 21 2 32 5 5 3 3 2 41 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 24 1 25 3 3 3 4 1 22 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 39 4 142 5 4 3 4 2 30 3 2 1 2 1 0 0 1 0 0 1 0 0 0 1 + 1 13 4 18 1 2 3 1 2 28 1 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 15 2 25 1 1 2 4 3 23 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 + 1 12 2 13 1 2 2 1 1 37 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 4 21 2 52 5 3 3 3 3 26 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 + 4 15 2 30 1 4 3 2 3 33 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 + 1 6 2 4 1 5 2 1 2 49 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 18 2 10 1 2 2 2 3 23 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 2 12 2 8 2 4 2 4 1 23 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 4 30 4 58 1 4 2 2 3 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 12 3 16 4 5 3 4 4 55 3 2 2 1 1 0 0 1 0 0 0 0 0 1 2 + 1 24 2 13 5 4 2 4 4 32 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 + 3 6 4 13 1 3 3 1 1 74 3 3 2 1 2 1 0 1 0 0 1 1 0 0 1 + 3 15 4 13 5 3 3 4 4 39 3 2 1 2 1 0 0 1 0 0 0 0 0 1 2 + 4 24 2 14 1 3 3 2 1 31 3 1 1 2 1 1 0 0 0 0 1 0 0 1 1 + 1 12 4 7 1 5 3 3 2 35 3 2 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 15 4 50 5 5 2 4 3 59 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 1 18 4 21 1 3 2 4 1 24 3 2 1 1 1 0 0 1 0 1 0 0 0 1 2 + 1 12 2 22 1 3 3 3 2 24 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 21 4 127 5 5 3 4 4 30 3 1 1 2 1 1 0 1 0 0 0 0 0 0 2 + 4 24 4 25 2 4 4 3 2 27 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 2 12 2 12 1 5 4 3 1 40 1 2 1 1 1 0 0 0 0 0 1 0 1 0 1 + 1 30 2 31 1 2 1 4 2 31 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 4 10 2 29 5 2 2 4 1 31 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 + 2 12 4 36 1 5 3 4 3 28 3 3 1 2 1 0 0 1 0 1 0 0 0 1 1 + 4 12 4 17 1 5 3 4 1 63 3 2 1 2 1 0 0 1 0 0 1 0 1 0 1 + 1 24 2 28 5 5 2 4 1 26 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 + 1 36 4 81 1 3 2 2 4 25 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 + 4 21 4 33 1 5 3 4 3 36 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 4 24 4 22 2 5 3 4 2 52 1 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 3 12 4 15 3 1 3 4 4 66 1 3 1 1 1 1 0 1 0 0 0 1 0 0 1 + 1 24 2 14 5 3 2 4 1 25 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 + 4 36 4 35 1 4 3 4 3 37 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 1 18 2 35 1 4 2 1 1 25 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 + 4 36 4 57 4 5 3 2 3 38 3 2 1 2 1 0 1 1 0 0 1 0 0 0 1 + 2 18 2 39 1 1 2 4 3 67 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 39 4 49 1 4 3 2 1 25 3 2 1 1 1 0 0 0 0 0 1 0 0 1 2 + 4 24 4 19 4 5 3 4 1 60 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 2 12 0 14 1 3 3 2 1 31 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 + 2 12 2 8 2 2 2 2 2 23 1 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 2 20 2 65 5 1 1 4 1 60 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 2 18 2 19 4 3 3 2 2 35 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 + 4 22 2 27 3 5 3 4 3 40 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 48 4 28 5 5 3 3 3 38 3 2 2 2 1 0 1 1 0 0 1 0 0 1 1 + 2 48 3 62 1 5 3 4 4 50 3 1 1 1 1 0 0 1 0 0 0 0 0 1 2 + 1 40 4 60 1 3 3 3 4 27 1 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 2 21 2 12 1 5 2 4 2 39 3 1 2 1 1 0 0 1 0 0 1 0 0 1 2 + 4 24 2 63 5 5 3 4 3 41 3 1 2 2 1 0 1 1 0 0 1 0 0 0 1 + 4 6 4 12 5 3 4 2 2 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 3 24 2 29 1 5 1 4 4 51 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 + 4 24 2 31 3 5 3 3 4 32 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 4 9 2 23 2 2 2 4 2 22 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 1 18 2 75 5 5 3 4 2 51 3 1 2 2 1 0 1 1 0 0 0 0 0 1 2 + 4 12 4 13 1 2 2 4 2 22 3 2 1 1 1 0 0 1 0 1 0 0 1 0 1 + 4 24 3 7 5 5 4 4 3 54 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 2 9 2 15 5 2 3 2 1 35 3 1 1 1 1 1 0 1 0 0 1 1 0 0 1 + 4 24 4 16 1 5 3 4 4 54 3 2 2 1 1 0 0 1 0 0 0 0 0 1 1 + 2 18 4 18 1 5 2 4 1 48 1 2 1 2 1 0 0 0 0 1 0 0 1 0 1 + 1 20 4 43 1 5 2 4 2 24 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 12 4 10 5 5 3 4 3 35 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 12 2 75 5 1 2 2 1 24 3 1 1 1 1 1 0 1 0 1 0 1 0 0 1 + 1 36 2 93 1 4 3 1 3 24 3 1 1 2 1 1 0 1 0 0 1 0 0 1 2 + 2 6 2 6 1 2 4 3 1 26 3 1 1 1 2 0 0 1 0 0 1 0 1 0 1 + 4 12 4 9 5 5 3 4 1 65 3 4 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 42 1 93 1 1 3 2 4 55 1 1 1 2 1 0 1 1 0 0 0 0 0 0 1 + 2 15 0 18 1 2 2 1 1 26 3 2 1 1 1 1 0 1 0 1 0 1 0 0 2 + 2 8 2 9 1 2 4 2 1 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 2 6 2 5 1 4 4 3 1 28 1 1 1 1 1 0 0 0 0 0 1 0 1 0 1 + 1 36 4 96 1 4 3 4 3 24 3 2 1 2 1 0 1 1 0 0 1 0 0 1 2 + 1 48 2 31 1 3 3 4 3 54 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 48 2 39 1 4 3 4 4 46 3 1 2 1 1 1 0 1 0 0 0 0 0 1 2 + 2 36 3 74 1 3 2 2 2 54 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 + 4 6 2 13 3 3 1 4 1 62 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 6 4 16 1 4 2 2 3 24 3 2 1 2 1 0 0 1 0 1 0 0 0 1 1 + 1 36 2 159 1 1 1 3 3 43 3 1 1 1 1 0 0 0 1 0 1 0 0 0 1 + 1 18 2 13 1 3 4 3 1 26 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 12 2 11 1 3 4 2 1 27 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 3 12 2 30 1 3 4 1 3 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 36 2 27 1 5 3 2 2 41 1 1 2 1 1 0 0 1 0 0 1 0 0 1 2 + 1 8 4 7 1 5 3 4 1 47 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 + 4 18 4 38 1 2 1 2 3 35 3 2 1 2 1 0 0 1 0 0 1 0 0 0 1 + 1 21 4 16 1 5 4 3 3 30 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 1 18 4 40 1 5 2 4 1 33 1 3 1 2 1 1 0 1 0 1 0 0 0 1 2 + 4 18 0 42 1 3 3 2 3 36 2 2 2 1 1 0 0 1 0 0 1 0 0 1 2 + 1 36 2 83 5 5 3 4 4 47 3 1 1 1 1 0 1 1 0 0 0 0 0 1 2 + 2 48 3 67 5 3 3 4 4 38 3 1 2 2 1 0 0 1 0 0 0 0 0 1 1 + 4 24 3 24 3 3 3 2 3 44 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 + 1 18 2 12 1 2 2 3 3 23 3 1 1 2 1 1 0 1 0 1 0 0 0 1 2 + 1 45 0 118 1 5 3 4 3 29 3 2 1 1 1 0 0 1 0 1 0 0 0 1 2 + 2 24 2 51 5 5 2 4 3 42 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 3 15 2 23 1 2 2 3 1 25 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 1 12 0 11 1 3 3 4 3 48 1 2 1 1 1 1 0 1 0 0 1 0 0 1 2 + 4 12 2 9 5 3 2 2 3 21 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 4 2 6 1 2 2 3 1 23 3 1 2 1 1 0 0 1 0 1 0 0 1 0 1 + 1 24 4 30 1 5 3 4 2 63 3 2 1 2 1 0 1 1 0 0 1 0 0 1 1 + 4 24 4 26 1 5 4 3 1 46 3 2 1 1 1 0 0 0 1 0 1 0 0 1 1 + 1 36 2 52 1 4 3 2 2 29 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 21 3 30 1 3 3 2 1 28 2 2 1 1 1 0 1 1 0 0 1 0 1 0 1 + 4 18 2 19 1 2 2 4 1 23 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 24 1 16 1 4 3 4 3 50 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 34 1 5 3 4 2 47 1 3 2 2 1 0 0 1 0 0 1 0 0 1 1 + 2 21 2 40 5 4 3 3 3 35 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 18 2 68 5 3 3 4 3 68 3 2 1 1 1 1 0 1 0 1 0 0 0 1 2 + 4 24 2 12 1 2 4 2 1 28 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 9 2 14 1 4 3 4 1 59 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 2 7 1 5 3 4 1 57 2 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 1 20 4 22 1 3 4 2 2 33 1 2 1 1 2 1 0 0 0 1 0 0 0 1 2 + 4 24 4 40 5 4 3 4 2 43 3 2 1 2 1 0 1 1 0 0 1 0 0 1 1 + 4 15 4 15 1 3 3 4 4 35 3 2 1 2 1 0 0 1 0 0 0 0 0 1 1 + 1 18 1 14 1 4 3 4 4 32 3 2 2 1 1 1 0 1 0 0 0 0 1 0 2 + 4 36 3 109 1 5 3 2 3 45 3 2 2 2 1 1 0 1 0 0 1 0 0 1 1 + 4 24 2 15 2 2 4 3 1 33 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 10 2 9 5 4 2 3 2 40 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 15 4 33 1 3 3 2 4 28 3 1 1 2 1 0 0 1 0 0 0 0 0 1 1 + 1 15 2 40 1 3 2 2 2 29 3 1 1 2 1 1 0 1 0 0 1 0 0 1 2 + 4 9 2 36 2 3 3 2 1 26 3 1 2 1 2 1 0 0 0 1 0 0 0 1 1 + 4 24 4 58 4 3 3 2 1 27 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 + 4 18 3 22 1 3 4 2 3 28 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 1 24 2 24 1 2 2 4 1 35 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 27 4 45 4 2 3 2 1 32 2 2 2 2 1 0 0 1 0 0 1 0 1 0 1 + 4 10 2 22 1 3 3 2 1 25 1 1 1 1 1 0 0 1 0 1 0 0 1 0 2 + 4 15 2 22 3 3 2 4 3 20 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 1 18 2 24 1 2 2 1 3 27 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 12 4 33 1 5 3 4 2 42 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 36 2 74 5 5 3 2 2 37 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 2 7 1 5 2 4 2 24 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 4 36 3 77 3 4 2 4 3 40 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 3 6 4 13 1 5 3 4 1 46 3 2 2 1 2 1 0 1 0 0 1 0 0 1 1 + 1 24 4 14 2 4 3 1 1 26 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 15 2 9 5 2 2 1 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 12 2 36 1 3 3 2 2 29 3 1 2 1 1 0 0 0 1 0 1 0 1 0 1 + 2 11 4 13 4 3 2 4 3 40 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 18 1 19 1 2 3 4 4 36 1 1 1 2 1 0 0 0 1 0 0 0 0 0 1 + 4 36 2 36 1 5 3 2 3 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 9 2 14 1 2 3 2 4 27 3 1 1 2 1 1 0 1 0 0 0 0 0 0 2 + 4 30 4 67 5 4 3 3 2 36 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 2 78 1 4 3 3 3 38 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 4 24 2 93 5 3 1 4 4 48 3 1 1 2 1 0 1 1 0 0 0 0 0 1 1 + 2 30 4 22 5 5 3 4 1 36 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 18 4 11 1 1 2 4 3 65 3 2 1 1 1 0 0 1 0 0 1 1 0 0 1 + 2 24 2 41 1 4 1 3 3 43 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 1 12 2 8 1 2 2 4 2 53 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 24 4 28 5 4 3 3 4 34 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 + 2 48 2 157 1 3 3 2 3 23 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 36 4 66 1 5 3 4 3 34 3 2 1 2 1 1 0 1 0 0 1 0 0 0 1 + 4 28 1 78 5 2 3 4 1 40 1 2 2 2 1 0 1 0 0 1 0 0 0 1 1 + 1 27 4 24 1 5 3 4 3 43 2 4 2 2 1 0 0 1 0 0 1 0 0 0 1 + 4 15 4 18 1 5 3 4 3 46 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 12 4 22 1 3 3 4 2 38 1 2 1 1 2 1 0 1 0 0 1 0 1 0 1 + 2 36 4 58 1 3 3 4 3 34 3 2 1 2 1 0 1 1 0 0 1 0 0 1 1 + 4 18 4 12 5 3 3 3 2 29 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 36 3 89 5 4 3 2 3 31 2 1 2 2 1 0 1 1 0 0 1 0 0 0 1 + 1 21 2 26 1 2 2 4 2 28 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 + 4 12 4 16 4 4 2 2 2 35 3 1 1 1 2 0 0 1 0 0 1 0 0 1 1 + 4 15 2 22 5 4 2 4 1 33 1 1 1 1 1 0 0 1 0 1 0 0 1 0 1 + 1 18 2 42 1 3 3 3 3 42 3 1 1 1 1 0 0 0 1 0 1 0 0 1 2 + 1 16 4 26 1 5 3 4 2 43 1 1 1 2 1 1 0 0 0 1 0 0 0 1 2 + 4 20 4 35 5 2 1 4 1 44 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 36 4 105 5 5 3 4 4 42 3 2 1 1 1 0 1 1 0 0 0 0 0 1 1 + 4 15 2 14 5 3 4 2 1 40 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 4 24 2 13 1 5 3 1 1 36 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 1 12 2 11 1 3 3 2 1 20 3 1 2 2 1 0 0 1 0 1 0 0 0 0 1 + 1 21 2 38 5 4 3 2 1 24 3 1 1 1 2 1 0 0 1 0 1 0 1 0 1 + 2 36 2 37 5 3 4 2 3 27 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 15 3 36 1 2 2 2 2 46 3 2 1 1 1 0 1 1 0 0 1 0 1 0 1 + 2 9 2 32 5 3 2 2 1 33 3 1 1 1 1 1 0 1 0 0 1 0 1 0 1 + 4 36 3 45 1 3 2 4 1 34 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 24 4 47 1 2 2 4 3 25 1 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 2 30 2 30 5 5 2 4 3 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 11 2 21 4 5 1 2 1 28 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 24 1 32 1 3 3 2 2 31 3 1 1 2 1 0 0 1 0 1 0 0 0 1 2 + 2 48 0 184 1 3 2 2 2 32 1 1 1 2 2 0 0 1 0 0 1 0 0 0 2 + 4 10 2 28 2 3 3 2 1 32 3 1 2 1 1 0 1 0 1 0 1 0 0 1 1 + 1 6 2 149 1 5 3 4 4 68 1 1 1 2 1 1 0 1 0 0 1 0 0 0 2 + 1 24 2 24 2 1 1 1 2 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 1 24 2 33 1 5 3 2 2 39 3 1 1 2 1 0 0 1 0 1 0 0 0 0 2 + 4 18 4 18 1 3 2 2 4 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 48 3 127 3 4 3 1 3 37 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 1 9 2 14 1 2 2 4 2 22 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 + 2 12 2 20 1 4 3 4 2 30 3 1 2 2 1 1 0 1 0 1 0 0 0 1 1 + 1 24 1 69 1 2 1 1 2 55 1 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 1 12 1 7 1 2 3 2 3 46 1 2 1 2 1 1 0 1 0 0 1 0 0 1 2 + 1 18 4 10 1 2 2 4 2 21 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 + 1 48 2 103 1 4 3 4 4 39 2 3 2 2 1 0 1 1 0 0 0 0 0 1 2 + 4 30 2 19 5 5 3 4 3 58 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 1 12 3 13 1 3 3 2 1 43 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 + 1 24 2 17 1 2 3 1 2 24 3 1 1 1 2 0 0 0 1 0 1 0 1 0 1 + 2 9 2 17 1 2 2 2 3 22 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 + 4 9 4 12 1 3 3 1 1 30 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 12 4 5 3 5 3 4 2 42 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 + 1 12 2 15 1 3 2 1 3 23 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 30 3 19 2 2 3 3 4 30 2 2 1 1 1 0 0 1 0 0 1 0 0 0 2 + 3 9 2 7 1 3 2 2 1 28 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 + 2 6 2 21 1 2 4 3 3 30 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 + 2 60 2 63 1 3 3 4 4 42 3 1 1 1 1 0 0 1 0 0 0 0 0 1 2 + 4 24 4 68 5 3 3 4 2 46 3 2 2 2 1 0 1 1 0 0 1 0 0 0 1 + 4 12 2 35 5 2 3 3 2 45 3 1 2 2 1 1 0 1 0 0 1 0 0 0 1 + 4 10 2 15 1 3 3 2 1 31 3 1 2 1 2 1 0 1 0 0 1 0 1 0 1 + 4 24 2 9 5 4 3 2 3 31 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 4 4 4 15 1 4 3 1 1 42 3 3 2 1 1 1 0 1 0 0 1 0 1 0 1 + 1 15 2 18 1 2 2 1 2 46 3 1 1 1 1 0 0 0 0 1 0 0 0 1 1 + 2 48 0 84 3 2 2 1 3 30 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 1 24 1 33 3 2 3 4 4 30 3 1 2 2 1 0 0 1 0 0 0 0 0 1 2 + 4 12 2 29 5 1 3 4 4 38 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 + 4 18 2 15 1 2 4 1 2 43 3 1 2 1 1 0 0 0 1 0 1 0 1 0 2 + 4 24 2 36 2 5 3 4 3 31 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 + 2 18 4 36 1 1 4 3 3 40 3 3 2 2 1 0 0 1 0 0 1 1 0 0 1 + 1 36 3 21 1 4 3 1 3 24 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 + 2 24 2 41 3 2 2 4 3 28 3 1 1 1 1 0 1 1 0 1 0 0 0 1 2 + 4 36 2 110 1 1 2 2 3 26 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 + 1 12 2 19 1 3 2 4 2 29 3 1 1 2 1 1 0 0 0 0 1 0 0 1 1 + 1 24 4 12 4 5 2 4 2 57 3 2 1 2 1 0 0 1 0 1 0 0 0 0 1 + 3 30 4 37 5 5 3 4 2 49 2 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 9 4 12 1 5 3 4 1 37 3 3 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 28 2 40 1 3 3 2 3 45 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 + 2 24 2 31 2 5 3 4 4 30 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 + 4 6 4 17 1 5 4 2 1 30 3 2 1 1 1 0 0 1 0 1 0 0 0 1 1 + 2 21 3 24 1 3 1 4 2 47 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 15 2 36 5 3 3 2 4 29 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 + 4 24 2 24 3 5 3 2 3 35 1 2 1 2 1 0 0 1 0 0 1 0 0 1 2 + 2 6 2 5 1 2 4 1 2 22 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 30 2 17 5 3 2 1 3 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 2 27 4 25 3 3 3 2 2 23 3 2 1 1 1 0 0 1 0 0 1 0 1 0 2 + 4 15 2 36 1 5 2 2 3 54 1 1 1 2 1 0 0 1 0 1 0 0 0 0 1 + 4 42 2 72 5 4 4 4 2 29 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 + 1 11 4 39 1 3 3 2 1 40 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 + 2 15 2 15 2 3 3 2 1 22 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 + 4 24 2 74 1 3 3 4 2 43 3 1 2 1 1 1 0 1 0 0 1 0 1 0 1 + 1 24 1 12 1 1 2 4 4 29 3 2 1 1 1 1 0 0 1 1 0 1 0 0 2 + 1 60 2 73 1 5 3 4 4 36 3 1 1 1 1 0 0 0 1 1 0 0 0 1 2 + 4 30 4 28 1 3 2 2 3 33 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 + 3 24 2 13 3 3 2 3 3 57 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 2 6 2 8 1 3 2 3 1 64 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 + 2 18 3 24 5 5 3 2 2 42 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 24 3 25 1 5 3 4 3 47 3 2 2 1 1 1 0 1 0 0 1 0 1 0 2 + 2 15 1 13 2 3 4 2 2 25 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 + 2 30 4 84 1 4 3 2 2 49 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 + 4 48 2 48 1 1 3 2 3 33 1 1 1 2 1 0 0 1 0 1 0 0 0 0 2 + 3 21 2 29 2 3 2 1 3 28 1 1 1 2 1 1 0 1 0 0 1 0 0 0 1 + 1 36 2 82 1 3 3 2 2 26 3 1 2 1 1 0 1 1 0 0 1 0 0 1 2 + 4 24 4 20 1 4 3 2 2 30 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 15 4 14 1 3 2 3 2 25 3 2 1 1 1 0 0 1 0 1 0 0 0 1 1 + 3 42 0 63 1 2 1 1 2 33 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 + 4 13 2 14 2 1 2 4 1 64 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 24 2 66 1 1 3 2 4 29 3 1 1 2 1 0 1 1 0 0 0 0 0 0 1 + 2 24 4 17 1 5 3 2 2 48 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 + 4 12 4 36 5 2 3 1 2 37 3 2 2 1 1 0 0 1 0 0 1 0 1 0 1 + 4 15 1 16 2 5 3 4 3 34 1 1 2 1 1 0 0 1 0 0 1 0 1 0 1 + 1 18 2 19 5 4 4 4 3 23 3 2 1 1 1 0 0 1 0 1 0 0 1 0 1 + 1 36 2 40 1 1 3 3 2 30 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 + 4 12 2 24 5 5 3 3 3 50 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 + 4 12 2 17 1 4 2 4 1 31 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 + 1 30 2 39 1 3 1 4 2 40 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 + 4 12 2 8 1 5 3 4 3 38 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 + 1 45 2 18 1 3 3 4 4 23 3 1 1 2 1 0 0 1 0 0 0 0 0 1 2 + 2 45 4 46 2 1 3 4 3 27 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 diff --git a/docs/source/tutorials/sklearn_svc.ipynb b/docs/source/tutorials/sklearn_svc.ipynb index 4d187215..9b978886 100644 --- a/docs/source/tutorials/sklearn_svc.ipynb +++ b/docs/source/tutorials/sklearn_svc.ipynb @@ -45,7 +45,6 @@ "from sklearn.svm import SVC\n", "from sklearn import metrics\n", "from time import time\n", - "from math import ceil, sqrt\n", "\n", "K = tc.set_backend(\"tensorflow\")" ] @@ -121,20 +120,16 @@ "outputs": [], "source": [ "def quantumTran(inputs):\n", - " size = len(inputs)\n", - " size_1d = ceil(sqrt(size))\n", - " c = tc.Circuit(size_1d)\n", - " cnot_start_first = size_1d % 2\n", - " for i in range(size_1d):\n", + " c = tc.Circuit(5)\n", + " for i in range(5):\n", " if i%2 == 0:\n", - " for j in range(size_1d):\n", - " c.rx(j, theta=(0 if i*size_1d+j >= size else inputs[i*size_1d+j]))\n", - " else:\n", - " for j in range(size_1d):\n", - " c.rz(j, theta=(0 if i*size_1d+j >= size else inputs[i*size_1d+j]))\n", - " if (cnot_start_first+i)%2 != 0:\n", - " for j in range(size_1d-1):\n", + " for j in range(5):\n", + " c.rx(j, theta=(0 if i*5+j >= 25 else inputs[i*5+j]))\n", + " for j in range(4):\n", " c.cnot(j, j+1)\n", + " else:\n", + " for j in range(5):\n", + " c.rz(j, theta=(0 if i*5+j >= 25 else inputs[i*5+j]))\n", " return c.state()\n", "\n", "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" @@ -171,7 +166,7 @@ " y_qt = K.convert_to_tensor([quantumTran(x1)])\n", " else:\n", " y_qt = K.concat([y_qt,[quantumTran(x1)]],0)\n", - " data_ret = K.cast(K.power(x_qt @ K.transpose(y_qt), 2), \"float32\")\n", + " data_ret = K.cast(K.power(K.abs(x_qt @ K.transpose(y_qt)), 2), \"float32\")\n", " return data_ret\n", " clf = SVC(kernel=kernel)\n", " clf.fit(data_x, data_y)\n", @@ -220,21 +215,19 @@ "text": [ "\n", "Accuracy:(linear as kernel) 0.79\n", - "time: 0.009181022644042969 seconds\n", + "time: 0.009650945663452148 seconds\n", "\n", "Accuracy:(poly as kernel) 0.77\n", - "time: 0.011379241943359375 seconds\n", + "time: 0.010898828506469727 seconds\n", "\n", "Accuracy:(rbf as kernel) 0.775\n", - "time: 0.012501955032348633 seconds\n", + "time: 0.012045145034790039 seconds\n", "\n", "Accuracy:(sigmoid as kernel) 0.565\n", - "time: 0.01753401756286621 seconds\n", + "time: 0.01863694190979004 seconds\n", "\n", - "WARNING:tensorflow:You are casting an input of type complex64 to an incompatible dtype float32. This will discard the imaginary part and may not be what you intended.\n", - "WARNING:tensorflow:You are casting an input of type complex64 to an incompatible dtype float32. This will discard the imaginary part and may not be what you intended.\n", - "Accuracy:(qml as kernel) 0.625\n", - "time: 6.15038275718689 seconds\n" + "Accuracy:(qml as kernel) 0.635\n", + "time: 6.367200136184692 seconds\n" ] } ], diff --git a/docs/source/tutorials/sklearn_svc_cn.ipynb b/docs/source/tutorials/sklearn_svc_cn.ipynb index a5799c27..e68cdad8 100644 --- a/docs/source/tutorials/sklearn_svc_cn.ipynb +++ b/docs/source/tutorials/sklearn_svc_cn.ipynb @@ -45,7 +45,6 @@ "from sklearn.svm import SVC\n", "from sklearn import metrics\n", "from time import time\n", - "from math import ceil, sqrt\n", "\n", "K = tc.set_backend(\"tensorflow\")" ] @@ -121,20 +120,16 @@ "outputs": [], "source": [ "def quantumTran(inputs):\n", - " size = len(inputs)\n", - " size_1d = ceil(sqrt(size))\n", - " c = tc.Circuit(size_1d)\n", - " cnot_start_first = size_1d % 2\n", - " for i in range(size_1d):\n", + " c = tc.Circuit(5)\n", + " for i in range(5):\n", " if i%2 == 0:\n", - " for j in range(size_1d):\n", - " c.rx(j, theta=(0 if i*size_1d+j >= size else inputs[i*size_1d+j]))\n", - " else:\n", - " for j in range(size_1d):\n", - " c.rz(j, theta=(0 if i*size_1d+j >= size else inputs[i*size_1d+j]))\n", - " if (cnot_start_first+i)%2 != 0:\n", - " for j in range(size_1d-1):\n", + " for j in range(5):\n", + " c.rx(j, theta=(0 if i*5+j >= 25 else inputs[i*5+j]))\n", + " for j in range(4):\n", " c.cnot(j, j+1)\n", + " else:\n", + " for j in range(5):\n", + " c.rz(j, theta=(0 if i*5+j >= 25 else inputs[i*5+j]))\n", " return c.state()\n", "\n", "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" @@ -171,7 +166,7 @@ " y_qt = K.convert_to_tensor([quantumTran(x1)])\n", " else:\n", " y_qt = K.concat([y_qt,[quantumTran(x1)]],0)\n", - " data_ret = K.cast(K.power(x_qt @ K.transpose(y_qt), 2), \"float32\")\n", + " data_ret = K.cast(K.power(K.abs(x_qt @ K.transpose(y_qt)), 2), \"float32\")\n", " return data_ret\n", " clf = SVC(kernel=kernel)\n", " clf.fit(data_x, data_y)\n", @@ -220,21 +215,19 @@ "text": [ "\n", "Accuracy:(linear as kernel) 0.79\n", - "time: 0.009181022644042969 seconds\n", + "time: 0.009594917297363281 seconds\n", "\n", "Accuracy:(poly as kernel) 0.77\n", - "time: 0.011379241943359375 seconds\n", + "time: 0.010785818099975586 seconds\n", "\n", "Accuracy:(rbf as kernel) 0.775\n", - "time: 0.012501955032348633 seconds\n", + "time: 0.012056112289428711 seconds\n", "\n", "Accuracy:(sigmoid as kernel) 0.565\n", - "time: 0.01753401756286621 seconds\n", + "time: 0.017444133758544922 seconds\n", "\n", - "WARNING:tensorflow:You are casting an input of type complex64 to an incompatible dtype float32. This will discard the imaginary part and may not be what you intended.\n", - "WARNING:tensorflow:You are casting an input of type complex64 to an incompatible dtype float32. This will discard the imaginary part and may not be what you intended.\n", - "Accuracy:(qml as kernel) 0.625\n", - "time: 6.15038275718689 seconds\n" + "Accuracy:(qml as kernel) 0.635\n", + "time: 6.606667995452881 seconds\n" ] } ], From b00279638c93044748c4ed74560a92ef180b6ff0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Jul 2023 15:20:13 +0800 Subject: [PATCH 547/725] add circuit cop --- CHANGELOG.md | 6 ++++++ docs/source/quickstart.rst | 2 ++ tensorcircuit/abstractcircuit.py | 5 +++++ tensorcircuit/basecircuit.py | 10 +++++----- tensorcircuit/densitymatrix.py | 4 ++-- tensorcircuit/results/counts.py | 2 ++ tests/test_circuit.py | 9 +++++++++ 7 files changed, 31 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9fd51e43..93bceb03 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,12 @@ - Add keras3 example showcasing integration with tc +- Add circuit copy method that avoid shallow copy issue `Circuit.copy()` + +### Changed + +- The static method `BaseCircuit.copy` is renamed as `BaseCircuit.copy_nodes` + ## 0.10.0 ### Added diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index 9767d08f..8257434b 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -148,6 +148,8 @@ The IR is given as a list, each element is a dict containing information on one >>> c.to_qir() [{'gate': cnot, 'index': (0, 1), 'name': 'cnot', 'split': None}, {'gate': crx, 'index': (1, 0), 'name': 'crx', 'split': None, 'parameters': {'theta': 0.2}}] +We can also create new copied circuit via ``c.copy()`` which internally utilize the ``qir``. + Programming Paradigm ------------------------- diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index c7c47aff..46c549c9 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -1172,6 +1172,11 @@ def append( self.__dict__.update(newc.__dict__) return self + def copy(self) -> "AbstractCircuit": + qir = self.to_qir() + c = type(self).from_qir(qir, self.circuit_param) + return c + def expectation( self, *ops: Tuple[tn.Node, List[int]], diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index bad32b0f..65eac8d8 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -81,7 +81,7 @@ def coloring_copied_nodes( node.id = getattr(n0, "id", id(n0)) @staticmethod - def copy( + def copy_nodes( nodes: Sequence[tn.Node], dangling: Optional[Sequence[tn.Edge]] = None, conj: Optional[bool] = False, @@ -111,7 +111,7 @@ def copy( def _copy( self, conj: Optional[bool] = False ) -> Tuple[List[tn.Node], List[tn.Edge]]: - return self.copy(self._nodes, self._front, conj) + return self.copy_nodes(self._nodes, self._front, conj) def apply_general_gate( self, @@ -171,7 +171,7 @@ def apply_general_gate( self._front[index[0]] = n1[0] self._front[index[1]] = n2[1] if self.is_dm: - [n1l, n2l], _ = self.copy([n1, n2], conj=True) + [n1l, n2l], _ = self.copy_nodes([n1, n2], conj=True) n1l[1] ^ self._front[index[0] + nq] n2l[2] ^ self._front[index[1] + nq] self._nodes.append(n1l) @@ -186,7 +186,7 @@ def apply_general_gate( self._front[index[0]] = n1[0] self._front[index[1]] = n2[1] if self.is_dm: - [n1l, n2l], _ = self.copy([n1, n2], conj=True) + [n1l, n2l], _ = self.copy_nodes([n1, n2], conj=True) n2l[1] ^ self._front[index[0] + nq] n1l[2] ^ self._front[index[1] + nq] self._nodes.append(n1l) @@ -203,7 +203,7 @@ def apply_general_gate( # gate.id = id(gate) self._nodes.append(gate) if self.is_dm: - lgates, _ = self.copy([gate], conj=True) + lgates, _ = self.copy_nodes([gate], conj=True) lgate = lgates[0] self._nodes.append(lgate) for i, ind in enumerate(index): diff --git a/tensorcircuit/densitymatrix.py b/tensorcircuit/densitymatrix.py index ec0277a6..e70197dc 100644 --- a/tensorcircuit/densitymatrix.py +++ b/tensorcircuit/densitymatrix.py @@ -86,7 +86,7 @@ def __init__( for i, n in enumerate(mps_nodes): mps_nodes[i].tensor = backend.cast(n.tensor, dtypestr) # type: ignore mps_edges = mps_inputs.out_edges + mps_inputs.in_edges - self._nodes, self._front = self.copy(mps_nodes, mps_edges) + self._nodes, self._front = self.copy_nodes(mps_nodes, mps_edges) self.coloring_nodes(self._nodes) self._double_nodes_front() @@ -131,7 +131,7 @@ def __init__( self._extra_qir: List[Dict[str, Any]] = [] def _double_nodes_front(self) -> None: - lnodes, lfront = self.copy(self._nodes, self._front, conj=True) + lnodes, lfront = self.copy_nodes(self._nodes, self._front, conj=True) self._front.extend(lfront) self._nodes.extend(lnodes) diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index 37d5a9d7..9611ee4b 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -9,6 +9,8 @@ Tensor = Any ct = Dict[str, int] +# TODO(@refraction-ray): merge_count + def reverse_count(count: ct) -> ct: ncount = {} diff --git a/tests/test_circuit.py b/tests/test_circuit.py index c50508f4..04ba7cb2 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1627,3 +1627,12 @@ def test_general_kraus_with_prob(backend): np.testing.assert_allclose(rs[0][1], [0.25, 0.25, 0.5], atol=1e-5) np.testing.assert_allclose(rs[1][1], [0.25, 0.25, 0.5], atol=1e-5) np.testing.assert_allclose(tc.backend.norm(c.state()), 1, atol=1e-5) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("npb")]) +def test_circuit_copy(backend): + c = tc.Circuit(2) + c.h(0) + c1 = c.copy() + c.rz(0, theta=0.1) + assert c1.gate_count() == 1 From d0836f113493c11d381c85c9946e23517aeae708 Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Fri, 14 Jul 2023 15:25:27 +0800 Subject: [PATCH 548/725] fixed according advice --- docs/source/quickstart.rst | 2 +- docs/source/tutorial.rst | 4 ++-- docs/source/tutorials/sklearn_svc.ipynb | 2 +- docs/source/tutorials/sklearn_svc_cn.ipynb | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst index c3b3131f..4f54a289 100644 --- a/docs/source/quickstart.rst +++ b/docs/source/quickstart.rst @@ -29,7 +29,7 @@ For more details on docker setup, please refer to `docker readme `_ or `TC via WSL `_. -- For MacOS, please refer to `TC on Mac `_ or `在Mac上安装TC `_. +- For MacOS, please refer to `TC on Mac `_. Overall, the installation of TensorCircuit is simple, since it is purely in Python and hence very portable. As long as the users can take care of the installation of ML frameworks on the corresponding system, TensorCircuit will work as expected. diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index 8d5105c2..ec6a3744 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -24,5 +24,5 @@ Jupyter Tutorials tutorials/barren_plateaus.ipynb tutorials/qaoa_portfolio_optimization.ipynb tutorials/imag_time_evo.ipynb - tutorials/qcloud_sdk_demo.ipynb - tutorials/sklearn_svc.ipynb \ No newline at end of file + tutorials/sklearn_svc.ipynb + tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file diff --git a/docs/source/tutorials/sklearn_svc.ipynb b/docs/source/tutorials/sklearn_svc.ipynb index 9b978886..b0045221 100644 --- a/docs/source/tutorials/sklearn_svc.ipynb +++ b/docs/source/tutorials/sklearn_svc.ipynb @@ -9,7 +9,7 @@ "Authored by [_Mark (Zixuan) Song_](https://marksong.tech)\n", "- - -\n", "\n", - "In order to improve the simplicity of code, I used the SKLearn library to implement SVC." + "We use the `SKLearn` library to implement `SVC` in the following tutorial." ] }, { diff --git a/docs/source/tutorials/sklearn_svc_cn.ipynb b/docs/source/tutorials/sklearn_svc_cn.ipynb index e68cdad8..241cfc35 100644 --- a/docs/source/tutorials/sklearn_svc_cn.ipynb +++ b/docs/source/tutorials/sklearn_svc_cn.ipynb @@ -9,7 +9,7 @@ "[_Mark (Zixuan) Song_](https://marksong.tech) 撰写\n", "- - -\n", "\n", - "为代码简洁，本示例结合了`sklearn`库中的`SVC`类，实现了支持向量分类。" + "本示例结合了`sklearn`库中的`SVC`类，实现了支持向量分类。" ] }, { From e29f878d7c5a1040719c3b77f79eeeb9b08501ea Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Fri, 14 Jul 2023 16:12:24 +0800 Subject: [PATCH 549/725] updated .po file for translated install guide --- docs/source/locale/zh/LC_MESSAGES/api.po | 3981 ++++++++++++----- docs/source/locale/zh/LC_MESSAGES/contribs.po | 366 +- .../locale/zh/LC_MESSAGES/quickstart.po | 687 +-- 3 files changed, 3553 insertions(+), 1481 deletions(-) diff --git a/docs/source/locale/zh/LC_MESSAGES/api.po b/docs/source/locale/zh/LC_MESSAGES/api.po index c3ed832b..b7958e1e 100644 --- a/docs/source/locale/zh/LC_MESSAGES/api.po +++ b/docs/source/locale/zh/LC_MESSAGES/api.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-05-10 22:01+0800\n" +"POT-Creation-Date: 2023-07-14 15:43+0800\n" "PO-Revision-Date: 2022-04-13 14:58+0800\n" "Last-Translator: Xinghan Yang\n" "Language: cn\n" @@ -16,7 +16,7 @@ msgstr "" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" -"Generated-By: Babel 2.9.1\n" +"Generated-By: Babel 2.12.1\n" #: ../../source/api/about.rst:2 msgid "tensorcircuit.about" @@ -65,45 +65,55 @@ msgstr "" msgid "example" msgstr "" -#: keras.engine.base_layer.Layer.add_loss -#: keras.engine.base_layer.Layer.add_metric -#: keras.engine.base_layer.Layer.add_update -#: keras.engine.base_layer.Layer.add_weight keras.engine.base_layer.Layer.apply -#: keras.engine.base_layer.Layer.build -#: keras.engine.base_layer.Layer.compute_mask -#: keras.engine.base_layer.Layer.compute_output_shape -#: keras.engine.base_layer.Layer.compute_output_signature -#: keras.engine.base_layer.Layer.from_config -#: keras.engine.base_layer.Layer.get_input_at -#: keras.engine.base_layer.Layer.get_input_mask_at -#: keras.engine.base_layer.Layer.get_input_shape_at -#: keras.engine.base_layer.Layer.get_losses_for -#: keras.engine.base_layer.Layer.get_output_at -#: keras.engine.base_layer.Layer.get_output_mask_at -#: keras.engine.base_layer.Layer.get_output_shape_at -#: keras.engine.base_layer.Layer.get_updates_for -#: keras.engine.base_layer.Layer.set_weights keras.engine.training.Model.build -#: keras.engine.training.Model.compile keras.engine.training.Model.evaluate -#: keras.engine.training.Model.fit keras.engine.training.Model.from_config -#: keras.engine.training.Model.get_layer -#: keras.engine.training.Model.load_weights -#: keras.engine.training.Model.make_predict_function -#: keras.engine.training.Model.make_test_function -#: keras.engine.training.Model.make_train_function -#: keras.engine.training.Model.predict -#: keras.engine.training.Model.predict_on_batch -#: keras.engine.training.Model.predict_step keras.engine.training.Model.save -#: keras.engine.training.Model.save_weights keras.engine.training.Model.summary -#: keras.engine.training.Model.test_on_batch -#: keras.engine.training.Model.test_step keras.engine.training.Model.to_json -#: keras.engine.training.Model.to_yaml -#: keras.engine.training.Model.train_on_batch -#: keras.engine.training.Model.train_step -#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config +#: keras.src.engine.base_layer.Layer.add_loss +#: keras.src.engine.base_layer.Layer.add_metric +#: keras.src.engine.base_layer.Layer.add_update +#: keras.src.engine.base_layer.Layer.add_weight +#: keras.src.engine.base_layer.Layer.build +#: keras.src.engine.base_layer.Layer.build_from_config +#: keras.src.engine.base_layer.Layer.compute_mask +#: keras.src.engine.base_layer.Layer.compute_output_shape +#: keras.src.engine.base_layer.Layer.compute_output_signature +#: keras.src.engine.base_layer.Layer.from_config +#: keras.src.engine.base_layer.Layer.get_input_at +#: keras.src.engine.base_layer.Layer.get_input_mask_at +#: keras.src.engine.base_layer.Layer.get_input_shape_at +#: keras.src.engine.base_layer.Layer.get_output_at +#: keras.src.engine.base_layer.Layer.get_output_mask_at +#: keras.src.engine.base_layer.Layer.get_output_shape_at +#: keras.src.engine.base_layer.Layer.load_own_variables +#: keras.src.engine.base_layer.Layer.save_own_variables +#: keras.src.engine.base_layer.Layer.set_weights +#: keras.src.engine.training.Model.build +#: keras.src.engine.training.Model.compile +#: keras.src.engine.training.Model.compile_from_config +#: keras.src.engine.training.Model.compute_loss +#: keras.src.engine.training.Model.compute_metrics +#: keras.src.engine.training.Model.evaluate +#: keras.src.engine.training.Model.export keras.src.engine.training.Model.fit +#: keras.src.engine.training.Model.from_config +#: keras.src.engine.training.Model.get_layer +#: keras.src.engine.training.Model.load_weights +#: keras.src.engine.training.Model.make_predict_function +#: keras.src.engine.training.Model.make_test_function +#: keras.src.engine.training.Model.make_train_function +#: keras.src.engine.training.Model.predict +#: keras.src.engine.training.Model.predict_on_batch +#: keras.src.engine.training.Model.predict_step +#: keras.src.engine.training.Model.save +#: keras.src.engine.training.Model.save_weights +#: keras.src.engine.training.Model.summary +#: keras.src.engine.training.Model.test_on_batch +#: keras.src.engine.training.Model.test_step +#: keras.src.engine.training.Model.to_json +#: keras.src.engine.training.Model.to_yaml +#: keras.src.engine.training.Model.train_on_batch +#: keras.src.engine.training.Model.train_step +#: keras.src.optimizers.schedules.learning_rate_schedule.LearningRateSchedule.from_config #: of tensorcircuit.abstractcircuit.AbstractCircuit.append #: tensorcircuit.abstractcircuit.AbstractCircuit.append_from_qir -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list #: tensorcircuit.abstractcircuit.AbstractCircuit.barrier_instruction #: tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement #: tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps @@ -601,6 +611,7 @@ msgstr "" #: tensorcircuit.densitymatrix.DMCircuit.expectation #: tensorcircuit.densitymatrix.DMCircuit.to_circuit #: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply +#: tensorcircuit.experimental.evol_global tensorcircuit.experimental.evol_local #: tensorcircuit.experimental.hamiltonian_evol #: tensorcircuit.experimental.parameter_shift_grad #: tensorcircuit.experimental.parameter_shift_grad_v2 @@ -693,6 +704,12 @@ msgstr "" #: tensorcircuit.quantum.truncated_free_energy tensorcircuit.quantum.xyz2ps #: tensorcircuit.results.counts.expectation #: tensorcircuit.results.counts.plot_histogram +#: tensorcircuit.results.qem.qem_methods.add_dd +#: tensorcircuit.results.qem.qem_methods.apply_dd +#: tensorcircuit.results.qem.qem_methods.apply_rc +#: tensorcircuit.results.qem.qem_methods.apply_zne +#: tensorcircuit.results.qem.qem_methods.prune_ddcircuit +#: tensorcircuit.results.qem.qem_methods.used_qubits #: tensorcircuit.results.readout_mitigation.ReadoutMit.__init__ #: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_correction #: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_readout_mitigation @@ -710,7 +727,6 @@ msgstr "" #: tensorcircuit.templates.blocks.example_block #: tensorcircuit.templates.blocks.qft #: tensorcircuit.templates.blocks.state_centric -#: tensorcircuit.templates.chems.get_ps #: tensorcircuit.templates.graphs.Grid2DCoord.__init__ #: tensorcircuit.templates.graphs.Grid2DCoord.all_cols #: tensorcircuit.templates.graphs.Grid2DCoord.all_rows @@ -816,7 +832,6 @@ msgstr "" #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sign #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.slice -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace #: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator #: tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality @@ -871,39 +886,44 @@ msgid "" "means plain concatenation." msgstr "" -#: keras.engine.base_layer.Layer.add_weight keras.engine.base_layer.Layer.apply -#: keras.engine.base_layer.Layer.compute_mask -#: keras.engine.base_layer.Layer.compute_output_shape -#: keras.engine.base_layer.Layer.compute_output_signature -#: keras.engine.base_layer.Layer.count_params -#: keras.engine.base_layer.Layer.from_config -#: keras.engine.base_layer.Layer.get_config -#: keras.engine.base_layer.Layer.get_input_at -#: keras.engine.base_layer.Layer.get_input_mask_at -#: keras.engine.base_layer.Layer.get_input_shape_at -#: keras.engine.base_layer.Layer.get_losses_for -#: keras.engine.base_layer.Layer.get_output_at -#: keras.engine.base_layer.Layer.get_output_mask_at -#: keras.engine.base_layer.Layer.get_output_shape_at -#: keras.engine.base_layer.Layer.get_updates_for -#: keras.engine.base_layer.Layer.get_weights -#: keras.engine.training.Model.evaluate keras.engine.training.Model.fit -#: keras.engine.training.Model.from_config -#: keras.engine.training.Model.get_config keras.engine.training.Model.get_layer -#: keras.engine.training.Model.get_weights -#: keras.engine.training.Model.load_weights -#: keras.engine.training.Model.make_predict_function -#: keras.engine.training.Model.make_test_function -#: keras.engine.training.Model.make_train_function -#: keras.engine.training.Model.predict -#: keras.engine.training.Model.predict_on_batch -#: keras.engine.training.Model.predict_step -#: keras.engine.training.Model.test_on_batch -#: keras.engine.training.Model.test_step keras.engine.training.Model.to_json -#: keras.engine.training.Model.to_yaml -#: keras.engine.training.Model.train_on_batch -#: keras.engine.training.Model.train_step -#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config +#: keras.src.engine.base_layer.Layer.add_weight +#: keras.src.engine.base_layer.Layer.compute_mask +#: keras.src.engine.base_layer.Layer.compute_output_shape +#: keras.src.engine.base_layer.Layer.compute_output_signature +#: keras.src.engine.base_layer.Layer.count_params +#: keras.src.engine.base_layer.Layer.from_config +#: keras.src.engine.base_layer.Layer.get_build_config +#: keras.src.engine.base_layer.Layer.get_config +#: keras.src.engine.base_layer.Layer.get_input_at +#: keras.src.engine.base_layer.Layer.get_input_mask_at +#: keras.src.engine.base_layer.Layer.get_input_shape_at +#: keras.src.engine.base_layer.Layer.get_output_at +#: keras.src.engine.base_layer.Layer.get_output_mask_at +#: keras.src.engine.base_layer.Layer.get_output_shape_at +#: keras.src.engine.base_layer.Layer.get_weights +#: keras.src.engine.training.Model.compute_loss +#: keras.src.engine.training.Model.compute_metrics +#: keras.src.engine.training.Model.evaluate keras.src.engine.training.Model.fit +#: keras.src.engine.training.Model.from_config +#: keras.src.engine.training.Model.get_compile_config +#: keras.src.engine.training.Model.get_config +#: keras.src.engine.training.Model.get_layer +#: keras.src.engine.training.Model.get_metrics_result +#: keras.src.engine.training.Model.get_weight_paths +#: keras.src.engine.training.Model.get_weights +#: keras.src.engine.training.Model.make_predict_function +#: keras.src.engine.training.Model.make_test_function +#: keras.src.engine.training.Model.make_train_function +#: keras.src.engine.training.Model.predict +#: keras.src.engine.training.Model.predict_on_batch +#: keras.src.engine.training.Model.predict_step +#: keras.src.engine.training.Model.test_on_batch +#: keras.src.engine.training.Model.test_step +#: keras.src.engine.training.Model.to_json +#: keras.src.engine.training.Model.to_yaml +#: keras.src.engine.training.Model.train_on_batch +#: keras.src.engine.training.Model.train_step +#: keras.src.optimizers.schedules.learning_rate_schedule.LearningRateSchedule.from_config #: of tensorcircuit.abstractcircuit.AbstractCircuit.append #: tensorcircuit.abstractcircuit.AbstractCircuit.cond_measurement #: tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps @@ -1540,6 +1560,7 @@ msgstr "" #: tensorcircuit.densitymatrix.DMCircuit.get_dm_as_quoperator #: tensorcircuit.densitymatrix.DMCircuit.to_circuit #: tensorcircuit.densitymatrix.DMCircuit.wavefunction +#: tensorcircuit.experimental.evol_global tensorcircuit.experimental.evol_local #: tensorcircuit.experimental.hamiltonian_evol #: tensorcircuit.experimental.parameter_shift_grad #: tensorcircuit.experimental.parameter_shift_grad_v2 @@ -1664,6 +1685,12 @@ msgstr "" #: tensorcircuit.quantum.truncated_free_energy tensorcircuit.quantum.xyz2ps #: tensorcircuit.results.counts.expectation #: tensorcircuit.results.counts.plot_histogram +#: tensorcircuit.results.qem.qem_methods.add_dd +#: tensorcircuit.results.qem.qem_methods.apply_dd +#: tensorcircuit.results.qem.qem_methods.apply_rc +#: tensorcircuit.results.qem.qem_methods.apply_zne +#: tensorcircuit.results.qem.qem_methods.prune_ddcircuit +#: tensorcircuit.results.qem.qem_methods.used_qubits #: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_readout_mitigation #: tensorcircuit.results.readout_mitigation.ReadoutMit.expectation #: tensorcircuit.results.readout_mitigation.ReadoutMit.get_matrix @@ -1679,7 +1706,6 @@ msgstr "" #: tensorcircuit.templates.blocks.example_block #: tensorcircuit.templates.blocks.qft #: tensorcircuit.templates.blocks.state_centric -#: tensorcircuit.templates.chems.get_ps #: tensorcircuit.templates.graphs.Grid2DCoord.all_cols #: tensorcircuit.templates.graphs.Grid2DCoord.all_rows #: tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph @@ -1824,7 +1850,6 @@ msgstr "" #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.shape_tuple #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.subtraction #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.transpose #: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator @@ -2324,6 +2349,7 @@ msgstr "" #: tensorcircuit.densitymatrix.DMCircuit.get_dm_as_quoperator #: tensorcircuit.densitymatrix.DMCircuit.to_circuit #: tensorcircuit.densitymatrix.DMCircuit.wavefunction +#: tensorcircuit.experimental.evol_global tensorcircuit.experimental.evol_local #: tensorcircuit.experimental.hamiltonian_evol #: tensorcircuit.experimental.parameter_shift_grad #: tensorcircuit.experimental.parameter_shift_grad_v2 @@ -2414,6 +2440,12 @@ msgstr "" #: tensorcircuit.quantum.truncated_free_energy tensorcircuit.quantum.xyz2ps #: tensorcircuit.results.counts.expectation #: tensorcircuit.results.counts.plot_histogram +#: tensorcircuit.results.qem.qem_methods.add_dd +#: tensorcircuit.results.qem.qem_methods.apply_dd +#: tensorcircuit.results.qem.qem_methods.apply_rc +#: tensorcircuit.results.qem.qem_methods.apply_zne +#: tensorcircuit.results.qem.qem_methods.prune_ddcircuit +#: tensorcircuit.results.qem.qem_methods.used_qubits #: tensorcircuit.results.readout_mitigation.ReadoutMit.apply_readout_mitigation #: tensorcircuit.results.readout_mitigation.ReadoutMit.expectation #: tensorcircuit.results.readout_mitigation.ReadoutMit.get_matrix @@ -2429,7 +2461,6 @@ msgstr "" #: tensorcircuit.templates.blocks.example_block #: tensorcircuit.templates.blocks.qft #: tensorcircuit.templates.blocks.state_centric -#: tensorcircuit.templates.chems.get_ps #: tensorcircuit.templates.graphs.Grid2DCoord.all_cols #: tensorcircuit.templates.graphs.Grid2DCoord.all_rows #: tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph @@ -2508,7 +2539,6 @@ msgstr "" #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.inv #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.random_uniform #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.sum -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace #: tensornetwork.matrixproductstates.base_mps.BaseMPS.apply_transfer_operator #: tensornetwork.matrixproductstates.base_mps.BaseMPS.check_orthonormality @@ -2632,6 +2662,8 @@ msgid "add a barrier instruction flag, no effect on numerical simulation" msgstr "" #: of tensorcircuit.abstractcircuit.AbstractCircuit.barrier_instruction:3 +#: tensorcircuit.abstractcircuit.AbstractCircuit.measure_instruction:3 +#: tensorcircuit.abstractcircuit.AbstractCircuit.reset_instruction:3 msgid "the corresponding qubits" msgstr "" @@ -2682,6 +2714,7 @@ msgid "" "Visualise the circuit. This method recevies the keywords as same as " "qiskit.circuit.QuantumCircuit.draw. More details can be found here: " "https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.draw.html." +" Interesting kws options include: ``idle_wires``(bool)" msgstr "" #: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:1 @@ -2706,10 +2739,17 @@ msgid "sites to apply Z gate, defaults to None" msgstr "" #: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:32 +msgid "" +"or one can apply a ps structures instead of ``x``, ``y``, ``z``, e.g. [0," +" 1, 3, 0, 2, 2] for X_1Z_2Y_4Y_5 defaults to None, ``ps`` can overwrite " +"``x``, ``y`` and ``z``" +msgstr "" + +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:36 msgid "whether to cache and reuse the wavefunction, defaults to True" msgstr "" -#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:34 +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:38 #: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:46 #: tensorcircuit.circuit.Circuit.expectation:32 #: tensorcircuit.densitymatrix.DMCircuit.expectation:8 @@ -2718,7 +2758,7 @@ msgstr "" msgid "Noise Configuration, defaults to None" msgstr "" -#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:36 +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:40 #: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:48 #: tensorcircuit.circuit.Circuit.expectation:34 #: tensorcircuit.noisemodel.expectation_noisfy:7 @@ -2727,7 +2767,7 @@ msgid "" " to 1000" msgstr "" -#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:38 +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:42 #: tensorcircuit.basecircuit.BaseCircuit.sample_expectation_ps:50 #: tensorcircuit.circuit.Circuit.expectation:36 #: tensorcircuit.densitymatrix.DMCircuit.expectation:10 @@ -2738,7 +2778,7 @@ msgid "" "None, used for noisfy circuit sampling" msgstr "" -#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:41 +#: of tensorcircuit.abstractcircuit.AbstractCircuit.expectation_ps:45 msgid "Expectation value" msgstr "" @@ -2815,6 +2855,12 @@ msgstr "" #: tensorcircuit.cloud.apis.set_token:13 #: tensorcircuit.cons.runtime_contractor:3 #: tensorcircuit.cons.set_function_contractor:3 +#: tensorcircuit.experimental.evol_global:4 +#: tensorcircuit.experimental.evol_global:9 +#: tensorcircuit.experimental.evol_global:11 +#: tensorcircuit.experimental.evol_local:4 +#: tensorcircuit.experimental.evol_local:6 +#: tensorcircuit.experimental.evol_local:13 #: tensorcircuit.experimental.hamiltonian_evol:4 #: tensorcircuit.experimental.hamiltonian_evol:6 #: tensorcircuit.experimental.hamiltonian_evol:8 tensorcircuit.gates.u_gate:16 @@ -2824,8 +2870,8 @@ msgstr "" #: tensorcircuit.quantum.ps2xyz:7 tensorcircuit.quantum.sample2count:3 #: tensorcircuit.quantum.sample2count:5 tensorcircuit.quantum.sample2count:9 #: tensorcircuit.quantum.xyz2ps:3 tensorcircuit.quantum.xyz2ps:7 -#: tensorcircuit.results.counts.plot_histogram:4 #: tensorcircuit.results.counts.plot_histogram:6 +#: tensorcircuit.results.counts.plot_histogram:8 #: tensorcircuit.templates.graphs.Grid2DCoord.lattice_graph:6 #: tensorcircuit.translation.eqasm2tc:3 tensorcircuit.translation.eqasm2tc:9 #: tensorcircuit.translation.qir2json:3 tensorcircuit.translation.qir2json:8 @@ -3006,11 +3052,6 @@ msgstr "" msgid "add a measurement instruction flag, no effect on numerical simulation" msgstr "" -#: of tensorcircuit.abstractcircuit.AbstractCircuit.measure_instruction:3 -#: tensorcircuit.abstractcircuit.AbstractCircuit.reset_instruction:3 -msgid "the corresponding qubit" -msgstr "" - #: of tensorcircuit.abstractcircuit.AbstractCircuit.prepend:1 msgid "prepend circuit ``c`` before" msgstr "" @@ -3766,7 +3807,7 @@ msgstr "" #: of tensorcircuit.applications.van.MADE:1 #: tensorcircuit.applications.van.NMF:1 #: tensorcircuit.applications.van.PixelCNN:1 -msgid "Bases: :py:class:`~keras.engine.training.Model`" +msgid "Bases: :py:class:`~keras.src.engine.training.Model`" msgstr "" #: of tensorcircuit.applications.van.MADE.activity_regularizer:1 @@ -3781,11 +3822,11 @@ msgstr "" msgid "Optional regularizer function for the output of this layer." msgstr "" -#: keras.engine.base_layer.Layer.add_loss:1 of +#: keras.src.engine.base_layer.Layer.add_loss:1 of msgid "Add loss tensor(s), potentially dependent on layer inputs." msgstr "" -#: keras.engine.base_layer.Layer.add_loss:3 of +#: keras.src.engine.base_layer.Layer.add_loss:3 of msgid "" "Some losses (for instance, activity regularization losses) may be " "dependent on the inputs passed when calling a layer. Hence, when reusing " @@ -3794,16 +3835,19 @@ msgid "" "automatically keeps track of dependencies." msgstr "" -#: keras.engine.base_layer.Layer.add_loss:9 of +#: keras.src.engine.base_layer.Layer.add_loss:9 of msgid "" "This method can be used inside a subclassed layer or model's `call` " "function, in which case `losses` should be a Tensor or list of Tensors." msgstr "" -#: keras.engine.base_layer.Layer.add_loss:12 -#: keras.engine.base_layer.Layer.add_loss:26 -#: keras.engine.base_layer.Layer.add_loss:42 -#: keras.engine.training.Model.compile:3 keras.engine.training.Model.save:28 of +#: keras.src.engine.base_layer.Layer.add_loss:12 +#: keras.src.engine.base_layer.Layer.add_loss:32 +#: keras.src.engine.base_layer.Layer.add_loss:48 +#: keras.src.engine.training.Model.compile:3 +#: keras.src.engine.training.Model.export:15 +#: keras.src.engine.training.Model.get_weight_paths:18 +#: keras.src.engine.training.Model.save:38 of #: tensorcircuit.applications.van.MaskedConv2D.metrics:3 #: tensorcircuit.applications.van.MaskedLinear.metrics:3 #: tensorcircuit.applications.van.ResidualBlock.metrics:3 @@ -3813,22 +3857,24 @@ msgstr "" msgid "Example:" msgstr "" -#: keras.engine.base_layer.Layer.add_loss:14 of +#: keras.src.engine.base_layer.Layer.add_loss:14 of msgid "```python class MyLayer(tf.keras.layers.Layer):" msgstr "" -#: keras.engine.base_layer.Layer.add_loss:17 -#: keras.engine.base_layer.Layer.add_metric:14 of +#: keras.src.engine.base_layer.Layer.add_loss:17 +#: keras.src.engine.base_layer.Layer.add_metric:14 +#: keras.src.engine.training.Model.get_weight_paths:30 of msgid "def call(self, inputs):" msgstr "" -#: keras.engine.base_layer.Layer.add_loss:17 of +#: keras.src.engine.base_layer.Layer.add_loss:17 of msgid "self.add_loss(tf.abs(tf.reduce_mean(inputs))) return inputs" msgstr "" -#: keras.engine.base_layer.Layer.add_loss:19 -#: keras.engine.base_layer.Layer.add_metric:16 -#: keras.engine.training.Model.compile:10 of +#: keras.src.engine.base_layer.Layer.add_loss:19 +#: keras.src.engine.base_layer.Layer.add_metric:16 +#: keras.src.engine.training.Model.compile:10 +#: keras.src.engine.training.Model.compute_metrics:21 of #: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:21 #: tensornetwork.backends.jax.jax_backend.JaxBackend.eigs:35 #: tensornetwork.backends.jax.jax_backend.JaxBackend.eigsh:21 @@ -3838,16 +3884,24 @@ msgstr "" msgid "```" msgstr "" -#: keras.engine.base_layer.Layer.add_loss:21 of +#: keras.src.engine.base_layer.Layer.add_loss:21 of msgid "" -"This method can also be called directly on a Functional Model during " -"construction. In this case, any loss Tensors passed to this Model must be" -" symbolic and be able to be traced back to the model's `Input`s. These " -"losses become part of the model's topology and are tracked in " +"The same code works in distributed training: the input to `add_loss()` is" +" treated like a regularization loss and averaged across replicas by the " +"training loop (both built-in `Model.fit()` and compliant custom training " +"loops)." +msgstr "" + +#: keras.src.engine.base_layer.Layer.add_loss:26 of +msgid "" +"The `add_loss` method can also be called directly on a Functional Model " +"during construction. In this case, any loss Tensors passed to this Model " +"must be symbolic and be able to be traced back to the model's `Input`s. " +"These losses become part of the model's topology and are tracked in " "`get_config`." msgstr "" -#: keras.engine.base_layer.Layer.add_loss:28 of +#: keras.src.engine.base_layer.Layer.add_loss:34 of msgid "" "```python inputs = tf.keras.Input(shape=(10,)) x = " "tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Dense(1)(x) " @@ -3855,7 +3909,7 @@ msgid "" "model.add_loss(tf.abs(tf.reduce_mean(x))) ```" msgstr "" -#: keras.engine.base_layer.Layer.add_loss:37 of +#: keras.src.engine.base_layer.Layer.add_loss:43 of msgid "" "If this is not the case for your loss (if, for example, your loss " "references a `Variable` of one of the model's layers), you can wrap your " @@ -3863,7 +3917,7 @@ msgid "" "the model's topology since they can't be serialized." msgstr "" -#: keras.engine.base_layer.Layer.add_loss:44 of +#: keras.src.engine.base_layer.Layer.add_loss:50 of msgid "" "```python inputs = tf.keras.Input(shape=(10,)) d = " "tf.keras.layers.Dense(10) x = d(inputs) outputs = " @@ -3872,57 +3926,47 @@ msgid "" "```" msgstr "" -#: keras.engine.base_layer.Layer.add_loss:54 of +#: keras.src.engine.base_layer.Layer.add_loss:60 of msgid "" "Loss tensor, or list/tuple of tensors. Rather than tensors, losses may " "also be zero-argument callables which create a loss tensor." msgstr "" -#: keras.engine.base_layer.Layer.add_loss:56 of -msgid "" -"Additional keyword arguments for backward compatibility. Accepted values:" -" inputs - Deprecated, will be automatically inferred." -msgstr "" - -#: keras.engine.base_layer.Layer.add_loss:56 of -msgid "Additional keyword arguments for backward compatibility. Accepted values:" -msgstr "" - -#: keras.engine.base_layer.Layer.add_loss:58 of -msgid "inputs - Deprecated, will be automatically inferred." +#: keras.src.engine.base_layer.Layer.add_loss:63 of +msgid "Used for backwards compatibility only." msgstr "" -#: keras.engine.base_layer.Layer.add_metric:1 of +#: keras.src.engine.base_layer.Layer.add_metric:1 of msgid "Adds metric tensor to the layer." msgstr "" -#: keras.engine.base_layer.Layer.add_metric:3 of +#: keras.src.engine.base_layer.Layer.add_metric:3 of msgid "" "This method can be used inside the `call()` method of a subclassed layer " "or model." msgstr "" -#: keras.engine.base_layer.Layer.add_metric:6 of +#: keras.src.engine.base_layer.Layer.add_metric:6 of msgid "```python class MyMetricLayer(tf.keras.layers.Layer):" msgstr "" -#: keras.engine.base_layer.Layer.add_metric:10 of +#: keras.src.engine.base_layer.Layer.add_metric:10 of msgid "def __init__(self):" msgstr "" -#: keras.engine.base_layer.Layer.add_metric:9 of +#: keras.src.engine.base_layer.Layer.add_metric:9 of msgid "" "super(MyMetricLayer, self).__init__(name='my_metric_layer') self.mean = " "tf.keras.metrics.Mean(name='metric_1')" msgstr "" -#: keras.engine.base_layer.Layer.add_metric:13 of +#: keras.src.engine.base_layer.Layer.add_metric:13 of msgid "" "self.add_metric(self.mean(inputs)) self.add_metric(tf.reduce_sum(inputs)," " name='metric_2') return inputs" msgstr "" -#: keras.engine.base_layer.Layer.add_metric:18 of +#: keras.src.engine.base_layer.Layer.add_metric:18 of msgid "" "This method can also be called directly on a Functional Model during " "construction. In this case, any tensor passed to this Model must be " @@ -3931,7 +3975,7 @@ msgid "" " the model via `save()`." msgstr "" -#: keras.engine.base_layer.Layer.add_metric:24 of +#: keras.src.engine.base_layer.Layer.add_metric:24 of msgid "" "```python inputs = tf.keras.Input(shape=(10,)) x = " "tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Dense(1)(x) " @@ -3939,7 +3983,7 @@ msgid "" "model.add_metric(math_ops.reduce_sum(x), name='metric_1') ```" msgstr "" -#: keras.engine.base_layer.Layer.add_metric:32 of +#: keras.src.engine.base_layer.Layer.add_metric:32 of msgid "" "Note: Calling `add_metric()` with the result of a metric object on a " "Functional Model, as shown in the example below, is not supported. This " @@ -3947,7 +3991,7 @@ msgid "" "inputs." msgstr "" -#: keras.engine.base_layer.Layer.add_metric:36 of +#: keras.src.engine.base_layer.Layer.add_metric:37 of msgid "" "```python inputs = tf.keras.Input(shape=(10,)) x = " "tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Dense(1)(x) " @@ -3955,15 +3999,15 @@ msgid "" "model.add_metric(tf.keras.metrics.Mean()(x), name='metric_1') ```" msgstr "" -#: keras.engine.base_layer.Layer.add_metric:44 of +#: keras.src.engine.base_layer.Layer.add_metric:45 of msgid "Metric tensor." msgstr "" -#: keras.engine.base_layer.Layer.add_metric:45 of +#: keras.src.engine.base_layer.Layer.add_metric:46 of msgid "String metric name." msgstr "" -#: keras.engine.base_layer.Layer.add_metric:46 of +#: keras.src.engine.base_layer.Layer.add_metric:47 of msgid "" "Additional keyword arguments for backward compatibility. Accepted values:" " `aggregation` - When the `value` tensor provided is not the result of " @@ -3971,11 +4015,11 @@ msgid "" " a `keras.Metric.Mean`." msgstr "" -#: keras.engine.base_layer.Layer.add_update:1 of +#: keras.src.engine.base_layer.Layer.add_update:1 of msgid "Add update op(s), potentially dependent on layer inputs." msgstr "" -#: keras.engine.base_layer.Layer.add_update:3 of +#: keras.src.engine.base_layer.Layer.add_update:3 of msgid "" "Weight updates (for instance, the updates of the moving mean and variance" " in a BatchNormalization layer) may be dependent on the inputs passed " @@ -3985,14 +4029,14 @@ msgid "" "dependencies." msgstr "" -#: keras.engine.base_layer.Layer.add_update:10 of +#: keras.src.engine.base_layer.Layer.add_update:10 of msgid "" "This call is ignored when eager execution is enabled (in that case, " "variable updates are run on the fly and thus do not need to be tracked " "for later execution)." msgstr "" -#: keras.engine.base_layer.Layer.add_update:14 of +#: keras.src.engine.base_layer.Layer.add_update:14 of msgid "" "Update op, or list/tuple of update ops, or zero-arg callable that returns" " an update op. A zero-arg callable should be passed in order to disable " @@ -4000,39 +4044,35 @@ msgid "" "executing in Eager mode." msgstr "" -#: keras.engine.base_layer.Layer.add_update:18 of -msgid "Deprecated, will be automatically inferred." -msgstr "" - -#: keras.engine.base_layer.Layer.add_variable:1 of +#: keras.src.engine.base_layer.Layer.add_variable:1 of msgid "Deprecated, do NOT use! Alias for `add_weight`." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:1 of +#: keras.src.engine.base_layer.Layer.add_weight:1 of msgid "Adds a new variable to the layer." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:3 of +#: keras.src.engine.base_layer.Layer.add_weight:3 of msgid "Variable name." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:4 of +#: keras.src.engine.base_layer.Layer.add_weight:4 of msgid "Variable shape. Defaults to scalar if unspecified." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:5 of +#: keras.src.engine.base_layer.Layer.add_weight:5 of msgid "The type of the variable. Defaults to `self.dtype`." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:6 of +#: keras.src.engine.base_layer.Layer.add_weight:6 of msgid "Initializer instance (callable)." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:7 of +#: keras.src.engine.base_layer.Layer.add_weight:7 of msgid "Regularizer instance (callable)." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:8 of +#: keras.src.engine.base_layer.Layer.add_weight:8 of msgid "" "Boolean, whether the variable should be part of the layer's " "\"trainable_variables\" (e.g. variables, biases) or " @@ -4040,15 +4080,28 @@ msgid "" " `trainable` cannot be `True` if `synchronization` is set to `ON_READ`." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:13 of +#: keras.src.engine.base_layer.Layer.add_weight:13 of msgid "Constraint instance (callable)." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:14 of -msgid "Whether to use `ResourceVariable`." +#: keras.src.engine.base_layer.Layer.add_weight:14 of +msgid "" +"Whether to use a `ResourceVariable` or not. See [this guide]( " +"https://www.tensorflow.org/guide/migrate/tf1_vs_tf2#resourcevariables_instead_of_referencevariables)" +" for more information." +msgstr "" + +#: keras.src.engine.base_layer.Layer.add_weight:14 of +msgid "" +"Whether to use a `ResourceVariable` or not. See [this guide]( " +"https://www.tensorflow.org/guide/migrate/tf1_vs_tf2#resourcevariables_instead_of_referencevariables)" +msgstr "" + +#: keras.src.engine.base_layer.Layer.add_weight:17 of +msgid "for more information." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:15 of +#: keras.src.engine.base_layer.Layer.add_weight:18 of msgid "" "Indicates when a distributed a variable will be aggregated. Accepted " "values are constants defined in the class `tf.VariableSynchronization`. " @@ -4057,37 +4110,39 @@ msgid "" "is set to `ON_READ`, `trainable` must not be set to `True`." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:21 of +#: keras.src.engine.base_layer.Layer.add_weight:24 of msgid "" "Indicates how a distributed variable will be aggregated. Accepted values " "are constants defined in the class `tf.VariableAggregation`." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:24 of +#: keras.src.engine.base_layer.Layer.add_weight:27 of msgid "" "Additional keyword arguments. Accepted values are `getter`, " "`collections`, `experimental_autocast` and `caching_device`." msgstr "" -#: keras.engine.base_layer.Layer.add_weight:27 of +#: keras.src.engine.base_layer.Layer.add_weight:30 of msgid "The variable created." msgstr "" -#: keras.engine.base_layer.Layer.add_weight -#: keras.engine.base_layer.Layer.compute_output_signature -#: keras.engine.base_layer.Layer.count_params -#: keras.engine.base_layer.Layer.get_input_at -#: keras.engine.base_layer.Layer.get_input_shape_at -#: keras.engine.base_layer.Layer.get_output_at -#: keras.engine.base_layer.Layer.get_output_shape_at -#: keras.engine.base_layer.Layer.set_weights keras.engine.training.Model.build -#: keras.engine.training.Model.evaluate keras.engine.training.Model.fit -#: keras.engine.training.Model.load_weights keras.engine.training.Model.predict -#: keras.engine.training.Model.predict_on_batch -#: keras.engine.training.Model.save_weights keras.engine.training.Model.summary -#: keras.engine.training.Model.test_on_batch -#: keras.engine.training.Model.to_yaml -#: keras.engine.training.Model.train_on_batch of +#: keras.src.engine.base_layer.Layer.add_weight +#: keras.src.engine.base_layer.Layer.compute_output_signature +#: keras.src.engine.base_layer.Layer.count_params +#: keras.src.engine.base_layer.Layer.get_input_at +#: keras.src.engine.base_layer.Layer.get_input_shape_at +#: keras.src.engine.base_layer.Layer.get_output_at +#: keras.src.engine.base_layer.Layer.get_output_shape_at +#: keras.src.engine.base_layer.Layer.set_weights +#: keras.src.engine.training.Model.build +#: keras.src.engine.training.Model.evaluate keras.src.engine.training.Model.fit +#: keras.src.engine.training.Model.predict +#: keras.src.engine.training.Model.predict_on_batch +#: keras.src.engine.training.Model.save_weights +#: keras.src.engine.training.Model.summary +#: keras.src.engine.training.Model.test_on_batch +#: keras.src.engine.training.Model.to_yaml +#: keras.src.engine.training.Model.train_on_batch of #: tensorcircuit.applications.van.MADE.input #: tensorcircuit.applications.van.MADE.input_mask #: tensorcircuit.applications.van.MADE.input_shape @@ -4170,52 +4225,23 @@ msgstr "" msgid "Raises" msgstr "" -#: keras.engine.base_layer.Layer.add_weight:29 of +#: keras.src.engine.base_layer.Layer.add_weight:32 of msgid "" "When giving unsupported dtype and no initializer or when trainable " -"has been set to True with synchronization set as `ON_READ`." -msgstr "" - -#: keras.engine.base_layer.Layer.apply:1 -#: keras.engine.base_layer.Layer.get_losses_for:1 -#: keras.engine.base_layer.Layer.get_updates_for:1 of -#: tensorcircuit.applications.van.MADE.state_updates:1 -#: tensorcircuit.applications.van.NMF.state_updates:1 -#: tensorcircuit.applications.van.PixelCNN.state_updates:1 -msgid "Deprecated, do NOT use!" -msgstr "" - -#: keras.engine.base_layer.Layer.apply:3 of -msgid "This is an alias of `self.__call__`." -msgstr "" - -#: keras.engine.base_layer.Layer.apply:5 of -msgid "Input tensor(s)." -msgstr "" - -#: keras.engine.base_layer.Layer.apply:6 of -msgid "additional positional arguments to be passed to `self.call`." +"has been set to True with synchronization set as `ON_READ`." msgstr "" -#: keras.engine.base_layer.Layer.apply:7 of -msgid "additional keyword arguments to be passed to `self.call`." -msgstr "" - -#: keras.engine.base_layer.Layer.apply:9 of -msgid "Output tensor(s)." -msgstr "" - -#: keras.engine.training.Model.build:1 of +#: keras.src.engine.training.Model.build:1 of msgid "Builds the model based on input shapes received." msgstr "" -#: keras.engine.training.Model.build:3 of +#: keras.src.engine.training.Model.build:3 of msgid "" "This is to be used for subclassed models, which do not know at " "instantiation time what their inputs look like." msgstr "" -#: keras.engine.training.Model.build:6 of +#: keras.src.engine.training.Model.build:6 of msgid "" "This method only exists for users who want to call `model.build()` in a " "standalone way (as a substitute for calling the model on real data to " @@ -4223,28 +4249,44 @@ msgid "" "never throw unexpected errors in an unrelated workflow)." msgstr "" -#: keras.engine.training.Model.build:11 of +#: keras.src.engine.training.Model.build:11 of msgid "" "Single tuple, `TensorShape` instance, or list/dict of shapes, where " "shapes are tuples, integers, or `TensorShape` instances." msgstr "" -#: keras.engine.training.Model.build:14 of +#: keras.src.engine.training.Model.build:15 of msgid "" "1. In case of invalid user-provided data (not of type tuple, list," " `TensorShape`, or dict). 2. If the model requires call arguments " "that are agnostic to the input shapes (positional or keyword arg " -"in call signature). 3. If not all layers were properly built. 4. " -"If float type inputs are not supported within the layers." +"in call signature). 3. If not all layers were properly built." +" 4. If float type inputs are not supported within the layers." msgstr "" -#: keras.engine.training.Model.build:14 of +#: keras.src.engine.training.Model.build:15 of msgid "" "In case of invalid user-provided data (not of type tuple, list, " "`TensorShape`, or dict). 2. If the model requires call arguments that" " are agnostic to the input shapes (positional or keyword arg in " -"call signature). 3. If not all layers were properly built. 4. If " -"float type inputs are not supported within the layers." +"call signature). 3. If not all layers were properly built." +" 4. If float type inputs are not supported within the layers." +msgstr "" + +#: keras.src.engine.base_layer.Layer.build_from_config:1 of +msgid "Builds the layer's states with the supplied config dict." +msgstr "" + +#: keras.src.engine.base_layer.Layer.build_from_config:3 of +msgid "" +"By default, this method calls the `build(config[\"input_shape\"])` " +"method, which creates weights based on the layer's input shape in the " +"supplied config. If your config contains other information needed to load" +" the layer's state, you should override this method." +msgstr "" + +#: keras.src.engine.base_layer.Layer.build_from_config:8 of +msgid "Dict containing the input shape associated with this layer." msgstr "" #: of tensorcircuit.applications.van.MADE.call:1 @@ -4290,24 +4332,10 @@ msgstr "" #: tensorcircuit.applications.van.PixelCNN.call:15 msgid "" "A mask or list of masks. A mask can be either a boolean tensor or None " -"(no mask). For more details, check the guide " +"(no mask). For more details, check the guide " "[here](https://www.tensorflow.org/guide/keras/masking_and_padding)." msgstr "" -#: of tensorcircuit.applications.van.MADE.call:15 -#: tensorcircuit.applications.van.NMF.call:15 -#: tensorcircuit.applications.van.PixelCNN.call:15 -msgid "" -"A mask or list of masks. A mask can be either a boolean tensor or None " -"(no mask). For more details, check the guide" -msgstr "" - -#: of tensorcircuit.applications.van.MADE.call:17 -#: tensorcircuit.applications.van.NMF.call:17 -#: tensorcircuit.applications.van.PixelCNN.call:17 -msgid "[here](https://www.tensorflow.org/guide/keras/masking_and_padding)." -msgstr "" - #: of tensorcircuit.applications.van.MADE.call:19 #: tensorcircuit.applications.van.NMF.call:19 #: tensorcircuit.applications.van.PixelCNN.call:19 @@ -4316,35 +4344,35 @@ msgid "" "more than one outputs." msgstr "" -#: keras.engine.training.Model.compile:1 of +#: keras.src.engine.training.Model.compile:1 of msgid "Configures the model for training." msgstr "" -#: keras.engine.training.Model.compile:5 of +#: keras.src.engine.training.Model.compile:5 of msgid "" "```python " "model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3)," msgstr "" -#: keras.engine.training.Model.compile:7 of +#: keras.src.engine.training.Model.compile:7 of msgid "" "loss=tf.keras.losses.BinaryCrossentropy(), " "metrics=[tf.keras.metrics.BinaryAccuracy()," msgstr "" -#: keras.engine.training.Model.compile:9 of +#: keras.src.engine.training.Model.compile:9 of msgid "tf.keras.metrics.FalseNegatives()])" msgstr "" -#: keras.engine.training.Model.compile:12 of +#: keras.src.engine.training.Model.compile:12 of msgid "" "String (name of optimizer) or optimizer instance. See " "`tf.keras.optimizers`." msgstr "" -#: keras.engine.training.Model.compile:14 of +#: keras.src.engine.training.Model.compile:14 of msgid "" -"Loss function. Maybe be a string (name of loss function), or a " +"Loss function. May be a string (name of loss function), or a " "`tf.keras.losses.Loss` instance. See `tf.keras.losses`. A loss function " "is any callable with the signature `loss = fn(y_true, y_pred)`, where " "`y_true` are the ground truth values, and `y_pred` are the model's " @@ -4361,7 +4389,7 @@ msgid "" "individual losses, unless `loss_weights` is specified." msgstr "" -#: keras.engine.training.Model.compile:34 of +#: keras.src.engine.training.Model.compile:34 of msgid "" "List of metrics to be evaluated by the model during training and testing." " Each of this can be a string (name of a built-in function), function or " @@ -4369,80 +4397,117 @@ msgid "" "you will use `metrics=['accuracy']`. A function is any callable with the " "signature `result = fn(y_true, y_pred)`. To specify different metrics for" " different outputs of a multi-output model, you could also pass a " -"dictionary, such as `metrics={'output_a': 'accuracy', 'output_b': " -"['accuracy', 'mse']}`. You can also pass a list to specify a metric or a " -"list of metrics for each output, such as `metrics=[['accuracy'], " -"['accuracy', 'mse']]` or `metrics=['accuracy', ['accuracy', 'mse']]`. " -"When you pass the strings 'accuracy' or 'acc', we convert this to one of " -"`tf.keras.metrics.BinaryAccuracy`, " +"dictionary, such as `metrics={'output_a':'accuracy', " +"'output_b':['accuracy', 'mse']}`. You can also pass a list to specify a " +"metric or a list of metrics for each output, such as " +"`metrics=[['accuracy'], ['accuracy', 'mse']]` or `metrics=['accuracy', " +"['accuracy', 'mse']]`. When you pass the strings 'accuracy' or 'acc', we " +"convert this to one of `tf.keras.metrics.BinaryAccuracy`, " "`tf.keras.metrics.CategoricalAccuracy`, " -"`tf.keras.metrics.SparseCategoricalAccuracy` based on the loss function " -"used and the model output shape. We do a similar conversion for the " -"strings 'crossentropy' and 'ce' as well." +"`tf.keras.metrics.SparseCategoricalAccuracy` based on the shapes of the " +"targets and of the model output. We do a similar conversion for the " +"strings 'crossentropy' and 'ce' as well. The metrics passed here are " +"evaluated without sample weighting; if you would like sample weighting to" +" apply, you can specify your metrics via the `weighted_metrics` argument " +"instead." msgstr "" -#: keras.engine.training.Model.compile:51 of +#: keras.src.engine.training.Model.compile:56 of msgid "" "Optional list or dictionary specifying scalar coefficients (Python " "floats) to weight the loss contributions of different model outputs. The " "loss value that will be minimized by the model will then be the *weighted" " sum* of all individual losses, weighted by the `loss_weights` " -"coefficients. If a list, it is expected to have a 1:1 mapping to the " -"model's outputs. If a dict, it is expected to map output names " -"(strings) to scalar coefficients." +"coefficients. If a list, it is expected to have a 1:1 mapping to the " +"model's outputs. If a dict, it is expected to map output names (strings) " +"to scalar coefficients." msgstr "" -#: keras.engine.training.Model.compile:51 of +#: keras.src.engine.training.Model.compile:64 of msgid "" -"Optional list or dictionary specifying scalar coefficients (Python " -"floats) to weight the loss contributions of different model outputs. The " -"loss value that will be minimized by the model will then be the *weighted" -" sum* of all individual losses, weighted by the `loss_weights` " -"coefficients." +"List of metrics to be evaluated and weighted by `sample_weight` or " +"`class_weight` during training and testing." msgstr "" -#: keras.engine.training.Model.compile:57 of -msgid "If a list, it is expected to have a 1:1 mapping to the model's" +#: keras.src.engine.training.Model.compile:66 of +msgid "" +"Bool. If `True`, this `Model`'s logic will not be wrapped in a " +"`tf.function`. Recommended to leave this as `None` unless your `Model` " +"cannot be run inside a `tf.function`. `run_eagerly=True` is not supported" +" when using `tf.distribute.experimental.ParameterServerStrategy`. " +"Defaults to `False`." msgstr "" -#: keras.engine.training.Model.compile:57 of +#: keras.src.engine.training.Model.compile:66 of msgid "" -"outputs. If a dict, it is expected to map output names (strings) to " -"scalar coefficients." +"Bool. If `True`, this `Model`'s logic will not be wrapped in a " +"`tf.function`. Recommended to leave this as `None` unless your `Model` " +"cannot be run inside a `tf.function`. `run_eagerly=True` is not supported" +" when using `tf.distribute.experimental.ParameterServerStrategy`. " +"Defaults to" +msgstr "" + +#: keras.src.engine.training.Model.compile:71 of +msgid "`False`." msgstr "" -#: keras.engine.training.Model.compile:59 of +#: keras.src.engine.training.Model.compile:72 of msgid "" -"List of metrics to be evaluated and weighted by `sample_weight` or " -"`class_weight` during training and testing." +"Int. The number of batches to run during each `tf.function` call. Running" +" multiple batches inside a single `tf.function` call can greatly improve " +"performance on TPUs or small models with a large Python overhead. At " +"most, one full epoch will be run each execution. If a number larger than " +"the size of the epoch is passed, the execution will be truncated to the " +"size of the epoch. Note that if `steps_per_execution` is set to `N`, " +"`Callback.on_batch_begin` and `Callback.on_batch_end` methods will only " +"be called every `N` batches (i.e. before/after each `tf.function` " +"execution). Defaults to `1`." msgstr "" -#: keras.engine.training.Model.compile:61 of +#: keras.src.engine.training.Model.compile:82 of msgid "" -"Bool. Defaults to `False`. If `True`, this `Model`'s logic will not be " -"wrapped in a `tf.function`. Recommended to leave this as `None` unless " -"your `Model` cannot be run inside a `tf.function`. `run_eagerly=True` is " -"not supported when using " -"`tf.distribute.experimental.ParameterServerStrategy`." +"If `True`, compile the model training step with XLA. " +"[XLA](https://www.tensorflow.org/xla) is an optimizing compiler for " +"machine learning. `jit_compile` is not enabled for by default. Note that " +"`jit_compile=True` may not necessarily work for all models. For more " +"information on supported operations please refer to the [XLA " +"documentation](https://www.tensorflow.org/xla). Also refer to [known XLA " +"issues](https://www.tensorflow.org/xla/known_issues) for more details." msgstr "" -#: keras.engine.training.Model.compile:66 of +#: keras.src.engine.training.Model.compile:93 of msgid "" -"Int. Defaults to 1. The number of batches to run during each " -"`tf.function` call. Running multiple batches inside a single " -"`tf.function` call can greatly improve performance on TPUs or small " -"models with a large Python overhead. At most, one full epoch will be run " -"each execution. If a number larger than the size of the epoch is passed, " -"the execution will be truncated to the size of the epoch. Note that if " -"`steps_per_execution` is set to `N`, `Callback.on_batch_begin` and " -"`Callback.on_batch_end` methods will only be called every `N` batches " -"(i.e. before/after each `tf.function` execution)." +"Integer or 'auto'. Used for `tf.distribute.ParameterServerStrategy` " +"training only. This arg sets the number of shards to split the dataset " +"into, to enable an exact visitation guarantee for evaluation, meaning the" +" model will be applied to each dataset element exactly once, even if " +"workers fail. The dataset must be sharded to ensure separate workers do " +"not process the same data. The number of shards should be at least the " +"number of workers for good performance. A value of 'auto' turns on exact " +"evaluation and uses a heuristic for the number of shards based on the " +"number of workers. 0, meaning no visitation guarantee is provided. NOTE: " +"Custom implementations of `Model.test_step` will be ignored when doing " +"exact evaluation. Defaults to `0`." msgstr "" -#: keras.engine.training.Model.compile:77 of +#: keras.src.engine.training.Model.compile:106 of msgid "Arguments supported for backwards compatibility only." msgstr "" +#: keras.src.engine.training.Model.compile_from_config:1 of +msgid "Compiles the model with the information given in config." +msgstr "" + +#: keras.src.engine.training.Model.compile_from_config:3 of +msgid "" +"This method uses the information in the config (optimizer, loss, metrics," +" etc.) to compile the model." +msgstr "" + +#: keras.src.engine.training.Model.compile_from_config:6 of +msgid "Dict containing information for compiling the model." +msgstr "" + #: of tensorcircuit.applications.van.MADE.compute_dtype:1 #: tensorcircuit.applications.van.MaskedConv2D.compute_dtype:1 #: tensorcircuit.applications.van.MaskedLinear.compute_dtype:1 @@ -4513,56 +4578,202 @@ msgstr "" msgid "The layer's compute dtype." msgstr "" -#: keras.engine.base_layer.Layer.compute_mask:1 of +#: keras.src.engine.training.Model.compute_loss:1 of +msgid "Compute the total loss, validate it, and return it." +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:3 of +msgid "" +"Subclasses can optionally override this method to provide custom loss " +"computation logic." +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:6 of +msgid "Example: ```python class MyModel(tf.keras.Model):" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:12 of +msgid "def __init__(self, *args, **kwargs):" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:11 of +msgid "" +"super(MyModel, self).__init__(*args, **kwargs) self.loss_tracker = " +"tf.keras.metrics.Mean(name='loss')" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:18 of +msgid "def compute_loss(self, x, y, y_pred, sample_weight):" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:15 of +msgid "" +"loss = tf.reduce_mean(tf.math.squared_difference(y_pred, y)) loss += " +"tf.add_n(self.losses) self.loss_tracker.update_state(loss) return loss" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:21 of +msgid "def reset_metrics(self):" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:21 of +msgid "self.loss_tracker.reset_states()" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:23 of +msgid "@property def metrics(self):" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:25 of +msgid "return [self.loss_tracker]" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:27 of +msgid "" +"tensors = tf.random.uniform((10, 10)), tf.random.uniform((10,)) dataset =" +" tf.data.Dataset.from_tensor_slices(tensors).repeat().batch(1)" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:30 of +msgid "" +"inputs = tf.keras.layers.Input(shape=(10,), name='my_input') outputs = " +"tf.keras.layers.Dense(10)(inputs) model = MyModel(inputs, outputs) " +"model.add_loss(tf.reduce_sum(outputs))" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:35 of +msgid "" +"optimizer = tf.keras.optimizers.SGD() model.compile(optimizer, " +"loss='mse', steps_per_execution=10) model.fit(dataset, epochs=2, " +"steps_per_epoch=10) print('My custom loss: ', " +"model.loss_tracker.result().numpy()) ```" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:41 +#: keras.src.engine.training.Model.compute_metrics:23 of +msgid "Input data." +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:42 +#: keras.src.engine.training.Model.compute_metrics:24 of +msgid "Target data." +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:43 of +msgid "Predictions returned by the model (output of `model(x)`)" +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:44 +#: keras.src.engine.training.Model.compute_metrics:26 of +msgid "Sample weights for weighting the loss function." +msgstr "" + +#: keras.src.engine.training.Model.compute_loss:46 of +msgid "" +"The total loss as a `tf.Tensor`, or `None` if no loss results (which is " +"the case when called by `Model.test_step`)." +msgstr "" + +#: keras.src.engine.base_layer.Layer.compute_mask:1 of msgid "Computes an output mask tensor." msgstr "" -#: keras.engine.base_layer.Layer.compute_mask:3 -#: keras.engine.base_layer.Layer.compute_mask:4 of +#: keras.src.engine.base_layer.Layer.compute_mask:3 +#: keras.src.engine.base_layer.Layer.compute_mask:4 of msgid "Tensor or list of tensors." msgstr "" -#: keras.engine.base_layer.Layer.compute_mask:6 of +#: keras.src.engine.base_layer.Layer.compute_mask:6 of msgid "" "None or a tensor (or list of tensors, one per output tensor of the " "layer)." msgstr "" -#: keras.engine.base_layer.Layer.compute_mask:8 of +#: keras.src.engine.base_layer.Layer.compute_mask:8 of msgid "None or a tensor (or list of tensors," msgstr "" -#: keras.engine.base_layer.Layer.compute_mask:9 of +#: keras.src.engine.base_layer.Layer.compute_mask:9 of msgid "one per output tensor of the layer)." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_shape:1 of +#: keras.src.engine.training.Model.compute_metrics:1 of +msgid "Update metric states and collect all metrics to be returned." +msgstr "" + +#: keras.src.engine.training.Model.compute_metrics:3 of +msgid "" +"Subclasses can optionally override this method to provide custom metric " +"updating and collection logic." +msgstr "" + +#: keras.src.engine.training.Model.compute_metrics:6 of +msgid "Example: ```python class MyModel(tf.keras.Sequential):" +msgstr "" + +#: keras.src.engine.training.Model.compute_metrics:10 of +msgid "def compute_metrics(self, x, y, y_pred, sample_weight):" +msgstr "" + +#: keras.src.engine.training.Model.compute_metrics:12 of +msgid "" +"# This super call updates `self.compiled_metrics` and returns # results " +"for all metrics listed in `self.metrics`. metric_results = super(MyModel," +" self).compute_metrics(" +msgstr "" + +#: keras.src.engine.training.Model.compute_metrics:15 of +msgid "x, y, y_pred, sample_weight)" +msgstr "" + +#: keras.src.engine.training.Model.compute_metrics:17 of +msgid "" +"# Note that `self.custom_metric` is not listed in `self.metrics`. " +"self.custom_metric.update_state(x, y, y_pred, sample_weight) " +"metric_results['custom_metric_name'] = self.custom_metric.result() return" +" metric_results" +msgstr "" + +#: keras.src.engine.training.Model.compute_metrics:25 of +msgid "Predictions returned by the model (output of `model.call(x)`)" +msgstr "" + +#: keras.src.engine.training.Model.compute_metrics:28 of +msgid "" +"A `dict` containing values that will be passed to " +"`tf.keras.callbacks.CallbackList.on_train_batch_end()`. Typically, the " +"values of the metrics listed in `self.metrics` are returned. Example: " +"`{'loss': 0.2, 'accuracy': 0.7}`." +msgstr "" + +#: keras.src.engine.base_layer.Layer.compute_output_shape:1 of msgid "Computes the output shape of the layer." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_shape:3 of +#: keras.src.engine.base_layer.Layer.compute_output_shape:3 of msgid "" -"If the layer has not been built, this method will call `build` on the " -"layer. This assumes that the layer will later be used with inputs that " -"match the input shape provided here." +"This method will cause the layer's state to be built, if that has not " +"happened before. This requires that the layer will later be used with " +"inputs that match the input shape provided here." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_shape:7 of +#: keras.src.engine.base_layer.Layer.compute_output_shape:7 of msgid "" -"Shape tuple (tuple of integers) or list of shape tuples (one per output " -"tensor of the layer). Shape tuples can include None for free dimensions, " -"instead of an integer." +"Shape tuple (tuple of integers) or `tf.TensorShape`, or structure of " +"shape tuples / `tf.TensorShape` instances (one per output tensor of the " +"layer). Shape tuples can include None for free dimensions, instead of an " +"integer." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_shape:12 of -msgid "An input shape tuple." +#: keras.src.engine.base_layer.Layer.compute_output_shape:13 of +msgid "A `tf.TensorShape` instance or structure of `tf.TensorShape` instances." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_signature:1 of +#: keras.src.engine.base_layer.Layer.compute_output_signature:1 of msgid "Compute the output tensor signature of the layer based on the inputs." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_signature:3 of +#: keras.src.engine.base_layer.Layer.compute_output_signature:3 of msgid "" "Unlike a TensorShape object, a TensorSpec object contains both shape and " "dtype information for a tensor. This method allows layers to provide " @@ -4572,44 +4783,59 @@ msgid "" "matches the input dtype." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_signature:10 of +#: keras.src.engine.base_layer.Layer.compute_output_signature:10 of msgid "" "Single TensorSpec or nested structure of TensorSpec objects, describing a" " candidate input for the layer." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_signature:13 of +#: keras.src.engine.base_layer.Layer.compute_output_signature:13 of msgid "" -"Single TensorSpec or nested structure of TensorSpec objects, describing" -" how the layer would transform the provided input." +"Single TensorSpec or nested structure of TensorSpec objects, describing" +" how the layer would transform the provided input." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_signature:16 of -msgid "Single TensorSpec or nested structure of TensorSpec objects, describing" +#: keras.src.engine.base_layer.Layer.compute_output_signature:16 of +msgid "Single TensorSpec or nested structure of TensorSpec objects," msgstr "" -#: keras.engine.base_layer.Layer.compute_output_signature:16 of -msgid "how the layer would transform the provided input." +#: keras.src.engine.base_layer.Layer.compute_output_signature:16 of +msgid "describing how the layer would transform the provided input." msgstr "" -#: keras.engine.base_layer.Layer.compute_output_signature:18 of +#: keras.src.engine.base_layer.Layer.compute_output_signature:18 of msgid "If input_signature contains a non-TensorSpec object." msgstr "" -#: keras.engine.base_layer.Layer.count_params:1 of +#: keras.src.engine.base_layer.Layer.count_params:1 of msgid "Count the total number of scalars composing the weights." msgstr "" -#: keras.engine.base_layer.Layer.count_params:3 of +#: keras.src.engine.base_layer.Layer.count_params:3 of msgid "An integer count." msgstr "" -#: keras.engine.base_layer.Layer.count_params:5 of +#: keras.src.engine.base_layer.Layer.count_params:5 of msgid "" "if the layer isn't yet built (in which case its weights aren't yet " "defined)." msgstr "" +#: of tensorcircuit.applications.van.MADE.distribute_reduction_method:1 +#: tensorcircuit.applications.van.NMF.distribute_reduction_method:1 +#: tensorcircuit.applications.van.PixelCNN.distribute_reduction_method:1 +msgid "The method employed to reduce per-replica values during training." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.distribute_reduction_method:3 +#: tensorcircuit.applications.van.NMF.distribute_reduction_method:3 +#: tensorcircuit.applications.van.PixelCNN.distribute_reduction_method:3 +msgid "" +"Unless specified, the value \"auto\" will be assumed, indicating that the" +" reduction strategy should be chosen based on the current running " +"environment. See `reduce_per_replica` function for more details." +msgstr "" + #: of tensorcircuit.applications.van.MADE.distribute_strategy:1 #: tensorcircuit.applications.van.NMF.distribute_strategy:1 #: tensorcircuit.applications.van.PixelCNN.distribute_strategy:1 @@ -4679,15 +4905,15 @@ msgstr "" msgid "Whether the layer is dynamic (eager-only); set in the constructor." msgstr "" -#: keras.engine.training.Model.evaluate:1 of +#: keras.src.engine.training.Model.evaluate:1 of msgid "Returns the loss value & metrics values for the model in test mode." msgstr "" -#: keras.engine.training.Model.evaluate:3 of +#: keras.src.engine.training.Model.evaluate:3 of msgid "Computation is done in batches (see the `batch_size` arg.)" msgstr "" -#: keras.engine.training.Model.evaluate:5 of +#: keras.src.engine.training.Model.evaluate:5 of msgid "" "Input data. It could be: - A Numpy array (or array-like), or a list of " "arrays (in case the model has multiple inputs). - A TensorFlow tensor, " @@ -4695,63 +4921,67 @@ msgid "" "mapping input names to the corresponding array/tensors, if the model " "has named inputs. - A `tf.data` dataset. Should return a tuple of " "either `(inputs, targets)` or `(inputs, targets, sample_weights)`. - A " -"generator or `keras.utils.Sequence` returning `(inputs, targets)` or " +"generator or `keras.utils.Sequence` returning `(inputs, targets)` or " "`(inputs, targets, sample_weights)`. A more detailed description of " "unpacking behavior for iterator types (Dataset, generator, Sequence) is " "given in the `Unpacking behavior for iterator-like inputs` section of " "`Model.fit`." msgstr "" -#: keras.engine.training.Model.evaluate:5 keras.engine.training.Model.fit:3 -#: keras.engine.training.Model.train_on_batch:3 of +#: keras.src.engine.training.Model.evaluate:5 +#: keras.src.engine.training.Model.fit:3 +#: keras.src.engine.training.Model.train_on_batch:3 of msgid "" "Input data. It could be: - A Numpy array (or array-like), or a list of " "arrays" msgstr "" -#: keras.engine.training.Model.evaluate:7 keras.engine.training.Model.fit:5 -#: keras.engine.training.Model.predict:13 -#: keras.engine.training.Model.train_on_batch:5 -#: keras.engine.training.Model.train_on_batch:7 of +#: keras.src.engine.training.Model.evaluate:7 +#: keras.src.engine.training.Model.fit:5 +#: keras.src.engine.training.Model.predict:28 +#: keras.src.engine.training.Model.train_on_batch:5 +#: keras.src.engine.training.Model.train_on_batch:7 of msgid "(in case the model has multiple inputs)." msgstr "" -#: keras.engine.training.Model.evaluate:8 keras.engine.training.Model.fit:6 -#: keras.engine.training.Model.predict:14 of +#: keras.src.engine.training.Model.evaluate:8 +#: keras.src.engine.training.Model.fit:6 +#: keras.src.engine.training.Model.predict:29 of msgid "" "A TensorFlow tensor, or a list of tensors (in case the model has multiple" " inputs)." msgstr "" -#: keras.engine.training.Model.evaluate:10 keras.engine.training.Model.fit:8 of +#: keras.src.engine.training.Model.evaluate:10 +#: keras.src.engine.training.Model.fit:8 of msgid "" "A dict mapping input names to the corresponding array/tensors, if the " "model has named inputs." msgstr "" -#: keras.engine.training.Model.evaluate:12 keras.engine.training.Model.fit:10 -#: of +#: keras.src.engine.training.Model.evaluate:12 +#: keras.src.engine.training.Model.fit:10 of msgid "" "A `tf.data` dataset. Should return a tuple of either `(inputs, targets)` " "or `(inputs, targets, sample_weights)`." msgstr "" -#: keras.engine.training.Model.evaluate:15 keras.engine.training.Model.fit:13 -#: of +#: keras.src.engine.training.Model.evaluate:15 +#: keras.src.engine.training.Model.fit:13 of msgid "" "A generator or `keras.utils.Sequence` returning `(inputs, targets)` or " "`(inputs, targets, sample_weights)`." msgstr "" -#: keras.engine.training.Model.evaluate:17 -#: keras.engine.training.Model.predict:18 of +#: keras.src.engine.training.Model.evaluate:17 +#: keras.src.engine.training.Model.predict:33 of msgid "" "A more detailed description of unpacking behavior for iterator types " "(Dataset, generator, Sequence) is given in the `Unpacking behavior for " "iterator-like inputs` section of `Model.fit`." msgstr "" -#: keras.engine.training.Model.evaluate:20 of +#: keras.src.engine.training.Model.evaluate:20 of msgid "" "Target data. Like the input data `x`, it could be either Numpy array(s) " "or TensorFlow tensor(s). It should be consistent with `x` (you cannot " @@ -4760,7 +4990,7 @@ msgid "" "specified (since targets will be obtained from the iterator/dataset)." msgstr "" -#: keras.engine.training.Model.evaluate:26 of +#: keras.src.engine.training.Model.evaluate:26 of msgid "" "Integer or `None`. Number of samples per batch of computation. If " "unspecified, `batch_size` will default to 32. Do not specify the " @@ -4768,34 +4998,41 @@ msgid "" "`keras.utils.Sequence` instances (since they generate batches)." msgstr "" -#: keras.engine.training.Model.evaluate:31 of -msgid "0 or 1. Verbosity mode. 0 = silent, 1 = progress bar." +#: keras.src.engine.training.Model.evaluate:31 +#: keras.src.engine.training.Model.predict:42 of +msgid "" +"`\"auto\"`, 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 =" +" single line. `\"auto\"` becomes 1 for most cases, and to 2 when used " +"with `ParameterServerStrategy`. Note that the progress bar is not " +"particularly useful when logged to a file, so `verbose=2` is recommended " +"when not running interactively (e.g. in a production environment). " +"Defaults to 'auto'." msgstr "" -#: keras.engine.training.Model.evaluate:32 of +#: keras.src.engine.training.Model.evaluate:38 of msgid "" "Optional Numpy array of weights for the test samples, used for weighting " "the loss function. You can either pass a flat (1D) Numpy array with the " "same length as the input samples (1:1 mapping between weights and " "samples), or in the case of temporal data, you can pass a 2D array " "with shape `(samples, sequence_length)`, to apply a different weight " -"to every timestep of every sample. This argument is not supported " -"when `x` is a dataset, instead pass sample weights as the third " +"to every timestep of every sample. This argument is not supported " +"when `x` is a dataset, instead pass sample weights as the third " "element of `x`." msgstr "" -#: keras.engine.training.Model.evaluate:32 of +#: keras.src.engine.training.Model.evaluate:38 of msgid "" "Optional Numpy array of weights for the test samples, used for weighting " "the loss function. You can either pass a flat (1D) Numpy array with the " "same length as the input samples" msgstr "" -#: keras.engine.training.Model.evaluate:38 of +#: keras.src.engine.training.Model.evaluate:45 of msgid "(1:1 mapping between weights and samples), or in the case of" msgstr "" -#: keras.engine.training.Model.evaluate:36 of +#: keras.src.engine.training.Model.evaluate:42 of msgid "" "temporal data, you can pass a 2D array with shape `(samples, " "sequence_length)`, to apply a different weight to every timestep of every" @@ -4803,7 +5040,7 @@ msgid "" "pass sample weights as the third element of `x`." msgstr "" -#: keras.engine.training.Model.evaluate:40 of +#: keras.src.engine.training.Model.evaluate:47 of msgid "" "Integer or `None`. Total number of steps (batches of samples) before " "declaring the evaluation round finished. Ignored with the default value " @@ -4812,30 +5049,33 @@ msgid "" "with array inputs." msgstr "" -#: keras.engine.training.Model.evaluate:45 of +#: keras.src.engine.training.Model.evaluate:52 of msgid "" "List of `keras.callbacks.Callback` instances. List of callbacks to apply " -"during evaluation. See [callbacks](/api_docs/python/tf/keras/callbacks)." +"during evaluation. See " +"[callbacks](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks)." msgstr "" -#: keras.engine.training.Model.evaluate:48 keras.engine.training.Model.fit:160 -#: keras.engine.training.Model.predict:36 of +#: keras.src.engine.training.Model.evaluate:55 +#: keras.src.engine.training.Model.predict:58 of msgid "" "Integer. Used for generator or `keras.utils.Sequence` input only. Maximum" " size for the generator queue. If unspecified, `max_queue_size` will " "default to 10." msgstr "" -#: keras.engine.training.Model.evaluate:51 keras.engine.training.Model.fit:163 -#: keras.engine.training.Model.predict:39 of +#: keras.src.engine.training.Model.evaluate:58 +#: keras.src.engine.training.Model.fit:178 +#: keras.src.engine.training.Model.predict:62 of msgid "" "Integer. Used for generator or `keras.utils.Sequence` input only. Maximum" " number of processes to spin up when using process-based threading. If " "unspecified, `workers` will default to 1." msgstr "" -#: keras.engine.training.Model.evaluate:54 keras.engine.training.Model.fit:167 -#: keras.engine.training.Model.predict:43 of +#: keras.src.engine.training.Model.evaluate:62 +#: keras.src.engine.training.Model.fit:182 +#: keras.src.engine.training.Model.predict:66 of msgid "" "Boolean. Used for generator or `keras.utils.Sequence` input only. If " "`True`, use process-based threading. If unspecified, " @@ -4845,32 +5085,26 @@ msgid "" "children processes." msgstr "" -#: keras.engine.training.Model.evaluate:60 -#: keras.engine.training.Model.test_on_batch:21 -#: keras.engine.training.Model.train_on_batch:25 of +#: keras.src.engine.training.Model.evaluate:69 +#: keras.src.engine.training.Model.test_on_batch:21 +#: keras.src.engine.training.Model.train_on_batch:27 of msgid "" "If `True`, loss and metric results are returned as a dict, with each key " "being the name of the metric. If `False`, they are returned as a list." msgstr "" -#: keras.engine.training.Model.evaluate:63 of +#: keras.src.engine.training.Model.evaluate:72 of msgid "Unused at this time." msgstr "" -#: keras.engine.training.Model.evaluate:65 of +#: keras.src.engine.training.Model.evaluate:74 of msgid "" "See the discussion of `Unpacking behavior for iterator-like inputs` for " "`Model.fit`." msgstr "" -#: keras.engine.training.Model.evaluate:68 of -msgid "" -"`Model.evaluate` is not yet supported with " -"`tf.distribute.experimental.ParameterServerStrategy`." -msgstr "" - -#: keras.engine.training.Model.evaluate:71 -#: keras.engine.training.Model.test_on_batch:25 of +#: keras.src.engine.training.Model.evaluate:77 +#: keras.src.engine.training.Model.test_on_batch:25 of msgid "" "Scalar test loss (if the model has a single output and no metrics) or " "list of scalars (if the model has multiple outputs and/or metrics). The " @@ -4878,42 +5112,89 @@ msgid "" "scalar outputs." msgstr "" -#: keras.engine.training.Model.evaluate:76 of +#: keras.src.engine.training.Model.evaluate:82 of msgid "If `model.evaluate` is wrapped in a `tf.function`." msgstr "" -#: keras.engine.training.Model.evaluate_generator:1 of +#: keras.src.engine.training.Model.evaluate_generator:1 of msgid "Evaluates the model on a data generator." msgstr "" -#: keras.engine.training.Model.evaluate_generator:4 -#: keras.engine.training.Model.fit_generator:4 -#: keras.engine.training.Model.predict_generator:4 of +#: keras.src.engine.training.Model.evaluate_generator:4 +#: keras.src.engine.training.Model.fit_generator:4 +#: keras.src.engine.training.Model.predict_generator:4 of msgid "DEPRECATED:" msgstr "" -#: keras.engine.training.Model.evaluate_generator:4 of +#: keras.src.engine.training.Model.evaluate_generator:4 of msgid "" "`Model.evaluate` now supports generators, so there is no longer any need " "to use this endpoint." msgstr "" -#: keras.engine.base_layer.Layer.finalize_state:1 of +#: keras.src.engine.training.Model.export:1 of +msgid "Create a SavedModel artifact for inference (e.g. via TF-Serving)." +msgstr "" + +#: keras.src.engine.training.Model.export:3 of +msgid "" +"This method lets you export a model to a lightweight SavedModel artifact " +"that contains the model's forward pass only (its `call()` method) and can" +" be served via e.g. TF-Serving. The forward pass is registered under the " +"name `serve()` (see example below)." +msgstr "" + +#: keras.src.engine.training.Model.export:8 of +msgid "" +"The original code of the model (including any custom layers you may have " +"used) is *no longer* necessary to reload the artifact -- it is entirely " +"standalone." +msgstr "" + +#: keras.src.engine.training.Model.export:12 of +msgid "`str` or `pathlib.Path` object. Path where to save the artifact." +msgstr "" + +#: keras.src.engine.training.Model.export:17 of +msgid "```python # Create the artifact model.export(\"path/to/location\")" +msgstr "" + +#: keras.src.engine.training.Model.export:21 of +msgid "" +"# Later, in a different process / environment... reloaded_artifact = " +"tf.saved_model.load(\"path/to/location\") predictions = " +"reloaded_artifact.serve(input_data) ```" +msgstr "" + +#: keras.src.engine.training.Model.export:26 of +msgid "" +"If you would like to customize your serving endpoints, you can use the " +"lower-level `keras.export.ExportArchive` class. The `export()` method " +"relies on `ExportArchive` internally." +msgstr "" + +#: keras.src.engine.base_layer.Layer.finalize_state:1 of msgid "Finalizes the layers state after updating layer weights." msgstr "" -#: keras.engine.base_layer.Layer.finalize_state:3 of +#: keras.src.engine.base_layer.Layer.finalize_state:3 of msgid "" "This function can be subclassed in a layer and will be called after " "updating a layer weights. It can be overridden to finalize any additional" " layer state after a weight update." msgstr "" -#: keras.engine.training.Model.fit:1 of -msgid "Trains the model for a fixed number of epochs (iterations on a dataset)." +#: keras.src.engine.base_layer.Layer.finalize_state:7 of +msgid "" +"This function will be called after weights of a layer have been restored " +"from a loaded model." +msgstr "" + +#: keras.src.engine.training.Model.fit:1 of +msgid "Trains the model for a fixed number of epochs (dataset iterations)." msgstr "" -#: keras.engine.training.Model.fit:3 of +#: keras.src.engine.training.Model.fit:3 of msgid "" "Input data. It could be: - A Numpy array (or array-like), or a list of " "arrays (in case the model has multiple inputs). - A TensorFlow tensor, " @@ -4921,7 +5202,7 @@ msgid "" "mapping input names to the corresponding array/tensors, if the model " "has named inputs. - A `tf.data` dataset. Should return a tuple of " "either `(inputs, targets)` or `(inputs, targets, sample_weights)`. - A " -"generator or `keras.utils.Sequence` returning `(inputs, targets)` or " +"generator or `keras.utils.Sequence` returning `(inputs, targets)` or " "`(inputs, targets, sample_weights)`. - A " "`tf.keras.utils.experimental.DatasetCreator`, which wraps a callable " "that takes a single argument of type `tf.distribute.InputContext`, and " @@ -4929,12 +5210,15 @@ msgid "" " prefer to specify the per-replica batching and sharding logic for the " "`Dataset`. See `tf.keras.utils.experimental.DatasetCreator` doc for " "more information. A more detailed description of unpacking behavior for" -" iterator types (Dataset, generator, Sequence) is given below. If using " +" iterator types (Dataset, generator, Sequence) is given below. If these " +"include `sample_weights` as a third component, note that sample weighting" +" applies to the `weighted_metrics` argument but not the `metrics` " +"argument in `compile()`. If using " "`tf.distribute.experimental.ParameterServerStrategy`, only " "`DatasetCreator` type is supported for `x`." msgstr "" -#: keras.engine.training.Model.fit:15 of +#: keras.src.engine.training.Model.fit:15 of msgid "" "A `tf.keras.utils.experimental.DatasetCreator`, which wraps a callable " "that takes a single argument of type `tf.distribute.InputContext`, and " @@ -4944,15 +5228,18 @@ msgid "" "information." msgstr "" -#: keras.engine.training.Model.fit:22 of +#: keras.src.engine.training.Model.fit:22 of msgid "" "A more detailed description of unpacking behavior for iterator types " -"(Dataset, generator, Sequence) is given below. If using " +"(Dataset, generator, Sequence) is given below. If these include " +"`sample_weights` as a third component, note that sample weighting applies" +" to the `weighted_metrics` argument but not the `metrics` argument in " +"`compile()`. If using " "`tf.distribute.experimental.ParameterServerStrategy`, only " "`DatasetCreator` type is supported for `x`." msgstr "" -#: keras.engine.training.Model.fit:26 of +#: keras.src.engine.training.Model.fit:29 of msgid "" "Target data. Like the input data `x`, it could be either Numpy array(s) " "or TensorFlow tensor(s). It should be consistent with `x` (you cannot " @@ -4961,7 +5248,7 @@ msgid "" "specified (since targets will be obtained from `x`)." msgstr "" -#: keras.engine.training.Model.fit:32 of +#: keras.src.engine.training.Model.fit:35 of msgid "" "Integer or `None`. Number of samples per gradient update. If unspecified," " `batch_size` will default to 32. Do not specify the `batch_size` if your" @@ -4969,7 +5256,7 @@ msgid "" "instances (since they generate batches)." msgstr "" -#: keras.engine.training.Model.fit:38 of +#: keras.src.engine.training.Model.fit:41 of msgid "" "Integer. Number of epochs to train the model. An epoch is an iteration " "over the entire `x` and `y` data provided (unless the `steps_per_epoch` " @@ -4979,16 +5266,17 @@ msgid "" "merely until the epoch of index `epochs` is reached." msgstr "" -#: keras.engine.training.Model.fit:48 of +#: keras.src.engine.training.Model.fit:51 of msgid "" "'auto', 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = one" -" line per epoch. 'auto' defaults to 1 for most cases, but 2 when used " -"with `ParameterServerStrategy`. Note that the progress bar is not " -"particularly useful when logged to a file, so verbose=2 is recommended " -"when not running interactively (eg, in a production environment)." +" line per epoch. 'auto' becomes 1 for most cases, but 2 when used with " +"`ParameterServerStrategy`. Note that the progress bar is not particularly" +" useful when logged to a file, so verbose=2 is recommended when not " +"running interactively (eg, in a production environment). Defaults to " +"'auto'." msgstr "" -#: keras.engine.training.Model.fit:55 of +#: keras.src.engine.training.Model.fit:58 of msgid "" "List of `keras.callbacks.Callback` instances. List of callbacks to apply " "during training. See `tf.keras.callbacks`. Note " @@ -5002,43 +5290,21 @@ msgid "" "`steps_per_epoch` value." msgstr "" -#: keras.engine.training.Model.fit:66 of -msgid "" -"Float between 0 and 1. Fraction of the training data to be used as " -"validation data. The model will set apart this fraction of the training " -"data, will not train on it, and will evaluate the loss and any model " -"metrics on this data at the end of each epoch. The validation data is " -"selected from the last samples in the `x` and `y` data provided, before " -"shuffling. This argument is not supported when `x` is a dataset, " -"generator or `keras.utils.Sequence` instance. `validation_split` is not " -"yet supported with `tf.distribute.experimental.ParameterServerStrategy`." -msgstr "" - -#: keras.engine.training.Model.fit:74 of -msgid "Float between 0 and 1." -msgstr "" - -#: keras.engine.training.Model.fit:68 of -msgid "" -"Fraction of the training data to be used as validation data. The model " -"will set apart this fraction of the training data, will not train on it, " -"and will evaluate the loss and any model metrics on this data at the end " -"of each epoch. The validation data is selected from the last samples in " -"the `x` and `y` data provided, before shuffling. This argument is not " -"supported when `x` is a dataset, generator or" -msgstr "" - -#: keras.engine.training.Model.fit:77 of -msgid "`keras.utils.Sequence` instance." -msgstr "" - -#: keras.engine.training.Model.fit:77 of +#: keras.src.engine.training.Model.fit:70 of msgid "" -"`validation_split` is not yet supported with " +"Float between 0 and 1. Fraction of the training data to be used as " +"validation data. The model will set apart this fraction of the training " +"data, will not train on it, and will evaluate the loss and any model " +"metrics on this data at the end of each epoch. The validation data is " +"selected from the last samples in the `x` and `y` data provided, before " +"shuffling. This argument is not supported when `x` is a dataset, " +"generator or `keras.utils.Sequence` instance. If both `validation_data` " +"and `validation_split` are provided, `validation_data` will override " +"`validation_split`. `validation_split` is not yet supported with " "`tf.distribute.experimental.ParameterServerStrategy`." msgstr "" -#: keras.engine.training.Model.fit:79 of +#: keras.src.engine.training.Model.fit:84 of msgid "" "Data on which to evaluate the loss and any model metrics at the end of " "each epoch. The model will not be trained on this data. Thus, note the " @@ -5046,14 +5312,14 @@ msgid "" "or `validation_data` is not affected by regularization layers like noise " "and dropout. `validation_data` will override `validation_split`. " "`validation_data` could be: - A tuple `(x_val, y_val)` of Numpy arrays " -"or tensors. - A tuple `(x_val, y_val, val_sample_weights)` of NumPy " -"arrays. - A `tf.data.Dataset`. - A Python generator or " +"or tensors. - A tuple `(x_val, y_val, val_sample_weights)` of NumPy" +" arrays. - A `tf.data.Dataset`. - A Python generator or " "`keras.utils.Sequence` returning `(inputs, targets)` or `(inputs, " "targets, sample_weights)`. `validation_data` is not yet supported with " "`tf.distribute.experimental.ParameterServerStrategy`." msgstr "" -#: keras.engine.training.Model.fit:79 of +#: keras.src.engine.training.Model.fit:84 of msgid "" "Data on which to evaluate the loss and any model metrics at the end of " "each epoch. The model will not be trained on this data. Thus, note the " @@ -5063,33 +5329,33 @@ msgid "" "`validation_data` could be:" msgstr "" -#: keras.engine.training.Model.fit:87 of +#: keras.src.engine.training.Model.fit:92 of msgid "A tuple `(x_val, y_val)` of Numpy arrays or tensors." msgstr "" -#: keras.engine.training.Model.fit:88 of +#: keras.src.engine.training.Model.fit:93 of msgid "A tuple `(x_val, y_val, val_sample_weights)` of NumPy arrays." msgstr "" -#: keras.engine.training.Model.fit:89 of +#: keras.src.engine.training.Model.fit:95 of msgid "A `tf.data.Dataset`." msgstr "" -#: keras.engine.training.Model.fit:90 of +#: keras.src.engine.training.Model.fit:96 of msgid "A Python generator or `keras.utils.Sequence` returning" msgstr "" -#: keras.engine.training.Model.fit:91 of +#: keras.src.engine.training.Model.fit:97 of msgid "`(inputs, targets)` or `(inputs, targets, sample_weights)`." msgstr "" -#: keras.engine.training.Model.fit:92 of +#: keras.src.engine.training.Model.fit:98 of msgid "" "`validation_data` is not yet supported with " "`tf.distribute.experimental.ParameterServerStrategy`." msgstr "" -#: keras.engine.training.Model.fit:94 of +#: keras.src.engine.training.Model.fit:100 of msgid "" "Boolean (whether to shuffle the training data before each epoch) or str " "(for 'batch'). This argument is ignored when `x` is a generator or an " @@ -5098,57 +5364,39 @@ msgid "" "effect when `steps_per_epoch` is not `None`." msgstr "" -#: keras.engine.training.Model.fit:100 of +#: keras.src.engine.training.Model.fit:106 of msgid "" "Optional dictionary mapping class indices (integers) to a weight (float) " "value, used for weighting the loss function (during training only). This " "can be useful to tell the model to \"pay more attention\" to samples from" -" an under-represented class." +" an under-represented class. When `class_weight` is specified and targets" +" have a rank of 2 or greater, either `y` must be one-hot encoded, or an " +"explicit final dimension of `1` must be included for sparse class labels." msgstr "" -#: keras.engine.training.Model.fit:106 of +#: keras.src.engine.training.Model.fit:115 of msgid "" -"Optional Numpy array of weights for the training samples, used for " -"weighting the loss function (during training only). You can either pass " -"a flat (1D) Numpy array with the same length as the input samples (1:1 " -"mapping between weights and samples), or in the case of temporal data, " -"you can pass a 2D array with shape `(samples, sequence_length)`, to " -"apply a different weight to every timestep of every sample. This " -"argument is not supported when `x` is a dataset, generator, or " -"`keras.utils.Sequence` instance, instead provide the sample_weights as " -"the third element of `x`." +"Optional Numpy array of weights for the training samples, used for " +"weighting the loss function (during training only). You can either pass a" +" flat (1D) Numpy array with the same length as the input samples (1:1 " +"mapping between weights and samples), or in the case of temporal data, " +"you can pass a 2D array with shape `(samples, sequence_length)`, to apply" +" a different weight to every timestep of every sample. This argument is " +"not supported when `x` is a dataset, generator, or `keras.utils.Sequence`" +" instance, instead provide the sample_weights as the third element of " +"`x`. Note that sample weighting does not apply to metrics specified via " +"the `metrics` argument in `compile()`. To apply sample weighting to your " +"metrics, you can specify them via the `weighted_metrics` in `compile()` " +"instead." msgstr "" -#: keras.engine.training.Model.fit:115 of -msgid "Optional Numpy array of weights for" -msgstr "" - -#: keras.engine.training.Model.fit:108 of -msgid "" -"the training samples, used for weighting the loss function (during " -"training only). You can either pass a flat (1D) Numpy array with the same" -" length as the input samples (1:1 mapping between weights and samples), " -"or in the case of temporal data, you can pass a 2D array with shape " -"`(samples, sequence_length)`, to apply a different weight to every " -"timestep of every sample. This argument is not supported when `x` is a " -"dataset, generator, or" -msgstr "" - -#: keras.engine.training.Model.fit:117 of -msgid "`keras.utils.Sequence` instance, instead provide the sample_weights" -msgstr "" - -#: keras.engine.training.Model.fit:118 of -msgid "as the third element of `x`." -msgstr "" - -#: keras.engine.training.Model.fit:119 of +#: keras.src.engine.training.Model.fit:131 of msgid "" "Integer. Epoch at which to start training (useful for resuming a previous" " training run)." msgstr "" -#: keras.engine.training.Model.fit:122 of +#: keras.src.engine.training.Model.fit:134 of msgid "" "Integer or `None`. Total number of steps (batches of samples) before " "declaring one epoch finished and starting the next epoch. When training " @@ -5156,15 +5404,15 @@ msgid "" " equal to the number of samples in your dataset divided by the batch " "size, or 1 if that cannot be determined. If x is a `tf.data` dataset, and" " 'steps_per_epoch' is None, the epoch will run until the input dataset is" -" exhausted. When passing an infinitely repeating dataset, you must " +" exhausted. When passing an infinitely repeating dataset, you must " "specify the `steps_per_epoch` argument. If `steps_per_epoch=-1` the " -"training will run indefinitely with an infinitely repeating dataset. This" -" argument is not supported with array inputs. When using " +"training will run indefinitely with an infinitely repeating dataset. " +"This argument is not supported with array inputs. When using " "`tf.distribute.experimental.ParameterServerStrategy`: * " "`steps_per_epoch=None` is not supported." msgstr "" -#: keras.engine.training.Model.fit:122 of +#: keras.src.engine.training.Model.fit:134 of msgid "" "Integer or `None`. Total number of steps (batches of samples) before " "declaring one epoch finished and starting the next epoch. When training " @@ -5172,18 +5420,18 @@ msgid "" " equal to the number of samples in your dataset divided by the batch " "size, or 1 if that cannot be determined. If x is a `tf.data` dataset, and" " 'steps_per_epoch' is None, the epoch will run until the input dataset is" -" exhausted. When passing an infinitely repeating dataset, you must " +" exhausted. When passing an infinitely repeating dataset, you must " "specify the `steps_per_epoch` argument. If `steps_per_epoch=-1` the " -"training will run indefinitely with an infinitely repeating dataset. This" -" argument is not supported with array inputs. When using " +"training will run indefinitely with an infinitely repeating dataset. " +"This argument is not supported with array inputs. When using " "`tf.distribute.experimental.ParameterServerStrategy`:" msgstr "" -#: keras.engine.training.Model.fit:136 of +#: keras.src.engine.training.Model.fit:149 of msgid "`steps_per_epoch=None` is not supported." msgstr "" -#: keras.engine.training.Model.fit:137 of +#: keras.src.engine.training.Model.fit:150 of msgid "" "Only relevant if `validation_data` is provided and is a `tf.data` " "dataset. Total number of steps (batches of samples) to draw before " @@ -5197,7 +5445,7 @@ msgid "" "time." msgstr "" -#: keras.engine.training.Model.fit:147 of +#: keras.src.engine.training.Model.fit:161 of msgid "" "Integer or `None`. Number of samples per validation batch. If " "unspecified, will default to `batch_size`. Do not specify the " @@ -5206,10 +5454,10 @@ msgid "" "batches)." msgstr "" -#: keras.engine.training.Model.fit:153 of +#: keras.src.engine.training.Model.fit:167 of msgid "" "Only relevant if validation data is provided. Integer or " -"`collections.abc.Container` instance (e.g. list, tuple, etc.). If an " +"`collections.abc.Container` instance (e.g. list, tuple, etc.). If an " "integer, specifies how many training epochs to run before a new " "validation run is performed, e.g. `validation_freq=2` runs validation " "every 2 epochs. If a Container, specifies the epochs on which to run " @@ -5217,19 +5465,26 @@ msgid "" "of the 1st, 2nd, and 10th epochs." msgstr "" -#: keras.engine.training.Model.fit:196 of +#: keras.src.engine.training.Model.fit:175 of +msgid "" +"Integer. Used for generator or `keras.utils.Sequence` input only. Maximum" +" size for the generator queue. If unspecified, `max_queue_size` will " +"default to 10." +msgstr "" + +#: keras.src.engine.training.Model.fit:214 of msgid "Unpacking behavior for iterator-like inputs:" msgstr "" -#: keras.engine.training.Model.fit:175 of +#: keras.src.engine.training.Model.fit:191 of msgid "A common pattern is to pass a tf.data.Dataset, generator, or" msgstr "" -#: keras.engine.training.Model.fit:176 of +#: keras.src.engine.training.Model.fit:192 of msgid "" "tf.keras.utils.Sequence to the `x` argument of fit, which will in fact " "yield not only features (x) but optionally targets (y) and sample " -"weights. Keras requires that the output of such iterator-likes be " +"weights. Keras requires that the output of such iterator-likes be " "unambiguous. The iterator should return a tuple of length 1, 2, or 3, " "where the optional second and third elements will be used for y and " "sample_weight respectively. Any other type provided will be wrapped in a " @@ -5239,31 +5494,31 @@ msgid "" "features, targets, and weights from the keys of a single dict." msgstr "" -#: keras.engine.training.Model.fit:186 of -msgid "A notable unsupported data type is the namedtuple. The reason is that" +#: keras.src.engine.training.Model.fit:203 of +msgid "A notable unsupported data type is the namedtuple. The reason is" msgstr "" -#: keras.engine.training.Model.fit:187 of +#: keras.src.engine.training.Model.fit:204 of msgid "" -"it behaves like both an ordered datatype (tuple) and a mapping datatype " -"(dict). So given a namedtuple of the form:" +"that it behaves like both an ordered datatype (tuple) and a mapping " +"datatype (dict). So given a namedtuple of the form:" msgstr "" -#: keras.engine.training.Model.fit:189 of +#: keras.src.engine.training.Model.fit:206 of msgid "`namedtuple(\"example_tuple\", [\"y\", \"x\"])`" msgstr "" -#: keras.engine.training.Model.fit:190 of +#: keras.src.engine.training.Model.fit:207 of msgid "" "it is ambiguous whether to reverse the order of the elements when " "interpreting the value. Even worse is a tuple of the form:" msgstr "" -#: keras.engine.training.Model.fit:192 of +#: keras.src.engine.training.Model.fit:209 of msgid "`namedtuple(\"other_tuple\", [\"x\", \"y\", \"z\"])`" msgstr "" -#: keras.engine.training.Model.fit:193 of +#: keras.src.engine.training.Model.fit:210 of msgid "" "where it is unclear if the tuple was intended to be unpacked into x, y, " "and sample_weight or passed through as a single element to `x`. As a " @@ -5271,44 +5526,44 @@ msgid "" "encounters a namedtuple. (Along with instructions to remedy the issue.)" msgstr "" -#: keras.engine.training.Model.fit:198 of +#: keras.src.engine.training.Model.fit:216 of msgid "" "A `History` object. Its `History.history` attribute is a record of " "training loss values and metrics values at successive epochs, as well as " "validation loss values and validation metrics values (if applicable)." msgstr "" -#: keras.engine.training.Model.fit:203 of +#: keras.src.engine.training.Model.fit:221 of msgid "1. If the model was never compiled or," msgstr "" -#: keras.engine.training.Model.fit:203 of +#: keras.src.engine.training.Model.fit:221 of msgid "If the model was never compiled or," msgstr "" -#: keras.engine.training.Model.fit:205 of +#: keras.src.engine.training.Model.fit:223 of msgid "" "In case of mismatch between the provided input data and what the " "model expects or when the input data is empty." msgstr "" -#: keras.engine.training.Model.fit_generator:1 of +#: keras.src.engine.training.Model.fit_generator:1 of msgid "Fits the model on data yielded batch-by-batch by a Python generator." msgstr "" -#: keras.engine.training.Model.fit_generator:4 of +#: keras.src.engine.training.Model.fit_generator:4 of msgid "" "`Model.fit` now supports generators, so there is no longer any need to " "use this endpoint." msgstr "" -#: keras.engine.base_layer.Layer.from_config:1 -#: keras.engine.training.Model.from_config:1 of +#: keras.src.engine.base_layer.Layer.from_config:1 +#: keras.src.engine.training.Model.from_config:1 of msgid "Creates a layer from its config." msgstr "" -#: keras.engine.base_layer.Layer.from_config:3 -#: keras.engine.training.Model.from_config:3 of +#: keras.src.engine.base_layer.Layer.from_config:3 +#: keras.src.engine.training.Model.from_config:3 of msgid "" "This method is the reverse of `get_config`, capable of instantiating the " "same layer from the config dictionary. It does not handle layer " @@ -5316,69 +5571,106 @@ msgid "" "`set_weights`)." msgstr "" -#: keras.engine.base_layer.Layer.from_config:8 -#: keras.engine.training.Model.from_config:8 of +#: keras.src.engine.base_layer.Layer.from_config:8 +#: keras.src.engine.training.Model.from_config:8 of msgid "A Python dictionary, typically the output of get_config." msgstr "" -#: keras.engine.base_layer.Layer.from_config:11 -#: keras.engine.training.Model.from_config:11 -#: keras.engine.training.Model.get_layer:9 of +#: keras.src.engine.base_layer.Layer.from_config:11 +#: keras.src.engine.training.Model.from_config:11 +#: keras.src.engine.training.Model.get_layer:9 of msgid "A layer instance." msgstr "" -#: keras.engine.base_layer.Layer.get_config:1 -#: keras.engine.training.Model.get_config:1 of -msgid "Returns the config of the layer." +#: keras.src.engine.base_layer.Layer.get_build_config:1 of +msgid "Returns a dictionary with the layer's input shape." msgstr "" -#: keras.engine.base_layer.Layer.get_config:3 -#: keras.engine.training.Model.get_config:3 of +#: keras.src.engine.base_layer.Layer.get_build_config:3 of msgid "" -"A layer config is a Python dictionary (serializable) containing the " -"configuration of a layer. The same layer can be reinstantiated later " -"(without its trained weights) from this configuration." +"This method returns a config dict that can be used by " +"`build_from_config(config)` to create all states (e.g. Variables and " +"Lookup tables) needed by the layer." msgstr "" -#: keras.engine.base_layer.Layer.get_config:8 -#: keras.engine.training.Model.get_config:8 of +#: keras.src.engine.base_layer.Layer.get_build_config:7 of msgid "" -"The config of a layer does not include connectivity information, nor the " -"layer class name. These are handled by `Network` (one layer of " -"abstraction above)." +"By default, the config only contains the input shape that the layer was " +"built with. If you're writing a custom layer that creates state in an " +"unusual way, you should override this method to make sure this state is " +"already created when Keras attempts to load its value upon model loading." +msgstr "" + +#: keras.src.engine.base_layer.Layer.get_build_config:13 of +msgid "A dict containing the input shape associated with the layer." +msgstr "" + +#: keras.src.engine.training.Model.get_compile_config:1 of +msgid "Returns a serialized config with information for compiling the model." +msgstr "" + +#: keras.src.engine.training.Model.get_compile_config:3 of +msgid "" +"This method returns a config dictionary containing all the information " +"(optimizer, loss, metrics, etc.) with which the model was compiled." +msgstr "" + +#: keras.src.engine.training.Model.get_compile_config:6 of +msgid "A dict containing information for compiling the model." +msgstr "" + +#: keras.src.engine.training.Model.get_config:1 of +msgid "Returns the config of the `Model`." msgstr "" -#: keras.engine.base_layer.Layer.get_config:12 -#: keras.engine.training.Model.get_config:12 of +#: keras.src.engine.training.Model.get_config:3 of +msgid "" +"Config is a Python dictionary (serializable) containing the configuration" +" of an object, which in this case is a `Model`. This allows the `Model` " +"to be be reinstantiated later (without its trained weights) from this " +"configuration." +msgstr "" + +#: keras.src.engine.base_layer.Layer.get_config:12 +#: keras.src.engine.training.Model.get_config:8 of msgid "" "Note that `get_config()` does not guarantee to return a fresh copy of " "dict every time it is called. The callers should make a copy of the " "returned dict if they want to modify it." msgstr "" -#: keras.engine.base_layer.Layer.get_config:16 -#: keras.engine.training.Model.get_config:16 of -msgid "Python dictionary." +#: keras.src.engine.training.Model.get_config:12 of +msgid "" +"Developers of subclassed `Model` are advised to override this method, and" +" continue to update the dict from `super(MyModel, self).get_config()` to " +"provide the proper configuration of this `Model`. The default config will" +" return config dict for init parameters if they are basic types. Raises " +"`NotImplementedError` when in cases where a custom `get_config()` " +"implementation is required for the subclassed model." +msgstr "" + +#: keras.src.engine.training.Model.get_config:19 of +msgid "Python dictionary containing the configuration of this `Model`." msgstr "" -#: keras.engine.base_layer.Layer.get_input_at:1 of +#: keras.src.engine.base_layer.Layer.get_input_at:1 of msgid "Retrieves the input tensor(s) of a layer at a given node." msgstr "" -#: keras.engine.base_layer.Layer.get_input_at:3 of +#: keras.src.engine.base_layer.Layer.get_input_at:3 of msgid "" "Integer, index of the node from which to retrieve the attribute. E.g. " "`node_index=0` will correspond to the first input node of the layer." msgstr "" -#: keras.engine.base_layer.Layer.get_input_at:8 of +#: keras.src.engine.base_layer.Layer.get_input_at:8 of msgid "A tensor (or list of tensors if the layer has multiple inputs)." msgstr "" -#: keras.engine.base_layer.Layer.get_input_at:10 -#: keras.engine.base_layer.Layer.get_input_shape_at:11 -#: keras.engine.base_layer.Layer.get_output_at:10 -#: keras.engine.base_layer.Layer.get_output_shape_at:11 of +#: keras.src.engine.base_layer.Layer.get_input_at:10 +#: keras.src.engine.base_layer.Layer.get_input_shape_at:11 +#: keras.src.engine.base_layer.Layer.get_output_at:10 +#: keras.src.engine.base_layer.Layer.get_output_shape_at:11 of #: tensorcircuit.applications.van.MADE.input:8 #: tensorcircuit.applications.van.MaskedConv2D.input:8 #: tensorcircuit.applications.van.MaskedLinear.input:8 @@ -5391,127 +5683,187 @@ msgstr "" msgid "If called in Eager mode." msgstr "" -#: keras.engine.base_layer.Layer.get_input_mask_at:1 of +#: keras.src.engine.base_layer.Layer.get_input_mask_at:1 of msgid "Retrieves the input mask tensor(s) of a layer at a given node." msgstr "" -#: keras.engine.base_layer.Layer.get_input_mask_at:3 -#: keras.engine.base_layer.Layer.get_input_shape_at:3 -#: keras.engine.base_layer.Layer.get_output_mask_at:3 -#: keras.engine.base_layer.Layer.get_output_shape_at:3 of +#: keras.src.engine.base_layer.Layer.get_input_mask_at:3 +#: keras.src.engine.base_layer.Layer.get_input_shape_at:3 +#: keras.src.engine.base_layer.Layer.get_output_mask_at:3 +#: keras.src.engine.base_layer.Layer.get_output_shape_at:3 of msgid "" "Integer, index of the node from which to retrieve the attribute. E.g. " "`node_index=0` will correspond to the first time the layer was called." msgstr "" -#: keras.engine.base_layer.Layer.get_input_mask_at:8 of +#: keras.src.engine.base_layer.Layer.get_input_mask_at:8 of msgid "A mask tensor (or list of tensors if the layer has multiple inputs)." msgstr "" -#: keras.engine.base_layer.Layer.get_input_shape_at:1 of +#: keras.src.engine.base_layer.Layer.get_input_shape_at:1 of msgid "Retrieves the input shape(s) of a layer at a given node." msgstr "" -#: keras.engine.base_layer.Layer.get_input_shape_at:8 of +#: keras.src.engine.base_layer.Layer.get_input_shape_at:8 of msgid "A shape tuple (or list of shape tuples if the layer has multiple inputs)." msgstr "" -#: keras.engine.training.Model.get_layer:1 of +#: keras.src.engine.training.Model.get_layer:1 of msgid "Retrieves a layer based on either its name (unique) or index." msgstr "" -#: keras.engine.training.Model.get_layer:3 of +#: keras.src.engine.training.Model.get_layer:3 of msgid "" "If `name` and `index` are both provided, `index` will take precedence. " "Indices are based on order of horizontal graph traversal (bottom-up)." msgstr "" -#: keras.engine.training.Model.get_layer:6 of +#: keras.src.engine.training.Model.get_layer:6 of msgid "String, name of layer." msgstr "" -#: keras.engine.training.Model.get_layer:7 of +#: keras.src.engine.training.Model.get_layer:7 of msgid "Integer, index of layer." msgstr "" -#: keras.engine.base_layer.Layer.get_losses_for:3 of -msgid "Retrieves losses relevant to a specific set of inputs." +#: keras.src.engine.training.Model.get_metrics_result:1 of +msgid "Returns the model's metrics values as a dict." msgstr "" -#: keras.engine.base_layer.Layer.get_losses_for:5 -#: keras.engine.base_layer.Layer.get_updates_for:5 of -msgid "Input tensor or list/tuple of input tensors." +#: keras.src.engine.training.Model.get_metrics_result:3 of +msgid "" +"If any of the metric result is a dict (containing multiple metrics), each" +" of them gets added to the top level returned dict of this method." msgstr "" -#: keras.engine.base_layer.Layer.get_losses_for:7 of -msgid "List of loss tensors of the layer that depend on `inputs`." +#: keras.src.engine.training.Model.get_metrics_result:6 of +msgid "" +"A `dict` containing values of the metrics listed in `self.metrics`. " +"Example: `{'loss': 0.2, 'accuracy': 0.7}`." msgstr "" -#: keras.engine.base_layer.Layer.get_output_at:1 of +#: keras.src.engine.base_layer.Layer.get_output_at:1 of msgid "Retrieves the output tensor(s) of a layer at a given node." msgstr "" -#: keras.engine.base_layer.Layer.get_output_at:3 of +#: keras.src.engine.base_layer.Layer.get_output_at:3 of msgid "" "Integer, index of the node from which to retrieve the attribute. E.g. " "`node_index=0` will correspond to the first output node of the layer." msgstr "" -#: keras.engine.base_layer.Layer.get_output_at:8 of +#: keras.src.engine.base_layer.Layer.get_output_at:8 of msgid "A tensor (or list of tensors if the layer has multiple outputs)." msgstr "" -#: keras.engine.base_layer.Layer.get_output_mask_at:1 of +#: keras.src.engine.base_layer.Layer.get_output_mask_at:1 of msgid "Retrieves the output mask tensor(s) of a layer at a given node." msgstr "" -#: keras.engine.base_layer.Layer.get_output_mask_at:8 of +#: keras.src.engine.base_layer.Layer.get_output_mask_at:8 of msgid "A mask tensor (or list of tensors if the layer has multiple outputs)." msgstr "" -#: keras.engine.base_layer.Layer.get_output_shape_at:1 of +#: keras.src.engine.base_layer.Layer.get_output_shape_at:1 of msgid "Retrieves the output shape(s) of a layer at a given node." msgstr "" -#: keras.engine.base_layer.Layer.get_output_shape_at:8 of +#: keras.src.engine.base_layer.Layer.get_output_shape_at:8 of msgid "A shape tuple (or list of shape tuples if the layer has multiple outputs)." msgstr "" -#: keras.engine.base_layer.Layer.get_updates_for:3 of -msgid "Retrieves updates relevant to a specific set of inputs." +#: keras.src.engine.training.Model.get_weight_paths:1 of +msgid "Retrieve all the variables and their paths for the model." msgstr "" -#: keras.engine.base_layer.Layer.get_updates_for:7 of -msgid "List of update ops of the layer that depend on `inputs`." +#: keras.src.engine.training.Model.get_weight_paths:3 of +msgid "" +"The variable path (string) is a stable key to identify a `tf.Variable` " +"instance owned by the model. It can be used to specify variable-specific " +"configurations (e.g. DTensor, quantization) from a global view." msgstr "" -#: keras.engine.training.Model.get_weights:1 of -msgid "Retrieves the weights of the model." +#: keras.src.engine.training.Model.get_weight_paths:7 of +msgid "" +"This method returns a dict with weight object paths as keys and the " +"corresponding `tf.Variable` instances as values." msgstr "" -#: keras.engine.training.Model.get_weights:3 of -msgid "A flat list of Numpy arrays." +#: keras.src.engine.training.Model.get_weight_paths:10 of +msgid "" +"Note that if the model is a subclassed model and the weights haven't been" +" initialized, an empty dict will be returned." msgstr "" -#: of tensorcircuit.applications.van.MADE.inbound_nodes:1 -#: tensorcircuit.applications.van.MADE.outbound_nodes:1 -#: tensorcircuit.applications.van.MaskedConv2D.inbound_nodes:1 -#: tensorcircuit.applications.van.MaskedConv2D.outbound_nodes:1 -#: tensorcircuit.applications.van.MaskedLinear.inbound_nodes:1 -#: tensorcircuit.applications.van.MaskedLinear.outbound_nodes:1 -#: tensorcircuit.applications.van.NMF.inbound_nodes:1 -#: tensorcircuit.applications.van.NMF.outbound_nodes:1 -#: tensorcircuit.applications.van.PixelCNN.inbound_nodes:1 -#: tensorcircuit.applications.van.PixelCNN.outbound_nodes:1 -#: tensorcircuit.applications.van.ResidualBlock.inbound_nodes:1 -#: tensorcircuit.applications.van.ResidualBlock.outbound_nodes:1 -#: tensorcircuit.applications.vqes.Linear.inbound_nodes:1 -#: tensorcircuit.applications.vqes.Linear.outbound_nodes:1 -#: tensorcircuit.keras.HardwareLayer.inbound_nodes:1 -#: tensorcircuit.keras.HardwareLayer.outbound_nodes:1 -#: tensorcircuit.keras.QuantumLayer.inbound_nodes:1 -#: tensorcircuit.keras.QuantumLayer.outbound_nodes:1 -msgid "Deprecated, do NOT use! Only for compatibility with external Keras." +#: keras.src.engine.training.Model.get_weight_paths:13 of +msgid "" +"A dict where keys are variable paths and values are `tf.Variable` " +"instances." +msgstr "" + +#: keras.src.engine.training.Model.get_weight_paths:16 of +msgid "A dict where keys are variable paths and values are `tf.Variable`" +msgstr "" + +#: keras.src.engine.training.Model.get_weight_paths:16 of +msgid "instances." +msgstr "" + +#: keras.src.engine.training.Model.get_weight_paths:20 of +msgid "```python class SubclassModel(tf.keras.Model):" +msgstr "" + +#: keras.src.engine.training.Model.get_weight_paths:26 of +msgid "def __init__(self, name=None):" +msgstr "" + +#: keras.src.engine.training.Model.get_weight_paths:24 of +msgid "" +"super().__init__(name=name) self.d1 = tf.keras.layers.Dense(10) self.d2 =" +" tf.keras.layers.Dense(20)" +msgstr "" + +#: keras.src.engine.training.Model.get_weight_paths:29 of +msgid "x = self.d1(inputs) return self.d2(x)" +msgstr "" + +#: keras.src.engine.training.Model.get_weight_paths:32 of +msgid "" +"model = SubclassModel() model(tf.zeros((10, 10))) weight_paths = " +"model.get_weight_paths() # weight_paths: # { # 'd1.kernel': " +"model.d1.kernel, # 'd1.bias': model.d1.bias, # 'd2.kernel': " +"model.d2.kernel, # 'd2.bias': model.d2.bias, # }" +msgstr "" + +#: keras.src.engine.training.Model.get_weight_paths:43 of +msgid "" +"# Functional model inputs = tf.keras.Input((10,), batch_size=10) x = " +"tf.keras.layers.Dense(20, name='d1')(inputs) output = " +"tf.keras.layers.Dense(30, name='d2')(x) model = tf.keras.Model(inputs, " +"output) d1 = model.layers[1] d2 = model.layers[2] weight_paths = " +"model.get_weight_paths() # weight_paths: # { # 'd1.kernel': d1.kernel," +" # 'd1.bias': d1.bias, # 'd2.kernel': d2.kernel, # 'd2.bias': " +"d2.bias, # } ```" +msgstr "" + +#: keras.src.engine.training.Model.get_weights:1 of +msgid "Retrieves the weights of the model." +msgstr "" + +#: keras.src.engine.training.Model.get_weights:3 of +msgid "A flat list of Numpy arrays." +msgstr "" + +#: of tensorcircuit.applications.van.MADE.inbound_nodes:1 +#: tensorcircuit.applications.van.MaskedConv2D.inbound_nodes:1 +#: tensorcircuit.applications.van.MaskedLinear.inbound_nodes:1 +#: tensorcircuit.applications.van.NMF.inbound_nodes:1 +#: tensorcircuit.applications.van.PixelCNN.inbound_nodes:1 +#: tensorcircuit.applications.van.ResidualBlock.inbound_nodes:1 +#: tensorcircuit.applications.vqes.Linear.inbound_nodes:1 +#: tensorcircuit.keras.HardwareLayer.inbound_nodes:1 +#: tensorcircuit.keras.QuantumLayer.inbound_nodes:1 +msgid "Return Functional API nodes upstream of this layer." msgstr "" #: of tensorcircuit.applications.van.MADE.input:1 @@ -5822,92 +6174,125 @@ msgstr "" msgid "A `tf.keras.layers.InputSpec` instance, or nested structure thereof." msgstr "" -#: keras.engine.training.Model.load_weights:1 of -msgid "Loads all layer weights, either from a TensorFlow or an HDF5 weight file." +#: of tensorcircuit.applications.van.MADE.jit_compile:1 +#: tensorcircuit.applications.van.NMF.jit_compile:1 +#: tensorcircuit.applications.van.PixelCNN.jit_compile:1 +msgid "Specify whether to compile the model with XLA." msgstr "" -#: keras.engine.training.Model.load_weights:3 of +#: of tensorcircuit.applications.van.MADE.jit_compile:3 +#: tensorcircuit.applications.van.NMF.jit_compile:3 +#: tensorcircuit.applications.van.PixelCNN.jit_compile:3 msgid "" -"If `by_name` is False weights are loaded based on the network's topology." -" This means the architecture should be the same as when the weights were " -"saved. Note that layers that don't have weights are not taken into " -"account in the topological ordering, so adding or removing layers is fine" -" as long as they don't have weights." +"[XLA](https://www.tensorflow.org/xla) is an optimizing compiler for " +"machine learning. `jit_compile` is not enabled by default. Note that " +"`jit_compile=True` may not necessarily work for all models." msgstr "" -#: keras.engine.training.Model.load_weights:9 of +#: of tensorcircuit.applications.van.MADE.jit_compile:7 +#: tensorcircuit.applications.van.NMF.jit_compile:7 +#: tensorcircuit.applications.van.PixelCNN.jit_compile:7 msgid "" -"If `by_name` is True, weights are loaded into layers only if they share " -"the same name. This is useful for fine-tuning or transfer-learning models" -" where some of the layers have changed." +"For more information on supported operations please refer to the [XLA " +"documentation](https://www.tensorflow.org/xla). Also refer to [known XLA " +"issues](https://www.tensorflow.org/xla/known_issues) for more details." msgstr "" -#: keras.engine.training.Model.load_weights:13 of +#: keras.src.engine.base_layer.Layer.load_own_variables:1 of +msgid "Loads the state of the layer." +msgstr "" + +#: keras.src.engine.base_layer.Layer.load_own_variables:3 of msgid "" -"Only topological loading (`by_name=False`) is supported when loading " -"weights from the TensorFlow format. Note that topological loading differs" -" slightly between TensorFlow and HDF5 formats for user-defined classes " -"inheriting from `tf.keras.Model`: HDF5 loads based on a flattened list of" -" weights, while the TensorFlow format loads based on the object-local " -"names of attributes to which layers are assigned in the `Model`'s " -"constructor." +"You can override this method to take full control of how the state of the" +" layer is loaded upon calling `keras.models.load_model()`." +msgstr "" + +#: keras.src.engine.base_layer.Layer.load_own_variables:6 of +msgid "Dict from which the state of the model will be loaded." msgstr "" -#: keras.engine.training.Model.load_weights:20 of +#: keras.src.engine.training.Model.load_weights:1 of +msgid "Loads all layer weights from a saved files." +msgstr "" + +#: keras.src.engine.training.Model.load_weights:3 of msgid "" -"String, path to the weights file to load. For weight files in TensorFlow " -"format, this is the file prefix (the same as was passed to " -"`save_weights`). This can also be a path to a SavedModel saved from " -"`model.save`." +"The saved file could be a SavedModel file, a `.keras` file (v3 saving " +"format), or a file created via `model.save_weights()`." msgstr "" -#: keras.engine.training.Model.load_weights:24 of +#: keras.src.engine.training.Model.load_weights:6 of msgid "" -"Boolean, whether to load weights by name or by topological order. Only " -"topological loading is supported for weight files in TensorFlow format." +"By default, weights are loaded based on the network's topology. This " +"means the architecture should be the same as when the weights were saved." +" Note that layers that don't have weights are not taken into account in " +"the topological ordering, so adding or removing layers is fine as long as" +" they don't have weights." +msgstr "" + +#: keras.src.engine.training.Model.load_weights:12 of +msgid "**Partial weight loading**" msgstr "" -#: keras.engine.training.Model.load_weights:27 of +#: keras.src.engine.training.Model.load_weights:14 of msgid "" -"Boolean, whether to skip loading of layers where there is a mismatch in " -"the number of weights, or a mismatch in the shape of the weight (only " -"valid when `by_name=True`)." +"If you have modified your model, for instance by adding a new layer (with" +" weights) or by changing the shape of the weights of a layer, you can " +"choose to ignore errors and continue loading by setting " +"`skip_mismatch=True`. In this case any layer with mismatching weights " +"will be skipped. A warning will be displayed for each skipped layer." msgstr "" -#: keras.engine.training.Model.load_weights:30 of +#: keras.src.engine.training.Model.load_weights:21 of +msgid "**Weight loading by name**" +msgstr "" + +#: keras.src.engine.training.Model.load_weights:23 of msgid "" -"Optional `tf.train.CheckpointOptions` object that specifies options for " -"loading weights." +"If your weights are saved as a `.h5` file created via " +"`model.save_weights()`, you can use the argument `by_name=True`." +msgstr "" + +#: keras.src.engine.training.Model.load_weights:26 of +msgid "" +"In this case, weights are loaded into layers only if they share the same " +"name. This is useful for fine-tuning or transfer-learning models where " +"some of the layers have changed." msgstr "" -#: keras.engine.training.Model.load_weights:33 of +#: keras.src.engine.training.Model.load_weights:30 of msgid "" -"When loading a weight file in TensorFlow format, returns the same status " -"object as `tf.train.Checkpoint.restore`. When graph building, restore ops" -" are run automatically as soon as the network is built (on first call for" -" user-defined classes inheriting from `Model`, immediately if it is " -"already built). When loading weights in HDF5 format, returns `None`." +"Note that only topological loading (`by_name=False`) is supported when " +"loading weights from the `.keras` v3 format or from the TensorFlow " +"SavedModel format." msgstr "" -#: keras.engine.training.Model.load_weights:33 of +#: keras.src.engine.training.Model.load_weights:34 of msgid "" -"When loading a weight file in TensorFlow format, returns the same status " -"object as `tf.train.Checkpoint.restore`. When graph building, restore ops" -" are run automatically as soon as the network is built (on first call for" -" user-defined classes inheriting from `Model`, immediately if it is " -"already built)." +"String, path to the weights file to load. For weight files in TensorFlow " +"format, this is the file prefix (the same as was passed to " +"`save_weights()`). This can also be a path to a SavedModel or a `.keras` " +"file (v3 saving format) saved via `model.save()`." msgstr "" -#: keras.engine.training.Model.load_weights:39 of -msgid "When loading weights in HDF5 format, returns `None`." +#: keras.src.engine.training.Model.load_weights:39 of +msgid "" +"Boolean, whether to skip loading of layers where there is a mismatch in " +"the number of weights, or a mismatch in the shape of the weights." msgstr "" -#: keras.engine.training.Model.load_weights:41 of -msgid "If `h5py` is not available and the weight file is in HDF5 format." +#: keras.src.engine.training.Model.load_weights:42 of +msgid "" +"Boolean, whether to load weights by name or by topological order. Only " +"topological loading is supported for weight files in the `.keras` v3 " +"format or in the TensorFlow SavedModel format." msgstr "" -#: keras.engine.training.Model.load_weights:42 of -msgid "If `skip_mismatch` is set to `True` when `by_name` is `False`." +#: keras.src.engine.training.Model.load_weights:45 of +msgid "" +"Optional `tf.train.CheckpointOptions` object that specifies options for " +"loading weights (only valid for a SavedModel file)." msgstr "" #: of tensorcircuit.applications.van.MADE.losses:1 @@ -5938,55 +6323,55 @@ msgid "" "variables." msgstr "" -#: keras.engine.training.Model.reset_metrics:3 of -#: tensorcircuit.applications.van.MADE.losses:7 +#: keras.src.engine.training.Model.reset_metrics:3 of +#: tensorcircuit.applications.van.MADE.losses:8 #: tensorcircuit.applications.van.MADE.metrics:6 #: tensorcircuit.applications.van.MADE.metrics_names:6 -#: tensorcircuit.applications.van.MaskedConv2D.losses:7 -#: tensorcircuit.applications.van.MaskedLinear.losses:7 -#: tensorcircuit.applications.van.NMF.losses:7 +#: tensorcircuit.applications.van.MaskedConv2D.losses:8 +#: tensorcircuit.applications.van.MaskedLinear.losses:8 +#: tensorcircuit.applications.van.NMF.losses:8 #: tensorcircuit.applications.van.NMF.metrics:6 #: tensorcircuit.applications.van.NMF.metrics_names:6 -#: tensorcircuit.applications.van.PixelCNN.losses:7 +#: tensorcircuit.applications.van.PixelCNN.losses:8 #: tensorcircuit.applications.van.PixelCNN.metrics:6 #: tensorcircuit.applications.van.PixelCNN.metrics_names:6 -#: tensorcircuit.applications.van.ResidualBlock.losses:7 -#: tensorcircuit.applications.vqes.Linear.losses:7 -#: tensorcircuit.keras.HardwareLayer.losses:7 -#: tensorcircuit.keras.QuantumLayer.losses:7 +#: tensorcircuit.applications.van.ResidualBlock.losses:8 +#: tensorcircuit.applications.vqes.Linear.losses:8 +#: tensorcircuit.keras.HardwareLayer.losses:8 +#: tensorcircuit.keras.QuantumLayer.losses:8 msgid "Examples:" msgstr "" -#: of tensorcircuit.applications.van.MADE.losses:39 -#: tensorcircuit.applications.van.MaskedConv2D.losses:39 -#: tensorcircuit.applications.van.MaskedLinear.losses:39 -#: tensorcircuit.applications.van.NMF.losses:39 -#: tensorcircuit.applications.van.PixelCNN.losses:39 -#: tensorcircuit.applications.van.ResidualBlock.losses:39 -#: tensorcircuit.applications.vqes.Linear.losses:39 -#: tensorcircuit.keras.HardwareLayer.losses:39 -#: tensorcircuit.keras.QuantumLayer.losses:39 +#: of tensorcircuit.applications.van.MADE.losses:40 +#: tensorcircuit.applications.van.MaskedConv2D.losses:40 +#: tensorcircuit.applications.van.MaskedLinear.losses:40 +#: tensorcircuit.applications.van.NMF.losses:40 +#: tensorcircuit.applications.van.PixelCNN.losses:40 +#: tensorcircuit.applications.van.ResidualBlock.losses:40 +#: tensorcircuit.applications.vqes.Linear.losses:40 +#: tensorcircuit.keras.HardwareLayer.losses:40 +#: tensorcircuit.keras.QuantumLayer.losses:40 msgid "A list of tensors." msgstr "" -#: keras.engine.training.Model.make_predict_function:1 of +#: keras.src.engine.training.Model.make_predict_function:1 of msgid "Creates a function that executes one step of inference." msgstr "" -#: keras.engine.training.Model.make_predict_function:3 of +#: keras.src.engine.training.Model.make_predict_function:3 of msgid "" "This method can be overridden to support custom inference logic. This " "method is called by `Model.predict` and `Model.predict_on_batch`." msgstr "" -#: keras.engine.training.Model.make_predict_function:6 of +#: keras.src.engine.training.Model.make_predict_function:6 of msgid "" "Typically, this method directly controls `tf.function` and " "`tf.distribute.Strategy` settings, and delegates the actual evaluation " "logic to `Model.predict_step`." msgstr "" -#: keras.engine.training.Model.make_predict_function:10 of +#: keras.src.engine.training.Model.make_predict_function:10 of msgid "" "This function is cached the first time `Model.predict` or " "`Model.predict_on_batch` is called. The cache is cleared whenever " @@ -5994,36 +6379,36 @@ msgid "" "function with `force=True`." msgstr "" -#: keras.engine.training.Model.make_predict_function:15 of +#: keras.src.engine.training.Model.make_predict_function:15 of msgid "" "Whether to regenerate the predict function and skip the cached function " "if available." msgstr "" -#: keras.engine.training.Model.make_predict_function:18 of +#: keras.src.engine.training.Model.make_predict_function:18 of msgid "" "Function. The function created by this method should accept a " "`tf.data.Iterator`, and return the outputs of the `Model`." msgstr "" -#: keras.engine.training.Model.make_test_function:1 of +#: keras.src.engine.training.Model.make_test_function:1 of msgid "Creates a function that executes one step of evaluation." msgstr "" -#: keras.engine.training.Model.make_test_function:3 of +#: keras.src.engine.training.Model.make_test_function:3 of msgid "" "This method can be overridden to support custom evaluation logic. This " "method is called by `Model.evaluate` and `Model.test_on_batch`." msgstr "" -#: keras.engine.training.Model.make_test_function:6 of +#: keras.src.engine.training.Model.make_test_function:6 of msgid "" "Typically, this method directly controls `tf.function` and " "`tf.distribute.Strategy` settings, and delegates the actual evaluation " "logic to `Model.test_step`." msgstr "" -#: keras.engine.training.Model.make_test_function:10 of +#: keras.src.engine.training.Model.make_test_function:10 of msgid "" "This function is cached the first time `Model.evaluate` or " "`Model.test_on_batch` is called. The cache is cleared whenever " @@ -6031,37 +6416,37 @@ msgid "" "function with `force=True`." msgstr "" -#: keras.engine.training.Model.make_test_function:15 of +#: keras.src.engine.training.Model.make_test_function:15 of msgid "" "Whether to regenerate the test function and skip the cached function if " "available." msgstr "" -#: keras.engine.training.Model.make_test_function:18 of +#: keras.src.engine.training.Model.make_test_function:18 of msgid "" "Function. The function created by this method should accept a " "`tf.data.Iterator`, and return a `dict` containing values that will be " "passed to `tf.keras.Callbacks.on_test_batch_end`." msgstr "" -#: keras.engine.training.Model.make_train_function:1 of +#: keras.src.engine.training.Model.make_train_function:1 of msgid "Creates a function that executes one step of training." msgstr "" -#: keras.engine.training.Model.make_train_function:3 of +#: keras.src.engine.training.Model.make_train_function:3 of msgid "" "This method can be overridden to support custom training logic. This " "method is called by `Model.fit` and `Model.train_on_batch`." msgstr "" -#: keras.engine.training.Model.make_train_function:6 of +#: keras.src.engine.training.Model.make_train_function:6 of msgid "" "Typically, this method directly controls `tf.function` and " "`tf.distribute.Strategy` settings, and delegates the actual training " "logic to `Model.train_step`." msgstr "" -#: keras.engine.training.Model.make_train_function:10 of +#: keras.src.engine.training.Model.make_train_function:10 of msgid "" "This function is cached the first time `Model.fit` or " "`Model.train_on_batch` is called. The cache is cleared whenever " @@ -6069,13 +6454,13 @@ msgid "" "function with `force=True`." msgstr "" -#: keras.engine.training.Model.make_train_function:15 of +#: keras.src.engine.training.Model.make_train_function:15 of msgid "" "Whether to regenerate the train function and skip the cached function if " "available." msgstr "" -#: keras.engine.training.Model.make_train_function:18 of +#: keras.src.engine.training.Model.make_train_function:18 of msgid "" "Function. The function created by this method should accept a " "`tf.data.Iterator`, and return a `dict` containing values that will be " @@ -6086,7 +6471,7 @@ msgstr "" #: of tensorcircuit.applications.van.MADE.metrics:1 #: tensorcircuit.applications.van.NMF.metrics:1 #: tensorcircuit.applications.van.PixelCNN.metrics:1 -msgid "Returns the model's metrics added using `compile()`, `add_metric()` APIs." +msgid "Return metrics added using `compile()` or `add_metric()`." msgstr "" #: of tensorcircuit.applications.van.MADE.metrics:3 @@ -6235,6 +6620,18 @@ msgstr "" msgid "A list of non-trainable variables." msgstr "" +#: of tensorcircuit.applications.van.MADE.outbound_nodes:1 +#: tensorcircuit.applications.van.MaskedConv2D.outbound_nodes:1 +#: tensorcircuit.applications.van.MaskedLinear.outbound_nodes:1 +#: tensorcircuit.applications.van.NMF.outbound_nodes:1 +#: tensorcircuit.applications.van.PixelCNN.outbound_nodes:1 +#: tensorcircuit.applications.van.ResidualBlock.outbound_nodes:1 +#: tensorcircuit.applications.vqes.Linear.outbound_nodes:1 +#: tensorcircuit.keras.HardwareLayer.outbound_nodes:1 +#: tensorcircuit.keras.QuantumLayer.outbound_nodes:1 +msgid "Return Functional API nodes downstream of this layer." +msgstr "" + #: of tensorcircuit.applications.van.MADE.output:1 #: tensorcircuit.applications.van.MaskedConv2D.output:1 #: tensorcircuit.applications.van.MaskedLinear.output:1 @@ -6361,22 +6758,45 @@ msgstr "" msgid "if the layer has no defined output shape." msgstr "" -#: keras.engine.training.Model.predict:1 of +#: keras.src.engine.training.Model.predict:1 of msgid "Generates output predictions for the input samples." msgstr "" -#: keras.engine.training.Model.predict:3 of +#: keras.src.engine.training.Model.predict:3 of +msgid "" +"Computation is done in batches. This method is designed for batch " +"processing of large numbers of inputs. It is not intended for use inside " +"of loops that iterate over your data and process small numbers of inputs " +"at a time." +msgstr "" + +#: keras.src.engine.training.Model.predict:8 of +msgid "" +"For small numbers of inputs that fit in one batch, directly use " +"`__call__()` for faster execution, e.g., `model(x)`, or `model(x, " +"training=False)` if you have layers such as " +"`tf.keras.layers.BatchNormalization` that behave differently during " +"inference. You may pair the individual model call with a `tf.function` " +"for additional performance inside your inner loop. If you need access to " +"numpy array values instead of tensors after your model call, you can use " +"`tensor.numpy()` to get the numpy array value of an eager tensor." +msgstr "" + +#: keras.src.engine.training.Model.predict:18 of +msgid "" +"Also, note the fact that test loss is not affected by regularization " +"layers like noise and dropout." +msgstr "" + +#: keras.src.engine.training.Model.predict:21 of msgid "" -"Computation is done in batches. This method is designed for performance " -"in large scale inputs. For small amount of inputs that fit in one batch, " -"directly using `__call__()` is recommended for faster execution, e.g., " -"`model(x)`, or `model(x, training=False)` if you have layers such as " -"`tf.keras.layers.BatchNormalization` that behaves differently during " -"inference. Also, note the fact that test loss is not affected by " -"regularization layers like noise and dropout." +"Note: See [this FAQ entry]( https://keras.io/getting_started/faq/#whats-" +"the-difference-between-model-methods-predict-and-call) for more details " +"about the difference between `Model` methods `predict()` and " +"`__call__()`." msgstr "" -#: keras.engine.training.Model.predict:11 of +#: keras.src.engine.training.Model.predict:26 of msgid "" "Input samples. It could be: - A Numpy array (or array-like), or a list of" " arrays (in case the model has multiple inputs). - A TensorFlow tensor," @@ -6387,21 +6807,21 @@ msgid "" "iterator-like inputs` section of `Model.fit`." msgstr "" -#: keras.engine.training.Model.predict:11 of +#: keras.src.engine.training.Model.predict:26 of msgid "" "Input samples. It could be: - A Numpy array (or array-like), or a list of" " arrays" msgstr "" -#: keras.engine.training.Model.predict:16 of +#: keras.src.engine.training.Model.predict:31 of msgid "A `tf.data` dataset." msgstr "" -#: keras.engine.training.Model.predict:17 of +#: keras.src.engine.training.Model.predict:32 of msgid "A generator or `keras.utils.Sequence` instance." msgstr "" -#: keras.engine.training.Model.predict:21 of +#: keras.src.engine.training.Model.predict:36 of msgid "" "Integer or `None`. Number of samples per batch. If unspecified, " "`batch_size` will default to 32. Do not specify the `batch_size` if your " @@ -6409,11 +6829,7 @@ msgid "" "instances (since they generate batches)." msgstr "" -#: keras.engine.training.Model.predict:27 of -msgid "Verbosity mode, 0 or 1." -msgstr "" - -#: keras.engine.training.Model.predict:28 of +#: keras.src.engine.training.Model.predict:49 of msgid "" "Total number of steps (batches of samples) before declaring the " "prediction round finished. Ignored with the default value of `None`. If x" @@ -6421,13 +6837,14 @@ msgid "" "the input dataset is exhausted." msgstr "" -#: keras.engine.training.Model.predict:33 of +#: keras.src.engine.training.Model.predict:54 of msgid "" "List of `keras.callbacks.Callback` instances. List of callbacks to apply " -"during prediction. See [callbacks](/api_docs/python/tf/keras/callbacks)." +"during prediction. See [callbacks]( " +"https://www.tensorflow.org/api_docs/python/tf/keras/callbacks)." msgstr "" -#: keras.engine.training.Model.predict:50 of +#: keras.src.engine.training.Model.predict:74 of msgid "" "See the discussion of `Unpacking behavior for iterator-like inputs` for " "`Model.fit`. Note that Model.predict uses the same interpretation rules " @@ -6435,105 +6852,105 @@ msgid "" "all three methods." msgstr "" -#: keras.engine.training.Model.predict:55 -#: keras.engine.training.Model.predict_on_batch:9 of +#: keras.src.engine.training.Model.predict:79 +#: keras.src.engine.training.Model.predict_on_batch:9 of msgid "Numpy array(s) of predictions." msgstr "" -#: keras.engine.training.Model.predict:57 of +#: keras.src.engine.training.Model.predict:81 of msgid "If `model.predict` is wrapped in a `tf.function`." msgstr "" -#: keras.engine.training.Model.predict:58 of +#: keras.src.engine.training.Model.predict:82 of msgid "" "In case of mismatch between the provided input data and the model's " "expectations, or in case a stateful model receives a number of " "samples that is not a multiple of the batch size." msgstr "" -#: keras.engine.training.Model.predict_generator:1 of +#: keras.src.engine.training.Model.predict_generator:1 of msgid "Generates predictions for the input samples from a data generator." msgstr "" -#: keras.engine.training.Model.predict_generator:4 of +#: keras.src.engine.training.Model.predict_generator:4 of msgid "" "`Model.predict` now supports generators, so there is no longer any need " "to use this endpoint." msgstr "" -#: keras.engine.training.Model.predict_on_batch:1 of +#: keras.src.engine.training.Model.predict_on_batch:1 of msgid "Returns predictions for a single batch of samples." msgstr "" -#: keras.engine.training.Model.predict_on_batch:3 of +#: keras.src.engine.training.Model.predict_on_batch:3 of msgid "" "Input data. It could be: - A Numpy array (or array-like), or a list of " "arrays (in case the model has multiple inputs). - A TensorFlow " "tensor, or a list of tensors (in case the model has multiple inputs)." msgstr "" -#: keras.engine.training.Model.predict_on_batch:3 -#: keras.engine.training.Model.test_on_batch:3 of +#: keras.src.engine.training.Model.predict_on_batch:3 +#: keras.src.engine.training.Model.test_on_batch:3 of msgid "" "Input data. It could be: - A Numpy array (or array-like), or a list of " "arrays (in case the" msgstr "" -#: keras.engine.training.Model.predict_on_batch:5 -#: keras.engine.training.Model.test_on_batch:5 of +#: keras.src.engine.training.Model.predict_on_batch:5 +#: keras.src.engine.training.Model.test_on_batch:5 of msgid "model has multiple inputs)." msgstr "" -#: keras.engine.training.Model.predict_on_batch:7 -#: keras.engine.training.Model.test_on_batch:6 of +#: keras.src.engine.training.Model.predict_on_batch:7 +#: keras.src.engine.training.Model.test_on_batch:6 of msgid "A TensorFlow tensor, or a list of tensors (in case the model has" msgstr "" -#: keras.engine.training.Model.predict_on_batch:7 -#: keras.engine.training.Model.test_on_batch:7 of +#: keras.src.engine.training.Model.predict_on_batch:7 +#: keras.src.engine.training.Model.test_on_batch:7 of msgid "multiple inputs)." msgstr "" -#: keras.engine.training.Model.predict_on_batch:11 of -msgid "If `model.predict_on_batch` is wrapped in a `tf.function`." +#: keras.src.engine.training.Model.predict_on_batch:11 of +msgid "If `model.predict_on_batch` is wrapped in a `tf.function`." msgstr "" -#: keras.engine.training.Model.predict_step:1 of +#: keras.src.engine.training.Model.predict_step:1 of msgid "The logic for one inference step." msgstr "" -#: keras.engine.training.Model.predict_step:3 of +#: keras.src.engine.training.Model.predict_step:3 of msgid "" "This method can be overridden to support custom inference logic. This " "method is called by `Model.make_predict_function`." msgstr "" -#: keras.engine.training.Model.predict_step:6 of +#: keras.src.engine.training.Model.predict_step:6 of msgid "" "This method should contain the mathematical logic for one step of " -"inference. This typically includes the forward pass." +"inference. This typically includes the forward pass." msgstr "" -#: keras.engine.training.Model.predict_step:9 of +#: keras.src.engine.training.Model.predict_step:9 of msgid "" "Configuration details for *how* this logic is run (e.g. `tf.function` and" " `tf.distribute.Strategy` settings), should be left to " "`Model.make_predict_function`, which can also be overridden." msgstr "" -#: keras.engine.training.Model.predict_step:13 -#: keras.engine.training.Model.test_step:15 -#: keras.engine.training.Model.train_step:16 of +#: keras.src.engine.training.Model.predict_step:13 +#: keras.src.engine.training.Model.test_step:15 +#: keras.src.engine.training.Model.train_step:17 of msgid "A nested structure of `Tensor`s." msgstr "" -#: keras.engine.training.Model.predict_step:15 of +#: keras.src.engine.training.Model.predict_step:15 of msgid "" "The result of one inference step, typically the output of calling the " "`Model` on data." msgstr "" -#: keras.engine.training.Model.reset_metrics:1 of +#: keras.src.engine.training.Model.reset_metrics:1 of msgid "Resets the state of all the metrics in the model." msgstr "" @@ -6566,124 +6983,170 @@ msgstr "" msgid "Boolean, whether the model should run eagerly." msgstr "" -#: keras.engine.training.Model.save:1 of -msgid "Saves the model to Tensorflow SavedModel or a single HDF5 file." +#: keras.src.engine.training.Model.save:1 of +msgid "Saves a model as a TensorFlow SavedModel or HDF5 file." msgstr "" -#: keras.engine.training.Model.save:3 of -msgid "" -"Please see `tf.keras.models.save_model` or the [Serialization and Saving " -"guide](https://keras.io/guides/serialization_and_saving/) for details." +#: keras.src.engine.training.Model.save:4 of +msgid "See the [Serialization and Saving guide](" msgstr "" -#: keras.engine.training.Model.save:7 of -msgid "String, PathLike, path to SavedModel or H5 file to save the model." +#: keras.src.engine.training.Model.save:4 of +msgid "https://keras.io/guides/serialization_and_saving/) for details." msgstr "" -#: keras.engine.training.Model.save:9 -#: keras.engine.training.Model.save_weights:47 of -msgid "" -"Whether to silently overwrite any existing file at the target location, " -"or provide the user with a manual prompt." +#: keras.src.engine.training.Model.save:6 of +msgid "Keras model instance to be saved." +msgstr "" + +#: keras.src.engine.training.Model.save:7 of +msgid "`str` or `pathlib.Path` object. Path where to save the model." msgstr "" -#: keras.engine.training.Model.save:11 of -msgid "If True, save optimizer's state together." +#: keras.src.engine.training.Model.save:9 of +msgid "" +"Whether we should overwrite any existing model at the target location, or" +" instead ask the user via an interactive prompt." msgstr "" -#: keras.engine.training.Model.save:12 of +#: keras.src.engine.training.Model.save:12 of msgid "" -"Either `'tf'` or `'h5'`, indicating whether to save the model to " -"Tensorflow SavedModel or HDF5. Defaults to 'tf' in TF 2.X, and 'h5' in TF" -" 1.X." +"Either `\"keras\"`, `\"tf\"`, `\"h5\"`, indicating whether to save the " +"model in the native Keras format (`.keras`), in the TensorFlow SavedModel" +" format (referred to as \"SavedModel\" below), or in the legacy HDF5 " +"format (`.h5`). Defaults to `\"tf\"` in TF 2.X, and `\"h5\"` in TF 1.X." +msgstr "" + +#: keras.src.engine.training.Model.save:36 of +msgid "SavedModel format arguments:" +msgstr "" + +#: keras.src.engine.training.Model.save:22 of +msgid "include_optimizer: Only applied to SavedModel and legacy HDF5" +msgstr "" + +#: keras.src.engine.training.Model.save:22 of +msgid "formats. If False, do not save the optimizer state. Defaults to `True`." msgstr "" -#: keras.engine.training.Model.save:15 of +#: keras.src.engine.training.Model.save:25 of +msgid "signatures: Only applies to SavedModel format. Signatures to save" +msgstr "" + +#: keras.src.engine.training.Model.save:25 of msgid "" -"Signatures to save with the SavedModel. Applicable to the 'tf' format " -"only. Please see the `signatures` argument in `tf.saved_model.save` for " -"details." +"with the SavedModel. See the `signatures` argument in " +"`tf.saved_model.save` for details." +msgstr "" + +#: keras.src.engine.training.Model.save:28 of +msgid "options: Only applies to SavedModel format." msgstr "" -#: keras.engine.training.Model.save:18 of +#: keras.src.engine.training.Model.save:28 of msgid "" -"(only applies to SavedModel format) `tf.saved_model.SaveOptions` object " -"that specifies options for saving to SavedModel." +"`tf.saved_model.SaveOptions` object that specifies SavedModel saving " +"options." msgstr "" -#: keras.engine.training.Model.save:21 of +#: keras.src.engine.training.Model.save:36 of +msgid "save_traces: Only applies to SavedModel format. When enabled, the" +msgstr "" + +#: keras.src.engine.training.Model.save:31 of msgid "" -"(only applies to SavedModel format) When enabled, the SavedModel will " -"store the function traces for each layer. This can be disabled, so that " -"only the configs of each layer are stored. Defaults to `True`. Disabling " -"this will decrease serialization time and reduce file size, but it " -"requires that all custom layers/models implement a `get_config()` method." +"SavedModel will store the function traces for each layer. This can be " +"disabled, so that only the configs of each layer are stored. Defaults to " +"`True`. Disabling this will decrease serialization time and reduce file " +"size, but it requires that all custom layers/models implement a " +"`get_config()` method." +msgstr "" + +#: keras.src.engine.training.Model.save:40 of +msgid "```python model = tf.keras.Sequential([" msgstr "" -#: keras.engine.training.Model.save:30 of -msgid "```python from keras.models import load_model" +#: keras.src.engine.training.Model.save:42 of +msgid "tf.keras.layers.Dense(5, input_shape=(3,)), tf.keras.layers.Softmax()])" msgstr "" -#: keras.engine.training.Model.save:33 of +#: keras.src.engine.training.Model.save:44 of msgid "" -"model.save('my_model.h5') # creates a HDF5 file 'my_model.h5' del model" -" # deletes the existing model" +"model.save(\"model.keras\") loaded_model = " +"tf.keras.models.load_model(\"model.keras\") x = tf.random.uniform((10, " +"3)) assert np.allclose(model.predict(x), loaded_model.predict(x)) ```" msgstr "" -#: keras.engine.training.Model.save:36 of +#: keras.src.engine.training.Model.save:50 of +msgid "Note that `model.save()` is an alias for `tf.keras.models.save_model()`." +msgstr "" + +#: keras.src.engine.base_layer.Layer.save_own_variables:1 of +msgid "Saves the state of the layer." +msgstr "" + +#: keras.src.engine.base_layer.Layer.save_own_variables:3 of msgid "" -"# returns a compiled model # identical to the previous one model = " -"load_model('my_model.h5') ```" +"You can override this method to take full control of how the state of the" +" layer is saved upon calling `model.save()`." msgstr "" -#: keras.engine.training.Model.save_spec:1 of -msgid "Returns the `tf.TensorSpec` of call inputs as a tuple `(args, kwargs)`." +#: keras.src.engine.base_layer.Layer.save_own_variables:6 of +msgid "Dict where the state of the model will be saved." msgstr "" -#: keras.engine.training.Model.save_spec:3 of +#: keras.src.engine.training.Model.save_spec:1 of +msgid "Returns the `tf.TensorSpec` of call args as a tuple `(args, kwargs)`." +msgstr "" + +#: keras.src.engine.training.Model.save_spec:3 of msgid "" "This value is automatically defined after calling the model for the first" " time. Afterwards, you can use it when exporting the model for serving:" msgstr "" -#: keras.engine.training.Model.save_spec:6 of +#: keras.src.engine.training.Model.save_spec:7 of msgid "```python model = tf.keras.Model(...)" msgstr "" -#: keras.engine.training.Model.save_spec:9 of +#: keras.src.engine.training.Model.save_spec:10 of msgid "@tf.function def serve(*args, **kwargs):" msgstr "" -#: keras.engine.training.Model.save_spec:11 of +#: keras.src.engine.training.Model.save_spec:12 of msgid "" "outputs = model(*args, **kwargs) # Apply postprocessing steps, or add " "additional outputs. ... return outputs" msgstr "" -#: keras.engine.training.Model.save_spec:16 of +#: keras.src.engine.training.Model.save_spec:17 of msgid "" -"# arg_specs is `[tf.TensorSpec(...), ...]`. kwarg_specs, in this example," -" is # an empty dict since functional models do not use keyword arguments." -" arg_specs, kwarg_specs = model.save_spec()" +"# arg_specs is `[tf.TensorSpec(...), ...]`. kwarg_specs, in this # " +"example, is an empty dict since functional models do not use keyword # " +"arguments. arg_specs, kwarg_specs = model.save_spec()" msgstr "" -#: keras.engine.training.Model.save_spec:20 of +#: keras.src.engine.training.Model.save_spec:23 of msgid "model.save(path, signatures={" msgstr "" -#: keras.engine.training.Model.save_spec:21 of -msgid "'serving_default': serve.get_concrete_function(*arg_specs, **kwarg_specs)" +#: keras.src.engine.training.Model.save_spec:23 of +msgid "'serving_default': serve.get_concrete_function(*arg_specs," +msgstr "" + +#: keras.src.engine.training.Model.save_spec:24 of +msgid "**kwarg_specs)" msgstr "" -#: keras.engine.training.Model.save_spec:23 of +#: keras.src.engine.training.Model.save_spec:26 of msgid "})" msgstr "" -#: keras.engine.training.Model.save_spec of +#: keras.src.engine.training.Model.save_spec of msgid "param dynamic_batch" msgstr "" -#: keras.engine.training.Model.save_spec:25 of +#: keras.src.engine.training.Model.save_spec:28 of msgid "" "Whether to set the batch sizes of all the returned `tf.TensorSpec` to " "`None`. (Note that when defining functional or Sequential models with " @@ -6691,11 +7154,11 @@ msgid "" "preserved). Defaults to `True`." msgstr "" -#: keras.engine.training.Model.save_spec of +#: keras.src.engine.training.Model.save_spec of msgid "returns" msgstr "" -#: keras.engine.training.Model.save_spec:30 of +#: keras.src.engine.training.Model.save_spec:33 of msgid "" "If the model inputs are defined, returns a tuple `(args, kwargs)`. All " "elements in `args` and `kwargs` are `tf.TensorSpec`. If the model inputs " @@ -6703,49 +7166,49 @@ msgid "" "when calling the model, `model.fit`, `model.evaluate` or `model.predict`." msgstr "" -#: keras.engine.training.Model.save_weights:1 of +#: keras.src.engine.training.Model.save_weights:1 of msgid "Saves all layer weights." msgstr "" -#: keras.engine.training.Model.save_weights:3 of +#: keras.src.engine.training.Model.save_weights:3 of msgid "" "Either saves in HDF5 or in TensorFlow format based on the `save_format` " "argument." msgstr "" -#: keras.engine.training.Model.save_weights:14 of +#: keras.src.engine.training.Model.save_weights:14 of msgid "When saving in HDF5 format, the weight file has:" msgstr "" -#: keras.engine.training.Model.save_weights:7 of +#: keras.src.engine.training.Model.save_weights:7 of msgid "`layer_names` (attribute), a list of strings" msgstr "" -#: keras.engine.training.Model.save_weights:8 of +#: keras.src.engine.training.Model.save_weights:8 of msgid "(ordered names of model layers)." msgstr "" -#: keras.engine.training.Model.save_weights:14 of +#: keras.src.engine.training.Model.save_weights:14 of msgid "For every layer, a `group` named `layer.name`" msgstr "" -#: keras.engine.training.Model.save_weights:11 of +#: keras.src.engine.training.Model.save_weights:11 of msgid "For every such layer group, a group attribute `weight_names`," msgstr "" -#: keras.engine.training.Model.save_weights:11 of +#: keras.src.engine.training.Model.save_weights:11 of msgid "a list of strings (ordered names of weights tensor of the layer)." msgstr "" -#: keras.engine.training.Model.save_weights:14 of +#: keras.src.engine.training.Model.save_weights:14 of msgid "For every weight in the layer, a dataset" msgstr "" -#: keras.engine.training.Model.save_weights:14 of +#: keras.src.engine.training.Model.save_weights:14 of msgid "storing the weight value, named after the weight tensor." msgstr "" -#: keras.engine.training.Model.save_weights:16 of +#: keras.src.engine.training.Model.save_weights:16 of msgid "" "When saving in TensorFlow format, all objects referenced by the network " "are saved in the same format as `tf.train.Checkpoint`, including any " @@ -6758,7 +7221,7 @@ msgid "" "`tf.train.Checkpoint` and `tf.keras.Model` for details." msgstr "" -#: keras.engine.training.Model.save_weights:26 of +#: keras.src.engine.training.Model.save_weights:26 of msgid "" "While the formats are the same, do not mix `save_weights` and " "`tf.train.Checkpoint`. Checkpoints saved by `Model.save_weights` should " @@ -6768,7 +7231,7 @@ msgid "" "`save_weights` for training checkpoints." msgstr "" -#: keras.engine.training.Model.save_weights:33 of +#: keras.src.engine.training.Model.save_weights:33 of msgid "" "The TensorFlow format matches objects and variables by starting at a root" " object, `self` for `save_weights`, and greedily matching attribute " @@ -6777,11 +7240,11 @@ msgid "" "This means saving a `tf.keras.Model` using `save_weights` and loading " "into a `tf.train.Checkpoint` with a `Model` attached (or vice versa) will" " not match the `Model`'s variables. See the [guide to training " -"checkpoints](https://www.tensorflow.org/guide/checkpoint) for details on " -"the TensorFlow format." +"checkpoints]( https://www.tensorflow.org/guide/checkpoint) for details on" +" the TensorFlow format." msgstr "" -#: keras.engine.training.Model.save_weights:43 of +#: keras.src.engine.training.Model.save_weights:44 of msgid "" "String or PathLike, path to the file to save the weights to. When saving " "in TensorFlow format, this is the prefix used for checkpoint files " @@ -6789,28 +7252,34 @@ msgid "" " to be saved in HDF5 format." msgstr "" -#: keras.engine.training.Model.save_weights:49 of +#: keras.src.engine.training.Model.save_weights:48 of +msgid "" +"Whether to silently overwrite any existing file at the target location, " +"or provide the user with a manual prompt." +msgstr "" + +#: keras.src.engine.training.Model.save_weights:50 of msgid "" "Either 'tf' or 'h5'. A `filepath` ending in '.h5' or '.keras' will " -"default to HDF5 if `save_format` is `None`. Otherwise `None` defaults to " -"'tf'." +"default to HDF5 if `save_format` is `None`. Otherwise, `None` becomes " +"'tf'. Defaults to `None`." msgstr "" -#: keras.engine.training.Model.save_weights:52 of +#: keras.src.engine.training.Model.save_weights:53 of msgid "" "Optional `tf.train.CheckpointOptions` object that specifies options for " "saving weights." msgstr "" -#: keras.engine.training.Model.save_weights:55 of -msgid "If `h5py` is not available when attempting to save in HDF5 format." +#: keras.src.engine.training.Model.save_weights:56 of +msgid "If `h5py` is not available when attempting to save in HDF5 format." msgstr "" -#: keras.engine.base_layer.Layer.set_weights:1 of +#: keras.src.engine.base_layer.Layer.set_weights:1 of msgid "Sets the weights of the layer, from NumPy arrays." msgstr "" -#: keras.engine.base_layer.Layer.set_weights:3 of +#: keras.src.engine.base_layer.Layer.set_weights:3 of msgid "" "The weights of a layer represent the state of the layer. This function " "sets the weight values from numpy arrays. The weight values should be " @@ -6819,27 +7288,33 @@ msgid "" " layer." msgstr "" -#: keras.engine.base_layer.Layer.get_weights:8 -#: keras.engine.base_layer.Layer.set_weights:9 of +#: keras.src.engine.base_layer.Layer.get_weights:8 +#: keras.src.engine.base_layer.Layer.set_weights:9 of msgid "" "For example, a `Dense` layer returns a list of two values: the kernel " "matrix and the bias vector. These can be used to set the weights of " "another `Dense` layer:" msgstr "" -#: keras.engine.base_layer.Layer.set_weights:33 of +#: keras.src.engine.base_layer.Layer.set_weights:33 of msgid "" "a list of NumPy arrays. The number of arrays and their shape must match " "number of the dimensions of the weights of the layer (i.e. it should " "match the output of `get_weights`)." msgstr "" -#: keras.engine.base_layer.Layer.set_weights:39 of +#: keras.src.engine.base_layer.Layer.set_weights:39 of msgid "" "If the provided weights list does not match the layer's " "specifications." msgstr "" +#: of tensorcircuit.applications.van.MADE.state_updates:1 +#: tensorcircuit.applications.van.NMF.state_updates:1 +#: tensorcircuit.applications.van.PixelCNN.state_updates:1 +msgid "Deprecated, do NOT use!" +msgstr "" + #: of tensorcircuit.applications.van.MADE.state_updates:3 #: tensorcircuit.applications.van.NMF.state_updates:3 #: tensorcircuit.applications.van.PixelCNN.state_updates:3 @@ -6898,34 +7373,50 @@ msgstr "" msgid "A sequence of all submodules." msgstr "" -#: keras.engine.training.Model.summary:1 of +#: keras.src.engine.training.Model.summary:1 of msgid "Prints a string summary of the network." msgstr "" -#: keras.engine.training.Model.summary:3 of +#: keras.src.engine.training.Model.summary:3 of msgid "" "Total length of printed lines (e.g. set this to adapt the display to " "different terminal window sizes)." msgstr "" -#: keras.engine.training.Model.summary:6 of +#: keras.src.engine.training.Model.summary:6 of msgid "" "Relative or absolute positions of log elements in each line. If not " -"provided, defaults to `[.33, .55, .67, 1.]`." +"provided, becomes `[0.3, 0.6, 0.70, 1.]`. Defaults to `None`." msgstr "" -#: keras.engine.training.Model.summary:9 of +#: keras.src.engine.training.Model.summary:9 of msgid "" -"Print function to use. Defaults to `print`. It will be called on each " -"line of the summary. You can set it to a custom function in order to " -"capture the string summary." +"Print function to use. By default, prints to `stdout`. If `stdout` " +"doesn't work in your environment, change to `print`. It will be called on" +" each line of the summary. You can set it to a custom function in order " +"to capture the string summary." +msgstr "" + +#: keras.src.engine.training.Model.summary:14 of +msgid "Whether to expand the nested models. Defaults to `False`." msgstr "" -#: keras.engine.training.Model.summary:13 of -msgid "Whether to expand the nested models. If not provided, defaults to `False`." +#: keras.src.engine.training.Model.summary:16 of +msgid "Whether to show if a layer is trainable. Defaults to `False`." msgstr "" -#: keras.engine.training.Model.summary:16 of +#: keras.src.engine.training.Model.summary:18 of +msgid "" +"a list or tuple of 2 strings, which is the starting layer name and ending" +" layer name (both inclusive) indicating the range of layers to be printed" +" in summary. It also accepts regex patterns instead of exact name. In " +"such case, start predicate will be the first element it matches to " +"`layer_range[0]` and the end predicate will be the last element it " +"matches to `layer_range[1]`. By default `None` which considers all layers" +" of model." +msgstr "" + +#: keras.src.engine.training.Model.summary:27 of msgid "if `summary()` is called before the model is built." msgstr "" @@ -6941,37 +7432,38 @@ msgstr "" msgid "Whether this layer supports computing a mask using `compute_mask`." msgstr "" -#: keras.engine.training.Model.test_on_batch:1 of +#: keras.src.engine.training.Model.test_on_batch:1 of msgid "Test the model on a single batch of samples." msgstr "" -#: keras.engine.training.Model.test_on_batch:3 of +#: keras.src.engine.training.Model.test_on_batch:3 of msgid "" "Input data. It could be: - A Numpy array (or array-like), or a list of " "arrays (in case the model has multiple inputs). - A TensorFlow " "tensor, or a list of tensors (in case the model has multiple inputs)." -" - A dict mapping input names to the corresponding array/tensors, if " +" - A dict mapping input names to the corresponding array/tensors, if " "the model has named inputs." msgstr "" -#: keras.engine.training.Model.test_on_batch:8 of -msgid "A dict mapping input names to the corresponding array/tensors, if" +#: keras.src.engine.training.Model.test_on_batch:8 +#: keras.src.engine.training.Model.train_on_batch:8 of +msgid "A dict mapping input names to the corresponding array/tensors," msgstr "" -#: keras.engine.training.Model.test_on_batch:9 of -msgid "the model has named inputs." +#: keras.src.engine.training.Model.test_on_batch:9 +#: keras.src.engine.training.Model.train_on_batch:9 of +msgid "if the model has named inputs." msgstr "" -#: keras.engine.training.Model.test_on_batch:10 -#: keras.engine.training.Model.train_on_batch:10 of +#: keras.src.engine.training.Model.test_on_batch:10 of msgid "" "Target data. Like the input data `x`, it could be either Numpy array(s) " "or TensorFlow tensor(s). It should be consistent with `x` (you cannot " "have Numpy inputs and tensor targets, or inversely)." msgstr "" -#: keras.engine.training.Model.test_on_batch:13 -#: keras.engine.training.Model.train_on_batch:13 of +#: keras.src.engine.training.Model.test_on_batch:13 +#: keras.src.engine.training.Model.train_on_batch:12 of msgid "" "Optional array of the same length as x, containing weights to apply to " "the model's loss for each sample. In the case of temporal data, you can " @@ -6979,105 +7471,105 @@ msgid "" "different weight to every timestep of every sample." msgstr "" -#: keras.engine.training.Model.test_on_batch:18 -#: keras.engine.training.Model.train_on_batch:22 of +#: keras.src.engine.training.Model.test_on_batch:18 +#: keras.src.engine.training.Model.train_on_batch:24 of msgid "" "If `True`, the metrics returned will be only for this batch. If `False`, " "the metrics will be statefully accumulated across batches." msgstr "" -#: keras.engine.training.Model.test_on_batch:30 of -msgid "If `model.test_on_batch` is wrapped in a `tf.function`." +#: keras.src.engine.training.Model.test_on_batch:30 of +msgid "If `model.test_on_batch` is wrapped in a `tf.function`." msgstr "" -#: keras.engine.training.Model.test_step:1 of +#: keras.src.engine.training.Model.test_step:1 of msgid "The logic for one evaluation step." msgstr "" -#: keras.engine.training.Model.test_step:3 of +#: keras.src.engine.training.Model.test_step:3 of msgid "" "This method can be overridden to support custom evaluation logic. This " "method is called by `Model.make_test_function`." msgstr "" -#: keras.engine.training.Model.test_step:6 of +#: keras.src.engine.training.Model.test_step:6 of msgid "" "This function should contain the mathematical logic for one step of " "evaluation. This typically includes the forward pass, loss calculation, " "and metrics updates." msgstr "" -#: keras.engine.training.Model.test_step:11 of +#: keras.src.engine.training.Model.test_step:11 of msgid "" "Configuration details for *how* this logic is run (e.g. `tf.function` and" " `tf.distribute.Strategy` settings), should be left to " "`Model.make_test_function`, which can also be overridden." msgstr "" -#: keras.engine.training.Model.test_step:17 of +#: keras.src.engine.training.Model.test_step:17 of msgid "" "A `dict` containing values that will be passed to " "`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the " "values of the `Model`'s metrics are returned." msgstr "" -#: keras.engine.training.Model.to_json:1 of +#: keras.src.engine.training.Model.to_json:1 of msgid "Returns a JSON string containing the network configuration." msgstr "" -#: keras.engine.training.Model.to_json:3 of +#: keras.src.engine.training.Model.to_json:3 of msgid "" "To load a network from a JSON save file, use " "`keras.models.model_from_json(json_string, custom_objects={})`." msgstr "" -#: keras.engine.training.Model.to_json:6 of -msgid "Additional keyword arguments to be passed to `json.dumps()`." +#: keras.src.engine.training.Model.to_json:6 of +msgid "Additional keyword arguments to be passed to *`json.dumps()`." msgstr "" -#: keras.engine.training.Model.to_json:9 of +#: keras.src.engine.training.Model.to_json:9 of msgid "A JSON string." msgstr "" -#: keras.engine.training.Model.to_yaml:1 of +#: keras.src.engine.training.Model.to_yaml:1 of msgid "Returns a yaml string containing the network configuration." msgstr "" -#: keras.engine.training.Model.to_yaml:3 of +#: keras.src.engine.training.Model.to_yaml:3 of msgid "" "Note: Since TF 2.6, this method is no longer supported and will raise a " "RuntimeError." msgstr "" -#: keras.engine.training.Model.to_yaml:6 of +#: keras.src.engine.training.Model.to_yaml:6 of msgid "" "To load a network from a yaml save file, use " "`keras.models.model_from_yaml(yaml_string, custom_objects={})`." msgstr "" -#: keras.engine.training.Model.to_yaml:9 of +#: keras.src.engine.training.Model.to_yaml:9 of msgid "" "`custom_objects` should be a dictionary mapping the names of custom " "losses / layers / etc to the corresponding functions / classes." msgstr "" -#: keras.engine.training.Model.to_yaml:13 of +#: keras.src.engine.training.Model.to_yaml:13 of msgid "Additional keyword arguments to be passed to `yaml.dump()`." msgstr "" -#: keras.engine.training.Model.to_yaml:16 of +#: keras.src.engine.training.Model.to_yaml:16 of msgid "A YAML string." msgstr "" -#: keras.engine.training.Model.to_yaml:18 of +#: keras.src.engine.training.Model.to_yaml:18 of msgid "announces that the method poses a security risk" msgstr "" -#: keras.engine.training.Model.train_on_batch:1 of +#: keras.src.engine.training.Model.train_on_batch:1 of msgid "Runs a single gradient update on a single batch of data." msgstr "" -#: keras.engine.training.Model.train_on_batch:3 of +#: keras.src.engine.training.Model.train_on_batch:3 of msgid "" "Input data. It could be: - A Numpy array (or array-like), or a list of " "arrays (in case the model has multiple inputs). - A TensorFlow " @@ -7086,27 +7578,28 @@ msgid "" "the model has named inputs." msgstr "" -#: keras.engine.training.Model.train_on_batch:6 of +#: keras.src.engine.training.Model.train_on_batch:6 of msgid "A TensorFlow tensor, or a list of tensors" msgstr "" -#: keras.engine.training.Model.train_on_batch:8 of -msgid "A dict mapping input names to the corresponding array/tensors," -msgstr "" - -#: keras.engine.training.Model.train_on_batch:9 of -msgid "if the model has named inputs." +#: keras.src.engine.training.Model.train_on_batch:10 of +msgid "" +"Target data. Like the input data `x`, it could be either Numpy array(s) " +"or TensorFlow tensor(s)." msgstr "" -#: keras.engine.training.Model.train_on_batch:18 of +#: keras.src.engine.training.Model.train_on_batch:17 of msgid "" "Optional dictionary mapping class indices (integers) to a weight (float) " "to apply to the model's loss for the samples from this class during " "training. This can be useful to tell the model to \"pay more attention\" " -"to samples from an under-represented class." +"to samples from an under-represented class. When `class_weight` is " +"specified and targets have a rank of 2 or greater, either `y` must be " +"one-hot encoded, or an explicit final dimension of `1` must be included " +"for sparse class labels." msgstr "" -#: keras.engine.training.Model.train_on_batch:29 of +#: keras.src.engine.training.Model.train_on_batch:31 of msgid "" "Scalar training loss (if the model has a single output and no metrics) or" " list of scalars (if the model has multiple outputs and/or metrics). The " @@ -7114,38 +7607,38 @@ msgid "" "scalar outputs." msgstr "" -#: keras.engine.training.Model.train_on_batch:35 of +#: keras.src.engine.training.Model.train_on_batch:37 of msgid "If `model.train_on_batch` is wrapped in a `tf.function`." msgstr "" -#: keras.engine.training.Model.train_step:1 of +#: keras.src.engine.training.Model.train_step:1 of msgid "The logic for one training step." msgstr "" -#: keras.engine.training.Model.train_step:3 of +#: keras.src.engine.training.Model.train_step:3 of msgid "" "This method can be overridden to support custom training logic. For " "concrete examples of how to override this method see [Customizing what " -"happends in " -"fit](https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit)." -" This method is called by `Model.make_train_function`." +"happens in fit]( " +"https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit). " +"This method is called by `Model.make_train_function`." msgstr "" -#: keras.engine.training.Model.train_step:8 of +#: keras.src.engine.training.Model.train_step:9 of msgid "" "This method should contain the mathematical logic for one step of " -"training. This typically includes the forward pass, loss calculation, " +"training. This typically includes the forward pass, loss calculation, " "backpropagation, and metric updates." msgstr "" -#: keras.engine.training.Model.train_step:12 of +#: keras.src.engine.training.Model.train_step:13 of msgid "" "Configuration details for *how* this logic is run (e.g. `tf.function` and" " `tf.distribute.Strategy` settings), should be left to " "`Model.make_train_function`, which can also be overridden." msgstr "" -#: keras.engine.training.Model.train_step:18 of +#: keras.src.engine.training.Model.train_step:19 of msgid "" "A `dict` containing values that will be passed to " "`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the " @@ -7306,33 +7799,36 @@ msgstr "" #: tensorcircuit.applications.van.MaskedLinear:1 #: tensorcircuit.applications.van.ResidualBlock:1 #: tensorcircuit.applications.vqes.Linear:1 tensorcircuit.keras.QuantumLayer:1 -msgid "Bases: :py:class:`~keras.engine.base_layer.Layer`" +msgid "Bases: :py:class:`~keras.src.engine.base_layer.Layer`" msgstr "" -#: keras.engine.base_layer.Layer.build:1 of +#: keras.src.engine.base_layer.Layer.build:1 of #: tensorcircuit.applications.van.MaskedConv2D.build:1 #: tensorcircuit.keras.QuantumLayer.build:1 -msgid "Creates the variables of the layer (optional, for subclass implementers)." +msgid "Creates the variables of the layer (for subclass implementers)." msgstr "" -#: keras.engine.base_layer.Layer.build:3 of +#: keras.src.engine.base_layer.Layer.build:3 of #: tensorcircuit.applications.van.MaskedConv2D.build:3 #: tensorcircuit.keras.QuantumLayer.build:3 msgid "" "This is a method that implementers of subclasses of `Layer` or `Model` " "can override if they need a state-creation step in-between layer " -"instantiation and layer call." +"instantiation and layer call. It is invoked automatically before the " +"first execution of `call()`." msgstr "" -#: keras.engine.base_layer.Layer.build:7 of -#: tensorcircuit.applications.van.MaskedConv2D.build:7 -#: tensorcircuit.keras.QuantumLayer.build:7 -msgid "This is typically used to create the weights of `Layer` subclasses." +#: keras.src.engine.base_layer.Layer.build:8 of +#: tensorcircuit.applications.van.MaskedConv2D.build:8 +#: tensorcircuit.keras.QuantumLayer.build:8 +msgid "" +"This is typically used to create the weights of `Layer` subclasses (at " +"the discretion of the subclass implementer)." msgstr "" -#: keras.engine.base_layer.Layer.build:9 of -#: tensorcircuit.applications.van.MaskedConv2D.build:9 -#: tensorcircuit.keras.QuantumLayer.build:9 +#: keras.src.engine.base_layer.Layer.build:11 of +#: tensorcircuit.applications.van.MaskedConv2D.build:11 +#: tensorcircuit.keras.QuantumLayer.build:11 msgid "" "Instance of `TensorShape`, or list of instances of `TensorShape` if the " "layer expects a list of inputs (one instance per input)." @@ -7350,81 +7846,79 @@ msgstr "" #: tensorcircuit.applications.van.ResidualBlock.call:3 #: tensorcircuit.applications.vqes.Linear.call:3 msgid "" -"Note here that `call()` method in `tf.keras` is little bit different from" -" `keras` API. In `keras` API, you can pass support masking for layers as " -"additional arguments. Whereas `tf.keras` has `compute_mask()` method to " -"support masking." +"The `call()` method may not create state (except in its first invocation," +" wrapping the creation of variables or other resources in " +"`tf.init_scope()`). It is recommended to create state, including " +"`tf.Variable` instances and nested `Layer` instances," +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:7 +#: tensorcircuit.applications.van.MaskedLinear.call:7 +#: tensorcircuit.applications.van.ResidualBlock.call:7 +#: tensorcircuit.applications.vqes.Linear.call:7 +msgid "in `__init__()`, or in the `build()` method that is" msgstr "" #: of tensorcircuit.applications.van.MaskedConv2D.call:8 #: tensorcircuit.applications.van.MaskedLinear.call:8 #: tensorcircuit.applications.van.ResidualBlock.call:8 #: tensorcircuit.applications.vqes.Linear.call:8 +msgid "called automatically before `call()` executes for the first time." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:10 +#: tensorcircuit.applications.van.MaskedLinear.call:10 +#: tensorcircuit.applications.van.ResidualBlock.call:10 +#: tensorcircuit.applications.vqes.Linear.call:10 msgid "" "Input tensor, or dict/list/tuple of input tensors. The first positional " "`inputs` argument is subject to special rules: - `inputs` must be " "explicitly passed. A layer cannot have zero arguments, and `inputs` " "cannot be provided via the default value of a keyword argument. - NumPy" -" array or Python scalar values in `inputs` get cast as tensors. - Keras " -"mask metadata is only collected from `inputs`. - Layers are built " +" array or Python scalar values in `inputs` get cast as tensors. - Keras" +" mask metadata is only collected from `inputs`. - Layers are built " "(`build(input_shape)` method) using shape info from `inputs` only. - " "`input_spec` compatibility is only checked against `inputs`. - Mixed " "precision input casting is only applied to `inputs`. If a layer has " "tensor arguments in `*args` or `**kwargs`, their casting behavior in " "mixed precision should be handled manually. - The SavedModel input " -"specification is generated using `inputs` only. - Integration with " +"specification is generated using `inputs` only. - Integration with " "various ecosystem packages like TFMOT, TFLite, TF.js, etc is only " "supported for `inputs` and not for tensors in positional and keyword " "arguments." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:8 -#: tensorcircuit.applications.van.MaskedLinear.call:8 -#: tensorcircuit.applications.van.ResidualBlock.call:8 -#: tensorcircuit.applications.vqes.Linear.call:8 +#: of tensorcircuit.applications.van.MaskedConv2D.call:10 +#: tensorcircuit.applications.van.MaskedLinear.call:10 +#: tensorcircuit.applications.van.ResidualBlock.call:10 +#: tensorcircuit.applications.vqes.Linear.call:10 msgid "" "Input tensor, or dict/list/tuple of input tensors. The first positional " "`inputs` argument is subject to special rules: - `inputs` must be " "explicitly passed. A layer cannot have zero" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:11 -#: tensorcircuit.applications.van.MaskedLinear.call:11 -#: tensorcircuit.applications.van.ResidualBlock.call:11 -#: tensorcircuit.applications.vqes.Linear.call:11 -msgid "" -"arguments, and `inputs` cannot be provided via the default value of a " -"keyword argument." -msgstr "" - #: of tensorcircuit.applications.van.MaskedConv2D.call:13 #: tensorcircuit.applications.van.MaskedLinear.call:13 #: tensorcircuit.applications.van.ResidualBlock.call:13 #: tensorcircuit.applications.vqes.Linear.call:13 -msgid "NumPy array or Python scalar values in `inputs` get cast as tensors." -msgstr "" - -#: of tensorcircuit.applications.van.MaskedConv2D.call:14 -#: tensorcircuit.applications.van.MaskedLinear.call:14 -#: tensorcircuit.applications.van.ResidualBlock.call:14 -#: tensorcircuit.applications.vqes.Linear.call:14 -msgid "Keras mask metadata is only collected from `inputs`." +msgid "" +"arguments, and `inputs` cannot be provided via the default value of a " +"keyword argument." msgstr "" #: of tensorcircuit.applications.van.MaskedConv2D.call:15 #: tensorcircuit.applications.van.MaskedLinear.call:15 #: tensorcircuit.applications.van.ResidualBlock.call:15 #: tensorcircuit.applications.vqes.Linear.call:15 -msgid "" -"Layers are built (`build(input_shape)` method) using shape info from " -"`inputs` only." +msgid "NumPy array or Python scalar values in `inputs` get cast as tensors." msgstr "" #: of tensorcircuit.applications.van.MaskedConv2D.call:17 #: tensorcircuit.applications.van.MaskedLinear.call:17 #: tensorcircuit.applications.van.ResidualBlock.call:17 #: tensorcircuit.applications.vqes.Linear.call:17 -msgid "`input_spec` compatibility is only checked against `inputs`." +msgid "Keras mask metadata is only collected from `inputs`." msgstr "" #: of tensorcircuit.applications.van.MaskedConv2D.call:18 @@ -7432,57 +7926,73 @@ msgstr "" #: tensorcircuit.applications.van.ResidualBlock.call:18 #: tensorcircuit.applications.vqes.Linear.call:18 msgid "" -"Mixed precision input casting is only applied to `inputs`. If a layer has" -" tensor arguments in `*args` or `**kwargs`, their casting behavior in " -"mixed precision should be handled manually." +"Layers are built (`build(input_shape)` method) using shape info from " +"`inputs` only." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:20 +#: tensorcircuit.applications.van.MaskedLinear.call:20 +#: tensorcircuit.applications.van.ResidualBlock.call:20 +#: tensorcircuit.applications.vqes.Linear.call:20 +msgid "`input_spec` compatibility is only checked against `inputs`." msgstr "" #: of tensorcircuit.applications.van.MaskedConv2D.call:21 #: tensorcircuit.applications.van.MaskedLinear.call:21 #: tensorcircuit.applications.van.ResidualBlock.call:21 #: tensorcircuit.applications.vqes.Linear.call:21 +msgid "" +"Mixed precision input casting is only applied to `inputs`. If a layer has" +" tensor arguments in `*args` or `**kwargs`, their casting behavior in " +"mixed precision should be handled manually." +msgstr "" + +#: of tensorcircuit.applications.van.MaskedConv2D.call:24 +#: tensorcircuit.applications.van.MaskedLinear.call:24 +#: tensorcircuit.applications.van.ResidualBlock.call:24 +#: tensorcircuit.applications.vqes.Linear.call:24 msgid "The SavedModel input specification is generated using `inputs` only." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:22 -#: tensorcircuit.applications.van.MaskedLinear.call:22 -#: tensorcircuit.applications.van.ResidualBlock.call:22 -#: tensorcircuit.applications.vqes.Linear.call:22 +#: of tensorcircuit.applications.van.MaskedConv2D.call:26 +#: tensorcircuit.applications.van.MaskedLinear.call:26 +#: tensorcircuit.applications.van.ResidualBlock.call:26 +#: tensorcircuit.applications.vqes.Linear.call:26 msgid "" "Integration with various ecosystem packages like TFMOT, TFLite, TF.js, " "etc is only supported for `inputs` and not for tensors in positional and " "keyword arguments." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:25 -#: tensorcircuit.applications.van.MaskedLinear.call:25 -#: tensorcircuit.applications.van.ResidualBlock.call:25 -#: tensorcircuit.applications.vqes.Linear.call:25 +#: of tensorcircuit.applications.van.MaskedConv2D.call:29 +#: tensorcircuit.applications.van.MaskedLinear.call:29 +#: tensorcircuit.applications.van.ResidualBlock.call:29 +#: tensorcircuit.applications.vqes.Linear.call:29 msgid "" "Additional positional arguments. May contain tensors, although this is " "not recommended, for the reasons above." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:27 -#: tensorcircuit.applications.van.MaskedLinear.call:27 -#: tensorcircuit.applications.van.ResidualBlock.call:27 -#: tensorcircuit.applications.vqes.Linear.call:27 +#: of tensorcircuit.applications.van.MaskedConv2D.call:31 +#: tensorcircuit.applications.van.MaskedLinear.call:31 +#: tensorcircuit.applications.van.ResidualBlock.call:31 +#: tensorcircuit.applications.vqes.Linear.call:31 msgid "" "Additional keyword arguments. May contain tensors, although this is not " "recommended, for the reasons above. The following optional keyword " "arguments are reserved: - `training`: Boolean scalar tensor of Python " "boolean indicating whether the `call` is meant for training or " "inference. - `mask`: Boolean input mask. If the layer's `call()` method " -"takes a `mask` argument, its default value will be set to the mask " -"generated for `inputs` by the previous layer (if `input` did come from " -"a layer that generated a corresponding mask, i.e. if it came from a " -"Keras layer with masking support)." +"takes a `mask` argument, its default value will be set to the mask " +"generated for `inputs` by the previous layer (if `input` did come from " +"a layer that generated a corresponding mask, i.e. if it came from a " +"Keras layer with masking support)." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:27 -#: tensorcircuit.applications.van.MaskedLinear.call:27 -#: tensorcircuit.applications.van.ResidualBlock.call:27 -#: tensorcircuit.applications.vqes.Linear.call:27 +#: of tensorcircuit.applications.van.MaskedConv2D.call:31 +#: tensorcircuit.applications.van.MaskedLinear.call:31 +#: tensorcircuit.applications.van.ResidualBlock.call:31 +#: tensorcircuit.applications.vqes.Linear.call:31 msgid "" "Additional keyword arguments. May contain tensors, although this is not " "recommended, for the reasons above. The following optional keyword " @@ -7490,17 +8000,17 @@ msgid "" "boolean indicating" msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:31 -#: tensorcircuit.applications.van.MaskedLinear.call:31 -#: tensorcircuit.applications.van.ResidualBlock.call:31 -#: tensorcircuit.applications.vqes.Linear.call:31 +#: of tensorcircuit.applications.van.MaskedConv2D.call:35 +#: tensorcircuit.applications.van.MaskedLinear.call:35 +#: tensorcircuit.applications.van.ResidualBlock.call:35 +#: tensorcircuit.applications.vqes.Linear.call:35 msgid "whether the `call` is meant for training or inference." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:32 -#: tensorcircuit.applications.van.MaskedLinear.call:32 -#: tensorcircuit.applications.van.ResidualBlock.call:32 -#: tensorcircuit.applications.vqes.Linear.call:32 +#: of tensorcircuit.applications.van.MaskedConv2D.call:36 +#: tensorcircuit.applications.van.MaskedLinear.call:36 +#: tensorcircuit.applications.van.ResidualBlock.call:36 +#: tensorcircuit.applications.vqes.Linear.call:36 msgid "" "`mask`: Boolean input mask. If the layer's `call()` method takes a `mask`" " argument, its default value will be set to the mask generated for " @@ -7509,18 +8019,40 @@ msgid "" "masking support)." msgstr "" -#: of tensorcircuit.applications.van.MaskedConv2D.call:38 -#: tensorcircuit.applications.van.MaskedLinear.call:38 -#: tensorcircuit.applications.van.ResidualBlock.call:38 -#: tensorcircuit.applications.vqes.Linear.call:38 +#: of tensorcircuit.applications.van.MaskedConv2D.call:42 +#: tensorcircuit.applications.van.MaskedLinear.call:42 +#: tensorcircuit.applications.van.ResidualBlock.call:42 +#: tensorcircuit.applications.vqes.Linear.call:42 msgid "A tensor or list/tuple of tensors." msgstr "" -#: keras.engine.base_layer.Layer.get_weights:1 of +#: keras.src.engine.base_layer.Layer.get_config:1 of +msgid "Returns the config of the layer." +msgstr "" + +#: keras.src.engine.base_layer.Layer.get_config:3 of +msgid "" +"A layer config is a Python dictionary (serializable) containing the " +"configuration of a layer. The same layer can be reinstantiated later " +"(without its trained weights) from this configuration." +msgstr "" + +#: keras.src.engine.base_layer.Layer.get_config:8 of +msgid "" +"The config of a layer does not include connectivity information, nor the " +"layer class name. These are handled by `Network` (one layer of " +"abstraction above)." +msgstr "" + +#: keras.src.engine.base_layer.Layer.get_config:16 of +msgid "Python dictionary." +msgstr "" + +#: keras.src.engine.base_layer.Layer.get_weights:1 of msgid "Returns the current weights of the layer, as NumPy arrays." msgstr "" -#: keras.engine.base_layer.Layer.get_weights:3 of +#: keras.src.engine.base_layer.Layer.get_weights:3 of msgid "" "The weights of a layer represent the state of the layer. This function " "returns both trainable and non-trainable weight values associated with " @@ -7528,7 +8060,7 @@ msgid "" "state into similarly parameterized layers." msgstr "" -#: keras.engine.base_layer.Layer.get_weights:32 of +#: keras.src.engine.base_layer.Layer.get_weights:32 of msgid "Weights values as a list of NumPy arrays." msgstr "" @@ -7561,20 +8093,20 @@ msgstr "" #: of tensorcircuit.applications.vqes.JointSchedule:1 msgid "" "Bases: " -":py:class:`~keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule`" +":py:class:`~keras.src.optimizers.schedules.learning_rate_schedule.LearningRateSchedule`" msgstr "" -#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config:1 +#: keras.src.optimizers.schedules.learning_rate_schedule.LearningRateSchedule.from_config:1 #: of msgid "Instantiates a `LearningRateSchedule` from its config." msgstr "" -#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config:3 +#: keras.src.optimizers.schedules.learning_rate_schedule.LearningRateSchedule.from_config:3 #: of msgid "Output of `get_config()`." msgstr "" -#: keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule.from_config:5 +#: keras.src.optimizers.schedules.learning_rate_schedule.LearningRateSchedule.from_config:5 #: of msgid "A `LearningRateSchedule` instance." msgstr "" @@ -10823,18 +11355,18 @@ msgid "will be reduced by 1." msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:1 +#: tensorcircuit.backends.tensorflow_backend._svd_tf:1 #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:1 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:1 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:1 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:1 msgid "Computes the singular value decomposition (SVD) of a tensor." msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:3 +#: tensorcircuit.backends.tensorflow_backend._svd_tf:3 #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:3 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:3 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:3 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:3 msgid "" "The SVD is performed by treating the tensor as a matrix, with an " "effective left (row) index resulting from combining the axes " @@ -10843,10 +11375,10 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:8 +#: tensorcircuit.backends.tensorflow_backend._svd_tf:8 #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:8 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:8 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:8 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:8 msgid "" "For example, if `tensor` had a shape (2, 3, 4, 5) and `pivot_axis` was 2," " then `u` would have shape (2, 3, 6), `s` would have shape (6), and `vh` " @@ -10854,20 +11386,20 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:12 +#: tensorcircuit.backends.tensorflow_backend._svd_tf:12 #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:12 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:12 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:12 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:12 msgid "" "If `max_singular_values` is set to an integer, the SVD is truncated to " "keep at most this many singular values." msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:15 +#: tensorcircuit.backends.tensorflow_backend._svd_tf:15 #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:15 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:15 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:15 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:15 msgid "" "If `max_truncation_error > 0`, as many singular values will be truncated " "as possible, so that the truncation error (the norm of discarded singular" @@ -10880,7 +11412,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:21 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:21 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:21 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:21 msgid "" "If both `max_singular_values` and `max_truncation_error` are specified, " "the number of retained singular values will be `min(max_singular_values, " @@ -10893,7 +11424,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:27 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:27 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:27 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:27 msgid "The output consists of three tensors `u, s, vh` such that: ```python" msgstr "" @@ -10901,7 +11431,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:29 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:29 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:29 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:29 msgid "u[i1,...,iN, j] * s[j] * vh[j, k1,...,kM] == tensor[i1,...,iN, k1,...,kM]" msgstr "" @@ -10909,7 +11438,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:30 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:30 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:30 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:30 msgid "" "``` Note that the output ordering matches numpy.linalg.svd rather than " "tf.svd." @@ -10923,7 +11451,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:33 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:33 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:33 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:33 msgid "A tensor to be decomposed." msgstr "" @@ -10935,7 +11462,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:34 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:34 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:34 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:34 msgid "Where to split the tensor's axes before flattening into a matrix." msgstr "" @@ -10943,7 +11469,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:36 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:36 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:36 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:36 msgid "The number of singular values to keep, or `None` to keep them all." msgstr "" @@ -10951,7 +11476,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:38 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:38 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:38 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:38 msgid "The maximum allowed truncation error or `None` to not do any truncation." msgstr "" @@ -10961,7 +11485,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:40 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:40 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:40 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:40 msgid "Multiply `max_truncation_err` with the largest singular value." msgstr "" @@ -10969,7 +11492,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:42 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:42 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:42 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:42 msgid "" "Left tensor factor. s: Vector of ordered singular values from largest to " "smallest. vh: Right tensor factor. s_rest: Vector of discarded singular " @@ -10980,7 +11502,6 @@ msgstr "" #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:42 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:42 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:42 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:42 msgid "" "Left tensor factor. s: Vector of ordered singular values from largest to " "smallest. vh: Right tensor factor. s_rest: Vector of discarded singular " @@ -10988,10 +11509,10 @@ msgid "" msgstr "" #: of tensorcircuit.backends.jax_backend._svd_jax:46 +#: tensorcircuit.backends.tensorflow_backend._svd_tf:49 #: tensornetwork.backends.abstract_backend.AbstractBackend.svd:46 #: tensornetwork.backends.numpy.numpy_backend.NumPyBackend.svd:46 #: tensornetwork.backends.pytorch.pytorch_backend.PyTorchBackend.svd:46 -#: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.svd:46 msgid "truncation)." msgstr "" @@ -12039,6 +12560,62 @@ msgid "" "backend. The TensorFlow version returns y[i] = x[i] / abs(x[i])." msgstr "" +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:21 +msgid "" +"If both `max_singular_values` snd `max_truncation_error` are specified, " +"the number of retained singular values will be `min(max_singular_values, " +"nsv_auto_trunc)`, where `nsv_auto_trunc` is the number of singular values" +" that must be kept to maintain a truncation error smaller than " +"`max_truncation_error`." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:27 +msgid "" +"The output consists of three tensors `u, s, vh` such that: ```python " +"u[i1,...,iN, j] * s[j] * vh[j, k1,...,kM] == tensor[i1,...,iN, k1,...,kM]" +" ``` Note that the output ordering matches numpy.linalg.svd rather than " +"tf.svd." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:33 +msgid "" +"Args: tf: The tensorflow module. tensor: A tensor to be decomposed. " +"pivot_axis: Where to split the tensor's axes before flattening into a" +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:37 +msgid "matrix." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:38 +msgid "max_singular_values: The number of singular values to keep, or `None` to" +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:39 +msgid "keep them all." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:40 +msgid "" +"max_truncation_error: The maximum allowed truncation error or `None` to " +"not" +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:41 +msgid "do any truncation." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:42 +msgid "relative: Multiply `max_truncation_err` with the largest singular value." +msgstr "" + +#: of tensorcircuit.backends.tensorflow_backend._svd_tf:44 +msgid "" +"Returns: u: Left tensor factor. s: Vector of ordered singular values from" +" largest to smallest. vh: Right tensor factor. s_rest: Vector of " +"discarded singular values (length zero if no" +msgstr "" + #: of #: tensornetwork.backends.tensorflow.tensorflow_backend.TensorFlowBackend.trace:11 msgid "" @@ -12907,15 +13484,15 @@ msgid "``Circuit`` class. Simple usage demo below." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **ANY** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.any_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:4 -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:4 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:5 #: tensorcircuit.circuit.Circuit.apply_general_kraus_delayed..apply:4 #: tensorcircuit.densitymatrix.DMCircuit.apply_general_kraus_delayed..apply:4 #: tensorcircuit.densitymatrix.DMCircuit2.apply_general_kraus_delayed..apply:4 @@ -12923,20 +13500,20 @@ msgid "Qubit number that the gate applies on." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:6 -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:7 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:6 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:7 msgid "Parameters for the gate." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **CNOT** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.cnot_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" @@ -12945,12 +13522,12 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "Qubit number that the gate applies on. The matrix for the gate is" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " "1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 1.+0.j\\\\ " @@ -12958,56 +13535,56 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **CPHASE** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.cphase_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **CR** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.cr_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **CRX** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.crx_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **CRY** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.cry_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **CRZ** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.crz_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **CU** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.cu_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **CY** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.cy_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" @@ -13016,7 +13593,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " "1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 0.+0.j & 0.-1.j\\\\ " @@ -13024,14 +13601,14 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **CZ** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.cz_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" @@ -13040,7 +13617,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " "1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " @@ -13048,28 +13625,28 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **EXP** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.exp_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **EXP1** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.exp1_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **FREDKIN** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.fredkin_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " @@ -13085,7 +13662,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j &" " 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " @@ -13100,14 +13677,14 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **H** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.h_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 0.70710677+0.j & 0.70710677+0.j\\\\ " @@ -13115,21 +13692,21 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 0.70710677+0.j & 0.70710677+0.j\\\\ 0.70710677+0.j" " & -0.70710677+0.j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **I** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.i_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j " @@ -13137,61 +13714,61 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **ISWAP** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.iswap_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply mpo gate in MPO format on the circuit. See " ":py:meth:`tensorcircuit.gates.mpo_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply multicontrol gate in MPO format on the circuit. See " ":py:meth:`tensorcircuit.gates.multicontrol_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **ORX** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.orx_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **ORY** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.ory_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **ORZ** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.orz_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **OX** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.ox_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\" @@ -13200,7 +13777,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ 1.+0.j & " "0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " @@ -13208,14 +13785,14 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **OY** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.oy_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 0.+0.j & 0.-1.j & 0.+0.j & 0.+0.j\\\\" @@ -13224,7 +13801,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 0.+0.j & 0.-1.j & 0.+0.j & 0.+0.j\\\\ 0.+1.j & " "0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\ " @@ -13232,14 +13809,14 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **OZ** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.oz_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" @@ -13248,7 +13825,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " "-1.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+0.j & 1.+0.j & 0.+0.j\\\\" @@ -13256,70 +13833,70 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **PHASE** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.phase_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **R** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.r_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **RX** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.rx_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **RXX** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.rxx_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **RY** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.ry_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **RYY** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.ryy_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **RZ** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.rz_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **RZZ** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.rzz_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **S** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.s_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+1.j " @@ -13327,19 +13904,19 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.+1.j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **SD** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.sd_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.-1.j " @@ -13347,19 +13924,19 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & 0.-1.j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **SWAP** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.swap_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\" @@ -13368,7 +13945,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j\\\\ 0.+0.j & " "0.+0.j & 1.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j\\\\ " @@ -13376,14 +13953,14 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **T** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.t_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j " @@ -13391,21 +13968,21 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j & " "0.70710677+0.70710677j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **TD** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.td_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j " @@ -13413,21 +13990,21 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1. & +0.j & 0. & +0.j\\\\ 0. & +0.j & " "0.70710677-0.70710677j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **TOFFOLI** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.toffoli_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " @@ -13443,7 +14020,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & 0.+0.j &" " 0.+0.j & 0.+0.j\\\\ 0.+0.j & 1.+0.j & 0.+0.j & 0.+0.j & 0.+0.j & " @@ -13458,21 +14035,21 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_variable_gate_delayed..apply_list:1 msgid "" "Apply **U** gate with parameters on the circuit. See " ":py:meth:`tensorcircuit.gates.u_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **WROOT** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.wroot_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 0.70710677+0.j & -0.5 & -0.5j\\\\ " @@ -13480,21 +14057,21 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "" "\\begin{bmatrix} 0.70710677+0.j & -0.5 & -0.5j\\\\ 0.5 & -0.5j & " "0.70710677+0.j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **X** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.x_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 0.+0.j & 1.+0.j\\\\ 1.+0.j & 0.+0.j " @@ -13502,19 +14079,19 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "\\begin{bmatrix} 0.+0.j & 1.+0.j\\\\ 1.+0.j & 0.+0.j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **Y** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.y_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 0.+0.j & 0.-1.j\\\\ 0.+1.j & 0.+0.j " @@ -13522,19 +14099,19 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "\\begin{bmatrix} 0.+0.j & 0.-1.j\\\\ 0.+1.j & 0.+0.j \\end{bmatrix}" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:1 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:1 msgid "" "Apply **Z** gate on the circuit. See " ":py:meth:`tensorcircuit.gates.z_gate`." msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:5 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:5 msgid "" "Qubit number that the gate applies on. The matrix for the gate is .. " "math:: \\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & -1.+0.j" @@ -13542,7 +14119,7 @@ msgid "" msgstr "" #: of -#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply:8 +#: tensorcircuit.abstractcircuit.AbstractCircuit.apply_general_gate_delayed..apply_list:8 msgid "\\begin{bmatrix} 1.+0.j & 0.+0.j\\\\ 0.+0.j & -1.+0.j \\end{bmatrix}" msgstr "" @@ -14659,6 +15236,34 @@ msgstr "" msgid "Experimental features" msgstr "" +#: of tensorcircuit.experimental.evol_global:1 +msgid "" +"ode evolution of time dependent Hamiltonian on circuit of all qubits " +"[only jax backend support for now]" +msgstr "" + +#: of tensorcircuit.experimental.evol_global:6 +msgid "" +"h_fun should return a **SPARSE** Hamiltonian matrix with input arguments " +"time and *args" +msgstr "" + +#: of tensorcircuit.experimental.evol_local:1 +msgid "" +"ode evolution of time dependent Hamiltonian on circuit of given indices " +"[only jax backend support for now]" +msgstr "" + +#: of tensorcircuit.experimental.evol_local:8 +msgid "" +"h_fun should return a dense Hamiltonian matrix with input arguments time " +"and *args" +msgstr "" + +#: of tensorcircuit.experimental.evol_local:11 +msgid "evolution time" +msgstr "" + #: of tensorcircuit.experimental.hamiltonian_evol:1 msgid "" "Fast implementation of static full Hamiltonian evolution (default as " @@ -17478,15 +18083,184 @@ msgid "" "https://qiskit.org/documentation/stubs/qiskit.visualization.plot_histogram.html" msgstr "" -#: ../../source/api/results/readout_mitigation.rst:2 -msgid "tensorcircuit.results.readout_mitigation" +#: of tensorcircuit.results.counts.plot_histogram:4 +msgid "interesting kw options include: ``number_to_keep`` (int)" msgstr "" -#: of tensorcircuit.results.readout_mitigation:1 -msgid "readout error mitigation functionalities" +#: ../../source/api/results/qem.rst:2 +msgid "tensorcircuit.results.qem" msgstr "" -#: of tensorcircuit.results.readout_mitigation.ReadoutMit.__init__:1 +#: ../../source/api/results/qem/benchmark_circuits.rst:2 +msgid "tensorcircuit.results.qem.benchmark_circuits" +msgstr "" + +#: of tensorcircuit.results.qem.benchmark_circuits:1 +msgid "circuits for quantum chip benchmark" +msgstr "" + +#: ../../source/api/results/qem/qem_methods.rst:2 +msgid "tensorcircuit.results.qem.qem_methods" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods:1 +msgid "quantum error mitigation functionalities" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.add_dd:1 +msgid "Add DD sequence to A circuit" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.add_dd:3 +#: tensorcircuit.results.qem.qem_methods.prune_ddcircuit:4 +msgid "circuit" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.add_dd:5 +msgid "The rule to conduct the DD sequence" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.add_dd:7 +#: tensorcircuit.results.qem.qem_methods.prune_ddcircuit:8 +msgid "new circuit" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:1 +msgid "Apply dynamic decoupling (DD) and return the mitigated results." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:4 +#: tensorcircuit.results.qem.qem_methods.apply_zne:3 +msgid "The aim circuit." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:6 +#: tensorcircuit.results.qem.qem_methods.apply_rc:5 +msgid "A executor that executes a circuit and return results." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:8 +msgid "" +"The rule to construct DD sequence, can use default rule " +"\"dd_option.rules.xx\"" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:9 +msgid "" +"or custom rule \"['X','X']\" :type rule: Union[Callable[[int], Any], " +"List[str]] :param rule_args:An optional dictionary of keyword arguments " +"for ``rule``, defaults to {}. :type rule_args: Dict[str, Any], optional " +":param num_trials: The number of independent experiments to average over," +" defaults to 1 :type num_trials: int, optional :param full_output: If " +"``False`` only the mitigated expectation value is" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:16 +msgid "" +"returned. If ``True`` a dictionary containing all DD data is returned " +"too, defaults to False" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:19 +msgid "ignore the DD sequences that added to unused qubits, defaults to True" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:21 +msgid "dd sequence full fill the idle circuits, defaults to False" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:23 +#: tensorcircuit.results.qem.qem_methods.apply_rc:11 +msgid "whether the output is bit string, defaults to False" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_dd:25 +msgid "" +"mitigated expectation value or mitigated expectation value and DD circuit" +" information" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_rc:1 +msgid "Apply Randomized Compiling or Pauli twirling on two-qubit gates." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_rc:3 +msgid "Input circuit" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_rc:7 +msgid "Number of circuits for RC, defaults to 1" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_rc:9 +msgid "" +"Whether simplify the circuits by merging single qubit gates, defaults to " +"True" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_rc:13 +msgid "Mitigated results by RC" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_zne:1 +msgid "Apply zero-noise extrapolation (ZNE) and return the mitigated results." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_zne:5 +msgid "" +"A executor that executes a single circuit or a batch of circuits and " +"return results." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_zne:7 +msgid "Determines the extropolation method." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_zne:9 +msgid "The scaling function for the aim circuit, defaults to fold_gates_at_random" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_zne:11 +msgid "" +"Number of times expectation values are computed by the executor, average " +"each point, defaults to 1." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.apply_zne:14 +msgid "Mitigated average value by ZNE." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.prune_ddcircuit:1 +msgid "" +"Discard DD sequence on idle qubits and Discard identity gate (no " +"identity/idle gate on device now) filled in DD sequence." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.prune_ddcircuit:6 +msgid "qubit list to apply DD sequence" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.used_qubits:1 +msgid "Create a qubit list that includes all qubits having gate manipulation." +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.used_qubits:3 +msgid "a circuit" +msgstr "" + +#: of tensorcircuit.results.qem.qem_methods.used_qubits:5 +msgid "qubit list" +msgstr "" + +#: ../../source/api/results/readout_mitigation.rst:2 +msgid "tensorcircuit.results.readout_mitigation" +msgstr "" + +#: of tensorcircuit.results.readout_mitigation:1 +msgid "readout error mitigation functionalities" +msgstr "" + +#: of tensorcircuit.results.readout_mitigation.ReadoutMit.__init__:1 msgid "The Class for readout error mitigation" msgstr "" @@ -17846,24 +18620,6 @@ msgstr "" msgid "Useful utilities for quantum chemistry related task" msgstr "" -#: of tensorcircuit.templates.chems.get_ps:1 -msgid "" -"Get Pauli string array and weights array for a qubit Hamiltonian as a sum" -" of Pauli strings defined in openfermion ``QubitOperator``." -msgstr "" - -#: of tensorcircuit.templates.chems.get_ps:4 -msgid "``openfermion.ops.operators.qubit_operator.QubitOperator``" -msgstr "" - -#: of tensorcircuit.templates.chems.get_ps:6 -msgid "The number of qubits" -msgstr "" - -#: of tensorcircuit.templates.chems.get_ps:8 -msgid "Pauli String array and weights array" -msgstr "" - #: ../../source/api/templates/dataset.rst:2 msgid "tensorcircuit.templates.dataset" msgstr "" @@ -24097,3 +24853,1044 @@ msgstr "" #~ msgid "Returns a dictionary containing a whole state of the module." #~ msgstr "" +#~ msgid "" +#~ "Visualise the circuit. This method " +#~ "recevies the keywords as same as " +#~ "qiskit.circuit.QuantumCircuit.draw. More details can" +#~ " be found here: " +#~ "https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.draw.html." +#~ msgstr "" + +#~ msgid "the corresponding qubit" +#~ msgstr "" + +#~ msgid "Bases: :py:class:`~keras.engine.training.Model`" +#~ msgstr "" + +#~ msgid "" +#~ "This method can also be called " +#~ "directly on a Functional Model during" +#~ " construction. In this case, any loss" +#~ " Tensors passed to this Model must" +#~ " be symbolic and be able to be" +#~ " traced back to the model's `Input`s." +#~ " These losses become part of the " +#~ "model's topology and are tracked in " +#~ "`get_config`." +#~ msgstr "" + +#~ msgid "" +#~ "Additional keyword arguments for backward " +#~ "compatibility. Accepted values: inputs - " +#~ "Deprecated, will be automatically inferred." +#~ msgstr "" + +#~ msgid "" +#~ "Additional keyword arguments for backward " +#~ "compatibility. Accepted values:" +#~ msgstr "" + +#~ msgid "inputs - Deprecated, will be automatically inferred." +#~ msgstr "" + +#~ msgid "Deprecated, will be automatically inferred." +#~ msgstr "" + +#~ msgid "Whether to use `ResourceVariable`." +#~ msgstr "" + +#~ msgid "" +#~ "When giving unsupported dtype and no " +#~ "initializer or when trainable has " +#~ "been set to True with synchronization" +#~ " set as `ON_READ`." +#~ msgstr "" + +#~ msgid "This is an alias of `self.__call__`." +#~ msgstr "" + +#~ msgid "Input tensor(s)." +#~ msgstr "" + +#~ msgid "additional positional arguments to be passed to `self.call`." +#~ msgstr "" + +#~ msgid "additional keyword arguments to be passed to `self.call`." +#~ msgstr "" + +#~ msgid "Output tensor(s)." +#~ msgstr "" + +#~ msgid "" +#~ "1. In case of invalid user-" +#~ "provided data (not of type tuple," +#~ " list, `TensorShape`, or dict). " +#~ "2. If the model requires call " +#~ "arguments that are agnostic to " +#~ "the input shapes (positional or keyword" +#~ " arg in call signature). 3. If" +#~ " not all layers were properly built." +#~ " 4. If float type inputs are " +#~ "not supported within the layers." +#~ msgstr "" + +#~ msgid "" +#~ "In case of invalid user-provided " +#~ "data (not of type tuple, list," +#~ " `TensorShape`, or dict). 2. If " +#~ "the model requires call arguments that" +#~ " are agnostic to the input " +#~ "shapes (positional or keyword arg in " +#~ "call signature). 3. If not all " +#~ "layers were properly built. 4. If" +#~ " float type inputs are not supported" +#~ " within the layers." +#~ msgstr "" + +#~ msgid "" +#~ "A mask or list of masks. A " +#~ "mask can be either a boolean " +#~ "tensor or None (no mask). For more" +#~ " details, check the guide " +#~ "[here](https://www.tensorflow.org/guide/keras/masking_and_padding)." +#~ msgstr "" + +#~ msgid "" +#~ "A mask or list of masks. A " +#~ "mask can be either a boolean " +#~ "tensor or None (no mask). For more" +#~ " details, check the guide" +#~ msgstr "" + +#~ msgid "" +#~ "Loss function. Maybe be a string " +#~ "(name of loss function), or a " +#~ "`tf.keras.losses.Loss` instance. See " +#~ "`tf.keras.losses`. A loss function is " +#~ "any callable with the signature `loss" +#~ " = fn(y_true, y_pred)`, where `y_true` " +#~ "are the ground truth values, and " +#~ "`y_pred` are the model's predictions. " +#~ "`y_true` should have shape `(batch_size, " +#~ "d0, .. dN)` (except in the case" +#~ " of sparse loss functions such as " +#~ "sparse categorical crossentropy which expects" +#~ " integer arrays of shape `(batch_size, " +#~ "d0, .. dN-1)`). `y_pred` should have " +#~ "shape `(batch_size, d0, .. dN)`. The " +#~ "loss function should return a float " +#~ "tensor. If a custom `Loss` instance " +#~ "is used and reduction is set to" +#~ " `None`, return value has shape " +#~ "`(batch_size, d0, .. dN-1)` i.e. per-" +#~ "sample or per-timestep loss values; " +#~ "otherwise, it is a scalar. If the" +#~ " model has multiple outputs, you can" +#~ " use a different loss on each " +#~ "output by passing a dictionary or " +#~ "a list of losses. The loss value" +#~ " that will be minimized by the " +#~ "model will then be the sum of " +#~ "all individual losses, unless `loss_weights`" +#~ " is specified." +#~ msgstr "" + +#~ msgid "" +#~ "List of metrics to be evaluated by" +#~ " the model during training and " +#~ "testing. Each of this can be a " +#~ "string (name of a built-in " +#~ "function), function or a " +#~ "`tf.keras.metrics.Metric` instance. See " +#~ "`tf.keras.metrics`. Typically you will use " +#~ "`metrics=['accuracy']`. A function is any " +#~ "callable with the signature `result =" +#~ " fn(y_true, y_pred)`. To specify different" +#~ " metrics for different outputs of a" +#~ " multi-output model, you could also" +#~ " pass a dictionary, such as " +#~ "`metrics={'output_a': 'accuracy', 'output_b': " +#~ "['accuracy', 'mse']}`. You can also pass" +#~ " a list to specify a metric or" +#~ " a list of metrics for each " +#~ "output, such as `metrics=[['accuracy'], " +#~ "['accuracy', 'mse']]` or `metrics=['accuracy', " +#~ "['accuracy', 'mse']]`. When you pass the" +#~ " strings 'accuracy' or 'acc', we " +#~ "convert this to one of " +#~ "`tf.keras.metrics.BinaryAccuracy`, " +#~ "`tf.keras.metrics.CategoricalAccuracy`, " +#~ "`tf.keras.metrics.SparseCategoricalAccuracy` based on " +#~ "the loss function used and the " +#~ "model output shape. We do a " +#~ "similar conversion for the strings " +#~ "'crossentropy' and 'ce' as well." +#~ msgstr "" + +#~ msgid "" +#~ "Optional list or dictionary specifying " +#~ "scalar coefficients (Python floats) to " +#~ "weight the loss contributions of " +#~ "different model outputs. The loss value" +#~ " that will be minimized by the " +#~ "model will then be the *weighted " +#~ "sum* of all individual losses, weighted" +#~ " by the `loss_weights` coefficients. If" +#~ " a list, it is expected to have" +#~ " a 1:1 mapping to the model's " +#~ "outputs. If a dict, it is expected" +#~ " to map output names (strings) to" +#~ " scalar coefficients." +#~ msgstr "" + +#~ msgid "" +#~ "Optional list or dictionary specifying " +#~ "scalar coefficients (Python floats) to " +#~ "weight the loss contributions of " +#~ "different model outputs. The loss value" +#~ " that will be minimized by the " +#~ "model will then be the *weighted " +#~ "sum* of all individual losses, weighted" +#~ " by the `loss_weights` coefficients." +#~ msgstr "" + +#~ msgid "If a list, it is expected to have a 1:1 mapping to the model's" +#~ msgstr "" + +#~ msgid "" +#~ "outputs. If a dict, it is expected" +#~ " to map output names (strings) to " +#~ "scalar coefficients." +#~ msgstr "" + +#~ msgid "" +#~ "Bool. Defaults to `False`. If `True`," +#~ " this `Model`'s logic will not be " +#~ "wrapped in a `tf.function`. Recommended " +#~ "to leave this as `None` unless " +#~ "your `Model` cannot be run inside " +#~ "a `tf.function`. `run_eagerly=True` is not " +#~ "supported when using " +#~ "`tf.distribute.experimental.ParameterServerStrategy`." +#~ msgstr "" + +#~ msgid "" +#~ "Int. Defaults to 1. The number of" +#~ " batches to run during each " +#~ "`tf.function` call. Running multiple batches" +#~ " inside a single `tf.function` call " +#~ "can greatly improve performance on TPUs" +#~ " or small models with a large " +#~ "Python overhead. At most, one full " +#~ "epoch will be run each execution. " +#~ "If a number larger than the size" +#~ " of the epoch is passed, the " +#~ "execution will be truncated to the " +#~ "size of the epoch. Note that if" +#~ " `steps_per_execution` is set to `N`, " +#~ "`Callback.on_batch_begin` and `Callback.on_batch_end` " +#~ "methods will only be called every " +#~ "`N` batches (i.e. before/after each " +#~ "`tf.function` execution)." +#~ msgstr "" + +#~ msgid "" +#~ "If the layer has not been built," +#~ " this method will call `build` on " +#~ "the layer. This assumes that the " +#~ "layer will later be used with " +#~ "inputs that match the input shape " +#~ "provided here." +#~ msgstr "" + +#~ msgid "" +#~ "Shape tuple (tuple of integers) or " +#~ "list of shape tuples (one per " +#~ "output tensor of the layer). Shape " +#~ "tuples can include None for free " +#~ "dimensions, instead of an integer." +#~ msgstr "" + +#~ msgid "An input shape tuple." +#~ msgstr "" + +#~ msgid "" +#~ "Single TensorSpec or nested structure of" +#~ " TensorSpec objects, describing how the" +#~ " layer would transform the provided " +#~ "input." +#~ msgstr "" + +#~ msgid "Single TensorSpec or nested structure of TensorSpec objects, describing" +#~ msgstr "" + +#~ msgid "how the layer would transform the provided input." +#~ msgstr "" + +#~ msgid "" +#~ "Input data. It could be: - A " +#~ "Numpy array (or array-like), or a" +#~ " list of arrays (in case the " +#~ "model has multiple inputs). - A " +#~ "TensorFlow tensor, or a list of " +#~ "tensors (in case the model has " +#~ "multiple inputs). - A dict mapping " +#~ "input names to the corresponding " +#~ "array/tensors, if the model has named" +#~ " inputs. - A `tf.data` dataset. " +#~ "Should return a tuple of either " +#~ "`(inputs, targets)` or `(inputs, targets," +#~ " sample_weights)`. - A generator or " +#~ "`keras.utils.Sequence` returning `(inputs, targets)`" +#~ " or `(inputs, targets, sample_weights)`. " +#~ "A more detailed description of unpacking" +#~ " behavior for iterator types (Dataset, " +#~ "generator, Sequence) is given in the " +#~ "`Unpacking behavior for iterator-like " +#~ "inputs` section of `Model.fit`." +#~ msgstr "" + +#~ msgid "0 or 1. Verbosity mode. 0 = silent, 1 = progress bar." +#~ msgstr "" + +#~ msgid "" +#~ "Optional Numpy array of weights for " +#~ "the test samples, used for weighting " +#~ "the loss function. You can either " +#~ "pass a flat (1D) Numpy array with" +#~ " the same length as the input " +#~ "samples (1:1 mapping between weights " +#~ "and samples), or in the case of" +#~ " temporal data, you can pass a" +#~ " 2D array with shape `(samples, " +#~ "sequence_length)`, to apply a different " +#~ "weight to every timestep of every" +#~ " sample. This argument is not " +#~ "supported when `x` is a dataset, " +#~ "instead pass sample weights as the " +#~ "third element of `x`." +#~ msgstr "" + +#~ msgid "" +#~ "List of `keras.callbacks.Callback` instances. " +#~ "List of callbacks to apply during " +#~ "evaluation. See " +#~ "[callbacks](/api_docs/python/tf/keras/callbacks)." +#~ msgstr "" + +#~ msgid "" +#~ "`Model.evaluate` is not yet supported " +#~ "with `tf.distribute.experimental.ParameterServerStrategy`." +#~ msgstr "" + +#~ msgid "" +#~ "Trains the model for a fixed " +#~ "number of epochs (iterations on a " +#~ "dataset)." +#~ msgstr "" + +#~ msgid "" +#~ "Input data. It could be: - A " +#~ "Numpy array (or array-like), or a" +#~ " list of arrays (in case the " +#~ "model has multiple inputs). - A " +#~ "TensorFlow tensor, or a list of " +#~ "tensors (in case the model has " +#~ "multiple inputs). - A dict mapping " +#~ "input names to the corresponding " +#~ "array/tensors, if the model has named" +#~ " inputs. - A `tf.data` dataset. " +#~ "Should return a tuple of either " +#~ "`(inputs, targets)` or `(inputs, targets," +#~ " sample_weights)`. - A generator or " +#~ "`keras.utils.Sequence` returning `(inputs, targets)`" +#~ " or `(inputs, targets, sample_weights)`. " +#~ "- A `tf.keras.utils.experimental.DatasetCreator`, " +#~ "which wraps a callable that takes " +#~ "a single argument of type " +#~ "`tf.distribute.InputContext`, and returns a " +#~ "`tf.data.Dataset`. `DatasetCreator` should be " +#~ "used when users prefer to specify " +#~ "the per-replica batching and sharding" +#~ " logic for the `Dataset`. See " +#~ "`tf.keras.utils.experimental.DatasetCreator` doc for " +#~ "more information. A more detailed " +#~ "description of unpacking behavior for " +#~ "iterator types (Dataset, generator, Sequence)" +#~ " is given below. If using " +#~ "`tf.distribute.experimental.ParameterServerStrategy`, only " +#~ "`DatasetCreator` type is supported for " +#~ "`x`." +#~ msgstr "" + +#~ msgid "" +#~ "A more detailed description of unpacking" +#~ " behavior for iterator types (Dataset, " +#~ "generator, Sequence) is given below. If" +#~ " using `tf.distribute.experimental.ParameterServerStrategy`," +#~ " only `DatasetCreator` type is supported" +#~ " for `x`." +#~ msgstr "" + +#~ msgid "" +#~ "'auto', 0, 1, or 2. Verbosity " +#~ "mode. 0 = silent, 1 = progress " +#~ "bar, 2 = one line per epoch. " +#~ "'auto' defaults to 1 for most " +#~ "cases, but 2 when used with " +#~ "`ParameterServerStrategy`. Note that the " +#~ "progress bar is not particularly useful" +#~ " when logged to a file, so " +#~ "verbose=2 is recommended when not " +#~ "running interactively (eg, in a " +#~ "production environment)." +#~ msgstr "" + +#~ msgid "" +#~ "Float between 0 and 1. Fraction " +#~ "of the training data to be used" +#~ " as validation data. The model will" +#~ " set apart this fraction of the " +#~ "training data, will not train on " +#~ "it, and will evaluate the loss " +#~ "and any model metrics on this " +#~ "data at the end of each epoch." +#~ " The validation data is selected " +#~ "from the last samples in the `x`" +#~ " and `y` data provided, before " +#~ "shuffling. This argument is not " +#~ "supported when `x` is a dataset, " +#~ "generator or `keras.utils.Sequence` instance. " +#~ "`validation_split` is not yet supported " +#~ "with `tf.distribute.experimental.ParameterServerStrategy`." +#~ msgstr "" + +#~ msgid "Float between 0 and 1." +#~ msgstr "" + +#~ msgid "" +#~ "Fraction of the training data to " +#~ "be used as validation data. The " +#~ "model will set apart this fraction " +#~ "of the training data, will not " +#~ "train on it, and will evaluate the" +#~ " loss and any model metrics on " +#~ "this data at the end of each " +#~ "epoch. The validation data is selected" +#~ " from the last samples in the " +#~ "`x` and `y` data provided, before " +#~ "shuffling. This argument is not " +#~ "supported when `x` is a dataset, " +#~ "generator or" +#~ msgstr "" + +#~ msgid "`keras.utils.Sequence` instance." +#~ msgstr "" + +#~ msgid "" +#~ "`validation_split` is not yet supported " +#~ "with `tf.distribute.experimental.ParameterServerStrategy`." +#~ msgstr "" + +#~ msgid "" +#~ "Data on which to evaluate the loss" +#~ " and any model metrics at the " +#~ "end of each epoch. The model will" +#~ " not be trained on this data. " +#~ "Thus, note the fact that the " +#~ "validation loss of data provided using" +#~ " `validation_split` or `validation_data` is " +#~ "not affected by regularization layers " +#~ "like noise and dropout. `validation_data` " +#~ "will override `validation_split`. `validation_data`" +#~ " could be: - A tuple `(x_val, " +#~ "y_val)` of Numpy arrays or tensors." +#~ " - A tuple `(x_val, y_val, " +#~ "val_sample_weights)` of NumPy arrays. - " +#~ "A `tf.data.Dataset`. - A Python " +#~ "generator or `keras.utils.Sequence` returning " +#~ "`(inputs, targets)` or `(inputs, targets, " +#~ "sample_weights)`. `validation_data` is not yet" +#~ " supported with " +#~ "`tf.distribute.experimental.ParameterServerStrategy`." +#~ msgstr "" + +#~ msgid "" +#~ "Optional dictionary mapping class indices " +#~ "(integers) to a weight (float) value," +#~ " used for weighting the loss function" +#~ " (during training only). This can be" +#~ " useful to tell the model to " +#~ "\"pay more attention\" to samples from" +#~ " an under-represented class." +#~ msgstr "" + +#~ msgid "" +#~ "Optional Numpy array of weights for " +#~ "the training samples, used for weighting" +#~ " the loss function (during training " +#~ "only). You can either pass a flat" +#~ " (1D) Numpy array with the same " +#~ "length as the input samples (1:1 " +#~ "mapping between weights and samples), " +#~ "or in the case of temporal data," +#~ " you can pass a 2D array with" +#~ " shape `(samples, sequence_length)`, to " +#~ "apply a different weight to every " +#~ "timestep of every sample. This argument" +#~ " is not supported when `x` is a" +#~ " dataset, generator, or `keras.utils.Sequence`" +#~ " instance, instead provide the " +#~ "sample_weights as the third element of" +#~ " `x`." +#~ msgstr "" + +#~ msgid "Optional Numpy array of weights for" +#~ msgstr "" + +#~ msgid "" +#~ "the training samples, used for weighting" +#~ " the loss function (during training " +#~ "only). You can either pass a flat" +#~ " (1D) Numpy array with the same " +#~ "length as the input samples (1:1 " +#~ "mapping between weights and samples), or" +#~ " in the case of temporal data, " +#~ "you can pass a 2D array with " +#~ "shape `(samples, sequence_length)`, to apply" +#~ " a different weight to every timestep" +#~ " of every sample. This argument is" +#~ " not supported when `x` is a " +#~ "dataset, generator, or" +#~ msgstr "" + +#~ msgid "`keras.utils.Sequence` instance, instead provide the sample_weights" +#~ msgstr "" + +#~ msgid "as the third element of `x`." +#~ msgstr "" + +#~ msgid "" +#~ "Integer or `None`. Total number of " +#~ "steps (batches of samples) before " +#~ "declaring one epoch finished and " +#~ "starting the next epoch. When training" +#~ " with input tensors such as " +#~ "TensorFlow data tensors, the default " +#~ "`None` is equal to the number of" +#~ " samples in your dataset divided by" +#~ " the batch size, or 1 if that" +#~ " cannot be determined. If x is " +#~ "a `tf.data` dataset, and 'steps_per_epoch' " +#~ "is None, the epoch will run until" +#~ " the input dataset is exhausted. When" +#~ " passing an infinitely repeating dataset," +#~ " you must specify the `steps_per_epoch` " +#~ "argument. If `steps_per_epoch=-1` the training" +#~ " will run indefinitely with an " +#~ "infinitely repeating dataset. This argument" +#~ " is not supported with array inputs." +#~ " When using " +#~ "`tf.distribute.experimental.ParameterServerStrategy`: * " +#~ "`steps_per_epoch=None` is not supported." +#~ msgstr "" + +#~ msgid "" +#~ "Integer or `None`. Total number of " +#~ "steps (batches of samples) before " +#~ "declaring one epoch finished and " +#~ "starting the next epoch. When training" +#~ " with input tensors such as " +#~ "TensorFlow data tensors, the default " +#~ "`None` is equal to the number of" +#~ " samples in your dataset divided by" +#~ " the batch size, or 1 if that" +#~ " cannot be determined. If x is " +#~ "a `tf.data` dataset, and 'steps_per_epoch' " +#~ "is None, the epoch will run until" +#~ " the input dataset is exhausted. When" +#~ " passing an infinitely repeating dataset," +#~ " you must specify the `steps_per_epoch` " +#~ "argument. If `steps_per_epoch=-1` the training" +#~ " will run indefinitely with an " +#~ "infinitely repeating dataset. This argument" +#~ " is not supported with array inputs." +#~ " When using " +#~ "`tf.distribute.experimental.ParameterServerStrategy`:" +#~ msgstr "" + +#~ msgid "" +#~ "Only relevant if validation data is " +#~ "provided. Integer or `collections.abc.Container` " +#~ "instance (e.g. list, tuple, etc.). If" +#~ " an integer, specifies how many " +#~ "training epochs to run before a " +#~ "new validation run is performed, e.g." +#~ " `validation_freq=2` runs validation every " +#~ "2 epochs. If a Container, specifies " +#~ "the epochs on which to run " +#~ "validation, e.g. `validation_freq=[1, 2, 10]`" +#~ " runs validation at the end of " +#~ "the 1st, 2nd, and 10th epochs." +#~ msgstr "" + +#~ msgid "" +#~ "tf.keras.utils.Sequence to the `x` argument" +#~ " of fit, which will in fact " +#~ "yield not only features (x) but " +#~ "optionally targets (y) and sample " +#~ "weights. Keras requires that the output" +#~ " of such iterator-likes be " +#~ "unambiguous. The iterator should return " +#~ "a tuple of length 1, 2, or " +#~ "3, where the optional second and " +#~ "third elements will be used for y" +#~ " and sample_weight respectively. Any other" +#~ " type provided will be wrapped in " +#~ "a length one tuple, effectively treating" +#~ " everything as 'x'. When yielding " +#~ "dicts, they should still adhere to " +#~ "the top-level tuple structure. e.g. " +#~ "`({\"x0\": x0, \"x1\": x1}, y)`. Keras" +#~ " will not attempt to separate " +#~ "features, targets, and weights from the" +#~ " keys of a single dict." +#~ msgstr "" + +#~ msgid "A notable unsupported data type is the namedtuple. The reason is that" +#~ msgstr "" + +#~ msgid "" +#~ "it behaves like both an ordered " +#~ "datatype (tuple) and a mapping datatype" +#~ " (dict). So given a namedtuple of " +#~ "the form:" +#~ msgstr "" + +#~ msgid "Retrieves losses relevant to a specific set of inputs." +#~ msgstr "" + +#~ msgid "Input tensor or list/tuple of input tensors." +#~ msgstr "" + +#~ msgid "List of loss tensors of the layer that depend on `inputs`." +#~ msgstr "" + +#~ msgid "Retrieves updates relevant to a specific set of inputs." +#~ msgstr "" + +#~ msgid "List of update ops of the layer that depend on `inputs`." +#~ msgstr "" + +#~ msgid "Deprecated, do NOT use! Only for compatibility with external Keras." +#~ msgstr "" + +#~ msgid "" +#~ "Loads all layer weights, either from " +#~ "a TensorFlow or an HDF5 weight " +#~ "file." +#~ msgstr "" + +#~ msgid "" +#~ "If `by_name` is False weights are " +#~ "loaded based on the network's topology." +#~ " This means the architecture should " +#~ "be the same as when the weights" +#~ " were saved. Note that layers that" +#~ " don't have weights are not taken " +#~ "into account in the topological " +#~ "ordering, so adding or removing layers" +#~ " is fine as long as they don't" +#~ " have weights." +#~ msgstr "" + +#~ msgid "" +#~ "If `by_name` is True, weights are " +#~ "loaded into layers only if they " +#~ "share the same name. This is " +#~ "useful for fine-tuning or transfer-" +#~ "learning models where some of the " +#~ "layers have changed." +#~ msgstr "" + +#~ msgid "" +#~ "Only topological loading (`by_name=False`) is" +#~ " supported when loading weights from " +#~ "the TensorFlow format. Note that " +#~ "topological loading differs slightly between" +#~ " TensorFlow and HDF5 formats for " +#~ "user-defined classes inheriting from " +#~ "`tf.keras.Model`: HDF5 loads based on a" +#~ " flattened list of weights, while the" +#~ " TensorFlow format loads based on the" +#~ " object-local names of attributes to" +#~ " which layers are assigned in the " +#~ "`Model`'s constructor." +#~ msgstr "" + +#~ msgid "" +#~ "String, path to the weights file " +#~ "to load. For weight files in " +#~ "TensorFlow format, this is the file " +#~ "prefix (the same as was passed to" +#~ " `save_weights`). This can also be a" +#~ " path to a SavedModel saved from " +#~ "`model.save`." +#~ msgstr "" + +#~ msgid "" +#~ "Boolean, whether to load weights by " +#~ "name or by topological order. Only " +#~ "topological loading is supported for " +#~ "weight files in TensorFlow format." +#~ msgstr "" + +#~ msgid "" +#~ "Boolean, whether to skip loading of " +#~ "layers where there is a mismatch " +#~ "in the number of weights, or a " +#~ "mismatch in the shape of the " +#~ "weight (only valid when `by_name=True`)." +#~ msgstr "" + +#~ msgid "" +#~ "Optional `tf.train.CheckpointOptions` object that" +#~ " specifies options for loading weights." +#~ msgstr "" + +#~ msgid "" +#~ "When loading a weight file in " +#~ "TensorFlow format, returns the same " +#~ "status object as `tf.train.Checkpoint.restore`. " +#~ "When graph building, restore ops are " +#~ "run automatically as soon as the " +#~ "network is built (on first call " +#~ "for user-defined classes inheriting from" +#~ " `Model`, immediately if it is " +#~ "already built). When loading weights in" +#~ " HDF5 format, returns `None`." +#~ msgstr "" + +#~ msgid "" +#~ "When loading a weight file in " +#~ "TensorFlow format, returns the same " +#~ "status object as `tf.train.Checkpoint.restore`. " +#~ "When graph building, restore ops are " +#~ "run automatically as soon as the " +#~ "network is built (on first call " +#~ "for user-defined classes inheriting from" +#~ " `Model`, immediately if it is " +#~ "already built)." +#~ msgstr "" + +#~ msgid "When loading weights in HDF5 format, returns `None`." +#~ msgstr "" + +#~ msgid "If `h5py` is not available and the weight file is in HDF5 format." +#~ msgstr "" + +#~ msgid "If `skip_mismatch` is set to `True` when `by_name` is `False`." +#~ msgstr "" + +#~ msgid "" +#~ "Returns the model's metrics added using" +#~ " `compile()`, `add_metric()` APIs." +#~ msgstr "" + +#~ msgid "" +#~ "Computation is done in batches. This " +#~ "method is designed for performance in" +#~ " large scale inputs. For small amount" +#~ " of inputs that fit in one " +#~ "batch, directly using `__call__()` is " +#~ "recommended for faster execution, e.g., " +#~ "`model(x)`, or `model(x, training=False)` if" +#~ " you have layers such as " +#~ "`tf.keras.layers.BatchNormalization` that behaves " +#~ "differently during inference. Also, note " +#~ "the fact that test loss is not " +#~ "affected by regularization layers like " +#~ "noise and dropout." +#~ msgstr "" + +#~ msgid "Verbosity mode, 0 or 1." +#~ msgstr "" + +#~ msgid "" +#~ "List of `keras.callbacks.Callback` instances. " +#~ "List of callbacks to apply during " +#~ "prediction. See " +#~ "[callbacks](/api_docs/python/tf/keras/callbacks)." +#~ msgstr "" + +#~ msgid "If `model.predict_on_batch` is wrapped in a `tf.function`." +#~ msgstr "" + +#~ msgid "" +#~ "This method should contain the " +#~ "mathematical logic for one step of " +#~ "inference. This typically includes the " +#~ "forward pass." +#~ msgstr "" + +#~ msgid "Saves the model to Tensorflow SavedModel or a single HDF5 file." +#~ msgstr "" + +#~ msgid "" +#~ "Please see `tf.keras.models.save_model` or the" +#~ " [Serialization and Saving " +#~ "guide](https://keras.io/guides/serialization_and_saving/) for" +#~ " details." +#~ msgstr "" + +#~ msgid "String, PathLike, path to SavedModel or H5 file to save the model." +#~ msgstr "" + +#~ msgid "If True, save optimizer's state together." +#~ msgstr "" + +#~ msgid "" +#~ "Either `'tf'` or `'h5'`, indicating " +#~ "whether to save the model to " +#~ "Tensorflow SavedModel or HDF5. Defaults " +#~ "to 'tf' in TF 2.X, and 'h5' " +#~ "in TF 1.X." +#~ msgstr "" + +#~ msgid "" +#~ "Signatures to save with the SavedModel." +#~ " Applicable to the 'tf' format only." +#~ " Please see the `signatures` argument " +#~ "in `tf.saved_model.save` for details." +#~ msgstr "" + +#~ msgid "" +#~ "(only applies to SavedModel format) " +#~ "`tf.saved_model.SaveOptions` object that specifies" +#~ " options for saving to SavedModel." +#~ msgstr "" + +#~ msgid "" +#~ "(only applies to SavedModel format) When" +#~ " enabled, the SavedModel will store " +#~ "the function traces for each layer. " +#~ "This can be disabled, so that only" +#~ " the configs of each layer are " +#~ "stored. Defaults to `True`. Disabling " +#~ "this will decrease serialization time " +#~ "and reduce file size, but it " +#~ "requires that all custom layers/models " +#~ "implement a `get_config()` method." +#~ msgstr "" + +#~ msgid "```python from keras.models import load_model" +#~ msgstr "" + +#~ msgid "" +#~ "model.save('my_model.h5') # creates a HDF5" +#~ " file 'my_model.h5' del model # " +#~ "deletes the existing model" +#~ msgstr "" + +#~ msgid "" +#~ "# returns a compiled model # " +#~ "identical to the previous one model " +#~ "= load_model('my_model.h5') ```" +#~ msgstr "" + +#~ msgid "Returns the `tf.TensorSpec` of call inputs as a tuple `(args, kwargs)`." +#~ msgstr "" + +#~ msgid "" +#~ "# arg_specs is `[tf.TensorSpec(...), ...]`." +#~ " kwarg_specs, in this example, is #" +#~ " an empty dict since functional " +#~ "models do not use keyword arguments. " +#~ "arg_specs, kwarg_specs = model.save_spec()" +#~ msgstr "" + +#~ msgid "" +#~ "'serving_default': serve.get_concrete_function(*arg_specs, " +#~ "**kwarg_specs)" +#~ msgstr "" + +#~ msgid "" +#~ "The TensorFlow format matches objects " +#~ "and variables by starting at a " +#~ "root object, `self` for `save_weights`, " +#~ "and greedily matching attribute names. " +#~ "For `Model.save` this is the `Model`," +#~ " and for `Checkpoint.save` this is " +#~ "the `Checkpoint` even if the " +#~ "`Checkpoint` has a model attached. This" +#~ " means saving a `tf.keras.Model` using " +#~ "`save_weights` and loading into a " +#~ "`tf.train.Checkpoint` with a `Model` attached" +#~ " (or vice versa) will not match " +#~ "the `Model`'s variables. See the [guide" +#~ " to training " +#~ "checkpoints](https://www.tensorflow.org/guide/checkpoint) for" +#~ " details on the TensorFlow format." +#~ msgstr "" + +#~ msgid "" +#~ "Either 'tf' or 'h5'. A `filepath` " +#~ "ending in '.h5' or '.keras' will " +#~ "default to HDF5 if `save_format` is " +#~ "`None`. Otherwise `None` defaults to " +#~ "'tf'." +#~ msgstr "" + +#~ msgid "If `h5py` is not available when attempting to save in HDF5 format." +#~ msgstr "" + +#~ msgid "" +#~ "Relative or absolute positions of log" +#~ " elements in each line. If not " +#~ "provided, defaults to `[.33, .55, .67," +#~ " 1.]`." +#~ msgstr "" + +#~ msgid "" +#~ "Print function to use. Defaults to " +#~ "`print`. It will be called on each" +#~ " line of the summary. You can " +#~ "set it to a custom function in " +#~ "order to capture the string summary." +#~ msgstr "" + +#~ msgid "" +#~ "Whether to expand the nested models. " +#~ "If not provided, defaults to `False`." +#~ msgstr "" + +#~ msgid "" +#~ "Input data. It could be: - A " +#~ "Numpy array (or array-like), or a" +#~ " list of arrays (in case the " +#~ "model has multiple inputs). - A " +#~ "TensorFlow tensor, or a list of " +#~ "tensors (in case the model has " +#~ "multiple inputs). - A dict mapping " +#~ "input names to the corresponding " +#~ "array/tensors, if the model has " +#~ "named inputs." +#~ msgstr "" + +#~ msgid "A dict mapping input names to the corresponding array/tensors, if" +#~ msgstr "" + +#~ msgid "the model has named inputs." +#~ msgstr "" + +#~ msgid "If `model.test_on_batch` is wrapped in a `tf.function`." +#~ msgstr "" + +#~ msgid "Additional keyword arguments to be passed to `json.dumps()`." +#~ msgstr "" + +#~ msgid "" +#~ "Optional dictionary mapping class indices " +#~ "(integers) to a weight (float) to " +#~ "apply to the model's loss for the" +#~ " samples from this class during " +#~ "training. This can be useful to " +#~ "tell the model to \"pay more " +#~ "attention\" to samples from an under-" +#~ "represented class." +#~ msgstr "" + +#~ msgid "" +#~ "This method can be overridden to " +#~ "support custom training logic. For " +#~ "concrete examples of how to override " +#~ "this method see [Customizing what " +#~ "happends in " +#~ "fit](https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit)." +#~ " This method is called by " +#~ "`Model.make_train_function`." +#~ msgstr "" + +#~ msgid "" +#~ "This method should contain the " +#~ "mathematical logic for one step of " +#~ "training. This typically includes the " +#~ "forward pass, loss calculation, " +#~ "backpropagation, and metric updates." +#~ msgstr "" + +#~ msgid "Bases: :py:class:`~keras.engine.base_layer.Layer`" +#~ msgstr "" + +#~ msgid "" +#~ "Input tensor, or dict/list/tuple of " +#~ "input tensors. The first positional " +#~ "`inputs` argument is subject to special" +#~ " rules: - `inputs` must be explicitly" +#~ " passed. A layer cannot have zero" +#~ " arguments, and `inputs` cannot be " +#~ "provided via the default value of " +#~ "a keyword argument. - NumPy array " +#~ "or Python scalar values in `inputs` " +#~ "get cast as tensors. - Keras mask" +#~ " metadata is only collected from " +#~ "`inputs`. - Layers are built " +#~ "(`build(input_shape)` method) using shape " +#~ "info from `inputs` only. - `input_spec`" +#~ " compatibility is only checked against " +#~ "`inputs`. - Mixed precision input " +#~ "casting is only applied to `inputs`." +#~ " If a layer has tensor arguments" +#~ " in `*args` or `**kwargs`, their " +#~ "casting behavior in mixed precision " +#~ "should be handled manually. - The " +#~ "SavedModel input specification is generated" +#~ " using `inputs` only. - Integration " +#~ "with various ecosystem packages like " +#~ "TFMOT, TFLite, TF.js, etc is only " +#~ "supported for `inputs` and not for " +#~ "tensors in positional and keyword " +#~ "arguments." +#~ msgstr "" + +#~ msgid "" +#~ "Additional keyword arguments. May contain " +#~ "tensors, although this is not " +#~ "recommended, for the reasons above. The" +#~ " following optional keyword arguments are" +#~ " reserved: - `training`: Boolean scalar " +#~ "tensor of Python boolean indicating " +#~ "whether the `call` is meant for " +#~ "training or inference. - `mask`: Boolean" +#~ " input mask. If the layer's `call()`" +#~ " method takes a `mask` argument, " +#~ "its default value will be set to" +#~ " the mask generated for `inputs` by" +#~ " the previous layer (if `input` did" +#~ " come from a layer that generated" +#~ " a corresponding mask, i.e. if it " +#~ "came from a Keras layer with " +#~ "masking support)." +#~ msgstr "" + +#~ msgid "" +#~ "Bases: " +#~ ":py:class:`~keras.optimizer_v2.learning_rate_schedule.LearningRateSchedule`" +#~ msgstr "" + +#~ msgid "" +#~ "Get Pauli string array and weights " +#~ "array for a qubit Hamiltonian as a" +#~ " sum of Pauli strings defined in " +#~ "openfermion ``QubitOperator``." +#~ msgstr "" + +#~ msgid "``openfermion.ops.operators.qubit_operator.QubitOperator``" +#~ msgstr "" + +#~ msgid "The number of qubits" +#~ msgstr "" + +#~ msgid "Pauli String array and weights array" +#~ msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/contribs.po b/docs/source/locale/zh/LC_MESSAGES/contribs.po index cb11a0fd..004ca724 100644 --- a/docs/source/locale/zh/LC_MESSAGES/contribs.po +++ b/docs/source/locale/zh/LC_MESSAGES/contribs.po @@ -9,142 +9,222 @@ msgid "" msgstr "" "Project-Id-Version: tensorcircuit \n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-02-02 14:19+0800\n" +"POT-Creation-Date: 2023-07-14 15:43+0800\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" -"Generated-By: Babel 2.9.1\n" +"Generated-By: Babel 2.12.1\n" +#: ../../source/contribs/development_Mac.md:1 #: ../../source/contribs/development_MacARM.md:1 +#: ../../source/contribs/development_MacM2.md:1 msgid "Tensorcircuit Installation Guide on MacOS" msgstr "" -#: ../../source/contribs/development_MacARM.md:3 -msgid "Contributed by Mark (Zixuan) Song" +#: ../../source/contribs/development_Mac.md:3 +msgid "Contributed by [_Mark (Zixuan) Song_](https://marksong.tech)" msgstr "" -#: ../../source/contribs/development_MacARM.md:5 +#: ../../source/contribs/development_Mac.md:5 +msgid "" +"Apple has updated Tensorflow (for MacOS) so that installation on M-series" +" (until M2) and Intel-series Mac can follow the exact same procedure." +msgstr "" + +#: ../../source/contribs/development_Mac.md:7 +#: ../../source/contribs/development_MacARM.md:8 +#: ../../source/contribs/development_MacM2.md:10 msgid "Starting From Scratch" msgstr "" -#: ../../source/contribs/development_MacARM.md:7 -msgid "For completely new macos or macos without xcode and brew" +#: ../../source/contribs/development_Mac.md:9 +msgid "For completely new Macos or Macos without Xcode and Homebrew installed." msgstr "" -#: ../../source/contribs/development_MacARM.md:9 +#: ../../source/contribs/development_Mac.md:11 +#: ../../source/contribs/development_MacARM.md:12 +#: ../../source/contribs/development_MacM2.md:12 msgid "Install Xcode Command Line Tools" msgstr "" -#: ../../source/contribs/development_MacARM.md:11 +#: ../../source/contribs/development_Mac.md:13 +#: ../../source/contribs/development_MacARM.md:14 +#: ../../source/contribs/development_MacM2.md:14 msgid "Need graphical access to the machine." msgstr "" -#: ../../source/contribs/development_MacARM.md:13 +#: ../../source/contribs/development_Mac.md:15 +#: ../../source/contribs/development_MacARM.md:16 +#: ../../source/contribs/development_MacM2.md:16 msgid "Run `xcode-select --install` to install if on optimal internet." msgstr "" -#: ../../source/contribs/development_MacARM.md:15 +#: ../../source/contribs/development_Mac.md:17 msgid "" -"Or Download from [Apple](https://developer.apple.com/download/more/) " -"Command Line Tools installation image then install if internet connection" -" is weak." +"Or Download it from [Apple](https://developer.apple.com/download/more/) " +"Command Line Tools installation image then install it if the internet " +"connection is weak." msgstr "" -#: ../../source/contribs/development_MacARM.md:17 +#: ../../source/contribs/development_Mac.md:19 +#: ../../source/contribs/development_MacARM.md:20 +#: ../../source/contribs/development_MacM2.md:20 msgid "Install Miniconda" msgstr "" -#: ../../source/contribs/development_MacARM.md:19 +#: ../../source/contribs/development_Mac.md:21 msgid "" -"Due to the limitation of MacOS and packages, the lastest version of " -"python does not always function as desired, thus miniconda installation " -"is advised to solve the issues." +"Due to the limitation of MacOS and packages, the latest version of Python" +" does not always function as desired, thus miniconda installation is " +"advised to solve the issues." msgstr "" -#: ../../source/contribs/development_MacARM.md:28 -msgid "Install TC Prerequisites" -msgstr "" - -#: ../../source/contribs/development_MacARM.md:34 +#: ../../source/contribs/development_Mac.md:30 +#: ../../source/contribs/development_MacARM.md:37 msgid "Install TC Backends" msgstr "" -#: ../../source/contribs/development_MacARM.md:36 -msgid "There are four backends to choose from, Numpy, Tensorflow, Jax, Torch." +#: ../../source/contribs/development_Mac.md:32 +msgid "There are four backends to choose from, Numpy, Tensorflow, Jax, and Torch." msgstr "" -#: ../../source/contribs/development_MacARM.md:38 +#: ../../source/contribs/development_Mac.md:34 +#: ../../source/contribs/development_MacARM.md:41 msgid "Install Jax, Pytorch, Qiskit, Cirq (Optional)" msgstr "" -#: ../../source/contribs/development_MacARM.md:44 +#: ../../source/contribs/development_Mac.md:40 +#: ../../source/contribs/development_MacARM.md:47 msgid "Install Tensorflow (Optional)" msgstr "" -#: ../../source/contribs/development_MacARM.md:46 -msgid "Install Tensorflow (Recommended Approach)" +#: ../../source/contribs/development_Mac.md:42 +msgid "Installation" +msgstr "" + +#: ../../source/contribs/development_Mac.md:44 +msgid "For Tensorflow version 2.13 or later:" msgstr "" -#: ../../source/contribs/development_MacARM.md:48 +#: ../../source/contribs/development_Mac.md:50 +msgid "For Tensorflow version 2.12 or earlier:" +msgstr "" + +#: ../../source/contribs/development_Mac.md:56 +#: ../../source/contribs/development_MacARM.md:57 +#: ../../source/contribs/development_MacARM.md:89 +msgid "Verify Tensorflow Installation" +msgstr "" + +#: ../../source/contribs/development_Mac.md:74 +#: ../../source/contribs/development_MacARM.md:107 +msgid "Install Tensorcircuit" +msgstr "" + +#: ../../source/contribs/development_Mac.md:80 msgid "" -"❗️ Tensorflow with MacOS optimization would not function correctly in " -"version 2.11.0 and before. Do not use this version of tensorflow if you " -"intented to train any machine learning model." +"Until July 2023, this has been tested on Intel Macs running Ventura, M1 " +"Macs running Ventura, M2 Macs running Ventura, and M2 Macs running Sonoma" +" beta." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:3 +msgid "Contributed by Mark (Zixuan) Song" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:5 +#: ../../source/contribs/development_MacM2.md:5 +msgid "" +".. warning:: This page is deprecated. Please visit `the update " +"tutorial `_ for the latest information." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:10 +msgid "For completely new macos or macos without xcode and brew" msgstr "" -#: ../../source/contribs/development_MacARM.md:50 +#: ../../source/contribs/development_MacARM.md:18 +#: ../../source/contribs/development_MacM2.md:18 msgid "" -"FYI: Error can occur when machine learning training or gpu related code " -"is involved." +"Or Download from [Apple](https://developer.apple.com/download/more/) " +"Command Line Tools installation image then install if internet connection" +" is weak." msgstr "" -#: ../../source/contribs/development_MacARM.md:52 +#: ../../source/contribs/development_MacARM.md:22 msgid "" -"⚠️ Tensorflow without macos optimization does not support Metal API and " -"utilizing GPU (both intel chips and M-series chips) until at least " -"tensorflow 2.11. Tensorflow-macos would fail when running " -"`tc.backend.to_dense()`" +"Due to the limitation of MacOS and packages, the lastest version of " +"python does not always function as desired, thus miniconda installation " +"is advised to solve the issues." msgstr "" -#: ../../source/contribs/development_MacARM.md:60 -msgid "Verify Tensorflow Installation" +#: ../../source/contribs/development_MacARM.md:31 +msgid "Install TC Prerequisites" msgstr "" -#: ../../source/contribs/development_MacARM.md:78 -msgid "Install Tensorcircuit" +#: ../../source/contribs/development_MacARM.md:39 +msgid "There are four backends to choose from, Numpy, Tensorflow, Jax, Torch." +msgstr "" + +#: ../../source/contribs/development_MacARM.md:49 +msgid "Install Tensorflow without MacOS optimization" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:75 +msgid "Install Tensorflow with MacOS optimization (Recommended)" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:77 +msgid "For tensorflow version 2.13 or later:" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:83 +msgid "For tensorflow version 2.12 or earlier:" msgstr "" -#: ../../source/contribs/development_MacARM.md:84 -msgid "Testing Platform (Tested Feb 2023)" +#: ../../source/contribs/development_MacARM.md:113 +msgid "Testing Platform (Tested Jun 2023)" msgstr "" -#: ../../source/contribs/development_MacARM.md:86 +#: ../../source/contribs/development_MacARM.md:115 msgid "Platform 1:" msgstr "" -#: ../../source/contribs/development_MacARM.md:87 +#: ../../source/contribs/development_MacARM.md:116 msgid "MacOS Ventura 13.1 (Build version 22C65)" msgstr "" -#: ../../source/contribs/development_MacARM.md:88 +#: ../../source/contribs/development_MacARM.md:117 msgid "M1 Ultra" msgstr "" -#: ../../source/contribs/development_MacARM.md:89 +#: ../../source/contribs/development_MacARM.md:118 msgid "Platform 2:" msgstr "" -#: ../../source/contribs/development_MacARM.md:90 +#: ../../source/contribs/development_MacARM.md:119 msgid "MacOS Ventura 13.2 (Build version 22D49)" msgstr "" -#: ../../source/contribs/development_MacARM.md:91 +#: ../../source/contribs/development_MacARM.md:120 msgid "M1 Ultra (Virtual)" msgstr "" +#: ../../source/contribs/development_MacARM.md:121 +msgid "Platform 4:" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:122 +msgid "MacOS Sonoma 14.0 Beta 2 (Build version 23A5276g)" +msgstr "" + +#: ../../source/contribs/development_MacARM.md:123 +msgid "M2 Max" +msgstr "" + #: ../../source/contribs/development_MacM1.rst:2 msgid "Run TensorCircuit on TensorlowBackend with Apple M1" msgstr "" @@ -156,7 +236,7 @@ msgstr "" #: ../../source/contribs/development_MacM1.rst:7 msgid "" "This page is deprecated. Please visit `the update tutorial " -"`_ for latest information." +"`_ for the latest information." msgstr "" #: ../../source/contribs/development_MacM1.rst:11 @@ -256,6 +336,146 @@ msgstr "" msgid "Then unpackage it, and cd into the folder with \"setup.py\". Conducting" msgstr "" +#: ../../source/contribs/development_MacM2.md:3 +msgid "Contributed by [Hong-Ye Hu](https://github.com/hongyehu)" +msgstr "" + +#: ../../source/contribs/development_MacM2.md:8 +msgid "" +"The key issue addressed in this document is **how to install both " +"TensorFlow and Jax on a M2 chip MacOS without conflict**." +msgstr "" + +#: ../../source/contribs/development_MacM2.md:22 +msgid "" +"Due to the limitation of MacOS and packages, the lastest version of " +"python does not always function as desired, thus miniconda installation " +"is advised to solve the issues. And use anaconda virtual environment is " +"always a good habit." +msgstr "" + +#: ../../source/contribs/development_MacM2.md:30 +msgid "Install Packages" +msgstr "" + +#: ../../source/contribs/development_MacM2.md:31 +msgid "" +"First, create a virtual environment, and make sure the python version is " +"3.8.5 by" +msgstr "" + +#: ../../source/contribs/development_MacM2.md:36 +msgid "" +"Then, install the TensorFlow from `.whl` file (file can be downloaded " +"from this " +"[URL](https://drive.google.com/drive/folders/1oSipZLnoeQB0Awz8U68KYeCPsULy_dQ7))." +" This will install TensorFlow version 2.4.1" +msgstr "" + +#: ../../source/contribs/development_MacM2.md:40 +msgid "Next, one need to install **Jax** and **Optax** by" +msgstr "" + +#: ../../source/contribs/development_MacM2.md:45 +msgid "" +"Now, hopefully, you should be able to use both Jax and TensorFlow in this" +" environment. But sometimes, it may give you an error \"ERROR: package " +"Chardet not found.\". If that is the case, you can install it by `conda " +"install chardet`. Lastly, install tensorcircuit" +msgstr "" + +#: ../../source/contribs/development_MacM2.md:51 +msgid "" +"This is the solution that seems to work for M2-chip MacOS. Please let me " +"know if there is a better solution!" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:1 +msgid "MacOS Tensorcircuit 安装教程" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:3 +msgid "[_Mark (Zixuan) Song_](https://marksong.tech) 撰写" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:5 +msgid "由于苹果更新了Tensorflow，因此M系列（直到M2）和英特尔系列Mac上的安装可以遵循完全相同的过程。" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:7 +msgid "从头开始" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:9 +msgid "对于全新的Macos或未安装Xcode和Homebrew的Macos。" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:11 +msgid "安装Xcode命令行工具" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:13 +msgid "需要对机器的图形访问。" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:15 +msgid "如果网络良好，请运行`xcode-select --install`进行安装。" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:17 +msgid "或者，如果网络连接较弱，请从[苹果](https://developer.apple.com/download/more/)下载命令行工具安装映像，然后进行安装。" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:19 +msgid "安装Miniconda" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:21 +msgid "由于MacOS和软件包的限制，因此建议安装miniconda以解决问题。" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:30 +msgid "安装TC后端" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:32 +msgid "有四个后端可供选择，Numpy，Tensorflow，Jax和Torch。" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:34 +msgid "安装Jax，Pytorch，Qiskit，Cirq（可选）" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:40 +msgid "安装Tensorflow（可选）" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:42 +msgid "安装步骤" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:44 +msgid "Tensorflow版本2.13或之后：" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:50 +msgid "Tensorflow版本2.12或之前：" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:56 +msgid "验证Tensorflow安装" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:74 +msgid "安装Tensorcircuit" +msgstr "" + +#: ../../source/contribs/development_Mac_cn.md:80 +msgid "" +"直到2023年7月，这已在运行Ventura的英特尔i9 Mac、运行Ventura的M1 Mac、运行Ventura的M2 " +"Mac、运行Sonoma测试版的M2 Mac上进行了测试。" +msgstr "" + #: ../../source/contribs/development_windows.rst:2 msgid "Run TensorCircuit on Windows Machine with Docker" msgstr "" @@ -666,3 +886,39 @@ msgstr "" #~ msgid "Testing Platform" #~ msgstr "" +#~ msgid "Install Tensorflow (Recommended Approach)" +#~ msgstr "" + +#~ msgid "" +#~ "❗️ Tensorflow with MacOS optimization " +#~ "would not function correctly in version" +#~ " 2.11.0 and before. Do not use " +#~ "this version of tensorflow if you " +#~ "intented to train any machine learning" +#~ " model." +#~ msgstr "" + +#~ msgid "" +#~ "FYI: Error can occur when machine " +#~ "learning training or gpu related code" +#~ " is involved." +#~ msgstr "" + +#~ msgid "" +#~ "⚠️ Tensorflow without macos optimization " +#~ "does not support Metal API and " +#~ "utilizing GPU (both intel chips and " +#~ "M-series chips) until at least " +#~ "tensorflow 2.11. Tensorflow-macos would " +#~ "fail when running `tc.backend.to_dense()`" +#~ msgstr "" + +#~ msgid "Testing Platform (Tested Feb 2023)" +#~ msgstr "" + +#~ msgid "" +#~ "This page is deprecated. Please visit" +#~ " `the update tutorial `_" +#~ " for latest information." +#~ msgstr "" + diff --git a/docs/source/locale/zh/LC_MESSAGES/quickstart.po b/docs/source/locale/zh/LC_MESSAGES/quickstart.po index 75a6f3e5..b4275455 100644 --- a/docs/source/locale/zh/LC_MESSAGES/quickstart.po +++ b/docs/source/locale/zh/LC_MESSAGES/quickstart.po @@ -6,18 +6,17 @@ # msgid "" msgstr "" -"Project-Id-Version: tensorcircuit\n" +"Project-Id-Version: tensorcircuit\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2023-05-07 10:47+0800\n" +"POT-Creation-Date: 2023-07-14 15:43+0800\n" "PO-Revision-Date: 2023-05-07 11:01+0800\n" "Last-Translator: Xinghan Yang\n" -"Language-Team: Xinghan Yang\n" "Language: cn\n" +"Language-Team: Xinghan Yang\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" -"Generated-By: Babel 2.9.1\n" -"X-Generator: Poedit 3.2.2\n" +"Generated-By: Babel 2.12.1\n" #: ../../source/quickstart.rst:3 msgid "Quick Start" @@ -28,22 +27,23 @@ msgid "Installation" msgstr "安装" #: ../../source/quickstart.rst:8 -msgid "For x86 Linux or Mac," -msgstr "" +msgid "For x86 Linux," +msgstr "x64 Linux" #: ../../source/quickstart.rst:10 msgid "``pip install tensorcircuit``" -msgstr "" +msgstr "``pip install tensorcircuit``" #: ../../source/quickstart.rst:12 msgid "" -"is in general enough. Either pip from conda or other python env managers is fine." +"is in general enough. Either pip from conda or other python env managers " +"is fine." msgstr "" #: ../../source/quickstart.rst:15 msgid "" -"Since there are many optional packages for various features, the users may need " -"to install more pip packages when required." +"Since there are many optional packages for various features, the users " +"may need to install more pip packages when required." msgstr "" #: ../../source/quickstart.rst:18 @@ -52,9 +52,10 @@ msgstr "" #: ../../source/quickstart.rst:19 msgid "" -"please refer to the GPU aware installation guide of corresponding machine " -"learning frameworks: `TensorFlow `_, " -"`Jax `_, or `PyTorch " +"please refer to the GPU aware installation guide of corresponding machine" +" learning frameworks: `TensorFlow " +"`_, `Jax " +"`_, or `PyTorch " "`_." msgstr "" @@ -64,46 +65,48 @@ msgstr "" #: ../../source/quickstart.rst:26 msgid "" -"``sudo docker run -it --network host --gpus all tensorcircuit/tensorcircuit``." +"``sudo docker run -it --network host --gpus all " +"tensorcircuit/tensorcircuit``." msgstr "" #: ../../source/quickstart.rst:28 msgid "" -"For more details on docker setup, please refer to `docker readme `_." +"For more details on docker setup, please refer to `docker readme " +"`_." msgstr "" #: ../../source/quickstart.rst:30 msgid "" -"For Windows, due to the lack of support for Jax, we recommend to use docker or " -"WSL, please refer to `TC via windows docker `_ or `TC via WSL `_." +"For Windows, due to the lack of support for Jax, we recommend to use " +"docker or WSL, please refer to `TC via windows docker " +"`_ or `TC via WSL " +"`_." msgstr "" #: ../../source/quickstart.rst:32 -msgid "" -"For Mac with M series chips (arm architecture), please refer to `TC on Mac M " -"series `_." -msgstr "" +msgid "For MacOS, please refer to `TC on Mac `_." +msgstr "For MacOS, please refer to `在Mac上安装TC `_." #: ../../source/quickstart.rst:34 msgid "" -"Overall, the installation of TensorCircuit is simple, since it is purely in " -"Python and hence very portable. As long as the users can take care of the " -"installation of ML frameworks on the corresponding system, TensorCircuit will " -"work as expected." +"Overall, the installation of TensorCircuit is simple, since it is purely " +"in Python and hence very portable. As long as the users can take care of " +"the installation of ML frameworks on the corresponding system, " +"TensorCircuit will work as expected." msgstr "" #: ../../source/quickstart.rst:37 msgid "" -"To debug the installation issue or report bugs, please check the environment " -"information by ``tc.about()``." +"To debug the installation issue or report bugs, please check the " +"environment information by ``tc.about()``." msgstr "" #: ../../source/quickstart.rst:40 msgid "" -"We also provide a nightly build of tensorcircuit via PyPI which can be accessed " -"by ``pip uninstall tensorcircuit``, then ``pip install tensorcircuit-nightly``" +"We also provide a nightly build of tensorcircuit via PyPI which can be " +"accessed by ``pip uninstall tensorcircuit``, then ``pip install " +"tensorcircuit-nightly``" msgstr "" #: ../../source/quickstart.rst:46 @@ -124,20 +127,18 @@ msgstr "**输入状态:**" #: ../../source/quickstart.rst:54 msgid "" -"The default input function for the circuit is :math:`\\vert 0^n \\rangle`. One " -"can change this to other wavefunctions by directly feeding the inputs state " -"vectors w: ``c=tc.Circuit(n, inputs=w)``." +"The default input function for the circuit is :math:`\\vert 0^n " +"\\rangle`. One can change this to other wavefunctions by directly feeding" +" the inputs state vectors w: ``c=tc.Circuit(n, inputs=w)``." msgstr "" -"电路的默认输入函数是 :math:`\\vert 0^n \\rangle` 。可以通过直接输入输入状态向量 " -"w 将其更改为其他波函数: ``c=tc.Circuit(n, inputs=w)``。" +"电路的默认输入函数是 :math:`\\vert 0^n \\rangle` 。可以通过直接输入输入状态向量 w 将其更改为其他波函数: " +"``c=tc.Circuit(n, inputs=w)``。" #: ../../source/quickstart.rst:56 msgid "" -"One can also feed matrix product states as input states for the circuit, but we " -"leave MPS/MPO usage for future sections." -msgstr "" -"也可以将矩阵乘积状态作为电路的输入状态，但我们将矩阵乘积状态/矩阵乘积算子的使用留" -"待后续讲解。" +"One can also feed matrix product states as input states for the circuit, " +"but we leave MPS/MPO usage for future sections." +msgstr "也可以将矩阵乘积状态作为电路的输入状态，但我们将矩阵乘积状态/矩阵乘积算子的使用留待后续讲解。" #: ../../source/quickstart.rst:58 msgid "**Quantum Gates:**" @@ -145,13 +146,12 @@ msgstr "**量子门:**" #: ../../source/quickstart.rst:60 msgid "" -"We can apply gates on circuit objects. For example, using ``c.H(1)`` or ``c." -"rx(2, theta=0.2)``, we can apply Hadamard gate on qubit 1 (0-based) or apply Rx " -"gate on qubit 2 as :math:`e^{-i\\theta/2 X}`." +"We can apply gates on circuit objects. For example, using ``c.H(1)`` or " +"``c.rx(2, theta=0.2)``, we can apply Hadamard gate on qubit 1 (0-based) " +"or apply Rx gate on qubit 2 as :math:`e^{-i\\theta/2 X}`." msgstr "" -"我们可以将门应用于电路对象。 例如，使用 ``c.H(1)`` 或 ``c.rx(2, theta=0.2)``，我" -"们可以将 Hadamard 门应用于量子比特1 （基于0）或将 Rx 门应用于量子比特2 :math:" -"`e^{-i\\theta/2 X}`。" +"我们可以将门应用于电路对象。 例如，使用 ``c.H(1)`` 或 ``c.rx(2, theta=0.2)``，我们可以将 Hadamard " +"门应用于量子比特1 （基于0）或将 Rx 门应用于量子比特2 :math:`e^{-i\\theta/2 X}`。" #: ../../source/quickstart.rst:62 msgid "The same rule also applies to multi-qubit gates, such as ``c.cnot(0, 1)``." @@ -163,16 +163,16 @@ msgstr "这些量子门也是高度可定制的，下面是两个例子" #: ../../source/quickstart.rst:66 msgid "" -"``c.exp1(0, 1, unitary=m, theta=0.2)`` which is for the exponential gate :math:" -"`e^{i\\theta m}` of any matrix m as long as :math:`m^2=1`." +"``c.exp1(0, 1, unitary=m, theta=0.2)`` which is for the exponential gate " +":math:`e^{i\\theta m}` of any matrix m as long as :math:`m^2=1`." msgstr "" -"``c.exp1(0, 1, unitary=m, theta=0.2)`` 用于任何矩阵 m 的指数门 :math:" -"`e^{i\\theta m}`，只要 m 满足 :math:`m^2=1`。" +"``c.exp1(0, 1, unitary=m, theta=0.2)`` 用于任何矩阵 m 的指数门 :math:`e^{i\\theta " +"m}`，只要 m 满足 :math:`m^2=1`。" #: ../../source/quickstart.rst:68 msgid "" -"``c.any(0, 1, unitary=m)`` which is for applying the unitary gate m on the " -"circuit." +"``c.any(0, 1, unitary=m)`` which is for applying the unitary gate m on " +"the circuit." msgstr "``c.any(0, 1, unitary=m)`` 在电路上作用任意的幺正量子门。" #: ../../source/quickstart.rst:70 @@ -185,36 +185,33 @@ msgstr "**测量与期望**" #: ../../source/quickstart.rst:74 msgid "" -"The most straightforward way to get the output from the circuit object is by " -"getting the output wavefunction in vector form as ``c.state()``." -msgstr "" -"从电路对象中获取输出的最直接的方法是通过 ``c.state()`` 以向量形式获取输出波函数。" +"The most straightforward way to get the output from the circuit object is" +" by getting the output wavefunction in vector form as ``c.state()``." +msgstr "从电路对象中获取输出的最直接的方法是通过 ``c.state()`` 以向量形式获取输出波函数。" #: ../../source/quickstart.rst:76 msgid "" -"For bitstring sampling, we have ``c.perfect_sampling()`` which returns the " -"bitstring and the corresponding probability amplitude." -msgstr "" -"对于位串采样，我们有 ``c.perfect_sampling()``，它返回位串和相应的概率幅度。" +"For bitstring sampling, we have ``c.perfect_sampling()`` which returns " +"the bitstring and the corresponding probability amplitude." +msgstr "对于位串采样，我们有 ``c.perfect_sampling()``，它返回位串和相应的概率幅度。" #: ../../source/quickstart.rst:78 msgid "" -"To measure part of the qubits, we can use ``c.measure(0, 1)``, if we want to " -"know the corresponding probability of the measurement output, try ``c.measure(0, " -"1, with_prob=True)``. The measure API is by default non-jittable, but we also " -"have a jittable version as ``c.measure_jit(0, 1)``." +"To measure part of the qubits, we can use ``c.measure(0, 1)``, if we want" +" to know the corresponding probability of the measurement output, try " +"``c.measure(0, 1, with_prob=True)``. The measure API is by default non-" +"jittable, but we also have a jittable version as ``c.measure_jit(0, 1)``." msgstr "" -"要测量部分量子比特，我们可以使用 ``c.measure(0, 1)``，如果我们想知道测量的结果的" -"对应概率，可以尝试 ``c.measure(0, 1, with_prob=True)``。 测量 API 在默认情况下是" -"不可即时编译的 ，但我们也有一个可即时编译的版本，如 ``c.measure_jit(0, 1)``。" +"要测量部分量子比特，我们可以使用 ``c.measure(0, 1)``，如果我们想知道测量的结果的对应概率，可以尝试 " +"``c.measure(0, 1, with_prob=True)``。 测量 API 在默认情况下是不可即时编译的 " +"，但我们也有一个可即时编译的版本，如 ``c.measure_jit(0, 1)``。" #: ../../source/quickstart.rst:80 msgid "" -"The measurement and sampling utilize advanced algorithms based on tensornetwork " -"and thus require no knowledge or space for the full wavefunction." -msgstr "" -"测量和采样使用了基于张量网络的高级算法，因此不需要任何相关知识或者空间来获取全波" -"函数。" +"The measurement and sampling utilize advanced algorithms based on " +"tensornetwork and thus require no knowledge or space for the full " +"wavefunction." +msgstr "测量和采样使用了基于张量网络的高级算法，因此不需要任何相关知识或者空间来获取全波函数。" #: ../../source/quickstart.rst:82 msgid "See the example below:" @@ -222,25 +219,26 @@ msgstr "请看下面的例子：" #: ../../source/quickstart.rst:100 msgid "" -"To compute expectation values for local observables, we have ``c.expectation([tc." -"gates.z(), [0]], [tc.gates.z(), [1]])`` for :math:`\\langle Z_0Z_1 \\rangle` or " -"``c.expectation([tc.gates.x(), [0]])`` for :math:`\\langle X_0 \\rangle`." +"To compute expectation values for local observables, we have " +"``c.expectation([tc.gates.z(), [0]], [tc.gates.z(), [1]])`` for " +":math:`\\langle Z_0Z_1 \\rangle` or ``c.expectation([tc.gates.x(), " +"[0]])`` for :math:`\\langle X_0 \\rangle`." msgstr "" -"为了计算局部可观察量的期望值，我们有 ``c.expectation([tc.gates.z(), [0]], [tc." -"gates.z(), [1]])`` 对应的期望为 :math:`\\langle Z_0Z_1 \\rangle` 时，或 ``c." -"expectation([tc.gates.x(), [0]])`` 对应的期望为 :math:`\\langle X_0 \\rangle`时." +"为了计算局部可观察量的期望值，我们有 ``c.expectation([tc.gates.z(), [0]], [tc.gates.z(), " +"[1]])`` 对应的期望为 :math:`\\langle Z_0Z_1 \\rangle` 时，或 " +"``c.expectation([tc.gates.x(), [0]])`` 对应的期望为 :math:`\\langle X_0 " +"\\rangle`时." #: ../../source/quickstart.rst:102 msgid "" -"This expectation API is rather flexible, as one can measure an m on several " -"qubits as ``c.expectation([m, [0, 1, 2]])``." -msgstr "" -"因为可以在几个量子比特上测量一个 m，这种计算期望值的 API 相当灵活：``c." -"expectation([m, [0, 1, 2]])``。" +"This expectation API is rather flexible, as one can measure an m on " +"several qubits as ``c.expectation([m, [0, 1, 2]])``." +msgstr "因为可以在几个量子比特上测量一个 m，这种计算期望值的 API 相当灵活：``c.expectation([m, [0, 1, 2]])``。" #: ../../source/quickstart.rst:104 msgid "" -"We can also extract the unitary matrix underlying the whole circuit as follows:" +"We can also extract the unitary matrix underlying the whole circuit as " +"follows:" msgstr "我们还可以提取整个电路下面的幺正矩阵，如下所示：" #: ../../source/quickstart.rst:117 @@ -251,22 +249,20 @@ msgstr "**电路可视化**" msgid "" "We currently support transform ``tc.Circuit`` from and to Qiskit " "``QuantumCircuit`` object." -msgstr "" -"我们目前支持 ``tc.Circuit`` 与 Qiskit ``QuantumCircuit`` 对象之间的互相转换。" +msgstr "我们目前支持 ``tc.Circuit`` 与 Qiskit ``QuantumCircuit`` 对象之间的互相转换。" #: ../../source/quickstart.rst:121 msgid "" -"Export to Qiskit (possible for further hardware experiment, compiling, and " -"visualization): ``c.to_qiskit()``." -msgstr "" -"导出到 Qiskit（可能用于进一步的硬件实验、编译和可视化）：``c.to_qiskit()``。" +"Export to Qiskit (possible for further hardware experiment, compiling, " +"and visualization): ``c.to_qiskit()``." +msgstr "导出到 Qiskit（可能用于进一步的硬件实验、编译和可视化）：``c.to_qiskit()``。" #: ../../source/quickstart.rst:123 msgid "" "Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``. " -"Parameterized Qiskit circuit is supported by passing the parameters to the " -"``binding_parameters`` argument of the ``from_qiskit`` function, similar to the " -"``assign_parameters`` function in Qiskit." +"Parameterized Qiskit circuit is supported by passing the parameters to " +"the ``binding_parameters`` argument of the ``from_qiskit`` function, " +"similar to the ``assign_parameters`` function in Qiskit." msgstr "" #: ../../source/quickstart.rst:127 @@ -275,40 +271,41 @@ msgstr "**电路可视化**" #: ../../source/quickstart.rst:129 msgid "" -"``c.vis_tex()`` can generate tex code for circuit visualization based on LaTeX " -"`quantikz `__ package." +"``c.vis_tex()`` can generate tex code for circuit visualization based on " +"LaTeX `quantikz `__ package." msgstr "" "``c.vis_tex()`` 可以基于 `quantikz `__ " "package 生成用于电路可视化的 tex 代码。" #: ../../source/quickstart.rst:131 msgid "" -"There are also some automatic pipeline helper functions to directly generate " -"figures from tex code, but they require extra installations in the environment." -msgstr "" -"还有一些自动辅助函数可以直接从 tex 代码生成图形，但它们需要在环境中进行额外安装。" +"There are also some automatic pipeline helper functions to directly " +"generate figures from tex code, but they require extra installations in " +"the environment." +msgstr "还有一些自动辅助函数可以直接从 tex 代码生成图形，但它们需要在环境中进行额外安装。" #: ../../source/quickstart.rst:133 msgid "" -"``render_pdf(tex)`` function requires full installation of LaTeX locally. And in " -"the Jupyter environment, we may prefer ``render_pdf(tex, notebook=True)`` to " -"return jpg figures, which further require wand magicwand library installed, see " -"`here `__." +"``render_pdf(tex)`` function requires full installation of LaTeX locally." +" And in the Jupyter environment, we may prefer ``render_pdf(tex, " +"notebook=True)`` to return jpg figures, which further require wand " +"magicwand library installed, see `here `__." msgstr "" -"``render_pdf(tex)`` 函数需要在本地完全安装 LaTeX。 在 Jupyter 环境中，我们可能会" -"偏好 ``render_pdf(tex, notebook=True)`` 来返回 jpg 图形，这需要安装 wand " -"magicwand 库，请参阅 `这里 `__ 。" +"``render_pdf(tex)`` 函数需要在本地完全安装 LaTeX。 在 Jupyter 环境中，我们可能会偏好 " +"``render_pdf(tex, notebook=True)`` 来返回 jpg 图形，这需要安装 wand magicwand 库，请参阅 " +"`这里 `__ 。" #: ../../source/quickstart.rst:135 msgid "" -"Or since we can transform ``tc.Circuit`` into QuantumCircuit easily, we have a " -"simple pipeline to first transform ``tc.Circuit`` into Qiskit and then call the " -"visualization built in Qiskit. Namely, we have ``c.draw()`` API." +"Or since we can transform ``tc.Circuit`` into QuantumCircuit easily, we " +"have a simple pipeline to first transform ``tc.Circuit`` into Qiskit and " +"then call the visualization built in Qiskit. Namely, we have ``c.draw()``" +" API." msgstr "" -"从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)`` 或者因为我们可" -"以轻松地将 ``tc.Circuit`` 转换为 QuantumCircuit，我们有一个简单的管道来首先转换 " -"``tc.Circuit`` 为 Qiskit，然后调用 Qiskit 中内置的可视化。 也就是说，我们有 ``c." -"draw()`` API。" +"从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)`` " +"或者因为我们可以轻松地将 ``tc.Circuit`` 转换为 QuantumCircuit，我们有一个简单的管道来首先转换 " +"``tc.Circuit`` 为 Qiskit，然后调用 Qiskit 中内置的可视化。 也就是说，我们有 ``c.draw()`` API。" #: ../../source/quickstart.rst:137 msgid "**Circuit Intermediate Representation:**" @@ -316,21 +313,19 @@ msgstr "**电路中间表示:**" #: ../../source/quickstart.rst:139 msgid "" -"TensorCircuit provides its own circuit IR as a python list of dicts. This IR can " -"be further utilized to run compiling, generate serialization qasm, or render " -"circuit figures." -msgstr "" -"TensorCircuit 提供自己的中间表示是元素是字典的列表。此中间表示可进一步用于运行编" -"译、生成序列化 qasm 或渲染电路图。" +"TensorCircuit provides its own circuit IR as a python list of dicts. This" +" IR can be further utilized to run compiling, generate serialization " +"qasm, or render circuit figures." +msgstr "TensorCircuit 提供自己的中间表示是元素是字典的列表。此中间表示可进一步用于运行编译、生成序列化 qasm 或渲染电路图。" #: ../../source/quickstart.rst:141 msgid "" -"The IR is given as a list, each element is a dict containing information on one " -"gate that is applied to the circuit. Note gate attr in the dict is a python " -"function that returns the gate's node." +"The IR is given as a list, each element is a dict containing information " +"on one gate that is applied to the circuit. Note gate attr in the dict is" +" a python function that returns the gate's node." msgstr "" -"中间表示以列表形式给出，每个元素都是一个字典，其中包含应用于电路的一个量子门的信" -"息。 注意字典中的 gate atrr 实际上是一个返回此量子门的节点的 python 函数。" +"中间表示以列表形式给出，每个元素都是一个字典，其中包含应用于电路的一个量子门的信息。 注意字典中的 gate atrr " +"实际上是一个返回此量子门的节点的 python 函数。" #: ../../source/quickstart.rst:153 msgid "Programming Paradigm" @@ -338,38 +333,36 @@ msgstr "编程范式" #: ../../source/quickstart.rst:155 msgid "" -"The most common case and the most typical programming paradigm for TensorCircuit " -"are to evaluate the circuit output and the corresponding quantum gradients, " -"which is common in variational quantum algorithms." -msgstr "" -"TensorCircuit 最常见的情况和最典型的编程范式是评估电路的输出以及相应的量子梯度，" -"这在变分量子算法中很常见。" +"The most common case and the most typical programming paradigm for " +"TensorCircuit are to evaluate the circuit output and the corresponding " +"quantum gradients, which is common in variational quantum algorithms." +msgstr "TensorCircuit 最常见的情况和最典型的编程范式是评估电路的输出以及相应的量子梯度，这在变分量子算法中很常见。" #: ../../source/quickstart.rst:182 #, fuzzy msgid "" -"Also for a non-quantum example (linear regression) demonstrating the backend " -"agnostic feature, variables with pytree support, AD/jit/vmap usage, and " -"variational optimization loops. Please refer to the example script: `linear " -"regression example `_. This example might be more friendly to the " -"machine learning community since it is purely classical while also showcasing " -"the main features and paradigms of tensorcircuit." +"Also for a non-quantum example (linear regression) demonstrating the " +"backend agnostic feature, variables with pytree support, AD/jit/vmap " +"usage, and variational optimization loops. Please refer to the example " +"script: `linear regression example `_. This example " +"might be more friendly to the machine learning community since it is " +"purely classical while also showcasing the main features and paradigms of" +" tensorcircuit." msgstr "" -"同样对于演示后端不可知特性的非量子示例（线性回归），pytree 支持变量、自动微分/即" -"时编译/矢量并行化 用法和变分优化循环。请参考示例脚本: `线性回归示例 `_ 。 这" -"个例子可能对机器学习的用户更友好，因为它纯粹是经典的，同时也展示了 TensorCircuit " -"的主要特征和范式。" +"同样对于演示后端不可知特性的非量子示例（线性回归），pytree 支持变量、自动微分/即时编译/矢量并行化 用法和变分优化循环。请参考示例脚本: " +"`线性回归示例 `_ 。 " +"这个例子可能对机器学习的用户更友好，因为它纯粹是经典的，同时也展示了 TensorCircuit 的主要特征和范式。" #: ../../source/quickstart.rst:185 msgid "" -"If the user has no intention to maintain the application code in a backend " -"agnostic fashion, the API for ML frameworks can be more handily used and " -"interleaved with the TensorCircuit API." +"If the user has no intention to maintain the application code in a " +"backend agnostic fashion, the API for ML frameworks can be more handily " +"used and interleaved with the TensorCircuit API." msgstr "" -"如果用户无意以与后端无关的方式维护应用程序代码，则可以更方便地使用用于机器学习框" -"架的 API 并将其与 TensorCircuit API 交替使用。" +"如果用户无意以与后端无关的方式维护应用程序代码，则可以更方便地使用用于机器学习框架的 API 并将其与 TensorCircuit API " +"交替使用。" #: ../../source/quickstart.rst:220 msgid "Automatic Differentiation, JIT, and Vectorized Parallelism" @@ -377,22 +370,21 @@ msgstr "自动微分、即时编译和矢量化并行 " #: ../../source/quickstart.rst:222 msgid "" -"For concepts of AD, JIT and VMAP, please refer to `Jax documentation `__ ." +"For concepts of AD, JIT and VMAP, please refer to `Jax documentation " +"`__ ." msgstr "" -"关于自动微分、即时编译和向量并行化，请参考 `Jax 文档 `__ 。" +"关于自动微分、即时编译和向量并行化，请参考 `Jax 文档 " +"`__ 。" #: ../../source/quickstart.rst:224 msgid "" "The related API design in TensorCircuit closely follows the functional " -"programming design pattern in Jax with some slight differences. So we strongly " -"recommend users learn some basics about Jax no matter which ML backend they " -"intend to use." +"programming design pattern in Jax with some slight differences. So we " +"strongly recommend users learn some basics about Jax no matter which ML " +"backend they intend to use." msgstr "" -"TensorCircuit 中的相关 API 设计与 Jax 中的函数式编程的设计模式密切相关，但是略有" -"不同。因此，我们强烈建议用户学习一些有关 Jax 的基础知识，无论他们打算使用哪种机器" -"学习后端。" +"TensorCircuit 中的相关 API 设计与 Jax 中的函数式编程的设计模式密切相关，但是略有不同。因此，我们强烈建议用户学习一些有关 " +"Jax 的基础知识，无论他们打算使用哪种机器学习后端。" #: ../../source/quickstart.rst:226 msgid "**AD Support:**" @@ -400,11 +392,9 @@ msgstr "**自动微分支持**" #: ../../source/quickstart.rst:228 msgid "" -"Gradients, vjps, jvps, natural gradients, Jacobians, and Hessians. AD is the " -"base for all modern machine learning libraries." -msgstr "" -"梯度、矢量雅可比乘积、自然梯度、 Jacobian 矩阵和 Hessian 矩阵。自动微分是所有现代" -"机器学习库的基础。" +"Gradients, vjps, jvps, natural gradients, Jacobians, and Hessians. AD is " +"the base for all modern machine learning libraries." +msgstr "梯度、矢量雅可比乘积、自然梯度、 Jacobian 矩阵和 Hessian 矩阵。自动微分是所有现代机器学习库的基础。" #: ../../source/quickstart.rst:232 msgid "**JIT Support:**" @@ -412,19 +402,18 @@ msgstr "**自动微分支持**" #: ../../source/quickstart.rst:234 msgid "" -"Parameterized quantum circuits can run in a blink. Always use jit if the circuit " -"will get evaluations multiple times, it can greatly boost the simulation with " -"two or three order time reduction. But also be cautious, users need to be " -"familiar with jit, otherwise, the jitted function may return unexpected results " -"or recompile on every hit (wasting lots of time). To learn more about the jit " -"mechanism, one can refer to documentation or blogs on ``tf.function`` or ``jax." -"jit``, though these two still have subtle differences." +"Parameterized quantum circuits can run in a blink. Always use jit if the " +"circuit will get evaluations multiple times, it can greatly boost the " +"simulation with two or three order time reduction. But also be cautious, " +"users need to be familiar with jit, otherwise, the jitted function may " +"return unexpected results or recompile on every hit (wasting lots of " +"time). To learn more about the jit mechanism, one can refer to " +"documentation or blogs on ``tf.function`` or ``jax.jit``, though these " +"two still have subtle differences." msgstr "" -"参数化的量子电路可以在瞬间完成运行。如果电路将得到多次运行，请始终使用即时编译，" -"它可以大大提高仿真速度，减少两到三个数量级的运行时间。但也要小心，用户需要熟悉 即" -"时编译，否则，即时编译的函数可能会返回意外结果或每次在点击时都重新编译（浪费大量" -"时间）。要了解更多关于即时编译机制的信息，可以参考关于 ``tf.function`` 或 ``jax." -"jit`` 的文档或博客，即使这两者仍然存在细微差别。" +"参数化的量子电路可以在瞬间完成运行。如果电路将得到多次运行，请始终使用即时编译，它可以大大提高仿真速度，减少两到三个数量级的运行时间。但也要小心，用户需要熟悉" +" 即时编译，否则，即时编译的函数可能会返回意外结果或每次在点击时都重新编译（浪费大量时间）。要了解更多关于即时编译机制的信息，可以参考关于 " +"``tf.function`` 或 ``jax.jit`` 的文档或博客，即使这两者仍然存在细微差别。" #: ../../source/quickstart.rst:238 msgid "**VMAP Support:**" @@ -432,12 +421,13 @@ msgstr "**自动微分支持**" #: ../../source/quickstart.rst:240 msgid "" -"Inputs, parameters, measurements, circuit structures, and Monte Carlo noise can " -"all be evaluated in parallel. To learn more about vmap mechanism, one can refer " -"to documentation or blogs on ``tf.vectorized_map`` or ``jax.vmap``." +"Inputs, parameters, measurements, circuit structures, and Monte Carlo " +"noise can all be evaluated in parallel. To learn more about vmap " +"mechanism, one can refer to documentation or blogs on " +"``tf.vectorized_map`` or ``jax.vmap``." msgstr "" -"输入、参数、测量、电路结构、蒙特卡洛噪声都可以并行测算。 要了解有关矢量并行化机制" -"的更多信息，可以参考 ``tf.vectorized_map`` 或 ``jax.vmap`` 上的文档或博客。" +"输入、参数、测量、电路结构、蒙特卡洛噪声都可以并行测算。 要了解有关矢量并行化机制的更多信息，可以参考 ``tf.vectorized_map``" +" 或 ``jax.vmap`` 上的文档或博客。" #: ../../source/quickstart.rst:245 msgid "Backend Agnosticism" @@ -445,34 +435,36 @@ msgstr "后端无关特性" #: ../../source/quickstart.rst:247 msgid "" -"TensorCircuit supports TensorFlow, Jax, and PyTorch backends. We recommend using " -"TensorFlow or Jax backend since PyTorch lacks advanced jit and vmap features." +"TensorCircuit supports TensorFlow, Jax, and PyTorch backends. We " +"recommend using TensorFlow or Jax backend since PyTorch lacks advanced " +"jit and vmap features." msgstr "" -"TensorCircuit 支持 TensorFlow、Jax 和 PyTorch 后端。 我们建议使用 TensorFlow 或 " -"Jax 后端，因为 PyTorch 缺乏高级 jit 和 vmap 功能。" +"TensorCircuit 支持 TensorFlow、Jax 和 PyTorch 后端。 我们建议使用 TensorFlow 或 Jax " +"后端，因为 PyTorch 缺乏高级 jit 和 vmap 功能。" #: ../../source/quickstart.rst:249 msgid "" -"The backend can be set as ``K=tc.set_backend(\"jax\")`` and ``K`` is the backend " -"with a full set of APIs as a conventional ML framework, which can also be " -"accessed by ``tc.backend``." +"The backend can be set as ``K=tc.set_backend(\"jax\")`` and ``K`` is the " +"backend with a full set of APIs as a conventional ML framework, which can" +" also be accessed by ``tc.backend``." msgstr "" -"后端可以设置为 ``K=tc.set_backend(\"jax\")`` ，``K``作为常规机器学习框架的全套API" -"的后端，也可以通过``tc .backend`` 被访问。" +"后端可以设置为 ``K=tc.set_backend(\"jax\")`` ，``K``作为常规机器学习框架的全套API的后端，也可以通过``tc" +" .backend`` 被访问。" #: ../../source/quickstart.rst:272 #, fuzzy msgid "" -"The supported APIs in the backend come from two sources, one part is implemented " -"in `TensorNetwork package `__ and the other part is implemented " -"in `TensorCircuit package `__. To " -"see all the backend agnostic APIs, try:" +"The supported APIs in the backend come from two sources, one part is " +"implemented in `TensorNetwork package " +"`__" +" and the other part is implemented in `TensorCircuit package " +"`__. To see all the backend " +"agnostic APIs, try:" msgstr "" -"在后端支持的 APIs 有两个来源 , 一个来自 `TensorNetwork `__ " -"另一个来自 `TensorCircuit package `__。" +"在后端支持的 APIs 有两个来源 , 一个来自 `TensorNetwork " +"`__" +" 另一个来自 `TensorCircuit package `__。" #: ../../source/quickstart.rst:427 msgid "​" @@ -484,20 +476,19 @@ msgstr "转换 dtype" #: ../../source/quickstart.rst:432 msgid "" -"TensorCircuit supports simulation using 32/64 bit precession. The default dtype " -"is 32-bit as \"complex64\". Change this by ``tc.set_dtype(\"complex128\")``." +"TensorCircuit supports simulation using 32/64 bit precession. The default" +" dtype is 32-bit as \"complex64\". Change this by " +"``tc.set_dtype(\"complex128\")``." msgstr "" "TensorCircuit 支持使用 32/64 bit 精确度的模拟。默认的 dtype 是 32-bit 的 " -"\"complex64\"。可以通过 ``tc.set_dtype(\"complex128\")`` 把 dtype 改为 " -"\"complex 128\" 。" +"\"complex64\"。可以通过 ``tc.set_dtype(\"complex128\")`` 把 dtype 改为 \"complex" +" 128\" 。" #: ../../source/quickstart.rst:435 msgid "" -"``tc.dtypestr`` always returns the current dtype string: either \"complex64\" or " -"\"complex128\"." -msgstr "" -"``tc.dtypestr`` 总会返回当前的 dtype 字符串: 不是 \"complex64\" 就是 " -"\"complex128\"." +"``tc.dtypestr`` always returns the current dtype string: either " +"\"complex64\" or \"complex128\"." +msgstr "``tc.dtypestr`` 总会返回当前的 dtype 字符串: 不是 \"complex64\" 就是 \"complex128\"." #: ../../source/quickstart.rst:439 msgid "Setup the Contractor" @@ -505,29 +496,29 @@ msgstr "设置 contractor" #: ../../source/quickstart.rst:441 msgid "" -"TensorCircuit is a tensornetwork contraction-based quantum circuit simulator. A " -"contractor is for searching for the optimal contraction path of the circuit " -"tensornetwork." -msgstr "" -"TensorCircuit 是一个基于张量网络收缩的量子电路模拟器。 contractor 用于搜索电路张" -"量网络的最佳收缩路径。" +"TensorCircuit is a tensornetwork contraction-based quantum circuit " +"simulator. A contractor is for searching for the optimal contraction path" +" of the circuit tensornetwork." +msgstr "TensorCircuit 是一个基于张量网络收缩的量子电路模拟器。 contractor 用于搜索电路张量网络的最佳收缩路径。" #: ../../source/quickstart.rst:443 msgid "" -"There are various advanced contractors provided by third-party packages, such as " -"`opt-einsum `__ and `cotengra `__." +"There are various advanced contractors provided by third-party packages, " +"such as `opt-einsum `__ and " +"`cotengra `__." msgstr "" -"有各种第三方包提供的高级 contractor ，例如 `opt-einsum `__ 和 `cotengra `__ 。" +"有各种第三方包提供的高级 contractor ，例如 `opt-einsum " +"`__ 和 `cotengra " +"`__ 。" #: ../../source/quickstart.rst:445 msgid "" -"`opt-einsum` is shipped with TensorNetwork package. To use cotengra, one needs " -"to pip install it; kahypar is also recommended to install with cotengra." +"`opt-einsum` is shipped with TensorNetwork package. To use cotengra, one " +"needs to pip install it; kahypar is also recommended to install with " +"cotengra." msgstr "" -"`opt-einsum` 随 TensorNetwork 软件包一起。如要使用 cotengra，则需要 pip 安装它； " -"还建议安装 cotengra 随 kahypar 一起使用。" +"`opt-einsum` 随 TensorNetwork 软件包一起。如要使用 cotengra，则需要 pip 安装它； 还建议安装 " +"cotengra 随 kahypar 一起使用。" #: ../../source/quickstart.rst:447 msgid "Some setup cases:" @@ -536,15 +527,17 @@ msgstr "一些设置案例：" #: ../../source/quickstart.rst:473 #, fuzzy msgid "" -"For advanced configurations on cotengra contractors, please refer to cotengra " -"`doc `__ and more fancy " -"examples can be found at `contractor tutorial `__." +"For advanced configurations on cotengra contractors, please refer to " +"cotengra `doc " +"`__ and more " +"fancy examples can be found at `contractor tutorial `__." msgstr "" -"有关 cotengra contractor 的高级配置，请参阅 cotengra `doc `__ 更多精彩示例在 `contractor 教程 " -"`__." +"有关 cotengra contractor 的高级配置，请参阅 cotengra `doc " +"`__ 更多精彩示例在 " +"`contractor 教程 `__." #: ../../source/quickstart.rst:475 msgid "**Setup in Function or Context Level**" @@ -552,11 +545,9 @@ msgstr "**函数和上下文级别的设置**" #: ../../source/quickstart.rst:477 msgid "" -"Beside global level setup, we can also setup the backend, the dtype, and the " -"contractor at the function level or context manager level:" -msgstr "" -"除了全局级别设置，我们还可以在函数级别或上下文管理器级别设置后端、dtype 和" -"contractor：" +"Beside global level setup, we can also setup the backend, the dtype, and " +"the contractor at the function level or context manager level:" +msgstr "除了全局级别设置，我们还可以在函数级别或上下文管理器级别设置后端、dtype 和contractor：" #: ../../source/quickstart.rst:495 msgid "Noisy Circuit Simulation" @@ -568,12 +559,12 @@ msgstr "**蒙特卡洛态模拟器**" #: ../../source/quickstart.rst:499 msgid "" -"For the Monte Carlo trajectory noise simulator, the unitary Kraus channel can be " -"handled easily. TensorCircuit also supports fully jittable and differentiable " -"general Kraus channel Monte Carlo simulation, though." +"For the Monte Carlo trajectory noise simulator, the unitary Kraus channel" +" can be handled easily. TensorCircuit also supports fully jittable and " +"differentiable general Kraus channel Monte Carlo simulation, though." msgstr "" -"对于蒙特卡洛轨迹噪声模拟器，可以轻松处理幺正的 Kraus 通道。 不过，TensorCircuit " -"还支持完全可即时编译和可微分的通用 Kraus 通道蒙特卡罗模拟。" +"对于蒙特卡洛轨迹噪声模拟器，可以轻松处理幺正的 Kraus 通道。 不过，TensorCircuit 还支持完全可即时编译和可微分的通用 " +"Kraus 通道蒙特卡罗模拟。" #: ../../source/quickstart.rst:526 msgid "**Density Matrix Simulator:**" @@ -581,12 +572,10 @@ msgstr "**密度矩阵模拟器**" #: ../../source/quickstart.rst:528 msgid "" -"Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full form, " -"but takes twice qubits to do noiseless simulation. The API is the same as ``tc." -"Circuit``." -msgstr "" -"密度矩阵模拟器``tc.DMCircuit`` 以完整形式模拟噪声，但需要两倍的量子比特。API 与 " -"``tc.Circuit`` 基本相同。" +"Density matrix simulator ``tc.DMCircuit`` simulates the noise in a full " +"form, but takes twice qubits to do noiseless simulation. The API is the " +"same as ``tc.Circuit``." +msgstr "密度矩阵模拟器``tc.DMCircuit`` 以完整形式模拟噪声，但需要两倍的量子比特。API 与 ``tc.Circuit`` 基本相同。" #: ../../source/quickstart.rst:547 msgid "**Experiment with quantum errors:**" @@ -602,8 +591,8 @@ msgstr "" #: ../../source/quickstart.rst:567 msgid "" -"Readout error can be added in experiments for sampling and expectation value " -"calculation." +"Readout error can be added in experiments for sampling and expectation " +"value calculation." msgstr "" #: ../../source/quickstart.rst:593 @@ -612,27 +601,27 @@ msgstr "矩阵乘积状态和矩阵乘积算子" #: ../../source/quickstart.rst:595 msgid "" -"TensorCircuit has its class for MPS and MPO originally defined in TensorNetwork " -"as ``tc.QuVector``, ``tc.QuOperator``." +"TensorCircuit has its class for MPS and MPO originally defined in " +"TensorNetwork as ``tc.QuVector``, ``tc.QuOperator``." msgstr "" -"TensorCircuit 有自己的 MPS 和 MPO 类，起初在 TensorNetwork 中定义为“tc.QuVector” " -"和 “tc.QuOperator”。" +"TensorCircuit 有自己的 MPS 和 MPO 类，起初在 TensorNetwork 中定义为“tc.QuVector” 和 " +"“tc.QuOperator”。" #: ../../source/quickstart.rst:597 msgid "" -"``tc.QuVector`` can be extracted from ``tc.Circuit`` as the tensor network form " -"for the output state (uncontracted) by ``c.quvector()``." +"``tc.QuVector`` can be extracted from ``tc.Circuit`` as the tensor " +"network form for the output state (uncontracted) by ``c.quvector()``." msgstr "" -"作为``c.quvector()`` 的输出状态（未收缩）的张量网络形式，``tc.QuVector`` 可以从" -"``tc.Circuit`` 中提取。" +"作为``c.quvector()`` 的输出状态（未收缩）的张量网络形式，``tc.QuVector`` 可以从``tc.Circuit`` " +"中提取。" #: ../../source/quickstart.rst:599 msgid "" -"The QuVector forms a wavefunction w, which can also be fed into Circuit as the " -"inputs state as ``c=tc.Circuit(n, mps_inputs=w)``." +"The QuVector forms a wavefunction w, which can also be fed into Circuit " +"as the inputs state as ``c=tc.Circuit(n, mps_inputs=w)``." msgstr "" -"QuVector 形成一个波函数 w，它也可以作为 ``c=tc.Circuit(n, mps_inputs=w)`` 的输入" -"状态输入到 Circuit 中。" +"QuVector 形成一个波函数 w，它也可以作为 ``c=tc.Circuit(n, mps_inputs=w)`` 的输入状态输入到 " +"Circuit 中。" #: ../../source/quickstart.rst:601 msgid "MPS as input state for circuit" @@ -640,8 +629,8 @@ msgstr "MPS 作为电路的输入状态" #: ../../source/quickstart.rst:603 msgid "" -"The MPS/QuVector representation of the input state has a more efficient and " -"compact form." +"The MPS/QuVector representation of the input state has a more efficient " +"and compact form." msgstr "输入状态的 MPS/QuVector 表示具有更高效和紧凑的形式。" #: ../../source/quickstart.rst:615 @@ -660,12 +649,14 @@ msgstr "MPO 作为电路上的门" #: ../../source/quickstart.rst:636 msgid "" -"Instead of a common quantum gate in matrix/node format, we can directly apply a " -"gate in MPO/QuOperator format." +"Instead of a common quantum gate in matrix/node format, we can directly " +"apply a gate in MPO/QuOperator format." msgstr "代替矩阵/节点格式的普通量子门，我们可以直接应用 MPO/QuOperator 格式的门。" #: ../../source/quickstart.rst:647 -msgid "The representative gate defined in MPO format is the ``multicontrol`` gate." +msgid "" +"The representative gate defined in MPO format is the ``multicontrol`` " +"gate." msgstr "以 MPO 格式定义的代表门是 ``multicontrol`` 门。" #: ../../source/quickstart.rst:649 @@ -674,8 +665,8 @@ msgstr "MPO作为电路期望估测算子" #: ../../source/quickstart.rst:651 msgid "" -"We can also measure operator expectation on the circuit output state where the " -"operator is in MPO/QuOperator format." +"We can also measure operator expectation on the circuit output state " +"where the operator is in MPO/QuOperator format." msgstr "我们还可以测量运算符对 MPO/QuOperator 格式的电路输出状态的期望。" #: ../../source/quickstart.rst:663 @@ -688,46 +679,47 @@ msgstr "**与 PyTorch 模块混合的 PyTorch 接口：**" #: ../../source/quickstart.rst:667 msgid "" -"As we have mentioned in the backend section, the PyTorch backend may lack " -"advanced features. This doesn't mean we cannot hybrid the advanced circuit " -"module with PyTorch neural module. We can run the quantum function on TensorFlow " -"or Jax backend while wrapping it with a Torch interface." +"As we have mentioned in the backend section, the PyTorch backend may lack" +" advanced features. This doesn't mean we cannot hybrid the advanced " +"circuit module with PyTorch neural module. We can run the quantum " +"function on TensorFlow or Jax backend while wrapping it with a Torch " +"interface." msgstr "" -"正如我们在后端部分提到的，PyTorch 后端可能缺少高级功能。 这并不意味着我们不能将高" -"级量子电路模块与 PyTorch 神经模块混合。 我们可以在 TensorFlow 或 Jax 后端运行量子" -"函数，同时使用 Torch 接口包装它。 " +"正如我们在后端部分提到的，PyTorch 后端可能缺少高级功能。 这并不意味着我们不能将高级量子电路模块与 PyTorch 神经模块混合。 " +"我们可以在 TensorFlow 或 Jax 后端运行量子函数，同时使用 Torch 接口包装它。 " #: ../../source/quickstart.rst:694 msgid "" -"For a GPU/CPU, torch/tensorflow, quantum/classical hybrid machine learning " -"pipeline enabled by tensorcircuit, see `example script `__." +"For a GPU/CPU, torch/tensorflow, quantum/classical hybrid machine " +"learning pipeline enabled by tensorcircuit, see `example script " +"`__." msgstr "" #: ../../source/quickstart.rst:696 msgid "" -"There is also a more flexible torch interface that support static non-tensor " -"inputs as keyword arguments, which can be utilized as below:" +"There is also a more flexible torch interface that support static non-" +"tensor inputs as keyword arguments, which can be utilized as below:" msgstr "" #: ../../source/quickstart.rst:710 msgid "" -"We also provider wrapper of quantum function for torch module as :py:meth:" -"`tensorcircuit.TorchLayer` alias to :py:meth:`tensorcircuit.torchnn.QuantumNet`." +"We also provider wrapper of quantum function for torch module as " +":py:meth:`tensorcircuit.TorchLayer` alias to " +":py:meth:`tensorcircuit.torchnn.QuantumNet`." msgstr "" #: ../../source/quickstart.rst:712 msgid "" -"For ``TorchLayer``, ``use_interface=True`` is by default, which natively allow " -"the quantum function defined on other tensorcircuit backends, such as jax or tf " -"for speed consideration." +"For ``TorchLayer``, ``use_interface=True`` is by default, which natively " +"allow the quantum function defined on other tensorcircuit backends, such " +"as jax or tf for speed consideration." msgstr "" #: ../../source/quickstart.rst:714 msgid "" -"``TorchLayer`` can process multiple input arguments as multiple function inputs, " -"following torch practice." +"``TorchLayer`` can process multiple input arguments as multiple function " +"inputs, following torch practice." msgstr "" #: ../../source/quickstart.rst:742 @@ -736,28 +728,29 @@ msgstr "" #: ../../source/quickstart.rst:744 msgid "" -"Similar rules apply similar as torch interface. The interface can even be used " -"within jit environment outside. See :py:meth:`tensorcircuit.interfaces." -"tensorflow.tensorflow_interface`." +"Similar rules apply similar as torch interface. The interface can even be" +" used within jit environment outside. See " +":py:meth:`tensorcircuit.interfaces.tensorflow.tensorflow_interface`." msgstr "" #: ../../source/quickstart.rst:747 msgid "" -"We also provider ``enable_dlpack=True`` option in torch and tf interfaces, which " -"allow the tensor transformation happen without memory transfer via dlpack, " -"higher version of tf or torch package required." +"We also provider ``enable_dlpack=True`` option in torch and tf " +"interfaces, which allow the tensor transformation happen without memory " +"transfer via dlpack, higher version of tf or torch package required." msgstr "" #: ../../source/quickstart.rst:750 msgid "" -"We also provider wrapper of quantum function for keras layer as :py:meth:" -"`tensorcircuit.KerasLayer` alias to :py:meth:`tensorcircuit.keras.KerasLayer`." +"We also provider wrapper of quantum function for keras layer as " +":py:meth:`tensorcircuit.KerasLayer` alias to " +":py:meth:`tensorcircuit.keras.KerasLayer`." msgstr "" #: ../../source/quickstart.rst:752 msgid "" -"``KerasLayer`` can process multiple input arguments with the input as a dict, " -"following the common keras practice, see example below." +"``KerasLayer`` can process multiple input arguments with the input as a " +"dict, following the common keras practice, see example below." msgstr "" #: ../../source/quickstart.rst:774 @@ -766,11 +759,9 @@ msgstr "**使用 scipy接口使用scipy优化器：**" #: ../../source/quickstart.rst:776 msgid "" -"Automatically transform quantum functions as scipy-compatible values and grad " -"functions as provided for scipy interface with ``jac=True``." -msgstr "" -"为带有 jac=True 的 scipy 接口自动将量子函数转换为与 scipy 兼容的 value 和 grad 函" -"数。" +"Automatically transform quantum functions as scipy-compatible values and " +"grad functions as provided for scipy interface with ``jac=True``." +msgstr "为带有 jac=True 的 scipy 接口自动将量子函数转换为与 scipy 兼容的 value 和 grad 函数。" #: ../../source/quickstart.rst:802 msgid "Templates as Shortcuts" @@ -785,18 +776,20 @@ msgid "Ising type Hamiltonian defined on a general graph" msgstr "在一般图上定义的伊辛型哈密顿量" #: ../../source/quickstart.rst:808 -msgid "See :py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" -msgstr "" -"参考 :py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" +msgid "" +"See " +":py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" +msgstr "参考 :py:meth:`tensorcircuit.templates.measurements.spin_glass_measurements`" #: ../../source/quickstart.rst:810 msgid "Heisenberg Hamiltonian on a general graph with possible external fields" msgstr "具有可能存在的外场的一般图上的海森堡哈密顿量" #: ../../source/quickstart.rst:812 -msgid "See :py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" -msgstr "" -"参考 :py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" +msgid "" +"See " +":py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" +msgstr "参考 :py:meth:`tensorcircuit.templates.measurements.heisenberg_measurements`" #: ../../source/quickstart.rst:814 msgid "**Circuit Blocks:**" @@ -812,45 +805,71 @@ msgstr "**电路块**" #~ msgstr "从GitHub安装" #~ msgid "" -#~ "For beta version usage, one needs to install tensorcircuit package from " -#~ "GitHub. For development and PR workflow, please refer to `contribution " +#~ "For beta version usage, one needs " +#~ "to install tensorcircuit package from " +#~ "GitHub. For development and PR workflow," +#~ " please refer to `contribution " #~ "`__ instead." #~ msgstr "" -#~ "如需使用测试版本，则需要从 GitHub 安装 tensorcircuit。对于开发和 PR 工作流程，" -#~ "请另外参考 `贡献 `__ 。" +#~ "如需使用测试版本，则需要从 GitHub 安装 tensorcircuit。对于开发和 PR" +#~ " 工作流程，请另外参考 `贡献 `__ 。" #~ msgid "" -#~ "For private tensorcircuit-dev repo, one needs to first configure the SSH key " -#~ "on GitHub and locally, please refer to `GitHub doc `__" +#~ "For private tensorcircuit-dev repo, one" +#~ " needs to first configure the SSH " +#~ "key on GitHub and locally, please " +#~ "refer to `GitHub doc " +#~ "`__" #~ msgstr "" -#~ "对于私有 tensorcircuit 开发库，首先需要在 GitHub 和本地配置 SSH 密钥, 请参考 " -#~ "`GitHub 文档 `__" +#~ "对于私有 tensorcircuit 开发库，首先需要在 GitHub 和本地配置 " +#~ "SSH 密钥, 请参考 `GitHub 文档 " +#~ "`__" #~ msgid "" -#~ "Then try ``pip3 install --force-reinstall git+ssh://git@github.com/quclub/" -#~ "tensorcircuit-dev.git`` in shell." +#~ "Then try ``pip3 install --force-" +#~ "reinstall git+ssh://git@github.com/quclub/tensorcircuit-" +#~ "dev.git`` in shell." #~ msgstr "" -#~ "然后尝试在命令行窗口中输入 ``pip3 install --force-reinstall git+ssh://" -#~ "git@github.com/quclub/tensorcircuit-dev.git`` 。" +#~ "然后尝试在命令行窗口中输入 ``pip3 install --force-reinstall" +#~ " git+ssh://git@github.com/quclub/tensorcircuit-dev.git`` " +#~ "。" #~ msgid "" -#~ "Depending on one's need, one may further pip install tensorflow (for " -#~ "TensorFlow backend) or jax and jaxlib (for jax backend) or `cotengra `__ (for more advanced tensornetwork contraction " -#~ "path solver)." +#~ "Depending on one's need, one may " +#~ "further pip install tensorflow (for " +#~ "TensorFlow backend) or jax and jaxlib" +#~ " (for jax backend) or `cotengra " +#~ "`__ (for more " +#~ "advanced tensornetwork contraction path " +#~ "solver)." #~ msgstr "" -#~ "基于个人情况，用户可能需要进一步安装 tensorflow, jax 或 jaxlib 或 `cotengra " -#~ "`_ 以满足后端要求。" +#~ "基于个人情况，用户可能需要进一步安装 tensorflow, jax 或 jaxlib" +#~ " 或 `cotengra `_" +#~ " 以满足后端要求。" #~ msgid "" -#~ "If one needs circuit visualization on JupyterLab, python package `wand " -#~ "`__ and its binary bindings, as well as " -#~ "LaTeX installation, are required." +#~ "If one needs circuit visualization on" +#~ " JupyterLab, python package `wand " +#~ "`__ and its " +#~ "binary bindings, as well as LaTeX " +#~ "installation, are required." #~ msgstr "" -#~ "如果需要在 JupyterLab 中进行电路可视化，则需要 python 库 `wand `__ 及其二进制绑定以及 LaTeX 的安装。" +#~ "如果需要在 JupyterLab 中进行电路可视化，则需要 python 库 " +#~ "`wand `__ " +#~ "及其二进制绑定以及 LaTeX 的安装。" #~ msgid "Import from Qiskit: ``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``" #~ msgstr "从 Qiskit 导入：``c = tc.Circuit.from_qiskit(QuantumCircuit, n)``" + +#~ msgid "For x86 Linux or Mac," +#~ msgstr "" + +#~ msgid "" +#~ "For Mac with M series chips (arm" +#~ " architecture), please refer to `TC " +#~ "on Mac M series " +#~ "`_." +#~ msgstr "" + From 9b6a3360e83948a45b11793e222063605fe5c64b Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Fri, 14 Jul 2023 17:05:17 +0800 Subject: [PATCH 550/725] update qaoa_bo.ipynb --- docs/source/tutorials/qaoa_bo.ipynb | 909 ++++++++++++++++++++++------ 1 file changed, 710 insertions(+), 199 deletions(-) diff --git a/docs/source/tutorials/qaoa_bo.ipynb b/docs/source/tutorials/qaoa_bo.ipynb index cd6e97e4..e82bc841 100644 --- a/docs/source/tutorials/qaoa_bo.ipynb +++ b/docs/source/tutorials/qaoa_bo.ipynb @@ -3,290 +3,801 @@ { "cell_type": "markdown", "source": [ - "# Optimizing QAOA using BO" + "# Optimizing QAOA by Bayesian Optimization (BO)" ], "metadata": {} }, { "cell_type": "markdown", "source": [ - "## Setup" + "## Overview" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "In this tutorial, we show how to use Bayesian optimization to optimize QAOA. For the introduction of QAOA, please refer to the [previous tutorial](qaoa.ipynb). Bayesian optimization in this tutorial is based on $\\text{ODBO}$, please refer to [Cheng, Yang, Hsieh, Liao and Zhang](https://doi.org/10.48550/arXiv.2205.09548) for details and this [repository](https://github.com/tencent-quantum-lab/ODBO) for source code and [installation](https://github.com/tencent-quantum-lab/ODBO#installation). In this tutorial, the updated modules of BO, TuRBO and DARBO are packaged." ], "metadata": {} }, + { + "cell_type": "markdown", + "source": [ + "## Setup" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "source": [ "import tensorcircuit as tc\n", - "import tensorflow as tf\n", - "import cotengra as ctg\n", + "from jax import numpy as jnp\n", "import optax\n", + "import torch\n", "import networkx as nx\n", - "import time\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "import torch\n", - "import os\n", + "import cotengra as ctg\n", + "from typing import Union\n", + "import time\n", + "import odbo\n", + "from IPython.display import clear_output\n", + "\n", + "K = tc.set_backend(\"jax\")\n", + "tc.set_dtype(\"complex128\")\n", + "dtype = torch.float64\n", "\n", - "K = tc.set_backend(\"tensorflow\")" + "# cotengra package to speed up the calculation\n", + "opt_ctg = ctg.ReusableHyperOptimizer(\n", + " methods = [\"greedy\", \"kahypar\"],\n", + " parallel = True,\n", + " minimize = \"combo\",\n", + " max_time = 20,\n", + " max_repeats = 128,\n", + " progbar = True\n", + ")\n", + "\n", + "tc.set_contractor(\"custom\", optimizer=opt_ctg, preprocessing=True)\n", + "\n", + "nlayers = 10\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "acqfn = \"ucb\"" ], - "outputs": [], - "metadata": {} + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-07-14 16:25:57.015620: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.284160700Z", + "start_time": "2023-07-14T08:25:56.959511700Z" + } + } }, { "cell_type": "markdown", "source": [ - "## QAOA blackbox" + "## MAX-CUT Hamiltonian" ], "metadata": {} }, + { + "cell_type": "markdown", + "source": [ + "### Define the Graph" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": 2, "source": [ - "# Generate a graph\n", - "def dict2graph(d):\n", - " g = nx.to_networkx_graph(d)\n", - " for e in g.edges:\n", - " if not g[e[0]][e[1]].get(\"weight\"):\n", - " g[e[0]][e[1]][\"weight\"] = 1.0\n", - " nx.draw(g, with_labels=True)\n", - " return g\n", - "\n", - "\n", "# a graph instance\n", - "example_graph_dict = {\n", - " 0: {1: {\"weight\": 0.9}, 7: {\"weight\": 0.4}, 3: {\"weight\": 0.38}},\n", - " 1: {0: {\"weight\": 0.44}, 2: {\"weight\": 0.67}, 3: {\"weight\": 0.62}},\n", - " 2: {1: {\"weight\": 0.21}, 3: {\"weight\": 0.87}, 5: {\"weight\": 0.72}},\n", - " 4: {7: {\"weight\": 0.34}, 6: {\"weight\": 0.53}, 5: {\"weight\": 0.45}},\n", - " 7: {4: {\"weight\": 0.45}, 6: {\"weight\": 0.63}, 0: {\"weight\": 0.59}},\n", - " 3: {1: {\"weight\": 0.12}, 2: {\"weight\": 0.21}, 0: {\"weight\": 0.68}},\n", - " 6: {7: {\"weight\": 0.34}, 4: {\"weight\": 0.33}, 5: {\"weight\": 0.96}},\n", - " 5: {6: {\"weight\": 0.18}, 4: {\"weight\": 0.79}, 2: {\"weight\": 0.17}},\n", + "graph_dict = {\n", + " 0: {1: {\"weight\": 1.0}, 7: {\"weight\": 1.0}, 3: {\"weight\": 1.0}},\n", + " 1: {0: {\"weight\": 1.0}, 2: {\"weight\": 1.0}, 3: {\"weight\": 1.0}},\n", + " 2: {1: {\"weight\": 1.0}, 3: {\"weight\": 1.0}, 5: {\"weight\": 1.0}},\n", + " 3: {1: {\"weight\": 1.0}, 2: {\"weight\": 1.0}, 0: {\"weight\": 1.0}},\n", + " 4: {7: {\"weight\": 1.0}, 6: {\"weight\": 1.0}, 5: {\"weight\": 1.0}},\n", + " 5: {6: {\"weight\": 1.0}, 4: {\"weight\": 1.0}, 2: {\"weight\": 1.0}},\n", + " 6: {7: {\"weight\": 1.0}, 4: {\"weight\": 1.0}, 5: {\"weight\": 1.0}},\n", + " 7: {4: {\"weight\": 1.0}, 6: {\"weight\": 1.0}, 0: {\"weight\": 1.0}},\n", "}\n", "\n", - "example_graph = dict2graph(example_graph_dict)" + "graph = nx.to_networkx_graph(graph_dict)\n", + "pos = nx.spring_layout(graph)\n", + "nx.draw_networkx(graph, with_labels=True, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor('w')" ], "outputs": [ { - "output_type": "display_data", "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } ], - "metadata": {} + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.442502100Z", + "start_time": "2023-07-14T08:26:01.299147Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Brutal Force Result" + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "code", "execution_count": 3, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bit string: ['01010101', '10101010'] \n", + "max cut: 10.0\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def classical_solver(graph):\n", + " num_nodes = len(graph)\n", + " max_cut = [0]\n", + " best_case = [0] # \"01\" series with max cut\n", + " for i in range(2 ** num_nodes):\n", + " case = f\"{bin(i)[2:]:0>{num_nodes}}\"\n", + " cat1, cat2 = [], []\n", + " for j in range(num_nodes):\n", + " if str(case)[j] == \"0\":\n", + " cat1.append(j)\n", + " else:\n", + " cat2.append(j)\n", + "\n", + " # calculate the cost function\n", + " cost = 0\n", + " for node1 in cat1:\n", + " for node2 in cat2:\n", + " if graph[node1].get(node2):\n", + " cost += graph[node1][node2][\"weight\"]\n", + " cost = round(cost, 4) # elimate minor error\n", + " if max_cut[-1] <= cost:\n", + " max_cut.append(cost)\n", + " best_case.append(case)\n", + "\n", + " # optimal cases maybe more than 1, but they are all at the end\n", + " index = max_cut.index(max_cut[-1])\n", + "\n", + " return max_cut[-1], best_case[index:]\n", + "\n", + "max_cut, best_case = classical_solver(graph_dict)\n", + "print(\"bit string:\", best_case, \"\\nmax cut:\", max_cut)\n", + "\n", + "colors = [\"r\" if best_case[0][i] == \"0\" else \"c\" for i in graph.nodes]\n", + "weighted_graph = nx.to_networkx_graph(graph_dict)\n", + "nx.draw_networkx(weighted_graph, with_labels=True, node_color=colors, pos=pos)\n", + "ax = plt.gca()\n", + "ax.set_facecolor(\"w\")" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.576063200Z", + "start_time": "2023-07-14T08:26:01.462858Z" + } + } + }, + { + "cell_type": "markdown", "source": [ - "def QAOAansatz(params, g=example_graph):\n", - " n = len(g.nodes) # the number of nodes\n", - " c = tc.Circuit(n)\n", + "## QAOA Ansatz" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [], + "source": [ + "def QAOAansatz(params, each=1, return_circuit=False):\n", + " n = graph.number_of_nodes() # the number of nodes\n", + "\n", + " # PQC loop\n", + " def pqc_loop(s_, params_):\n", + " c_ = tc.Circuit(n, inputs=s_)\n", + " for j in range(each):\n", + " # driving layer\n", + " for a, b in graph.edges:\n", + " c_.RZZ(a, b, theta=graph[a][b]['weight'] * params_[2 * j])\n", + " # mixing layer\n", + " for i in range(n):\n", + " c_.RX(i, theta=params_[2 * j + 1])\n", + " s_ = c_.state()\n", + " return s_\n", + "\n", + " c0 = tc.Circuit(n)\n", " for i in range(n):\n", - " c.H(i)\n", - " # PQC\n", - " for j in range(nlayers):\n", - " # U_j\n", - " for e in g.edges:\n", - " c.exp1(\n", - " e[0],\n", - " e[1],\n", - " unitary=tc.gates._zz_matrix,\n", - " theta=g[e[0]][e[1]].get(\"weight\", 1.0) * params[2 * j],\n", - " )\n", - " # V_j\n", - " for i in range(n):\n", - " c.rx(i, theta=params[2 * j + 1])\n", + " c0.H(i)\n", + " s0 = c0.state()\n", + " s = K.scan(pqc_loop, K.reshape(params, [nlayers // each, 2 * each]), s0)\n", + " c = tc.Circuit(n, inputs=s)\n", + "\n", + " # whether to return the circuit\n", + " if return_circuit is True:\n", + " return c\n", "\n", " # calculate the loss function\n", - " loss = 0.0\n", - " for e in g.edges:\n", - " loss += g[e[0]][e[1]].get(\"weight\") * c.expectation_ps(z=[e[0], e[1]])\n", + " loss = 0.\n", + " for a, b in graph.edges:\n", + " loss += c.expectation_ps(z=[a, b]) * graph[a][b]['weight']\n", "\n", " return K.real(loss)" ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.580388700Z", + "start_time": "2023-07-14T08:26:01.580361500Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 5, "outputs": [], - "metadata": {} + "source": [ + "QAOA_vag = K.jit(tc.backend.value_and_grad(QAOAansatz, argnums=0), static_argnums=(1, 2))\n", + "QAOA_nograd = K.jit(QAOAansatz, static_argnums=(1, 2))\n", + "\n", + "def eval_objective(x):\n", + " \"\"\"This is a helper function we use to unnormalize and evalaute a point\"\"\"\n", + " return -torch.from_numpy(np.asarray(QAOA_nograd(jnp.asarray(x.ravel()))))" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.651675700Z", + "start_time": "2023-07-14T08:26:01.580388700Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Adam Optimizer" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [], + "source": [ + "opt = K.optimizer(optax.adam(1e-2))" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.667741600Z", + "start_time": "2023-07-14T08:26:01.620275700Z" + } + } }, { "cell_type": "markdown", "source": [ - "## Using BO optimizer from ODBO\n" + "## BO Optimizer" ], "metadata": {} }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "source": [ - "import odbo\n", + "class BO_optimizer:\n", + " def __init__(self, eval_func, batch_size: int = 1, device='cpu'):\n", + " self.eval_func = eval_func\n", + " self.device = device\n", + " self.batch_size = batch_size\n", "\n", - "# BO settings\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "dtype = torch.float\n", + " def computeY(self, X):\n", + " return torch.tensor([self.eval_func(x) for x in X], dtype=X.dtype, device=self.device).unsqueeze(-1)\n", + "\n", + " def update(self, X, Y=None, acqfn: str = \"ucb\", normalize: bool = False, verbose: bool = False):\n", + " if Y is None:\n", + " Y = self.computeY(X)\n", + " X_next = odbo.run_exp.bo_design(X=X, Y=Y, batch_size=self.batch_size, acqfn=acqfn, normalize=normalize, verbose=verbose)[0].reshape(self.batch_size, X.shape[-1])\n", + " Y_next = self.computeY(X_next)\n", + " # Update training set\n", + " X = torch.cat((X, X_next), dim=0)\n", + " Y = torch.cat((Y, Y_next), dim=0)\n", + " best_idx = torch.argmax(Y, dim=0)\n", + "\n", + " return X, Y, Y_next.mean().item(), X[best_idx], Y[best_idx].item()" + ], + "outputs": [], + "metadata": { + "scrolled": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.667741600Z", + "start_time": "2023-07-14T08:26:01.620275700Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [], + "source": [ "batch_size = 1\n", - "acqfn = \"ucb\"\n", "\n", - "QAOA_nograd = K.jit(QAOAansatz)\n", + "bo_opt = BO_optimizer(eval_objective, batch_size, device)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.667741600Z", + "start_time": "2023-07-14T08:26:01.620916400Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## TuRBO Optimizer" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [], + "source": [ + "class TuRBO_optimizer(BO_optimizer):\n", + " def __init__(self, eval_func, num_params, tr_length, failure_tolerance, device=\"cpu\"):\n", + " super(TuRBO_optimizer, self).__init__(eval_func, device=device)\n", + " self.batch_size = 1 # There is bug in odbo.run_exp.turbo_design, batch_size can only be 1\n", + " self.tr_length = tr_length\n", + " self.state = odbo.turbo.TurboState(dim=num_params, batch_size=batch_size, length=tr_length, n_trust_regions=len(tr_length), failure_tolerance=failure_tolerance)\n", + "\n", + " def inverse_transform(self, X):\n", + " '''\n", + " Note TuRBO is working on only [0,1] parameter range\n", + " We need to transform parameters from [0,1] to [-pi,pi] before using eval_func\n", + " '''\n", + " return X * 2 * np.pi - np.pi\n", "\n", + " def transform(self, X):\n", + " '''\n", + " Note TuRBO is working on only [0,1] parameter range\n", + " We need to transform parameters from [-pi,pi] to [0,1] before using odbo.run_exp.turbo_design\n", + " '''\n", + " return X / 2 / np.pi + 0.5\n", "\n", - "def eval_objective(x, example_graph):\n", - " \"\"\"This is a helper function we use to unnormalize and evalaute a point\"\"\"\n", - " a = tf.convert_to_tensor(np.array(x).ravel())\n", - " return -QAOA_nograd(a, example_graph).numpy()\n", + " def computeY(self, X, transformed_input: bool = True):\n", + " if transformed_input:\n", + " X = self.inverse_transform(X)\n", + " return torch.tensor([self.eval_func(x) for x in X], dtype=X.dtype, device=self.device).unsqueeze(-1)\n", + "\n", + " def get_next(self, X, Y, acqfn, normalize, verbose):\n", + " X_next = odbo.run_exp.turbo_design(state=self.state, X=X, Y=Y, n_trust_regions=len(self.tr_length), batch_size=self.batch_size, acqfn=acqfn, normalize=normalize, verbose=verbose)[0].reshape(len(self.tr_length) * self.batch_size, X.shape[-1])\n", + " Y_next = self.computeY(X_next)\n", + " return X_next, Y_next\n", + "\n", + " def update_state(self, Y_next):\n", + " self.state = odbo.turbo.update_state(state=self.state, Y_next=Y_next.reshape(len(self.tr_length), self.batch_size, 1))\n", + "\n", + " def preprocess(self, X, Y, transformed_input):\n", + " if not transformed_input:\n", + " X = self.transform(X)\n", + " if Y is None:\n", + " Y = self.computeY(X)\n", + " self.state.best_value = max(self.state.best_value, Y.max())\n", + " return X, Y\n", + "\n", + " def postprocess(self, X, Y, X_next, Y_next, transformed_output):\n", + " X = torch.cat((X, X_next), dim=0)\n", + " Y = torch.cat((Y, Y_next), dim=0)\n", + " if not transformed_output:\n", + " X = self.inverse_transform(X)\n", + " best_idx = torch.argmax(Y, dim=0)\n", + " return X, Y, X[best_idx]\n", "\n", + " def update(self, X, Y=None, acqfn: str = \"ucb\", normalize: bool = False, verbose: bool = False, transformed_input: bool = False, transformed_output: bool = False):\n", + " X, Y = self.preprocess(X, Y, transformed_input)\n", "\n", - "X_new = np.random.uniform(low=0, high=1, size=[1, 2 * nlayers])\n", - "X_bo = torch.tensor(np.vstack([initial_X, X_new]))\n", - "Y_bo = torch.tensor(\n", - " [eval_objective(x, example_graph) for x in X_bo], dtype=dtype, device=device\n", - ").unsqueeze(-1)" + " X_next, Y_next = self.get_next(X, Y, acqfn, normalize, verbose)\n", + "\n", + " self.update_state(Y_next)\n", + "\n", + " X, Y, best_X = self.postprocess(X, Y, X_next, Y_next, transformed_output)\n", + "\n", + " return X, Y, Y_next.mean().item(), best_X, self.state.best_value" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.667741600Z", + "start_time": "2023-07-14T08:26:01.666716700Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [], + "source": [ + "failure_tolerance = 10\n", + "tr_length= [1.6]\n", + "\n", + "turbo_opt = TuRBO_optimizer(eval_objective, 2 * nlayers, tr_length, failure_tolerance, device)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.668291500Z", + "start_time": "2023-07-14T08:26:01.666716700Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## DARBO Optimizer" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Please refer to [Cheng, Chen, Zhang and Zhang](https://doi.org/10.48550/arXiv.2303.14877) for details." ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 11, "outputs": [], + "source": [ + "class DARBO_optimizer(TuRBO_optimizer):\n", + " def __init__(self, eval_func, num_params, tr_length, failure_tolerance, mode: Union[bool, str] = True, device=\"cpu\"):\n", + " super(DARBO_optimizer, self).__init__(eval_func, num_params, tr_length, failure_tolerance, device)\n", + " self.switch_counter = 0\n", + " if mode ==True or mode == 'large':\n", + " self.mode = True\n", + " else:\n", + " self.mode = False\n", + "\n", + " def get_mode(self):\n", + " return 'large' if self.mode else 'small'\n", + "\n", + " def inverse_transform(self, X):\n", + " '''\n", + " Note TuRBO is working on only [0,1] parameter range\n", + " We need to transform parameters from [0, 1] to [-pi, pi] or [-pi / 2, pi / 2] before using eval_func\n", + " '''\n", + " if self.mode: # [0, 1] to [-pi, pi]\n", + " return X * 2 * np.pi - np.pi\n", + " else: # [0, 1] to [-pi / 2, pi / 2]\n", + " return X * np.pi - np.pi / 2\n", + "\n", + " def transform(self, X):\n", + " '''\n", + " Note TuRBO is working on only [0,1] parameter range\n", + " We need to transform parameters from [-pi,pi] or [-pi / 2, pi / 2] to [0,1] before using odbo.run_exp.turbo_design\n", + " '''\n", + " if self.mode: # [-pi, pi] to [0, 1]\n", + " return X / 2 / np.pi + 0.5\n", + " else: # [-pi / 2, pi / 2] to [0, 1]\n", + " return X / np.pi + 0.5\n", + "\n", + " def computeY(self, X, transformed_input: bool = True):\n", + " if transformed_input:\n", + " X = self.inverse_transform(X)\n", + " return torch.tensor([self.eval_func(x) for x in X], dtype=X.dtype, device=self.device).unsqueeze(-1)\n", + "\n", + " def update(self, X, Y=None, acqfn: str = \"ucb\", normalize: bool = False, verbose: bool = False, transformed_input: bool = False, transformed_output: bool = False):\n", + " X, Y = self.preprocess(X, Y, transformed_input)\n", + "\n", + " # check if we need to switch the searching parameter range.\n", + " if self.switch_counter >= 4:\n", + " if self.mode:\n", + " X *= 2\n", + " self.mode = False # small\n", + " else:\n", + " X /= 2\n", + " self.mode = True # large\n", + " self.switch_counter = 0\n", + "\n", + " X_next, Y_next = self.get_next(X, Y, acqfn, normalize, verbose)\n", + "\n", + " if Y_next.max() < Y.max():\n", + " self.switch_counter += 1\n", + "\n", + " self.update_state(Y_next)\n", + "\n", + " X, Y, best_X = self.postprocess(X, Y, X_next, Y_next, transformed_output)\n", + "\n", + " return X, Y , Y_next.mean().item(), best_X, self.state.best_value" + ], "metadata": { - "scrolled": false + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.713967Z", + "start_time": "2023-07-14T08:26:01.666716700Z" + } } }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "initial mode: small\n" + ] + } + ], + "source": [ + "mode = 'small'\n", + "\n", + "darbo_opt = DARBO_optimizer(eval_objective, 2 * nlayers, tr_length, failure_tolerance, mode, device)\n", + "print(f'initial mode: {darbo_opt.get_mode()}')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T08:26:01.713967Z", + "start_time": "2023-07-14T08:26:01.704050400Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Optimization" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 13, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 299 min loss: -7.575720919791415\t-5.524467468261719\t-7.743190336435761\t-6.011992874299757\n", + "Epoch 299 time: 15.6287100315094\tTotal time: 2132.036656141281\n" + ] + } + ], + "source": [ + "# initial parameters\n", + "params = K.implicit_randu(shape=(2 * nlayers,))\n", + "initial_X = torch.from_numpy(np.asarray(params)).type(dtype)\n", + "\n", + "# First point by BO is actually just a random selection, to have a better search, we pick the most distant point\n", + "X_new = []\n", + "for i in initial_X:\n", + " if i <= 0.5:\n", + " X_new.append(i + 0.5)\n", + " else:\n", + " X_new.append(i - 0.5)\n", + "X_new = torch.tensor(X_new)\n", + "\n", + "X_bo = torch.stack((initial_X, X_new), dim=0)\n", + "Y_bo = None\n", + "X_turbo = X_bo.clone()\n", + "Y_turbo = None\n", + "X_darbo = X_bo.clone()\n", + "Y_darbo = None\n", + "\n", + "losses, losses_bo, losses_turbo, losses_darbo = [], [], [], []\n", + "t0 = ts = time.time()\n", + "\n", + "for i in range(300):\n", + " loss, grads = QAOA_vag(params)\n", + " params = opt.update(grads, params) # gradient descent\n", + " losses.append(loss)\n", + "\n", + " X_bo, Y_bo, loss, X_bo_best, bo_max = bo_opt.update(X_bo, Y_bo, acqfn)\n", + " losses_bo.append(-loss)\n", + "\n", + " X_turbo, Y_turbo, loss, X_turbo_best, turbo_max = turbo_opt.update(X_turbo, Y_turbo, acqfn, transformed_input=False if i == 0 else True, transformed_output=True)\n", + " losses_turbo.append(-loss)\n", + "\n", + " X_darbo, Y_darbo, loss, X_darbo_best, darbo_max = darbo_opt.update(X_darbo, Y_darbo, acqfn, transformed_input=False if i == 0 else True, transformed_output=True)\n", + " losses_darbo.append(-loss)\n", + "\n", + " # visualise the progress\n", + " clear_output(wait=True)\n", + " plt.figure()\n", + " plt.xlabel('Iteration')\n", + " plt.ylabel('Cost')\n", + " plt.plot(range(i + 1), losses, c='r', label='Adam')\n", + " plt.plot(range(i + 1), losses_bo, c='b', label='BO')\n", + " plt.plot(range(i + 1), losses_turbo, c='g', label='TuRBO')\n", + " plt.plot(range(i + 1), losses_darbo, c='y', label='DARBO')\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + " print(f'Epoch {i} min loss: {min(losses)}\\t{-bo_max}\\t{-turbo_max}\\t{-darbo_max}')\n", + "\n", + " te = time.time()\n", + " print(f'Epoch {i} time: {te - ts}\\tTotal time: {te - t0}')\n", + " ts = te" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", "source": [ - "# BO Optimizer\n", - "for i in range(100): # run 100 iter optimizations\n", - " X_next, acq_value, ids = odbo.run_exp.bo_design(\n", - " X=X_bo,\n", - " Y=Y_bo,\n", - " batch_size=batch_size,\n", - " acqfn=acqfn,\n", - " normalize=False,\n", - " verbose=False,\n", - " )\n", - " X_next = torch.reshape(X_next, [batch_size, 2 * nlayers])\n", - " Y_next = torch.tensor(\n", - " [eval_objective(x, example_graph) for x in X_next], dtype=dtype, device=device\n", - " )\n", - " # Update training set\n", - " X_bo = torch.cat((X_bo, X_next), dim=0)\n", - " Y_bo = torch.cat((Y_bo, Y_next.unsqueeze(-1)), dim=0)\n", - " print(f\"{i+1}) New loss: {-Y_next.item(): .4e} Best loss: {-Y_bo.max():.4e}\")" + "## Results" ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "After inputting the optimized parameters back to the ansatz circuit, we can perform the projective measurement on the output quantum state to get the solution. Here we directly use the bit string with the maximum probability as the solution since we know all information of the probability distribution of the output quantum state, but which is not feasible in the experiment." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 14, "outputs": [ { + "name": "stdout", "output_type": "stream", + "text": [ + "Adam\n", + "loss: -7.577690877449574\tprob: 0.432590481525006\tbit strings: ['01010101', '10101010']\n", + "\n", + "BO\n", + "loss: -5.52446757529149\tprob: 0.17464402602528795\tbit strings: ['10101010']\n", + "\n", + "TuRBO\n", + "loss: -7.743190336435761\tprob: 0.4689543236081881\tbit strings: ['10101010']\n", + "\n", + "DARBO\n", + "loss: -6.011992874299757\tprob: 0.23617910579498852\tbit strings: ['01010101']\n" + ] + } + ], + "source": [ + "params_bo = jnp.asarray(X_bo_best.ravel())\n", + "params_turbo = jnp.asarray(turbo_opt.inverse_transform(X_turbo_best).ravel())\n", + "params_darbo = jnp.asarray(darbo_opt.inverse_transform(X_darbo_best).ravel())\n", + "\n", + "# find the states with max probabilities\n", + "def find_max(params):\n", + " loss = QAOA_nograd(params)\n", + " c = QAOAansatz(params, return_circuit=True)\n", + " probs = K.numpy(c.probability())\n", + " max_prob = max(probs)\n", + " index = np.where(probs == max_prob)[0]\n", + " states = []\n", + " for i in index:\n", + " states.append(f'{bin(i)[2:]:0>{graph.number_of_nodes()}}')\n", + " return loss, max_prob, states\n", + "\n", + "loss, prob, states = find_max(params)\n", + "loss_bo, prob_bo, states_bo = find_max(params_bo)\n", + "loss_turbo, prob_turbo, states_turbo = find_max(params_turbo)\n", + "loss_darbo, prob_darbo, states_darbo = find_max(params_darbo)\n", + "print(f'Adam\\nloss: {loss}\\tprob: {prob}\\tbit strings: {states}\\n')\n", + "print(f'BO\\nloss: {loss_bo}\\tprob: {prob_bo}\\tbit strings: {states_bo}\\n')\n", + "print(f'TuRBO\\nloss: {loss_turbo}\\tprob: {prob_turbo}\\tbit strings: {states_turbo}\\n')\n", + "print(f'DARBO\\nloss: {loss_darbo}\\tprob: {prob_darbo}\\tbit strings: {states_darbo}')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T09:01:36.583670800Z", + "start_time": "2023-07-14T09:01:34.061688200Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 15, + "outputs": [ + { "name": "stdout", + "output_type": "stream", "text": [ - "1) New loss: 1.3437e+00 Best loss: 1.2106e+00\n", - "2) New loss: 8.7936e-01 Best loss: 8.7936e-01\n", - "3) New loss: 7.1789e-01 Best loss: 7.1789e-01\n", - "4) New loss: 6.1326e-01 Best loss: 6.1326e-01\n", - "5) New loss: 5.8545e-01 Best loss: 5.8545e-01\n", - "6) New loss: 2.7606e-01 Best loss: 2.7606e-01\n", - "7) New loss: 1.7849e-02 Best loss: 1.7849e-02\n", - "8) New loss: -1.1042e-01 Best loss: -1.1042e-01\n", - "9) New loss: -1.1939e-01 Best loss: -1.1939e-01\n", - "10) New loss: -2.5096e-01 Best loss: -2.5096e-01\n", - "11) New loss: -5.6989e-01 Best loss: -5.6989e-01\n", - "12) New loss: -7.5698e-01 Best loss: -7.5698e-01\n", - "13) New loss: -8.6725e-01 Best loss: -8.6725e-01\n", - "14) New loss: -9.1735e-01 Best loss: -9.1735e-01\n", - "15) New loss: -9.2709e-01 Best loss: -9.2709e-01\n", - "16) New loss: -9.3580e-01 Best loss: -9.3580e-01\n", - "17) New loss: -9.1267e-01 Best loss: -9.3580e-01\n", - "18) New loss: -9.4420e-01 Best loss: -9.4420e-01\n", - "19) New loss: -9.4391e-01 Best loss: -9.4420e-01\n", - "20) New loss: -9.5668e-01 Best loss: -9.5668e-01\n", - "21) New loss: -9.7023e-01 Best loss: -9.7023e-01\n", - "22) New loss: -9.7753e-01 Best loss: -9.7753e-01\n", - "23) New loss: -9.7975e-01 Best loss: -9.7975e-01\n", - "24) New loss: -9.8380e-01 Best loss: -9.8380e-01\n", - "25) New loss: -9.8546e-01 Best loss: -9.8546e-01\n", - "26) New loss: -9.8754e-01 Best loss: -9.8754e-01\n", - "27) New loss: -9.8786e-01 Best loss: -9.8786e-01\n", - "28) New loss: -9.8514e-01 Best loss: -9.8786e-01\n", - "29) New loss: -9.9017e-01 Best loss: -9.9017e-01\n", - "30) New loss: -9.9235e-01 Best loss: -9.9235e-01\n", - "31) New loss: -9.9391e-01 Best loss: -9.9391e-01\n", - "32) New loss: -9.9355e-01 Best loss: -9.9391e-01\n", - "33) New loss: -9.8973e-01 Best loss: -9.9391e-01\n", - "34) New loss: -9.9798e-01 Best loss: -9.9798e-01\n", - "35) New loss: -1.0005e+00 Best loss: -1.0005e+00\n", - "36) New loss: -1.0021e+00 Best loss: -1.0021e+00\n", - "37) New loss: -1.0029e+00 Best loss: -1.0029e+00\n", - "38) New loss: -1.0029e+00 Best loss: -1.0029e+00\n", - "39) New loss: -1.0022e+00 Best loss: -1.0029e+00\n", - "40) New loss: -1.0034e+00 Best loss: -1.0034e+00\n", - "41) New loss: -1.0037e+00 Best loss: -1.0037e+00\n", - "42) New loss: -1.0035e+00 Best loss: -1.0037e+00\n", - "43) New loss: -1.0037e+00 Best loss: -1.0037e+00\n", - "44) New loss: -1.0036e+00 Best loss: -1.0037e+00\n", - "45) New loss: -1.0035e+00 Best loss: -1.0037e+00\n", - "46) New loss: -1.0033e+00 Best loss: -1.0037e+00\n", - "47) New loss: -1.0033e+00 Best loss: -1.0037e+00\n", - "48) New loss: -1.0036e+00 Best loss: -1.0037e+00\n", - "49) New loss: -1.0041e+00 Best loss: -1.0041e+00\n", - "50) New loss: -1.0035e+00 Best loss: -1.0041e+00\n", - "51) New loss: -1.0044e+00 Best loss: -1.0044e+00\n", - "52) New loss: -1.0044e+00 Best loss: -1.0044e+00\n", - "53) New loss: -1.0044e+00 Best loss: -1.0044e+00\n", - "54) New loss: -1.0045e+00 Best loss: -1.0045e+00\n", - "55) New loss: -1.0043e+00 Best loss: -1.0045e+00\n", - "56) New loss: -1.0046e+00 Best loss: -1.0046e+00\n", - "57) New loss: -1.0043e+00 Best loss: -1.0046e+00\n", - "58) New loss: -1.0045e+00 Best loss: -1.0046e+00\n", - "59) New loss: -1.0042e+00 Best loss: -1.0046e+00\n", - "60) New loss: -1.0045e+00 Best loss: -1.0046e+00\n", - "61) New loss: -1.0042e+00 Best loss: -1.0046e+00\n", - "62) New loss: -1.0047e+00 Best loss: -1.0047e+00\n", - "63) New loss: -1.0047e+00 Best loss: -1.0047e+00\n", - "64) New loss: -1.0048e+00 Best loss: -1.0048e+00\n", - "65) New loss: -1.0045e+00 Best loss: -1.0048e+00\n", - "66) New loss: -1.0047e+00 Best loss: -1.0048e+00\n", - "67) New loss: -1.0045e+00 Best loss: -1.0048e+00\n", - "68) New loss: -1.0045e+00 Best loss: -1.0048e+00\n", - "69) New loss: -1.0049e+00 Best loss: -1.0049e+00\n", - "70) New loss: -1.0049e+00 Best loss: -1.0049e+00\n", - "71) New loss: -1.0049e+00 Best loss: -1.0049e+00\n", - "72) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "73) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", - "74) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", - "75) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", - "76) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "77) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "78) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "79) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "80) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "81) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "82) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", - "83) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "84) New loss: -1.0049e+00 Best loss: -1.0050e+00\n", - "85) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "86) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "87) New loss: -1.0050e+00 Best loss: -1.0050e+00\n", - "88) New loss: -1.0051e+00 Best loss: -1.0051e+00\n", - "89) New loss: -1.0051e+00 Best loss: -1.0051e+00\n", - "90) New loss: -1.0051e+00 Best loss: -1.0051e+00\n", - "91) New loss: -1.0052e+00 Best loss: -1.0052e+00\n", - "92) New loss: -1.0050e+00 Best loss: -1.0052e+00\n", - "93) New loss: -1.0052e+00 Best loss: -1.0052e+00\n", - "94) New loss: -1.0050e+00 Best loss: -1.0052e+00\n", - "95) New loss: -1.0049e+00 Best loss: -1.0052e+00\n", - "96) New loss: -1.0051e+00 Best loss: -1.0052e+00\n", - "97) New loss: -1.0051e+00 Best loss: -1.0052e+00\n", - "98) New loss: -1.0051e+00 Best loss: -1.0052e+00\n", - "99) New loss: -1.0052e+00 Best loss: -1.0052e+00\n", - "100) New loss: -1.0051e+00 Best loss: -1.0052e+00\n" + "OS info: Linux-5.4.119-1-tlinux4-0010.2-x86_64-with-glibc2.28\n", + "Python version: 3.10.11\n", + "Numpy version: 1.23.5\n", + "Scipy version: 1.11.0\n", + "Pandas version: 2.0.2\n", + "TensorNetwork version: 0.4.6\n", + "Cotengra version: 0.2.1.dev15+g120379e\n", + "TensorFlow version: 2.12.0\n", + "TensorFlow GPU: []\n", + "TensorFlow CUDA infos: {'cpu_compiler': '/dt9/usr/bin/gcc', 'cuda_compute_capabilities': ['sm_35', 'sm_50', 'sm_60', 'sm_70', 'sm_75', 'compute_80'], 'cuda_version': '11.8', 'cudnn_version': '8', 'is_cuda_build': True, 'is_rocm_build': False, 'is_tensorrt_build': True}\n", + "Jax version: 0.4.13\n", + "Jax installation doesn't support GPU\n", + "JaxLib version: 0.4.13\n", + "PyTorch version: 2.0.1\n", + "PyTorch GPU support: False\n", + "PyTorch GPUs: []\n", + "Cupy is not installed\n", + "Qiskit version: 0.24.1\n", + "Cirq version: 1.1.0\n", + "TensorCircuit version 0.10.0\n" ] } ], + "source": [ + "tc.about()" + ], "metadata": { - "scrolled": false + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-07-14T09:01:36.583670800Z", + "start_time": "2023-07-14T09:01:36.583447800Z" + } } } ], @@ -311,4 +822,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From 13db85eb8f7738c7ff220ed09a293791f16adbc0 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Fri, 14 Jul 2023 17:33:47 +0800 Subject: [PATCH 551/725] update qaoa_bo.ipynb --- docs/source/tutorial.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index 39ede96d..a19702ce 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -6,6 +6,7 @@ Jupyter Tutorials tutorials/circuit_basics.ipynb tutorials/qaoa.ipynb + tutorials/qaoa_bo.ipynb tutorials/qaoa_nae3sat.ipynb tutorials/qaoa_quantum_dropout.ipynb tutorials/tfim_vqe.ipynb From 9bab90377bde3a4556c7906b9ac6519927106f17 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Fri, 14 Jul 2023 15:44:29 +0100 Subject: [PATCH 552/725] after first review --- docs/source/tutorials/QAOA_funcs.py | 439 ------------------ tensorcircuit/applications/__init__.py | 2 - .../applications/finance/portfolio.py | 151 ++++++ tensorcircuit/applications/optimization.py | 84 ++-- tensorcircuit/templates/ansatz.py | 88 ++++ tensorcircuit/templates/blocks.py | 94 ---- tensorcircuit/templates/conversions.py | 148 +----- 7 files changed, 292 insertions(+), 714 deletions(-) delete mode 100644 docs/source/tutorials/QAOA_funcs.py create mode 100644 tensorcircuit/applications/finance/portfolio.py diff --git a/docs/source/tutorials/QAOA_funcs.py b/docs/source/tutorials/QAOA_funcs.py deleted file mode 100644 index 87d35d59..00000000 --- a/docs/source/tutorials/QAOA_funcs.py +++ /dev/null @@ -1,439 +0,0 @@ -### -### functions for QAOA problems -### - -from typing import List, Tuple, Callable, Any -import tensorcircuit as tc -import numpy as np -import tensorflow as tf -import matplotlib.pyplot as plt -from IPython.display import clear_output -from functools import partial -import scipy.optimize as optimize - -Array = any -Tensor = Any - - -# moved -def QUBO_to_Ising(Q: List[list]) -> Tuple[List[list], list, float]: - """ - Cnvert the Q matrix into a the indication of pauli terms, the corresponding weights, and the offset. - The outputs are used to construct an Ising Hamiltonian for QAOA. - - :param Q: The n-by-n square and symmetric Q-matrix. - :return pauli_terms: A list of 0/1 series, where each element represents a Pauli term. - A value of 1 indicates the presence of a Pauli-Z operator, while a value of 0 indicates its absence. - :return weights: A list of weights corresponding to each Pauli term. - :return offset: A float representing the offset term of the Ising Hamiltonian. - """ - - # input is n-by-n symmetric numpy array corresponding to Q-matrix - # output is the components of Ising Hamiltonian - - n = Q.shape[0] - - # square matrix check - if Q[0].shape[0] != n: - raise ValueError("Matrix is not a square matrix.") - - offset = ( - np.triu(Q, 0).sum() / 2 - ) # Calculate the offset term of the Ising Hamiltonian - pauli_terms = [] # List to store the Pauli terms - weights = ( - -np.sum(Q, axis=1) / 2 - ) # Calculate the weights corresponding to each Pauli term - - for i in range(n): - term = np.zeros(n) - term[i] = 1 - pauli_terms.append( - term.tolist() - ) # Add a Pauli term corresponding to a single qubit - - for i in range(n - 1): - for j in range(i + 1, n): - term = np.zeros(n) - term[i] = 1 - term[j] = 1 - pauli_terms.append( - term.tolist() - ) # Add a Pauli term corresponding to a two-qubit interaction - - weight = ( - Q[i][j] / 2 - ) # Calculate the weight for the two-qubit interaction term - weights = np.concatenate( - (weights, weight), axis=None - ) # Add the weight to the weights list - - return pauli_terms, weights, offset - - -def Ising_loss(c: tc.Circuit, pauli_terms: List[list], weights: list) -> float: - """ - computes the loss function for the Ising model based on a given quantum circuit, - a list of Pauli terms, and corresponding weights. - The offset is ignored. - - :param c: A quantum circuit object generating the state. - :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. - :param weights: A list of weights corresponding to each Pauli term. - :return loss: A real number representing the computed loss value. - """ - loss = 0.0 - for k in range(len(pauli_terms)): - term = pauli_terms[k] - index_of_ones = [] - - for l in range(len(term)): - if term[l] == 1: - index_of_ones.append(l) - - # Compute expectation value based on the number of qubits involved in the Pauli term - if len(index_of_ones) == 1: - delta_loss = weights[k] * c.expectation_ps(z=[index_of_ones[0]]) - # Compute expectation value for a single-qubit Pauli term - else: - delta_loss = weights[k] * c.expectation_ps( - z=[index_of_ones[0], index_of_ones[1]] - ) - # Compute expectation value for a two-qubit Pauli term - - loss += delta_loss - - return K.real(loss) - - -def QAOA_loss( - nlayers: int, pauli_terms: List[list], weights: list, params: list -) -> float: - """ - computes the loss function for the Quantum Approximate Optimization Algorithm (QAOA) applied to the Ising model. - - :param nlayers: The number of layers in the QAOA ansatz. - :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. - :param weights: A list of weights corresponding to each Pauli term. - :param params: A list of parameter values used in the QAOA ansatz. - :return: The computed loss value. - """ - c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights) - # Obtain the quantum circuit using QAOA_from_Ising function - - return Ising_loss(c, pauli_terms, weights) - # Compute the Ising loss using Ising_loss function on the obtained circuit - - -def QUBO_QAOA( - Q: List[list], - ansatz: Callable[[list, int, List[list], list], tc.Circuit], - nlayers: int, - iterations: int, - vvag: bool = False, - ncircuits: int = 10, -) -> list: - """ - Performs the QAOA on a given QUBO problem. - - :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. - :param ansatz: The ansatz function to be used for the QAOA. - :param nlayers: The number of layers in the QAOA ansatz. - :param iterations: The number of iterations to run the optimization. - :param vvag (optional): A flag indicating whether to use vectorized variational adjoint gradient. Default is False. - :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. Default is 10. - :return params: The optimized parameters for the ansatz circuit. - """ - try: - K - except NameError: - print("select a backend and assign it to K.") - - pauli_terms, weights, offset = QUBO_to_Ising(Q) - learning_rate = 1e-2 - - loss_val_grad = K.value_and_grad(partial(ansatz, nlayers, pauli_terms, weights)) - params = K.implicit_randn(shape=[2 * nlayers], stddev=0.5) - # Initialize the parameters for the ansatz circuit - - if vvag == True: - loss_val_grad = tc.backend.vvag(loss_val_grad, argnums=0, vectorized_argnums=0) - params = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) - # Use vectorized variational adjoint gradient (vvag) if vvag flag is set to True - - loss_val_grad_jit = K.jit(loss_val_grad, static_argnums=(1, 2)) - - opt = K.optimizer(tf.keras.optimizers.Adam(learning_rate)) - # Define the optimizer (Adam optimizer) with the specified learning rate - - for i in range(iterations): - loss, grads = loss_val_grad_jit(params) - # Calculate the loss and gradients using the loss_val_grad_jit function - - params = opt.update(grads, params) - # Update the parameters using the optimizer and gradients - - if i % 100 == 0: # print the cost every 100 iterations - print(K.numpy(loss)) - - return params - - -# calcelled -def print_result_prob(c: tc.Circuit, wrap: bool = False, reverse: bool = False) -> None: - """ - Print the results and probabilities of a given quantum circuit. - The default order is from the highest probability to the lowest one - - :param c: The quantum circuit to print the results and probabilities. - :param wrap (optional): A flag indicating whether to wrap the output. Default is False. - :param reverse (optional): A flag indicating whether to reverse the order of the output. Default is False. - """ - try: - K - except NameError: - print("select a backend and assign it to K.") - - states = [] - n_qubits = c._nqubits - for i in range(2**n_qubits): - a = f"{bin(i)[2:]:0>{n_qubits}}" - states.append(a) - # Generate all possible binary states for the given number of qubits - - probs = K.numpy(c.probability()).round(decimals=4) - # Calculate the probabilities of each state using the circuit's probability method - - sorted_indices = np.argsort(probs)[::-1] - if reverse == True: - sorted_indices = sorted_indices[::-1] - state_sorted = np.array(states)[sorted_indices] - prob_sorted = np.array(probs)[sorted_indices] - # Sort the states and probabilities in descending order based on the probabilities - - print("\n-------------------------------------") - print(" selection\t |\tprobability") - print("-------------------------------------") - if wrap == False: - for i in range(len(states)): - print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) - # Print the sorted states and their corresponding probabilities - elif wrap == True: - for i in range(4): - print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) - print(" ... ...") - for i in range(-4, -1): - print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) - print("-------------------------------------") - - -# calcelled -def print_result_cost( - c: tc.Circuit, Q: List[list], wrap: bool = False, reverse: bool = False -) -> None: - """ - Print the results and costs of a given quantum circuit. - Specificly designed for the variational circuit. - The default order is from the highest probability to the lowest one. - - :param c: The quantum circuit to print the results and probabilities. - :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. - :param wrap (optional): A flag indicating whether to wrap the output. Default is False. - :param reverse (optional): A flag indicating whether to reverse the order of the output. Default is False. - """ - cost_dict = {} - states = [] - n_qubits = c._nqubits - for i in range(2**n_qubits): - a = f"{bin(i)[2:]:0>{n_qubits}}" - states.append(a) - # Generate all possible binary states for the given number of qubits - for selection in states: - x = np.array([int(bit) for bit in selection]) - cost_dict[selection] = np.dot(x, np.dot(Q, x)) - cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1])) - if reverse == True: - cost_sorted = dict( - sorted(cost_dict.items(), key=lambda item: item[1], reverse=True) - ) - num = 0 - print("\n-------------------------------------") - print(" selection\t |\t cost") - print("-------------------------------------") - for k, v in cost_sorted.items(): - print("%10s\t |\t%.4f" % (k, v)) - num += 1 - if (num >= 8) & (wrap == True): - break - print("-------------------------------------") - - -# cancelled -def print_Q_cost(Q: List[list], wrap: bool = False, reverse: bool = False) -> None: - n_stocks = len(Q) - states = [] - for i in range(2**n_stocks): - a = f"{bin(i)[2:]:0>{n_stocks}}" - n_ones = 0 - for j in a: - if j == "1": - n_ones += 1 - states.append(a) - - cost_dict = {} - for selection in states: - x = np.array([int(bit) for bit in selection]) - cost_dict[selection] = np.dot(x, np.dot(Q, x)) - cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1])) - if reverse == True: - cost_sorted = dict( - sorted(cost_dict.items(), key=lambda item: item[1], reverse=True) - ) - num = 0 - print("\n-------------------------------------") - print(" selection\t |\t cost") - print("-------------------------------------") - for k, v in cost_sorted.items(): - print("%10s\t |\t%.4f" % (k, v)) - num += 1 - if (num >= 8) & (wrap == True): - break - print("-------------------------------------") - - -# moved -class StockData: - """ - convert real-world stock data to the inputs of QAOA. - """ - - def __init__(self, data: Tensor) -> None: - """ - stock data object - - :param data: real-world stock data, in the form of several lists of daily price. - """ - self.data = data # add data - self.n_stocks = len(data) # num of stocks - self.n_days = len(data[1]) - - # check the number of days - n_days = [len(i) for i in data] - if max(n_days) != (sum(n_days) / len(n_days)): - raise Exception("timespan of stocks should be the same") - - # calculate the daily percentage price change - self.daily_change = [] # daily percentage price change - for i in range(self.n_stocks): - each_stcok = [] - for j in range(self.n_days - 1): - each_stcok.append((data[i][j + 1] - data[i][j]) / data[i][j]) - self.daily_change.append(each_stcok) - - def get_return(self) -> Array: - """ - :return ret: annualized return (mu) - """ - ret = np.mean(self.daily_change, axis=1) - return ret - - def get_covariance(self) -> Array: - """ - :return cov: symmetric annualized covariance matrix (sigma) - """ - return np.cov(self.daily_change) - - def get_pentalty( - self, cov: Array, ret: Array, risk_pre: float, budget: int - ) -> float: - """ - calculate the pentalty using the method in https://link.springer.com/article/10.1007/s11128-022-03766-5 - brutal force is used - - :param cov: symmetrix annualized covariance matrix (sigma) - :param ret: annualized return (ret) - :param risk_pre: risk preference of the investor - :param budge: the number of assets to be chosen for the portfolio - """ - # get all fesible and unfeasible states - self.f_state = [] # feasible states (num of '1's equal to budge) - self.uf_state = [] # unfeasible states - self.all_state = [] - for i in range(2**self.n_stocks): - state = f"{bin(i)[2:]:0>{self.n_stocks}}" - n_ones = 0 - for j in state: - if j == "1": - n_ones += 1 - self.all_state.append(state) - if n_ones == budget: - self.f_state.append(state) - else: - self.uf_state.append(state) - - # determine the penalty factor - mark = False - penalty = 0 # initial value - while mark == False: - R = np.diag(ret) - S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( - np.ones(self.n_stocks) - ) - Q = risk_pre * cov - R + penalty * S - F = [] - for state in self.f_state: - x = np.array([int(bit) for bit in state]) - F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) - Fmin = np.amin(F) - Fbar = np.mean(F) - F = [] - for state in self.uf_state: - x = np.array([int(bit) for bit in state]) - F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) - Fmin_uf = np.amin(F) - location = np.where(F == Fmin_uf)[0][0] - if Fmin_uf < 0.5 * (Fmin + Fbar): - n_ones = 0 - for j in self.uf_state[location]: - if j == "1": - n_ones += 1 - penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 - # mark = True - else: - mark = True # ready to return the penalty - return penalty - - -# moved -def QUBO_from_portfolio(cov: Array, mean: Array, q: float, B: int, t: float) -> Tensor: - """ - convert portfolio parameters to a Q matrix - :param cov: n-by-n covariance numpy array - :param mean: numpy array of means - :param q: the risk preference of investor - :param B: budget - :param t: penalty factor - :return Q: n-by-n symmetric Q matrix - """ - n = cov.shape[0] - R = np.diag(mean) - S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n)) - - Q = q * cov - R + t * S - return Q - - -def print_output(c): - n = c._nqubits - N = 2**n - # Calculate the total number of states based on the number of qubits - - x_label = r"$\left|{0:0" + str(n) + r"b}\right>$" - labels = [x_label.format(i) for i in range(N)] - # Generate labels for the x-axis representing the binary states - - plt.bar(range(N), c.probability()) - # Create a bar plot with the probabilities of each state - - plt.xticks(range(N), labels, rotation=70) - # Set the x-axis ticks to the generated labels and rotate them for better visibility diff --git a/tensorcircuit/applications/__init__.py b/tensorcircuit/applications/__init__.py index 200fcbe6..70d128b0 100644 --- a/tensorcircuit/applications/__init__.py +++ b/tensorcircuit/applications/__init__.py @@ -3,5 +3,3 @@ the code inside is subject to change, be caution to use. Most of the useful code is and will be refactored and copied to other parts of tensorcircuit. """ - -from . import optimization \ No newline at end of file diff --git a/tensorcircuit/applications/finance/portfolio.py b/tensorcircuit/applications/finance/portfolio.py new file mode 100644 index 00000000..93633790 --- /dev/null +++ b/tensorcircuit/applications/finance/portfolio.py @@ -0,0 +1,151 @@ +""" +Supplementary functions for portfolio optimization +""" + +from typing import Any + +import numpy as np + +Array = Any +Tensor = Any + + +def QUBO_from_portfolio(cov: Array, mean: Array, q: float, B: int, t: float) -> Tensor: + """ + convert portfolio parameters to a Q matrix + :param cov: n-by-n covariance numpy array + :param mean: numpy array of means + :param q: the risk preference of investor + :param B: budget + :param t: penalty factor + :return Q: n-by-n symmetric Q matrix + """ + n = cov.shape[0] + R = np.diag(mean) + S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n)) + + Q = q * cov - R + t * S + return Q + + +class StockData: + """ + A class for converting real-world stock data to an annualized covariance matrix and annualized return. + + Attributes: + - data: A list of continuous stock data in the same time span. + - n_stocks: The number of stocks in the data. + - n_days: The number of trading days in the data. + + Methods: + - __init__(self, data): Initializes the StockData object. + - get_return(self, decimals=5): Calculates the annualized return. + - get_covariance(self, decimals=5): Calculates the annualized covariance matrix. + - get_penalty(self, cov, ret, risk_pre, budget, decimals=5): Calculates the penalty factor. + """ + + def __init__(self, data): + """ + Initializes the StockData object. + + :param data: A list of continuous stock data in the same time span. + """ + self.data = data + self.n_stocks = len(data) + + # Check the number of days + n_days = [len(i) for i in data] + if max(n_days) != (sum(n_days) / len(n_days)): + raise Exception("Timespan of stocks should be the same") + self.n_days = len(data[1]) + + # Calculate the daily percentage price change + self.daily_change = [] + for i in range(self.n_stocks): + each_stock = [] + for j in range(self.n_days - 1): + each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j + 1]) + self.daily_change.append(each_stock) + + def get_return(self, decimals=5): + """ + Calculates the annualized return (mu). + + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The annualized return as an array rounded to the specified number of decimals. + """ + change = [[j + 1 for j in i] for i in self.daily_change] + ret = np.prod(change, axis=1) ** (252 / self.n_days) + return ret.round(decimals) + + def get_covariance(self, decimals=5): + """ + Calculates the annualized covariance matrix (sigma). + + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The annualized covariance matrix rounded to the specified number of decimals. + """ + mean = np.mean(self.daily_change, axis=1) + relative_change = [ + [j - mean[i] for j in self.daily_change[i]] for i in range(6) + ] + cov = 252 / self.n_days * np.dot(relative_change, np.transpose(relative_change)) + return cov.round(decimals) + + def get_penalty(self, cov, ret, risk_pre, budget, decimals=5): + """ + Calculates the penalty factor. + + :param cov: The annualized covariance matrix. + :param ret: The annualized return. + :param risk_pre: The risk preference factor. + :param budget: The budget (number of stocks to select). + :param decimals: Number of decimal places to round the result to (default: 5). + :return: The penalty factor rounded to the specified number of decimals. + """ + # Get all feasible and unfeasible states + self.f_state = [] # Feasible states (number of '1's equal to budget) + self.uf_state = [] # Unfeasible states + self.all_state = [] + for i in range(2**self.n_stocks): + state = f"{bin(i)[2:]:0>{self.n_stocks}}" + n_ones = 0 + for j in state: + if j == "1": + n_ones += 1 + self.all_state.append(state) + if n_ones == budget: + self.f_state.append(state) + else: + self.uf_state.append(state) + + # Determine the penalty factor + mark = False + penalty = 0 # Initial value + while mark == False: + R = np.diag(ret) + S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( + np.ones(self.n_stocks) + ) + Q = risk_pre * cov - R + penalty * S + F = [] + for state in self.f_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) + Fmin = np.amin(F) + Fbar = np.mean(F) + F = [] + for state in self.uf_state: + x = np.array([int(bit) for bit in state]) + F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) + Fmin_uf = np.amin(F) + location = np.where(F == Fmin_uf)[0][0] + if Fmin_uf < 0.5 * (Fmin + Fbar): + n_ones = 0 + for j in self.uf_state[location]: + if j == "1": + n_ones += 1 + penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 + else: + mark = True # Ready to return the penalty + return round(penalty, decimals) diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index fd05b693..8bcb1a90 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -3,25 +3,23 @@ """ from typing import List, Callable, Any +from functools import partial -import tensorcircuit as tc import numpy as np -from functools import partial import tensorflow as tf import scipy.optimize as optimize -from ..cons import backend -from ..templates.blocks import QAOA_ansatz_for_Ising +from ..cons import backend, get_backend +from ..quantum import measurement_results +from ..interfaces import scipy_interface +from ..templates.ansatz import QAOA_ansatz_for_Ising from ..templates.conversions import QUBO_to_Ising -from tensorflow.python.ops.numpy_ops import np_config - -np_config.enable_numpy_behavior() Circuit = Any Tensor = Any -def Ising_loss(c: Circuit, pauli_terms: List[list], weights: list) -> float: +def Ising_loss(c: Circuit, pauli_terms: Tensor, weights: List[float]) -> float: """ computes the loss function for the Ising model based on a given quantum circuit, a list of Pauli terms, and corresponding weights. @@ -57,7 +55,12 @@ def Ising_loss(c: Circuit, pauli_terms: List[list], weights: list) -> float: def QAOA_loss( - nlayers: int, pauli_terms: List[list], weights: list, params: list, mixer: str = "X" + nlayers: int, + pauli_terms: Tensor, + weights: List[float], + params: List[float], + full_coupling: bool = False, + mixer: str = "X", ) -> float: """ computes the loss function for the Quantum Approximate Optimization Algorithm (QAOA) applied to the Ising model. @@ -66,9 +69,13 @@ def QAOA_loss( :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. :param weights: A list of weights corresponding to each Pauli term. :param params: A list of parameter values used in the QAOA ansatz. + :param full_coupling (optional): A flag indicating whether to use all-to-all coupling in mixers. Default is False. + :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "XY" and "ZZ". :return: The computed loss value. """ - c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights, mixer=mixer) + c = QAOA_ansatz_for_Ising( + params, nlayers, pauli_terms, weights, mixer=mixer, full_coupling=full_coupling + ) # Obtain the quantum circuit using QAOA_from_Ising function return Ising_loss(c, pauli_terms, weights) @@ -76,17 +83,17 @@ def QAOA_loss( def QUBO_QAOA( - Q: List[list], + Q: Tensor, nlayers: int, iterations: int, vvag: bool = False, ncircuits: int = 10, - init_params: list = None, + init_params: List[float] = None, mixer: str = "X", learning_rate: float = 1e-2, - jit: bool = True, callback: callable = None, -) -> list: + full_coupling=False, +) -> List[float]: """ Performs the QAOA on a given QUBO problem. Adam optimizer from TensorFlow is used. @@ -97,29 +104,35 @@ def QUBO_QAOA( :param vvag (optional): A flag indicating whether to use vectorized variational adjoint gradient. Default is False. :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. Default is 10. :param init_params (optional): The initial parameters for the ansatz circuit. Default is None, which initializes the parameters randomly. - :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "X", "XY", "XY_full", and "ZZ". + :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "XY" and "ZZ". :param learning_rate (optional): The learning rate for the Adam optimizer. Default is 1e-2. - :param jit (optional): A flag indicating whether to use just-in-time compilation. Default is True. :param callback (optional): A callback function that is executed during each iteration. Default is None. + :param full_coupling (optional): A flag indicating whether to use all-to-all coupling in mixers. Default is False. :return params: The optimized parameters for the ansatz circuit. """ - if backend != tc.set_backend("tensorflow"): + if backend != get_backend("tensorflow"): raise ValueError("`QUBO_QAOA` is designed for tensorflow backend.") # Check if the backend is set to TensorFlow. Raise an error if it is not. pauli_terms, weights, offset = QUBO_to_Ising(Q) loss_val_grad = backend.value_and_grad( - partial(QAOA_loss, nlayers, pauli_terms, weights, mixer=mixer) + partial( + QAOA_loss, + nlayers, + pauli_terms, + weights, + mixer=mixer, + full_coupling=full_coupling, + ) ) + loss_val_grad = backend.jit(loss_val_grad, static_argnums=(1, 2)) # Define the loss and gradients function using value_and_grad, which calculates both the loss value and gradients. if init_params is None: params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) if vvag == True: - loss_val_grad = tc.backend.vvag( - loss_val_grad, argnums=0, vectorized_argnums=0 - ) + loss_val_grad = backend.vvag(loss_val_grad, argnums=0, vectorized_argnums=0) params = backend.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # If init_params is not provided, initialize the parameters randomly. # If vvag flag is set to True, use vectorized variational adjoint gradient (vvag) with multiple circuits. @@ -128,9 +141,6 @@ def QUBO_QAOA( # If init_params is provided, use the provided parameters. # Initialize the parameters for the ansatz circuit. - if jit == True: - loss_val_grad = backend.jit(loss_val_grad, static_argnums=(1, 2)) - # Use just-in-time compilation (jit) if jit flag is set to True. # This can improve the performance by pre-compiling the loss and gradients function. opt = backend.optimizer(tf.keras.optimizers.Adam(learning_rate)) @@ -151,7 +161,7 @@ def QUBO_QAOA( # Return the optimized parameters for the ansatz circuit. -def cvar_value(r: list, p: list, percent: float) -> float: +def cvar_value(r: List[float], p: List[float], percent: float) -> float: """ Calculate the Conditional Value at Risk (CVaR) according to the measurement results. @@ -184,6 +194,7 @@ def cvar_value(r: list, p: list, percent: float) -> float: cvar_result /= percent return cvar_result + def cvar_from_circuit( circuit: Circuit, nsamples: int, Q: Tensor, alpha: float ) -> float: @@ -198,7 +209,7 @@ def cvar_from_circuit( :return: The calculated CVaR value. """ s = circuit.state() - results = tc.quantum.measurement_results( + results = measurement_results( s, counts=nsamples, format="count_dict_bin" ) # Get readouts from the measurements. results = {k: v / nsamples for k, v in results.items()} # Normalize the results. @@ -217,7 +228,7 @@ def cvar_from_circuit( return cvar_result -def cvar_from_expectation(circuit, Q, alpha: float) -> float: +def cvar_from_expectation(circuit: Circuit, Q: Tensor, alpha: float) -> float: """ Calculate the Conditional Value at Risk (CVaR) from the expectation values of a quantum circuit. @@ -247,7 +258,14 @@ def cvar_from_expectation(circuit, Q, alpha: float) -> float: return cvar_result -def cvar_loss(nlayers, Q, nsamples, alpha, fake, params): +def cvar_loss( + nlayers: int, + Q: Tensor, + nsamples: int, + alpha: float, + fake: bool, + params: List[float], +) -> float: """ Calculate the CVaR loss for a given QUBO problem using the QAOA ansatz. @@ -276,15 +294,15 @@ def cvar_loss(nlayers, Q, nsamples, alpha, fake, params): def QUBO_QAOA_cvar( - Q: List[list], + Q: Tensor, nlayers: int, alpha: int, nsamples: int = 1000, callback: callable = None, fake: bool = False, maxiter: int = 1000, - init_params: list = None, -) -> list: + init_params: List[float] = None, +) -> List[float]: """ Perform the QUBO QAOA optimization with CVaR as the loss function. @@ -300,9 +318,7 @@ def QUBO_QAOA_cvar( """ loss = partial(cvar_loss, nlayers, Q, nsamples, alpha, fake) - f_scipy = tc.interfaces.scipy_interface( - loss, shape=[2 * nlayers], jit=False, gradient=False - ) + f_scipy = scipy_interface(loss, shape=[2 * nlayers], jit=False, gradient=False) if init_params is None: params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) diff --git a/tensorcircuit/templates/ansatz.py b/tensorcircuit/templates/ansatz.py index 6af93245..575b820a 100644 --- a/tensorcircuit/templates/ansatz.py +++ b/tensorcircuit/templates/ansatz.py @@ -1,3 +1,91 @@ """ Shortcuts for reusable circuit ansatz """ + +from typing import Any, List + +from ..circuit import Circuit as Circ + +Tensor = Any +Circuit = Any + + +def QAOA_ansatz_for_Ising( + params: List[float], + nlayers: int, + pauli_terms: Tensor, + weights: List[float], + full_coupling: bool = False, + mixer: str = "X", +) -> Circuit: + """ + Construct the QAOA ansatz for the Ising Model. + The number of qubits is determined by `pauli_terms`. + + :param params: A list of parameter values used in the QAOA ansatz. + :param nlayers: The number of layers in the QAOA ansatz. + :pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. + :param weights: A list of weights corresponding to each Pauli term. + :param full_coupling (optional): A flag indicating whether to use all-to-all coupling in mixers. Default is False. + :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "XY" and "ZZ". + """ + nqubits = len(pauli_terms[0]) + c = Circ(nqubits) + for i in range(nqubits): + c.h(i) # Apply Hadamard gate to each qubit + + for j in range(nlayers): + # cost terms + for k, term in enumerate(pauli_terms): + index_of_ones = [] + for l in range(len(term)): + if term[l] == 1: + index_of_ones.append(l) + if len(index_of_ones) == 1: + c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) + # Apply Rz gate with angle determined by weight and current parameter value + elif len(index_of_ones) == 2: + c.rzz( + index_of_ones[0], + index_of_ones[1], + theta=weights[k] * params[2 * j], + ) + # Apply exp1 gate with a custom unitary (zz_matrix) and angle determined by weight and current parameter value + else: + raise ValueError("Invalid number of Z terms") + + # prepare the coupling map for mixer terms + pairs = [] + if full_coupling is False: + for q0 in list(range(0, nqubits - 1, 2)) + list(range(1, nqubits - 1, 2)): + pairs.append([q0, q0 + 1]) + pairs.append([nqubits - 1, 0]) + elif full_coupling is True: + for q0 in range(nqubits - 1): + for q1 in range(q0 + 1, nqubits): + pairs.append([q0, q1]) + else: + raise ValueError("Invalid input.") + + # standard mixer + if mixer == "X": + for i in range(nqubits): + c.rx( + i, theta=params[2 * j + 1] + ) # Apply Rx gate with angle determined by current parameter value + + # XY mixer + elif mixer == "XY": + for [q0, q1] in pairs: + c.rxx(q0, q1, theta=params[2 * j + 1]) + c.ryy(q0, q1, theta=params[2 * j + 1]) + + # ZZ mixer + elif mixer == "ZZ": + for [q0, q1] in pairs: + c.rzz(q0, q1, theta=params[2 * j + 1]) + + else: + raise ValueError("Invalid mixer type.") + + return c diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 655ac21e..3159d5a0 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -200,97 +200,3 @@ def qft( for i in range(len(index) // 2): c.swap(index[i], index[len(index) - 1 - i]) return c - - -def QAOA_ansatz_for_Ising( - params: list, - nlayers: int, - pauli_terms: Tensor, - weights: list, - mixer: str = "X", - gap: int = 5, -) -> Circuit: - """ - Construct the QAOA ansatz for the Ising Model. - The number of qubits is determined by `pauli_terms`. - - :param params: A list of parameter values used in the QAOA ansatz. - :param nlayers: The number of layers in the QAOA ansatz. - :pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. - :param weights: A list of weights corresponding to each Pauli term. - :param mixer: mixer type. The options are "X", "XY_ring", "XY_par_ring", "XY_full", and "QAMPA". - """ - nqubits = len(pauli_terms[0]) - c = Circ(nqubits) - for i in range(nqubits): - c.h(i) # Apply Hadamard gate to each qubit - - for j in range(nlayers): - # cost terms - for k in range(len(pauli_terms)): - term = pauli_terms[k] - index_of_ones = [] - for l in range(len(term)): - if term[l] == 1: - index_of_ones.append(l) - if len(index_of_ones) == 1: - c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) - # Apply Rz gate with angle determined by weight and current parameter value - elif len(index_of_ones) == 2: - c.exp1( - index_of_ones[0], - index_of_ones[1], - unitary=G._zz_matrix, - theta=weights[k] * params[2 * j], - ) - # Apply exp1 gate with a custom unitary (zz_matrix) and angle determined by weight and current parameter value - else: - raise ValueError("Invalid number of Z terms") - - # standard mixer - if mixer == "X": - for i in range(nqubits): - c.rx( - i, theta=params[2 * j + 1] - ) # Apply Rx gate with angle determined by current parameter value - # Parity ring XY mixer - elif mixer == "XY": - pairs = [] - for index in [0, 1]: - while index + 2 <= nqubits: - pairs.append([index, index + 1]) - index += 2 - for pair in pairs: - c.exp1(pair[0], pair[1], unitary=G._xx_matrix, theta=params[2 * j + 1]) - c.exp1(pair[0], pair[1], unitary=G._yy_matrix, theta=params[2 * j + 1]) - c.exp1(nqubits - 1, 0, unitary=G._xx_matrix, theta=params[2 * j + 1]) - c.exp1(nqubits - 1, 0, unitary=G._yy_matrix, theta=params[2 * j + 1]) - - # XY mixer with full couplings - elif mixer == "XY_full": - for q0 in range(nqubits - 1): - for q1 in range(q0 + 1, nqubits): - c.exp1(q0, q1, unitary=G._xx_matrix, theta=params[2 * j + 1]) - c.exp1(q0, q1, unitary=G._yy_matrix, theta=params[2 * j + 1]) - - # Parity ring ZZ mixer - elif mixer == "ZZ": - pairs = [] - for index in [0, 1]: - while index + 2 <= nqubits: - pairs.append([index, index + 1]) - index += 2 - for pair in pairs: - c.exp1(pair[0], pair[1], unitary=G._zz_matrix, theta=params[2 * j + 1]) - c.exp1(nqubits - 1, 0, unitary=G._zz_matrix, theta=params[2 * j + 1]) - - # ZZ mixer with full couplings - elif mixer == "ZZ_full": - for q0 in range(nqubits - 1): - for q1 in range(q0, nqubits): - c.exp1(q0, q1, unitary=G._zz_matrix, theta=params[2 * j + 1]) - - else: - raise ValueError("Invalid mixer type.") - - return c diff --git a/tensorcircuit/templates/conversions.py b/tensorcircuit/templates/conversions.py index 513a79a5..be14ed1e 100644 --- a/tensorcircuit/templates/conversions.py +++ b/tensorcircuit/templates/conversions.py @@ -3,10 +3,11 @@ """ from typing import Any, Tuple, List -from ..cons import backend import numpy as np +from ..cons import backend + Tensor = Any Array = Any @@ -40,7 +41,7 @@ def get_ps(qo: Any, n: int) -> Tuple[Tensor, Tensor]: return np.array(res), np.array(wts) -def QUBO_to_Ising(Q: List[list]) -> Tuple[List[list], list, float]: +def QUBO_to_Ising(Q: Tensor) -> Tuple[Tensor, List[float], float]: """ Cnvert the Q matrix into a the indication of pauli terms, the corresponding weights, and the offset. The outputs are used to construct an Ising Hamiltonian for QAOA. @@ -93,146 +94,3 @@ def QUBO_to_Ising(Q: List[list]) -> Tuple[List[list], list, float]: ) # Add the weight to the weights list return pauli_terms, weights, offset - - -def QUBO_from_portfolio(cov: Array, mean: Array, q: float, B: int, t: float) -> Tensor: - """ - convert portfolio parameters to a Q matrix - :param cov: n-by-n covariance numpy array - :param mean: numpy array of means - :param q: the risk preference of investor - :param B: budget - :param t: penalty factor - :return Q: n-by-n symmetric Q matrix - """ - n = cov.shape[0] - R = np.diag(mean) - S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n)) - - Q = q * cov - R + t * S - return Q - - -class StockData: - """ - A class for converting real-world stock data to an annualized covariance matrix and annualized return. - - Attributes: - - data: A list of continuous stock data in the same time span. - - n_stocks: The number of stocks in the data. - - n_days: The number of trading days in the data. - - Methods: - - __init__(self, data): Initializes the StockData object. - - get_return(self, decimals=5): Calculates the annualized return. - - get_covariance(self, decimals=5): Calculates the annualized covariance matrix. - - get_penalty(self, cov, ret, risk_pre, budget, decimals=5): Calculates the penalty factor. - """ - - def __init__(self, data): - """ - Initializes the StockData object. - - :param data: A list of continuous stock data in the same time span. - """ - self.data = data - self.n_stocks = len(data) - - # Check the number of days - n_days = [len(i) for i in data] - if max(n_days) != (sum(n_days) / len(n_days)): - raise Exception("Timespan of stocks should be the same") - self.n_days = len(data[1]) - - # Calculate the daily percentage price change - self.daily_change = [] - for i in range(self.n_stocks): - each_stock = [] - for j in range(self.n_days - 1): - each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j + 1]) - self.daily_change.append(each_stock) - - def get_return(self, decimals=5): - """ - Calculates the annualized return (mu). - - :param decimals: Number of decimal places to round the result to (default: 5). - :return: The annualized return as an array rounded to the specified number of decimals. - """ - change = [[j + 1 for j in i] for i in self.daily_change] - ret = np.prod(change, axis=1) ** (252 / self.n_days) - return ret.round(decimals) - - def get_covariance(self, decimals=5): - """ - Calculates the annualized covariance matrix (sigma). - - :param decimals: Number of decimal places to round the result to (default: 5). - :return: The annualized covariance matrix rounded to the specified number of decimals. - """ - mean = np.mean(self.daily_change, axis=1) - relative_change = [ - [j - mean[i] for j in self.daily_change[i]] for i in range(6) - ] - cov = 252 / self.n_days * np.dot(relative_change, np.transpose(relative_change)) - return cov.round(decimals) - - def get_penalty(self, cov, ret, risk_pre, budget, decimals=5): - """ - Calculates the penalty factor. - - :param cov: The annualized covariance matrix. - :param ret: The annualized return. - :param risk_pre: The risk preference factor. - :param budget: The budget (number of stocks to select). - :param decimals: Number of decimal places to round the result to (default: 5). - :return: The penalty factor rounded to the specified number of decimals. - """ - # Get all feasible and unfeasible states - self.f_state = [] # Feasible states (number of '1's equal to budget) - self.uf_state = [] # Unfeasible states - self.all_state = [] - for i in range(2 ** self.n_stocks): - state = f"{bin(i)[2:]:0>{self.n_stocks}}" - n_ones = 0 - for j in state: - if j == "1": - n_ones += 1 - self.all_state.append(state) - if n_ones == budget: - self.f_state.append(state) - else: - self.uf_state.append(state) - - # Determine the penalty factor - mark = False - penalty = 0 # Initial value - while mark == False: - R = np.diag(ret) - S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( - np.ones(self.n_stocks) - ) - Q = risk_pre * cov - R + penalty * S - F = [] - for state in self.f_state: - x = np.array([int(bit) for bit in state]) - F.append(np.dot(x, np.dot(Q, x)) + penalty * budget ** 2) - Fmin = np.amin(F) - Fbar = np.mean(F) - F = [] - for state in self.uf_state: - x = np.array([int(bit) for bit in state]) - F.append(np.dot(x, np.dot(Q, x)) + penalty * budget ** 2) - Fmin_uf = np.amin(F) - location = np.where(F == Fmin_uf)[0][0] - if Fmin_uf < 0.5 * (Fmin + Fbar): - n_ones = 0 - for j in self.uf_state[location]: - if j == "1": - n_ones += 1 - penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 - else: - mark = True # Ready to return the penalty - return round(penalty, decimals) - - From 6d26fa47e696fc4771b740c35ea5d41df5cb089d Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Fri, 14 Jul 2023 23:57:58 +0800 Subject: [PATCH 553/725] udpat install guide w/benchmark&unified tf install --- docs/source/contribs/development_Mac.md | 67 +++++++++++++++----- docs/source/contribs/development_Mac_cn.md | 72 ++++++++++++++++------ 2 files changed, 103 insertions(+), 36 deletions(-) diff --git a/docs/source/contribs/development_Mac.md b/docs/source/contribs/development_Mac.md index 00e03c92..b2682f32 100644 --- a/docs/source/contribs/development_Mac.md +++ b/docs/source/contribs/development_Mac.md @@ -6,7 +6,9 @@ Apple has updated Tensorflow (for MacOS) so that installation on M-series (until ## Starting From Scratch -For completely new Macos or Macos without Xcode and Homebrew installed. +For completely new Macos or Macos without Xcode installed. + +If you have Xcode installed, skip to Install TC backends. ### Install Xcode Command Line Tools @@ -16,40 +18,39 @@ Run `xcode-select --install` to install if on optimal internet. Or Download it from [Apple](https://developer.apple.com/download/more/) Command Line Tools installation image then install it if the internet connection is weak. -## Install Miniconda +## Install TC Backends + +There are four backends to choose from, Numpy, Tensorflow, Jax, and Torch. -Due to the limitation of MacOS and packages, the latest version of Python does not always function as desired, thus miniconda installation is advised to solve the issues. +### Install Jax, Pytorch (Optional) ```bash -curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -bash ~/miniconda.sh -b -p $HOME/miniconda -source ~/miniconda/bin/activate -conda install -c apple tensorflow-deps +pip install [Package Name] ``` +### Install Tensorflow (Optional - Recommended) -## Install TC Backends +#### Install Miniconda (Optional - Recommended) -There are four backends to choose from, Numpy, Tensorflow, Jax, and Torch. +If you wish to install Tensorflow optimized for MacOS (`tensorflow-macos`) or Tensorflow GPU optimized (`tensorflow-metal`) please install miniconda. -### Install Jax, Pytorch, Qiskit, Cirq (Optional) +If you wish to install Vanilla Tensorflow developed by Google (`tensorflow`) please skip this step. ```bash -pip install [Package Name] +curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh +bash ~/miniconda.sh -b -p $HOME/miniconda +source ~/miniconda/bin/activate +conda install -c apple tensorflow-deps ``` -### Install Tensorflow (Optional) - #### Installation -For Tensorflow version 2.13 or later: ```bash pip install tensorflow -pip install tensorflow-metal ``` -For Tensorflow version 2.12 or earlier: +If you wish to use tensorflow-metal PluggableDevice, then continue install (not recommended): + ```bash -pip install tensorflow-macos pip install tensorflow-metal ``` @@ -77,4 +78,36 @@ model.fit(x_train, y_train, epochs=5, batch_size=64) pip install tensorcircuit ``` +## Benchmarking + +This data is collected by running `benchmarks/scripts/vqe_tc.py` 10 times and average results. + + + + + + + + + + + + + + + + + + + + + + + + + + +
Vanilla TensorflowApple TensorflowApple Tensorflow with Metal Plugin
Construction Time11.49241641s11.31878941s11.6103961s
Iteration time0.002313011s0.002333004s0.046412581s
Total time11.72371747s11.55208979s16.25165417s
+ + Until July 2023, this has been tested on Intel Macs running Ventura, M1 Macs running Ventura, M2 Macs running Ventura, and M2 Macs running Sonoma beta. \ No newline at end of file diff --git a/docs/source/contribs/development_Mac_cn.md b/docs/source/contribs/development_Mac_cn.md index 2188a67b..f23fd01f 100644 --- a/docs/source/contribs/development_Mac_cn.md +++ b/docs/source/contribs/development_Mac_cn.md @@ -6,50 +6,52 @@ ## 从头开始 -对于全新的Macos或未安装Xcode和Homebrew的Macos。 +对于全新的Macos或未安装Xcode的Macos。 + +若您已安装Xcode，请跳转到安装TC后端。 ### 安装Xcode命令行工具 -需要对机器的图形访问。 +需要对机器的图形访问 如果网络良好，请运行`xcode-select --install`进行安装。 -或者，如果网络连接较弱，请从[苹果](https://developer.apple.com/download/more/)下载命令行工具安装映像，然后进行安装。 +或者，如果网络连接不理想，请从[苹果](https://developer.apple.com/download/more/)下载命令行工具安装映像，然后进行安装。 + +## 安装TC后端 -## 安装Miniconda +有四个后端可供选择，Numpy，Tensorflow，Jax和Torch。 -由于MacOS和软件包的限制，因此建议安装miniconda以解决问题。 +### 安装Jax、Pytorch（可选） ```bash -curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -bash ~/miniconda.sh -b -p $HOME/miniconda -source ~/miniconda/bin/activate -conda install -c apple tensorflow-deps +pip install [Package Name] ``` -## 安装TC后端 +### 安装Tensorflow（可选 - 推荐） -有四个后端可供选择，Numpy，Tensorflow，Jax和Torch。 +#### 安装miniconda（可选 - 推荐） -### 安装Jax，Pytorch，Qiskit，Cirq（可选） +若您希望使用苹果为MacOS优化的Tensorflow（`tensorflow-macos`）或使用Tensorflow GPU优化（`tensorflow-metal`）请安装mimiconda。 + +若您希望使Google开发的原版Tensorflow（`tensorflow`）请跳过此步骤。 ```bash -pip install [Package Name] +curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh +bash ~/miniconda.sh -b -p $HOME/miniconda +source ~/miniconda/bin/activate +conda install -c apple tensorflow-deps ``` -### 安装Tensorflow（可选） - #### 安装步骤 -Tensorflow版本2.13或之后： ```bash pip install tensorflow -pip install tensorflow-metal ``` -Tensorflow版本2.12或之前： +若您希望使用苹果为Tensorflow优化的Metal后端，请继续运行（不建议）： + ```bash -pip install tensorflow-macos pip install tensorflow-metal ``` @@ -77,4 +79,36 @@ model.fit(x_train, y_train, epochs=5, batch_size=64) pip install tensorcircuit ``` +## 测试与比较 + +以下数据由运行`benchmarks/scripts/vqe_tc.py` 10次并取平均值得到。 + + + + + + + + + + + + + + + + + + + + + + + + + + +
原版Tensorflow苹果优化版Tensorflow苹果优化版Tensorflow并安装Tensorflow Metal插件
构建时间11.49241641s11.31878941s11.6103961s
迭代时间0.002313011s0.002333004s0.046412581s
从时间11.72371747s11.55208979s16.25165417s
+ + 直到2023年7月，这已在运行Ventura的英特尔i9 Mac、运行Ventura的M1 Mac、运行Ventura的M2 Mac、运行Sonoma测试版的M2 Mac上进行了测试。 \ No newline at end of file From df6bc9c7b2d62a9a9ee34f0d6d2205bf06065bf7 Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Fri, 14 Jul 2023 23:23:02 +0100 Subject: [PATCH 554/725] reviewed version 1.1 --- tensorcircuit/applications/finance/portfolio.py | 12 +++++++----- tensorcircuit/applications/optimization.py | 17 +++++++++-------- tensorcircuit/templates/ansatz.py | 14 +++++++------- 3 files changed, 23 insertions(+), 20 deletions(-) diff --git a/tensorcircuit/applications/finance/portfolio.py b/tensorcircuit/applications/finance/portfolio.py index 93633790..dfff9108 100644 --- a/tensorcircuit/applications/finance/portfolio.py +++ b/tensorcircuit/applications/finance/portfolio.py @@ -2,7 +2,7 @@ Supplementary functions for portfolio optimization """ -from typing import Any +from typing import Any, List import numpy as np @@ -44,7 +44,7 @@ class StockData: - get_penalty(self, cov, ret, risk_pre, budget, decimals=5): Calculates the penalty factor. """ - def __init__(self, data): + def __init__(self, data: Tensor): """ Initializes the StockData object. @@ -67,7 +67,7 @@ def __init__(self, data): each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j + 1]) self.daily_change.append(each_stock) - def get_return(self, decimals=5): + def get_return(self, decimals: int = 5) -> List[float]: """ Calculates the annualized return (mu). @@ -78,7 +78,7 @@ def get_return(self, decimals=5): ret = np.prod(change, axis=1) ** (252 / self.n_days) return ret.round(decimals) - def get_covariance(self, decimals=5): + def get_covariance(self, decimals: int = 5) -> Tensor: """ Calculates the annualized covariance matrix (sigma). @@ -92,7 +92,9 @@ def get_covariance(self, decimals=5): cov = 252 / self.n_days * np.dot(relative_change, np.transpose(relative_change)) return cov.round(decimals) - def get_penalty(self, cov, ret, risk_pre, budget, decimals=5): + def get_penalty( + self, cov: Tensor, ret: List[float], risk_pre: float, budget: int, decimals: int = 5 + ) -> float: """ Calculates the penalty factor. diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index 8bcb1a90..b80a6d6c 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -2,7 +2,7 @@ modules for QUBO problems in QAOA """ -from typing import List, Callable, Any +from typing import List, Callable, Any, Optional, Tuple from functools import partial import numpy as np @@ -17,9 +17,10 @@ Circuit = Any Tensor = Any +Array = Any -def Ising_loss(c: Circuit, pauli_terms: Tensor, weights: List[float]) -> float: +def Ising_loss(c: Circuit, pauli_terms: Tensor, weights: List[float]) -> Any: """ computes the loss function for the Ising model based on a given quantum circuit, a list of Pauli terms, and corresponding weights. @@ -88,11 +89,11 @@ def QUBO_QAOA( iterations: int, vvag: bool = False, ncircuits: int = 10, - init_params: List[float] = None, + init_params: Optional[List[float]] = None, mixer: str = "X", learning_rate: float = 1e-2, - callback: callable = None, - full_coupling=False, + callback: Optional[Callable] = None, + full_coupling: bool = False, ) -> List[float]: """ Performs the QAOA on a given QUBO problem. @@ -298,11 +299,11 @@ def QUBO_QAOA_cvar( nlayers: int, alpha: int, nsamples: int = 1000, - callback: callable = None, + callback: Optional[callable] = None, fake: bool = False, maxiter: int = 1000, - init_params: List[float] = None, -) -> List[float]: + init_params: Optional[Tuple[float,]] = None, +) -> Array: """ Perform the QUBO QAOA optimization with CVaR as the loss function. diff --git a/tensorcircuit/templates/ansatz.py b/tensorcircuit/templates/ansatz.py index 575b820a..4c8bb140 100644 --- a/tensorcircuit/templates/ansatz.py +++ b/tensorcircuit/templates/ansatz.py @@ -32,7 +32,7 @@ def QAOA_ansatz_for_Ising( nqubits = len(pauli_terms[0]) c = Circ(nqubits) for i in range(nqubits): - c.h(i) # Apply Hadamard gate to each qubit + c.H(i) # Apply Hadamard gate to each qubit for j in range(nlayers): # cost terms @@ -42,10 +42,10 @@ def QAOA_ansatz_for_Ising( if term[l] == 1: index_of_ones.append(l) if len(index_of_ones) == 1: - c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) + c.RZ(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) # Apply Rz gate with angle determined by weight and current parameter value elif len(index_of_ones) == 2: - c.rzz( + c.RZZ( index_of_ones[0], index_of_ones[1], theta=weights[k] * params[2 * j], @@ -70,20 +70,20 @@ def QAOA_ansatz_for_Ising( # standard mixer if mixer == "X": for i in range(nqubits): - c.rx( + c.RX( i, theta=params[2 * j + 1] ) # Apply Rx gate with angle determined by current parameter value # XY mixer elif mixer == "XY": for [q0, q1] in pairs: - c.rxx(q0, q1, theta=params[2 * j + 1]) - c.ryy(q0, q1, theta=params[2 * j + 1]) + c.RXX(q0, q1, theta=params[2 * j + 1]) + c.RYY(q0, q1, theta=params[2 * j + 1]) # ZZ mixer elif mixer == "ZZ": for [q0, q1] in pairs: - c.rzz(q0, q1, theta=params[2 * j + 1]) + c.RZZ(q0, q1, theta=params[2 * j + 1]) else: raise ValueError("Invalid mixer type.") From 4d66265b31c5534deaaa8776d669d5a1ae034758 Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Fri, 14 Jul 2023 23:29:57 +0100 Subject: [PATCH 555/725] fixed a format problem (reviewed V1.2) --- tensorcircuit/applications/finance/portfolio.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/applications/finance/portfolio.py b/tensorcircuit/applications/finance/portfolio.py index dfff9108..506deae5 100644 --- a/tensorcircuit/applications/finance/portfolio.py +++ b/tensorcircuit/applications/finance/portfolio.py @@ -93,7 +93,12 @@ def get_covariance(self, decimals: int = 5) -> Tensor: return cov.round(decimals) def get_penalty( - self, cov: Tensor, ret: List[float], risk_pre: float, budget: int, decimals: int = 5 + self, + cov: Tensor, + ret: List[float], + risk_pre: float, + budget: int, + decimals: int = 5, ) -> float: """ Calculates the penalty factor. From 1a114ece6e5c6b0e58c5ad893c242170d63a599b Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sat, 15 Jul 2023 15:49:25 +0800 Subject: [PATCH 556/725] update qaoa_bo.ipynb --- docs/source/tutorials/qaoa_bo.ipynb | 462 ++++++++++++++++++---------- 1 file changed, 291 insertions(+), 171 deletions(-) diff --git a/docs/source/tutorials/qaoa_bo.ipynb b/docs/source/tutorials/qaoa_bo.ipynb index e82bc841..e8fe334b 100644 --- a/docs/source/tutorials/qaoa_bo.ipynb +++ b/docs/source/tutorials/qaoa_bo.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "source": [ "import tensorcircuit as tc\n", "from jax import numpy as jnp\n", @@ -55,12 +55,12 @@ "\n", "# cotengra package to speed up the calculation\n", "opt_ctg = ctg.ReusableHyperOptimizer(\n", - " methods = [\"greedy\", \"kahypar\"],\n", - " parallel = True,\n", - " minimize = \"combo\",\n", - " max_time = 20,\n", - " max_repeats = 128,\n", - " progbar = True\n", + " methods=[\"greedy\", \"kahypar\"],\n", + " parallel=True,\n", + " minimize=\"combo\",\n", + " max_time=20,\n", + " max_repeats=128,\n", + " progbar=True,\n", ")\n", "\n", "tc.set_contractor(\"custom\", optimizer=opt_ctg, preprocessing=True)\n", @@ -69,21 +69,8 @@ "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "acqfn = \"ucb\"" ], - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-07-14 16:25:57.015620: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.284160700Z", - "start_time": "2023-07-14T08:25:56.959511700Z" - } - } + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", @@ -103,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "source": [ "# a graph instance\n", "graph_dict = {\n", @@ -121,13 +108,13 @@ "pos = nx.spring_layout(graph)\n", "nx.draw_networkx(graph, with_labels=True, pos=pos)\n", "ax = plt.gca()\n", - "ax.set_facecolor('w')" + "ax.set_facecolor(\"w\")" ], "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -135,8 +122,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.442502100Z", - "start_time": "2023-07-14T08:26:01.299147Z" + "end_time": "2023-07-15T07:42:26.571397400Z", + "start_time": "2023-07-15T07:42:26.444088200Z" } } }, @@ -151,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "outputs": [ { "name": "stdout", @@ -164,7 +151,7 @@ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -175,7 +162,7 @@ " num_nodes = len(graph)\n", " max_cut = [0]\n", " best_case = [0] # \"01\" series with max cut\n", - " for i in range(2 ** num_nodes):\n", + " for i in range(2**num_nodes):\n", " case = f\"{bin(i)[2:]:0>{num_nodes}}\"\n", " cat1, cat2 = [], []\n", " for j in range(num_nodes):\n", @@ -200,6 +187,7 @@ "\n", " return max_cut[-1], best_case[index:]\n", "\n", + "\n", "max_cut, best_case = classical_solver(graph_dict)\n", "print(\"bit string:\", best_case, \"\\nmax cut:\", max_cut)\n", "\n", @@ -212,8 +200,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.576063200Z", - "start_time": "2023-07-14T08:26:01.462858Z" + "end_time": "2023-07-15T07:42:29.489809800Z", + "start_time": "2023-07-15T07:42:29.368921400Z" } } }, @@ -228,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 46, "outputs": [], "source": [ "def QAOAansatz(params, each=1, return_circuit=False):\n", @@ -240,7 +228,7 @@ " for j in range(each):\n", " # driving layer\n", " for a, b in graph.edges:\n", - " c_.RZZ(a, b, theta=graph[a][b]['weight'] * params_[2 * j])\n", + " c_.RZZ(a, b, theta=graph[a][b][\"weight\"] * params_[2 * j])\n", " # mixing layer\n", " for i in range(n):\n", " c_.RX(i, theta=params_[2 * j + 1])\n", @@ -259,28 +247,31 @@ " return c\n", "\n", " # calculate the loss function\n", - " loss = 0.\n", + " loss = 0.0\n", " for a, b in graph.edges:\n", - " loss += c.expectation_ps(z=[a, b]) * graph[a][b]['weight']\n", + " loss += c.expectation_ps(z=[a, b]) * graph[a][b][\"weight\"]\n", "\n", " return K.real(loss)" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.580388700Z", - "start_time": "2023-07-14T08:26:01.580361500Z" + "end_time": "2023-07-15T05:12:41.534488800Z", + "start_time": "2023-07-15T05:12:41.483853500Z" } } }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 47, "outputs": [], "source": [ - "QAOA_vag = K.jit(tc.backend.value_and_grad(QAOAansatz, argnums=0), static_argnums=(1, 2))\n", + "QAOA_vag = K.jit(\n", + " tc.backend.value_and_grad(QAOAansatz, argnums=0), static_argnums=(1, 2)\n", + ")\n", "QAOA_nograd = K.jit(QAOAansatz, static_argnums=(1, 2))\n", "\n", + "\n", "def eval_objective(x):\n", " \"\"\"This is a helper function we use to unnormalize and evalaute a point\"\"\"\n", " return -torch.from_numpy(np.asarray(QAOA_nograd(jnp.asarray(x.ravel()))))" @@ -288,8 +279,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.651675700Z", - "start_time": "2023-07-14T08:26:01.580388700Z" + "end_time": "2023-07-15T05:12:41.541255500Z", + "start_time": "2023-07-15T05:12:41.484406100Z" } } }, @@ -304,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 48, "outputs": [], "source": [ "opt = K.optimizer(optax.adam(1e-2))" @@ -312,8 +303,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.667741600Z", - "start_time": "2023-07-14T08:26:01.620275700Z" + "end_time": "2023-07-15T05:12:41.603802800Z", + "start_time": "2023-07-15T05:12:41.585764800Z" } } }, @@ -326,41 +317,67 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 49, "source": [ "class BO_optimizer:\n", - " def __init__(self, eval_func, batch_size: int = 1, device='cpu'):\n", + " def __init__(self, eval_func, batch_size: int = 1, device=\"cpu\"):\n", " self.eval_func = eval_func\n", " self.device = device\n", " self.batch_size = batch_size\n", - "\n", - " def computeY(self, X):\n", - " return torch.tensor([self.eval_func(x) for x in X], dtype=X.dtype, device=self.device).unsqueeze(-1)\n", - "\n", - " def update(self, X, Y=None, acqfn: str = \"ucb\", normalize: bool = False, verbose: bool = False):\n", + " self.best_dict = {\"X\": None, \"Y\": torch.tensor(-float(\"inf\"))}\n", + "\n", + " def compute_Y(self, X):\n", + " return torch.tensor(\n", + " [self.eval_func(x) for x in X], dtype=X.dtype, device=self.device\n", + " ).unsqueeze(-1)\n", + "\n", + " def update_best(self, X_next, Y_next):\n", + " new_Y, new_idx = torch.max(Y_next, dim=0)\n", + " new_Y = new_Y.squeeze()\n", + " if new_Y > self.best_dict[\"Y\"]:\n", + " self.best_dict[\"Y\"] = new_Y\n", + " self.best_dict[\"X\"] = X_next[new_idx]\n", + "\n", + " def update(\n", + " self,\n", + " X,\n", + " Y=None,\n", + " acqfn: str = \"ucb\",\n", + " normalize: bool = False,\n", + " verbose: bool = False,\n", + " ):\n", " if Y is None:\n", - " Y = self.computeY(X)\n", - " X_next = odbo.run_exp.bo_design(X=X, Y=Y, batch_size=self.batch_size, acqfn=acqfn, normalize=normalize, verbose=verbose)[0].reshape(self.batch_size, X.shape[-1])\n", - " Y_next = self.computeY(X_next)\n", + " Y = self.compute_Y(X)\n", + " X_next = odbo.run_exp.bo_design(\n", + " X=X,\n", + " Y=Y,\n", + " batch_size=self.batch_size,\n", + " acqfn=acqfn,\n", + " normalize=normalize,\n", + " verbose=verbose,\n", + " )[0].reshape(self.batch_size, X.shape[-1])\n", + " Y_next = self.compute_Y(X_next)\n", + "\n", + " self.update_best(X_next, Y_next)\n", + "\n", " # Update training set\n", " X = torch.cat((X, X_next), dim=0)\n", " Y = torch.cat((Y, Y_next), dim=0)\n", - " best_idx = torch.argmax(Y, dim=0)\n", "\n", - " return X, Y, Y_next.mean().item(), X[best_idx], Y[best_idx].item()" + " return X, Y, Y_next.mean()" ], "outputs": [], "metadata": { "scrolled": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.667741600Z", - "start_time": "2023-07-14T08:26:01.620275700Z" + "end_time": "2023-07-15T05:12:41.603802800Z", + "start_time": "2023-07-15T05:12:41.586291Z" } } }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 50, "outputs": [], "source": [ "batch_size = 1\n", @@ -370,8 +387,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.667741600Z", - "start_time": "2023-07-14T08:26:01.620916400Z" + "end_time": "2023-07-15T05:12:41.603802800Z", + "start_time": "2023-07-15T05:12:41.586291Z" } } }, @@ -386,49 +403,78 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 51, "outputs": [], "source": [ "class TuRBO_optimizer(BO_optimizer):\n", - " def __init__(self, eval_func, num_params, tr_length, failure_tolerance, device=\"cpu\"):\n", + " def __init__(\n", + " self, eval_func, num_params, tr_length, failure_tolerance, device=\"cpu\"\n", + " ):\n", " super(TuRBO_optimizer, self).__init__(eval_func, device=device)\n", - " self.batch_size = 1 # There is bug in odbo.run_exp.turbo_design, batch_size can only be 1\n", + " self.batch_size = (\n", + " 1 # There is bug in odbo.run_exp.turbo_design, batch_size can only be 1\n", + " )\n", " self.tr_length = tr_length\n", - " self.state = odbo.turbo.TurboState(dim=num_params, batch_size=batch_size, length=tr_length, n_trust_regions=len(tr_length), failure_tolerance=failure_tolerance)\n", + " self.state = odbo.turbo.TurboState(\n", + " dim=num_params,\n", + " batch_size=batch_size,\n", + " length=tr_length,\n", + " n_trust_regions=len(tr_length),\n", + " failure_tolerance=failure_tolerance,\n", + " )\n", "\n", " def inverse_transform(self, X):\n", - " '''\n", - " Note TuRBO is working on only [0,1] parameter range\n", - " We need to transform parameters from [0,1] to [-pi,pi] before using eval_func\n", - " '''\n", + " \"\"\"\n", + " Note TuRBO is working on only [0,1] parameter range\n", + " We need to transform parameters from [0,1] to [-pi,pi] before using eval_func\n", + " \"\"\"\n", " return X * 2 * np.pi - np.pi\n", "\n", " def transform(self, X):\n", - " '''\n", - " Note TuRBO is working on only [0,1] parameter range\n", - " We need to transform parameters from [-pi,pi] to [0,1] before using odbo.run_exp.turbo_design\n", - " '''\n", + " \"\"\"\n", + " Note TuRBO is working on only [0,1] parameter range\n", + " We need to transform parameters from [-pi,pi] to [0,1] before using odbo.run_exp.turbo_design\n", + " \"\"\"\n", " return X / 2 / np.pi + 0.5\n", "\n", - " def computeY(self, X, transformed_input: bool = True):\n", + " def compute_Y(self, X, transformed_input: bool = True):\n", " if transformed_input:\n", " X = self.inverse_transform(X)\n", - " return torch.tensor([self.eval_func(x) for x in X], dtype=X.dtype, device=self.device).unsqueeze(-1)\n", + " return torch.tensor(\n", + " [self.eval_func(x) for x in X], dtype=X.dtype, device=self.device\n", + " ).unsqueeze(-1)\n", "\n", " def get_next(self, X, Y, acqfn, normalize, verbose):\n", - " X_next = odbo.run_exp.turbo_design(state=self.state, X=X, Y=Y, n_trust_regions=len(self.tr_length), batch_size=self.batch_size, acqfn=acqfn, normalize=normalize, verbose=verbose)[0].reshape(len(self.tr_length) * self.batch_size, X.shape[-1])\n", - " Y_next = self.computeY(X_next)\n", + " X_next = odbo.run_exp.turbo_design(\n", + " state=self.state,\n", + " X=X,\n", + " Y=Y,\n", + " n_trust_regions=len(self.tr_length),\n", + " batch_size=self.batch_size,\n", + " acqfn=acqfn,\n", + " normalize=normalize,\n", + " verbose=verbose,\n", + " )[0].reshape(len(self.tr_length) * self.batch_size, X.shape[-1])\n", + " Y_next = self.compute_Y(X_next)\n", " return X_next, Y_next\n", "\n", " def update_state(self, Y_next):\n", - " self.state = odbo.turbo.update_state(state=self.state, Y_next=Y_next.reshape(len(self.tr_length), self.batch_size, 1))\n", + " self.state = odbo.turbo.update_state(\n", + " state=self.state,\n", + " Y_next=Y_next.reshape(len(self.tr_length), self.batch_size, 1),\n", + " )\n", "\n", " def preprocess(self, X, Y, transformed_input):\n", " if not transformed_input:\n", " X = self.transform(X)\n", " if Y is None:\n", - " Y = self.computeY(X)\n", - " self.state.best_value = max(self.state.best_value, Y.max())\n", + " Y = self.compute_Y(X)\n", + " best_Y, best_idx = torch.max(Y, dim=0)\n", + " best_Y = best_Y.squeeze()\n", + " if best_Y > self.best_dict[\"Y\"]:\n", + " self.state.best_value = best_Y.item()\n", + " self.best_dict[\"Y\"] = best_Y\n", + " self.best_dict[\"X\"] = X[best_idx]\n", " return X, Y\n", "\n", " def postprocess(self, X, Y, X_next, Y_next, transformed_output):\n", @@ -436,43 +482,55 @@ " Y = torch.cat((Y, Y_next), dim=0)\n", " if not transformed_output:\n", " X = self.inverse_transform(X)\n", - " best_idx = torch.argmax(Y, dim=0)\n", - " return X, Y, X[best_idx]\n", + " return X, Y\n", "\n", - " def update(self, X, Y=None, acqfn: str = \"ucb\", normalize: bool = False, verbose: bool = False, transformed_input: bool = False, transformed_output: bool = False):\n", + " def update(\n", + " self,\n", + " X,\n", + " Y=None,\n", + " acqfn: str = \"ucb\",\n", + " normalize: bool = False,\n", + " verbose: bool = False,\n", + " transformed_input: bool = False,\n", + " transformed_output: bool = False,\n", + " ):\n", " X, Y = self.preprocess(X, Y, transformed_input)\n", "\n", " X_next, Y_next = self.get_next(X, Y, acqfn, normalize, verbose)\n", "\n", + " self.update_best(X_next, Y_next)\n", + "\n", " self.update_state(Y_next)\n", "\n", - " X, Y, best_X = self.postprocess(X, Y, X_next, Y_next, transformed_output)\n", + " X, Y = self.postprocess(X, Y, X_next, Y_next, transformed_output)\n", "\n", - " return X, Y, Y_next.mean().item(), best_X, self.state.best_value" + " return X, Y, Y_next.mean()" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.667741600Z", - "start_time": "2023-07-14T08:26:01.666716700Z" + "end_time": "2023-07-15T05:12:41.603802800Z", + "start_time": "2023-07-15T05:12:41.586798100Z" } } }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 52, "outputs": [], "source": [ "failure_tolerance = 10\n", - "tr_length= [1.6]\n", + "tr_length = [1.6]\n", "\n", - "turbo_opt = TuRBO_optimizer(eval_objective, 2 * nlayers, tr_length, failure_tolerance, device)" + "turbo_opt = TuRBO_optimizer(\n", + " eval_objective, 2 * nlayers, tr_length, failure_tolerance, device\n", + ")" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.668291500Z", - "start_time": "2023-07-14T08:26:01.666716700Z" + "end_time": "2023-07-15T05:12:41.645737200Z", + "start_time": "2023-07-15T05:12:41.586798100Z" } } }, @@ -496,81 +554,121 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 53, "outputs": [], "source": [ "class DARBO_optimizer(TuRBO_optimizer):\n", - " def __init__(self, eval_func, num_params, tr_length, failure_tolerance, mode: Union[bool, str] = True, device=\"cpu\"):\n", - " super(DARBO_optimizer, self).__init__(eval_func, num_params, tr_length, failure_tolerance, device)\n", + " def __init__(\n", + " self,\n", + " eval_func,\n", + " num_params,\n", + " tr_length,\n", + " failure_tolerance,\n", + " mode: Union[bool, str] = True,\n", + " device=\"cpu\",\n", + " ):\n", + " super(DARBO_optimizer, self).__init__(\n", + " eval_func, num_params, tr_length, failure_tolerance, device\n", + " )\n", " self.switch_counter = 0\n", - " if mode ==True or mode == 'large':\n", + " if mode == True or mode == \"large\":\n", " self.mode = True\n", " else:\n", " self.mode = False\n", + " self.best_dict = {\n", + " \"X\": None,\n", + " \"Y\": torch.tensor(self.state.best_value),\n", + " \"mode\": self.mode,\n", + " }\n", "\n", " def get_mode(self):\n", - " return 'large' if self.mode else 'small'\n", + " return \"large\" if self.mode else \"small\"\n", "\n", - " def inverse_transform(self, X):\n", - " '''\n", - " Note TuRBO is working on only [0,1] parameter range\n", - " We need to transform parameters from [0, 1] to [-pi, pi] or [-pi / 2, pi / 2] before using eval_func\n", - " '''\n", - " if self.mode: # [0, 1] to [-pi, pi]\n", + " def compute_Y(self, X, transformed_input: bool = True, mode=None):\n", + " if transformed_input:\n", + " X = self.inverse_transform(X, mode)\n", + " return torch.tensor(\n", + " [self.eval_func(x) for x in X], dtype=X.dtype, device=self.device\n", + " ).unsqueeze(-1)\n", + "\n", + " def inverse_transform(self, X, mode=None):\n", + " \"\"\"\n", + " Note TuRBO is working on only [0,1] parameter range\n", + " We need to transform parameters from [0, 1] to [-pi, pi] or [-pi / 2, pi / 2] before using eval_func\n", + " \"\"\"\n", + " if mode is None:\n", + " mode = self.mode\n", + " if mode: # [0, 1] to [-pi, pi]\n", " return X * 2 * np.pi - np.pi\n", - " else: # [0, 1] to [-pi / 2, pi / 2]\n", + " else: # [0, 1] to [-pi / 2, pi / 2]\n", " return X * np.pi - np.pi / 2\n", "\n", - " def transform(self, X):\n", - " '''\n", - " Note TuRBO is working on only [0,1] parameter range\n", - " We need to transform parameters from [-pi,pi] or [-pi / 2, pi / 2] to [0,1] before using odbo.run_exp.turbo_design\n", - " '''\n", - " if self.mode: # [-pi, pi] to [0, 1]\n", + " def transform(self, X, mode=None):\n", + " \"\"\"\n", + " Note TuRBO is working on only [0,1] parameter range\n", + " We need to transform parameters from [-pi,pi] or [-pi / 2, pi / 2] to [0,1] before using odbo.run_exp.turbo_design\n", + " \"\"\"\n", + " if mode is None:\n", + " mode = self.mode\n", + " if mode: # [-pi, pi] to [0, 1]\n", " return X / 2 / np.pi + 0.5\n", - " else: # [-pi / 2, pi / 2] to [0, 1]\n", + " else: # [-pi / 2, pi / 2] to [0, 1]\n", " return X / np.pi + 0.5\n", "\n", - " def computeY(self, X, transformed_input: bool = True):\n", - " if transformed_input:\n", - " X = self.inverse_transform(X)\n", - " return torch.tensor([self.eval_func(x) for x in X], dtype=X.dtype, device=self.device).unsqueeze(-1)\n", + " def update_best(self, X_next, Y_next):\n", + " new_Y, new_idx = torch.max(Y_next, dim=0)\n", + " new_Y = new_Y.squeeze()\n", + " if new_Y > self.best_dict[\"Y\"]:\n", + " self.best_dict[\"Y\"] = new_Y\n", + " self.best_dict[\"X\"] = X_next[new_idx]\n", + " self.best_dict[\"mode\"] = self.mode\n", + " else:\n", + " self.switch_counter += 1\n", "\n", - " def update(self, X, Y=None, acqfn: str = \"ucb\", normalize: bool = False, verbose: bool = False, transformed_input: bool = False, transformed_output: bool = False):\n", + " def update(\n", + " self,\n", + " X,\n", + " Y=None,\n", + " acqfn: str = \"ucb\",\n", + " normalize: bool = False,\n", + " verbose: bool = False,\n", + " transformed_input: bool = False,\n", + " transformed_output: bool = False,\n", + " frequency: int = 4,\n", + " ):\n", " X, Y = self.preprocess(X, Y, transformed_input)\n", "\n", " # check if we need to switch the searching parameter range.\n", - " if self.switch_counter >= 4:\n", + " if self.switch_counter >= frequency:\n", " if self.mode:\n", - " X *= 2\n", + " X = (X * 2).clamp(0, 1)\n", " self.mode = False # small\n", " else:\n", - " X /= 2\n", - " self.mode = True # large\n", + " X = (X / 2).clamp(0, 1)\n", + " self.mode = True # large\n", " self.switch_counter = 0\n", "\n", " X_next, Y_next = self.get_next(X, Y, acqfn, normalize, verbose)\n", "\n", - " if Y_next.max() < Y.max():\n", - " self.switch_counter += 1\n", + " self.update_best(X_next, Y_next)\n", "\n", " self.update_state(Y_next)\n", "\n", - " X, Y, best_X = self.postprocess(X, Y, X_next, Y_next, transformed_output)\n", + " X, Y = self.postprocess(X, Y, X_next, Y_next, transformed_output)\n", "\n", - " return X, Y , Y_next.mean().item(), best_X, self.state.best_value" + " return X, Y, Y_next.mean()" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.713967Z", - "start_time": "2023-07-14T08:26:01.666716700Z" + "end_time": "2023-07-15T05:12:41.645737200Z", + "start_time": "2023-07-15T05:12:41.627215300Z" } } }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 54, "outputs": [ { "name": "stdout", @@ -581,16 +679,18 @@ } ], "source": [ - "mode = 'small'\n", + "mode = \"small\"\n", "\n", - "darbo_opt = DARBO_optimizer(eval_objective, 2 * nlayers, tr_length, failure_tolerance, mode, device)\n", - "print(f'initial mode: {darbo_opt.get_mode()}')" + "darbo_opt = DARBO_optimizer(\n", + " eval_objective, 2 * nlayers, tr_length, failure_tolerance, mode, device\n", + ")\n", + "print(f\"initial mode: {darbo_opt.get_mode()}\")" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T08:26:01.713967Z", - "start_time": "2023-07-14T08:26:01.704050400Z" + "end_time": "2023-07-15T05:12:41.645737200Z", + "start_time": "2023-07-15T05:12:41.627726200Z" } } }, @@ -605,12 +705,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 55, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -619,8 +719,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 299 min loss: -7.575720919791415\t-5.524467468261719\t-7.743190336435761\t-6.011992874299757\n", - "Epoch 299 time: 15.6287100315094\tTotal time: 2132.036656141281\n" + "Epoch 299 min loss: -5.837215998677346\t-6.87628698348999\t-6.8708058821631575\t-7.000515157123274\n", + "Epoch 299 time: 13.83302903175354\tTotal time: 2123.8649847507477\n" ] } ], @@ -653,31 +753,45 @@ " params = opt.update(grads, params) # gradient descent\n", " losses.append(loss)\n", "\n", - " X_bo, Y_bo, loss, X_bo_best, bo_max = bo_opt.update(X_bo, Y_bo, acqfn)\n", - " losses_bo.append(-loss)\n", - "\n", - " X_turbo, Y_turbo, loss, X_turbo_best, turbo_max = turbo_opt.update(X_turbo, Y_turbo, acqfn, transformed_input=False if i == 0 else True, transformed_output=True)\n", - " losses_turbo.append(-loss)\n", - "\n", - " X_darbo, Y_darbo, loss, X_darbo_best, darbo_max = darbo_opt.update(X_darbo, Y_darbo, acqfn, transformed_input=False if i == 0 else True, transformed_output=True)\n", - " losses_darbo.append(-loss)\n", + " X_bo, Y_bo, _ = bo_opt.update(X_bo, Y_bo, acqfn)\n", + " losses_bo.append(-bo_opt.best_dict[\"Y\"].item())\n", + "\n", + " X_turbo, Y_turbo, _ = turbo_opt.update(\n", + " X_turbo,\n", + " Y_turbo,\n", + " acqfn,\n", + " transformed_input=False if i == 0 else True,\n", + " transformed_output=True,\n", + " )\n", + " losses_turbo.append(-turbo_opt.best_dict[\"Y\"].item())\n", + "\n", + " X_darbo, Y_darbo, _ = darbo_opt.update(\n", + " X_darbo,\n", + " Y_darbo,\n", + " acqfn,\n", + " transformed_input=False if i == 0 else True,\n", + " transformed_output=True,\n", + " )\n", + " losses_darbo.append(-darbo_opt.best_dict[\"Y\"].item())\n", "\n", " # visualise the progress\n", " clear_output(wait=True)\n", " plt.figure()\n", - " plt.xlabel('Iteration')\n", - " plt.ylabel('Cost')\n", - " plt.plot(range(i + 1), losses, c='r', label='Adam')\n", - " plt.plot(range(i + 1), losses_bo, c='b', label='BO')\n", - " plt.plot(range(i + 1), losses_turbo, c='g', label='TuRBO')\n", - " plt.plot(range(i + 1), losses_darbo, c='y', label='DARBO')\n", + " plt.xlabel(\"Iteration\")\n", + " plt.ylabel(\"Cost\")\n", + " plt.plot(range(i + 1), losses, c=\"r\", label=\"Adam\")\n", + " plt.plot(range(i + 1), losses_bo, c=\"b\", label=\"BO\")\n", + " plt.plot(range(i + 1), losses_turbo, c=\"g\", label=\"TuRBO\")\n", + " plt.plot(range(i + 1), losses_darbo, c=\"y\", label=\"DARBO\")\n", " plt.legend()\n", " plt.show()\n", "\n", - " print(f'Epoch {i} min loss: {min(losses)}\\t{-bo_max}\\t{-turbo_max}\\t{-darbo_max}')\n", + " print(\n", + " f\"Epoch {i} min loss: {min(losses)}\\t{losses_bo[-1]}\\t{losses_turbo[-1]}\\t{losses_darbo[-1]}\"\n", + " )\n", "\n", " te = time.time()\n", - " print(f'Epoch {i} time: {te - ts}\\tTotal time: {te - t0}')\n", + " print(f\"Epoch {i} time: {te - ts}\\tTotal time: {te - t0}\")\n", " ts = te" ], "metadata": { @@ -704,30 +818,35 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 56, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Adam\n", - "loss: -7.577690877449574\tprob: 0.432590481525006\tbit strings: ['01010101', '10101010']\n", + "loss: -5.837558827215271\tprob: 0.318607790021735\tbit strings: ['10101010']\n", "\n", "BO\n", - "loss: -5.52446757529149\tprob: 0.17464402602528795\tbit strings: ['10101010']\n", + "loss: -6.876287191047742\tprob: 0.3434109359024678\tbit strings: ['10101010']\n", "\n", "TuRBO\n", - "loss: -7.743190336435761\tprob: 0.4689543236081881\tbit strings: ['10101010']\n", + "loss: -6.8708058821631575\tprob: 0.3339171040448526\tbit strings: ['10101010']\n", "\n", "DARBO\n", - "loss: -6.011992874299757\tprob: 0.23617910579498852\tbit strings: ['01010101']\n" + "loss: -7.000515157123274\tprob: 0.36778546095898973\tbit strings: ['01010101']\n" ] } ], "source": [ - "params_bo = jnp.asarray(X_bo_best.ravel())\n", - "params_turbo = jnp.asarray(turbo_opt.inverse_transform(X_turbo_best).ravel())\n", - "params_darbo = jnp.asarray(darbo_opt.inverse_transform(X_darbo_best).ravel())\n", + "params_bo = jnp.asarray(bo_opt.best_dict[\"X\"])\n", + "params_turbo = jnp.asarray(turbo_opt.inverse_transform(turbo_opt.best_dict[\"X\"]))\n", + "params_darbo = jnp.asarray(\n", + " darbo_opt.inverse_transform(\n", + " darbo_opt.best_dict[\"X\"], mode=darbo_opt.best_dict[\"mode\"]\n", + " )\n", + ")\n", + "\n", "\n", "# find the states with max probabilities\n", "def find_max(params):\n", @@ -738,29 +857,30 @@ " index = np.where(probs == max_prob)[0]\n", " states = []\n", " for i in index:\n", - " states.append(f'{bin(i)[2:]:0>{graph.number_of_nodes()}}')\n", + " states.append(f\"{bin(i)[2:]:0>{graph.number_of_nodes()}}\")\n", " return loss, max_prob, states\n", "\n", + "\n", "loss, prob, states = find_max(params)\n", "loss_bo, prob_bo, states_bo = find_max(params_bo)\n", "loss_turbo, prob_turbo, states_turbo = find_max(params_turbo)\n", "loss_darbo, prob_darbo, states_darbo = find_max(params_darbo)\n", - "print(f'Adam\\nloss: {loss}\\tprob: {prob}\\tbit strings: {states}\\n')\n", - "print(f'BO\\nloss: {loss_bo}\\tprob: {prob_bo}\\tbit strings: {states_bo}\\n')\n", - "print(f'TuRBO\\nloss: {loss_turbo}\\tprob: {prob_turbo}\\tbit strings: {states_turbo}\\n')\n", - "print(f'DARBO\\nloss: {loss_darbo}\\tprob: {prob_darbo}\\tbit strings: {states_darbo}')" + "print(f\"Adam\\nloss: {loss}\\tprob: {prob}\\tbit strings: {states}\\n\")\n", + "print(f\"BO\\nloss: {loss_bo}\\tprob: {prob_bo}\\tbit strings: {states_bo}\\n\")\n", + "print(f\"TuRBO\\nloss: {loss_turbo}\\tprob: {prob_turbo}\\tbit strings: {states_turbo}\\n\")\n", + "print(f\"DARBO\\nloss: {loss_darbo}\\tprob: {prob_darbo}\\tbit strings: {states_darbo}\")" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T09:01:36.583670800Z", - "start_time": "2023-07-14T09:01:34.061688200Z" + "end_time": "2023-07-15T05:48:09.478379400Z", + "start_time": "2023-07-15T05:48:05.566717500Z" } } }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 57, "outputs": [ { "name": "stdout", @@ -795,8 +915,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-07-14T09:01:36.583670800Z", - "start_time": "2023-07-14T09:01:36.583447800Z" + "end_time": "2023-07-15T05:48:09.478379400Z", + "start_time": "2023-07-15T05:48:09.477371900Z" } } } From a2249f928442adf51713e438eef24d575ab7c9e0 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sat, 15 Jul 2023 15:58:45 +0800 Subject: [PATCH 557/725] update qaoa_bo.ipynb --- docs/source/tutorials/qaoa_bo.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/tutorials/qaoa_bo.ipynb b/docs/source/tutorials/qaoa_bo.ipynb index e8fe334b..8ad88ad7 100644 --- a/docs/source/tutorials/qaoa_bo.ipynb +++ b/docs/source/tutorials/qaoa_bo.ipynb @@ -412,7 +412,7 @@ " ):\n", " super(TuRBO_optimizer, self).__init__(eval_func, device=device)\n", " self.batch_size = (\n", - " 1 # There is bug in odbo.run_exp.turbo_design, batch_size can only be 1\n", + " 1 # There is a bug in odbo.run_exp.turbo_design, batch_size can only be 1 right now.\n", " )\n", " self.tr_length = tr_length\n", " self.state = odbo.turbo.TurboState(\n", From e2bcf3e301de5fd39c7e08afe78db87ae9e19831 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sat, 15 Jul 2023 16:42:29 +0800 Subject: [PATCH 558/725] update qaoa_bo.ipynb --- docs/source/tutorials/qaoa_bo.ipynb | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/docs/source/tutorials/qaoa_bo.ipynb b/docs/source/tutorials/qaoa_bo.ipynb index 8ad88ad7..240bf374 100644 --- a/docs/source/tutorials/qaoa_bo.ipynb +++ b/docs/source/tutorials/qaoa_bo.ipynb @@ -411,9 +411,7 @@ " self, eval_func, num_params, tr_length, failure_tolerance, device=\"cpu\"\n", " ):\n", " super(TuRBO_optimizer, self).__init__(eval_func, device=device)\n", - " self.batch_size = (\n", - " 1 # There is a bug in odbo.run_exp.turbo_design, batch_size can only be 1 right now.\n", - " )\n", + " self.batch_size = 1 # There is a bug in odbo.run_exp.turbo_design, batch_size can only be 1 right now.\n", " self.tr_length = tr_length\n", " self.state = odbo.turbo.TurboState(\n", " dim=num_params,\n", @@ -641,10 +639,10 @@ " # check if we need to switch the searching parameter range.\n", " if self.switch_counter >= frequency:\n", " if self.mode:\n", - " X = (X * 2).clamp(0, 1)\n", + " X = X * 2 - 0.5\n", " self.mode = False # small\n", " else:\n", - " X = (X / 2).clamp(0, 1)\n", + " X = X / 2 + 0.25\n", " self.mode = True # large\n", " self.switch_counter = 0\n", "\n", From 24818b11df6dbde7b30dc25cef43560af8d09d87 Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Sat, 15 Jul 2023 11:04:03 +0100 Subject: [PATCH 559/725] reviewed V1.3 --- tensorcircuit/applications/finance/portfolio.py | 2 +- tensorcircuit/applications/optimization.py | 8 ++++---- tensorcircuit/templates/ansatz.py | 16 ++++++++-------- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/tensorcircuit/applications/finance/portfolio.py b/tensorcircuit/applications/finance/portfolio.py index 506deae5..9befb2f0 100644 --- a/tensorcircuit/applications/finance/portfolio.py +++ b/tensorcircuit/applications/finance/portfolio.py @@ -64,7 +64,7 @@ def __init__(self, data: Tensor): for i in range(self.n_stocks): each_stock = [] for j in range(self.n_days - 1): - each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j + 1]) + each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j]) self.daily_change.append(each_stock) def get_return(self, decimals: int = 5) -> List[float]: diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index b80a6d6c..df41428a 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -62,7 +62,7 @@ def QAOA_loss( params: List[float], full_coupling: bool = False, mixer: str = "X", -) -> float: +) -> Any: """ computes the loss function for the Quantum Approximate Optimization Algorithm (QAOA) applied to the Ising model. @@ -92,9 +92,9 @@ def QUBO_QAOA( init_params: Optional[List[float]] = None, mixer: str = "X", learning_rate: float = 1e-2, - callback: Optional[Callable] = None, + callback: Optional[Optional[Callable[[List[float], float], None]]] = None, full_coupling: bool = False, -) -> List[float]: +) -> Array: """ Performs the QAOA on a given QUBO problem. Adam optimizer from TensorFlow is used. @@ -299,7 +299,7 @@ def QUBO_QAOA_cvar( nlayers: int, alpha: int, nsamples: int = 1000, - callback: Optional[callable] = None, + callback: Optional[Callable[[List[float], float], None]] = None, fake: bool = False, maxiter: int = 1000, init_params: Optional[Tuple[float,]] = None, diff --git a/tensorcircuit/templates/ansatz.py b/tensorcircuit/templates/ansatz.py index 4c8bb140..03fab788 100644 --- a/tensorcircuit/templates/ansatz.py +++ b/tensorcircuit/templates/ansatz.py @@ -30,9 +30,9 @@ def QAOA_ansatz_for_Ising( :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "XY" and "ZZ". """ nqubits = len(pauli_terms[0]) - c = Circ(nqubits) + c: Any = Circ(nqubits) for i in range(nqubits): - c.H(i) # Apply Hadamard gate to each qubit + c.h(i) # Apply Hadamard gate to each qubit for j in range(nlayers): # cost terms @@ -42,10 +42,10 @@ def QAOA_ansatz_for_Ising( if term[l] == 1: index_of_ones.append(l) if len(index_of_ones) == 1: - c.RZ(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) + c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) # Apply Rz gate with angle determined by weight and current parameter value elif len(index_of_ones) == 2: - c.RZZ( + c.rzz( index_of_ones[0], index_of_ones[1], theta=weights[k] * params[2 * j], @@ -70,20 +70,20 @@ def QAOA_ansatz_for_Ising( # standard mixer if mixer == "X": for i in range(nqubits): - c.RX( + c.rx( i, theta=params[2 * j + 1] ) # Apply Rx gate with angle determined by current parameter value # XY mixer elif mixer == "XY": for [q0, q1] in pairs: - c.RXX(q0, q1, theta=params[2 * j + 1]) - c.RYY(q0, q1, theta=params[2 * j + 1]) + c.rxx(q0, q1, theta=params[2 * j + 1]) + c.ryy(q0, q1, theta=params[2 * j + 1]) # ZZ mixer elif mixer == "ZZ": for [q0, q1] in pairs: - c.RZZ(q0, q1, theta=params[2 * j + 1]) + c.rzz(q0, q1, theta=params[2 * j + 1]) else: raise ValueError("Invalid mixer type.") From d130ec4ce7a6a80e13b5e5492801a5e9fd9d66da Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Sat, 15 Jul 2023 16:29:26 +0100 Subject: [PATCH 560/725] reviewed V1.4 --- .../applications/finance/portfolio.py | 4 ++-- tensorcircuit/applications/optimization.py | 21 +++++++++++-------- tensorcircuit/templates/ansatz.py | 3 ++- tensorcircuit/templates/blocks.py | 2 +- tensorcircuit/templates/conversions.py | 2 -- 5 files changed, 17 insertions(+), 15 deletions(-) diff --git a/tensorcircuit/applications/finance/portfolio.py b/tensorcircuit/applications/finance/portfolio.py index 9befb2f0..06d7c0b9 100644 --- a/tensorcircuit/applications/finance/portfolio.py +++ b/tensorcircuit/applications/finance/portfolio.py @@ -67,7 +67,7 @@ def __init__(self, data: Tensor): each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j]) self.daily_change.append(each_stock) - def get_return(self, decimals: int = 5) -> List[float]: + def get_return(self, decimals: int = 5) -> Any: """ Calculates the annualized return (mu). @@ -129,7 +129,7 @@ def get_penalty( # Determine the penalty factor mark = False penalty = 0 # Initial value - while mark == False: + while mark is False: R = np.diag(ret) S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( np.ones(self.n_stocks) diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index df41428a..b59bb1e6 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -103,8 +103,10 @@ def QUBO_QAOA( :param nlayers: The number of layers (depth) in the QAOA ansatz. :param iterations: The number of iterations to run the optimization. :param vvag (optional): A flag indicating whether to use vectorized variational adjoint gradient. Default is False. - :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. Default is 10. - :param init_params (optional): The initial parameters for the ansatz circuit. Default is None, which initializes the parameters randomly. + :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. + Default is 10. + :param init_params (optional): The initial parameters for the ansatz circuit. + Default is None, which initializes the parameters randomly. :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "XY" and "ZZ". :param learning_rate (optional): The learning rate for the Adam optimizer. Default is 1e-2. :param callback (optional): A callback function that is executed during each iteration. Default is None. @@ -115,7 +117,7 @@ def QUBO_QAOA( raise ValueError("`QUBO_QAOA` is designed for tensorflow backend.") # Check if the backend is set to TensorFlow. Raise an error if it is not. - pauli_terms, weights, offset = QUBO_to_Ising(Q) + pauli_terms, weights, _ = QUBO_to_Ising(Q) loss_val_grad = backend.value_and_grad( partial( @@ -132,7 +134,7 @@ def QUBO_QAOA( if init_params is None: params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) - if vvag == True: + if vvag is True: loss_val_grad = backend.vvag(loss_val_grad, argnums=0, vectorized_argnums=0) params = backend.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) # If init_params is not provided, initialize the parameters randomly. @@ -147,7 +149,7 @@ def QUBO_QAOA( opt = backend.optimizer(tf.keras.optimizers.Adam(learning_rate)) # Define the optimizer (Adam optimizer) with the specified learning rate. - for i in range(iterations): + for _ in range(iterations): loss, grads = loss_val_grad(params) # Calculate the loss and gradients using the loss_val_grad_jit function. @@ -278,15 +280,16 @@ def cvar_loss( :param params: The parameters for the QAOA ansatz circuit. :return: The calculated CVaR loss. """ - pauli_terms, weights, offset = QUBO_to_Ising(Q) + + pauli_terms, weights, _ = QUBO_to_Ising(Q) c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights) # Generate the QAOA ansatz circuit for the given parameters. - if fake == False: + if fake is False: return cvar_from_circuit(c, nsamples, Q, alpha) # Calculate CVaR using circuit-based measurement results. - elif fake == True: + elif fake is True: return cvar_from_expectation(c, Q, alpha) # Calculate CVaR using expectation values of the circuit. else: @@ -319,7 +322,7 @@ def QUBO_QAOA_cvar( """ loss = partial(cvar_loss, nlayers, Q, nsamples, alpha, fake) - f_scipy = scipy_interface(loss, shape=[2 * nlayers], jit=False, gradient=False) + f_scipy = scipy_interface(loss, shape=(2 * nlayers,), jit=False, gradient=False) if init_params is None: params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) diff --git a/tensorcircuit/templates/ansatz.py b/tensorcircuit/templates/ansatz.py index 03fab788..e24b1ca3 100644 --- a/tensorcircuit/templates/ansatz.py +++ b/tensorcircuit/templates/ansatz.py @@ -50,7 +50,8 @@ def QAOA_ansatz_for_Ising( index_of_ones[1], theta=weights[k] * params[2 * j], ) - # Apply exp1 gate with a custom unitary (zz_matrix) and angle determined by weight and current parameter value + # Apply exp1 gate with a custom unitary (zz_matrix) + # and angle determined by weight and current parameter value else: raise ValueError("Invalid number of Z terms") diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 3159d5a0..eacc2b42 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -5,7 +5,7 @@ # pylint: disable=invalid-name from functools import wraps -from typing import Any, Callable, Optional, Sequence, Tuple, List +from typing import Any, Callable, Optional, Sequence, Tuple import numpy as np diff --git a/tensorcircuit/templates/conversions.py b/tensorcircuit/templates/conversions.py index be14ed1e..d848e405 100644 --- a/tensorcircuit/templates/conversions.py +++ b/tensorcircuit/templates/conversions.py @@ -6,8 +6,6 @@ import numpy as np -from ..cons import backend - Tensor = Any Array = Any From 49b7661d12ebb50ad8fbb56710b9b64463a016e6 Mon Sep 17 00:00:00 2001 From: MarkSong535 Date: Sun, 16 Jul 2023 00:04:08 +0800 Subject: [PATCH 561/725] update gcn load method and data struc --- docs/source/tutorials/german.data-numeric | 1000 -------------------- docs/source/tutorials/sklearn_svc.ipynb | 120 ++- docs/source/tutorials/sklearn_svc_cn.ipynb | 108 ++- 3 files changed, 112 insertions(+), 1116 deletions(-) delete mode 100644 docs/source/tutorials/german.data-numeric diff --git a/docs/source/tutorials/german.data-numeric b/docs/source/tutorials/german.data-numeric deleted file mode 100644 index 723307e1..00000000 --- a/docs/source/tutorials/german.data-numeric +++ /dev/null @@ -1,1000 +0,0 @@ - 1 6 4 12 5 5 3 4 1 67 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 48 2 60 1 3 2 2 1 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 12 4 21 1 4 3 3 1 49 3 1 2 1 1 0 0 1 0 0 1 0 1 0 1 - 1 42 2 79 1 4 3 4 2 45 3 1 2 1 1 0 0 0 0 0 0 0 0 1 1 - 1 24 3 49 1 3 3 4 4 53 3 2 2 1 1 1 0 1 0 0 0 0 0 1 2 - 4 36 2 91 5 3 3 4 4 35 3 1 2 2 1 0 0 1 0 0 0 0 1 0 1 - 4 24 2 28 3 5 3 4 2 53 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 36 2 69 1 3 3 2 3 35 3 1 1 2 1 0 1 1 0 1 0 0 0 0 1 - 4 12 2 31 4 4 1 4 1 61 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 30 4 52 1 1 4 2 3 28 3 2 1 1 1 1 0 1 0 0 1 0 0 0 2 - 2 12 2 13 1 2 2 1 3 25 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 - 1 48 2 43 1 2 2 4 2 24 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 2 12 2 16 1 3 2 1 3 22 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 24 4 12 1 5 3 4 3 60 3 2 1 1 1 1 0 1 0 0 1 0 1 0 2 - 1 15 2 14 1 3 2 4 3 28 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 - 1 24 2 13 2 3 2 2 3 32 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 4 24 4 24 5 5 3 4 2 53 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 30 0 81 5 2 3 3 3 25 1 3 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 24 2 126 1 5 2 2 4 44 3 1 1 2 1 0 1 1 0 0 0 0 0 0 2 - 4 24 2 34 3 5 3 2 3 31 3 1 2 2 1 0 0 1 0 0 1 0 0 1 1 - 4 9 4 21 1 3 3 4 3 48 3 3 1 2 1 1 0 1 0 0 1 0 0 1 1 - 1 6 2 26 3 3 3 3 1 44 3 1 2 1 1 0 0 1 0 1 0 0 0 1 1 - 1 10 4 22 1 2 3 3 1 48 3 2 2 1 2 1 0 1 0 1 0 0 1 0 1 - 2 12 4 18 2 2 3 4 2 44 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 - 4 10 4 21 5 3 4 1 3 26 3 2 1 1 2 0 0 1 0 0 1 0 0 1 1 - 1 6 2 14 1 3 3 2 1 36 1 1 1 2 1 0 0 1 0 0 1 0 1 0 1 - 4 6 0 4 1 5 4 4 3 39 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 3 12 1 4 4 3 2 3 1 42 3 2 1 1 1 0 0 1 0 1 0 0 0 1 1 - 2 7 2 24 1 3 3 2 1 34 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 - 1 60 3 68 1 5 3 4 4 63 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 - 2 18 2 19 4 2 4 3 1 36 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 24 2 40 1 3 3 2 3 27 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 18 2 59 2 3 3 2 3 30 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 12 4 13 5 5 3 4 4 57 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 3 12 2 15 1 2 2 1 2 33 1 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 2 45 4 47 1 2 3 2 2 25 3 2 1 1 1 0 0 1 0 0 1 0 1 0 2 - 4 48 4 61 1 3 3 3 4 31 1 1 1 2 1 0 0 1 0 0 0 0 0 1 1 - 3 18 2 21 1 3 3 2 1 37 2 1 1 1 1 0 0 0 1 0 1 0 0 1 2 - 3 10 2 12 1 3 3 2 3 37 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 9 2 5 1 3 3 3 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 30 2 23 3 5 3 2 3 30 1 1 1 1 1 0 0 1 0 0 1 0 0 0 1 - 2 12 2 12 3 3 1 1 3 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 18 3 62 1 3 3 4 1 44 3 1 2 2 1 0 0 1 0 0 1 0 1 0 1 - 1 30 4 62 2 4 4 4 3 24 3 2 1 1 1 0 1 1 0 1 0 0 0 1 1 - 1 48 4 61 1 5 2 4 4 58 2 2 1 1 1 0 1 1 0 0 0 0 1 0 2 - 4 11 4 14 1 2 2 4 3 35 3 2 1 1 1 1 0 1 0 0 1 0 0 0 1 - 4 36 2 23 3 5 3 4 3 39 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 6 2 14 3 1 2 2 2 23 3 1 1 2 1 0 1 1 0 1 0 1 0 0 1 - 4 11 4 72 1 3 3 4 2 39 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 - 4 12 2 21 2 3 2 2 1 28 3 1 1 1 1 0 0 0 1 0 1 0 0 1 1 - 2 24 3 23 5 2 3 2 2 29 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 27 3 60 1 5 3 2 3 30 3 2 1 2 1 0 1 1 0 0 1 0 0 0 1 - 4 12 2 13 1 3 3 2 3 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 34 5 3 3 1 2 31 3 1 1 2 1 0 1 1 0 0 1 0 0 1 1 - 2 36 3 22 1 5 3 4 4 57 1 2 1 2 1 1 0 1 0 0 0 0 0 1 2 - 4 6 1 8 5 3 3 2 1 26 2 1 2 1 1 1 0 0 0 0 1 0 1 0 1 - 2 12 2 65 5 1 3 1 4 52 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 36 4 96 1 3 2 2 3 31 2 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 3 18 2 20 1 5 2 2 3 23 3 1 1 1 1 1 0 1 0 0 1 0 0 0 1 - 1 36 4 62 1 2 2 4 4 23 3 2 1 2 1 0 0 0 1 1 0 0 1 0 2 - 2 9 2 14 1 3 4 1 1 27 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 15 4 15 5 5 3 4 1 50 3 2 1 2 1 0 0 0 0 0 1 0 0 1 1 - 2 36 0 20 1 5 3 4 4 61 3 1 1 2 1 0 0 1 0 0 0 0 0 0 2 - 2 48 0 144 1 3 3 2 3 25 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 24 2 32 1 2 2 4 2 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 27 2 52 5 5 3 4 2 48 3 4 2 2 1 0 0 1 0 0 1 0 0 1 1 - 4 12 2 22 1 2 2 2 3 29 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 12 2 10 4 3 4 1 1 22 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 36 2 18 1 3 3 4 4 37 2 1 1 2 1 0 0 1 0 0 0 0 0 1 2 - 4 36 2 24 5 3 2 4 3 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 36 2 81 1 3 2 2 2 30 1 1 1 1 1 0 1 1 0 0 1 0 0 1 1 - 4 7 4 7 5 5 3 2 2 46 3 2 1 2 1 0 0 1 0 1 0 0 1 0 1 - 1 8 4 12 1 5 3 4 4 51 1 2 2 2 1 0 0 1 0 0 0 0 0 0 1 - 2 42 4 60 1 4 2 1 1 41 1 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 36 2 20 5 5 3 4 4 40 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 1 12 4 15 1 5 3 4 4 66 3 2 1 1 1 0 1 1 0 0 0 0 0 0 1 - 1 42 2 40 1 2 3 3 3 34 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 11 3 48 1 4 3 4 2 51 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 54 0 94 5 3 3 2 2 39 3 1 2 1 1 0 1 1 0 0 1 0 1 0 1 - 2 30 2 38 1 2 4 1 2 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 59 5 2 2 1 3 44 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 15 2 12 3 5 3 3 2 47 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 16 2 3 2 4 2 24 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 1 24 2 18 1 5 2 4 1 58 3 1 1 2 1 0 0 0 0 0 1 0 1 0 1 - 1 10 2 23 1 5 3 4 1 52 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 12 4 14 1 3 2 2 1 29 3 2 1 2 1 0 0 0 0 0 1 0 0 0 1 - 2 18 4 13 1 2 2 1 2 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 36 2 126 2 3 3 4 4 47 3 1 2 2 1 0 0 1 0 0 0 0 0 1 2 - 1 18 2 22 2 4 3 3 3 30 3 1 2 2 1 1 0 1 0 0 1 0 0 0 1 - 1 12 0 11 1 4 3 3 1 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 12 4 6 1 5 3 4 1 56 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 4 14 1 5 3 3 1 54 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 - 4 12 4 8 5 5 2 3 2 33 1 1 2 1 1 0 0 1 0 0 1 0 1 0 2 - 3 24 4 36 5 5 3 4 4 20 3 2 1 1 1 0 0 0 1 1 0 0 0 1 1 - 2 12 2 13 4 5 3 4 1 54 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 2 54 0 159 1 2 3 4 4 58 3 1 1 2 1 0 0 1 0 1 0 0 0 1 2 - 4 12 4 20 5 4 2 2 3 61 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 18 2 26 2 3 3 4 3 34 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 36 4 23 1 5 3 4 1 36 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 20 3 71 5 4 3 4 2 36 1 2 2 2 1 0 1 1 0 1 0 0 0 0 1 - 4 24 2 15 2 5 4 4 1 41 3 1 1 1 1 1 0 1 0 1 0 0 1 0 1 - 2 36 2 23 1 4 3 4 3 24 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 4 6 3 9 1 3 2 2 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 9 4 19 1 4 3 3 3 35 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 4 12 2 24 5 2 4 4 3 26 3 1 1 2 1 0 1 1 0 1 0 0 0 1 1 - 2 24 4 119 1 3 3 3 3 39 3 2 2 2 1 0 0 0 1 0 1 0 0 0 2 - 4 18 1 65 1 5 3 4 4 39 1 2 2 2 1 1 0 1 0 0 1 0 0 0 2 - 2 12 2 61 1 4 3 2 3 32 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 24 2 77 5 2 2 2 2 30 3 1 1 2 2 0 0 1 0 0 1 0 0 1 1 - 2 14 2 14 3 5 4 2 1 35 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 6 3 14 2 5 1 2 3 31 1 2 2 1 1 0 0 1 0 0 1 0 0 1 1 - 3 15 2 4 1 2 2 4 2 23 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 2 18 2 63 1 4 3 3 1 28 3 1 1 1 1 1 0 1 0 1 0 0 1 0 1 - 4 36 4 79 1 3 2 2 1 25 2 2 1 2 1 1 0 1 0 0 1 0 0 1 2 - 1 12 2 17 3 5 4 1 1 35 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 48 4 36 5 5 3 1 1 47 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 42 2 72 5 4 2 3 3 30 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 1 10 4 21 5 2 2 3 1 27 3 2 1 1 2 0 0 0 1 1 0 0 0 1 1 - 1 33 4 43 3 3 2 4 3 23 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 12 4 24 3 4 1 3 3 36 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 - 1 21 2 18 1 3 2 2 1 25 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 24 4 39 1 5 2 2 3 41 3 2 1 2 1 0 1 1 0 1 0 0 0 0 1 - 4 12 2 18 1 3 3 2 1 24 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 3 10 4 8 1 5 3 4 4 63 3 2 1 2 1 1 0 1 0 0 0 0 0 1 1 - 2 18 2 19 5 2 2 3 1 27 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 1 12 4 21 1 3 3 2 2 30 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 12 2 7 1 3 4 2 1 40 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 12 2 6 1 3 3 2 3 30 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 12 4 19 1 1 3 2 3 34 3 2 1 2 1 0 1 1 0 0 1 0 0 0 1 - 1 12 4 35 1 3 2 2 1 29 3 2 1 1 1 1 0 0 1 0 1 0 0 1 2 - 2 48 2 85 5 4 2 2 3 24 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 36 3 69 1 3 3 3 2 29 2 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 15 2 27 1 2 3 3 2 27 1 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 18 2 20 1 3 3 4 4 47 1 2 1 1 1 0 0 1 0 0 0 0 0 1 1 - 4 60 2 101 2 4 2 4 1 21 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 12 4 12 5 5 2 2 1 38 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 27 3 86 4 3 3 2 3 27 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 - 2 12 2 8 3 3 3 3 1 66 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 2 15 4 27 5 4 3 2 1 35 1 3 1 2 1 0 0 0 0 0 1 0 0 1 1 - 3 12 2 19 1 3 2 2 3 44 3 1 1 2 1 0 0 1 0 1 0 0 1 0 1 - 3 6 2 7 4 2 4 2 1 27 3 1 1 1 2 1 0 1 0 0 1 1 0 0 1 - 2 36 2 48 1 2 2 1 4 30 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 1 27 2 34 1 3 3 2 3 27 3 1 1 1 1 0 0 1 0 0 1 0 0 0 1 - 1 18 2 25 1 3 3 2 3 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 21 4 23 1 2 2 4 2 23 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 48 1 36 2 4 3 2 3 30 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 6 4 9 1 5 2 4 4 39 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 12 4 7 2 4 2 3 3 51 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 1 36 4 54 1 3 3 2 2 28 3 2 1 1 1 0 0 0 0 0 1 0 0 1 1 - 4 18 4 16 4 5 3 4 3 46 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 6 2 13 2 5 3 4 4 42 1 1 2 2 1 0 0 1 0 0 0 0 0 1 1 - 4 10 2 19 1 3 3 4 2 38 3 1 1 2 2 0 0 1 0 0 1 0 0 1 1 - 3 36 2 58 1 3 3 1 3 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 24 4 78 4 5 2 4 4 29 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 - 2 24 3 70 2 4 3 4 3 36 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 - 1 12 2 13 1 3 2 4 3 20 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 1 9 4 13 2 5 3 4 1 48 3 2 2 1 2 0 0 0 0 0 1 0 0 1 1 - 1 12 1 3 1 5 4 1 3 45 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 24 2 35 2 4 3 3 3 38 1 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 6 4 19 5 3 3 2 1 34 3 2 2 1 1 0 0 1 0 0 1 0 1 0 1 - 4 24 4 29 2 5 3 4 1 36 3 1 2 2 1 0 0 1 0 0 1 0 0 1 1 - 4 18 4 11 1 2 2 1 2 30 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 15 2 13 3 4 3 3 2 36 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 10 2 73 1 1 3 4 4 70 1 1 1 2 1 1 0 1 0 0 0 0 0 0 1 - 4 36 2 9 3 5 3 4 2 36 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 6 2 30 3 3 3 2 3 32 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 18 2 11 1 1 2 2 3 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 11 2 16 4 2 2 1 1 20 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 40 1 4 2 4 2 25 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 2 24 4 19 1 5 1 4 1 31 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 - 1 15 0 10 1 5 3 3 3 33 3 2 2 1 1 1 0 1 0 1 0 0 0 1 2 - 4 12 2 8 1 3 2 1 1 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 24 3 21 1 1 2 2 2 34 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 2 8 2 14 1 3 3 2 1 33 3 1 1 1 2 0 0 0 0 0 1 0 0 1 1 - 1 21 3 34 1 2 3 1 2 26 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 30 1 75 5 1 2 1 1 53 1 1 1 2 1 0 1 1 0 0 1 0 0 0 2 - 1 12 2 26 1 3 1 1 3 42 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 6 4 3 3 5 3 4 3 52 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 12 2 20 1 4 3 2 3 31 3 2 2 2 1 0 0 1 0 1 0 0 0 0 1 - 1 21 4 6 1 5 3 4 1 65 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 36 3 96 1 2 1 1 3 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 36 3 45 1 3 1 2 1 30 2 2 1 2 1 0 0 1 0 0 1 0 0 0 2 - 1 21 1 16 5 3 3 2 2 40 3 2 2 1 1 1 0 1 0 0 1 0 1 0 2 - 4 24 4 38 4 3 3 4 1 50 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 18 4 9 1 5 3 4 3 36 1 1 2 2 1 1 0 1 0 0 1 0 0 1 2 - 4 15 4 14 1 3 3 2 2 31 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 9 1 51 1 5 2 4 4 74 1 1 2 2 1 0 1 1 0 0 0 0 0 0 2 - 2 16 4 12 1 1 3 3 3 68 3 3 1 2 1 1 0 1 0 0 0 1 0 0 1 - 1 12 2 7 2 4 4 1 2 20 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 18 0 32 1 3 2 4 3 33 1 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 46 4 3 3 3 2 54 3 3 1 2 1 0 0 1 0 0 1 0 0 0 2 - 2 48 0 38 2 4 3 4 4 34 3 1 2 1 1 0 0 1 0 0 0 0 1 0 2 - 2 27 2 39 1 3 3 2 3 36 3 1 2 2 1 0 0 1 0 0 1 0 0 1 2 - 4 6 2 21 1 4 4 2 1 29 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 2 45 2 30 2 3 3 4 2 21 3 1 1 1 1 0 0 0 0 1 0 0 0 1 2 - 2 9 4 15 1 5 2 3 3 34 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 6 4 14 1 3 2 1 3 28 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 12 2 10 2 2 2 4 3 27 1 4 1 1 1 0 0 1 0 1 0 0 0 1 2 - 2 24 2 28 5 5 3 4 4 36 1 1 1 2 1 0 1 1 0 0 0 0 0 1 1 - 2 18 3 43 1 5 1 3 4 40 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 9 4 9 3 5 3 2 3 52 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 12 2 12 1 3 4 3 1 27 3 1 1 1 1 1 0 1 0 0 1 0 1 0 1 - 4 27 3 51 1 4 3 4 3 26 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 2 9 1 4 4 4 2 21 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 4 12 4 15 1 5 3 1 1 38 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 - 1 30 4 106 1 5 3 4 4 38 3 3 2 2 1 0 1 1 0 0 0 0 0 0 1 - 4 12 4 19 1 5 3 4 1 43 3 3 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 12 4 14 1 4 3 3 2 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 24 2 66 1 3 4 2 3 21 2 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 12 2 14 4 4 3 2 2 55 3 1 1 1 2 0 1 1 0 0 1 0 0 1 1 - 4 9 4 31 5 3 3 2 1 33 3 2 2 1 1 0 0 1 0 0 1 0 0 1 1 - 4 36 2 38 5 5 2 4 1 45 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 - 1 27 0 53 1 1 3 4 2 50 2 2 1 2 1 0 0 1 0 0 1 0 0 1 2 - 3 30 3 19 1 5 3 4 1 66 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 36 4 33 5 5 3 2 3 51 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 6 4 9 5 4 2 3 2 39 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 18 0 31 1 4 3 1 2 31 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 3 36 2 39 1 3 3 2 1 23 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 24 2 30 1 3 1 2 1 24 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 4 10 2 14 1 3 2 4 3 64 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 2 12 2 6 1 2 4 1 1 26 1 1 1 1 1 0 0 0 0 0 1 0 1 0 1 - 1 12 2 12 5 3 2 4 2 23 1 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 4 12 2 7 1 3 3 2 1 30 1 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 3 30 5 3 3 4 1 32 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 - 4 15 2 47 1 3 3 2 3 30 3 1 1 2 1 0 1 1 0 0 1 0 0 1 1 - 4 36 0 26 1 3 3 2 3 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 48 2 110 4 4 3 2 4 27 1 2 1 2 1 0 0 0 1 0 1 0 0 1 2 - 1 12 2 79 1 5 3 4 4 53 3 1 1 2 1 0 0 1 0 0 0 0 0 0 2 - 4 9 2 15 1 4 3 2 3 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 24 2 31 1 2 3 1 4 22 1 1 1 1 1 0 0 1 0 0 0 0 0 1 1 - 3 36 2 42 1 3 3 2 3 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 9 2 25 3 5 3 4 4 51 3 1 1 1 1 1 0 1 0 0 0 0 1 0 1 - 4 12 2 21 2 4 3 1 4 35 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 18 2 9 1 3 4 2 1 25 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 - 4 4 4 15 1 4 3 1 1 42 3 3 2 1 1 0 0 1 0 0 1 0 1 0 1 - 1 24 2 18 1 1 3 2 3 30 2 1 2 1 1 0 0 1 0 0 1 0 0 0 2 - 2 6 2 146 5 1 3 2 2 23 3 1 1 2 1 1 0 1 0 0 1 1 0 0 2 - 2 21 2 28 2 5 1 2 3 61 1 2 1 1 1 0 0 1 0 1 0 0 1 0 2 - 4 12 4 13 1 3 2 2 2 35 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 30 2 25 1 5 3 3 2 39 3 1 2 1 1 0 0 0 0 0 1 0 0 1 1 - 1 24 2 9 5 5 2 2 3 29 1 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 6 2 16 1 4 3 2 2 51 3 1 2 1 1 0 0 1 0 0 1 0 0 1 1 - 1 48 0 46 1 5 3 4 4 24 3 2 2 1 1 0 1 1 0 0 0 0 0 1 2 - 4 12 4 12 1 3 2 2 1 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 12 1 34 3 3 2 3 1 35 3 1 2 1 1 0 0 1 0 0 1 0 1 0 1 - 4 24 2 13 1 4 3 1 1 25 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 12 4 7 1 5 3 4 1 52 3 3 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 6 0 12 2 3 3 1 4 35 1 1 1 1 2 1 0 1 0 1 0 0 0 1 1 - 3 24 2 19 1 3 3 2 1 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 4 1 1 2 4 1 22 3 1 1 1 1 0 0 0 1 1 0 0 0 1 2 - 1 6 4 7 4 4 2 4 1 39 3 2 1 2 1 1 0 1 0 0 1 0 1 0 1 - 3 12 2 23 1 3 2 2 3 46 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 30 2 22 1 3 2 2 4 24 1 1 1 1 1 1 0 0 0 0 1 0 0 1 2 - 4 24 3 42 2 3 3 3 2 35 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 9 2 20 5 4 3 1 3 24 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 60 3 74 5 3 3 1 1 27 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 24 4 27 1 3 3 2 1 35 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 12 1 21 1 3 1 1 4 29 3 1 1 1 1 0 0 1 0 0 0 0 0 1 2 - 4 15 2 38 2 2 2 4 3 23 3 1 1 2 1 0 1 1 0 0 1 0 0 1 1 - 4 11 4 12 2 1 2 4 1 57 3 3 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 12 2 17 1 3 3 2 1 27 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 24 2 16 1 5 2 4 3 55 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 18 4 53 1 5 3 4 4 36 3 3 1 2 1 1 0 1 0 0 0 0 0 0 1 - 4 12 4 27 1 5 2 4 4 57 1 3 1 1 1 0 0 1 0 0 0 0 1 0 1 - 4 10 4 12 1 5 3 4 1 32 3 2 2 1 2 1 0 1 0 0 1 0 1 0 1 - 2 15 2 8 1 5 3 3 3 37 3 1 2 1 1 0 0 1 0 0 1 0 0 1 2 - 4 36 4 63 5 5 3 4 1 36 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 15 1 2 2 3 3 38 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 14 2 90 1 5 1 4 2 45 3 1 1 2 2 1 0 1 0 0 1 0 0 0 2 - 4 24 2 10 5 5 3 2 3 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 27 5 4 3 3 2 32 3 1 1 1 2 1 0 1 0 0 1 0 0 1 1 - 4 12 4 14 3 4 2 4 3 37 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 2 48 1 122 5 1 3 4 4 36 3 1 1 2 1 1 0 0 1 0 0 0 0 0 1 - 2 48 2 31 1 4 3 4 1 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 30 2 120 1 2 1 1 4 34 3 1 1 2 1 0 0 1 0 0 1 0 1 0 2 - 4 9 2 27 1 3 3 2 1 32 3 1 2 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 4 24 1 3 2 2 3 26 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 2 13 5 5 1 4 2 49 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 - 4 6 2 46 1 2 2 4 2 32 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 24 2 19 2 3 3 4 3 29 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 - 4 15 4 34 4 5 3 4 4 23 3 2 1 2 1 0 1 1 0 1 0 0 0 1 1 - 4 12 2 16 1 3 3 2 1 50 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 3 18 1 14 5 4 3 4 3 49 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 15 4 15 5 5 3 4 2 63 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 24 4 39 2 2 1 2 3 37 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 1 47 2 107 1 2 2 1 1 35 3 1 1 2 1 1 0 1 0 0 1 0 1 0 1 - 1 48 2 48 1 4 3 3 2 26 3 1 2 1 1 0 1 1 0 0 1 0 0 1 1 - 2 48 3 76 2 1 3 4 4 31 3 1 1 2 1 0 0 1 0 0 0 0 0 0 1 - 2 12 2 11 1 3 2 4 1 49 3 2 1 2 1 0 0 0 0 0 1 0 0 1 1 - 1 24 3 10 1 2 4 4 1 48 2 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 12 2 11 1 3 4 2 1 26 3 1 1 2 2 0 0 1 0 0 1 0 0 1 1 - 2 36 2 94 1 2 4 4 3 28 3 1 1 2 1 0 1 1 0 1 0 0 0 0 2 - 1 24 4 64 1 5 2 4 4 44 3 2 2 2 1 0 1 1 0 0 0 0 0 0 1 - 3 42 4 48 1 5 3 4 4 56 3 1 1 1 1 0 1 1 0 0 0 0 0 1 1 - 4 48 4 76 5 5 1 2 3 46 1 2 2 1 1 0 0 1 0 0 1 0 0 0 1 - 2 48 2 100 1 2 2 2 3 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 12 2 47 5 2 2 4 3 20 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 - 4 10 2 13 5 5 3 2 2 45 3 1 1 1 2 1 0 0 1 0 1 0 1 0 1 - 4 18 2 25 1 3 3 4 1 43 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 21 4 27 4 4 3 2 3 32 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 6 2 7 1 1 2 4 1 54 3 1 1 2 1 1 0 1 0 0 1 1 0 0 1 - 2 36 0 38 1 3 2 1 3 42 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 3 24 4 13 5 4 3 2 1 37 1 2 2 1 1 1 0 1 0 0 1 0 1 0 2 - 1 10 4 10 1 4 3 3 2 49 3 2 1 2 1 1 0 0 1 0 1 0 0 1 1 - 4 48 4 101 3 3 3 2 4 44 1 1 1 1 1 1 0 1 0 0 0 0 0 1 2 - 4 6 2 15 4 3 1 2 1 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 30 2 48 5 4 2 4 2 24 2 1 1 1 1 0 1 1 0 1 0 0 1 0 1 - 1 12 2 7 2 2 4 3 4 33 3 1 1 2 1 0 0 1 0 0 1 0 1 0 2 - 2 8 2 12 1 3 2 4 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 9 2 3 1 3 4 4 1 22 3 1 1 1 1 1 0 1 0 1 0 0 1 0 1 - 2 48 2 54 5 1 3 4 4 40 1 1 1 2 1 0 0 1 0 0 0 1 0 0 1 - 4 24 2 55 2 3 3 1 3 25 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 3 24 2 37 1 2 2 4 3 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 12 2 7 1 4 4 3 3 25 1 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 3 4 2 15 5 2 3 2 1 29 3 1 2 1 2 1 0 1 0 0 1 0 1 0 1 - 1 36 1 27 1 5 3 4 3 31 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 12 2 7 1 3 3 3 2 38 3 1 2 1 1 0 0 0 0 0 1 0 1 0 1 - 2 24 2 44 5 3 2 4 2 48 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 - 4 12 4 7 1 3 3 2 3 32 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 15 3 36 1 5 2 4 2 27 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 30 4 42 1 1 4 2 3 28 3 2 1 1 1 1 0 1 0 0 1 0 0 0 2 - 1 24 2 19 1 2 1 3 2 32 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 24 2 29 1 4 3 1 4 34 3 1 1 2 1 0 1 1 0 0 0 0 0 0 1 - 1 18 2 27 4 3 3 2 3 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 4 10 1 3 2 3 1 36 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 8 4 34 1 4 3 4 1 39 3 2 1 1 2 1 0 1 0 0 1 0 1 0 1 - 4 12 4 58 5 5 3 4 2 49 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 4 24 2 15 4 4 2 3 3 34 3 1 2 2 1 1 0 1 0 0 1 0 0 1 1 - 3 36 2 45 1 5 3 2 3 31 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 6 2 11 1 5 3 4 3 28 3 1 2 1 1 0 0 1 0 0 1 0 0 1 1 - 1 24 4 66 1 1 3 4 4 75 3 2 1 2 1 0 1 1 0 0 0 0 0 0 1 - 4 18 4 19 2 3 2 2 1 30 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 60 2 74 2 2 2 2 2 24 3 1 1 1 1 1 0 1 0 0 1 0 0 0 2 - 4 48 4 116 2 3 2 4 3 24 1 2 1 1 1 0 1 1 0 1 0 0 1 0 2 - 1 24 0 41 1 5 3 4 4 23 1 2 2 1 1 0 0 1 0 1 0 0 0 1 2 - 1 6 4 34 1 3 1 4 1 44 3 1 1 2 1 0 0 1 0 1 0 0 0 0 2 - 2 13 2 21 1 2 2 4 2 23 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 - 1 15 2 13 5 3 2 2 3 24 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 1 24 2 42 1 3 3 4 2 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 10 2 15 1 3 1 2 3 31 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 24 4 57 1 2 2 4 4 24 3 2 1 2 1 0 0 1 0 0 0 0 0 1 1 - 1 21 2 36 1 4 2 4 3 26 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 2 18 2 32 3 2 4 3 1 25 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 2 18 2 44 1 5 3 1 1 33 1 1 1 2 1 0 0 0 1 0 1 0 0 0 1 - 3 10 2 39 1 2 3 1 2 37 3 1 2 1 1 1 0 0 0 0 1 0 1 0 1 - 4 15 4 15 1 3 2 2 3 43 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 13 4 9 1 2 3 4 1 23 3 2 1 1 1 0 0 0 0 0 1 0 0 1 1 - 2 24 2 38 3 1 2 4 4 23 3 1 1 1 1 0 0 1 0 1 0 1 0 0 1 - 4 6 3 17 2 3 3 2 1 34 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 9 4 11 4 5 3 3 4 32 3 2 2 1 1 0 0 1 0 0 0 0 0 1 2 - 4 9 2 12 1 2 2 4 1 23 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 2 9 2 10 1 3 2 2 3 29 3 1 1 1 2 0 0 1 0 0 1 0 0 1 2 - 4 18 4 32 5 1 3 4 4 38 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 1 12 0 62 1 3 3 2 2 28 3 2 1 2 1 0 0 1 0 1 0 0 0 1 2 - 4 10 2 7 3 5 3 4 4 46 3 1 1 2 1 0 0 1 0 0 0 0 0 1 1 - 2 24 2 12 1 2 3 2 1 23 2 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 4 12 4 23 5 5 3 4 1 49 3 1 1 2 1 0 0 0 1 0 1 0 0 1 1 - 4 36 3 45 1 3 3 2 3 26 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 12 2 8 1 3 4 2 1 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 30 2 24 1 4 2 4 1 23 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 2 18 2 12 5 3 3 4 4 61 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 - 3 12 2 34 5 5 3 3 3 37 3 1 1 1 1 0 0 1 0 0 1 0 0 0 1 - 3 12 3 22 1 3 2 2 3 36 2 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 6 2 18 1 3 4 2 2 21 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 1 18 2 25 1 1 3 1 3 25 3 1 1 1 1 0 0 1 0 0 1 1 0 0 2 - 4 12 2 15 1 4 3 4 3 36 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 18 4 38 1 4 3 1 3 27 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 - 1 18 2 36 1 2 2 4 3 22 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 1 36 2 34 1 5 3 2 3 42 3 1 2 1 1 0 0 1 0 0 1 0 0 1 2 - 2 18 2 30 1 4 2 4 1 40 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 4 36 2 31 5 3 3 4 1 36 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 18 4 61 1 5 3 4 3 33 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 10 4 21 1 2 2 3 1 23 3 2 1 1 1 0 0 1 0 1 0 0 0 1 1 - 4 60 4 138 5 5 3 4 4 63 1 1 1 2 1 1 0 1 0 0 0 0 0 0 1 - 2 60 1 148 2 5 2 4 4 60 1 2 1 2 1 0 0 1 0 0 0 0 0 0 2 - 1 48 1 77 1 4 2 4 3 37 3 1 1 1 1 0 0 0 0 1 0 0 0 1 2 - 4 18 3 23 1 1 4 3 1 34 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 7 3 8 5 5 3 4 4 36 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 - 2 36 2 143 1 5 3 2 4 57 3 1 1 2 1 1 0 1 0 0 0 0 0 0 2 - 4 6 4 4 2 3 2 4 3 52 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 - 1 20 2 22 5 4 3 4 3 39 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 18 2 130 1 1 2 4 4 38 3 1 1 2 1 0 1 1 0 0 0 0 0 0 2 - 4 22 2 13 5 4 2 4 2 25 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 - 3 12 2 13 1 2 3 1 1 26 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 30 3 43 2 3 3 2 2 26 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 18 4 22 1 3 2 1 3 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 11 5 2 2 2 1 21 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 2 18 4 74 1 1 3 4 2 40 2 2 1 2 1 0 0 1 0 0 1 0 0 0 1 - 2 15 4 23 3 3 3 4 3 27 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 9 2 14 1 4 2 2 3 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 18 1 3 4 2 2 30 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 - 2 12 2 10 4 2 2 4 1 19 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 1 36 2 32 1 4 3 4 4 39 1 1 2 2 1 1 0 1 0 0 0 0 0 0 1 - 1 6 4 20 1 4 2 4 3 31 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 9 4 24 1 1 3 3 3 31 3 1 1 1 1 0 0 1 0 0 1 0 0 0 1 - 2 39 3 118 2 4 3 3 4 32 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 1 12 2 26 1 1 2 4 4 55 3 1 1 1 1 0 0 1 0 0 0 0 0 0 1 - 1 36 4 23 1 3 4 2 2 46 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 12 2 12 1 5 1 1 1 46 3 2 1 1 1 1 0 1 0 1 0 0 0 1 2 - 4 24 4 15 4 3 2 1 1 43 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 18 2 15 1 2 4 4 1 39 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 18 4 19 5 3 4 4 1 28 1 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 3 86 1 2 3 2 3 27 1 2 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 14 3 8 1 3 3 2 3 27 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 - 2 18 3 29 5 5 3 4 3 43 3 1 2 1 1 1 0 1 0 0 1 0 0 1 1 - 2 24 2 20 1 2 4 1 2 22 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 24 4 22 5 4 3 4 3 43 3 2 2 2 1 0 1 1 0 0 1 0 0 1 1 - 1 15 2 11 1 2 4 2 1 27 3 1 1 1 2 0 0 1 0 0 1 0 0 1 1 - 4 24 2 32 3 5 1 2 3 26 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 3 12 4 9 3 4 4 2 1 28 3 3 1 2 1 1 0 1 0 0 1 0 0 1 2 - 2 24 2 20 1 5 2 4 3 20 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 33 4 73 1 4 3 2 3 35 3 2 1 2 1 0 1 1 0 0 1 0 0 0 1 - 4 12 4 23 1 1 3 2 3 42 2 2 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 10 2 16 3 3 3 2 4 40 3 1 2 1 2 1 0 1 0 1 0 0 1 0 1 - 1 24 2 14 5 3 2 2 2 35 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 36 4 58 1 5 3 2 2 35 3 2 2 2 1 0 1 1 0 0 1 0 0 1 1 - 1 12 2 26 1 2 3 1 1 33 3 1 2 1 1 1 0 1 0 0 1 0 1 0 2 - 1 18 3 85 5 3 2 2 3 23 3 2 1 2 1 0 0 1 0 1 0 0 0 1 1 - 4 21 2 28 3 4 2 2 3 31 1 1 1 1 1 1 0 1 0 0 1 0 0 0 1 - 2 18 2 10 5 3 2 2 2 33 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 15 2 32 4 4 2 3 3 20 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 - 2 12 2 20 5 3 3 2 3 30 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 - 2 12 4 10 1 4 3 3 1 47 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 - 4 21 3 16 2 4 3 3 1 34 3 2 1 1 1 0 0 1 0 0 1 0 0 0 1 - 2 12 2 28 5 5 2 2 2 25 1 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 2 18 2 28 1 3 4 3 3 21 3 1 1 2 1 0 1 1 0 1 0 0 0 1 1 - 4 28 4 27 1 5 3 2 3 29 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 4 11 4 3 3 3 1 46 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 9 2 13 1 5 3 4 3 20 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 18 4 12 1 1 2 4 4 55 3 3 2 1 1 0 0 1 0 0 0 1 0 0 2 - 4 5 2 34 1 4 3 4 1 74 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 24 2 113 1 3 3 3 3 29 1 2 1 2 1 0 0 0 1 0 1 0 0 0 2 - 1 6 4 19 1 1 3 4 4 36 3 3 1 2 1 0 0 1 0 0 0 0 0 0 1 - 4 24 4 21 1 3 1 2 1 33 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 9 2 21 1 3 3 2 1 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 12 2 15 5 3 4 1 1 25 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 6 2 7 3 4 4 4 1 23 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 4 24 4 13 4 5 2 4 1 37 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 1 42 4 34 1 1 3 4 3 65 3 2 1 1 1 0 0 0 1 0 1 1 0 0 1 - 3 12 1 6 1 2 2 1 1 26 3 1 1 1 1 0 0 1 0 0 1 1 0 0 2 - 4 12 2 19 1 5 3 4 3 39 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 - 1 12 2 16 1 3 2 3 2 30 3 1 1 1 1 0 0 0 1 0 1 0 0 1 1 - 2 20 3 26 1 3 3 3 3 29 1 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 12 2 7 1 5 3 4 3 41 1 1 2 1 1 0 0 1 0 0 1 0 1 0 2 - 2 48 4 51 1 3 2 3 3 30 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 9 4 12 5 5 2 4 2 41 3 2 1 1 1 0 0 1 0 1 0 0 1 0 1 - 1 36 2 18 1 2 2 4 3 34 3 1 1 2 1 1 0 1 0 0 1 0 0 1 2 - 2 7 2 26 1 3 3 2 1 35 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 - 3 12 2 14 5 5 2 4 1 55 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 2 15 3 15 4 3 4 3 2 61 2 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 36 4 111 5 3 3 2 3 30 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 4 6 2 5 1 3 2 1 1 29 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 12 0 28 1 5 3 4 2 34 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 27 1 5 3 4 3 35 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 1 24 2 48 1 4 3 3 2 31 3 1 1 2 1 1 0 0 1 0 1 0 0 1 2 - 4 24 2 27 1 2 2 1 4 29 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 1 11 4 39 1 3 3 2 1 36 3 2 2 1 1 1 0 1 0 1 0 0 0 1 1 - 1 12 2 34 1 5 3 4 4 35 3 1 1 2 1 0 1 1 0 0 0 0 0 1 2 - 1 6 2 3 1 2 2 1 1 27 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 46 1 2 3 2 3 32 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 36 2 36 1 3 3 2 2 37 3 1 2 1 1 0 0 0 0 0 1 0 0 1 1 - 1 15 2 17 1 2 3 3 1 36 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 2 12 2 30 1 2 2 1 1 34 3 1 1 1 1 0 0 1 0 1 0 0 0 0 1 - 2 12 2 8 5 5 3 4 2 38 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 20 1 4 3 1 3 34 2 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 24 2 29 1 3 3 4 4 63 1 1 2 2 1 0 1 0 0 0 1 0 0 1 1 - 1 24 3 17 1 2 2 2 3 29 3 1 1 2 1 0 0 1 0 1 0 0 1 0 2 - 4 48 3 72 5 5 3 3 3 32 1 2 2 1 1 0 0 1 0 0 1 0 0 1 1 - 4 33 3 28 1 3 2 2 3 26 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 24 3 47 1 4 3 3 3 35 3 2 1 2 1 0 1 1 0 0 1 0 1 0 1 - 2 24 2 31 2 2 4 2 3 22 3 1 1 2 1 0 0 1 0 1 0 0 0 1 2 - 1 6 2 4 1 2 2 4 2 23 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 9 2 7 1 3 3 3 3 28 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 4 6 2 12 5 1 3 4 2 36 3 1 2 2 1 0 0 1 0 0 1 0 0 0 1 - 2 18 4 12 1 3 4 2 3 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 18 0 31 1 2 2 4 2 26 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 4 39 2 26 3 3 3 4 3 24 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 - 3 24 2 52 1 4 3 2 3 25 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 12 2 10 2 4 3 4 1 39 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 15 4 15 1 5 3 4 3 44 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 - 2 12 4 36 1 3 2 1 1 23 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 24 2 12 1 2 3 1 2 26 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 30 2 36 4 5 2 4 2 57 3 2 1 2 1 0 0 1 0 1 0 0 0 1 1 - 4 15 3 10 4 4 2 2 2 30 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 12 4 12 3 3 3 4 1 44 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 2 6 3 12 1 1 3 4 2 47 3 1 1 2 1 1 0 1 0 0 1 0 0 0 2 - 4 12 2 31 1 3 3 4 3 52 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 38 1 5 2 4 4 62 3 1 1 2 1 1 0 0 1 0 0 0 0 1 1 - 4 10 2 14 2 3 3 2 1 35 3 1 1 1 2 1 0 1 0 1 0 0 1 0 1 - 4 6 2 35 1 3 3 3 2 26 3 1 1 1 1 1 0 0 0 1 0 0 0 1 1 - 4 12 4 19 1 5 3 2 4 26 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 27 0 83 1 5 2 4 4 42 3 2 1 2 1 0 0 1 0 0 0 0 0 0 2 - 4 6 4 12 2 3 2 1 2 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 6 2 4 5 5 3 4 2 38 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 4 21 1 3 3 2 1 39 3 2 2 1 2 1 0 1 0 1 0 0 1 0 1 - 1 24 2 30 5 3 4 4 3 20 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 36 2 90 2 2 3 1 4 29 3 1 1 2 1 0 0 0 1 1 0 0 0 0 2 - 4 24 4 16 1 4 3 3 2 40 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 18 2 13 1 5 4 2 1 32 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 - 3 6 4 13 2 5 1 4 3 28 3 2 2 2 1 1 0 1 0 0 1 0 0 1 1 - 1 24 2 31 1 2 2 1 2 27 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 1 36 2 55 1 5 3 4 4 42 3 1 2 1 1 0 1 1 0 0 0 0 0 1 1 - 3 9 2 11 2 5 1 4 1 49 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 24 4 12 2 2 3 4 4 38 1 2 2 1 1 0 0 1 0 0 1 0 0 1 2 - 1 24 2 12 1 2 2 4 2 24 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 - 4 10 2 13 5 3 3 4 2 27 3 1 1 1 1 1 0 0 0 0 1 0 1 0 2 - 3 15 4 24 3 3 3 2 3 36 3 1 1 2 1 0 1 1 0 0 1 0 0 1 1 - 2 15 1 68 2 1 3 2 2 34 3 1 2 2 1 1 0 1 0 0 1 0 0 0 2 - 4 24 2 14 1 3 4 2 2 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 39 2 86 2 5 3 2 3 45 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 1 12 2 8 1 4 3 2 1 26 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 36 2 47 1 3 3 2 4 32 3 1 1 2 1 0 1 1 0 0 0 0 0 0 1 - 3 15 2 27 1 4 3 4 2 26 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 2 12 3 6 1 3 4 4 1 20 3 2 1 1 1 0 0 0 1 1 0 0 0 1 1 - 4 24 2 23 5 2 3 1 2 54 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 6 4 6 1 4 2 3 2 37 3 2 1 1 2 1 0 1 0 0 1 0 0 1 1 - 1 6 4 14 1 2 3 4 1 40 3 1 2 1 2 1 0 1 0 0 1 0 1 0 1 - 4 36 4 71 1 2 2 4 2 23 3 2 1 2 1 0 0 1 0 1 0 0 0 1 2 - 1 6 2 12 2 5 3 2 2 43 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 6 4 7 5 5 3 4 4 36 3 2 1 1 1 0 0 1 0 0 0 0 0 1 1 - 4 24 4 55 1 5 3 4 4 44 3 2 1 1 1 0 0 1 0 0 0 0 0 1 1 - 1 18 2 32 1 3 2 2 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 48 0 71 1 3 3 4 4 53 3 2 2 1 1 0 0 1 0 0 0 0 0 1 2 - 4 24 2 35 2 4 2 4 3 23 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 - 2 18 2 11 1 3 2 4 1 26 3 1 2 1 1 0 0 0 0 0 1 0 1 0 1 - 2 26 2 80 1 2 3 3 3 30 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 - 4 15 4 15 2 3 2 3 3 31 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 4 4 15 1 4 3 1 1 42 3 2 2 1 1 0 0 1 0 0 1 0 1 0 1 - 1 36 2 23 1 3 1 4 3 31 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 1 6 2 7 1 2 3 4 1 41 3 1 2 2 1 1 0 1 0 0 1 0 1 0 1 - 2 36 2 23 1 4 3 1 3 32 3 2 2 1 1 0 0 1 0 0 1 0 0 1 1 - 2 15 2 26 2 3 2 4 3 28 3 2 1 2 1 1 0 1 0 1 0 0 0 1 2 - 4 12 3 15 1 3 4 4 1 41 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 - 4 24 2 13 2 4 4 3 2 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 31 5 2 3 2 3 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 3 21 4 23 1 2 1 1 3 33 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 1 6 2 14 5 1 2 3 2 75 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 - 2 18 4 36 1 5 2 4 2 37 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 48 2 78 1 5 3 4 4 42 1 1 1 1 1 1 0 1 0 0 0 0 0 0 2 - 3 18 2 30 1 2 2 1 2 45 2 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 12 2 15 1 2 4 1 1 23 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 4 24 3 20 1 5 3 4 4 60 3 2 1 2 1 1 0 1 0 0 0 0 0 1 1 - 1 30 2 64 5 5 3 4 2 31 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 3 18 2 29 1 3 3 1 1 34 3 1 2 1 1 0 0 1 0 0 1 0 1 0 2 - 4 12 4 13 1 5 3 4 1 61 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 - 1 24 3 13 1 1 3 2 1 43 3 2 2 1 1 1 0 1 0 0 0 0 0 1 2 - 4 24 4 20 1 3 2 4 3 37 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 24 2 16 1 4 3 1 3 32 1 1 2 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 1 6 1 3 2 4 1 24 1 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 4 48 4 89 5 4 3 1 4 35 3 2 1 2 1 0 1 1 0 0 0 0 0 1 1 - 4 12 4 10 5 4 2 4 1 23 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 6 1 18 3 5 3 4 2 45 1 1 2 1 1 0 0 1 0 0 1 0 1 0 1 - 1 48 2 70 1 4 4 1 1 34 3 2 1 2 1 0 0 0 0 0 1 0 0 1 2 - 2 12 4 20 2 2 3 1 3 27 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 2 9 2 12 1 4 2 4 2 67 3 2 1 2 1 0 0 1 0 0 1 0 0 0 1 - 2 12 2 13 1 2 3 1 3 22 2 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 18 0 23 2 2 2 3 3 28 3 2 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 21 0 50 5 3 2 4 2 29 1 2 1 2 1 1 0 1 0 0 1 0 0 1 2 - 1 24 1 36 1 4 3 4 3 27 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 18 4 19 1 2 3 2 1 31 3 2 1 1 1 0 0 1 0 0 1 0 1 0 2 - 1 24 2 30 5 5 3 4 4 49 1 1 2 2 1 0 1 1 0 0 0 0 0 1 1 - 1 24 1 15 1 4 3 4 3 24 1 1 1 1 1 0 0 0 0 1 0 0 1 0 2 - 3 6 3 7 1 2 2 1 2 29 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 36 2 124 5 3 3 4 4 37 3 1 1 2 1 1 0 1 0 0 0 0 0 1 2 - 2 24 3 47 5 3 3 2 2 37 1 2 1 2 1 0 0 1 0 0 1 0 0 0 1 - 2 24 3 16 2 4 2 2 2 23 3 2 1 2 1 0 0 1 0 1 0 0 0 1 1 - 1 12 2 14 1 4 1 3 3 36 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 24 4 26 4 5 3 2 3 34 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 48 2 40 5 4 3 1 3 41 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 - 1 48 2 68 1 3 2 2 3 31 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 1 24 2 32 1 2 2 4 1 23 3 1 1 2 1 0 0 1 0 1 0 0 1 0 2 - 4 30 4 60 1 4 3 2 3 38 3 1 1 1 1 0 0 0 1 0 1 0 0 1 1 - 4 24 2 54 5 1 2 4 2 26 3 1 1 2 1 0 1 1 0 1 0 0 0 0 1 - 1 15 2 8 1 3 2 4 2 22 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 9 2 11 1 5 3 4 3 27 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 15 4 28 1 4 2 3 3 24 1 2 1 1 1 0 0 0 1 0 1 0 0 1 1 - 2 12 2 29 1 4 2 1 1 27 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 4 19 5 3 2 2 3 33 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 36 4 28 1 2 1 4 3 27 3 2 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 24 2 9 1 2 4 3 3 27 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 18 4 11 1 5 3 3 1 30 1 2 1 1 1 1 0 0 0 0 1 0 0 1 2 - 2 12 4 31 1 2 3 3 1 49 1 2 2 1 1 1 0 1 0 0 1 0 1 0 1 - 4 9 2 14 1 3 2 2 1 26 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 2 36 2 24 1 2 3 1 4 33 3 1 1 1 1 0 0 1 0 1 0 0 1 0 2 - 4 12 2 21 5 5 2 4 4 52 3 1 1 2 1 1 0 1 0 0 0 0 0 0 1 - 1 18 2 20 1 3 2 4 1 20 1 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 1 9 4 28 1 3 3 2 1 36 3 2 2 1 1 1 0 1 0 1 0 0 0 1 1 - 1 12 2 13 1 3 3 1 2 21 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 - 1 18 2 12 1 3 4 3 1 47 3 1 1 2 1 0 0 1 0 0 1 0 1 0 2 - 1 12 4 22 1 5 3 3 2 60 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 12 4 4 1 4 2 3 1 58 3 4 1 2 1 0 0 1 0 0 1 0 1 0 1 - 2 24 3 20 5 3 2 4 3 42 3 2 1 2 1 1 0 1 0 1 0 0 0 1 1 - 4 21 2 16 4 5 2 4 1 36 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 24 2 27 1 3 2 4 2 20 3 1 1 2 1 1 0 1 0 1 0 0 1 0 2 - 1 24 1 14 5 5 3 3 3 40 2 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 2 6 1 9 2 2 2 1 2 32 2 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 1 24 2 14 1 4 2 4 3 23 3 2 1 1 1 1 0 1 0 1 0 0 0 1 2 - 2 24 0 42 1 3 3 4 1 36 3 3 1 2 1 0 0 1 0 0 1 0 1 0 2 - 4 18 4 28 1 4 3 2 2 31 1 2 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 24 3 39 1 3 3 2 4 32 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 - 2 7 2 23 1 2 2 1 1 45 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 - 2 9 2 9 1 3 2 1 2 30 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 24 1 18 1 4 2 4 4 34 1 1 1 1 1 0 0 1 0 0 0 0 1 0 2 - 4 36 2 33 1 3 2 2 3 28 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 3 10 2 13 1 2 2 2 2 23 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 24 1 28 3 3 3 4 1 22 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 24 4 45 1 3 3 2 1 74 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 2 36 2 27 2 3 2 4 4 50 3 1 1 1 1 0 0 0 1 0 0 0 0 1 2 - 4 18 2 21 1 2 3 1 1 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 15 2 13 5 5 3 4 4 45 1 1 2 1 1 0 1 1 0 0 0 0 0 1 1 - 1 12 2 7 2 1 2 3 2 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 3 10 2 12 2 5 2 4 4 48 3 1 2 1 1 1 0 1 0 0 0 0 1 0 2 - 1 21 2 34 4 2 2 2 3 29 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 24 1 36 1 3 2 4 3 22 1 1 1 1 2 0 1 0 0 1 0 0 0 1 1 - 4 18 3 18 1 4 2 1 1 22 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 48 0 122 5 3 3 2 3 48 1 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 2 60 3 92 5 3 3 2 4 27 3 1 1 1 1 0 0 1 0 0 0 0 0 0 1 - 1 6 4 37 1 3 3 3 1 37 3 3 2 1 1 1 0 1 0 1 0 0 0 1 1 - 2 30 2 34 2 3 2 4 3 21 3 1 1 1 1 0 0 0 1 1 0 0 0 1 2 - 4 12 2 6 1 3 1 2 1 49 3 1 1 1 1 1 0 1 0 0 1 0 1 0 1 - 2 21 4 37 1 4 3 3 2 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 18 4 15 1 3 3 2 2 32 1 2 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 48 2 39 5 3 1 2 1 38 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 12 2 19 1 2 2 1 3 22 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 1 18 2 26 1 3 3 4 4 65 3 2 1 1 1 0 0 1 0 0 0 0 0 1 2 - 4 15 2 20 5 5 3 2 3 35 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 3 6 2 21 1 3 3 2 1 41 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 9 1 14 2 4 3 3 4 29 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 42 4 40 3 3 3 4 1 36 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 9 2 38 5 5 3 4 1 64 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 24 2 37 1 3 2 4 3 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 18 1 16 1 3 3 3 3 44 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 15 2 14 5 2 3 1 2 23 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 9 2 20 1 2 2 2 3 19 3 2 1 1 1 0 0 0 1 1 0 0 0 1 2 - 2 24 2 14 1 2 2 4 3 25 3 1 1 2 1 1 0 1 0 0 1 0 1 0 2 - 4 12 2 14 1 5 3 4 2 47 1 3 2 2 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 14 3 4 2 1 3 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 60 3 157 1 4 3 4 3 21 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 12 2 15 1 2 2 3 3 34 3 1 2 1 1 0 0 1 0 0 1 0 0 1 1 - 1 42 3 44 1 4 3 2 2 26 1 2 2 2 1 0 0 1 0 0 1 0 0 1 2 - 1 18 2 8 1 1 2 1 1 27 3 1 1 1 1 0 0 1 0 0 1 1 0 0 2 - 2 15 2 13 1 5 3 4 3 38 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 15 2 46 2 3 3 2 2 40 3 1 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 24 4 19 1 4 4 2 3 33 3 2 1 2 1 0 0 0 0 0 1 0 0 1 1 - 1 18 4 19 1 4 4 1 2 32 3 2 1 2 1 0 0 1 0 0 1 0 0 0 1 - 4 36 3 80 5 2 3 4 3 27 3 2 1 2 1 0 0 1 0 1 0 0 0 1 2 - 1 30 0 46 1 3 1 2 1 32 3 2 1 1 1 0 0 0 0 0 1 0 0 1 1 - 4 12 2 14 3 3 2 2 2 26 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 3 24 2 9 1 4 3 3 4 38 1 1 2 1 1 1 0 1 0 0 0 0 0 1 2 - 1 12 2 7 1 3 3 4 3 40 3 1 2 1 1 0 0 1 0 1 0 0 1 0 2 - 1 48 2 75 1 4 3 1 4 50 3 1 1 2 1 0 0 1 0 0 0 0 0 0 1 - 2 12 2 19 1 3 3 2 2 37 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 1 24 2 23 1 5 3 1 1 45 3 1 1 1 1 1 0 0 1 0 1 0 0 1 2 - 2 36 3 81 2 5 3 4 3 42 3 4 1 2 1 1 0 1 0 0 1 0 0 0 2 - 4 24 4 23 1 4 3 3 3 35 3 2 1 2 1 0 1 1 0 0 1 0 0 1 1 - 1 14 2 40 1 1 3 4 4 22 3 1 1 1 1 1 0 1 0 0 0 0 0 1 1 - 2 12 2 9 1 5 3 4 3 41 1 1 2 1 1 1 0 1 0 0 1 0 1 0 2 - 4 48 2 102 5 4 3 3 3 37 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 30 0 42 1 3 2 1 3 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 18 4 64 1 5 3 1 4 41 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 3 12 2 13 1 3 4 4 1 23 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 1 12 2 9 5 3 4 2 3 23 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 21 2 22 1 5 3 2 1 50 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 6 3 10 1 1 3 1 2 35 2 2 1 2 1 0 0 1 0 0 1 0 0 0 1 - 3 6 4 10 1 3 2 4 2 50 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 24 4 63 1 1 3 2 4 27 1 2 1 2 1 0 0 0 1 0 1 0 0 0 1 - 2 30 1 35 4 3 3 2 3 34 2 1 2 2 1 0 0 1 0 0 1 0 0 1 1 - 4 48 1 36 1 3 2 1 1 27 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 4 48 1 5 3 4 2 43 3 2 1 2 1 1 0 0 1 1 0 0 0 1 2 - 3 30 4 30 1 5 3 4 2 47 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 4 41 2 3 3 3 2 27 3 2 1 2 1 0 0 1 0 0 1 0 1 0 1 - 4 36 2 57 2 4 3 2 3 31 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 60 2 104 1 5 3 4 2 42 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 - 4 6 4 21 3 3 4 2 3 24 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 21 3 26 3 2 3 2 1 41 1 1 2 1 1 0 0 1 0 0 1 0 1 0 2 - 4 30 4 45 1 4 2 4 3 26 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 - 4 24 4 52 1 5 3 4 3 33 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 72 2 56 2 3 4 2 3 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 24 2 24 1 5 3 4 1 64 1 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 4 18 2 15 1 2 2 1 1 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 6 2 15 1 2 2 2 4 56 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 12 2 23 5 3 3 4 4 37 3 1 1 2 1 0 0 1 0 0 0 0 0 1 1 - 4 15 3 15 1 3 4 3 1 33 1 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 4 51 1 2 4 3 4 47 3 3 1 2 1 0 0 1 0 0 0 0 0 1 1 - 2 36 3 99 2 4 3 3 2 31 3 2 2 2 1 0 0 1 0 0 1 0 1 0 1 - 4 60 2 65 5 3 3 4 4 34 3 1 2 2 1 1 0 1 0 0 0 0 0 1 1 - 3 10 4 13 5 4 3 2 2 27 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 36 3 29 2 5 3 3 4 30 3 1 1 1 1 1 0 1 0 0 0 0 0 1 1 - 4 9 2 28 2 5 3 4 3 35 3 1 1 2 1 0 0 0 1 0 1 0 0 1 1 - 1 12 2 37 4 3 3 3 2 31 3 1 2 1 1 1 0 1 0 0 1 0 0 1 1 - 1 15 4 10 1 3 1 3 2 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 15 2 26 2 3 2 2 1 25 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 24 2 29 2 2 3 1 3 29 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 6 4 47 5 2 3 3 1 44 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 - 4 24 2 23 1 4 3 2 3 28 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 6 2 12 3 3 3 4 2 50 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 - 2 12 2 11 1 4 3 3 1 29 3 2 1 1 2 0 0 0 0 0 1 0 0 1 1 - 4 12 4 9 1 1 2 2 2 38 3 1 1 1 1 1 0 1 0 0 1 1 0 0 1 - 4 18 4 18 1 3 3 2 3 24 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 3 15 2 19 1 5 3 4 3 40 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 - 4 12 2 11 3 3 2 4 3 29 3 1 1 1 1 0 0 1 0 1 0 0 1 0 2 - 1 48 4 63 1 5 3 4 4 46 3 2 1 2 1 0 1 1 0 0 0 0 0 1 2 - 3 24 2 14 2 5 2 2 4 47 3 1 1 2 1 0 0 1 0 0 0 0 0 1 1 - 2 30 3 25 2 5 3 2 2 41 2 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 27 2 25 1 2 2 1 2 32 3 1 2 2 1 0 0 1 0 0 1 0 0 1 1 - 4 15 2 53 3 5 2 4 4 35 3 1 1 1 1 1 0 1 0 0 0 0 0 1 1 - 2 48 2 66 2 4 3 2 2 24 3 1 1 1 1 1 0 1 0 0 1 0 0 1 2 - 2 12 0 30 1 2 2 3 2 25 3 2 1 1 1 0 0 1 0 1 0 0 0 1 2 - 2 9 2 12 1 5 2 4 1 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 9 2 21 1 3 3 2 1 37 3 1 2 1 1 0 0 1 0 0 1 0 1 0 1 - 4 18 4 6 3 5 3 3 2 32 1 2 1 2 1 0 0 1 0 0 1 0 0 0 1 - 1 6 1 12 1 5 2 4 4 35 3 1 1 1 1 0 0 1 0 0 0 0 0 1 2 - 4 21 2 25 5 5 3 4 1 46 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 1 9 4 11 1 3 3 4 1 25 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 60 2 140 1 4 3 2 4 27 3 1 1 2 1 1 0 1 0 0 1 0 0 0 2 - 4 30 4 76 5 5 3 4 3 63 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 - 4 30 4 31 5 5 3 2 3 40 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 15 1 3 3 2 4 32 3 1 1 2 1 0 0 1 0 0 0 0 0 0 1 - 3 24 4 31 5 3 3 2 3 31 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 20 0 61 2 5 4 4 3 31 1 2 1 2 1 0 1 1 0 0 1 0 0 1 1 - 3 9 0 13 1 2 3 2 3 34 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 - 2 6 1 4 4 2 2 2 2 24 1 1 2 1 1 0 0 1 0 1 0 0 0 1 2 - 1 12 2 12 1 3 2 2 1 24 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 2 9 2 8 3 3 2 3 1 66 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 27 2 26 1 3 2 3 1 21 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 - 4 6 4 2 4 3 2 2 1 41 1 2 1 1 1 1 0 1 0 0 1 0 1 0 1 - 4 15 4 13 3 3 4 2 2 47 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 18 2 19 1 3 2 4 3 25 1 2 1 1 1 0 0 1 0 1 0 0 0 1 2 - 2 48 1 64 1 5 2 3 4 59 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 3 24 4 13 4 3 1 4 1 36 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 24 3 64 1 2 3 2 3 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 24 2 20 1 3 3 4 1 21 3 1 2 1 1 0 0 1 0 1 0 0 1 0 2 - 2 8 2 8 1 4 2 2 1 44 3 1 1 1 1 0 0 0 0 0 1 0 1 0 1 - 4 24 2 26 4 3 2 4 3 28 3 1 1 2 1 0 1 1 0 1 0 0 0 1 1 - 4 4 4 34 1 4 2 1 1 37 3 1 2 1 1 1 0 1 0 0 1 0 0 1 1 - 2 36 1 40 5 2 2 2 4 29 1 1 1 1 1 0 0 1 0 0 1 1 0 0 1 - 2 24 2 116 1 3 2 4 3 23 3 2 1 1 1 0 1 1 0 1 0 0 0 0 2 - 1 18 2 44 2 3 3 4 3 35 3 1 2 2 1 1 0 1 0 0 1 0 1 0 1 - 4 6 4 68 1 4 3 3 4 45 3 2 2 2 1 1 0 1 0 0 1 0 0 0 1 - 2 30 0 43 2 3 2 4 3 26 3 2 1 1 1 0 0 1 0 1 0 0 1 0 2 - 1 24 1 23 2 4 3 3 3 32 1 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 2 10 1 10 1 3 3 4 1 23 2 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 21 2 32 5 5 3 3 2 41 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 24 1 25 3 3 3 4 1 22 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 39 4 142 5 4 3 4 2 30 3 2 1 2 1 0 0 1 0 0 1 0 0 0 1 - 1 13 4 18 1 2 3 1 2 28 1 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 15 2 25 1 1 2 4 3 23 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 - 1 12 2 13 1 2 2 1 1 37 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 4 21 2 52 5 3 3 3 3 26 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 - 4 15 2 30 1 4 3 2 3 33 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 - 1 6 2 4 1 5 2 1 2 49 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 18 2 10 1 2 2 2 3 23 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 2 12 2 8 2 4 2 4 1 23 3 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 4 30 4 58 1 4 2 2 3 25 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 12 3 16 4 5 3 4 4 55 3 2 2 1 1 0 0 1 0 0 0 0 0 1 2 - 1 24 2 13 5 4 2 4 4 32 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 - 3 6 4 13 1 3 3 1 1 74 3 3 2 1 2 1 0 1 0 0 1 1 0 0 1 - 3 15 4 13 5 3 3 4 4 39 3 2 1 2 1 0 0 1 0 0 0 0 0 1 2 - 4 24 2 14 1 3 3 2 1 31 3 1 1 2 1 1 0 0 0 0 1 0 0 1 1 - 1 12 4 7 1 5 3 3 2 35 3 2 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 15 4 50 5 5 2 4 3 59 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 1 18 4 21 1 3 2 4 1 24 3 2 1 1 1 0 0 1 0 1 0 0 0 1 2 - 1 12 2 22 1 3 3 3 2 24 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 21 4 127 5 5 3 4 4 30 3 1 1 2 1 1 0 1 0 0 0 0 0 0 2 - 4 24 4 25 2 4 4 3 2 27 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 2 12 2 12 1 5 4 3 1 40 1 2 1 1 1 0 0 0 0 0 1 0 1 0 1 - 1 30 2 31 1 2 1 4 2 31 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 4 10 2 29 5 2 2 4 1 31 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 - 2 12 4 36 1 5 3 4 3 28 3 3 1 2 1 0 0 1 0 1 0 0 0 1 1 - 4 12 4 17 1 5 3 4 1 63 3 2 1 2 1 0 0 1 0 0 1 0 1 0 1 - 1 24 2 28 5 5 2 4 1 26 3 1 1 1 1 0 1 1 0 1 0 0 0 1 1 - 1 36 4 81 1 3 2 2 4 25 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 - 4 21 4 33 1 5 3 4 3 36 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 4 24 4 22 2 5 3 4 2 52 1 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 3 12 4 15 3 1 3 4 4 66 1 3 1 1 1 1 0 1 0 0 0 1 0 0 1 - 1 24 2 14 5 3 2 4 1 25 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 - 4 36 4 35 1 4 3 4 3 37 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 1 18 2 35 1 4 2 1 1 25 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 - 4 36 4 57 4 5 3 2 3 38 3 2 1 2 1 0 1 1 0 0 1 0 0 0 1 - 2 18 2 39 1 1 2 4 3 67 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 39 4 49 1 4 3 2 1 25 3 2 1 1 1 0 0 0 0 0 1 0 0 1 2 - 4 24 4 19 4 5 3 4 1 60 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 2 12 0 14 1 3 3 2 1 31 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 - 2 12 2 8 2 2 2 2 2 23 1 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 2 20 2 65 5 1 1 4 1 60 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 2 18 2 19 4 3 3 2 2 35 3 1 1 2 1 0 0 1 0 0 1 0 1 0 1 - 4 22 2 27 3 5 3 4 3 40 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 48 4 28 5 5 3 3 3 38 3 2 2 2 1 0 1 1 0 0 1 0 0 1 1 - 2 48 3 62 1 5 3 4 4 50 3 1 1 1 1 0 0 1 0 0 0 0 0 1 2 - 1 40 4 60 1 3 3 3 4 27 1 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 2 21 2 12 1 5 2 4 2 39 3 1 2 1 1 0 0 1 0 0 1 0 0 1 2 - 4 24 2 63 5 5 3 4 3 41 3 1 2 2 1 0 1 1 0 0 1 0 0 0 1 - 4 6 4 12 5 3 4 2 2 27 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 3 24 2 29 1 5 1 4 4 51 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 - 4 24 2 31 3 5 3 3 4 32 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 4 9 2 23 2 2 2 4 2 22 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 1 18 2 75 5 5 3 4 2 51 3 1 2 2 1 0 1 1 0 0 0 0 0 1 2 - 4 12 4 13 1 2 2 4 2 22 3 2 1 1 1 0 0 1 0 1 0 0 1 0 1 - 4 24 3 7 5 5 4 4 3 54 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 2 9 2 15 5 2 3 2 1 35 3 1 1 1 1 1 0 1 0 0 1 1 0 0 1 - 4 24 4 16 1 5 3 4 4 54 3 2 2 1 1 0 0 1 0 0 0 0 0 1 1 - 2 18 4 18 1 5 2 4 1 48 1 2 1 2 1 0 0 0 0 1 0 0 1 0 1 - 1 20 4 43 1 5 2 4 2 24 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 12 4 10 5 5 3 4 3 35 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 12 2 75 5 1 2 2 1 24 3 1 1 1 1 1 0 1 0 1 0 1 0 0 1 - 1 36 2 93 1 4 3 1 3 24 3 1 1 2 1 1 0 1 0 0 1 0 0 1 2 - 2 6 2 6 1 2 4 3 1 26 3 1 1 1 2 0 0 1 0 0 1 0 1 0 1 - 4 12 4 9 5 5 3 4 1 65 3 4 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 42 1 93 1 1 3 2 4 55 1 1 1 2 1 0 1 1 0 0 0 0 0 0 1 - 2 15 0 18 1 2 2 1 1 26 3 2 1 1 1 1 0 1 0 1 0 1 0 0 2 - 2 8 2 9 1 2 4 2 1 26 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 2 6 2 5 1 4 4 3 1 28 1 1 1 1 1 0 0 0 0 0 1 0 1 0 1 - 1 36 4 96 1 4 3 4 3 24 3 2 1 2 1 0 1 1 0 0 1 0 0 1 2 - 1 48 2 31 1 3 3 4 3 54 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 48 2 39 1 4 3 4 4 46 3 1 2 1 1 1 0 1 0 0 0 0 0 1 2 - 2 36 3 74 1 3 2 2 2 54 3 1 1 1 1 1 0 1 0 1 0 0 0 1 1 - 4 6 2 13 3 3 1 4 1 62 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 6 4 16 1 4 2 2 3 24 3 2 1 2 1 0 0 1 0 1 0 0 0 1 1 - 1 36 2 159 1 1 1 3 3 43 3 1 1 1 1 0 0 0 1 0 1 0 0 0 1 - 1 18 2 13 1 3 4 3 1 26 1 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 12 2 11 1 3 4 2 1 27 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 3 12 2 30 1 3 4 1 3 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 36 2 27 1 5 3 2 2 41 1 1 2 1 1 0 0 1 0 0 1 0 0 1 2 - 1 8 4 7 1 5 3 4 1 47 3 2 1 1 1 1 0 1 0 0 1 0 1 0 1 - 4 18 4 38 1 2 1 2 3 35 3 2 1 2 1 0 0 1 0 0 1 0 0 0 1 - 1 21 4 16 1 5 4 3 3 30 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 1 18 4 40 1 5 2 4 1 33 1 3 1 2 1 1 0 1 0 1 0 0 0 1 2 - 4 18 0 42 1 3 3 2 3 36 2 2 2 1 1 0 0 1 0 0 1 0 0 1 2 - 1 36 2 83 5 5 3 4 4 47 3 1 1 1 1 0 1 1 0 0 0 0 0 1 2 - 2 48 3 67 5 3 3 4 4 38 3 1 2 2 1 0 0 1 0 0 0 0 0 1 1 - 4 24 3 24 3 3 3 2 3 44 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 - 1 18 2 12 1 2 2 3 3 23 3 1 1 2 1 1 0 1 0 1 0 0 0 1 2 - 1 45 0 118 1 5 3 4 3 29 3 2 1 1 1 0 0 1 0 1 0 0 0 1 2 - 2 24 2 51 5 5 2 4 3 42 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 3 15 2 23 1 2 2 3 1 25 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 1 12 0 11 1 3 3 4 3 48 1 2 1 1 1 1 0 1 0 0 1 0 0 1 2 - 4 12 2 9 5 3 2 2 3 21 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 4 2 6 1 2 2 3 1 23 3 1 2 1 1 0 0 1 0 1 0 0 1 0 1 - 1 24 4 30 1 5 3 4 2 63 3 2 1 2 1 0 1 1 0 0 1 0 0 1 1 - 4 24 4 26 1 5 4 3 1 46 3 2 1 1 1 0 0 0 1 0 1 0 0 1 1 - 1 36 2 52 1 4 3 2 2 29 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 21 3 30 1 3 3 2 1 28 2 2 1 1 1 0 1 1 0 0 1 0 1 0 1 - 4 18 2 19 1 2 2 4 1 23 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 24 1 16 1 4 3 4 3 50 1 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 34 1 5 3 4 2 47 1 3 2 2 1 0 0 1 0 0 1 0 0 1 1 - 2 21 2 40 5 4 3 3 3 35 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 18 2 68 5 3 3 4 3 68 3 2 1 1 1 1 0 1 0 1 0 0 0 1 2 - 4 24 2 12 1 2 4 2 1 28 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 9 2 14 1 4 3 4 1 59 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 2 7 1 5 3 4 1 57 2 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 1 20 4 22 1 3 4 2 2 33 1 2 1 1 2 1 0 0 0 1 0 0 0 1 2 - 4 24 4 40 5 4 3 4 2 43 3 2 1 2 1 0 1 1 0 0 1 0 0 1 1 - 4 15 4 15 1 3 3 4 4 35 3 2 1 2 1 0 0 1 0 0 0 0 0 1 1 - 1 18 1 14 1 4 3 4 4 32 3 2 2 1 1 1 0 1 0 0 0 0 1 0 2 - 4 36 3 109 1 5 3 2 3 45 3 2 2 2 1 1 0 1 0 0 1 0 0 1 1 - 4 24 2 15 2 2 4 3 1 33 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 10 2 9 5 4 2 3 2 40 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 15 4 33 1 3 3 2 4 28 3 1 1 2 1 0 0 1 0 0 0 0 0 1 1 - 1 15 2 40 1 3 2 2 2 29 3 1 1 2 1 1 0 1 0 0 1 0 0 1 2 - 4 9 2 36 2 3 3 2 1 26 3 1 2 1 2 1 0 0 0 1 0 0 0 1 1 - 4 24 4 58 4 3 3 2 1 27 3 2 1 1 1 0 1 1 0 0 1 0 0 1 1 - 4 18 3 22 1 3 4 2 3 28 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 1 24 2 24 1 2 2 4 1 35 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 27 4 45 4 2 3 2 1 32 2 2 2 2 1 0 0 1 0 0 1 0 1 0 1 - 4 10 2 22 1 3 3 2 1 25 1 1 1 1 1 0 0 1 0 1 0 0 1 0 2 - 4 15 2 22 3 3 2 4 3 20 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 1 18 2 24 1 2 2 1 3 27 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 12 4 33 1 5 3 4 2 42 2 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 36 2 74 5 5 3 2 2 37 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 2 7 1 5 2 4 2 24 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 4 36 3 77 3 4 2 4 3 40 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 3 6 4 13 1 5 3 4 1 46 3 2 2 1 2 1 0 1 0 0 1 0 0 1 1 - 1 24 4 14 2 4 3 1 1 26 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 15 2 9 5 2 2 1 1 24 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 12 2 36 1 3 3 2 2 29 3 1 2 1 1 0 0 0 1 0 1 0 1 0 1 - 2 11 4 13 4 3 2 4 3 40 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 18 1 19 1 2 3 4 4 36 1 1 1 2 1 0 0 0 1 0 0 0 0 0 1 - 4 36 2 36 1 5 3 2 3 28 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 9 2 14 1 2 3 2 4 27 3 1 1 2 1 1 0 1 0 0 0 0 0 0 2 - 4 30 4 67 5 4 3 3 2 36 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 2 78 1 4 3 3 3 38 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 4 24 2 93 5 3 1 4 4 48 3 1 1 2 1 0 1 1 0 0 0 0 0 1 1 - 2 30 4 22 5 5 3 4 1 36 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 18 4 11 1 1 2 4 3 65 3 2 1 1 1 0 0 1 0 0 1 1 0 0 1 - 2 24 2 41 1 4 1 3 3 43 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 1 12 2 8 1 2 2 4 2 53 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 24 4 28 5 4 3 3 4 34 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 - 2 48 2 157 1 3 3 2 3 23 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 36 4 66 1 5 3 4 3 34 3 2 1 2 1 1 0 1 0 0 1 0 0 0 1 - 4 28 1 78 5 2 3 4 1 40 1 2 2 2 1 0 1 0 0 1 0 0 0 1 1 - 1 27 4 24 1 5 3 4 3 43 2 4 2 2 1 0 0 1 0 0 1 0 0 0 1 - 4 15 4 18 1 5 3 4 3 46 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 12 4 22 1 3 3 4 2 38 1 2 1 1 2 1 0 1 0 0 1 0 1 0 1 - 2 36 4 58 1 3 3 4 3 34 3 2 1 2 1 0 1 1 0 0 1 0 0 1 1 - 4 18 4 12 5 3 3 3 2 29 3 2 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 36 3 89 5 4 3 2 3 31 2 1 2 2 1 0 1 1 0 0 1 0 0 0 1 - 1 21 2 26 1 2 2 4 2 28 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 - 4 12 4 16 4 4 2 2 2 35 3 1 1 1 2 0 0 1 0 0 1 0 0 1 1 - 4 15 2 22 5 4 2 4 1 33 1 1 1 1 1 0 0 1 0 1 0 0 1 0 1 - 1 18 2 42 1 3 3 3 3 42 3 1 1 1 1 0 0 0 1 0 1 0 0 1 2 - 1 16 4 26 1 5 3 4 2 43 1 1 1 2 1 1 0 0 0 1 0 0 0 1 2 - 4 20 4 35 5 2 1 4 1 44 3 2 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 36 4 105 5 5 3 4 4 42 3 2 1 1 1 0 1 1 0 0 0 0 0 1 1 - 4 15 2 14 5 3 4 2 1 40 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 4 24 2 13 1 5 3 1 1 36 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 1 12 2 11 1 3 3 2 1 20 3 1 2 2 1 0 0 1 0 1 0 0 0 0 1 - 1 21 2 38 5 4 3 2 1 24 3 1 1 1 2 1 0 0 1 0 1 0 1 0 1 - 2 36 2 37 5 3 4 2 3 27 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 15 3 36 1 2 2 2 2 46 3 2 1 1 1 0 1 1 0 0 1 0 1 0 1 - 2 9 2 32 5 3 2 2 1 33 3 1 1 1 1 1 0 1 0 0 1 0 1 0 1 - 4 36 3 45 1 3 2 4 1 34 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 24 4 47 1 2 2 4 3 25 1 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 2 30 2 30 5 5 2 4 3 25 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 11 2 21 4 5 1 2 1 28 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 24 1 32 1 3 3 2 2 31 3 1 1 2 1 0 0 1 0 1 0 0 0 1 2 - 2 48 0 184 1 3 2 2 2 32 1 1 1 2 2 0 0 1 0 0 1 0 0 0 2 - 4 10 2 28 2 3 3 2 1 32 3 1 2 1 1 0 1 0 1 0 1 0 0 1 1 - 1 6 2 149 1 5 3 4 4 68 1 1 1 2 1 1 0 1 0 0 1 0 0 0 2 - 1 24 2 24 2 1 1 1 2 33 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 1 24 2 33 1 5 3 2 2 39 3 1 1 2 1 0 0 1 0 1 0 0 0 0 2 - 4 18 4 18 1 3 2 2 4 28 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 48 3 127 3 4 3 1 3 37 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 1 9 2 14 1 2 2 4 2 22 3 1 1 1 1 0 0 1 0 1 0 0 0 1 2 - 2 12 2 20 1 4 3 4 2 30 3 1 2 2 1 1 0 1 0 1 0 0 0 1 1 - 1 24 1 69 1 2 1 1 2 55 1 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 1 12 1 7 1 2 3 2 3 46 1 2 1 2 1 1 0 1 0 0 1 0 0 1 2 - 1 18 4 10 1 2 2 4 2 21 3 1 1 1 1 0 0 1 0 1 0 0 0 1 1 - 1 48 2 103 1 4 3 4 4 39 2 3 2 2 1 0 1 1 0 0 0 0 0 1 2 - 4 30 2 19 5 5 3 4 3 58 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 1 12 3 13 1 3 3 2 1 43 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 - 1 24 2 17 1 2 3 1 2 24 3 1 1 1 2 0 0 0 1 0 1 0 1 0 1 - 2 9 2 17 1 2 2 2 3 22 3 1 1 2 1 0 0 1 0 0 1 0 0 1 2 - 4 9 4 12 1 3 3 1 1 30 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 12 4 5 3 5 3 4 2 42 3 2 2 2 1 0 0 1 0 0 1 0 0 1 1 - 1 12 2 15 1 3 2 1 3 23 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 30 3 19 2 2 3 3 4 30 2 2 1 1 1 0 0 1 0 0 1 0 0 0 2 - 3 9 2 7 1 3 2 2 1 28 3 1 1 1 1 0 0 1 0 0 1 0 1 0 2 - 2 6 2 21 1 2 4 3 3 30 3 1 1 2 1 0 0 1 0 1 0 0 0 0 1 - 2 60 2 63 1 3 3 4 4 42 3 1 1 1 1 0 0 1 0 0 0 0 0 1 2 - 4 24 4 68 5 3 3 4 2 46 3 2 2 2 1 0 1 1 0 0 1 0 0 0 1 - 4 12 2 35 5 2 3 3 2 45 3 1 2 2 1 1 0 1 0 0 1 0 0 0 1 - 4 10 2 15 1 3 3 2 1 31 3 1 2 1 2 1 0 1 0 0 1 0 1 0 1 - 4 24 2 9 5 4 3 2 3 31 2 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 4 4 4 15 1 4 3 1 1 42 3 3 2 1 1 1 0 1 0 0 1 0 1 0 1 - 1 15 2 18 1 2 2 1 2 46 3 1 1 1 1 0 0 0 0 1 0 0 0 1 1 - 2 48 0 84 3 2 2 1 3 30 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 1 24 1 33 3 2 3 4 4 30 3 1 2 2 1 0 0 1 0 0 0 0 0 1 2 - 4 12 2 29 5 1 3 4 4 38 3 1 1 2 1 1 0 1 0 0 1 0 0 0 1 - 4 18 2 15 1 2 4 1 2 43 3 1 2 1 1 0 0 0 1 0 1 0 1 0 2 - 4 24 2 36 2 5 3 4 3 31 3 2 1 1 1 0 0 1 0 0 1 0 0 1 2 - 2 18 4 36 1 1 4 3 3 40 3 3 2 2 1 0 0 1 0 0 1 1 0 0 1 - 1 36 3 21 1 4 3 1 3 24 3 2 1 2 1 0 0 1 0 0 1 0 0 1 2 - 2 24 2 41 3 2 2 4 3 28 3 1 1 1 1 0 1 1 0 1 0 0 0 1 2 - 4 36 2 110 1 1 2 2 3 26 3 2 1 2 1 0 0 1 0 0 1 0 0 0 2 - 1 12 2 19 1 3 2 4 2 29 3 1 1 2 1 1 0 0 0 0 1 0 0 1 1 - 1 24 4 12 4 5 2 4 2 57 3 2 1 2 1 0 0 1 0 1 0 0 0 0 1 - 3 30 4 37 5 5 3 4 2 49 2 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 9 4 12 1 5 3 4 1 37 3 3 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 28 2 40 1 3 3 2 3 45 3 1 1 1 1 1 0 1 0 0 1 0 1 0 2 - 2 24 2 31 2 5 3 4 4 30 3 1 1 1 1 0 0 1 0 0 0 0 0 1 1 - 4 6 4 17 1 5 4 2 1 30 3 2 1 1 1 0 0 1 0 1 0 0 0 1 1 - 2 21 3 24 1 3 1 4 2 47 3 2 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 15 2 36 5 3 3 2 4 29 3 1 1 1 1 1 0 1 0 0 1 0 0 1 1 - 4 24 2 24 3 5 3 2 3 35 1 2 1 2 1 0 0 1 0 0 1 0 0 1 2 - 2 6 2 5 1 2 4 1 2 22 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 30 2 17 5 3 2 1 3 26 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 2 27 4 25 3 3 3 2 2 23 3 2 1 1 1 0 0 1 0 0 1 0 1 0 2 - 4 15 2 36 1 5 2 2 3 54 1 1 1 2 1 0 0 1 0 1 0 0 0 0 1 - 4 42 2 72 5 4 4 4 2 29 3 1 1 2 1 0 0 1 0 1 0 0 0 1 1 - 1 11 4 39 1 3 3 2 1 40 3 2 2 1 1 1 0 1 0 0 1 0 1 0 1 - 2 15 2 15 2 3 3 2 1 22 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 - 4 24 2 74 1 3 3 4 2 43 3 1 2 1 1 1 0 1 0 0 1 0 1 0 1 - 1 24 1 12 1 1 2 4 4 29 3 2 1 1 1 1 0 0 1 1 0 1 0 0 2 - 1 60 2 73 1 5 3 4 4 36 3 1 1 1 1 0 0 0 1 1 0 0 0 1 2 - 4 30 4 28 1 3 2 2 3 33 3 1 1 2 1 0 0 1 0 0 1 0 0 1 1 - 3 24 2 13 3 3 2 3 3 57 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 2 6 2 8 1 3 2 3 1 64 3 1 1 1 1 0 0 0 0 0 1 0 0 1 1 - 2 18 3 24 5 5 3 2 2 42 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 24 3 25 1 5 3 4 3 47 3 2 2 1 1 1 0 1 0 0 1 0 1 0 2 - 2 15 1 13 2 3 4 2 2 25 3 1 1 1 1 1 0 1 0 1 0 0 0 1 2 - 2 30 4 84 1 4 3 2 2 49 3 1 1 1 1 0 0 1 0 0 1 0 0 1 2 - 4 48 2 48 1 1 3 2 3 33 1 1 1 2 1 0 0 1 0 1 0 0 0 0 2 - 3 21 2 29 2 3 2 1 3 28 1 1 1 2 1 1 0 1 0 0 1 0 0 0 1 - 1 36 2 82 1 3 3 2 2 26 3 1 2 1 1 0 1 1 0 0 1 0 0 1 2 - 4 24 4 20 1 4 3 2 2 30 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 15 4 14 1 3 2 3 2 25 3 2 1 1 1 0 0 1 0 1 0 0 0 1 1 - 3 42 0 63 1 2 1 1 2 33 3 2 1 1 1 0 0 1 0 0 1 0 0 1 1 - 4 13 2 14 2 1 2 4 1 64 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 24 2 66 1 1 3 2 4 29 3 1 1 2 1 0 1 1 0 0 0 0 0 0 1 - 2 24 4 17 1 5 3 2 2 48 3 2 1 1 1 0 0 1 0 0 1 0 1 0 1 - 4 12 4 36 5 2 3 1 2 37 3 2 2 1 1 0 0 1 0 0 1 0 1 0 1 - 4 15 1 16 2 5 3 4 3 34 1 1 2 1 1 0 0 1 0 0 1 0 1 0 1 - 1 18 2 19 5 4 4 4 3 23 3 2 1 1 1 0 0 1 0 1 0 0 1 0 1 - 1 36 2 40 1 1 3 3 2 30 3 1 1 2 1 0 0 1 0 0 1 0 0 0 1 - 4 12 2 24 5 5 3 3 3 50 3 1 1 2 1 1 0 1 0 0 1 0 0 1 1 - 4 12 2 17 1 4 2 4 1 31 3 1 1 1 1 0 0 1 0 0 1 0 1 0 1 - 1 30 2 39 1 3 1 4 2 40 3 1 1 2 1 0 1 1 0 0 1 0 0 0 1 - 4 12 2 8 1 5 3 4 3 38 3 1 1 1 1 0 0 1 0 0 1 0 0 1 1 - 1 45 2 18 1 3 3 4 4 23 3 1 1 2 1 0 0 1 0 0 0 0 0 1 2 - 2 45 4 46 2 1 3 4 3 27 3 1 1 1 1 0 1 1 0 0 1 0 0 1 1 diff --git a/docs/source/tutorials/sklearn_svc.ipynb b/docs/source/tutorials/sklearn_svc.ipynb index b0045221..441abcee 100644 --- a/docs/source/tutorials/sklearn_svc.ipynb +++ b/docs/source/tutorials/sklearn_svc.ipynb @@ -27,16 +27,16 @@ "source": [ "## Setup\n", "\n", - "Install `scikit-learn` and download dataset that is going to be used in this model [`GCN`](https://archive.ics.uci.edu/dataset/144/statlog+german+credit+data) as `german.data-numeric`.\n", + "Install `scikit-learn` and `requests`. The data that is going to be used is [German Credit Data by UCI](http://home.cse.ust.hk/~qyang/221/Assignments/German/GermanData.csv)\n", "\n", "```bash\n", - "pip install scikit-learn\n", + "pip install scikit-learn requests\n", "```" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -45,6 +45,7 @@ "from sklearn.svm import SVC\n", "from sklearn import metrics\n", "from time import time\n", + "import requests\n", "\n", "K = tc.set_backend(\"tensorflow\")" ] @@ -55,52 +56,49 @@ "source": [ "## Data Preprocessing\n", "\n", - "The data has 24 variables and each is a integer value. In order for the model to use the data, we need to first convert the data into a matrix of either 4x6 or 5x5 (the case of this tutorial) and then normalize the data to between 0 and 1." + "The data has 20 variables and each is a integer value. In order for the model to use the data, we need to normalize the data to between 0 and 1." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def load_GCN_data():\n", - " f = open(\"german.data-numeric\")\n", - " line = f.readline()\n", - " X = []\n", - " while line:\n", - " ll = line\n", - " while ' ' in ll:\n", - " ll = ll.replace(' ',' ')\n", - " if ll[0]==' ':\n", - " ll = ll[1:]\n", - " if ll[-1]=='\\n':\n", - " ll = ll[:-1]\n", - " if ll[-1]==' ':\n", - " ll = ll[:-1]\n", - " x = ll.split(' ')\n", - " x_int = []\n", - " for i in x:\n", - " x_int.append(int(i))\n", - " X.append(x_int)\n", - " line = f.readline()\n", - " f.close()\n", - " X_temp = K.convert_to_tensor(X)\n", - " X = []\n", - " Y = []\n", - " X_temp_transpose = K.transpose(K.convert_to_tensor(X_temp))\n", - " X_temp_max = []\n", - " for i in range(len(X_temp_transpose)):\n", - " X_temp_max.append(max(X_temp_transpose[i]))\n", - " X_temp_max = K.convert_to_tensor(X_temp_max)\n", - " final_digit = K.cast([0],'int32')\n", - " for i in X_temp:\n", - " Y.append(i[-1]-1)\n", - " X.append(K.divide(K.concat([i[:24],final_digit],0), X_temp_max))\n", - " Y = K.cast(K.convert_to_tensor(Y),'float32')\n", - " X = K.cast(K.convert_to_tensor(X),'float32')\n", - " return (X[:800],Y[:800]),(X[800:],Y[800:])\n", - "\n", + " link2gcn = \"http://home.cse.ust.hk/~qyang/221/Assignments/German/GermanData.csv\"\n", + " data = requests.get(link2gcn)\n", + " data = data.text\n", + " data = data.split(\"\\n\")[:-1]\n", + " x = None\n", + " y = None\n", + " def destring(string):\n", + " string = string.split(\",\")\n", + " return_array = []\n", + " for i, v in enumerate(string):\n", + " if v[0] == 'A':\n", + " return_array.append(int(v[1+len(str(i)):]))\n", + " else:\n", + " return_array.append(int(v))\n", + " return K.cast([return_array[:-1]], dtype=\"float32\"), K.cast([return_array[-1]-1], dtype=\"int32\")\n", + " for i in data:\n", + " if x is None:\n", + " temp_x, temp_y = destring(i)\n", + " x = K.cast(temp_x, dtype=\"float32\")\n", + " y = K.cast(temp_y, dtype=\"int32\")\n", + " else:\n", + " temp_x, temp_y = destring(i)\n", + " x = K.concat([x, temp_x], axis=0)\n", + " y = K.concat([y, temp_y], axis=0)\n", + " x = K.transpose(x)\n", + " nx = None\n", + " for i in x:\n", + " max_i = K.cast(K.max(i),dtype=\"float32\")\n", + " temp_nx = [K.divide(i, max_i)]\n", + " nx = K.concat([nx, temp_nx], axis=0) if nx is not None else temp_nx\n", + " x = K.transpose(nx)\n", + " return (x[:800],y[:800]),(x[800:],y[800:])\n", + " \n", "(x_train, y_train), (x_test, y_test) = load_GCN_data()" ] }, @@ -110,26 +108,26 @@ "source": [ "## Quantum Model\n", "\n", - "This quantum model takes in 5x5 matrices as input and output the state of 5 qbits. The model is shown below:" + "This quantum model takes in 1x20 matrices as input and output the state of 5 qbits. The model is shown below:" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def quantumTran(inputs):\n", " c = tc.Circuit(5)\n", - " for i in range(5):\n", + " for i in range(4):\n", " if i%2 == 0:\n", " for j in range(5):\n", - " c.rx(j, theta=(0 if i*5+j >= 25 else inputs[i*5+j]))\n", - " for j in range(4):\n", - " c.cnot(j, j+1)\n", + " c.rx(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n", " else:\n", " for j in range(5):\n", - " c.rz(j, theta=(0 if i*5+j >= 25 else inputs[i*5+j]))\n", + " c.rz(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n", + " for j in range(4):\n", + " c.cnot(j, j+1)\n", " return c.state()\n", "\n", "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" @@ -146,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -182,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -206,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -214,20 +212,20 @@ "output_type": "stream", "text": [ "\n", - "Accuracy:(linear as kernel) 0.79\n", - "time: 0.009650945663452148 seconds\n", + "Accuracy:(linear as kernel) 0.78\n", + "time: 0.007764101028442383 seconds\n", "\n", - "Accuracy:(poly as kernel) 0.77\n", - "time: 0.010898828506469727 seconds\n", + "Accuracy:(poly as kernel) 0.75\n", + "time: 0.024492979049682617 seconds\n", "\n", - "Accuracy:(rbf as kernel) 0.775\n", - "time: 0.012045145034790039 seconds\n", + "Accuracy:(rbf as kernel) 0.765\n", + "time: 0.011505126953125 seconds\n", "\n", - "Accuracy:(sigmoid as kernel) 0.565\n", - "time: 0.01863694190979004 seconds\n", + "Accuracy:(sigmoid as kernel) 0.695\n", + "time: 0.010205984115600586 seconds\n", "\n", - "Accuracy:(qml as kernel) 0.635\n", - "time: 6.367200136184692 seconds\n" + "Accuracy:(qml as kernel) 0.66\n", + "time: 3.0243749618530273 seconds\n" ] } ], diff --git a/docs/source/tutorials/sklearn_svc_cn.ipynb b/docs/source/tutorials/sklearn_svc_cn.ipynb index 241cfc35..5c215f7e 100644 --- a/docs/source/tutorials/sklearn_svc_cn.ipynb +++ b/docs/source/tutorials/sklearn_svc_cn.ipynb @@ -27,10 +27,10 @@ "source": [ "## 设置\n", "\n", - "安装`scikit-learn`。下载数据集[`GCN`](https://archive.ics.uci.edu/dataset/144/statlog+german+credit+data)并存储为`german.data-numeric`。\n", + "安装 `scikit-learn` 和 `requests`. 本模型测试数据为 [德国信用]The data that is going to be used is [German Credit Data by UCI](http://home.cse.ust.hk/~qyang/221/Assignments/German/GermanData.csv)\n", "\n", "```bash\n", - "pip install scikit-learn\n", + "pip install scikit-learn requests\n", "```" ] }, @@ -45,6 +45,7 @@ "from sklearn.svm import SVC\n", "from sklearn import metrics\n", "from time import time\n", + "import requests\n", "\n", "K = tc.set_backend(\"tensorflow\")" ] @@ -55,7 +56,7 @@ "source": [ "## 数据处理\n", "\n", - "数据集包含24个变量，每个变量都是整数值。为了使模型能够使用数据，我们需要首先将数据转换为4x6或5x5的矩阵（本教程的情况），然后将数据归一化为0到1之间。" + "数据集包含20个变量，每个变量都是整数值。为了使模型能够使用数据，我们需要将数据归一化为0到1之间。" ] }, { @@ -65,42 +66,39 @@ "outputs": [], "source": [ "def load_GCN_data():\n", - " f = open(\"german.data-numeric\")\n", - " line = f.readline()\n", - " X = []\n", - " while line:\n", - " ll = line\n", - " while ' ' in ll:\n", - " ll = ll.replace(' ',' ')\n", - " if ll[0]==' ':\n", - " ll = ll[1:]\n", - " if ll[-1]=='\\n':\n", - " ll = ll[:-1]\n", - " if ll[-1]==' ':\n", - " ll = ll[:-1]\n", - " x = ll.split(' ')\n", - " x_int = []\n", - " for i in x:\n", - " x_int.append(int(i))\n", - " X.append(x_int)\n", - " line = f.readline()\n", - " f.close()\n", - " X_temp = K.convert_to_tensor(X)\n", - " X = []\n", - " Y = []\n", - " X_temp_transpose = K.transpose(K.convert_to_tensor(X_temp))\n", - " X_temp_max = []\n", - " for i in range(len(X_temp_transpose)):\n", - " X_temp_max.append(max(X_temp_transpose[i]))\n", - " X_temp_max = K.convert_to_tensor(X_temp_max)\n", - " final_digit = K.cast([0],'int32')\n", - " for i in X_temp:\n", - " Y.append(i[-1]-1)\n", - " X.append(K.divide(K.concat([i[:24],final_digit],0), X_temp_max))\n", - " Y = K.cast(K.convert_to_tensor(Y),'float32')\n", - " X = K.cast(K.convert_to_tensor(X),'float32')\n", - " return (X[:800],Y[:800]),(X[800:],Y[800:])\n", - "\n", + " link2gcn = \"http://home.cse.ust.hk/~qyang/221/Assignments/German/GermanData.csv\"\n", + " data = requests.get(link2gcn)\n", + " data = data.text\n", + " data = data.split(\"\\n\")[:-1]\n", + " x = None\n", + " y = None\n", + " def destring(string):\n", + " string = string.split(\",\")\n", + " return_array = []\n", + " for i, v in enumerate(string):\n", + " if v[0] == 'A':\n", + " return_array.append(int(v[1+len(str(i)):]))\n", + " else:\n", + " return_array.append(int(v))\n", + " return K.cast([return_array[:-1]], dtype=\"float32\"), K.cast([return_array[-1]-1], dtype=\"int32\")\n", + " for i in data:\n", + " if x is None:\n", + " temp_x, temp_y = destring(i)\n", + " x = K.cast(temp_x, dtype=\"float32\")\n", + " y = K.cast(temp_y, dtype=\"int32\")\n", + " else:\n", + " temp_x, temp_y = destring(i)\n", + " x = K.concat([x, temp_x], axis=0)\n", + " y = K.concat([y, temp_y], axis=0)\n", + " x = K.transpose(x)\n", + " nx = None\n", + " for i in x:\n", + " max_i = K.cast(K.max(i),dtype=\"float32\")\n", + " temp_nx = [K.divide(i, max_i)]\n", + " nx = K.concat([nx, temp_nx], axis=0) if nx is not None else temp_nx\n", + " x = K.transpose(nx)\n", + " return (x[:800],y[:800]),(x[800:],y[800:])\n", + " \n", "(x_train, y_train), (x_test, y_test) = load_GCN_data()" ] }, @@ -110,7 +108,7 @@ "source": [ "## 量子模型\n", "\n", - "这个量子模型是输入为5x5矩阵，并输出为5个量子比特的状态。模型如下所示：" + "这个量子模型是输入为1x20的矩阵，并输出为5个量子比特的状态。模型如下所示：" ] }, { @@ -121,15 +119,15 @@ "source": [ "def quantumTran(inputs):\n", " c = tc.Circuit(5)\n", - " for i in range(5):\n", + " for i in range(4):\n", " if i%2 == 0:\n", " for j in range(5):\n", - " c.rx(j, theta=(0 if i*5+j >= 25 else inputs[i*5+j]))\n", - " for j in range(4):\n", - " c.cnot(j, j+1)\n", + " c.rx(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n", " else:\n", " for j in range(5):\n", - " c.rz(j, theta=(0 if i*5+j >= 25 else inputs[i*5+j]))\n", + " c.rz(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n", + " for j in range(4):\n", + " c.cnot(j, j+1)\n", " return c.state()\n", "\n", "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" @@ -214,20 +212,20 @@ "output_type": "stream", "text": [ "\n", - "Accuracy:(linear as kernel) 0.79\n", - "time: 0.009594917297363281 seconds\n", + "Accuracy:(linear as kernel) 0.78\n", + "time: 0.00810384750366211 seconds\n", "\n", - "Accuracy:(poly as kernel) 0.77\n", - "time: 0.010785818099975586 seconds\n", + "Accuracy:(poly as kernel) 0.75\n", + "time: 0.024804115295410156 seconds\n", "\n", - "Accuracy:(rbf as kernel) 0.775\n", - "time: 0.012056112289428711 seconds\n", + "Accuracy:(rbf as kernel) 0.765\n", + "time: 0.011444091796875 seconds\n", "\n", - "Accuracy:(sigmoid as kernel) 0.565\n", - "time: 0.017444133758544922 seconds\n", + "Accuracy:(sigmoid as kernel) 0.695\n", + "time: 0.010396003723144531 seconds\n", "\n", - "Accuracy:(qml as kernel) 0.635\n", - "time: 6.606667995452881 seconds\n" + "Accuracy:(qml as kernel) 0.66\n", + "time: 6.472219228744507 seconds\n" ] } ], From 51344936d863b040462a07c2a98ef595f2d42e47 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 16 Jul 2023 12:34:32 +0800 Subject: [PATCH 562/725] amend black --- docs/source/tutorials/sklearn_svc.ipynb | 48 ++++++++++++---------- docs/source/tutorials/sklearn_svc_cn.ipynb | 48 ++++++++++++---------- requirements/requirements-dev.txt | 2 +- 3 files changed, 55 insertions(+), 43 deletions(-) diff --git a/docs/source/tutorials/sklearn_svc.ipynb b/docs/source/tutorials/sklearn_svc.ipynb index 441abcee..59bfbef1 100644 --- a/docs/source/tutorials/sklearn_svc.ipynb +++ b/docs/source/tutorials/sklearn_svc.ipynb @@ -72,15 +72,19 @@ " data = data.split(\"\\n\")[:-1]\n", " x = None\n", " y = None\n", + "\n", " def destring(string):\n", " string = string.split(\",\")\n", " return_array = []\n", " for i, v in enumerate(string):\n", - " if v[0] == 'A':\n", - " return_array.append(int(v[1+len(str(i)):]))\n", + " if v[0] == \"A\":\n", + " return_array.append(int(v[1 + len(str(i)) :]))\n", " else:\n", " return_array.append(int(v))\n", - " return K.cast([return_array[:-1]], dtype=\"float32\"), K.cast([return_array[-1]-1], dtype=\"int32\")\n", + " return K.cast([return_array[:-1]], dtype=\"float32\"), K.cast(\n", + " [return_array[-1] - 1], dtype=\"int32\"\n", + " )\n", + "\n", " for i in data:\n", " if x is None:\n", " temp_x, temp_y = destring(i)\n", @@ -93,12 +97,13 @@ " x = K.transpose(x)\n", " nx = None\n", " for i in x:\n", - " max_i = K.cast(K.max(i),dtype=\"float32\")\n", + " max_i = K.cast(K.max(i), dtype=\"float32\")\n", " temp_nx = [K.divide(i, max_i)]\n", " nx = K.concat([nx, temp_nx], axis=0) if nx is not None else temp_nx\n", " x = K.transpose(nx)\n", - " return (x[:800],y[:800]),(x[800:],y[800:])\n", - " \n", + " return (x[:800], y[:800]), (x[800:], y[800:])\n", + "\n", + "\n", "(x_train, y_train), (x_test, y_test) = load_GCN_data()" ] }, @@ -120,17 +125,18 @@ "def quantumTran(inputs):\n", " c = tc.Circuit(5)\n", " for i in range(4):\n", - " if i%2 == 0:\n", + " if i % 2 == 0:\n", " for j in range(5):\n", - " c.rx(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n", + " c.rx(j, theta=(0 if i * 5 + j >= 20 else inputs[i * 5 + j]))\n", " else:\n", " for j in range(5):\n", - " c.rz(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n", + " c.rz(j, theta=(0 if i * 5 + j >= 20 else inputs[i * 5 + j]))\n", " for j in range(4):\n", - " c.cnot(j, j+1)\n", + " c.cnot(j, j + 1)\n", " return c.state()\n", "\n", - "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" + "\n", + "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" ] }, { @@ -149,7 +155,7 @@ "outputs": [], "source": [ "def quantum_kernel(quantumTran, data_x, data_y):\n", - " def kernel(x,y):\n", + " def kernel(x, y):\n", " x = K.convert_to_tensor(x)\n", " y = K.convert_to_tensor(y)\n", " x_qt = None\n", @@ -157,15 +163,16 @@ " if i == 0:\n", " x_qt = K.convert_to_tensor([quantumTran(x1)])\n", " else:\n", - " x_qt = K.concat([x_qt,[quantumTran(x1)]],0)\n", + " x_qt = K.concat([x_qt, [quantumTran(x1)]], 0)\n", " y_qt = None\n", " for i, x1 in enumerate(y):\n", " if i == 0:\n", " y_qt = K.convert_to_tensor([quantumTran(x1)])\n", " else:\n", - " y_qt = K.concat([y_qt,[quantumTran(x1)]],0)\n", + " y_qt = K.concat([y_qt, [quantumTran(x1)]], 0)\n", " data_ret = K.cast(K.power(K.abs(x_qt @ K.transpose(y_qt)), 2), \"float32\")\n", " return data_ret\n", + "\n", " clf = SVC(kernel=kernel)\n", " clf.fit(data_x, data_y)\n", " return clf" @@ -185,7 +192,7 @@ "outputs": [], "source": [ "def standard_kernel(data_x, data_y, method):\n", - " methods = ['linear', 'poly', 'rbf', 'sigmoid']\n", + " methods = [\"linear\", \"poly\", \"rbf\", \"sigmoid\"]\n", " if method not in methods:\n", " raise ValueError(\"method must be one of %r.\" % methods)\n", " clf = SVC(kernel=method)\n", @@ -230,27 +237,26 @@ } ], "source": [ - "methods = ['linear', 'poly', 'rbf', 'sigmoid']\n", + "methods = [\"linear\", \"poly\", \"rbf\", \"sigmoid\"]\n", "\n", "for method in methods:\n", - " \n", " print()\n", " t = time()\n", "\n", " k = standard_kernel(data_x=x_train, data_y=y_train, method=method)\n", " y_pred = k.predict(x_test)\n", - " print(\"Accuracy:(%s as kernel)\" % method,metrics.accuracy_score(y_test, y_pred))\n", + " print(\"Accuracy:(%s as kernel)\" % method, metrics.accuracy_score(y_test, y_pred))\n", "\n", - " print(\"time:\",time()-t,'seconds')\n", + " print(\"time:\", time() - t, \"seconds\")\n", "\n", "print()\n", "t = time()\n", "\n", "k = quantum_kernel(quantumTran=func_qt, data_x=x_train, data_y=y_train)\n", "y_pred = k.predict(x_test)\n", - "print(\"Accuracy:(qml as kernel)\",metrics.accuracy_score(y_test, y_pred))\n", + "print(\"Accuracy:(qml as kernel)\", metrics.accuracy_score(y_test, y_pred))\n", "\n", - "print(\"time:\",time()-t,'seconds')" + "print(\"time:\", time() - t, \"seconds\")" ] }, { diff --git a/docs/source/tutorials/sklearn_svc_cn.ipynb b/docs/source/tutorials/sklearn_svc_cn.ipynb index 5c215f7e..f33ea424 100644 --- a/docs/source/tutorials/sklearn_svc_cn.ipynb +++ b/docs/source/tutorials/sklearn_svc_cn.ipynb @@ -72,15 +72,19 @@ " data = data.split(\"\\n\")[:-1]\n", " x = None\n", " y = None\n", + "\n", " def destring(string):\n", " string = string.split(\",\")\n", " return_array = []\n", " for i, v in enumerate(string):\n", - " if v[0] == 'A':\n", - " return_array.append(int(v[1+len(str(i)):]))\n", + " if v[0] == \"A\":\n", + " return_array.append(int(v[1 + len(str(i)) :]))\n", " else:\n", " return_array.append(int(v))\n", - " return K.cast([return_array[:-1]], dtype=\"float32\"), K.cast([return_array[-1]-1], dtype=\"int32\")\n", + " return K.cast([return_array[:-1]], dtype=\"float32\"), K.cast(\n", + " [return_array[-1] - 1], dtype=\"int32\"\n", + " )\n", + "\n", " for i in data:\n", " if x is None:\n", " temp_x, temp_y = destring(i)\n", @@ -93,12 +97,13 @@ " x = K.transpose(x)\n", " nx = None\n", " for i in x:\n", - " max_i = K.cast(K.max(i),dtype=\"float32\")\n", + " max_i = K.cast(K.max(i), dtype=\"float32\")\n", " temp_nx = [K.divide(i, max_i)]\n", " nx = K.concat([nx, temp_nx], axis=0) if nx is not None else temp_nx\n", " x = K.transpose(nx)\n", - " return (x[:800],y[:800]),(x[800:],y[800:])\n", - " \n", + " return (x[:800], y[:800]), (x[800:], y[800:])\n", + "\n", + "\n", "(x_train, y_train), (x_test, y_test) = load_GCN_data()" ] }, @@ -120,17 +125,18 @@ "def quantumTran(inputs):\n", " c = tc.Circuit(5)\n", " for i in range(4):\n", - " if i%2 == 0:\n", + " if i % 2 == 0:\n", " for j in range(5):\n", - " c.rx(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n", + " c.rx(j, theta=(0 if i * 5 + j >= 20 else inputs[i * 5 + j]))\n", " else:\n", " for j in range(5):\n", - " c.rz(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n", + " c.rz(j, theta=(0 if i * 5 + j >= 20 else inputs[i * 5 + j]))\n", " for j in range(4):\n", - " c.cnot(j, j+1)\n", + " c.cnot(j, j + 1)\n", " return c.state()\n", "\n", - "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" + "\n", + "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)" ] }, { @@ -149,7 +155,7 @@ "outputs": [], "source": [ "def quantum_kernel(quantumTran, data_x, data_y):\n", - " def kernel(x,y):\n", + " def kernel(x, y):\n", " x = K.convert_to_tensor(x)\n", " y = K.convert_to_tensor(y)\n", " x_qt = None\n", @@ -157,15 +163,16 @@ " if i == 0:\n", " x_qt = K.convert_to_tensor([quantumTran(x1)])\n", " else:\n", - " x_qt = K.concat([x_qt,[quantumTran(x1)]],0)\n", + " x_qt = K.concat([x_qt, [quantumTran(x1)]], 0)\n", " y_qt = None\n", " for i, x1 in enumerate(y):\n", " if i == 0:\n", " y_qt = K.convert_to_tensor([quantumTran(x1)])\n", " else:\n", - " y_qt = K.concat([y_qt,[quantumTran(x1)]],0)\n", + " y_qt = K.concat([y_qt, [quantumTran(x1)]], 0)\n", " data_ret = K.cast(K.power(K.abs(x_qt @ K.transpose(y_qt)), 2), \"float32\")\n", " return data_ret\n", + "\n", " clf = SVC(kernel=kernel)\n", " clf.fit(data_x, data_y)\n", " return clf" @@ -185,7 +192,7 @@ "outputs": [], "source": [ "def standard_kernel(data_x, data_y, method):\n", - " methods = ['linear', 'poly', 'rbf', 'sigmoid']\n", + " methods = [\"linear\", \"poly\", \"rbf\", \"sigmoid\"]\n", " if method not in methods:\n", " raise ValueError(\"method must be one of %r.\" % methods)\n", " clf = SVC(kernel=method)\n", @@ -230,27 +237,26 @@ } ], "source": [ - "methods = ['linear', 'poly', 'rbf', 'sigmoid']\n", + "methods = [\"linear\", \"poly\", \"rbf\", \"sigmoid\"]\n", "\n", "for method in methods:\n", - " \n", " print()\n", " t = time()\n", "\n", " k = standard_kernel(data_x=x_train, data_y=y_train, method=method)\n", " y_pred = k.predict(x_test)\n", - " print(\"Accuracy:(%s as kernel)\" % method,metrics.accuracy_score(y_test, y_pred))\n", + " print(\"Accuracy:(%s as kernel)\" % method, metrics.accuracy_score(y_test, y_pred))\n", "\n", - " print(\"time:\",time()-t,'seconds')\n", + " print(\"time:\", time() - t, \"seconds\")\n", "\n", "print()\n", "t = time()\n", "\n", "k = quantum_kernel(quantumTran=func_qt, data_x=x_train, data_y=y_train)\n", "y_pred = k.predict(x_test)\n", - "print(\"Accuracy:(qml as kernel)\",metrics.accuracy_score(y_test, y_pred))\n", + "print(\"Accuracy:(qml as kernel)\", metrics.accuracy_score(y_test, y_pred))\n", "\n", - "print(\"time:\",time()-t,'seconds')" + "print(\"time:\", time() - t, \"seconds\")" ] }, { diff --git a/requirements/requirements-dev.txt b/requirements/requirements-dev.txt index 6401ab30..753fe704 100644 --- a/requirements/requirements-dev.txt +++ b/requirements/requirements-dev.txt @@ -3,7 +3,7 @@ pytest==6.2.4 pytest-cov pytest-benchmark pytest-xdist -black==23.3.0 +black[jupyter]==23.3.0 sphinx>=4.0 pytest-lazy-fixture pylint==2.11.1 From cfdbc4662f5ae9c6a9838e88497a0aa28ac1aa08 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 16 Jul 2023 16:02:21 +0800 Subject: [PATCH 563/725] modify title level --- docs/source/tutorials/sklearn_svc.ipynb | 3 +-- docs/source/tutorials/sklearn_svc_cn.ipynb | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/docs/source/tutorials/sklearn_svc.ipynb b/docs/source/tutorials/sklearn_svc.ipynb index 59bfbef1..5226eb08 100644 --- a/docs/source/tutorials/sklearn_svc.ipynb +++ b/docs/source/tutorials/sklearn_svc.ipynb @@ -7,7 +7,6 @@ "# Support Vector Classification with SKLearn\n", "\n", "Authored by [_Mark (Zixuan) Song_](https://marksong.tech)\n", - "- - -\n", "\n", "We use the `SKLearn` library to implement `SVC` in the following tutorial." ] @@ -16,7 +15,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Overview\n", + "## Overview\n", "\n", "The aim of this tutorial is to implant a quantum machine learning (QML) transformer into SVC pipeline. And this is a general introduction to connect `tensorcircuit` with `scikit-learn`." ] diff --git a/docs/source/tutorials/sklearn_svc_cn.ipynb b/docs/source/tutorials/sklearn_svc_cn.ipynb index f33ea424..c737dc72 100644 --- a/docs/source/tutorials/sklearn_svc_cn.ipynb +++ b/docs/source/tutorials/sklearn_svc_cn.ipynb @@ -7,7 +7,6 @@ "# 结合SKLearn实现的支持向量分类\n", "\n", "[_Mark (Zixuan) Song_](https://marksong.tech) 撰写\n", - "- - -\n", "\n", "本示例结合了`sklearn`库中的`SVC`类，实现了支持向量分类。" ] @@ -16,7 +15,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 概述\n", + "## 概述\n", "\n", "本示例的目的是将量子机器学习（QML）转换器嵌入到SVC管道中并且介绍`tensorcircuit`与`scikit-learn`的一种连接方式。" ] From cbd641bd0d9c4b3e3248f9b8375f7bd125fd6518 Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Sun, 16 Jul 2023 19:17:25 +0100 Subject: [PATCH 564/725] added tests V1.5 --- tests/test_qaoa.py | 59 +++++++++++++++++++++++++++++++++++++++++ tests/test_templates.py | 31 ++++++++++++++++++++++ 2 files changed, 90 insertions(+) diff --git a/tests/test_qaoa.py b/tests/test_qaoa.py index fae3c69a..a1b762f9 100644 --- a/tests/test_qaoa.py +++ b/tests/test_qaoa.py @@ -7,11 +7,14 @@ sys.path.insert(0, modulepath) import numpy as np +import pytest from tensorcircuit.applications.dqas import set_op_pool from tensorcircuit.applications.graphdata import get_graph from tensorcircuit.applications.layers import Hlayer, rxlayer, zzlayer from tensorcircuit.applications.vags import evaluate_vag +from tensorcircuit.templates.ansatz import QAOA_ansatz_for_Ising +from tensorcircuit.circuit import Circuit def test_vag(tfb): @@ -25,3 +28,59 @@ def test_vag(tfb): ) print(expene, eneg, p) np.testing.assert_allclose(ene.numpy(), -7.01, rtol=1e-2) + + +cases = [ + ("X", True), + ("X", False), + ("XY", True), + ("XY", False), + ("ZZ", True), + ("ZZ", False), +] + + +@pytest.fixture +def example_inputs(): + params = [0.1, 0.2, 0.3, 0.4] + nlayers = 2 + pauli_terms = [[0, 1, 0], [1, 0, 1]] + weights = [0.5, -0.5] + return params, nlayers, pauli_terms, weights + + +@pytest.mark.parametrize("mixer, full_coupling", cases) +def test_QAOA_ansatz_for_Ising(example_inputs, full_coupling, mixer): + params, nlayers, pauli_terms, weights = example_inputs + circuit = QAOA_ansatz_for_Ising( + params, nlayers, pauli_terms, weights, full_coupling, mixer + ) + n = len(pauli_terms[0]) + assert isinstance(circuit, Circuit) + assert circuit._nqubits == n + + if mixer == "X": + assert circuit.gate_count() == n + nlayers * (len(pauli_terms) + n) + elif mixer == "XY": + if full_coupling is False: + assert circuit.gate_count() == n + nlayers * (len(pauli_terms) + 2 * n) + else: + assert circuit.gate_count() == n + nlayers * ( + len(pauli_terms) + sum(range(n + 1)) + ) + else: + if full_coupling is False: + assert circuit.gate_count() == n + nlayers * (len(pauli_terms) + n) + else: + assert circuit.gate_count() == n + nlayers * ( + len(pauli_terms) + sum(range(n + 1)) / 2 + ) + + +@pytest.mark.parametrize("mixer, full_coupling", [("AB", True), ("XY", 1), ("TC", 5)]) +def test_QAOA_ansatz_errors(example_inputs, full_coupling, mixer): + params, nlayers, pauli_terms, weights = example_inputs + with pytest.raises(ValueError): + QAOA_ansatz_for_Ising( + params, nlayers, pauli_terms, weights, full_coupling, mixer + ) diff --git a/tests/test_templates.py b/tests/test_templates.py index c22b6a73..fa1941bb 100644 --- a/tests/test_templates.py +++ b/tests/test_templates.py @@ -178,3 +178,34 @@ def f(theta): np.testing.assert_allclose(v, 0.84147, atol=1e-4) np.testing.assert_allclose(g, 0.54032, atol=1e-4) + + +@pytest.fixture +def symmetric_matrix(): + matrix = np.array([[-5.0, -2.0], [-2.0, 6.0]]) + nsym_matrix = np.array( + [[1.0, 2.0, 3.0], [2.0, 4.0, 5.0], [3.0, 5.0, 6.0], [8.0, 7.0, 6.0]] + ) + return matrix, nsym_matrix + + +def test_QUBO_to_Ising(symmetric_matrix): + matrix1, matrix2 = symmetric_matrix + pauli_terms, weights, offset = tc.templates.conversions.QUBO_to_Ising(matrix1) + n = matrix1.shape[0] + expected_num_terms = n + n * (n - 1) // 2 + assert len(pauli_terms) == expected_num_terms + assert len(weights) == expected_num_terms + assert isinstance(pauli_terms, list) + assert isinstance(weights, np.ndarray) + assert isinstance(offset, float) + assert pauli_terms == [ + [1, 0], + [0, 1], + [1, 1], + ] + assert all(weights == np.array([3.5, -2.0, -1.0])) + assert offset == -0.5 + + with pytest.raises(ValueError): + tc.templates.conversions.QUBO_to_Ising(matrix2) From ee21a9f924e4842600f9b8851168ea47aab1db00 Mon Sep 17 00:00:00 2001 From: Felix Xu Date: Mon, 17 Jul 2023 13:16:05 +0100 Subject: [PATCH 565/725] deleted the penalty solver V1.6 --- .../applications/finance/portfolio.py | 77 +------------------ tensorcircuit/applications/optimization.py | 20 +++-- tensorcircuit/templates/ansatz.py | 1 + 3 files changed, 14 insertions(+), 84 deletions(-) diff --git a/tensorcircuit/applications/finance/portfolio.py b/tensorcircuit/applications/finance/portfolio.py index 06d7c0b9..a9097241 100644 --- a/tensorcircuit/applications/finance/portfolio.py +++ b/tensorcircuit/applications/finance/portfolio.py @@ -2,7 +2,7 @@ Supplementary functions for portfolio optimization """ -from typing import Any, List +from typing import Any import numpy as np @@ -41,7 +41,6 @@ class StockData: - __init__(self, data): Initializes the StockData object. - get_return(self, decimals=5): Calculates the annualized return. - get_covariance(self, decimals=5): Calculates the annualized covariance matrix. - - get_penalty(self, cov, ret, risk_pre, budget, decimals=5): Calculates the penalty factor. """ def __init__(self, data: Tensor): @@ -60,12 +59,9 @@ def __init__(self, data: Tensor): self.n_days = len(data[1]) # Calculate the daily percentage price change - self.daily_change = [] - for i in range(self.n_stocks): - each_stock = [] - for j in range(self.n_days - 1): - each_stock.append((data[i][j + 1] - data[i][j]) / data[i][j]) - self.daily_change.append(each_stock) + self.daily_change = [ + np.diff(data[i][:]) / data[i][:-1] for i in range(self.n_stocks) + ] def get_return(self, decimals: int = 5) -> Any: """ @@ -91,68 +87,3 @@ def get_covariance(self, decimals: int = 5) -> Tensor: ] cov = 252 / self.n_days * np.dot(relative_change, np.transpose(relative_change)) return cov.round(decimals) - - def get_penalty( - self, - cov: Tensor, - ret: List[float], - risk_pre: float, - budget: int, - decimals: int = 5, - ) -> float: - """ - Calculates the penalty factor. - - :param cov: The annualized covariance matrix. - :param ret: The annualized return. - :param risk_pre: The risk preference factor. - :param budget: The budget (number of stocks to select). - :param decimals: Number of decimal places to round the result to (default: 5). - :return: The penalty factor rounded to the specified number of decimals. - """ - # Get all feasible and unfeasible states - self.f_state = [] # Feasible states (number of '1's equal to budget) - self.uf_state = [] # Unfeasible states - self.all_state = [] - for i in range(2**self.n_stocks): - state = f"{bin(i)[2:]:0>{self.n_stocks}}" - n_ones = 0 - for j in state: - if j == "1": - n_ones += 1 - self.all_state.append(state) - if n_ones == budget: - self.f_state.append(state) - else: - self.uf_state.append(state) - - # Determine the penalty factor - mark = False - penalty = 0 # Initial value - while mark is False: - R = np.diag(ret) - S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( - np.ones(self.n_stocks) - ) - Q = risk_pre * cov - R + penalty * S - F = [] - for state in self.f_state: - x = np.array([int(bit) for bit in state]) - F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) - Fmin = np.amin(F) - Fbar = np.mean(F) - F = [] - for state in self.uf_state: - x = np.array([int(bit) for bit in state]) - F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) - Fmin_uf = np.amin(F) - location = np.where(F == Fmin_uf)[0][0] - if Fmin_uf < 0.5 * (Fmin + Fbar): - n_ones = 0 - for j in self.uf_state[location]: - if j == "1": - n_ones += 1 - penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 - else: - mark = True # Ready to return the penalty - return round(penalty, decimals) diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index b59bb1e6..a579d6b8 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -9,7 +9,7 @@ import tensorflow as tf import scipy.optimize as optimize -from ..cons import backend, get_backend +from ..cons import backend from ..quantum import measurement_results from ..interfaces import scipy_interface from ..templates.ansatz import QAOA_ansatz_for_Ising @@ -113,9 +113,6 @@ def QUBO_QAOA( :param full_coupling (optional): A flag indicating whether to use all-to-all coupling in mixers. Default is False. :return params: The optimized parameters for the ansatz circuit. """ - if backend != get_backend("tensorflow"): - raise ValueError("`QUBO_QAOA` is designed for tensorflow backend.") - # Check if the backend is set to TensorFlow. Raise an error if it is not. pauli_terms, weights, _ = QUBO_to_Ising(Q) @@ -266,7 +263,7 @@ def cvar_loss( Q: Tensor, nsamples: int, alpha: float, - fake: bool, + expectation_based: bool, params: List[float], ) -> float: """ @@ -276,7 +273,7 @@ def cvar_loss( :param Q: The Q-matrix representing the Quadratic Unconstrained Binary Optimization (QUBO) problem. :param nsamples: The number of samples to take for measurements in the CVaR calculation. :param alpha: The cut-off percentage for CVaR. - :param fake: A flag indicating the type of CVaR ansatz (circuit-based or expectation-based). + :param expectation_based: A flag indicating the type of CVaR ansatz (measurement-based or expectation-based). :param params: The parameters for the QAOA ansatz circuit. :return: The calculated CVaR loss. """ @@ -286,10 +283,10 @@ def cvar_loss( c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights) # Generate the QAOA ansatz circuit for the given parameters. - if fake is False: + if expectation_based is False: return cvar_from_circuit(c, nsamples, Q, alpha) # Calculate CVaR using circuit-based measurement results. - elif fake is True: + elif expectation_based is True: return cvar_from_expectation(c, Q, alpha) # Calculate CVaR using expectation values of the circuit. else: @@ -303,7 +300,7 @@ def QUBO_QAOA_cvar( alpha: int, nsamples: int = 1000, callback: Optional[Callable[[List[float], float], None]] = None, - fake: bool = False, + expectation_based: bool = False, maxiter: int = 1000, init_params: Optional[Tuple[float,]] = None, ) -> Array: @@ -316,11 +313,12 @@ def QUBO_QAOA_cvar( :param alpha: The cut-off percentage for CVaR. :param nsamples: The number of samples for measurements in the CVaR calculation. Default is 1000. :param callback: A callback function to be called after each iteration. Default is None. - :param fake: A flag indicating the type of CVaR ansatz (circuit-based or expectation-based). Default is False. + :param expectation_based: A flag indicating the type of CVaR ansatz (measurement-based or expectation-based). + Default is False. :param maxiter: The maximum number of iterations for the optimization. Default is 1000. :return: The optimized parameters for the ansatz circuit. """ - loss = partial(cvar_loss, nlayers, Q, nsamples, alpha, fake) + loss = partial(cvar_loss, nlayers, Q, nsamples, alpha, expectation_based) f_scipy = scipy_interface(loss, shape=(2 * nlayers,), jit=False, gradient=False) diff --git a/tensorcircuit/templates/ansatz.py b/tensorcircuit/templates/ansatz.py index e24b1ca3..0bb96258 100644 --- a/tensorcircuit/templates/ansatz.py +++ b/tensorcircuit/templates/ansatz.py @@ -28,6 +28,7 @@ def QAOA_ansatz_for_Ising( :param weights: A list of weights corresponding to each Pauli term. :param full_coupling (optional): A flag indicating whether to use all-to-all coupling in mixers. Default is False. :paran mixer (optional): The mixer operator to use. Default is "X". The other options are "XY" and "ZZ". + :return: QAOA ansatz for Ising model. """ nqubits = len(pauli_terms[0]) c: Any = Circ(nqubits) From adc2623eaa920d3c669acfca2124cf04f0343399 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 18 Jul 2023 02:17:46 +0000 Subject: [PATCH 566/725] docs: update README.md [skip ci] --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1ed96c87..f48ee893 100644 --- a/README.md +++ b/README.md @@ -271,7 +271,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. 隐公观鱼
隐公观鱼
💻 ⚠️ WiuYuan
WiuYuan
💡 - Felix Xu
Felix Xu
✅ + Felix Xu
Felix Xu
✅ 💻 ⚠️ Hong-Ye Hu
Hong-Ye Hu
📖 peilin
peilin
✅ From e56b1e3bb0134aa864e4e08fb428e7f58dbe7098 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 18 Jul 2023 02:17:47 +0000 Subject: [PATCH 567/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index 47b9f2b9..2b6aff49 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -247,7 +247,9 @@ "avatar_url": "https://avatars.githubusercontent.com/u/61252303?v=4", "profile": "https://www.linkedin.com/in/felix-xu-16a153196/", "contributions": [ - "tutorial" + "tutorial", + "code", + "test" ] }, { From ec4740c6e5696d784c125edaf27a6977e58c3447 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 21 Jul 2023 10:40:47 +0800 Subject: [PATCH 568/725] improve fss function and fix token multiprocessing issue --- examples/mipt_pideal.py | 1 + tensorcircuit/applications/physics/fss.py | 19 +++++++++++-------- tensorcircuit/cloud/apis.py | 6 +++--- tensorcircuit/experimental.py | 1 + tensorcircuit/mpscircuit.py | 3 ++- 5 files changed, 18 insertions(+), 12 deletions(-) diff --git a/examples/mipt_pideal.py b/examples/mipt_pideal.py index 2a21c02b..c419446b 100644 --- a/examples/mipt_pideal.py +++ b/examples/mipt_pideal.py @@ -12,6 +12,7 @@ K = tc.set_backend("jax") tc.set_dtype("complex128") # tf backend is slow (at least on cpu) +tc.set_contractor("cotengra-16-64") def delete2(pick, plist): diff --git a/tensorcircuit/applications/physics/fss.py b/tensorcircuit/applications/physics/fss.py index 81e12252..6060915d 100644 --- a/tensorcircuit/applications/physics/fss.py +++ b/tensorcircuit/applications/physics/fss.py @@ -18,21 +18,24 @@ def data_collapse( xL: List[List[float]] = [] # x=(p-pc)L^(1/\nv) yL: List[List[float]] = [] # y=S(p,L)-S(pc,L) or S(p,L) pc_list = [] + if not isinstance(p[0], list): + p = [p for _ in n] # type: ignore for n0 in range(len(n)): xL.append([]) yL.append([]) - for p0 in range(len(p)): - xL[n0].append((p[p0] - pc) * (n[n0] ** (1 / nu))) - pc_L = pc_linear_interpolation(p, obs[n0], pc) + for p0 in range(len(p[n0])): # type: ignore + xL[n0].append((p[n0][p0] - pc) * (n[n0] ** (1 / nu))) # type: ignore + pc_L = pc_linear_interpolation(p[n0], obs[n0], pc) # type: ignore if obs_type == 0: - yL[n0].append((obs[n0][p0] - pc_L) * n[n0] ** (beta / nu)) + yL[n0].append((obs[n0][p0] - pc_L) * n[n0] ** beta) # entanglement with only collapse and no crossing else: - yL[n0].append(obs[n0][p0] * n[n0] ** (beta / nu)) + yL[n0].append(obs[n0][p0] * n[n0] ** beta) # tripartite mutual information pc_list.append(pc_L) - - xL_all = np.reshape(xL, -1) + xL_all = [] + for i in range(len(xL)): + xL_all.extend(xL[i]) yL_ave = [] loss = [] for x0 in range(len(xL_all)): @@ -48,7 +51,7 @@ def data_collapse( yL_ave.append(ybar) loss = np.sum(loss) - return pc_list, xL, np.array(yL), loss # type: ignore + return pc_list, xL, yL, loss # type: ignore def pc_linear_interpolation(p: List[float], SA: List[float], pc_input: float) -> float: diff --git a/tensorcircuit/cloud/apis.py b/tensorcircuit/cloud/apis.py index edddb0af..0e4f6eb6 100644 --- a/tensorcircuit/cloud/apis.py +++ b/tensorcircuit/cloud/apis.py @@ -237,9 +237,9 @@ def set_token( if cached: # file_token = backend.tree_map(b64encode_s, saved_token) file_token = {k: b64encode_s(v) for k, v in saved_token.items()} - - with open(authpath, "w") as f: - json.dump(file_token, f) + if file_token: + with open(authpath, "w") as f: + json.dump(file_token, f) return saved_token diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index bd395fb0..85a67a72 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -347,6 +347,7 @@ def grad_f(*args: Any, **kws: Any) -> Any: # TODO(@refraction-ray): add SPSA gradient wrapper similar to parameter shift +# -- using noisyopt package instead def finite_difference_differentiator( diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index 8749d9ef..1c6876ed 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -52,8 +52,9 @@ def split_tensor( return backend.qr(tensor) # type: ignore -# TODO(@refraction-ray): AD + MPS can lead to numerical stability issue +# AD + MPS can lead to numerical stability issue # E ./tensorflow/core/kernels/linalg/svd_op_impl.h:110] Eigen::BDCSVD failed with error code 3 +# this is now solved by setting os.environ["TC_BACKENDS_TENSORFLOW_BACKEND__SVD_TF_EPS"]="10" class MPSCircuit(AbstractCircuit): From 8863095012c3396bd2f3b809edf14adf3a165415 Mon Sep 17 00:00:00 2001 From: liwt31 Date: Wed, 26 Jul 2023 11:09:21 +0800 Subject: [PATCH 569/725] fix zne to qiskit --- tensorcircuit/results/qem/qem_methods.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py index 0dafdf15..7328b3bb 100644 --- a/tensorcircuit/results/qem/qem_methods.py +++ b/tensorcircuit/results/qem/qem_methods.py @@ -66,7 +66,7 @@ def executortc(c): # type: ignore c = Circuit.from_qiskit(c, c.num_qubits) return executor(c) - circuit = circuit.to_qiskit() + circuit = circuit.to_qiskit(enable_instruction=True) result = zne.execute_with_zne( circuit=circuit, executor=executortc, From 1de18a9caa772eff369295b657bb567d3c720792 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sun, 30 Jul 2023 22:29:25 +0800 Subject: [PATCH 570/725] Add shadows.py and repair the typo in gates.py --- tensorcircuit/gates.py | 2 +- tensorcircuit/shadows.py | 282 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 283 insertions(+), 1 deletion(-) create mode 100644 tensorcircuit/shadows.py diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index 40fa9b26..5c5f7e88 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -544,7 +544,7 @@ def r_gate(theta: float = 0, alpha: float = 0, phi: float = 0) -> Gate: General single qubit rotation gate .. math:: - R(\theta, \alpha, \phi) = j \cos(\theta) I + R(\theta, \alpha, \phi) = \cos(\theta) I - j \cos(\phi) \sin(\alpha) \sin(\theta) X - j \sin(\phi) \sin(\alpha) \sin(\theta) Y - j \sin(\theta) \cos(\alpha) Z diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py new file mode 100644 index 00000000..4dc42de7 --- /dev/null +++ b/tensorcircuit/shadows.py @@ -0,0 +1,282 @@ +"""Classical Shadows base class with processing functions""" +from typing import Optional, Sequence +from string import ascii_letters as ABC +from tensorcircuit.cons import backend +from tensorcircuit.circuit import Circuit +import numpy as np + + +def shadow_snapshots(psi, pauli_strings, repeat: int = 1): + ''' + ns: number of snapshots + nq: number of qubits + cir: quantum circuit + pauli_strings = (ns, nq) + repeat: times to measure on one pauli string + + return: + snapshots = (ns, repeat, nq) + ''' + if pauli_strings.dtype not in ("int", "int32"): + raise TypeError("Expected a int data type. " f"Got {pauli_strings.dtype}") + + # if backend.max(pauli_strings) > 2 or backend.min(pauli_strings) < 0: + # raise ValueError("The elements in pauli_strings must be between 0 and 2!") + + angles = backend.cast(backend.convert_to_tensor( + np.array([[-np.pi / 2, np.pi / 4, 0], [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], [0, 0, 0]])), + dtype=pauli_strings.dtype) + + nq = pauli_strings.shape[1] + assert 2 ** nq == len(psi) + + def proj_measure(pauli_string): + # pauli_rot = backend.onehot(pauli_string, num=3) @ angles + pauli_rot = angles[pauli_string] + c_ = Circuit(nq, inputs=psi) + for i, (theta, alpha, phi) in enumerate(pauli_rot): + c_.R(i, theta=theta, alpha=alpha, phi=phi) + return c_.sample(batch=repeat, format="sample_bin") + + vpm = backend.vmap(proj_measure, vectorized_argnums=0) + return vpm(pauli_strings) # (ns, repeat, nq) + + +def snapshot_states(snapshots, pauli_strings): + ''' + ns: number of snapshots + nq: number of qubits + pauli_strings = (ns, nq) or (ns, repeat, nq) + snapshots = (ns, repeat, nq) + + return: + snapshot_states = (ns, repeat, nq, 2, 2) + ''' + if len(pauli_strings.shape) < len(snapshots.shape): + pauli_strings = backend.tile(pauli_strings[:, None, :], (1, snapshots.shape[1], 1)) # (ns, repeat, nq) + + X_dm = backend.cast(np.array([[[1, 1], [1, 1]], [[1, -1], [-1, 1]]]) / 2, dtype=complex) + Y_dm = backend.cast(np.array([[[1, -1j], [1j, 1]], [[1, 1j], [-1j, 1]]]) / 2, dtype=complex) + Z_dm = backend.cast(np.array([[[1, 0], [0, 0]], [[0, 0], [0, 1]]]), dtype=complex) + pauli_dm = backend.convert_to_tensor(backend.stack((X_dm, Y_dm, Z_dm), axis=0)) # (3, 2, 2, 2) + + def dm(pauli, ss): + return pauli_dm[pauli, ss] + + v = backend.vmap(dm, vectorized_argnums=(0, 1)) + vv = backend.vmap(v, vectorized_argnums=(0, 1)) + vvv = backend.vmap(vv, vectorized_argnums=(0, 1)) + + return vvv(pauli_strings, snapshots) + + +def shadow_state(snapshots, pauli_strings, sub: Optional[Sequence[int]] = None): + ''' + ns: number of snapshots + nq: number of qubits + pauli_strings = (ns, nq) or (ns, repeat, nq) + snapshots = (ns, repeat, nq) + + return: + shadow_state = (2 ** nq, 2 ** nq) + ''' + return backend.mean(global_shadow_states(snapshot_states(snapshots, pauli_strings), sub), axis=(0, 1)) + + +def expection_ps_shadow(snapshots, pauli_strings, x: Optional[Sequence[int]] = None, y: Optional[Sequence[int]] = None, + z: Optional[Sequence[int]] = None, ps: Optional[Sequence[int]] = None, k: int = 1): + ''' + ns: number of snapshots + nq: number of qubits + pauli_strings = (ns, nq) or (ns, repeat, nq) + snapshots = (ns, repeat, nq) + + return: + expection = (1,) + ''' + ss_states = snapshot_states(snapshots, pauli_strings) # (ns, repeat, nq, 2, 2) + ns, repeat, nq, _, _ = ss_states.shape + ns *= repeat + ss_states = backend.reshape(ss_states, (ns, nq, 2, 2)) + + if ps is not None: + ps = np.array(ps) # (nq,) + else: + ps = np.zeros(nq, dtype=int) + if x is not None: + for i in x: + ps[i] = 0 + if y is not None: + for i in y: + ps[i] = 1 + if z is not None: + for i in z: + ps[i] = 2 + + paulis = backend.convert_to_tensor( + backend.cast(np.array([[[1, 0], [0, 1]], [[0, 1], [1, 0]], [[0, -1j], [1j, 0]], [[1, 0], [0, -1]]]), + dtype=ss_states.dtype)) + + def sqp(dm, p_idx): + return 3 * backend.real(backend.trace(paulis[p_idx] @ dm)) + + v = backend.vmap(sqp, vectorized_argnums=(0, 1)) # (nq,) + + def prod(dm, p_idx): + tensor = v(dm, p_idx) + return backend.shape_prod(tensor) + + vv = backend.vmap(prod, vectorized_argnums=0) # (ns,) + + batch = ns // k + means = [] + for i in range(0, ns, batch): + means.append(backend.mean(vv(ss_states[i: i + batch], ps))) + return means + + +def entropy_shadow(snapshots, pauli_strings, sub: Optional[Sequence[int]] = None, alpha: int = 1): + ''' + ns: number of snapshots + nq: number of qubits + pauli_strings = (ns, nq) or (ns, repeat, nq) + snapshots = (ns, repeat, nq) + + return: + entropy = (1,) + ''' + if alpha <= 0: + raise ValueError("Alpha should not be less than 1!") + + sdw_rdm = shadow_state(snapshots, pauli_strings, sub) # (2 ** nq, 2 ** nq) + + evs = backend.relu(backend.eigvalsh(sdw_rdm)) + if alpha == 1: + return -backend.sum(evs * backend.relu(backend.log(evs + 1e-15))) + else: + return backend.log(backend.sum(backend.power(evs, alpha))) / (1 - alpha) + + +def local_shadow_states(ss_states, sub: Optional[Sequence[int]] = None): + ''' + ns: number of snapshots + nq: number of qubits + ss_states = (ns, repeat, nq, 2, 2) + + return: + local_shadow_states = (ns, repeat, nq, 2, 2) + ''' + if sub is None: + return 3 * ss_states - backend.eye(2)[None, None, None, :, :] + else: + sub = backend.convert_to_tensor(np.array(sub)) + return 3 * ss_states[:, :, sub] - backend.eye(2)[None, None, None, :, :] + + +def global_shadow_states(ss_states, sub: Optional[Sequence[int]] = None): + ''' + ns: number of snapshots + nq: number of qubits + ss_states = (ns, repeat, nq, 2, 2) + + return: + global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) + ''' + shadow_states = backend.transpose(local_shadow_states(ss_states, sub), (2, 0, 1, 3, 4)) # (nq, ns, repeat, 2, 2) + nq, ns, repeat, _, _ = shadow_states.shape + + old_indices = [f"ab{ABC[2 + 2 * i: 4 + 2 * i]}" for i in range(nq)] + new_indices = f"ab{ABC[2:2 * nq + 2:2]}{ABC[3:2 * nq + 2:2]}" + + return backend.reshape( + backend.einsum(f'{",".join(old_indices)}->{new_indices}', *shadow_states, optimize=True), + (ns, repeat, 2 ** nq, 2 ** nq), + ) + + +def global_shadow_states0(ss_states, sub: Optional[Sequence[int]] = None): + ''' + ns: number of snapshots + nq: number of qubits + ss_states = (ns, repeat, nq, 2, 2) + + return: + global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) + ''' + shadow_states = local_shadow_states(ss_states, sub) # (ns, repeat, nq, 2, 2) + ns, repeat, nq, _, _ = ss_states.shape + + old_indices = [f"{ABC[2 * i: 2 + 2 * i]}" for i in range(nq)] + new_indices = f"{ABC[0:2 * nq:2]}{ABC[1:2 * nq:2]}" + + def tensor_prod(dms): + return backend.reshape(backend.einsum(f'{",".join(old_indices)}->{new_indices}', *dms, optimize=True), + (2 ** nq, 2 ** nq)) + + v = backend.vmap(tensor_prod, vectorized_argnums=0) + vv = backend.vmap(v, vectorized_argnums=0) + return vv(shadow_states) + + +def global_shadow_states1(ss_states, sub: Optional[Sequence[int]] = None): + ''' + ns: number of snapshots + nq: number of qubits + ss_states = (ns, repeat, nq, 2, 2) + + return: + global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) + ''' + shadow_states = local_shadow_states(ss_states, sub) # (ns, repeat, nq, 2, 2) + + def tensor_prod(dms): + res = dms[0] + for dm in dms[1:]: + res = backend.kron(res, dm) + return res + + v = backend.vmap(tensor_prod, vectorized_argnums=0) + vv = backend.vmap(v, vectorized_argnums=0) + return vv(shadow_states) + + +if __name__ == "__main__": + import time + from tensorcircuit import set_backend + backend = set_backend('jax') + N = 6 + + # old_indices = [f"a{ABC[1 + 2 * i: 3 + 2 * i]}" for i in range(N)] + # new_indices = f"a{ABC[1:2 * N + 1:2]}{ABC[2:2 * N + 1:2]}" + # print(old_indices, new_indices) + # exit(0) + + c = Circuit(N) + for i in range(N): + c.H(i) + for i in range(0, 2): + for j in range(N): + c.cnot(j, (j + 1) % N) + for j in range(N): + c.rx(j, theta=0.1) + psi0 = c.state() + # print(c.sample()) + + def classical_shadow(psi, pauli_strings): + snapshots = shadow_snapshots(psi, pauli_strings, repeat=1) + # ss_states = snapshot_states(snapshots, pauli_strings) + # return local_shadow_states(ss_states) + # return global_shadow_states(ss_states) + # return shadow_state(snapshots, pauli_strings) + return expection_ps_shadow(snapshots, pauli_strings, x=[0, 1], y=[3, 4], k=6) + # return entropy_shadow(snapshots, pauli_strings, sub=range(3), alpha=1) + + csjit = backend.jit(classical_shadow) + + pauli_strings = backend.convert_to_tensor(np.random.randint(0, 3, size=(100, N))) + res = csjit(psi0, pauli_strings) + print(res) + + + + From 9e0fbd6a6700b86f0c939881627d1513f1e6ca6a Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 31 Jul 2023 15:23:42 +0800 Subject: [PATCH 571/725] Update shadows.py --- tensorcircuit/shadows.py | 246 +++++++++++++++++++-------------------- 1 file changed, 123 insertions(+), 123 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 4dc42de7..3ff2438c 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -1,8 +1,8 @@ """Classical Shadows base class with processing functions""" from typing import Optional, Sequence from string import ascii_letters as ABC -from tensorcircuit.cons import backend -from tensorcircuit.circuit import Circuit +from .cons import backend +from .circuit import Circuit import numpy as np @@ -20,9 +20,6 @@ def shadow_snapshots(psi, pauli_strings, repeat: int = 1): if pauli_strings.dtype not in ("int", "int32"): raise TypeError("Expected a int data type. " f"Got {pauli_strings.dtype}") - # if backend.max(pauli_strings) > 2 or backend.min(pauli_strings) < 0: - # raise ValueError("The elements in pauli_strings must be between 0 and 2!") - angles = backend.cast(backend.convert_to_tensor( np.array([[-np.pi / 2, np.pi / 4, 0], [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], [0, 0, 0]])), dtype=pauli_strings.dtype) @@ -42,15 +39,16 @@ def proj_measure(pauli_string): return vpm(pauli_strings) # (ns, repeat, nq) -def snapshot_states(snapshots, pauli_strings): +def local_snapshot_states(snapshots, pauli_strings, sub: Optional[Sequence[int]] = None): ''' ns: number of snapshots nq: number of qubits pauli_strings = (ns, nq) or (ns, repeat, nq) snapshots = (ns, repeat, nq) + sub: qubit indices of subsystem return: - snapshot_states = (ns, repeat, nq, 2, 2) + lss_states = (ns, repeat, nq, 2, 2) ''' if len(pauli_strings.shape) < len(snapshots.shape): pauli_strings = backend.tile(pauli_strings[:, None, :], (1, snapshots.shape[1], 1)) # (ns, repeat, nq) @@ -67,37 +65,85 @@ def dm(pauli, ss): vv = backend.vmap(v, vectorized_argnums=(0, 1)) vvv = backend.vmap(vv, vectorized_argnums=(0, 1)) - return vvv(pauli_strings, snapshots) + lss_states = vvv(pauli_strings, snapshots) + if sub is not None: + sub = backend.convert_to_tensor(np.array(sub)) + lss_states = lss_states[:, :, sub] + return 3 * lss_states - backend.eye(2)[None, None, None, :, :] -def shadow_state(snapshots, pauli_strings, sub: Optional[Sequence[int]] = None): +def global_snapshot_states(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): ''' ns: number of snapshots nq: number of qubits - pauli_strings = (ns, nq) or (ns, repeat, nq) - snapshots = (ns, repeat, nq) + snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) + pauli_strings = None or (ns, nq) or (ns, repeat, nq) + sub: qubit indices of subsystem + + return: + global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) + ''' + if pauli_strings is not None: + assert len(snapshots.shape) == 3 + lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) + else: + if sub is not None: + sub = backend.convert_to_tensor(np.array(sub)) + lss_states = snapshots[:, :, sub] # (ns, repeat, nq_sub, 2, 2) + else: + lss_states = snapshots # (ns, repeat, nq, 2, 2) + + def tensor_prod(dms): + res = dms[0] + for dm in dms[1:]: + res = backend.kron(res, dm) + return res + + v = backend.vmap(tensor_prod, vectorized_argnums=0) + vv = backend.vmap(v, vectorized_argnums=0) + return vv(lss_states) + + +def shadow_state(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): + ''' + ns: number of snapshots + nq: number of qubits + snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) + or gss_states = (ns, repeat, 2 ** nq, 2 ** nq) + pauli_strings = None or (ns, nq) or (ns, repeat, nq) + sub: qubit indices of subsystem return: shadow_state = (2 ** nq, 2 ** nq) ''' - return backend.mean(global_shadow_states(snapshot_states(snapshots, pauli_strings), sub), axis=(0, 1)) + if len(snapshots.shape) == 4: + assert sub is None + gss_states = snapshots # (ns, repeat, 2 ** nq, 2 ** nq) + else: + gss_states = global_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, 2 ** nq_sub, 2 ** nq_sub) + return backend.mean(gss_states, axis=(0, 1)) -def expection_ps_shadow(snapshots, pauli_strings, x: Optional[Sequence[int]] = None, y: Optional[Sequence[int]] = None, - z: Optional[Sequence[int]] = None, ps: Optional[Sequence[int]] = None, k: int = 1): +def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int]] = None, + y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, + ps: Optional[Sequence[int]] = None, k: int = 1): ''' ns: number of snapshots nq: number of qubits - pauli_strings = (ns, nq) or (ns, repeat, nq) - snapshots = (ns, repeat, nq) + snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) + pauli_strings = None or (ns, nq) or (ns, repeat, nq) return: expection = (1,) ''' - ss_states = snapshot_states(snapshots, pauli_strings) # (ns, repeat, nq, 2, 2) - ns, repeat, nq, _, _ = ss_states.shape + if pauli_strings is not None: + assert len(snapshots.shape) == 3 + lss_states = local_snapshot_states(snapshots, pauli_strings) # (ns, repeat, nq, 2, 2) + else: + lss_states = snapshots # (ns, repeat, nq, 2, 2) + ns, repeat, nq, _, _ = lss_states.shape ns *= repeat - ss_states = backend.reshape(ss_states, (ns, nq, 2, 2)) + ss_states = backend.reshape(lss_states, (ns, nq, 2, 2)) if ps is not None: ps = np.array(ps) # (nq,) @@ -105,25 +151,25 @@ def expection_ps_shadow(snapshots, pauli_strings, x: Optional[Sequence[int]] = N ps = np.zeros(nq, dtype=int) if x is not None: for i in x: - ps[i] = 0 + ps[i] = 1 if y is not None: for i in y: - ps[i] = 1 + ps[i] = 2 if z is not None: for i in z: - ps[i] = 2 + ps[i] = 3 paulis = backend.convert_to_tensor( backend.cast(np.array([[[1, 0], [0, 1]], [[0, 1], [1, 0]], [[0, -1j], [1j, 0]], [[1, 0], [0, -1]]]), - dtype=ss_states.dtype)) + dtype=ss_states.dtype)) # (4, 2, 2) def sqp(dm, p_idx): - return 3 * backend.real(backend.trace(paulis[p_idx] @ dm)) + return backend.real(backend.trace(paulis[p_idx] @ dm)) v = backend.vmap(sqp, vectorized_argnums=(0, 1)) # (nq,) - def prod(dm, p_idx): - tensor = v(dm, p_idx) + def prod(dm): + tensor = v(dm, ps) return backend.shape_prod(tensor) vv = backend.vmap(prod, vectorized_argnums=0) # (ns,) @@ -131,80 +177,93 @@ def prod(dm, p_idx): batch = ns // k means = [] for i in range(0, ns, batch): - means.append(backend.mean(vv(ss_states[i: i + batch], ps))) + ans = vv(ss_states[i: i + batch]) + means.append(backend.mean(ans)) return means -def entropy_shadow(snapshots, pauli_strings, sub: Optional[Sequence[int]] = None, alpha: int = 1): +def entropy_shadow(ss_or_sd, pauli_strings=None, sub: Optional[Sequence[int]] = None, alpha: int = 1): + ''' + ns: number of snapshots + nq: number of qubits + snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) + or gss_states = (ns, repeat, 2 ** nq, 2 ** nq) or shadow_state = (2 ** nq, 2 ** nq) + pauli_strings = None or (ns, nq) or (ns, repeat, nq) + sub: qubit indices of subsystem + + return: + entropy = (1,) ''' - ns: number of snapshots - nq: number of qubits - pauli_strings = (ns, nq) or (ns, repeat, nq) - snapshots = (ns, repeat, nq) - - return: - entropy = (1,) - ''' if alpha <= 0: raise ValueError("Alpha should not be less than 1!") - sdw_rdm = shadow_state(snapshots, pauli_strings, sub) # (2 ** nq, 2 ** nq) + if len(ss_or_sd.shape) == 2 and ss_or_sd.shape[0] == ss_or_sd.shape[1]: + assert sub is None + sdw_rdm = ss_or_sd + else: + sdw_rdm = shadow_state(ss_or_sd, pauli_strings, sub) # (2 ** nq, 2 ** nq) evs = backend.relu(backend.eigvalsh(sdw_rdm)) + evs /= backend.sum(evs) if alpha == 1: - return -backend.sum(evs * backend.relu(backend.log(evs + 1e-15))) + return -backend.sum(evs * backend.log(evs + 1e-15)) else: return backend.log(backend.sum(backend.power(evs, alpha))) / (1 - alpha) -def local_shadow_states(ss_states, sub: Optional[Sequence[int]] = None): +def global_snapshot_states1(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): ''' ns: number of snapshots nq: number of qubits - ss_states = (ns, repeat, nq, 2, 2) - - return: - local_shadow_states = (ns, repeat, nq, 2, 2) - ''' - if sub is None: - return 3 * ss_states - backend.eye(2)[None, None, None, :, :] - else: - sub = backend.convert_to_tensor(np.array(sub)) - return 3 * ss_states[:, :, sub] - backend.eye(2)[None, None, None, :, :] - - -def global_shadow_states(ss_states, sub: Optional[Sequence[int]] = None): - ''' - ns: number of snapshots - nq: number of qubits - ss_states = (ns, repeat, nq, 2, 2) + snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) + pauli_strings = None or (ns, nq) or (ns, repeat, nq) + sub: qubit indices of subsystem return: global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) ''' - shadow_states = backend.transpose(local_shadow_states(ss_states, sub), (2, 0, 1, 3, 4)) # (nq, ns, repeat, 2, 2) - nq, ns, repeat, _, _ = shadow_states.shape + if pauli_strings is not None: + assert len(snapshots.shape) == 3 + lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) + else: + if sub is not None: + sub = backend.convert_to_tensor(np.array(sub)) + lss_states = snapshots[:, :, sub] # (ns, repeat, nq_sub, 2, 2) + else: + lss_states = snapshots # (ns, repeat, nq, 2, 2) + lss_states = backend.transpose(lss_states, (2, 0, 1, 3, 4)) # (nq, ns, repeat, 2, 2) + nq, ns, repeat, _, _ = lss_states.shape old_indices = [f"ab{ABC[2 + 2 * i: 4 + 2 * i]}" for i in range(nq)] new_indices = f"ab{ABC[2:2 * nq + 2:2]}{ABC[3:2 * nq + 2:2]}" return backend.reshape( - backend.einsum(f'{",".join(old_indices)}->{new_indices}', *shadow_states, optimize=True), + backend.einsum(f'{",".join(old_indices)}->{new_indices}', *lss_states, optimize=True), (ns, repeat, 2 ** nq, 2 ** nq), ) -def global_shadow_states0(ss_states, sub: Optional[Sequence[int]] = None): +def global_snapshot_states2(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): ''' ns: number of snapshots nq: number of qubits - ss_states = (ns, repeat, nq, 2, 2) + snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) + pauli_strings = None or (ns, nq) or (ns, repeat, nq) + sub: qubit indices of subsystem return: global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) ''' - shadow_states = local_shadow_states(ss_states, sub) # (ns, repeat, nq, 2, 2) - ns, repeat, nq, _, _ = ss_states.shape + if pauli_strings is not None: + assert len(snapshots.shape) == 3 + lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) + else: + if sub is not None: + sub = backend.convert_to_tensor(np.array(sub)) + lss_states = snapshots[:, :, sub] # (ns, repeat, nq_sub, 2, 2) + else: + lss_states = snapshots # (ns, repeat, nq, 2, 2) + ns, repeat, nq, _, _ = lss_states.shape old_indices = [f"{ABC[2 * i: 2 + 2 * i]}" for i in range(nq)] new_indices = f"{ABC[0:2 * nq:2]}{ABC[1:2 * nq:2]}" @@ -215,67 +274,8 @@ def tensor_prod(dms): v = backend.vmap(tensor_prod, vectorized_argnums=0) vv = backend.vmap(v, vectorized_argnums=0) - return vv(shadow_states) - + return vv(lss_states) -def global_shadow_states1(ss_states, sub: Optional[Sequence[int]] = None): - ''' - ns: number of snapshots - nq: number of qubits - ss_states = (ns, repeat, nq, 2, 2) - - return: - global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) - ''' - shadow_states = local_shadow_states(ss_states, sub) # (ns, repeat, nq, 2, 2) - - def tensor_prod(dms): - res = dms[0] - for dm in dms[1:]: - res = backend.kron(res, dm) - return res - - v = backend.vmap(tensor_prod, vectorized_argnums=0) - vv = backend.vmap(v, vectorized_argnums=0) - return vv(shadow_states) - - -if __name__ == "__main__": - import time - from tensorcircuit import set_backend - backend = set_backend('jax') - N = 6 - - # old_indices = [f"a{ABC[1 + 2 * i: 3 + 2 * i]}" for i in range(N)] - # new_indices = f"a{ABC[1:2 * N + 1:2]}{ABC[2:2 * N + 1:2]}" - # print(old_indices, new_indices) - # exit(0) - - c = Circuit(N) - for i in range(N): - c.H(i) - for i in range(0, 2): - for j in range(N): - c.cnot(j, (j + 1) % N) - for j in range(N): - c.rx(j, theta=0.1) - psi0 = c.state() - # print(c.sample()) - - def classical_shadow(psi, pauli_strings): - snapshots = shadow_snapshots(psi, pauli_strings, repeat=1) - # ss_states = snapshot_states(snapshots, pauli_strings) - # return local_shadow_states(ss_states) - # return global_shadow_states(ss_states) - # return shadow_state(snapshots, pauli_strings) - return expection_ps_shadow(snapshots, pauli_strings, x=[0, 1], y=[3, 4], k=6) - # return entropy_shadow(snapshots, pauli_strings, sub=range(3), alpha=1) - - csjit = backend.jit(classical_shadow) - - pauli_strings = backend.convert_to_tensor(np.random.randint(0, 3, size=(100, N))) - res = csjit(psi0, pauli_strings) - print(res) From 9585ff747d95a2406651cb79f461c1f6c139b939 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 31 Jul 2023 15:24:56 +0800 Subject: [PATCH 572/725] Update shadows.py --- tensorcircuit/shadows.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 3ff2438c..ed66e73a 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -1,4 +1,4 @@ -"""Classical Shadows base class with processing functions""" +"""Classical Shadows functions""" from typing import Optional, Sequence from string import ascii_letters as ABC from .cons import backend @@ -280,3 +280,5 @@ def tensor_prod(dms): + + From 424748876db4fefc6e4864590122df4a4c7d2f45 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 31 Jul 2023 16:27:30 +0800 Subject: [PATCH 573/725] add method for fss --- requirements/requirements-extra.txt | 2 +- tensorcircuit/applications/physics/fss.py | 70 +++++++++++++++++------ 2 files changed, 54 insertions(+), 18 deletions(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index bc98045e..acd416e3 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,5 +1,5 @@ # extra dependencies for ci -qiskit +qiskit==0.43 qiskit-nature cirq torch diff --git a/tensorcircuit/applications/physics/fss.py b/tensorcircuit/applications/physics/fss.py index 6060915d..dc60d492 100644 --- a/tensorcircuit/applications/physics/fss.py +++ b/tensorcircuit/applications/physics/fss.py @@ -1,7 +1,7 @@ """ finite size scaling tools """ -from typing import List, Tuple +from typing import List, Tuple, Optional import numpy as np @@ -14,6 +14,8 @@ def data_collapse( nu: float, beta: float = 0, obs_type: int = 1, + fit_type: int = 0, + dobs: Optional[List[List[float]]] = None, ) -> Tuple[List[float], List[List[float]], List[List[float]], float]: xL: List[List[float]] = [] # x=(p-pc)L^(1/\nv) yL: List[List[float]] = [] # y=S(p,L)-S(pc,L) or S(p,L) @@ -33,27 +35,61 @@ def data_collapse( yL[n0].append(obs[n0][p0] * n[n0] ** beta) # tripartite mutual information pc_list.append(pc_L) - xL_all = [] - for i in range(len(xL)): - xL_all.extend(xL[i]) - yL_ave = [] - loss = [] - for x0 in range(len(xL_all)): - ybar_list = [] - for n0 in range(len(n)): - if xL_all[x0] >= xL[n0][0] and xL_all[x0] <= xL[n0][-1]: - yinsert = pc_linear_interpolation(xL[n0], yL[n0], xL_all[x0]) - ybar_list.append(yinsert) + if fit_type == 0: + xL_all = [] + for i in range(len(xL)): + xL_all.extend(xL[i]) + yL_ave = [] + loss = [] + for x0 in range(len(xL_all)): + ybar_list = [] + for n0 in range(len(n)): + if xL_all[x0] >= xL[n0][0] and xL_all[x0] <= xL[n0][-1]: + yinsert = pc_linear_interpolation(xL[n0], yL[n0], xL_all[x0]) + ybar_list.append(yinsert) + + ybar = np.mean(ybar_list) + mean_squared = [(ybar_list[i] - ybar) ** 2 for i in range(len(ybar_list))] + loss.append(np.sum(mean_squared)) + yL_ave.append(ybar) + loss = np.sum(loss) - ybar = np.mean(ybar_list) - mean_squared = [(ybar_list[i] - ybar) ** 2 for i in range(len(ybar_list))] - loss.append(np.sum(mean_squared)) - yL_ave.append(ybar) - loss = np.sum(loss) + return pc_list, xL, yL, loss # type: ignore + # fit_type == 1 + if dobs is None: + raise ValueError("uncertainty of each y has to be specified in `dobs`") + + datas = [] + for n0 in range(len(n)): + for i in range(len(xL[n0])): + datas.append([xL[n0][i], yL[n0][i], dobs[n0][i]]) + datas = sorted(datas, key=lambda x: x[0]) + loss = _quality_objective_v2(datas) # type: ignore return pc_list, xL, yL, loss # type: ignore +def _quality_objective_v2(datas: List[List[float]]) -> float: + # https://journals.aps.org/prb/supplemental/10.1103/PhysRevB.101.060301/Supplement.pdf + loss = [] + for i in range(len(datas) - 2): + # i, i+1, i+2 + x, y, d = datas[i + 1] + x1, y1, d1 = datas[i] + x2, y2, d2 = datas[i + 2] + if np.abs(x - x1) < 1e-4 or np.abs(x - x2) < 1e-4: + continue + ybar = ((x2 - x) * y1 - (x1 - x) * y2) / (x2 - x1) + delta = ( + d**2 + + d1**2 * (x2 - x) ** 2 / (x2 - x1) ** 2 + + d2**2 * (x1 - x) ** 2 / (x2 - x1) ** 2 + ) + w = (y - ybar) ** 2 / delta + loss.append(w) + return np.mean(loss) # type: ignore + + def pc_linear_interpolation(p: List[float], SA: List[float], pc_input: float) -> float: if pc_input in p: pc_index = p.index(pc_input) From e1d40047050ec0dfa07522f28f7b3812db241e59 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 31 Jul 2023 21:33:47 +0800 Subject: [PATCH 574/725] Update shadows.py and add test_shadows.py --- tensorcircuit/shadows.py | 203 ++++++++++++++++++++++----------------- tests/test_shadows.py | 54 +++++++++++ 2 files changed, 169 insertions(+), 88 deletions(-) create mode 100644 tests/test_shadows.py diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index ed66e73a..91515b20 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -1,28 +1,29 @@ """Classical Shadows functions""" from typing import Optional, Sequence from string import ascii_letters as ABC +import numpy as np + from .cons import backend from .circuit import Circuit -import numpy as np def shadow_snapshots(psi, pauli_strings, repeat: int = 1): - ''' - ns: number of snapshots - nq: number of qubits - cir: quantum circuit - pauli_strings = (ns, nq) - repeat: times to measure on one pauli string - - return: - snapshots = (ns, repeat, nq) - ''' - if pauli_strings.dtype not in ("int", "int32"): - raise TypeError("Expected a int data type. " f"Got {pauli_strings.dtype}") - - angles = backend.cast(backend.convert_to_tensor( - np.array([[-np.pi / 2, np.pi / 4, 0], [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], [0, 0, 0]])), - dtype=pauli_strings.dtype) + r"""To generate the shadow snapshots from given pauli-string observable on $|\psi\rangle$ + + :param psi: shape = (2 ** nq, 2 ** nq), where nq is the number of qubits + :type: Tensor + :param pauli_strings: shape = (ns, nq), where ns is the number of pauli strings + :type: Tensor + :param repeat: times to measure on one pauli string + :type: int + + :return snapshots: shape = (ns, repeat, nq) + :rtype: Tensor + """ + pauli_strings = backend.cast(pauli_strings, dtype=int) + + angles = backend.convert_to_tensor( + np.array([[-np.pi / 2, np.pi / 4, 0], [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], [0, 0, 0]])) nq = pauli_strings.shape[1] assert 2 ** nq == len(psi) @@ -40,16 +41,18 @@ def proj_measure(pauli_string): def local_snapshot_states(snapshots, pauli_strings, sub: Optional[Sequence[int]] = None): - ''' - ns: number of snapshots - nq: number of qubits - pauli_strings = (ns, nq) or (ns, repeat, nq) - snapshots = (ns, repeat, nq) - sub: qubit indices of subsystem - - return: - lss_states = (ns, repeat, nq, 2, 2) - ''' + r"""To generate the local snapshots states from snapshots and pauli strings + + :param snapshots: shape = (ns, repeat, nq) + :type: Tensor + :param pauli_strings: shape = (ns, nq) or (ns, repeat, nq) + :type: Tensor + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] + + :return lss_states: shape = (ns, repeat, nq, 2, 2) + :rtype: Tensor + """ if len(pauli_strings.shape) < len(snapshots.shape): pauli_strings = backend.tile(pauli_strings[:, None, :], (1, snapshots.shape[1], 1)) # (ns, repeat, nq) @@ -73,16 +76,18 @@ def dm(pauli, ss): def global_snapshot_states(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): - ''' - ns: number of snapshots - nq: number of qubits - snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) - pauli_strings = None or (ns, nq) or (ns, repeat, nq) - sub: qubit indices of subsystem - - return: - global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) - ''' + r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings + + :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) + :type: Tensor + :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) + :type: Optional[Tensor] + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] + + :return gss_states: shape = (ns, repeat, 2 ** nq, 2 ** nq) + :rtype: Tensor + """ if pauli_strings is not None: assert len(snapshots.shape) == 3 lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) @@ -105,17 +110,18 @@ def tensor_prod(dms): def shadow_state(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): - ''' - ns: number of snapshots - nq: number of qubits - snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) - or gss_states = (ns, repeat, 2 ** nq, 2 ** nq) - pauli_strings = None or (ns, nq) or (ns, repeat, nq) - sub: qubit indices of subsystem - - return: - shadow_state = (2 ** nq, 2 ** nq) - ''' + r"""To generate the shadow states from global snapshot states or local snapshot states or snapshots and pauli strings + + :param snapshots: shape = (ns, repeat, 2 ** nq, 2 ** nq) or (ns, repeat, nq, 2, 2) or (ns, repeat, nq) + :type: Tensor + :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) + :type: Optional[Tensor] + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] + + :return shadow_state: shape = (2 ** nq, 2 ** nq) + :rtype: Tensor + """ if len(snapshots.shape) == 4: assert sub is None gss_states = snapshots # (ns, repeat, 2 ** nq, 2 ** nq) @@ -127,15 +133,28 @@ def shadow_state(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = N def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int]] = None, y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, ps: Optional[Sequence[int]] = None, k: int = 1): - ''' - ns: number of snapshots - nq: number of qubits - snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) - pauli_strings = None or (ns, nq) or (ns, repeat, nq) - - return: - expection = (1,) - ''' + r"""To calculate the expectation value of an observable on shadow snapshot states + + :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) + :type: Tensor + :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) + :type: Optional[Tensor] + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] + :param x: sites to apply X gate, defaults to None + :type: Optional[Sequence[int]] + :param y: sites to apply Y gate, defaults to None + :type: Optional[Sequence[int]] + :param z: sites to apply Z gate, defaults to None + :type: Optional[Sequence[int]] + :param ps: or one can apply a ps structures instead of x, y, z, e.g. [0, 1, 3, 0, 2, 2] for X_1Z_2Y_4Y_5 defaults to None, ps can overwrite x, y and z + :type: Optional[Sequence[int]] + :param k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. + :type: int + + :return expectation values: shape = (k,) or (k + 1,) + :rtype: List[Tensor] + """ if pauli_strings is not None: assert len(snapshots.shape) == 3 lss_states = local_snapshot_states(snapshots, pauli_strings) # (ns, repeat, nq, 2, 2) @@ -183,17 +202,20 @@ def prod(dm): def entropy_shadow(ss_or_sd, pauli_strings=None, sub: Optional[Sequence[int]] = None, alpha: int = 1): - ''' - ns: number of snapshots - nq: number of qubits - snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) - or gss_states = (ns, repeat, 2 ** nq, 2 ** nq) or shadow_state = (2 ** nq, 2 ** nq) - pauli_strings = None or (ns, nq) or (ns, repeat, nq) - sub: qubit indices of subsystem - - return: - entropy = (1,) - ''' + r"""To calculate the Renyi entropy of a subsystem from shadow state or shadow snapshot states + + :param ss_or_sd: shadow state (shape = (2 ** nq, 2 ** nq)) or snapshot states (shape = (ns, repeat, 2 ** nq, 2 ** nq) or (ns, repeat, nq, 2, 2) or (ns, repeat, nq)) + :type: Tensor + :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) + :type: Optional[Tensor] + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] + :param alpha: order of the Renyi entropy, alpha=1 corresponds to the von Neumann entropy/ + :type: int + + :return Renyi entropy: shape = (1,) + :rtype: Tensor + """ if alpha <= 0: raise ValueError("Alpha should not be less than 1!") @@ -212,16 +234,18 @@ def entropy_shadow(ss_or_sd, pauli_strings=None, sub: Optional[Sequence[int]] = def global_snapshot_states1(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): - ''' - ns: number of snapshots - nq: number of qubits - snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) - pauli_strings = None or (ns, nq) or (ns, repeat, nq) - sub: qubit indices of subsystem - - return: - global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) - ''' + r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings + + :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) + :type: Tensor + :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) + :type: Optional[Tensor] + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] + + :return gss_states: shape = (ns, repeat, 2 ** nq, 2 ** nq) + :rtype: Tensor + """ if pauli_strings is not None: assert len(snapshots.shape) == 3 lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) @@ -244,16 +268,18 @@ def global_snapshot_states1(snapshots, pauli_strings=None, sub: Optional[Sequenc def global_snapshot_states2(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): - ''' - ns: number of snapshots - nq: number of qubits - snapshots = (ns, repeat, nq) or lss_states = (ns, repeat, nq, 2, 2) - pauli_strings = None or (ns, nq) or (ns, repeat, nq) - sub: qubit indices of subsystem - - return: - global_shadow_states = (ns, repeat, 2 ** nq, 2 ** nq) - ''' + r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings + + :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) + :type: Tensor + :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) + :type: Optional[Tensor] + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] + + :return gss_states: shape = (ns, repeat, 2 ** nq, 2 ** nq) + :rtype: Tensor + """ if pauli_strings is not None: assert len(snapshots.shape) == 3 lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) @@ -282,3 +308,4 @@ def tensor_prod(dms): + diff --git a/tests/test_shadows.py b/tests/test_shadows.py new file mode 100644 index 00000000..f5b462e6 --- /dev/null +++ b/tests/test_shadows.py @@ -0,0 +1,54 @@ +import numpy as np +import time +from tensorcircuit.circuit import Circuit +from tensorcircuit import set_backend +from tensorcircuit.shadows import shadow_snapshots, shadow_state, local_snapshot_states, global_snapshot_states, \ + entropy_shadow, expection_ps_shadow + + +if __name__ == "__main__": + backend = set_backend('jax') + N = 6 + + c = Circuit(N) + for i in range(N): + c.H(i) + for i in range(0, 2): + for j in range(N): + c.cnot(j, (j + 1) % N) + for j in range(N): + c.rx(j, theta=0.1 * np.pi) + + ps = [1, 1, 0, 2, 2, 0] + + print("exact:", c.expectation_ps(ps=ps)) + + psi0 = c.state() + pauli_strings = np.random.randint(0, 3, size=(10000, N)) + snapshots = shadow_snapshots(psi0, backend.convert_to_tensor(pauli_strings), repeat=1) + + import pennylane as qml + shadow = qml.ClassicalShadow(np.asarray(snapshots[:, 0]), np.asarray(pauli_strings)) + H = [qml.PauliX(0) @ qml.PauliX(1) @ qml.PauliY(3) @ qml.PauliY(4)] + pl_expc = shadow.expval(H, k=10) + pl_ent = shadow.entropy(range(2), alpha=1) + print("pl:", pl_expc, pl_ent) + expc = expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=10) + ent = entropy_shadow(snapshots, pauli_strings, sub=range(2), alpha=1) + print("here:", np.median(expc), ent) + print(expc) + + # git test + def classical_shadow(psi, pauli_strings): + snapshots = shadow_snapshots(psi, pauli_strings, repeat=1) + # return local_snapshot_states(snapshots, pauli_strings, sub=[1, 3, 5]) + # return global_snapshot_states1(snapshots, pauli_strings, sub=[1, 3, 5]) + # return shadow_state(snapshots, pauli_strings, sub=[1, 3, 5]) + # return expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=10) + return entropy_shadow(snapshots, pauli_strings, sub=range(3), alpha=1) + + csjit = backend.jit(classical_shadow) + + pauli_strings = backend.convert_to_tensor(np.random.randint(0, 3, size=(10000, N))) + res = csjit(psi0, pauli_strings) + print(res) \ No newline at end of file From 092154a0a0bcdbf8067ebbc885d49262e0b2cd2a Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Mon, 31 Jul 2023 21:36:34 +0800 Subject: [PATCH 575/725] Update test_shadows.py --- tests/test_shadows.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/test_shadows.py b/tests/test_shadows.py index f5b462e6..002a448a 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -1,5 +1,6 @@ import numpy as np import time +import pytest from tensorcircuit.circuit import Circuit from tensorcircuit import set_backend from tensorcircuit.shadows import shadow_snapshots, shadow_state, local_snapshot_states, global_snapshot_states, \ @@ -38,7 +39,7 @@ print("here:", np.median(expc), ent) print(expc) - # git test + # jit test def classical_shadow(psi, pauli_strings): snapshots = shadow_snapshots(psi, pauli_strings, repeat=1) # return local_snapshot_states(snapshots, pauli_strings, sub=[1, 3, 5]) From f25fa9b0e772fc3776f1260808a827cf53a0811b Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 1 Aug 2023 10:24:03 +0800 Subject: [PATCH 576/725] Update shadows.py and test_shadows.py --- tensorcircuit/shadows.py | 13 ++++++------- tests/test_shadows.py | 13 +++++++------ 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 91515b20..f3b0cd77 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -8,7 +8,7 @@ def shadow_snapshots(psi, pauli_strings, repeat: int = 1): - r"""To generate the shadow snapshots from given pauli-string observable on $|\psi\rangle$ + r"""To generate the shadow snapshots from given pauli string observables on $|\psi\rangle$ :param psi: shape = (2 ** nq, 2 ** nq), where nq is the number of qubits :type: Tensor @@ -28,12 +28,11 @@ def shadow_snapshots(psi, pauli_strings, repeat: int = 1): nq = pauli_strings.shape[1] assert 2 ** nq == len(psi) + c_ = Circuit(nq, inputs=psi) + def proj_measure(pauli_string): - # pauli_rot = backend.onehot(pauli_string, num=3) @ angles - pauli_rot = angles[pauli_string] - c_ = Circuit(nq, inputs=psi) - for i, (theta, alpha, phi) in enumerate(pauli_rot): - c_.R(i, theta=theta, alpha=alpha, phi=phi) + for i, idx in enumerate(pauli_string): + c_.R(i, theta=angles[idx][0], alpha=angles[idx][1], phi=angles[idx][2]) return c_.sample(batch=repeat, format="sample_bin") vpm = backend.vmap(proj_measure, vectorized_argnums=0) @@ -210,7 +209,7 @@ def entropy_shadow(ss_or_sd, pauli_strings=None, sub: Optional[Sequence[int]] = :type: Optional[Tensor] :param sub: qubit indices of subsystem :type: Optional[Sequence[int]] - :param alpha: order of the Renyi entropy, alpha=1 corresponds to the von Neumann entropy/ + :param alpha: order of the Renyi entropy, alpha=1 corresponds to the von Neumann entropy :type: int :return Renyi entropy: shape = (1,) diff --git a/tests/test_shadows.py b/tests/test_shadows.py index 002a448a..60ce3c19 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -1,6 +1,6 @@ import numpy as np import time -import pytest +# import pytest from tensorcircuit.circuit import Circuit from tensorcircuit import set_backend from tensorcircuit.shadows import shadow_snapshots, shadow_state, local_snapshot_states, global_snapshot_states, \ @@ -42,11 +42,12 @@ # jit test def classical_shadow(psi, pauli_strings): snapshots = shadow_snapshots(psi, pauli_strings, repeat=1) - # return local_snapshot_states(snapshots, pauli_strings, sub=[1, 3, 5]) - # return global_snapshot_states1(snapshots, pauli_strings, sub=[1, 3, 5]) - # return shadow_state(snapshots, pauli_strings, sub=[1, 3, 5]) - # return expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=10) - return entropy_shadow(snapshots, pauli_strings, sub=range(3), alpha=1) + lss_states = local_snapshot_states(snapshots, pauli_strings) + gss_states = global_snapshot_states(lss_states, sub=[1, 3, 5]) + sdw_state = shadow_state(gss_states) + expc = expection_ps_shadow(lss_states, ps=ps, k=10) + ent = entropy_shadow(sdw_state, alpha=2) + return expc, ent, lss_states.shape, gss_states.shape, sdw_state.shape csjit = backend.jit(classical_shadow) From 0e823fd479cafbfc7551182a41d8253c9486a622 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 1 Aug 2023 10:26:04 +0800 Subject: [PATCH 577/725] Update shadows.py and test_shadows.py --- tensorcircuit/shadows.py | 2 +- tests/test_shadows.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index f3b0cd77..c169dafa 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -146,7 +146,7 @@ def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int] :type: Optional[Sequence[int]] :param z: sites to apply Z gate, defaults to None :type: Optional[Sequence[int]] - :param ps: or one can apply a ps structures instead of x, y, z, e.g. [0, 1, 3, 0, 2, 2] for X_1Z_2Y_4Y_5 defaults to None, ps can overwrite x, y and z + :param ps: or one can apply a ps structures instead of x, y, z, e.g. [1, 1, 0, 2, 3, 0] for X_0X_1Y_3Z_4 defaults to None, ps can overwrite x, y and z :type: Optional[Sequence[int]] :param k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. :type: int diff --git a/tests/test_shadows.py b/tests/test_shadows.py index 60ce3c19..162926be 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -1,6 +1,6 @@ import numpy as np import time -# import pytest +import pytest from tensorcircuit.circuit import Circuit from tensorcircuit import set_backend from tensorcircuit.shadows import shadow_snapshots, shadow_state, local_snapshot_states, global_snapshot_states, \ From eb3872a09805e90ae8b11c9fb662aa3a56b629b0 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 1 Aug 2023 15:04:21 +0800 Subject: [PATCH 578/725] fix adaptive vmap --- CHANGELOG.md | 4 ++++ tensorcircuit/experimental.py | 22 +++++++++++++--------- 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 93bceb03..3d5759a4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,10 @@ - Add circuit copy method that avoid shallow copy issue `Circuit.copy()` +### Fixed + +- improve the `adaptive_vmap` to support internal jit and pytree output + ### Changed - The static method `BaseCircuit.copy` is renamed as `BaseCircuit.copy_nodes` diff --git a/tensorcircuit/experimental.py b/tensorcircuit/experimental.py index 85a67a72..8eba9a43 100644 --- a/tensorcircuit/experimental.py +++ b/tensorcircuit/experimental.py @@ -17,6 +17,7 @@ def adaptive_vmap( f: Callable[..., Any], vectorized_argnums: Union[int, Sequence[int]] = 0, + static_argnums: Optional[Union[int, Sequence[int]]] = None, chunk_size: Optional[int] = None, ) -> Callable[..., Any]: if chunk_size is None: @@ -46,7 +47,10 @@ def wrapper(*args: Any, **kws: Any) -> Tensor: reshape_args.append(arg) if s2 != 0: rest_args.append(arg_rest) - _vmap = backend.vmap(f, vectorized_argnums) + _vmap = backend.jit( + backend.vmap(f, vectorized_argnums=vectorized_argnums), + static_argnums=static_argnums, + ) r = [] for i in range(s1): # currently using naive python loop for simplicity @@ -55,16 +59,16 @@ def wrapper(*args: Any, **kws: Any) -> Tensor: for j, a in enumerate(reshape_args) ] r.append(_vmap(*nreshape_args, **kws)) - r = backend.stack(r) - rshape = list(backend.shape_tuple(r)) - if len(rshape) == 2: - nshape = [rshape[0] * rshape[1]] - else: - nshape = [rshape[0] * rshape[1], -1] - r = backend.reshape(r, nshape) + r = backend.tree_map(lambda *x: backend.concat(x), *r) + # rshape = list(backend.shape_tuple(r)) + # if len(rshape) == 2: + # nshape = [rshape[0] * rshape[1]] + # else: + # nshape = [rshape[0] * rshape[1], -1] + # r = backend.reshape(r, nshape) if s2 != 0: rest_r = _vmap(*rest_args, **kws) - return backend.concat([r, rest_r]) + return backend.tree_map(lambda *x: backend.concat(x), r, rest_r) return r return wrapper From 601a67d3195b8264058576a27eb24fb80e203aed Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 1 Aug 2023 16:30:09 +0800 Subject: [PATCH 579/725] Update shadows.py --- tensorcircuit/shadows.py | 174 +++++++++++++++++++-------------------- 1 file changed, 84 insertions(+), 90 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index c169dafa..b2e1e243 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -1,9 +1,11 @@ -"""Classical Shadows functions""" +""" +Classical Shadows functions +""" from typing import Optional, Sequence from string import ascii_letters as ABC import numpy as np -from .cons import backend +from .cons import backend, dtypestr, rdtypestr from .circuit import Circuit @@ -20,20 +22,22 @@ def shadow_snapshots(psi, pauli_strings, repeat: int = 1): :return snapshots: shape = (ns, repeat, nq) :rtype: Tensor """ - pauli_strings = backend.cast(pauli_strings, dtype=int) + pauli_strings = backend.cast(pauli_strings, dtype="int32") - angles = backend.convert_to_tensor( - np.array([[-np.pi / 2, np.pi / 4, 0], [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], [0, 0, 0]])) + angles = backend.cast(backend.convert_to_tensor( + [[-np.pi / 2, np.pi / 4, 0], [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], [0, 0, 0]]), + dtype=rdtypestr) # (3, 3) nq = pauli_strings.shape[1] assert 2 ** nq == len(psi) - c_ = Circuit(nq, inputs=psi) - def proj_measure(pauli_string): - for i, idx in enumerate(pauli_string): - c_.R(i, theta=angles[idx][0], alpha=angles[idx][1], phi=angles[idx][2]) - return c_.sample(batch=repeat, format="sample_bin") + c_ = Circuit(nq, inputs=psi) + for i in range(nq): + c_.R(i, theta=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 0), + alpha=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 1), + phi=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 1)) + return c_.sample(batch=repeat, format="sample_bin", allow_state=True) vpm = backend.vmap(proj_measure, vectorized_argnums=0) return vpm(pauli_strings) # (ns, repeat, nq) @@ -52,30 +56,30 @@ def local_snapshot_states(snapshots, pauli_strings, sub: Optional[Sequence[int]] :return lss_states: shape = (ns, repeat, nq, 2, 2) :rtype: Tensor """ + pauli_strings = backend.cast(pauli_strings, dtype="int32") if len(pauli_strings.shape) < len(snapshots.shape): pauli_strings = backend.tile(pauli_strings[:, None, :], (1, snapshots.shape[1], 1)) # (ns, repeat, nq) - X_dm = backend.cast(np.array([[[1, 1], [1, 1]], [[1, -1], [-1, 1]]]) / 2, dtype=complex) - Y_dm = backend.cast(np.array([[[1, -1j], [1j, 1]], [[1, 1j], [-1j, 1]]]) / 2, dtype=complex) - Z_dm = backend.cast(np.array([[[1, 0], [0, 0]], [[0, 0], [0, 1]]]), dtype=complex) - pauli_dm = backend.convert_to_tensor(backend.stack((X_dm, Y_dm, Z_dm), axis=0)) # (3, 2, 2, 2) - - def dm(pauli, ss): - return pauli_dm[pauli, ss] + X_dm = backend.cast(backend.convert_to_tensor([[[1, 1], [1, 1]], [[1, -1], [-1, 1]]]) / 2, dtype=dtypestr) + Y_dm = backend.cast(backend.convert_to_tensor(np.array([[[1, -1j], [1j, 1]], [[1, 1j], [-1j, 1]]]) / 2), dtype=dtypestr) + Z_dm = backend.cast(backend.convert_to_tensor([[[1, 0], [0, 0]], [[0, 0], [0, 1]]]), dtype=dtypestr) + pauli_dm = backend.stack((X_dm, Y_dm, Z_dm), axis=0) # (3, 2, 2, 2) - v = backend.vmap(dm, vectorized_argnums=(0, 1)) + v = backend.vmap(lambda p, s: backend.gather1d(backend.gather1d(pauli_dm, p), s), vectorized_argnums=(0, 1)) vv = backend.vmap(v, vectorized_argnums=(0, 1)) vvv = backend.vmap(vv, vectorized_argnums=(0, 1)) lss_states = vvv(pauli_strings, snapshots) if sub is not None: - sub = backend.convert_to_tensor(np.array(sub)) - lss_states = lss_states[:, :, sub] + lss_states = backend.transpose(lss_states, (2, 0, 1, 3, 4)) + v0 = backend.vmap(lambda idx: backend.gather1d(lss_states, idx), vectorized_argnums=0) + lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) + return 3 * lss_states - backend.eye(2)[None, None, None, :, :] -def global_snapshot_states(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): - r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings +def global_shadow_state(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): + r"""To generate the global shadow state from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) :type: Tensor @@ -84,48 +88,34 @@ def global_snapshot_states(snapshots, pauli_strings=None, sub: Optional[Sequence :param sub: qubit indices of subsystem :type: Optional[Sequence[int]] - :return gss_states: shape = (ns, repeat, 2 ** nq, 2 ** nq) + :return gsdw_state: shape = (2 ** nq, 2 ** nq) :rtype: Tensor """ if pauli_strings is not None: - assert len(snapshots.shape) == 3 + if len(snapshots.shape) != 3: + raise RuntimeError( + f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead.") + pauli_strings = backend.cast(pauli_strings, dtype="int32") lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) else: if sub is not None: - sub = backend.convert_to_tensor(np.array(sub)) - lss_states = snapshots[:, :, sub] # (ns, repeat, nq_sub, 2, 2) + lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) + v0 = backend.vmap(lambda idx: backend.gather1d(lss_states, idx), vectorized_argnums=0) + lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) + nq = lss_states.shape[2] + def tensor_prod(dms): - res = dms[0] - for dm in dms[1:]: - res = backend.kron(res, dm) + res = backend.gather1d(dms, 0) + for i in range(1, nq): + res = backend.kron(res, backend.gather1d(dms, i)) return res v = backend.vmap(tensor_prod, vectorized_argnums=0) vv = backend.vmap(v, vectorized_argnums=0) - return vv(lss_states) - - -def shadow_state(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): - r"""To generate the shadow states from global snapshot states or local snapshot states or snapshots and pauli strings - - :param snapshots: shape = (ns, repeat, 2 ** nq, 2 ** nq) or (ns, repeat, nq, 2, 2) or (ns, repeat, nq) - :type: Tensor - :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) - :type: Optional[Tensor] - :param sub: qubit indices of subsystem - :type: Optional[Sequence[int]] - - :return shadow_state: shape = (2 ** nq, 2 ** nq) - :rtype: Tensor - """ - if len(snapshots.shape) == 4: - assert sub is None - gss_states = snapshots # (ns, repeat, 2 ** nq, 2 ** nq) - else: - gss_states = global_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, 2 ** nq_sub, 2 ** nq_sub) + gss_states = vv(lss_states) return backend.mean(gss_states, axis=(0, 1)) @@ -138,8 +128,6 @@ def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int] :type: Tensor :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) :type: Optional[Tensor] - :param sub: qubit indices of subsystem - :type: Optional[Sequence[int]] :param x: sites to apply X gate, defaults to None :type: Optional[Sequence[int]] :param y: sites to apply Y gate, defaults to None @@ -151,11 +139,14 @@ def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int] :param k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. :type: int - :return expectation values: shape = (k,) or (k + 1,) + :return expectation values: shape = (k,) :rtype: List[Tensor] """ if pauli_strings is not None: - assert len(snapshots.shape) == 3 + if len(snapshots.shape) != 3: + raise RuntimeError( + f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead.") + pauli_strings = backend.cast(pauli_strings, dtype="int32") lss_states = local_snapshot_states(snapshots, pauli_strings) # (ns, repeat, nq, 2, 2) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) @@ -164,9 +155,12 @@ def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int] ss_states = backend.reshape(lss_states, (ns, nq, 2, 2)) if ps is not None: + if len(ps) != nq: + raise RuntimeError( + f"The number of qubits of the shadow state is {nq}, but got a {len(ps)}-qubit pauli string observable.") ps = np.array(ps) # (nq,) else: - ps = np.zeros(nq, dtype=int) + ps = np.zeros(nq, dtype="int32") if x is not None: for i in x: ps[i] = 1 @@ -179,31 +173,20 @@ def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int] paulis = backend.convert_to_tensor( backend.cast(np.array([[[1, 0], [0, 1]], [[0, 1], [1, 0]], [[0, -1j], [1j, 0]], [[1, 0], [0, -1]]]), - dtype=ss_states.dtype)) # (4, 2, 2) + dtype=dtypestr)) # (4, 2, 2) - def sqp(dm, p_idx): - return backend.real(backend.trace(paulis[p_idx] @ dm)) + v = backend.vmap(lambda dm, idx: backend.real(backend.trace(backend.gather1d(paulis, idx) @ dm)), + vectorized_argnums=(0, 1)) # (nq,) + vv = backend.vmap(lambda dm: backend.shape_prod(v(dm, ps)), vectorized_argnums=0) # (ns,) - v = backend.vmap(sqp, vectorized_argnums=(0, 1)) # (nq,) - - def prod(dm): - tensor = v(dm, ps) - return backend.shape_prod(tensor) - - vv = backend.vmap(prod, vectorized_argnums=0) # (ns,) - - batch = ns // k - means = [] - for i in range(0, ns, batch): - ans = vv(ss_states[i: i + batch]) - means.append(backend.mean(ans)) - return means + batch = int(np.ceil(ns / k)) + return [backend.mean(vv(ss_states[i: i + batch])) for i in range(0, ns, batch)] def entropy_shadow(ss_or_sd, pauli_strings=None, sub: Optional[Sequence[int]] = None, alpha: int = 1): r"""To calculate the Renyi entropy of a subsystem from shadow state or shadow snapshot states - :param ss_or_sd: shadow state (shape = (2 ** nq, 2 ** nq)) or snapshot states (shape = (ns, repeat, 2 ** nq, 2 ** nq) or (ns, repeat, nq, 2, 2) or (ns, repeat, nq)) + :param ss_or_sd: shadow state (shape = (2 ** nq, 2 ** nq)) or snapshot states (shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq)) :type: Tensor :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) :type: Optional[Tensor] @@ -212,27 +195,28 @@ def entropy_shadow(ss_or_sd, pauli_strings=None, sub: Optional[Sequence[int]] = :param alpha: order of the Renyi entropy, alpha=1 corresponds to the von Neumann entropy :type: int - :return Renyi entropy: shape = (1,) + :return Renyi entropy: shape = () :rtype: Tensor """ if alpha <= 0: raise ValueError("Alpha should not be less than 1!") if len(ss_or_sd.shape) == 2 and ss_or_sd.shape[0] == ss_or_sd.shape[1]: - assert sub is None + if sub is not None: + raise ValueError("sub should be None if the input is the global shadow state.") sdw_rdm = ss_or_sd else: - sdw_rdm = shadow_state(ss_or_sd, pauli_strings, sub) # (2 ** nq, 2 ** nq) + sdw_rdm = global_shadow_state(ss_or_sd, pauli_strings, sub) # (2 ** nq, 2 ** nq) - evs = backend.relu(backend.eigvalsh(sdw_rdm)) + evs = backend.relu(backend.real(backend.eigvalsh(sdw_rdm))) evs /= backend.sum(evs) if alpha == 1: - return -backend.sum(evs * backend.log(evs + 1e-15)) + return -backend.sum(evs * backend.log(evs + 1e-12)) else: return backend.log(backend.sum(backend.power(evs, alpha))) / (1 - alpha) -def global_snapshot_states1(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): +def global_shadow_state1(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -242,16 +226,20 @@ def global_snapshot_states1(snapshots, pauli_strings=None, sub: Optional[Sequenc :param sub: qubit indices of subsystem :type: Optional[Sequence[int]] - :return gss_states: shape = (ns, repeat, 2 ** nq, 2 ** nq) + :return gsdw_state: shape = (2 ** nq, 2 ** nq) :rtype: Tensor """ if pauli_strings is not None: - assert len(snapshots.shape) == 3 + if len(snapshots.shape) != 3: + raise RuntimeError( + f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead.") + pauli_strings = backend.cast(pauli_strings, dtype="int32") lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) else: if sub is not None: - sub = backend.convert_to_tensor(np.array(sub)) - lss_states = snapshots[:, :, sub] # (ns, repeat, nq_sub, 2, 2) + lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) + v0 = backend.vmap(lambda idx: backend.gather1d(lss_states, idx), vectorized_argnums=0) + lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) lss_states = backend.transpose(lss_states, (2, 0, 1, 3, 4)) # (nq, ns, repeat, 2, 2) @@ -260,13 +248,14 @@ def global_snapshot_states1(snapshots, pauli_strings=None, sub: Optional[Sequenc old_indices = [f"ab{ABC[2 + 2 * i: 4 + 2 * i]}" for i in range(nq)] new_indices = f"ab{ABC[2:2 * nq + 2:2]}{ABC[3:2 * nq + 2:2]}" - return backend.reshape( + gss_states = backend.reshape( backend.einsum(f'{",".join(old_indices)}->{new_indices}', *lss_states, optimize=True), (ns, repeat, 2 ** nq, 2 ** nq), ) + return backend.mean(gss_states, axis=(0, 1)) -def global_snapshot_states2(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): +def global_shadow_state2(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -276,16 +265,20 @@ def global_snapshot_states2(snapshots, pauli_strings=None, sub: Optional[Sequenc :param sub: qubit indices of subsystem :type: Optional[Sequence[int]] - :return gss_states: shape = (ns, repeat, 2 ** nq, 2 ** nq) + :return gsdw_state: shape = (2 ** nq, 2 ** nq) :rtype: Tensor """ if pauli_strings is not None: - assert len(snapshots.shape) == 3 + if len(snapshots.shape) != 3: + raise RuntimeError( + f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead.") + pauli_strings = backend.cast(pauli_strings, dtype="int32") lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) else: if sub is not None: - sub = backend.convert_to_tensor(np.array(sub)) - lss_states = snapshots[:, :, sub] # (ns, repeat, nq_sub, 2, 2) + lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) + v0 = backend.vmap(lambda idx: backend.gather1d(lss_states, idx), vectorized_argnums=0) + lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) ns, repeat, nq, _, _ = lss_states.shape @@ -299,7 +292,8 @@ def tensor_prod(dms): v = backend.vmap(tensor_prod, vectorized_argnums=0) vv = backend.vmap(v, vectorized_argnums=0) - return vv(lss_states) + gss_states = vv(lss_states) + return backend.mean(gss_states, axis=(0, 1)) From a5d7c03bf8e40ecd30236265ca2bd7e060a0c704 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 2 Aug 2023 15:31:31 +0800 Subject: [PATCH 580/725] Update shadows.py and test_shadows.py --- tensorcircuit/shadows.py | 129 +++++++++++++++++++++++++++++---------- tests/test_shadows.py | 123 ++++++++++++++++++++++++------------- 2 files changed, 177 insertions(+), 75 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index b2e1e243..bed032c7 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -1,49 +1,59 @@ """ Classical Shadows functions """ -from typing import Optional, Sequence +from typing import Any, Optional, Sequence from string import ascii_letters as ABC import numpy as np from .cons import backend, dtypestr, rdtypestr from .circuit import Circuit +from .quantum import PauliString2COO, QuOperator +Tensor = Any -def shadow_snapshots(psi, pauli_strings, repeat: int = 1): + +def shadow_snapshots(psi: Tensor, pauli_strings: Tensor, status: Optional[Tensor] = None): r"""To generate the shadow snapshots from given pauli string observables on $|\psi\rangle$ :param psi: shape = (2 ** nq, 2 ** nq), where nq is the number of qubits :type: Tensor :param pauli_strings: shape = (ns, nq), where ns is the number of pauli strings :type: Tensor - :param repeat: times to measure on one pauli string - :type: int + :param status: shape = None or (ns, repeat), where repeat is the times to measure on one pauli string + :type: Optional[Tensor] :return snapshots: shape = (ns, repeat, nq) :rtype: Tensor """ pauli_strings = backend.cast(pauli_strings, dtype="int32") + ns, nq = pauli_strings.shape + if 2 ** nq != len(psi): + raise RuntimeError( + f"The number of qubits of psi and pauli_strings should be the same, but got {nq} and {int(np.log2(len(psi)))}.") + if status is None: + status = backend.convert_to_tensor(np.random.rand(ns, 1)) + elif status.shape[0] != ns: + raise RuntimeError(f"status.shape[0] should be {ns}, but got {status.shape[0]}.") + status = backend.cast(status, dtype=rdtypestr) + repeat = status.shape[1] angles = backend.cast(backend.convert_to_tensor( [[-np.pi / 2, np.pi / 4, 0], [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], [0, 0, 0]]), dtype=rdtypestr) # (3, 3) - nq = pauli_strings.shape[1] - assert 2 ** nq == len(psi) - - def proj_measure(pauli_string): + def proj_measure(pauli_string, st): c_ = Circuit(nq, inputs=psi) for i in range(nq): c_.R(i, theta=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 0), alpha=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 1), - phi=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 1)) - return c_.sample(batch=repeat, format="sample_bin", allow_state=True) + phi=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 2)) + return c_.sample(batch=repeat, format="sample_bin", allow_state=True, status=st) - vpm = backend.vmap(proj_measure, vectorized_argnums=0) - return vpm(pauli_strings) # (ns, repeat, nq) + vpm = backend.vmap(proj_measure, vectorized_argnums=(0, 1)) + return vpm(pauli_strings, status) # (ns, repeat, nq) -def local_snapshot_states(snapshots, pauli_strings, sub: Optional[Sequence[int]] = None): +def local_snapshot_states(snapshots: Tensor, pauli_strings: Tensor, sub: Optional[Sequence[int]] = None): r"""To generate the local snapshots states from snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq) @@ -65,20 +75,26 @@ def local_snapshot_states(snapshots, pauli_strings, sub: Optional[Sequence[int]] Z_dm = backend.cast(backend.convert_to_tensor([[[1, 0], [0, 0]], [[0, 0], [0, 1]]]), dtype=dtypestr) pauli_dm = backend.stack((X_dm, Y_dm, Z_dm), axis=0) # (3, 2, 2, 2) - v = backend.vmap(lambda p, s: backend.gather1d(backend.gather1d(pauli_dm, p), s), vectorized_argnums=(0, 1)) + def dm(p, s): + return backend.gather1d(backend.gather1d(pauli_dm, p), s) + + v = backend.vmap(dm, vectorized_argnums=(0, 1)) vv = backend.vmap(v, vectorized_argnums=(0, 1)) vvv = backend.vmap(vv, vectorized_argnums=(0, 1)) lss_states = vvv(pauli_strings, snapshots) if sub is not None: lss_states = backend.transpose(lss_states, (2, 0, 1, 3, 4)) - v0 = backend.vmap(lambda idx: backend.gather1d(lss_states, idx), vectorized_argnums=0) + def slice_sub(idx): + return backend.gather1d(lss_states, idx) + + v0 = backend.vmap(slice_sub, vectorized_argnums=0) lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) return 3 * lss_states - backend.eye(2)[None, None, None, :, :] -def global_shadow_state(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): +def global_shadow_state(snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None): r"""To generate the global shadow state from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -100,7 +116,11 @@ def global_shadow_state(snapshots, pauli_strings=None, sub: Optional[Sequence[in else: if sub is not None: lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) - v0 = backend.vmap(lambda idx: backend.gather1d(lss_states, idx), vectorized_argnums=0) + + def slice_sub(idx): + return backend.gather1d(lss_states, idx) + + v0 = backend.vmap(slice_sub, vectorized_argnums=0) lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) @@ -119,7 +139,7 @@ def tensor_prod(dms): return backend.mean(gss_states, axis=(0, 1)) -def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int]] = None, +def expection_ps_shadow(snapshots: Tensor, pauli_strings: Optional[Tensor] = None, x: Optional[Sequence[int]] = None, y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, ps: Optional[Sequence[int]] = None, k: int = 1): r"""To calculate the expectation value of an observable on shadow snapshot states @@ -154,13 +174,8 @@ def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int] ns *= repeat ss_states = backend.reshape(lss_states, (ns, nq, 2, 2)) - if ps is not None: - if len(ps) != nq: - raise RuntimeError( - f"The number of qubits of the shadow state is {nq}, but got a {len(ps)}-qubit pauli string observable.") - ps = np.array(ps) # (nq,) - else: - ps = np.zeros(nq, dtype="int32") + if ps is None: + ps = [0] * nq if x is not None: for i in x: ps[i] = 1 @@ -170,20 +185,30 @@ def expection_ps_shadow(snapshots, pauli_strings=None, x: Optional[Sequence[int] if z is not None: for i in z: ps[i] = 3 + elif len(ps) != nq: + raise RuntimeError( + f"The number of qubits of the shadow state is {nq}, but got a {len(ps)}-qubit pauli string observable.") + ps = backend.cast(backend.convert_to_tensor(ps), dtype="int32") # (nq,) paulis = backend.convert_to_tensor( backend.cast(np.array([[[1, 0], [0, 1]], [[0, 1], [1, 0]], [[0, -1j], [1j, 0]], [[1, 0], [0, -1]]]), dtype=dtypestr)) # (4, 2, 2) - v = backend.vmap(lambda dm, idx: backend.real(backend.trace(backend.gather1d(paulis, idx) @ dm)), - vectorized_argnums=(0, 1)) # (nq,) - vv = backend.vmap(lambda dm: backend.shape_prod(v(dm, ps)), vectorized_argnums=0) # (ns,) + def trace_paulis_prod(dm, idx): + return backend.real(backend.trace(backend.gather1d(paulis, idx) @ dm)) + + v = backend.vmap(trace_paulis_prod, vectorized_argnums=(0, 1)) # (nq,) + + def prod(dm): + return backend.shape_prod(v(dm, ps)) + + vv = backend.vmap(prod, vectorized_argnums=0) # (ns,) batch = int(np.ceil(ns / k)) return [backend.mean(vv(ss_states[i: i + batch])) for i in range(0, ns, batch)] -def entropy_shadow(ss_or_sd, pauli_strings=None, sub: Optional[Sequence[int]] = None, alpha: int = 1): +def entropy_shadow(ss_or_sd: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None, alpha: int = 1): r"""To calculate the Renyi entropy of a subsystem from shadow state or shadow snapshot states :param ss_or_sd: shadow state (shape = (2 ** nq, 2 ** nq)) or snapshot states (shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq)) @@ -216,7 +241,7 @@ def entropy_shadow(ss_or_sd, pauli_strings=None, sub: Optional[Sequence[int]] = return backend.log(backend.sum(backend.power(evs, alpha))) / (1 - alpha) -def global_shadow_state1(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): +def global_shadow_state1(snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None): r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -238,7 +263,11 @@ def global_shadow_state1(snapshots, pauli_strings=None, sub: Optional[Sequence[i else: if sub is not None: lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) - v0 = backend.vmap(lambda idx: backend.gather1d(lss_states, idx), vectorized_argnums=0) + + def slice_sub(idx): + return backend.gather1d(lss_states, idx) + + v0 = backend.vmap(slice_sub, vectorized_argnums=0) lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) @@ -255,7 +284,7 @@ def global_shadow_state1(snapshots, pauli_strings=None, sub: Optional[Sequence[i return backend.mean(gss_states, axis=(0, 1)) -def global_shadow_state2(snapshots, pauli_strings=None, sub: Optional[Sequence[int]] = None): +def global_shadow_state2(snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None): r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -277,7 +306,11 @@ def global_shadow_state2(snapshots, pauli_strings=None, sub: Optional[Sequence[i else: if sub is not None: lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) - v0 = backend.vmap(lambda idx: backend.gather1d(lss_states, idx), vectorized_argnums=0) + + def slice_sub(idx): + return backend.gather1d(lss_states, idx) + + v0 = backend.vmap(slice_sub, vectorized_argnums=0) lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) @@ -296,7 +329,37 @@ def tensor_prod(dms): return backend.mean(gss_states, axis=(0, 1)) +def shadow_bound(observables: Tensor, epsilon: float, delta: float = 0.01): + r"""Calculate the shadow bound of the Pauli observables, please refer to the Theorem S1 in Huang, H.-Y., R. Kueng, and J. Preskill, 2020, Nat. Phys. 16, 1050. + :param observables: shape = (nq,) or (M, nq), where nq is the number of qubits, M is the number of observables + :type: Tensor + :param epsilon: error on the estimator + :type: float + :param delta: rate of failure for the bound to hold + :type: float + + :return Nk: number of snapshots + :rtype: int + :return k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. + :rtype: int + """ + observables = backend.cast(observables, dtype="int32") + M = observables.shape[0] + k = int(2 * np.log(2 * M / delta)) + + def shadow_norm(o): + o = backend.to_dense(PauliString2COO(o)) + qo = QuOperator.from_tensor(o) + # print(qo.eval()) + n = qo.norm().eval() + # print(n) + return n ** 2 + + v = backend.vmap(shadow_norm, vectorized_argnums=0) + + N = int(34 * backend.max(v(observables)) / epsilon ** 2) + return N * k, k diff --git a/tests/test_shadows.py b/tests/test_shadows.py index 162926be..7cd39563 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -1,56 +1,95 @@ import numpy as np -import time import pytest -from tensorcircuit.circuit import Circuit -from tensorcircuit import set_backend -from tensorcircuit.shadows import shadow_snapshots, shadow_state, local_snapshot_states, global_snapshot_states, \ - entropy_shadow, expection_ps_shadow +from pytest_lazyfixture import lazy_fixture as lf +import tensorcircuit as tc +from tensorcircuit.shadows import shadow_snapshots, local_snapshot_states, global_shadow_state, global_shadow_state1, \ + global_shadow_state2, entropy_shadow, expection_ps_shadow, shadow_bound -if __name__ == "__main__": - backend = set_backend('jax') - N = 6 +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_jit(backend): + nq, ns = 8, 10000 - c = Circuit(N) - for i in range(N): + c = tc.Circuit(nq) + for i in range(nq): c.H(i) for i in range(0, 2): - for j in range(N): - c.cnot(j, (j + 1) % N) - for j in range(N): - c.rx(j, theta=0.1 * np.pi) + for j in range(nq): + c.cnot(j, (j + 1) % nq) + for j in range(nq): + c.rx(j, theta=0.5 * np.pi) - ps = [1, 1, 0, 2, 2, 0] + def classical_shadow(psi, pauli_strings, status, sub, x, y, z): + snapshots = shadow_snapshots(psi, pauli_strings, status) + lss_states = local_snapshot_states(snapshots, pauli_strings) + sdw_state = global_shadow_state(lss_states, sub=sub) + expc = expection_ps_shadow(lss_states, x=x, y=y, z=z, k=20) + ent = entropy_shadow(sdw_state, alpha=2) + return expc, ent, lss_states, sdw_state - print("exact:", c.expectation_ps(ps=ps)) + csjit = tc.backend.jit(classical_shadow, static_argnums=(4, 5, 6)) - psi0 = c.state() - pauli_strings = np.random.randint(0, 3, size=(10000, N)) - snapshots = shadow_snapshots(psi0, backend.convert_to_tensor(pauli_strings), repeat=1) + pauli_strings = tc.backend.convert_to_tensor(np.random.randint(0, 3, size=(ns, nq))) + status = tc.backend.convert_to_tensor(np.random.rand(ns, 6)) + x, y, z = (0, 6), (2, 3), (5, 7) + sub = [1, 3, 6, 7] - import pennylane as qml - shadow = qml.ClassicalShadow(np.asarray(snapshots[:, 0]), np.asarray(pauli_strings)) - H = [qml.PauliX(0) @ qml.PauliX(1) @ qml.PauliY(3) @ qml.PauliY(4)] - pl_expc = shadow.expval(H, k=10) - pl_ent = shadow.entropy(range(2), alpha=1) - print("pl:", pl_expc, pl_ent) - expc = expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=10) - ent = entropy_shadow(snapshots, pauli_strings, sub=range(2), alpha=1) - print("here:", np.median(expc), ent) - print(expc) + exact = c.expectation_ps(x=x, y=y, z=z) + expc, ent, lss_states, sdw_state = csjit(c.state(), pauli_strings, status, sub, x, y, z) + expc = np.median(expc) - # jit test - def classical_shadow(psi, pauli_strings): - snapshots = shadow_snapshots(psi, pauli_strings, repeat=1) - lss_states = local_snapshot_states(snapshots, pauli_strings) - gss_states = global_snapshot_states(lss_states, sub=[1, 3, 5]) - sdw_state = shadow_state(gss_states) - expc = expection_ps_shadow(lss_states, ps=ps, k=10) - ent = entropy_shadow(sdw_state, alpha=2) - return expc, ent, lss_states.shape, gss_states.shape, sdw_state.shape + assert np.abs(expc - exact) < 0.1 + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_state(backend): + nq, ns = 2, 10000 + + c = tc.Circuit(nq) + c.H(0) + c.cnot(0, 1) + + psi = c.state() + bell_state = psi[:, None] @ psi[None, :] + + pauli_strings = tc.backend.convert_to_tensor(np.random.randint(0, 3, size=(ns, nq))) + status = tc.backend.convert_to_tensor(np.random.rand(ns, 1)) + snapshots = shadow_snapshots(c.state(), pauli_strings, status) + + lss_states = local_snapshot_states(snapshots, pauli_strings) + sdw_state = global_shadow_state(lss_states) + + R = np.array(sdw_state - bell_state) + assert np.sqrt(np.trace(R.conj().T @ R)) < 0.1 + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_expc(backend): + nq, ns = 6, 10000 + + c = tc.Circuit(nq) + for i in range(nq): + c.H(i) + for i in range(0, 2): + for j in range(nq): + c.cnot(j, (j + 1) % nq) + for j in range(nq): + c.rx(j, theta=0.1 * np.pi) + + ps = [1, 1, 0, 2, 3, 0] + exact = c.expectation_ps(ps=ps) + + pauli_strings = tc.backend.convert_to_tensor(np.random.randint(0, 3, size=(ns, nq))) + status = tc.backend.convert_to_tensor(np.random.rand(ns, 2)) + snapshots = shadow_snapshots(c.state(), pauli_strings, status) - csjit = backend.jit(classical_shadow) + expc = np.median(expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=9)) + # ent = entropy_shadow(snapshots, pauli_strings, range(4), alpha=2) + # import pennylane as qml + # shadow = qml.ClassicalShadow(np.asarray(snapshots[:, 0]), np.asarray(pauli_strings)) # repeat == 1 + # H = qml.PauliX(0) @ qml.PauliX(1) @ qml.PauliY(3) @ qml.PauliZ(4) + # pl_expc = shadow.expval(H, k=9) + # pl_ent = shadow.entropy(range(4), alpha=2) + # print(np.isclose(expc, pl_expc), np.isclose(ent, pl_ent)) - pauli_strings = backend.convert_to_tensor(np.random.randint(0, 3, size=(10000, N))) - res = csjit(psi0, pauli_strings) - print(res) \ No newline at end of file + assert np.abs(expc - exact) < 0.1 From 1b8715ee41d41b027dad8166de1fe7de0b700ad3 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 2 Aug 2023 20:05:59 +0800 Subject: [PATCH 581/725] Update shadows.py and test_shadows.py and quantum.py --- tensorcircuit/quantum.py | 1 + tensorcircuit/shadows.py | 314 ++++++++++++++++++++++++--------------- tests/test_shadows.py | 137 +++++++++-------- 3 files changed, 272 insertions(+), 180 deletions(-) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index ab837c7f..55aea42a 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1543,6 +1543,7 @@ def entanglement2(param, n, nlayers): rho += eps * backend.cast(backend.eye(rho.shape[-1]), rho.dtype) # type: ignore lbd = backend.real(backend.eigh(rho)[0]) lbd = backend.relu(lbd) + lbd /= backend.sum(lbd) # we need the matrix anyway for AD. entropy = -backend.sum(lbd * backend.log(lbd + eps)) return backend.real(entropy) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index bed032c7..7f22f8dc 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -1,18 +1,49 @@ """ Classical Shadows functions """ -from typing import Any, Optional, Sequence +from typing import Any, Union, Optional, Sequence from string import ascii_letters as ABC import numpy as np from .cons import backend, dtypestr, rdtypestr from .circuit import Circuit -from .quantum import PauliString2COO, QuOperator Tensor = Any -def shadow_snapshots(psi: Tensor, pauli_strings: Tensor, status: Optional[Tensor] = None): +def shadow_bound( + observables: Union[np.ndarray, Sequence[int]], epsilon: float, delta: float = 0.01 +): + r"""Calculate the shadow bound of the Pauli observables, please refer to the Theorem S1 and Lemma S3 in Huang, H.-Y., R. Kueng, and J. Preskill, 2020, Nat. Phys. 16, 1050. + + :param observables: shape = (nq,) or (M, nq), where nq is the number of qubits, M is the number of observables + :type: Union[numpy.ndarray, Sequence[int]] + :param epsilon: error on the estimator + :type: float + :param delta: rate of failure for the bound to hold + :type: float + + :return Nk: number of snapshots + :rtype: int + :return k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. + :rtype: int + """ + observables = np.sign(np.asarray(observables)) + if len(observables.shape) == 1: + observables = observables[None, :] + M = observables.shape[0] + k = np.ceil(2 * np.log(2 * M / delta)) + max_length = np.max(np.sum(observables, axis=1)) + N = np.ceil((34 / epsilon**2) * 3**max_length) + return int(N * k), int(k) + + +def shadow_snapshots( + psi: Tensor, + pauli_strings: Tensor, + status: Optional[Tensor] = None, + measurement_only: bool = False, +): r"""To generate the shadow snapshots from given pauli string observables on $|\psi\rangle$ :param psi: shape = (2 ** nq, 2 ** nq), where nq is the number of qubits @@ -21,39 +52,64 @@ def shadow_snapshots(psi: Tensor, pauli_strings: Tensor, status: Optional[Tensor :type: Tensor :param status: shape = None or (ns, repeat), where repeat is the times to measure on one pauli string :type: Optional[Tensor] + :param measurement_only: return snapshots (True) or snapshot states (false), default=False + :type: bool :return snapshots: shape = (ns, repeat, nq) :rtype: Tensor """ - pauli_strings = backend.cast(pauli_strings, dtype="int32") + pauli_strings = backend.cast(pauli_strings, dtype="int32") - 1 ns, nq = pauli_strings.shape - if 2 ** nq != len(psi): - raise RuntimeError( - f"The number of qubits of psi and pauli_strings should be the same, but got {nq} and {int(np.log2(len(psi)))}.") + if 2**nq != len(psi): + raise ValueError( + f"The number of qubits of psi and pauli_strings should be the same, but got {nq} and {int(np.log2(len(psi)))}." + ) if status is None: status = backend.convert_to_tensor(np.random.rand(ns, 1)) elif status.shape[0] != ns: - raise RuntimeError(f"status.shape[0] should be {ns}, but got {status.shape[0]}.") + raise ValueError(f"status.shape[0] should be {ns}, but got {status.shape[0]}.") status = backend.cast(status, dtype=rdtypestr) repeat = status.shape[1] - angles = backend.cast(backend.convert_to_tensor( - [[-np.pi / 2, np.pi / 4, 0], [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], [0, 0, 0]]), - dtype=rdtypestr) # (3, 3) + angles = backend.cast( + backend.convert_to_tensor( + [ + [-np.pi / 2, np.pi / 4, 0], + [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], + [0, 0, 0], + ] + ), + dtype=rdtypestr, + ) # (3, 3) def proj_measure(pauli_string, st): c_ = Circuit(nq, inputs=psi) for i in range(nq): - c_.R(i, theta=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 0), - alpha=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 1), - phi=backend.gather1d(backend.gather1d(angles, backend.gather1d(pauli_string, i)), 2)) + c_.R( + i, + theta=backend.gather1d( + backend.gather1d(angles, backend.gather1d(pauli_string, i)), 0 + ), + alpha=backend.gather1d( + backend.gather1d(angles, backend.gather1d(pauli_string, i)), 1 + ), + phi=backend.gather1d( + backend.gather1d(angles, backend.gather1d(pauli_string, i)), 2 + ), + ) return c_.sample(batch=repeat, format="sample_bin", allow_state=True, status=st) vpm = backend.vmap(proj_measure, vectorized_argnums=(0, 1)) - return vpm(pauli_strings, status) # (ns, repeat, nq) + snapshots = vpm(pauli_strings, status) # (ns, repeat, nq) + if measurement_only: + return snapshots + else: + return local_snapshot_states(snapshots, pauli_strings + 1) -def local_snapshot_states(snapshots: Tensor, pauli_strings: Tensor, sub: Optional[Sequence[int]] = None): +def local_snapshot_states( + snapshots: Tensor, pauli_strings: Tensor, sub: Optional[Sequence[int]] = None +): r"""To generate the local snapshots states from snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq) @@ -66,13 +122,25 @@ def local_snapshot_states(snapshots: Tensor, pauli_strings: Tensor, sub: Optiona :return lss_states: shape = (ns, repeat, nq, 2, 2) :rtype: Tensor """ - pauli_strings = backend.cast(pauli_strings, dtype="int32") + pauli_strings = backend.cast(pauli_strings, dtype="int32") - 1 if len(pauli_strings.shape) < len(snapshots.shape): - pauli_strings = backend.tile(pauli_strings[:, None, :], (1, snapshots.shape[1], 1)) # (ns, repeat, nq) + pauli_strings = backend.tile( + pauli_strings[:, None, :], (1, snapshots.shape[1], 1) + ) # (ns, repeat, nq) - X_dm = backend.cast(backend.convert_to_tensor([[[1, 1], [1, 1]], [[1, -1], [-1, 1]]]) / 2, dtype=dtypestr) - Y_dm = backend.cast(backend.convert_to_tensor(np.array([[[1, -1j], [1j, 1]], [[1, 1j], [-1j, 1]]]) / 2), dtype=dtypestr) - Z_dm = backend.cast(backend.convert_to_tensor([[[1, 0], [0, 0]], [[0, 0], [0, 1]]]), dtype=dtypestr) + X_dm = backend.cast( + backend.convert_to_tensor([[[1, 1], [1, 1]], [[1, -1], [-1, 1]]]) / 2, + dtype=dtypestr, + ) + Y_dm = backend.cast( + backend.convert_to_tensor( + np.array([[[1, -1j], [1j, 1]], [[1, 1j], [-1j, 1]]]) / 2 + ), + dtype=dtypestr, + ) + Z_dm = backend.cast( + backend.convert_to_tensor([[[1, 0], [0, 0]], [[0, 0], [0, 1]]]), dtype=dtypestr + ) pauli_dm = backend.stack((X_dm, Y_dm, Z_dm), axis=0) # (3, 2, 2, 2) def dm(p, s): @@ -84,17 +152,15 @@ def dm(p, s): lss_states = vvv(pauli_strings, snapshots) if sub is not None: - lss_states = backend.transpose(lss_states, (2, 0, 1, 3, 4)) - def slice_sub(idx): - return backend.gather1d(lss_states, idx) - - v0 = backend.vmap(slice_sub, vectorized_argnums=0) - lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) - + lss_states = slice_sub(lss_states, sub) return 3 * lss_states - backend.eye(2)[None, None, None, :, :] -def global_shadow_state(snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None): +def global_shadow_state( + snapshots: Tensor, + pauli_strings: Optional[Tensor] = None, + sub: Optional[Sequence[int]] = None, +): r"""To generate the global shadow state from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -109,19 +175,15 @@ def global_shadow_state(snapshots: Tensor, pauli_strings: Optional[Tensor] = Non """ if pauli_strings is not None: if len(snapshots.shape) != 3: - raise RuntimeError( - f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead.") - pauli_strings = backend.cast(pauli_strings, dtype="int32") - lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) + raise ValueError( + f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead." + ) + lss_states = local_snapshot_states( + snapshots, pauli_strings, sub + ) # (ns, repeat, nq_sub, 2, 2) else: if sub is not None: - lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) - - def slice_sub(idx): - return backend.gather1d(lss_states, idx) - - v0 = backend.vmap(slice_sub, vectorized_argnums=0) - lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) + lss_states = slice_sub(snapshots, sub) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) @@ -139,9 +201,15 @@ def tensor_prod(dms): return backend.mean(gss_states, axis=(0, 1)) -def expection_ps_shadow(snapshots: Tensor, pauli_strings: Optional[Tensor] = None, x: Optional[Sequence[int]] = None, - y: Optional[Sequence[int]] = None, z: Optional[Sequence[int]] = None, - ps: Optional[Sequence[int]] = None, k: int = 1): +def expection_ps_shadow( + snapshots: Tensor, + pauli_strings: Optional[Tensor] = None, + x: Optional[Sequence[int]] = None, + y: Optional[Sequence[int]] = None, + z: Optional[Sequence[int]] = None, + ps: Optional[Sequence[int]] = None, + k: int = 1, +): r"""To calculate the expectation value of an observable on shadow snapshot states :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -164,10 +232,12 @@ def expection_ps_shadow(snapshots: Tensor, pauli_strings: Optional[Tensor] = Non """ if pauli_strings is not None: if len(snapshots.shape) != 3: - raise RuntimeError( - f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead.") - pauli_strings = backend.cast(pauli_strings, dtype="int32") - lss_states = local_snapshot_states(snapshots, pauli_strings) # (ns, repeat, nq, 2, 2) + raise ValueError( + f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead." + ) + lss_states = local_snapshot_states( + snapshots, pauli_strings + ) # (ns, repeat, nq, 2, 2) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) ns, repeat, nq, _, _ = lss_states.shape @@ -186,13 +256,24 @@ def expection_ps_shadow(snapshots: Tensor, pauli_strings: Optional[Tensor] = Non for i in z: ps[i] = 3 elif len(ps) != nq: - raise RuntimeError( - f"The number of qubits of the shadow state is {nq}, but got a {len(ps)}-qubit pauli string observable.") + raise ValueError( + f"The number of qubits of the shadow state is {nq}, but got a {len(ps)}-qubit pauli string observable." + ) ps = backend.cast(backend.convert_to_tensor(ps), dtype="int32") # (nq,) paulis = backend.convert_to_tensor( - backend.cast(np.array([[[1, 0], [0, 1]], [[0, 1], [1, 0]], [[0, -1j], [1j, 0]], [[1, 0], [0, -1]]]), - dtype=dtypestr)) # (4, 2, 2) + backend.cast( + np.array( + [ + [[1, 0], [0, 1]], + [[0, 1], [1, 0]], + [[0, -1j], [1j, 0]], + [[1, 0], [0, -1]], + ] + ), + dtype=dtypestr, + ) + ) # (4, 2, 2) def trace_paulis_prod(dm, idx): return backend.real(backend.trace(backend.gather1d(paulis, idx) @ dm)) @@ -205,13 +286,18 @@ def prod(dm): vv = backend.vmap(prod, vectorized_argnums=0) # (ns,) batch = int(np.ceil(ns / k)) - return [backend.mean(vv(ss_states[i: i + batch])) for i in range(0, ns, batch)] + return [backend.mean(vv(ss_states[i : i + batch])) for i in range(0, ns, batch)] -def entropy_shadow(ss_or_sd: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None, alpha: int = 1): +def entropy_shadow( + snapshots: Tensor, + pauli_strings: Optional[Tensor] = None, + sub: Optional[Sequence[int]] = None, + alpha: int = 2, +): r"""To calculate the Renyi entropy of a subsystem from shadow state or shadow snapshot states - :param ss_or_sd: shadow state (shape = (2 ** nq, 2 ** nq)) or snapshot states (shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq)) + :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) :type: Tensor :param pauli_strings: shape = None or (ns, nq) or (ns, repeat, nq) :type: Optional[Tensor] @@ -222,16 +308,13 @@ def entropy_shadow(ss_or_sd: Tensor, pauli_strings: Optional[Tensor] = None, sub :return Renyi entropy: shape = () :rtype: Tensor + + TODO: special case of alpha=2 """ if alpha <= 0: raise ValueError("Alpha should not be less than 1!") - if len(ss_or_sd.shape) == 2 and ss_or_sd.shape[0] == ss_or_sd.shape[1]: - if sub is not None: - raise ValueError("sub should be None if the input is the global shadow state.") - sdw_rdm = ss_or_sd - else: - sdw_rdm = global_shadow_state(ss_or_sd, pauli_strings, sub) # (2 ** nq, 2 ** nq) + sdw_rdm = global_shadow_state(snapshots, pauli_strings, sub) # (2 ** nq, 2 ** nq) evs = backend.relu(backend.real(backend.eigvalsh(sdw_rdm))) evs /= backend.sum(evs) @@ -241,7 +324,11 @@ def entropy_shadow(ss_or_sd: Tensor, pauli_strings: Optional[Tensor] = None, sub return backend.log(backend.sum(backend.power(evs, alpha))) / (1 - alpha) -def global_shadow_state1(snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None): +def global_shadow_state1( + snapshots: Tensor, + pauli_strings: Optional[Tensor] = None, + sub: Optional[Sequence[int]] = None, +): r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -256,35 +343,39 @@ def global_shadow_state1(snapshots: Tensor, pauli_strings: Optional[Tensor] = No """ if pauli_strings is not None: if len(snapshots.shape) != 3: - raise RuntimeError( - f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead.") - pauli_strings = backend.cast(pauli_strings, dtype="int32") - lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) + raise ValueError( + f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead." + ) + lss_states = local_snapshot_states( + snapshots, pauli_strings, sub + ) # (ns, repeat, nq_sub, 2, 2) else: if sub is not None: - lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) - - def slice_sub(idx): - return backend.gather1d(lss_states, idx) - - v0 = backend.vmap(slice_sub, vectorized_argnums=0) - lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) + lss_states = slice_sub(snapshots, sub) else: - lss_states = snapshots # (ns, repeat, nq, 2, 2) - lss_states = backend.transpose(lss_states, (2, 0, 1, 3, 4)) # (nq, ns, repeat, 2, 2) + lss_states = snapshots # (ns, repeat, nq, 2, 2) + lss_states = backend.transpose( + lss_states, (2, 0, 1, 3, 4) + ) # (nq, ns, repeat, 2, 2) nq, ns, repeat, _, _ = lss_states.shape old_indices = [f"ab{ABC[2 + 2 * i: 4 + 2 * i]}" for i in range(nq)] new_indices = f"ab{ABC[2:2 * nq + 2:2]}{ABC[3:2 * nq + 2:2]}" gss_states = backend.reshape( - backend.einsum(f'{",".join(old_indices)}->{new_indices}', *lss_states, optimize=True), - (ns, repeat, 2 ** nq, 2 ** nq), + backend.einsum( + f'{",".join(old_indices)}->{new_indices}', *lss_states, optimize=True + ), + (ns, repeat, 2**nq, 2**nq), ) return backend.mean(gss_states, axis=(0, 1)) -def global_shadow_state2(snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None): +def global_shadow_state2( + snapshots: Tensor, + pauli_strings: Optional[Tensor] = None, + sub: Optional[Sequence[int]] = None, +): r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -299,19 +390,15 @@ def global_shadow_state2(snapshots: Tensor, pauli_strings: Optional[Tensor] = No """ if pauli_strings is not None: if len(snapshots.shape) != 3: - raise RuntimeError( - f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead.") - pauli_strings = backend.cast(pauli_strings, dtype="int32") - lss_states = local_snapshot_states(snapshots, pauli_strings, sub) # (ns, repeat, nq_sub, 2, 2) + raise ValueError( + f"snapshots should be 3-d if pauli_strings is not None, got {len(snapshots.shape)}-d instead." + ) + lss_states = local_snapshot_states( + snapshots, pauli_strings, sub + ) # (ns, repeat, nq_sub, 2, 2) else: if sub is not None: - lss_states = backend.transpose(snapshots, (2, 0, 1, 3, 4)) - - def slice_sub(idx): - return backend.gather1d(lss_states, idx) - - v0 = backend.vmap(slice_sub, vectorized_argnums=0) - lss_states = backend.transpose(v0(backend.convert_to_tensor(sub)), (1, 2, 0, 3, 4)) + lss_states = slice_sub(snapshots, sub) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) ns, repeat, nq, _, _ = lss_states.shape @@ -320,8 +407,12 @@ def slice_sub(idx): new_indices = f"{ABC[0:2 * nq:2]}{ABC[1:2 * nq:2]}" def tensor_prod(dms): - return backend.reshape(backend.einsum(f'{",".join(old_indices)}->{new_indices}', *dms, optimize=True), - (2 ** nq, 2 ** nq)) + return backend.reshape( + backend.einsum( + f'{",".join(old_indices)}->{new_indices}', *dms, optimize=True + ), + (2**nq, 2**nq), + ) v = backend.vmap(tensor_prod, vectorized_argnums=0) vv = backend.vmap(v, vectorized_argnums=0) @@ -329,39 +420,22 @@ def tensor_prod(dms): return backend.mean(gss_states, axis=(0, 1)) -def shadow_bound(observables: Tensor, epsilon: float, delta: float = 0.01): - r"""Calculate the shadow bound of the Pauli observables, please refer to the Theorem S1 in Huang, H.-Y., R. Kueng, and J. Preskill, 2020, Nat. Phys. 16, 1050. +def slice_sub(entirety: Tensor, sub: Sequence[int]): + r"""To slice off the subsystem - :param observables: shape = (nq,) or (M, nq), where nq is the number of qubits, M is the number of observables + :param entirety: shape = (ns, repeat, nq, 2, 2) :type: Tensor - :param epsilon: error on the estimator - :type: float - :param delta: rate of failure for the bound to hold - :type: float + :param sub: qubit indices of subsystem + :type: Sequence[int] - :return Nk: number of snapshots - :rtype: int - :return k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. - :rtype: int + :return subsystem: shape = (ns, repeat, nq_sub, 2, 2) + :rtype: Tensor """ - observables = backend.cast(observables, dtype="int32") - M = observables.shape[0] - k = int(2 * np.log(2 * M / delta)) - - def shadow_norm(o): - o = backend.to_dense(PauliString2COO(o)) - qo = QuOperator.from_tensor(o) - # print(qo.eval()) - n = qo.norm().eval() - # print(n) - return n ** 2 - - v = backend.vmap(shadow_norm, vectorized_argnums=0) - - N = int(34 * backend.max(v(observables)) / epsilon ** 2) - return N * k, k - - - + def slc(x, idx): + return backend.gather1d(x, idx) + v = backend.vmap(slc, vectorized_argnums=(1,)) + vv = backend.vmap(v, vectorized_argnums=(0,)) + vvv = backend.vmap(vv, vectorized_argnums=(0,)) + return vvv(entirety, backend.convert_to_tensor(sub)) diff --git a/tests/test_shadows.py b/tests/test_shadows.py index 7cd39563..0a4c6b19 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -1,49 +1,64 @@ -import numpy as np import pytest from pytest_lazyfixture import lazy_fixture as lf +import numpy as np import tensorcircuit as tc -from tensorcircuit.shadows import shadow_snapshots, local_snapshot_states, global_shadow_state, global_shadow_state1, \ - global_shadow_state2, entropy_shadow, expection_ps_shadow, shadow_bound +from tensorcircuit.shadows import ( + shadow_bound, + shadow_snapshots, + local_snapshot_states, + global_shadow_state, + global_shadow_state1, + global_shadow_state2, + entropy_shadow, + expection_ps_shadow, +) @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_jit(backend): - nq, ns = 8, 10000 + nq, repeat = 8, 5 + ps = [1, 0, 0, 0, 2, 0, 0, 0] + sub = (1, 3, 6, 7) + error = 0.1 + ns, k = shadow_bound(ps, error) + ns //= repeat + + thetas = 2 * np.random.rand(2, nq) - 1 c = tc.Circuit(nq) for i in range(nq): c.H(i) - for i in range(0, 2): + for i in range(2): for j in range(nq): c.cnot(j, (j + 1) % nq) for j in range(nq): - c.rx(j, theta=0.5 * np.pi) + c.rz(j, theta=thetas[i, j] * np.pi) - def classical_shadow(psi, pauli_strings, status, sub, x, y, z): - snapshots = shadow_snapshots(psi, pauli_strings, status) - lss_states = local_snapshot_states(snapshots, pauli_strings) - sdw_state = global_shadow_state(lss_states, sub=sub) - expc = expection_ps_shadow(lss_states, x=x, y=y, z=z, k=20) - ent = entropy_shadow(sdw_state, alpha=2) - return expc, ent, lss_states, sdw_state + psi = c.state() + pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(ns, nq))) + status = tc.backend.convert_to_tensor(np.random.rand(ns, repeat)) - csjit = tc.backend.jit(classical_shadow, static_argnums=(4, 5, 6)) + def classical_shadow(psi, pauli_strings, status): + lss_states = shadow_snapshots(psi, pauli_strings, status) + expc = expection_ps_shadow(lss_states, ps=ps, k=k) + ent = entropy_shadow(lss_states, sub=sub, alpha=2) + return expc, ent - pauli_strings = tc.backend.convert_to_tensor(np.random.randint(0, 3, size=(ns, nq))) - status = tc.backend.convert_to_tensor(np.random.rand(ns, 6)) - x, y, z = (0, 6), (2, 3), (5, 7) - sub = [1, 3, 6, 7] + csjit = tc.backend.jit(classical_shadow) - exact = c.expectation_ps(x=x, y=y, z=z) - expc, ent, lss_states, sdw_state = csjit(c.state(), pauli_strings, status, sub, x, y, z) + exact_expc = c.expectation_ps(ps=ps) + exact_rdm = tc.quantum.reduced_density_matrix(psi, cut=[0, 2, 4, 5]) + exact_ent = tc.quantum.renyi_entropy(exact_rdm, k=2) + expc, ent = csjit(psi, pauli_strings, status) expc = np.median(expc) - assert np.abs(expc - exact) < 0.1 + assert np.abs(expc - exact_expc) < error + assert np.abs(ent - exact_ent) < 5 * error @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_state(backend): - nq, ns = 2, 10000 + nq, ns = 2, 6000 c = tc.Circuit(nq) c.H(0) @@ -52,44 +67,46 @@ def test_state(backend): psi = c.state() bell_state = psi[:, None] @ psi[None, :] - pauli_strings = tc.backend.convert_to_tensor(np.random.randint(0, 3, size=(ns, nq))) - status = tc.backend.convert_to_tensor(np.random.rand(ns, 1)) - snapshots = shadow_snapshots(c.state(), pauli_strings, status) - - lss_states = local_snapshot_states(snapshots, pauli_strings) + pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(ns, nq))) + status = tc.backend.convert_to_tensor(np.random.rand(ns, 2)) + lss_states = shadow_snapshots(c.state(), pauli_strings, status) sdw_state = global_shadow_state(lss_states) R = np.array(sdw_state - bell_state) - assert np.sqrt(np.trace(R.conj().T @ R)) < 0.1 - - -@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) -def test_expc(backend): - nq, ns = 6, 10000 - - c = tc.Circuit(nq) - for i in range(nq): - c.H(i) - for i in range(0, 2): - for j in range(nq): - c.cnot(j, (j + 1) % nq) - for j in range(nq): - c.rx(j, theta=0.1 * np.pi) - - ps = [1, 1, 0, 2, 3, 0] - exact = c.expectation_ps(ps=ps) - - pauli_strings = tc.backend.convert_to_tensor(np.random.randint(0, 3, size=(ns, nq))) - status = tc.backend.convert_to_tensor(np.random.rand(ns, 2)) - snapshots = shadow_snapshots(c.state(), pauli_strings, status) - - expc = np.median(expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=9)) - # ent = entropy_shadow(snapshots, pauli_strings, range(4), alpha=2) - # import pennylane as qml - # shadow = qml.ClassicalShadow(np.asarray(snapshots[:, 0]), np.asarray(pauli_strings)) # repeat == 1 - # H = qml.PauliX(0) @ qml.PauliX(1) @ qml.PauliY(3) @ qml.PauliZ(4) - # pl_expc = shadow.expval(H, k=9) - # pl_ent = shadow.entropy(range(4), alpha=2) - # print(np.isclose(expc, pl_expc), np.isclose(ent, pl_ent)) - - assert np.abs(expc - exact) < 0.1 + error = np.sqrt(np.trace(R.conj().T @ R)) + assert error < 0.1 + + +# @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +# def test_expc(backend): +# import pennylane as qml +# nq, ns = 8, 100000 +# +# c = tc.Circuit(nq) +# for i in range(nq): +# c.H(i) +# for j in range(nq): +# c.cnot(j, (j + 1) % nq) +# for j in range(nq): +# c.rx(j, theta=0.1 * np.pi) +# +# ps = [1, 0, 2, 2, 0, 3, 1, 3] +# exact = c.expectation_ps(ps=ps) +# +# pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(ns, nq))) +# status = tc.backend.convert_to_tensor(np.random.rand(ns, 1)) +# snapshots = shadow_snapshots( +# c.state(), pauli_strings, status, measurement_only=True +# ) +# +# expc = np.median(expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=9)) +# ent = entropy_shadow(snapshots, pauli_strings, range(4), alpha=2) +# +# shadow = qml.ClassicalShadow(np.asarray(snapshots[:, 0]), np.asarray(pauli_strings - 1)) # repeat == 1 +# H = qml.PauliX(0) @ qml.PauliX(6) @ qml.PauliY(2)@ qml.PauliY(3) @ qml.PauliZ(5) @ qml.PauliZ(7) +# pl_expc = shadow.expval(H, k=9) +# pl_ent = shadow.entropy(range(4), alpha=2) +# +# print(np.isclose(expc, pl_expc), np.isclose(ent, pl_ent)) +# +# assert np.abs(expc - exact) < 0.1 From f2185bdfbadc62c75cc4b3e8603a1cf824830c90 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 2 Aug 2023 21:22:48 +0800 Subject: [PATCH 582/725] Update shadows.py and test_shadows.py --- tensorcircuit/shadows.py | 60 ++++++++++++++++++++++------------------ tests/test_shadows.py | 19 ++++++------- 2 files changed, 42 insertions(+), 37 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 7f22f8dc..b581e04e 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -1,9 +1,10 @@ """ Classical Shadows functions """ -from typing import Any, Union, Optional, Sequence +from typing import Any, Union, Optional, Sequence, Tuple, List from string import ascii_letters as ABC import numpy as np +from numpy import ndarray from .cons import backend, dtypestr, rdtypestr from .circuit import Circuit @@ -12,8 +13,8 @@ def shadow_bound( - observables: Union[np.ndarray, Sequence[int]], epsilon: float, delta: float = 0.01 -): + observables: Union[Tensor, Sequence[int]], epsilon: float, delta: float = 0.01 +) -> Tuple[int, int]: r"""Calculate the shadow bound of the Pauli observables, please refer to the Theorem S1 and Lemma S3 in Huang, H.-Y., R. Kueng, and J. Preskill, 2020, Nat. Phys. 16, 1050. :param observables: shape = (nq,) or (M, nq), where nq is the number of qubits, M is the number of observables @@ -28,12 +29,12 @@ def shadow_bound( :return k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. :rtype: int """ - observables = np.sign(np.asarray(observables)) - if len(observables.shape) == 1: - observables = observables[None, :] - M = observables.shape[0] + count = np.sign(np.asarray(observables)) + if len(count.shape) == 1: + count = count[None, :] + M = count.shape[0] k = np.ceil(2 * np.log(2 * M / delta)) - max_length = np.max(np.sum(observables, axis=1)) + max_length = np.max(np.sum(count, axis=1)) N = np.ceil((34 / epsilon**2) * 3**max_length) return int(N * k), int(k) @@ -42,8 +43,9 @@ def shadow_snapshots( psi: Tensor, pauli_strings: Tensor, status: Optional[Tensor] = None, + sub: Optional[Sequence[int]] = None, measurement_only: bool = False, -): +) -> Tensor: r"""To generate the shadow snapshots from given pauli string observables on $|\psi\rangle$ :param psi: shape = (2 ** nq, 2 ** nq), where nq is the number of qubits @@ -52,6 +54,8 @@ def shadow_snapshots( :type: Tensor :param status: shape = None or (ns, repeat), where repeat is the times to measure on one pauli string :type: Optional[Tensor] + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] :param measurement_only: return snapshots (True) or snapshot states (false), default=False :type: bool @@ -82,10 +86,10 @@ def shadow_snapshots( dtype=rdtypestr, ) # (3, 3) - def proj_measure(pauli_string, st): + def proj_measure(pauli_string: Tensor, st: Tensor) -> Tensor: c_ = Circuit(nq, inputs=psi) for i in range(nq): - c_.R( + c_.r( i, theta=backend.gather1d( backend.gather1d(angles, backend.gather1d(pauli_string, i)), 0 @@ -102,14 +106,14 @@ def proj_measure(pauli_string, st): vpm = backend.vmap(proj_measure, vectorized_argnums=(0, 1)) snapshots = vpm(pauli_strings, status) # (ns, repeat, nq) if measurement_only: - return snapshots + return snapshots if sub is None else slice_sub(snapshots, sub) else: - return local_snapshot_states(snapshots, pauli_strings + 1) + return local_snapshot_states(snapshots, pauli_strings + 1, sub) def local_snapshot_states( snapshots: Tensor, pauli_strings: Tensor, sub: Optional[Sequence[int]] = None -): +) -> Tensor: r"""To generate the local snapshots states from snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq) @@ -143,7 +147,7 @@ def local_snapshot_states( ) pauli_dm = backend.stack((X_dm, Y_dm, Z_dm), axis=0) # (3, 2, 2, 2) - def dm(p, s): + def dm(p: Tensor, s: Tensor) -> Tensor: return backend.gather1d(backend.gather1d(pauli_dm, p), s) v = backend.vmap(dm, vectorized_argnums=(0, 1)) @@ -160,7 +164,7 @@ def global_shadow_state( snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None, -): +) -> Tensor: r"""To generate the global shadow state from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -189,7 +193,7 @@ def global_shadow_state( nq = lss_states.shape[2] - def tensor_prod(dms): + def tensor_prod(dms: Tensor) -> Tensor: res = backend.gather1d(dms, 0) for i in range(1, nq): res = backend.kron(res, backend.gather1d(dms, i)) @@ -209,7 +213,7 @@ def expection_ps_shadow( z: Optional[Sequence[int]] = None, ps: Optional[Sequence[int]] = None, k: int = 1, -): +) -> List[Tensor]: r"""To calculate the expectation value of an observable on shadow snapshot states :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -275,12 +279,12 @@ def expection_ps_shadow( ) ) # (4, 2, 2) - def trace_paulis_prod(dm, idx): + def trace_paulis_prod(dm: Tensor, idx: Tensor) -> Tensor: return backend.real(backend.trace(backend.gather1d(paulis, idx) @ dm)) v = backend.vmap(trace_paulis_prod, vectorized_argnums=(0, 1)) # (nq,) - def prod(dm): + def prod(dm: Tensor) -> Tensor: return backend.shape_prod(v(dm, ps)) vv = backend.vmap(prod, vectorized_argnums=0) # (ns,) @@ -294,7 +298,7 @@ def entropy_shadow( pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None, alpha: int = 2, -): +) -> Tensor: r"""To calculate the Renyi entropy of a subsystem from shadow state or shadow snapshot states :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -328,7 +332,7 @@ def global_shadow_state1( snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None, -): +) -> Tensor: r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -375,7 +379,7 @@ def global_shadow_state2( snapshots: Tensor, pauli_strings: Optional[Tensor] = None, sub: Optional[Sequence[int]] = None, -): +) -> Tensor: r"""To generate the global snapshots states from local snapshot states or snapshots and pauli strings :param snapshots: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) @@ -406,7 +410,7 @@ def global_shadow_state2( old_indices = [f"{ABC[2 * i: 2 + 2 * i]}" for i in range(nq)] new_indices = f"{ABC[0:2 * nq:2]}{ABC[1:2 * nq:2]}" - def tensor_prod(dms): + def tensor_prod(dms: Tensor) -> Tensor: return backend.reshape( backend.einsum( f'{",".join(old_indices)}->{new_indices}', *dms, optimize=True @@ -420,10 +424,10 @@ def tensor_prod(dms): return backend.mean(gss_states, axis=(0, 1)) -def slice_sub(entirety: Tensor, sub: Sequence[int]): +def slice_sub(entirety: Tensor, sub: Sequence[int]) -> Tensor: r"""To slice off the subsystem - :param entirety: shape = (ns, repeat, nq, 2, 2) + :param entirety: shape = (ns, repeat, nq, 2, 2) or (ns, repeat, nq) :type: Tensor :param sub: qubit indices of subsystem :type: Sequence[int] @@ -431,8 +435,10 @@ def slice_sub(entirety: Tensor, sub: Sequence[int]): :return subsystem: shape = (ns, repeat, nq_sub, 2, 2) :rtype: Tensor """ + if len(entirety.shape) < 3: + entirety = entirety[:, None, :] - def slc(x, idx): + def slc(x: Tensor, idx: Tensor) -> Tensor: return backend.gather1d(x, idx) v = backend.vmap(slc, vectorized_argnums=(1,)) diff --git a/tests/test_shadows.py b/tests/test_shadows.py index 0a4c6b19..23bec89a 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -7,10 +7,11 @@ shadow_snapshots, local_snapshot_states, global_shadow_state, - global_shadow_state1, - global_shadow_state2, entropy_shadow, expection_ps_shadow, + global_shadow_state1, + global_shadow_state2, + slice_sub, ) @@ -58,7 +59,7 @@ def classical_shadow(psi, pauli_strings, status): @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_state(backend): - nq, ns = 2, 6000 + nq, ns = 2, 10000 c = tc.Circuit(nq) c.H(0) @@ -72,15 +73,13 @@ def test_state(backend): lss_states = shadow_snapshots(c.state(), pauli_strings, status) sdw_state = global_shadow_state(lss_states) - R = np.array(sdw_state - bell_state) - error = np.sqrt(np.trace(R.conj().T @ R)) - assert error < 0.1 + np.allclose(sdw_state, bell_state, atol=0.01) # @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) # def test_expc(backend): # import pennylane as qml -# nq, ns = 8, 100000 +# nq, ns = 8, 200000 # # c = tc.Circuit(nq) # for i in range(nq): @@ -100,13 +99,13 @@ def test_state(backend): # ) # # expc = np.median(expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=9)) -# ent = entropy_shadow(snapshots, pauli_strings, range(4), alpha=2) +# ent = entropy_shadow(slice_sub(snapshots, range(4)), slice_sub(pauli_strings, range(4)), alpha=2) # # shadow = qml.ClassicalShadow(np.asarray(snapshots[:, 0]), np.asarray(pauli_strings - 1)) # repeat == 1 # H = qml.PauliX(0) @ qml.PauliX(6) @ qml.PauliY(2)@ qml.PauliY(3) @ qml.PauliZ(5) @ qml.PauliZ(7) # pl_expc = shadow.expval(H, k=9) # pl_ent = shadow.entropy(range(4), alpha=2) # -# print(np.isclose(expc, pl_expc), np.isclose(ent, pl_ent)) -# +# assert np.isclose(expc, pl_expc) +# assert np.isclose(ent, pl_ent) # assert np.abs(expc - exact) < 0.1 From 881fc4a0a2d589e3146d0ef895a2a02d3fab6601 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 3 Aug 2023 12:32:02 +0800 Subject: [PATCH 583/725] add gitattr to auto lr --- .gitattributes | 1 + 1 file changed, 1 insertion(+) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..176a458f --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +* text=auto From a9c4ee0a2d7ba87b19b6c51c7d1621167637fd8a Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Thu, 3 Aug 2023 17:23:01 +0800 Subject: [PATCH 584/725] Update shadows.py and test_shadows.py --- tensorcircuit/shadows.py | 41 +++++++++++++++++++++++++++++++---- tests/test_shadows.py | 47 +++++++++++++++++++++++++++------------- 2 files changed, 69 insertions(+), 19 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index b581e04e..9bae8d13 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -4,7 +4,6 @@ from typing import Any, Union, Optional, Sequence, Tuple, List from string import ascii_letters as ABC import numpy as np -from numpy import ndarray from .cons import backend, dtypestr, rdtypestr from .circuit import Circuit @@ -18,7 +17,7 @@ def shadow_bound( r"""Calculate the shadow bound of the Pauli observables, please refer to the Theorem S1 and Lemma S3 in Huang, H.-Y., R. Kueng, and J. Preskill, 2020, Nat. Phys. 16, 1050. :param observables: shape = (nq,) or (M, nq), where nq is the number of qubits, M is the number of observables - :type: Union[numpy.ndarray, Sequence[int]] + :type: Union[Tensor, Sequence[int]] :param epsilon: error on the estimator :type: float :param delta: rate of failure for the bound to hold @@ -29,7 +28,7 @@ def shadow_bound( :return k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. :rtype: int """ - count = np.sign(np.asarray(observables)) + count = np.sign(backend.numpy(observables)) if len(count.shape) == 1: count = count[None, :] M = count.shape[0] @@ -89,7 +88,7 @@ def shadow_snapshots( def proj_measure(pauli_string: Tensor, st: Tensor) -> Tensor: c_ = Circuit(nq, inputs=psi) for i in range(nq): - c_.r( + c_.r( # type: ignore i, theta=backend.gather1d( backend.gather1d(angles, backend.gather1d(pauli_string, i)), 0 @@ -328,6 +327,40 @@ def entropy_shadow( return backend.log(backend.sum(backend.power(evs, alpha))) / (1 - alpha) +def Renyi_entropy_2(snapshots: Tensor, sub: Optional[Sequence[int]] = None) -> Tensor: + r"""To calculate the second order Renyi entropy of a subsystem from snapshot, please refer to Brydges, T. et al. Science 364, 260–263 (2019). + This function is not jitable. + + :param snapshots: shape = (ns, repeat, nq) + :type: Tensor + :param sub: qubit indices of subsystem + :type: Optional[Sequence[int]] + + :return second order Renyi entropy: shape = () + :rtype: Tensor + """ + if sub is not None: + snapshots = slice_sub(snapshots, sub) + snapshots = backend.cast(snapshots, dtype="int32") + ns, repeat, nq = snapshots.shape + + count = {} + for i, ss in enumerate(snapshots): + for s in ss: + s = tuple(backend.numpy(s)) + if s not in count: + count[s] = np.zeros(ns) + count[s][i] += 1 + + tr = 0.0 + for x in count: + for y in count: + h = np.sum((np.asarray(x) + np.asarray(y)) % 2) + pp_mean = np.mean(count[x] * count[y]) / repeat / repeat + tr += pp_mean * (-2.0) ** (-h) + return -np.log(tr * 2**nq) + + def global_shadow_state1( snapshots: Tensor, pauli_strings: Optional[Tensor] = None, diff --git a/tests/test_shadows.py b/tests/test_shadows.py index 23bec89a..51674541 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -8,6 +8,7 @@ local_snapshot_states, global_shadow_state, entropy_shadow, + Renyi_entropy_2, expection_ps_shadow, global_shadow_state1, global_shadow_state2, @@ -79,33 +80,49 @@ def test_state(backend): # @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) # def test_expc(backend): # import pennylane as qml -# nq, ns = 8, 200000 +# +# nq, ns, repeat = 6, 2000, 1000 +# +# thetas = 2 * np.random.rand(2, nq) - 1 # # c = tc.Circuit(nq) # for i in range(nq): # c.H(i) -# for j in range(nq): -# c.cnot(j, (j + 1) % nq) -# for j in range(nq): -# c.rx(j, theta=0.1 * np.pi) +# for i in range(2): +# for j in range(nq): +# c.cnot(j, (j + 1) % nq) +# for j in range(nq): +# c.rz(j, theta=thetas[i, j] * np.pi) # -# ps = [1, 0, 2, 2, 0, 3, 1, 3] -# exact = c.expectation_ps(ps=ps) +# ps = [1, 0, 0, 0, 0, 3] +# sub = [1, 4] +# psi = c.state() # # pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(ns, nq))) -# status = tc.backend.convert_to_tensor(np.random.rand(ns, 1)) -# snapshots = shadow_snapshots( -# c.state(), pauli_strings, status, measurement_only=True +# status = tc.backend.convert_to_tensor(np.random.rand(ns, repeat)) +# snapshots = shadow_snapshots(psi, pauli_strings, status, measurement_only=True) +# +# exact_expc = c.expectation_ps(ps=ps) +# exact_rdm = tc.quantum.reduced_density_matrix( +# psi, cut=[i for i in range(nq) if i not in sub] # ) +# exact_ent = tc.quantum.renyi_entropy(exact_rdm, k=2) +# print(exact_expc, exact_ent) # # expc = np.median(expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=9)) -# ent = entropy_shadow(slice_sub(snapshots, range(4)), slice_sub(pauli_strings, range(4)), alpha=2) +# ent = entropy_shadow(snapshots, pauli_strings, sub, alpha=2) +# ent2 = Renyi_entropy_2(snapshots, sub) +# print(expc, ent, ent2) # -# shadow = qml.ClassicalShadow(np.asarray(snapshots[:, 0]), np.asarray(pauli_strings - 1)) # repeat == 1 -# H = qml.PauliX(0) @ qml.PauliX(6) @ qml.PauliY(2)@ qml.PauliY(3) @ qml.PauliZ(5) @ qml.PauliZ(7) +# pl_snapshots = np.asarray(snapshots).reshape(ns * repeat, nq) +# pl_ps = np.tile(np.asarray(pauli_strings - 1)[:, None, :], (1, repeat, 1)).reshape( +# ns * repeat, nq +# ) +# shadow = qml.ClassicalShadow(pl_snapshots, pl_ps) +# H = qml.PauliX(0) @ qml.PauliZ(5) # pl_expc = shadow.expval(H, k=9) -# pl_ent = shadow.entropy(range(4), alpha=2) +# pl_ent = shadow.entropy(sub, alpha=2) +# print(pl_expc, pl_ent) # # assert np.isclose(expc, pl_expc) # assert np.isclose(ent, pl_ent) -# assert np.abs(expc - exact) < 0.1 From dd554a6579a2a17f9364a336cab86355b29f3e8c Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Thu, 3 Aug 2023 17:31:19 +0800 Subject: [PATCH 585/725] Update shadows.py and test_shadows.py --- tensorcircuit/shadows.py | 2 +- tests/test_shadows.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 9bae8d13..ecd8d346 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -327,7 +327,7 @@ def entropy_shadow( return backend.log(backend.sum(backend.power(evs, alpha))) / (1 - alpha) -def Renyi_entropy_2(snapshots: Tensor, sub: Optional[Sequence[int]] = None) -> Tensor: +def renyi_entropy_2(snapshots: Tensor, sub: Optional[Sequence[int]] = None) -> Tensor: r"""To calculate the second order Renyi entropy of a subsystem from snapshot, please refer to Brydges, T. et al. Science 364, 260–263 (2019). This function is not jitable. diff --git a/tests/test_shadows.py b/tests/test_shadows.py index 51674541..5df80ffc 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -8,7 +8,7 @@ local_snapshot_states, global_shadow_state, entropy_shadow, - Renyi_entropy_2, + renyi_entropy_2, expection_ps_shadow, global_shadow_state1, global_shadow_state2, @@ -111,7 +111,7 @@ def test_state(backend): # # expc = np.median(expection_ps_shadow(snapshots, pauli_strings, ps=ps, k=9)) # ent = entropy_shadow(snapshots, pauli_strings, sub, alpha=2) -# ent2 = Renyi_entropy_2(snapshots, sub) +# ent2 = renyi_entropy_2(snapshots, sub) # print(expc, ent, ent2) # # pl_snapshots = np.asarray(snapshots).reshape(ns * repeat, nq) From cb2653158f9187c3bdb89ee53337f1ca7cb33b8f Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Thu, 3 Aug 2023 18:29:03 +0800 Subject: [PATCH 586/725] Update shadows.py and test_shadows.py --- tensorcircuit/shadows.py | 23 +++++++++++++--------- tests/test_shadows.py | 41 ++++++++++++++++++++++++++++++++++------ 2 files changed, 49 insertions(+), 15 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index ecd8d346..9efcdfba 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -14,7 +14,8 @@ def shadow_bound( observables: Union[Tensor, Sequence[int]], epsilon: float, delta: float = 0.01 ) -> Tuple[int, int]: - r"""Calculate the shadow bound of the Pauli observables, please refer to the Theorem S1 and Lemma S3 in Huang, H.-Y., R. Kueng, and J. Preskill, 2020, Nat. Phys. 16, 1050. + r"""Calculate the shadow bound of the Pauli observables, please refer to the Theorem S1 and Lemma S3 in + Huang, H.-Y., R. Kueng, and J. Preskill, 2020, Nat. Phys. 16, 1050. :param observables: shape = (nq,) or (M, nq), where nq is the number of qubits, M is the number of observables :type: Union[Tensor, Sequence[int]] @@ -25,10 +26,11 @@ def shadow_bound( :return Nk: number of snapshots :rtype: int - :return k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. + :return k: Number of equal parts to split the shadow snapshot states to compute the median of means. + k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. :rtype: int """ - count = np.sign(backend.numpy(observables)) + count = np.sign(np.asarray(observables)) if len(count.shape) == 1: count = count[None, :] M = count.shape[0] @@ -65,7 +67,8 @@ def shadow_snapshots( ns, nq = pauli_strings.shape if 2**nq != len(psi): raise ValueError( - f"The number of qubits of psi and pauli_strings should be the same, but got {nq} and {int(np.log2(len(psi)))}." + f"The number of qubits of psi and pauli_strings should be the same, " + f"but got {nq} and {int(np.log2(len(psi)))}." ) if status is None: status = backend.convert_to_tensor(np.random.rand(ns, 1)) @@ -225,9 +228,11 @@ def expection_ps_shadow( :type: Optional[Sequence[int]] :param z: sites to apply Z gate, defaults to None :type: Optional[Sequence[int]] - :param ps: or one can apply a ps structures instead of x, y, z, e.g. [1, 1, 0, 2, 3, 0] for X_0X_1Y_3Z_4 defaults to None, ps can overwrite x, y and z + :param ps: or one can apply a ps structures instead of x, y, z, e.g. [1, 1, 0, 2, 3, 0] for X_0X_1Y_3Z_4 + defaults to None, ps can overwrite x, y and z :type: Optional[Sequence[int]] - :param k: Number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. + :param k: Number of equal parts to split the shadow snapshot states to compute the median of means. + k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. :type: int :return expectation values: shape = (k,) @@ -328,8 +333,8 @@ def entropy_shadow( def renyi_entropy_2(snapshots: Tensor, sub: Optional[Sequence[int]] = None) -> Tensor: - r"""To calculate the second order Renyi entropy of a subsystem from snapshot, please refer to Brydges, T. et al. Science 364, 260–263 (2019). - This function is not jitable. + r"""To calculate the second order Renyi entropy of a subsystem from snapshot, please refer to + Brydges, T. et al. Science 364, 260–263 (2019). This function is not jitable. :param snapshots: shape = (ns, repeat, nq) :type: Tensor @@ -438,7 +443,7 @@ def global_shadow_state2( lss_states = slice_sub(snapshots, sub) else: lss_states = snapshots # (ns, repeat, nq, 2, 2) - ns, repeat, nq, _, _ = lss_states.shape + nq = lss_states.shape[2] old_indices = [f"{ABC[2 * i: 2 + 2 * i]}" for i in range(nq)] new_indices = f"{ABC[0:2 * nq:2]}{ABC[1:2 * nq:2]}" diff --git a/tests/test_shadows.py b/tests/test_shadows.py index 5df80ffc..e810f9bd 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -5,14 +5,10 @@ from tensorcircuit.shadows import ( shadow_bound, shadow_snapshots, - local_snapshot_states, global_shadow_state, entropy_shadow, renyi_entropy_2, expection_ps_shadow, - global_shadow_state1, - global_shadow_state2, - slice_sub, ) @@ -54,8 +50,8 @@ def classical_shadow(psi, pauli_strings, status): expc, ent = csjit(psi, pauli_strings, status) expc = np.median(expc) - assert np.abs(expc - exact_expc) < error - assert np.abs(ent - exact_ent) < 5 * error + assert np.isclose(expc, exact_expc, atol=error) + assert np.isclose(ent, exact_ent, atol=5 * error) @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) @@ -77,6 +73,39 @@ def test_state(backend): np.allclose(sdw_state, bell_state, atol=0.01) +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_ent(backend): + nq, ns, repeat = 6, 2000, 1000 + + thetas = 2 * np.random.rand(2, nq) - 1 + + c = tc.Circuit(nq) + for i in range(nq): + c.H(i) + for i in range(2): + for j in range(nq): + c.cnot(j, (j + 1) % nq) + for j in range(nq): + c.rz(j, theta=thetas[i, j] * np.pi) + + sub = [1, 4] + psi = c.state() + + pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(ns, nq))) + status = tc.backend.convert_to_tensor(np.random.rand(ns, repeat)) + snapshots = shadow_snapshots(psi, pauli_strings, status, measurement_only=True) + + exact_rdm = tc.quantum.reduced_density_matrix( + psi, cut=[i for i in range(nq) if i not in sub] + ) + exact_ent = tc.quantum.renyi_entropy(exact_rdm, k=2) + ent = entropy_shadow(snapshots, pauli_strings, sub, alpha=2) + ent2 = renyi_entropy_2(snapshots, sub) + + assert np.isclose(ent, exact_ent, atol=0.1) + assert np.isclose(ent2, exact_ent, atol=0.1) + + # @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) # def test_expc(backend): # import pennylane as qml From fbe5a9e454bcf4bd6854a78c969f1b0ed3f804f3 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Thu, 3 Aug 2023 19:40:35 +0800 Subject: [PATCH 587/725] Update shadows.py and test_shadows.py --- tensorcircuit/shadows.py | 6 +++--- tests/test_shadows.py | 14 +++++++------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 9efcdfba..028e0e94 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -49,7 +49,7 @@ def shadow_snapshots( ) -> Tensor: r"""To generate the shadow snapshots from given pauli string observables on $|\psi\rangle$ - :param psi: shape = (2 ** nq, 2 ** nq), where nq is the number of qubits + :param psi: shape = (2 ** nq,), where nq is the number of qubits :type: Tensor :param pauli_strings: shape = (ns, nq), where ns is the number of pauli strings :type: Tensor @@ -57,10 +57,10 @@ def shadow_snapshots( :type: Optional[Tensor] :param sub: qubit indices of subsystem :type: Optional[Sequence[int]] - :param measurement_only: return snapshots (True) or snapshot states (false), default=False + :param measurement_only: return snapshots (True) or snapshot states (False), default=False :type: bool - :return snapshots: shape = (ns, repeat, nq) + :return snapshots: shape = (ns, repeat, nq) if measurement_only=True otherwise (ns, repeat, nq, 2, 2) :rtype: Tensor """ pauli_strings = backend.cast(pauli_strings, dtype="int32") - 1 diff --git a/tests/test_shadows.py b/tests/test_shadows.py index e810f9bd..c78032b7 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -50,8 +50,8 @@ def classical_shadow(psi, pauli_strings, status): expc, ent = csjit(psi, pauli_strings, status) expc = np.median(expc) - assert np.isclose(expc, exact_expc, atol=error) - assert np.isclose(ent, exact_ent, atol=5 * error) + np.testing.assert_allclose(expc, exact_expc, atol=error) + np.testing.assert_allclose(ent, exact_ent, atol=5 * error) @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) @@ -66,16 +66,16 @@ def test_state(backend): bell_state = psi[:, None] @ psi[None, :] pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(ns, nq))) - status = tc.backend.convert_to_tensor(np.random.rand(ns, 2)) + status = tc.backend.convert_to_tensor(np.random.rand(ns, 5)) lss_states = shadow_snapshots(c.state(), pauli_strings, status) sdw_state = global_shadow_state(lss_states) - np.allclose(sdw_state, bell_state, atol=0.01) + np.testing.assert_allclose(sdw_state, bell_state, atol=0.1) @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_ent(backend): - nq, ns, repeat = 6, 2000, 1000 + nq, ns, repeat = 6, 1000, 500 thetas = 2 * np.random.rand(2, nq) - 1 @@ -102,8 +102,8 @@ def test_ent(backend): ent = entropy_shadow(snapshots, pauli_strings, sub, alpha=2) ent2 = renyi_entropy_2(snapshots, sub) - assert np.isclose(ent, exact_ent, atol=0.1) - assert np.isclose(ent2, exact_ent, atol=0.1) + np.testing.assert_allclose(ent, exact_ent, atol=0.1) + np.testing.assert_allclose(ent2, exact_ent, atol=0.1) # @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) From 89545a1178b62e3398a782cc151e12171349a94d Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 3 Aug 2023 21:57:10 +0800 Subject: [PATCH 588/725] update changelog --- CHANGELOG.md | 2 ++ tensorcircuit/shadows.py | 4 +++- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3d5759a4..6e3a5473 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,8 @@ - Add circuit copy method that avoid shallow copy issue `Circuit.copy()` +- Add end to end infrastructures and methods for classical shadow in `shadows.py` + ### Fixed - improve the `adaptive_vmap` to support internal jit and pytree output diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 028e0e94..d3eb6545 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -1,8 +1,10 @@ """ -Classical Shadows functions +Classical shadows functions """ + from typing import Any, Union, Optional, Sequence, Tuple, List from string import ascii_letters as ABC + import numpy as np from .cons import backend, dtypestr, rdtypestr From a17dac26f51acaf221f2acc786f06de2a10a4cd7 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 4 Aug 2023 22:28:32 +0800 Subject: [PATCH 589/725] update docs --- docs/source/api/applications.rst | 4 ++++ docs/source/api/applications/ai.rst | 4 ++++ docs/source/api/applications/finance.rst | 4 ++++ docs/source/api/applications/finance/portfolio.rst | 7 +++++++ docs/source/api/applications/optimization.rst | 7 +++++++ docs/source/api/applications/physics.rst | 5 +++++ docs/source/api/applications/physics/baseline.rst | 7 +++++++ docs/source/api/applications/physics/fss.rst | 7 +++++++ docs/source/api/shadows.rst | 7 +++++++ docs/source/api/templates.rst | 2 ++ docs/source/api/templates/ansatz.rst | 7 +++++++ docs/source/api/templates/conversions.rst | 7 +++++++ docs/source/modules.rst | 1 + 13 files changed, 69 insertions(+) create mode 100644 docs/source/api/applications/ai.rst create mode 100644 docs/source/api/applications/finance.rst create mode 100644 docs/source/api/applications/finance/portfolio.rst create mode 100644 docs/source/api/applications/optimization.rst create mode 100644 docs/source/api/applications/physics.rst create mode 100644 docs/source/api/applications/physics/baseline.rst create mode 100644 docs/source/api/applications/physics/fss.rst create mode 100644 docs/source/api/shadows.rst create mode 100644 docs/source/api/templates/ansatz.rst create mode 100644 docs/source/api/templates/conversions.rst diff --git a/docs/source/api/applications.rst b/docs/source/api/applications.rst index 2ecae939..85c31126 100644 --- a/docs/source/api/applications.rst +++ b/docs/source/api/applications.rst @@ -1,9 +1,13 @@ tensorcircuit.applications ================================================================================ .. toctree:: + applications/ai.rst applications/dqas.rst + applications/finance.rst applications/graphdata.rst applications/layers.rst + applications/optimization.rst + applications/physics.rst applications/utils.rst applications/vags.rst applications/van.rst diff --git a/docs/source/api/applications/ai.rst b/docs/source/api/applications/ai.rst new file mode 100644 index 00000000..c8749e92 --- /dev/null +++ b/docs/source/api/applications/ai.rst @@ -0,0 +1,4 @@ +tensorcircuit.applications.ai +================================================================================ +.. toctree:: + \ No newline at end of file diff --git a/docs/source/api/applications/finance.rst b/docs/source/api/applications/finance.rst new file mode 100644 index 00000000..d3302b31 --- /dev/null +++ b/docs/source/api/applications/finance.rst @@ -0,0 +1,4 @@ +tensorcircuit.applications.finance +================================================================================ +.. toctree:: + finance/portfolio.rst \ No newline at end of file diff --git a/docs/source/api/applications/finance/portfolio.rst b/docs/source/api/applications/finance/portfolio.rst new file mode 100644 index 00000000..993b5754 --- /dev/null +++ b/docs/source/api/applications/finance/portfolio.rst @@ -0,0 +1,7 @@ +tensorcircuit.applications.finance.portfolio +================================================================================ +.. automodule:: tensorcircuit.applications.finance.portfolio + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/applications/optimization.rst b/docs/source/api/applications/optimization.rst new file mode 100644 index 00000000..87a0ffbb --- /dev/null +++ b/docs/source/api/applications/optimization.rst @@ -0,0 +1,7 @@ +tensorcircuit.applications.optimization +================================================================================ +.. automodule:: tensorcircuit.applications.optimization + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/applications/physics.rst b/docs/source/api/applications/physics.rst new file mode 100644 index 00000000..98d1a2ed --- /dev/null +++ b/docs/source/api/applications/physics.rst @@ -0,0 +1,5 @@ +tensorcircuit.applications.physics +================================================================================ +.. toctree:: + physics/baseline.rst + physics/fss.rst \ No newline at end of file diff --git a/docs/source/api/applications/physics/baseline.rst b/docs/source/api/applications/physics/baseline.rst new file mode 100644 index 00000000..2ac581ba --- /dev/null +++ b/docs/source/api/applications/physics/baseline.rst @@ -0,0 +1,7 @@ +tensorcircuit.applications.physics.baseline +================================================================================ +.. automodule:: tensorcircuit.applications.physics.baseline + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/applications/physics/fss.rst b/docs/source/api/applications/physics/fss.rst new file mode 100644 index 00000000..d65cd6c1 --- /dev/null +++ b/docs/source/api/applications/physics/fss.rst @@ -0,0 +1,7 @@ +tensorcircuit.applications.physics.fss +================================================================================ +.. automodule:: tensorcircuit.applications.physics.fss + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/shadows.rst b/docs/source/api/shadows.rst new file mode 100644 index 00000000..7aea082e --- /dev/null +++ b/docs/source/api/shadows.rst @@ -0,0 +1,7 @@ +tensorcircuit.shadows +================================================================================ +.. automodule:: tensorcircuit.shadows + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/templates.rst b/docs/source/api/templates.rst index 897ff36c..d76ab744 100644 --- a/docs/source/api/templates.rst +++ b/docs/source/api/templates.rst @@ -1,8 +1,10 @@ tensorcircuit.templates ================================================================================ .. toctree:: + templates/ansatz.rst templates/blocks.rst templates/chems.rst + templates/conversions.rst templates/dataset.rst templates/ensemble.rst templates/graphs.rst diff --git a/docs/source/api/templates/ansatz.rst b/docs/source/api/templates/ansatz.rst new file mode 100644 index 00000000..15f19650 --- /dev/null +++ b/docs/source/api/templates/ansatz.rst @@ -0,0 +1,7 @@ +tensorcircuit.templates.ansatz +================================================================================ +.. automodule:: tensorcircuit.templates.ansatz + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/api/templates/conversions.rst b/docs/source/api/templates/conversions.rst new file mode 100644 index 00000000..38cbe47f --- /dev/null +++ b/docs/source/api/templates/conversions.rst @@ -0,0 +1,7 @@ +tensorcircuit.templates.conversions +================================================================================ +.. automodule:: tensorcircuit.templates.conversions + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/modules.rst b/docs/source/modules.rst index 67e7425e..5f08781f 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -21,6 +21,7 @@ tensorcircuit ./api/noisemodel.rst ./api/quantum.rst ./api/results.rst + ./api/shadows.rst ./api/simplify.rst ./api/templates.rst ./api/torchnn.rst From ce7f2f9671d17d9cfab643cab7a095274cf148fe Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Fri, 4 Aug 2023 14:30:13 +0000 Subject: [PATCH 590/725] docs: update README.md [skip ci] --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f48ee893..c8843fb2 100644 --- a/README.md +++ b/README.md @@ -273,7 +273,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. WiuYuan
WiuYuan
💡 Felix Xu
Felix Xu
✅ 💻 ⚠️ Hong-Ye Hu
Hong-Ye Hu
📖 - peilin
peilin
✅ + peilin
peilin
✅ 💻 ⚠️ 📖 From 1e57708504c702f52394cf41e20c1d31f5fc83a8 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Fri, 4 Aug 2023 14:30:14 +0000 Subject: [PATCH 591/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index 2b6aff49..b1735deb 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -267,7 +267,10 @@ "avatar_url": "https://avatars.githubusercontent.com/u/45784888?v=4", "profile": "https://github.com/PeilinZHENG", "contributions": [ - "tutorial" + "tutorial", + "code", + "test", + "doc" ] } ], From 20bccf384e8f3bffb21e6721b39cf9f4abf91124 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 6 Aug 2023 14:04:32 +0800 Subject: [PATCH 592/725] fix pauli gate dtype auto conversion --- tensorcircuit/gates.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index 5c5f7e88..fe71440b 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -389,6 +389,8 @@ def meta_gate() -> None: setattr(thismodule, n + "_gate", temp) setattr(thismodule, n, temp) + setattr(thismodule, "pauli_gates", [i(), x(), y(), z()]) # type: ignore + meta_gate() From afe0fd6b2df555f61b387834c574076f4b5b84b6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sun, 6 Aug 2023 15:32:35 +0800 Subject: [PATCH 593/725] delete replicated tests --- tests/test_templates.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_templates.py b/tests/test_templates.py index fa1941bb..25f22b08 100644 --- a/tests/test_templates.py +++ b/tests/test_templates.py @@ -25,7 +25,7 @@ def test_any_measurement(): np.testing.assert_allclose(r2, 0.0, atol=1e-5) -@pytest.mark.parametrize("backend", [lf("jaxb"), lf("tfb"), lf("jaxb")]) +@pytest.mark.parametrize("backend", [lf("jaxb"), lf("tfb")]) def test_parameterized_local_measurement(backend): c = tc.Circuit(3) c.X(0) From 46a16fa228046139c1f07d3c30ae5eed657e3b23 Mon Sep 17 00:00:00 2001 From: JachyMeow <114171061+JachyMeow@users.noreply.github.com> Date: Mon, 7 Aug 2023 00:47:50 +0800 Subject: [PATCH 594/725] Add files via upload --- docs/source/tutorials/nnvqe.ipynb | 4001 +++++++++++++++++++++++++++++ 1 file changed, 4001 insertions(+) create mode 100644 docs/source/tutorials/nnvqe.ipynb diff --git a/docs/source/tutorials/nnvqe.ipynb b/docs/source/tutorials/nnvqe.ipynb new file mode 100644 index 00000000..3669b34d --- /dev/null +++ b/docs/source/tutorials/nnvqe.ipynb @@ -0,0 +1,4001 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "64ba95d6", + "metadata": {}, + "source": [ + "#
NN-VQE" + ] + }, + { + "cell_type": "markdown", + "id": "b65f64bf", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "In this tutorial, we'll show you a general framework called neural network encoded variational quantum algorithms (NN-VQAs) with TensorCircuit. NN-VQA feeds input (such as parameters of a Hamiltonian) from a given problem to a neural network and uses its outputs to parameterize an ansatz circuit for the standard VQA. Here, we take NN-variational quantum eigensolver (VQE) to illustrate concretely." + ] + }, + { + "cell_type": "markdown", + "id": "831930ae", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4e1651b9", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "import tensorcircuit as tc\n", + "import cotengra\n", + "import quimb\n", + "from tqdm.notebook import tqdm\n", + "from functools import partial\n", + "\n", + "optc = cotengra.ReusableHyperOptimizer(\n", + " methods=[\"greedy\"],\n", + " parallel=\"ray\",\n", + " minimize=\"combo\",\n", + " max_time=30,\n", + " max_repeats=1024,\n", + " progbar=True,\n", + ")\n", + "tc.set_contractor(\"custom\", optimizer=optc, preprocessing=True)\n", + "\n", + "K = tc.set_backend(\"tensorflow\")\n", + "tc.set_dtype(\"complex128\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "d78b480b", + "metadata": {}, + "source": [ + "## Energy\n", + "\n", + "The Hamiltonian used in this tutorial is a 1D XXZ model with periodic boundary conditions, with the transverse field strength $\\lambda$ and the anisotropy parameter $\\Delta$. The Hamiltonian energy expectation function is chosen as loss.\n", + "\n", + "$$ \\hat{H}_{XXZ}=\\sum_{i}{ \\left( X_{i}X_{i+1}+Y_{i}Y_{i+1}+\\Delta Z_{i}Z_{i+1} \\right) } + \\lambda \\sum_{i}{Z_{i}} $$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fff67346", + "metadata": {}, + "outputs": [], + "source": [ + "def energy(c: tc.Circuit, lamb: float = 1.0, delta: float = 1.0):\n", + " e = 0.0\n", + " n = c._nqubits\n", + " for i in range(n):\n", + " e += lamb * c.expectation((tc.gates.z(), [i])) # \n", + " for i in range(n): \n", + " e += c.expectation(\n", + " (tc.gates.x(), [i]), (tc.gates.x(), [(i + 1) % n])\n", + " ) # \n", + " e += c.expectation(\n", + " (tc.gates.y(), [i]), (tc.gates.y(), [(i + 1) % n])\n", + " ) # \n", + " e += delta * c.expectation(\n", + " (tc.gates.z(), [i]), (tc.gates.z(), [(i + 1) % n])\n", + " ) # \n", + " return K.real(e)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0ad6a7a6", + "metadata": {}, + "source": [ + "## Ansatz circuit\n", + "\n", + "Now we design the circuit. We choose multi-scale entangled renormalization ansatz (MERA) as the ansatz here, $d$ is the circuit depth. (see tutorial of MERA [here](https://tensorcircuit.readthedocs.io/en/latest/tutorials/mera.html))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "445b7c86", + "metadata": {}, + "outputs": [], + "source": [ + "def MERA(inp, n, d=1, lamb=1., energy_flag=False): # for single-parameter 1D XXZ model, we fix lamb\n", + " params = K.cast(inp[\"params\"], \"complex128\")\n", + " delta = K.cast(inp[\"delta\"], \"complex128\") \n", + " c = tc.Circuit(n)\n", + " \n", + " idx = 0\n", + "\n", + " for i in range(n):\n", + " c.rx(i, theta=params[3 * i])\n", + " c.rz(i, theta=params[3 * i + 1])\n", + " c.rx(i, theta=params[3 * i + 2])\n", + " idx += 3 * n\n", + " \n", + "\n", + " for n_layer in range(1, int(np.log2(n)) + 1):\n", + " n_qubit = 2**n_layer # number of qubits involving\n", + " step = int(n / n_qubit)\n", + "\n", + " for _ in range(d): # circuit depth\n", + " # even \n", + " for i in range(step, n - step, 2 * step):\n", + " c.rxx(i, i + step, theta=params[idx])\n", + " c.rzz(i, i + step, theta=params[idx + 1])\n", + " idx += 2\n", + " \n", + " # odd \n", + " for i in range(0, n, 2 * step):\n", + " c.rxx(i, i + step, theta=params[idx])\n", + " c.rzz(i, i + step, theta=params[idx + 1])\n", + " idx += 2\n", + "\n", + " # single qubit\n", + " for i in range(0, n, step):\n", + " c.rx(i, theta=params[idx])\n", + " c.rz(i, theta=params[idx + 1])\n", + " idx += 2\n", + " \n", + " if energy_flag:\n", + " return energy(c, lamb, delta) # return Hamiltonian energy expectation\n", + " else:\n", + " return c, idx # return the circuit & number of circuit parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6daa2f64", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number of parameters is 74\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-08-06T16:31:47.918946\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.3, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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" + ], + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# circuit visulization\n", + "n = 8\n", + "d = 1\n", + "cirq, idx = MERA({\"params\": np.zeros(3000), \"delta\": 0.}, n, d, 1.)\n", + "print(\"The number of parameters is\", idx)\n", + "cirq.draw()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "bfe2fbee", + "metadata": {}, + "source": [ + "## NN-VQE\n", + "\n", + "Design the NN-VQE. We use a neural network to transform the Hamiltonian parameters to the optimized parameters in the PQC for VQE." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1ac050a8", + "metadata": {}, + "outputs": [], + "source": [ + "def NN_MERA(n, d, lamb, NN_shape, stddev):\n", + " input = tf.keras.layers.Input(shape=[1]) # input layer\n", + "\n", + " x = tf.keras.layers.Dense(\n", + " units=NN_shape, \n", + " kernel_initializer=tf.keras.initializers.RandomNormal(stddev=stddev),\n", + " activation=\"ReLU\"\n", + " )(input) # hidden layer\n", + "\n", + " x = tf.keras.layers.Dropout(0.05)(x) # dropout layer\n", + "\n", + " _, idx = MERA({\"params\": np.zeros(3000), \"delta\": 0.}, n, d, 1., energy_flag=False)\n", + " params = tf.keras.layers.Dense(\n", + " units=idx, \n", + " kernel_initializer=tf.keras.initializers.RandomNormal(stddev=stddev),\n", + " activation=\"sigmoid\"\n", + " )(x) # output layer\n", + " \n", + " qlayer = tc.KerasLayer(partial(MERA, n=n, d=d, lamb=lamb, energy_flag=True)) # PQC\n", + "\n", + " output = qlayer({\"params\": 6.3 * params, \"delta\": input}) # NN-VQE output\n", + "\n", + " m = tf.keras.Model(inputs=input, outputs=output)\n", + "\n", + " return m" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "e9afb1a5", + "metadata": {}, + "source": [ + "## Train\n", + "\n", + "Now we can train the NN-VQE with TensorFlow." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "873ebd5e", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "def train(n, d, lamb, delta, NN_shape, maxiter=10000, lr=0.005, stddev=1.):\n", + " exp_lr = tf.keras.optimizers.schedules.ExponentialDecay(\n", + " initial_learning_rate=lr, decay_steps=1000, decay_rate=0.7\n", + " )\n", + " opt = tf.keras.optimizers.Adam(exp_lr) # optimizer\n", + "\n", + " m = NN_MERA(n, d, lamb, NN_shape, stddev)\n", + " for i in range(maxiter):\n", + " with tf.GradientTape() as tape:\n", + " e = tf.zeros([1], dtype=tf.float64)\n", + " for de in delta:\n", + " e += m(K.reshape(de, [1])) # sum up energies of all training points\n", + " grads = tape.gradient(e, m.variables)\n", + " opt.apply_gradients(zip(grads, m.variables))\n", + " if i % 500 == 0:\n", + " print(\"epoch\", i, \":\", e)\n", + " \n", + " m.save_weights('NN-VQE.weights.h5') # save the trained model" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e8df3d67", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 0 : tf.Tensor([[117.53523392]], shape=(1, 1), dtype=float64)\n", + "epoch 500 : tf.Tensor([[-361.85937039]], shape=(1, 1), dtype=float64)\n", + "epoch 1000 : tf.Tensor([[-365.35288984]], shape=(1, 1), dtype=float64)\n", + "epoch 1500 : tf.Tensor([[-366.65891358]], shape=(1, 1), dtype=float64)\n", + "epoch 2000 : tf.Tensor([[-366.94258369]], shape=(1, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "n = 8 # number of qubits\n", + "d = 2 # circuit depth\n", + "lamb = 0.75 # fixed\n", + "delta = np.linspace(-3.0, 3.0, 20, dtype=\"complex128\") # training set\n", + "NN_shape = 20 # node number of the hidden layer\n", + "maxiter = 2500 # maximum iteration for the optimization\n", + "lr = 0.009 # learning rate\n", + "stddev = 0.1 # the initial standard deviation of the NN\n", + "\n", + "with tf.device('/cpu:0'):\n", + " train(n, d, lamb, delta, NN_shape=NN_shape, maxiter=maxiter, lr=lr, stddev=stddev)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c5a7cdb0", + "metadata": {}, + "source": [ + "## Test\n", + "\n", + "We use a test set beyond the training set to test the accuracy and generalization capability of NN-VQE." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "f15f4f68", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4a3ceb8bdf90463f88050b771fde6925", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_delta = np.linspace(-4.0, 4.0, 201) # test set\n", + "test_energies = tf.zeros_like(test_delta).numpy()\n", + "m = NN_MERA(n, d, lamb, NN_shape, stddev)\n", + "m.load_weights('DNN-MERA_2[20](-3.0,3.0,20)_drop05.weights.h5')\n", + "for i, de in tqdm(enumerate(test_delta)):\n", + " test_energies[i] = m(K.reshape(de, [1]))" + ] + }, + { + "cell_type": "markdown", + "id": "924027f8", + "metadata": {}, + "source": [ + "## Compare\n", + "\n", + "We compare the results of NN-VQE with the analytical ones to calculate the ground-state relative error. From the figure, we can see that NN-VQE is able to estimate the ground-state energies of parameterized Hamiltonians with high precision without fine-tuning and has a favorable generalization capability." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "c8668a13", + "metadata": {}, + "outputs": [], + "source": [ + "analytical_energies = [] # analytical result\n", + "for i in test_delta:\n", + " h = quimb.tensor.tensor_builder.MPO_ham_XXZ(n, i*4, jxy=4., bz=2.*0.75, S=0.5, cyclic=True) \n", + " h = h.to_dense()\n", + " analytical_energies.append(np.min(quimb.eigvalsh(h)))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "42799e3e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-08-06T23:44:26.082098\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.3, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + " \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", + " \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" + ], + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# relative error\n", + "plt.plot(test_delta, (test_energies - analytical_energies) / np.abs(analytical_energies), '-', color='b')\n", + "plt.xlabel(\"Delta\", fontsize=14)\n", + "plt.ylabel(\"GS Relative Error\", fontsize=14)\n", + "plt.axvspan(-3.0, 3.0, color='darkgrey', alpha=0.5) # training set span\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5f9bda8a", + "metadata": {}, + "source": [ + "To get more detailed information or further study, please refer to [our paper](https://arxiv.org/abs/2308.01068) and [GitHub](https://github.com/JachyMeow/NN-VQA)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.9.12" + }, + "vscode": { + "interpreter": { + "hash": "18d2a9923f839b0d86cf68fd09770e726264cf9d62311eaf57b1fff0ca4bed8e" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From b4f53c881d18df0be1c0ee2c01a73e40e1ef03d6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 7 Aug 2023 15:46:06 +0800 Subject: [PATCH 595/725] fix apply correction bug when non-numpy backend is set --- tensorcircuit/quantum.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 55aea42a..dd9f11ab 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -2034,7 +2034,10 @@ def count_vector2dict(count: Tensor, n: int, key: str = "bin") -> Dict[Any, int] :return: _description_ :rtype: _type_ """ - d = {i: backend.numpy(count[i]).item() for i in range(2**n)} + from .interfaces import which_backend + + b = which_backend(count) + d = {i: b.numpy(count[i]).item() for i in range(2**n)} if key == "int": return d else: From dd8fa81cd8a82ce2c402e957def7d8968f174340 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 7 Aug 2023 21:10:31 +0800 Subject: [PATCH 596/725] fix pauli gates --- tensorcircuit/gates.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index fe71440b..0250f00f 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -13,7 +13,7 @@ import tensornetwork as tn from scipy.stats import unitary_group -from .cons import backend, dtypestr, npdtype +from .cons import backend, dtypestr, npdtype, runtime_backend from .utils import arg_alias thismodule = sys.modules[__name__] @@ -389,7 +389,8 @@ def meta_gate() -> None: setattr(thismodule, n + "_gate", temp) setattr(thismodule, n, temp) - setattr(thismodule, "pauli_gates", [i(), x(), y(), z()]) # type: ignore + with runtime_backend("numpy"): # backward compatinility + setattr(thismodule, "pauli_gates", [i(), x(), y(), z()]) # type: ignore meta_gate() From 3b35a732ef1d1e50de500b81c792edee12c266ee Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 7 Aug 2023 23:09:46 +0800 Subject: [PATCH 597/725] update changelog --- CHANGELOG.md | 5 ++++- tensorcircuit/gates.py | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6e3a5473..9ceeb976 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,9 +20,12 @@ - improve the `adaptive_vmap` to support internal jit and pytree output +- fix `pauli_gates` dtype unchange issue when set new dtype (not recommend to use this property) + +- fix rem `apply_correction` bug when non-numpy backend is set ### Changed -- The static method `BaseCircuit.copy` is renamed as `BaseCircuit.copy_nodes` +- The static method `BaseCircuit.copy` is renamed as `BaseCircuit.copy_nodes` (breaking changes) ## 0.10.0 diff --git a/tensorcircuit/gates.py b/tensorcircuit/gates.py index 0250f00f..412230e2 100644 --- a/tensorcircuit/gates.py +++ b/tensorcircuit/gates.py @@ -389,7 +389,7 @@ def meta_gate() -> None: setattr(thismodule, n + "_gate", temp) setattr(thismodule, n, temp) - with runtime_backend("numpy"): # backward compatinility + with runtime_backend("numpy"): # backward compatibility setattr(thismodule, "pauli_gates", [i(), x(), y(), z()]) # type: ignore From 607fe0ec83390a5ac6a39d2668def99de05ea8c4 Mon Sep 17 00:00:00 2001 From: JachyMeow <114171061+JachyMeow@users.noreply.github.com> Date: Tue, 8 Aug 2023 18:17:15 +0800 Subject: [PATCH 598/725] Add files via upload --- docs/source/tutorials/nnvqe.ipynb | 112 +++++++++++++++++------------- 1 file changed, 63 insertions(+), 49 deletions(-) diff --git a/docs/source/tutorials/nnvqe.ipynb b/docs/source/tutorials/nnvqe.ipynb index 3669b34d..e0c861cc 100644 --- a/docs/source/tutorials/nnvqe.ipynb +++ b/docs/source/tutorials/nnvqe.ipynb @@ -84,7 +84,7 @@ " n = c._nqubits\n", " for i in range(n):\n", " e += lamb * c.expectation((tc.gates.z(), [i])) # \n", - " for i in range(n): \n", + " for i in range(n):\n", " e += c.expectation(\n", " (tc.gates.x(), [i]), (tc.gates.x(), [(i + 1) % n])\n", " ) # \n", @@ -115,11 +115,13 @@ "metadata": {}, "outputs": [], "source": [ - "def MERA(inp, n, d=1, lamb=1., energy_flag=False): # for single-parameter 1D XXZ model, we fix lamb\n", + "def MERA(\n", + " inp, n, d=1, lamb=1.0, energy_flag=False\n", + "): # for single-parameter 1D XXZ model, we fix lamb\n", " params = K.cast(inp[\"params\"], \"complex128\")\n", - " delta = K.cast(inp[\"delta\"], \"complex128\") \n", + " delta = K.cast(inp[\"delta\"], \"complex128\")\n", " c = tc.Circuit(n)\n", - " \n", + "\n", " idx = 0\n", "\n", " for i in range(n):\n", @@ -127,20 +129,19 @@ " c.rz(i, theta=params[3 * i + 1])\n", " c.rx(i, theta=params[3 * i + 2])\n", " idx += 3 * n\n", - " \n", "\n", " for n_layer in range(1, int(np.log2(n)) + 1):\n", - " n_qubit = 2**n_layer # number of qubits involving\n", + " n_qubit = 2**n_layer # number of qubits involving\n", " step = int(n / n_qubit)\n", "\n", - " for _ in range(d): # circuit depth\n", - " # even \n", + " for _ in range(d): # circuit depth\n", + " # even\n", " for i in range(step, n - step, 2 * step):\n", " c.rxx(i, i + step, theta=params[idx])\n", " c.rzz(i, i + step, theta=params[idx + 1])\n", " idx += 2\n", - " \n", - " # odd \n", + "\n", + " # odd\n", " for i in range(0, n, 2 * step):\n", " c.rxx(i, i + step, theta=params[idx])\n", " c.rzz(i, i + step, theta=params[idx + 1])\n", @@ -151,11 +152,11 @@ " c.rx(i, theta=params[idx])\n", " c.rz(i, theta=params[idx + 1])\n", " idx += 2\n", - " \n", + "\n", " if energy_flag:\n", - " return energy(c, lamb, delta) # return Hamiltonian energy expectation\n", + " return energy(c, lamb, delta) # return Hamiltonian energy expectation\n", " else:\n", - " return c, idx # return the circuit & number of circuit parameters" + " return c, idx # return the circuit & number of circuit parameters" ] }, { @@ -2895,7 +2896,7 @@ "# circuit visulization\n", "n = 8\n", "d = 1\n", - "cirq, idx = MERA({\"params\": np.zeros(3000), \"delta\": 0.}, n, d, 1.)\n", + "cirq, idx = MERA({\"params\": np.zeros(3000), \"delta\": 0.0}, n, d, 1.0)\n", "print(\"The number of parameters is\", idx)\n", "cirq.draw()" ] @@ -2919,26 +2920,32 @@ "outputs": [], "source": [ "def NN_MERA(n, d, lamb, NN_shape, stddev):\n", - " input = tf.keras.layers.Input(shape=[1]) # input layer\n", + " input = tf.keras.layers.Input(shape=[1]) # input layer\n", "\n", " x = tf.keras.layers.Dense(\n", - " units=NN_shape, \n", + " units=NN_shape,\n", " kernel_initializer=tf.keras.initializers.RandomNormal(stddev=stddev),\n", - " activation=\"ReLU\"\n", - " )(input) # hidden layer\n", + " activation=\"ReLU\",\n", + " )(\n", + " input\n", + " ) # hidden layer\n", "\n", - " x = tf.keras.layers.Dropout(0.05)(x) # dropout layer\n", + " x = tf.keras.layers.Dropout(0.05)(x) # dropout layer\n", "\n", - " _, idx = MERA({\"params\": np.zeros(3000), \"delta\": 0.}, n, d, 1., energy_flag=False)\n", + " _, idx = MERA(\n", + " {\"params\": np.zeros(3000), \"delta\": 0.0}, n, d, 1.0, energy_flag=False\n", + " )\n", " params = tf.keras.layers.Dense(\n", - " units=idx, \n", - " kernel_initializer=tf.keras.initializers.RandomNormal(stddev=stddev),\n", - " activation=\"sigmoid\"\n", - " )(x) # output layer\n", - " \n", - " qlayer = tc.KerasLayer(partial(MERA, n=n, d=d, lamb=lamb, energy_flag=True)) # PQC\n", + " units=idx,\n", + " kernel_initializer=tf.keras.initializers.RandomNormal(stddev=stddev),\n", + " activation=\"sigmoid\",\n", + " )(\n", + " x\n", + " ) # output layer\n", + "\n", + " qlayer = tc.KerasLayer(partial(MERA, n=n, d=d, lamb=lamb, energy_flag=True)) # PQC\n", "\n", - " output = qlayer({\"params\": 6.3 * params, \"delta\": input}) # NN-VQE output\n", + " output = qlayer({\"params\": 6.3 * params, \"delta\": input}) # NN-VQE output\n", "\n", " m = tf.keras.Model(inputs=input, outputs=output)\n", "\n", @@ -2965,24 +2972,24 @@ }, "outputs": [], "source": [ - "def train(n, d, lamb, delta, NN_shape, maxiter=10000, lr=0.005, stddev=1.):\n", + "def train(n, d, lamb, delta, NN_shape, maxiter=10000, lr=0.005, stddev=1.0):\n", " exp_lr = tf.keras.optimizers.schedules.ExponentialDecay(\n", - " initial_learning_rate=lr, decay_steps=1000, decay_rate=0.7\n", - " )\n", - " opt = tf.keras.optimizers.Adam(exp_lr) # optimizer\n", + " initial_learning_rate=lr, decay_steps=1000, decay_rate=0.7\n", + " )\n", + " opt = tf.keras.optimizers.Adam(exp_lr) # optimizer\n", "\n", " m = NN_MERA(n, d, lamb, NN_shape, stddev)\n", " for i in range(maxiter):\n", " with tf.GradientTape() as tape:\n", " e = tf.zeros([1], dtype=tf.float64)\n", " for de in delta:\n", - " e += m(K.reshape(de, [1])) # sum up energies of all training points\n", + " e += m(K.reshape(de, [1])) # sum up energies of all training points\n", " grads = tape.gradient(e, m.variables)\n", " opt.apply_gradients(zip(grads, m.variables))\n", " if i % 500 == 0:\n", " print(\"epoch\", i, \":\", e)\n", - " \n", - " m.save_weights('NN-VQE.weights.h5') # save the trained model" + "\n", + " m.save_weights(\"NN-VQE.weights.h5\") # save the trained model" ] }, { @@ -3006,16 +3013,16 @@ } ], "source": [ - "n = 8 # number of qubits\n", - "d = 2 # circuit depth\n", - "lamb = 0.75 # fixed\n", - "delta = np.linspace(-3.0, 3.0, 20, dtype=\"complex128\") # training set\n", - "NN_shape = 20 # node number of the hidden layer\n", - "maxiter = 2500 # maximum iteration for the optimization\n", - "lr = 0.009 # learning rate\n", - "stddev = 0.1 # the initial standard deviation of the NN\n", + "n = 8 # number of qubits\n", + "d = 2 # circuit depth\n", + "lamb = 0.75 # fixed\n", + "delta = np.linspace(-3.0, 3.0, 20, dtype=\"complex128\") # training set\n", + "NN_shape = 20 # node number of the hidden layer\n", + "maxiter = 2500 # maximum iteration for the optimization\n", + "lr = 0.009 # learning rate\n", + "stddev = 0.1 # the initial standard deviation of the NN\n", "\n", - "with tf.device('/cpu:0'):\n", + "with tf.device(\"/cpu:0\"):\n", " train(n, d, lamb, delta, NN_shape=NN_shape, maxiter=maxiter, lr=lr, stddev=stddev)" ] }, @@ -3052,10 +3059,10 @@ } ], "source": [ - "test_delta = np.linspace(-4.0, 4.0, 201) # test set\n", + "test_delta = np.linspace(-4.0, 4.0, 201) # test set\n", "test_energies = tf.zeros_like(test_delta).numpy()\n", "m = NN_MERA(n, d, lamb, NN_shape, stddev)\n", - "m.load_weights('DNN-MERA_2[20](-3.0,3.0,20)_drop05.weights.h5')\n", + "m.load_weights(\"DNN-MERA_2[20](-3.0,3.0,20)_drop05.weights.h5\")\n", "for i, de in tqdm(enumerate(test_delta)):\n", " test_energies[i] = m(K.reshape(de, [1]))" ] @@ -3077,9 +3084,11 @@ "metadata": {}, "outputs": [], "source": [ - "analytical_energies = [] # analytical result\n", + "analytical_energies = [] # analytical result\n", "for i in test_delta:\n", - " h = quimb.tensor.tensor_builder.MPO_ham_XXZ(n, i*4, jxy=4., bz=2.*0.75, S=0.5, cyclic=True) \n", + " h = quimb.tensor.tensor_builder.MPO_ham_XXZ(\n", + " n, i * 4, jxy=4.0, bz=2.0 * 0.75, S=0.5, cyclic=True\n", + " )\n", " h = h.to_dense()\n", " analytical_energies.append(np.min(quimb.eigvalsh(h)))" ] @@ -3956,10 +3965,15 @@ ], "source": [ "# relative error\n", - "plt.plot(test_delta, (test_energies - analytical_energies) / np.abs(analytical_energies), '-', color='b')\n", + "plt.plot(\n", + " test_delta,\n", + " (test_energies - analytical_energies) / np.abs(analytical_energies),\n", + " \"-\",\n", + " color=\"b\",\n", + ")\n", "plt.xlabel(\"Delta\", fontsize=14)\n", "plt.ylabel(\"GS Relative Error\", fontsize=14)\n", - "plt.axvspan(-3.0, 3.0, color='darkgrey', alpha=0.5) # training set span\n", + "plt.axvspan(-3.0, 3.0, color=\"darkgrey\", alpha=0.5) # training set span\n", "plt.show()" ] }, From b9514bfca456493847c839dbb62f935a29af61b4 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 8 Aug 2023 20:23:00 +0800 Subject: [PATCH 599/725] Add the tutorial classical_shadows.ipynb, fix the typo in api name: "expection_ps_shadows" -> "expectation_ps_shadows". --- docs/source/tutorial.rst | 1 + docs/source/tutorials/classical_shadows.ipynb | 757 ++++++++++++++++++ tensorcircuit/shadows.py | 6 +- tests/test_shadows.py | 7 +- 4 files changed, 765 insertions(+), 6 deletions(-) create mode 100644 docs/source/tutorials/classical_shadows.ipynb diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index 37fd287a..0fbf075d 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -25,5 +25,6 @@ Jupyter Tutorials tutorials/barren_plateaus.ipynb tutorials/qaoa_portfolio_optimization.ipynb tutorials/imag_time_evo.ipynb + tutorials/classical_shadows.ipynb tutorials/sklearn_svc.ipynb tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb new file mode 100644 index 00000000..ab1d6fc3 --- /dev/null +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -0,0 +1,757 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Classical Shadows in Pauli Basis" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Overview" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "[Classical shadows](https://www.nature.com/articles/s41567-020-0932-7) formalism is an efficient method to estimate multiple observables. In this tutorial, we will show how to use the `shadows` module in `TensorCircuit` to implement classic shadows in Pauli basis." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's first briefly review the classic shadows in Pauli basis. For an $n$-qubit quantum state $\\rho$, we randomly perform Pauli projection measurement on each qubit and obtain a snapshot like $\\{1,-1,-1,1\\cdots1,-1\\}$. This process is equivalent to apply a random unitary $U$ to $\\rho$ and measure in computational basis to obtain $|b\\rangle=|s_1\\cdots s_n\\rangle,\\ s_j\\in\\{0,1\\}$:\n", + "$$\n", + "\\begin{equation}\n", + " \\rho\\rightarrow U\\rho U^{\\dagger}\\xrightarrow{measure}|b\\rangle\\langle b|,\n", + "\\end{equation}\n", + "$$\n", + "where $U=\\bigotimes_{j=1}^{n}u_j$, $u_i\\in\\{H, HS^{\\dagger}, \\mathbb{I}\\}$ correspond to the projection measurements of Pauli $X$, $Y$, $Z$ respectively. Then we reverse the operation to get the equivalent measurement result on $\\rho$:\n", + "$$\n", + "\\begin{equation}\n", + " \\rho\\xrightarrow{measure}U^{\\dagger}|b\\rangle\\langle b| U.\n", + "\\end{equation}\n", + "$$\n", + "Moreover, we perform $N$ random measurements and view their average as a quantum channel:\n", + "$$\n", + "\\begin{equation}\n", + " \\mathbb{E}\\left[U^{\\dagger}|b\\rangle\\langle b|U\\right]=\\mathcal{M}(\\rho),\n", + "\\end{equation}\n", + "$$\n", + "we can invert the channel to get the approximation of $\\rho$:\n", + "$$\n", + "\\begin{equation}\n", + " \\rho=\\mathbb{E}\\left[\\mathcal{M}^{-1}(U^{\\dagger}|b\\rangle\\langle b|U)\\right].\n", + "\\end{equation}\n", + "$$\n", + "We call each $\\rho_i=\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)$ a shadow snapshot state and their ensemble $S(\\rho;N)=\\{\\rho_i|i=1\\cdots N\\}$ classical shadows." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "In Pauli basis, we have a simple expression of $\\mathcal{M}^{-1}$:\n", + "$$\n", + "\\begin{eqnarray}\n", + " \\rho_i&=&\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)=\\bigotimes_{j=1}^{n}3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I},\\\\\n", + " \\rho&=&\\frac{1}{N}\\sum_{i=1}^{N}\\rho_i\\ .\n", + "\\end{eqnarray}\n", + "$$\n", + "For an observable Pauli string $O=\\bigotimes_{j=1}^{n}P_j,\\ P_j\\in\\{\\mathbb{I}, X, Y, Z\\}$, we can directly use $\\rho$ to calculate $\\langle O\\rangle=\\text{Tr}(O\\rho)$. In practice, we will divide the classical shadows into $K$ parts to calculate the expectation value independently and take the median to avoid the influence of outliers:\n", + "$$\n", + "\\begin{equation}\n", + " \\langle O\\rangle=\\text{median}\\{\\langle O_{(1)}\\rangle\\cdots\\langle O_{(K)}\\rangle\\},\n", + "\\end{equation}\n", + "$$\n", + "where\n", + "$$\n", + "\\begin{equation}\n", + " \\begin{split}\n", + " \\langle O_{(k)}\\rangle&=\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\text{Tr}\\left[\\bigotimes_{j=1}^{n}P_j(3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I})\\right]\\\\\n", + " &=\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\prod_{j=1}^n\\text{Tr}\\left[3P_j u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}\\right].\n", + " \\end{split}\n", + "\\end{equation}\n", + "$$" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2023-08-08T12:07:59.787548200Z", + "start_time": "2023-08-08T12:07:59.689077500Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": "('complex128', 'float64')" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import tensorcircuit as tc\n", + "from tensorcircuit import shadows\n", + "import numpy as np\n", + "from functools import partial\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "\n", + "BK = tc.set_backend(\"jax\")\n", + "tc.set_dtype(\"complex128\")" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Construct the Classical Shadow Snapshots" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We first set the number of qubits $n$ and the number of repeated measurements $r$ on each Pauli string. Then from the target observable Pauli strings $\\{O_i|i=1,\\cdots,M\\}$ (0, 1, 2, and 3 correspond to $\\mathbb{I}$, $X$, $Y$, and $Z$, respectively), the error $\\epsilon$ and the rate of failure $\\delta$, we can use `shadow_bound` function to get the total number of snapshots $N$ and the number of equal parts $K$ to split the shadow snapshot states to compute the median of means:\n", + "$$\n", + "\\begin{eqnarray}\n", + " K&=&2\\log(2M/\\delta),\\\\\n", + " N&=&K\\frac{34}{\\epsilon^2}\\max_{1\\le i\\le M}\\left\\|O_i-\\frac{\\text{Tr}(O_i)}{2^n}\\mathbb{I}\\right\\|^2_{\\text{shadow}}=K\\frac{34}{\\epsilon^2}3^{\\max_{1\\le i\\le M}k_i},\n", + "\\end{eqnarray}\n", + "$$\n", + "where $k_i$ is the number of nontrivial Pauli matrices in $O_i$. Please refer to the Theorem S1 and Lemma S3 in [Huang, Kueng and Preskill (2020)](https://www.nature.com/articles/s41567-020-0932-7) for the details of proof. It should be noted that `shadow_bound` has a certain degree of overestimation of $N$, and so many measurements are not really needed in practice. And `shadow_bound` is not jitable and no need to jit." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N: 489600\tK: 16\tnumber of Pauli strings: 97920\n" + ] + } + ], + "source": [ + "n, r = 8, 5\n", + "ps = [\n", + " [1, 0, 0, 0, 0, 0, 0, 2],\n", + " [0, 3, 0, 0, 0, 0, 1, 0],\n", + " [0, 0, 2, 0, 0, 3, 0, 0],\n", + " [0, 0, 0, 1, 2, 0, 0, 0],\n", + " [0, 0, 0, 3, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 3, 0, 0],\n", + " [0, 0, 0, 0, 0, 0, 2, 0],\n", + " [3, 0, 0, 0, 0, 0, 0, 1],\n", + " [0, 2, 0, 0, 0, 0, 3, 0],\n", + " [0, 0, 1, 0, 0, 2, 0, 0],\n", + "]\n", + "\n", + "epsilon, delta = 0.1, 0.01\n", + "N, K = shadows.shadow_bound(ps, epsilon, delta)\n", + "nps = N // r # number of random pauli strings\n", + "print(f\"N: {N}\\tK: {K}\\tnumber of Pauli strings: {nps}\")" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:07:59.787548200Z", + "start_time": "2023-08-08T12:07:59.701762Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Then we use random quantum circuit to generate an entangled state." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [], + "source": [ + "nlayers = 10\n", + "thetas = 2 * np.random.rand(nlayers, n) - 1\n", + "\n", + "c = tc.Circuit(n)\n", + "for i in range(n):\n", + " c.H(i)\n", + "for i in range(nlayers):\n", + " for j in range(n):\n", + " c.cnot(j, (j + 1) % n)\n", + " for j in range(n):\n", + " c.rz(j, theta=thetas[i, j] * np.pi)\n", + "\n", + "psi = c.state()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:07:59.893829700Z", + "start_time": "2023-08-08T12:07:59.708422100Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We randomly generate Pauli strings. Since the function after just-in-time compilation does not support random sampling, we need to generate all random states in advance, that is, variable `status`." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [], + "source": [ + "pauli_strings = BK.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", + "status = BK.convert_to_tensor(np.random.rand(nps, r))" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:07:59.919435300Z", + "start_time": "2023-08-08T12:07:59.908781200Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "If `measurement_only`=True, the outputs of `shadow_snapshots` are snapshot bit strings $b=s_1\\cdots s_n,\\ s_j\\in\\{0,1\\}$, otherwise the outputs are snapshot states $\\{u_{j}^{\\dagger}|s_j\\rangle\\langle s_j| u_j\\ |j=1,\\cdots,n\\}$. If you only need to generate one batch of snapshots or generate multiple batches of snapshots with different `nps` or `r`, jit cannot provide speedup. JIT will only accelerate when the same shape of snapshots are generated multiple times." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(97920, 5, 8, 2, 2)\n" + ] + } + ], + "source": [ + "@partial(BK.jit, static_argnums=(3,))\n", + "def shadow_ss(psi, pauli_strings, status, measurement_only=False):\n", + " return shadows.shadow_snapshots(\n", + " psi, pauli_strings, status, measurement_only=measurement_only\n", + " )\n", + "\n", + "\n", + "ss_states = shadow_ss(psi, pauli_strings, status) # jit is not necessary here\n", + "print(ss_states.shape)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:08:03.113557900Z", + "start_time": "2023-08-08T12:08:00.167642400Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Estimate the Expectation Values of Observables" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Since the operation of taking the median is not jitable, the outputs of `expectation_ps_shadows` have $K$ values, and we need to take the median of them." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 13, + "outputs": [], + "source": [ + "def shadow_expec(snapshots_states, ob):\n", + " return shadows.expectation_ps_shadow(snapshots_states, ps=ob, k=K)\n", + "\n", + "\n", + "sejit = BK.jit(shadow_expec)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:08:03.189105100Z", + "start_time": "2023-08-08T12:08:03.113557900Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "It can be seen from the running time that every time the number of Pauli strings changes, `shadow_expec` will be recompiled, but for the same number of Pauli strings but different observables, `shadow_expec` will only be compiled once. In the end, the absolute errors given by classical shadows are much smaller than the $\\epsilon=0.1$ we set, so shadow_bound gives a very loose upper bound." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 14, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "observalbe: No.0\tnumber of Pauli strings: 1000\ttime: 0.9208428859710693\n", + "observalbe: No.1\tnumber of Pauli strings: 1000\ttime: 0.001764535903930664\n", + "observalbe: No.2\tnumber of Pauli strings: 1000\ttime: 0.0013713836669921875\n", + "observalbe: No.3\tnumber of Pauli strings: 1000\ttime: 0.0013463497161865234\n", + "observalbe: No.4\tnumber of Pauli strings: 1000\ttime: 0.0014214515686035156\n", + "observalbe: No.5\tnumber of Pauli strings: 1000\ttime: 0.0013613700866699219\n", + "observalbe: No.6\tnumber of Pauli strings: 1000\ttime: 0.001367330551147461\n", + "observalbe: No.7\tnumber of Pauli strings: 1000\ttime: 0.001378774642944336\n", + "observalbe: No.8\tnumber of Pauli strings: 1000\ttime: 0.0013740062713623047\n", + "observalbe: No.9\tnumber of Pauli strings: 1000\ttime: 0.001354217529296875\n", + "observalbe: No.0\tnumber of Pauli strings: 11000\ttime: 0.9906811714172363\n", + "observalbe: No.1\tnumber of Pauli strings: 11000\ttime: 0.012621402740478516\n", + "observalbe: No.2\tnumber of Pauli strings: 11000\ttime: 0.012280464172363281\n", + "observalbe: No.3\tnumber of Pauli strings: 11000\ttime: 0.012493133544921875\n", + "observalbe: No.4\tnumber of Pauli strings: 11000\ttime: 0.012433767318725586\n", + "observalbe: No.5\tnumber of Pauli strings: 11000\ttime: 0.012764692306518555\n", + "observalbe: No.6\tnumber of Pauli strings: 11000\ttime: 0.012403726577758789\n", + "observalbe: No.7\tnumber of Pauli strings: 11000\ttime: 0.012158393859863281\n", + "observalbe: No.8\tnumber of Pauli strings: 11000\ttime: 0.012058734893798828\n", + "observalbe: No.9\tnumber of Pauli strings: 11000\ttime: 0.012238740921020508\n", + "observalbe: No.0\tnumber of Pauli strings: 21000\ttime: 1.0218532085418701\n", + "observalbe: No.1\tnumber of Pauli strings: 21000\ttime: 0.024202823638916016\n", + "observalbe: No.2\tnumber of Pauli strings: 21000\ttime: 0.023923397064208984\n", + "observalbe: No.3\tnumber of Pauli strings: 21000\ttime: 0.023802757263183594\n", + "observalbe: No.4\tnumber of Pauli strings: 21000\ttime: 0.02439141273498535\n", + "observalbe: No.5\tnumber of Pauli strings: 21000\ttime: 0.024312973022460938\n", + "observalbe: No.6\tnumber of Pauli strings: 21000\ttime: 0.02409648895263672\n", + "observalbe: No.7\tnumber of Pauli strings: 21000\ttime: 0.0239260196685791\n", + "observalbe: No.8\tnumber of Pauli strings: 21000\ttime: 0.024311542510986328\n", + "observalbe: No.9\tnumber of Pauli strings: 21000\ttime: 0.023871660232543945\n", + "observalbe: No.0\tnumber of Pauli strings: 31000\ttime: 0.9866394996643066\n", + "observalbe: No.1\tnumber of Pauli strings: 31000\ttime: 0.03965640068054199\n", + "observalbe: No.2\tnumber of Pauli strings: 31000\ttime: 0.040810585021972656\n", + "observalbe: No.3\tnumber of Pauli strings: 31000\ttime: 0.040923118591308594\n", + "observalbe: No.4\tnumber of Pauli strings: 31000\ttime: 0.03870081901550293\n", + "observalbe: No.5\tnumber of Pauli strings: 31000\ttime: 0.03658175468444824\n", + "observalbe: No.6\tnumber of Pauli strings: 31000\ttime: 0.033846139907836914\n", + "observalbe: No.7\tnumber of Pauli strings: 31000\ttime: 0.03284430503845215\n", + "observalbe: No.8\tnumber of Pauli strings: 31000\ttime: 0.03468632698059082\n", + "observalbe: No.9\tnumber of Pauli strings: 31000\ttime: 0.034407615661621094\n", + "observalbe: No.0\tnumber of Pauli strings: 41000\ttime: 1.014129400253296\n", + "observalbe: No.1\tnumber of Pauli strings: 41000\ttime: 0.053369998931884766\n", + "observalbe: No.2\tnumber of Pauli strings: 41000\ttime: 0.05180001258850098\n", + "observalbe: No.3\tnumber of Pauli strings: 41000\ttime: 0.05307412147521973\n", + "observalbe: No.4\tnumber of Pauli strings: 41000\ttime: 0.05329442024230957\n", + "observalbe: No.5\tnumber of Pauli strings: 41000\ttime: 0.05172109603881836\n", + "observalbe: No.6\tnumber of Pauli strings: 41000\ttime: 0.052023887634277344\n", + "observalbe: No.7\tnumber of Pauli strings: 41000\ttime: 0.05315876007080078\n", + "observalbe: No.8\tnumber of Pauli strings: 41000\ttime: 0.05295825004577637\n", + "observalbe: No.9\tnumber of Pauli strings: 41000\ttime: 0.05689072608947754\n", + "observalbe: No.0\tnumber of Pauli strings: 51000\ttime: 0.997788667678833\n", + "observalbe: No.1\tnumber of Pauli strings: 51000\ttime: 0.06549453735351562\n", + "observalbe: No.2\tnumber of Pauli strings: 51000\ttime: 0.06295180320739746\n", + "observalbe: No.3\tnumber of Pauli strings: 51000\ttime: 0.06317925453186035\n", + "observalbe: No.4\tnumber of Pauli strings: 51000\ttime: 0.06182670593261719\n", + "observalbe: No.5\tnumber of Pauli strings: 51000\ttime: 0.06398820877075195\n", + "observalbe: No.6\tnumber of Pauli strings: 51000\ttime: 0.06252193450927734\n", + "observalbe: No.7\tnumber of Pauli strings: 51000\ttime: 0.057137250900268555\n", + "observalbe: No.8\tnumber of Pauli strings: 51000\ttime: 0.06129312515258789\n", + "observalbe: No.9\tnumber of Pauli strings: 51000\ttime: 0.06306266784667969\n", + "observalbe: No.0\tnumber of Pauli strings: 61000\ttime: 1.0299479961395264\n", + "observalbe: No.1\tnumber of Pauli strings: 61000\ttime: 0.06776976585388184\n", + "observalbe: No.2\tnumber of Pauli strings: 61000\ttime: 0.06797552108764648\n", + "observalbe: No.3\tnumber of Pauli strings: 61000\ttime: 0.06658697128295898\n", + "observalbe: No.4\tnumber of Pauli strings: 61000\ttime: 0.06751775741577148\n", + "observalbe: No.5\tnumber of Pauli strings: 61000\ttime: 0.06934762001037598\n", + "observalbe: No.6\tnumber of Pauli strings: 61000\ttime: 0.06731104850769043\n", + "observalbe: No.7\tnumber of Pauli strings: 61000\ttime: 0.06712603569030762\n", + "observalbe: No.8\tnumber of Pauli strings: 61000\ttime: 0.07176804542541504\n", + "observalbe: No.9\tnumber of Pauli strings: 61000\ttime: 0.06982183456420898\n", + "observalbe: No.0\tnumber of Pauli strings: 71000\ttime: 1.0498173236846924\n", + "observalbe: No.1\tnumber of Pauli strings: 71000\ttime: 0.07942628860473633\n", + "observalbe: No.2\tnumber of Pauli strings: 71000\ttime: 0.07740139961242676\n", + "observalbe: No.3\tnumber of Pauli strings: 71000\ttime: 0.07828497886657715\n", + "observalbe: No.4\tnumber of Pauli strings: 71000\ttime: 0.07857322692871094\n", + "observalbe: No.5\tnumber of Pauli strings: 71000\ttime: 0.07705187797546387\n", + "observalbe: No.6\tnumber of Pauli strings: 71000\ttime: 0.0785682201385498\n", + "observalbe: No.7\tnumber of Pauli strings: 71000\ttime: 0.07775306701660156\n", + "observalbe: No.8\tnumber of Pauli strings: 71000\ttime: 0.07622480392456055\n", + "observalbe: No.9\tnumber of Pauli strings: 71000\ttime: 0.07927823066711426\n", + "observalbe: No.0\tnumber of Pauli strings: 81000\ttime: 1.05106520652771\n", + "observalbe: No.1\tnumber of Pauli strings: 81000\ttime: 0.08436226844787598\n", + "observalbe: No.2\tnumber of Pauli strings: 81000\ttime: 0.08675956726074219\n", + "observalbe: No.3\tnumber of Pauli strings: 81000\ttime: 0.08600664138793945\n", + "observalbe: No.4\tnumber of Pauli strings: 81000\ttime: 0.08568215370178223\n", + "observalbe: No.5\tnumber of Pauli strings: 81000\ttime: 0.0852055549621582\n", + "observalbe: No.6\tnumber of Pauli strings: 81000\ttime: 0.08647036552429199\n", + "observalbe: No.7\tnumber of Pauli strings: 81000\ttime: 0.08586692810058594\n", + "observalbe: No.8\tnumber of Pauli strings: 81000\ttime: 0.0845186710357666\n", + "observalbe: No.9\tnumber of Pauli strings: 81000\ttime: 0.08591985702514648\n", + "observalbe: No.0\tnumber of Pauli strings: 91000\ttime: 1.0378658771514893\n", + "observalbe: No.1\tnumber of Pauli strings: 91000\ttime: 0.09274506568908691\n", + "observalbe: No.2\tnumber of Pauli strings: 91000\ttime: 0.09148311614990234\n", + "observalbe: No.3\tnumber of Pauli strings: 91000\ttime: 0.09451770782470703\n", + "observalbe: No.4\tnumber of Pauli strings: 91000\ttime: 0.09089279174804688\n", + "observalbe: No.5\tnumber of Pauli strings: 91000\ttime: 0.09438014030456543\n", + "observalbe: No.6\tnumber of Pauli strings: 91000\ttime: 0.09279298782348633\n", + "observalbe: No.7\tnumber of Pauli strings: 91000\ttime: 0.09514856338500977\n", + "observalbe: No.8\tnumber of Pauli strings: 91000\ttime: 0.09679627418518066\n", + "observalbe: No.9\tnumber of Pauli strings: 91000\ttime: 0.09592223167419434\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bz = 1000\n", + "\n", + "exact, res = [], []\n", + "exact_expec = c.expectation_ps(ps=ps[0])\n", + "for ob in ps:\n", + " exact.append(BK.real(c.expectation_ps(ps=ob)))\n", + "exact = np.asarray(exact)[:, None]\n", + "\n", + "bzs, res = [], []\n", + "for i in range(0, nps, bz):\n", + " res.append([])\n", + " ss_states_batch = ss_states[: i + bz]\n", + " bzs.append(ss_states_batch.shape[0])\n", + " t0 = time.time()\n", + " for j, ob in enumerate(ps):\n", + " expcs = sejit(ss_states_batch, ob)\n", + " res[-1].append(np.median(expcs))\n", + " t = time.time()\n", + " if i % (bz * 10) == 0:\n", + " print(\n", + " f\"observalbe: No.{j}\\tnumber of Pauli strings: {bzs[-1]}\\ttime: {t - t0}\"\n", + " )\n", + " t0 = t\n", + "res = np.asarray(res).T\n", + "bzs = np.asarray(bzs) * r\n", + "\n", + "error = np.abs(res - exact)\n", + "plt.figure()\n", + "plt.xlabel(\"N\")\n", + "plt.ylabel(\"Error\")\n", + "for i, y in enumerate(error):\n", + " plt.plot(bzs, y, label=f\"No.{i}\")\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:10:35.293046600Z", + "start_time": "2023-08-08T12:08:03.154791700Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Estimate the Entanglement Entropy" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We can also use classical shadows to calculate entanglement entropy. `entropy_shadow` first reconstructs the reduced density matrix, then solves the eigenvalues and finally calculates the entanglement entropy from non-negative eigenvalues. Since the time and space complexity of reconstructing the density matrix is exponential with respect to the system size, this method is only efficient when the reduced system size is constant. `entropy_shadow` is jitable, but since we only calculate the entanglement entropy once here, it is not wrapped." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 15, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exact: 1.326616283813521\n", + "shadow entropy: 1.328468470127564\n" + ] + } + ], + "source": [ + "sub = [1, 4]\n", + "\n", + "exact_rdm = tc.quantum.reduced_density_matrix(\n", + " psi, cut=[i for i in range(n) if i not in sub]\n", + ")\n", + "exact_ent = tc.quantum.renyi_entropy(exact_rdm, k=2)\n", + "\n", + "ent = shadows.entropy_shadow(ss_states, sub=sub, alpha=2)\n", + "\n", + "print(\"exact:\", exact_ent)\n", + "print(\"shadow entropy:\", ent)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:10:35.850421Z", + "start_time": "2023-08-08T12:10:35.292528800Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "On the other hand, for the second order Renyi entropy, we have another method to calculate it in polynomial time by random measurement:\n", + "$$\n", + "\\begin{eqnarray}\n", + " S_2&=&-\\log\\left(\\text{Tr}(\\rho_A^2)\\right),\\\\\n", + " \\text{Tr}(\\rho_A^2)&=&2^k\\sum_{b,b'\\in\\{0,1\\}^k}(-2)^{-H(b,b')}\\overline{P(b)P(b')},\n", + "\\end{eqnarray}\n", + "$$\n", + "where $A$ is the $k$-d reduced system, $H(b,b')$ is the Hamming distance between $b$ and $b'$, $P(b)$ is the probability for measuring $\\rho_A$ and obtaining the outcomes $b$ thus we need a larger $r$ to obtain a good enough priori probability, and the overline means the average on all random selected Pauli strings. Please refer to [Brydges, et al. (2019)](https://www.science.org/doi/full/10.1126/science.aau4963) for more details. We can use `renyi_entropy_2` to implement this method, but it is not jitable because we need to build the dictionary based on the bit strings obtained by measurement. Compared with `entropy_shadow`, it cannot filter out non-negative eigenvalues, so the accuracy is slightly worse." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 16, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shadow entropy 2: 1.3039560994783876\n" + ] + } + ], + "source": [ + "nps, r = 1000, 500\n", + "\n", + "pauli_strings = BK.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", + "status = BK.convert_to_tensor(np.random.rand(nps, r))\n", + "\n", + "snapshots = shadows.shadow_snapshots(psi, pauli_strings, status, measurement_only=True)\n", + "ent2 = shadows.renyi_entropy_2(snapshots, sub)\n", + "\n", + "print(\"shadow entropy 2:\", ent2)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:10:41.738126600Z", + "start_time": "2023-08-08T12:10:35.851060800Z" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Reconstruct the Density Matrix" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We can `global_shadow_state`, `global_shadow_state1` or `global_shadow_state2` to reconstruct the density matrix. These three functions use different methods, but the results are exactly the same and all of them are jitable. In specific, `global_shadow_state` uses `kron` and is recommended, the other two use `einsum`." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 17, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exact:\n", + " [[0.5+0.j 0. +0.j 0. +0.j 0.5+0.j]\n", + " [0. +0.j 0. +0.j 0. +0.j 0. +0.j]\n", + " [0. +0.j 0. +0.j 0. +0.j 0. +0.j]\n", + " [0.5+0.j 0. +0.j 0. +0.j 0.5+0.j]]\n", + "\n", + "shadow state:\n", + " [[ 0.49579 +0.j 0.003945-0.003675j 0.00729 -0.00345j\n", + " 0.498825+0.001125j]\n", + " [ 0.003945+0.003675j 0.00457 +0.j 0.007875+0.003465j\n", + " -0.0081 +0.00204j ]\n", + " [ 0.00729 +0.00345j 0.007875-0.003465j 0.00898 +0.j\n", + " -0.000645+0.002085j]\n", + " [ 0.498825-0.001125j -0.0081 -0.00204j -0.000645-0.002085j\n", + " 0.49066 +0.j ]]\n", + "\n", + "shadow state 1:\n", + " [[ 0.49579 +0.j 0.003945-0.003675j 0.00729 -0.00345j\n", + " 0.498825+0.001125j]\n", + " [ 0.003945+0.003675j 0.00457 +0.j 0.007875+0.003465j\n", + " -0.0081 +0.00204j ]\n", + " [ 0.00729 +0.00345j 0.007875-0.003465j 0.00898 +0.j\n", + " -0.000645+0.002085j]\n", + " [ 0.498825-0.001125j -0.0081 -0.00204j -0.000645-0.002085j\n", + " 0.49066 +0.j ]]\n", + "\n", + "shadow state 2:\n", + " [[ 0.49579 +0.j 0.003945-0.003675j 0.00729 -0.00345j\n", + " 0.498825+0.001125j]\n", + " [ 0.003945+0.003675j 0.00457 +0.j 0.007875+0.003465j\n", + " -0.0081 +0.00204j ]\n", + " [ 0.00729 +0.00345j 0.007875-0.003465j 0.00898 +0.j\n", + " -0.000645+0.002085j]\n", + " [ 0.498825-0.001125j -0.0081 -0.00204j -0.000645-0.002085j\n", + " 0.49066 +0.j ]]\n" + ] + } + ], + "source": [ + "n, nps, r = 2, 10000, 5\n", + "\n", + "c = tc.Circuit(n)\n", + "c.H(0)\n", + "c.cnot(0, 1)\n", + "\n", + "psi = c.state()\n", + "bell_state = psi[:, None] @ psi[None, :]\n", + "\n", + "pauli_strings = BK.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", + "status = BK.convert_to_tensor(np.random.rand(nps, r))\n", + "lss_states = shadows.shadow_snapshots(psi, pauli_strings, status)\n", + "sdw_state = shadows.global_shadow_state(lss_states)\n", + "sdw_state1 = shadows.global_shadow_state1(lss_states)\n", + "sdw_state2 = shadows.global_shadow_state2(lss_states)\n", + "\n", + "print(\"exact:\\n\", bell_state)\n", + "print(\"\\nshadow state:\\n\", sdw_state)\n", + "print(\"\\nshadow state 1:\\n\", sdw_state1)\n", + "print(\"\\nshadow state 2:\\n\", sdw_state2)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:10:43.360675500Z", + "start_time": "2023-08-08T12:10:41.746265700Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 18, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OS info: Linux-5.4.119-1-tlinux4-0010.2-x86_64-with-glibc2.28\n", + "Python version: 3.10.11\n", + "Numpy version: 1.23.5\n", + "Scipy version: 1.11.0\n", + "Pandas version: 2.0.2\n", + "TensorNetwork version: 0.4.6\n", + "Cotengra version: 0.2.1.dev15+g120379e\n", + "TensorFlow version: 2.12.0\n", + "TensorFlow GPU: []\n", + "TensorFlow CUDA infos: {'cpu_compiler': '/dt9/usr/bin/gcc', 'cuda_compute_capabilities': ['sm_35', 'sm_50', 'sm_60', 'sm_70', 'sm_75', 'compute_80'], 'cuda_version': '11.8', 'cudnn_version': '8', 'is_cuda_build': True, 'is_rocm_build': False, 'is_tensorrt_build': True}\n", + "Jax version: 0.4.13\n", + "Jax installation doesn't support GPU\n", + "JaxLib version: 0.4.13\n", + "PyTorch version: 2.0.1\n", + "PyTorch GPU support: False\n", + "PyTorch GPUs: []\n", + "Cupy is not installed\n", + "Qiskit version: 0.24.1\n", + "Cirq version: 1.1.0\n", + "TensorCircuit version 0.10.0\n" + ] + } + ], + "source": [ + "tc.about()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-08T12:10:43.409851700Z", + "start_time": "2023-08-08T12:10:43.360099800Z" + } + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 028e0e94..74f3c44d 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -26,7 +26,7 @@ def shadow_bound( :return Nk: number of snapshots :rtype: int - :return k: Number of equal parts to split the shadow snapshot states to compute the median of means. + :return k: number of equal parts to split the shadow snapshot states to compute the median of means. k=1 (default) corresponds to simply taking the mean over all shadow snapshot states. :rtype: int """ @@ -207,7 +207,7 @@ def tensor_prod(dms: Tensor) -> Tensor: return backend.mean(gss_states, axis=(0, 1)) -def expection_ps_shadow( +def expectation_ps_shadow( snapshots: Tensor, pauli_strings: Optional[Tensor] = None, x: Optional[Sequence[int]] = None, @@ -316,8 +316,6 @@ def entropy_shadow( :return Renyi entropy: shape = () :rtype: Tensor - - TODO: special case of alpha=2 """ if alpha <= 0: raise ValueError("Alpha should not be less than 1!") diff --git a/tests/test_shadows.py b/tests/test_shadows.py index c78032b7..9d6406b6 100644 --- a/tests/test_shadows.py +++ b/tests/test_shadows.py @@ -8,7 +8,8 @@ global_shadow_state, entropy_shadow, renyi_entropy_2, - expection_ps_shadow, + expectation_ps_shadow, + global_shadow_state1, ) @@ -38,7 +39,7 @@ def test_jit(backend): def classical_shadow(psi, pauli_strings, status): lss_states = shadow_snapshots(psi, pauli_strings, status) - expc = expection_ps_shadow(lss_states, ps=ps, k=k) + expc = expectation_ps_shadow(lss_states, ps=ps, k=k) ent = entropy_shadow(lss_states, sub=sub, alpha=2) return expc, ent @@ -69,8 +70,10 @@ def test_state(backend): status = tc.backend.convert_to_tensor(np.random.rand(ns, 5)) lss_states = shadow_snapshots(c.state(), pauli_strings, status) sdw_state = global_shadow_state(lss_states) + sdw_state1 = global_shadow_state1(lss_states) np.testing.assert_allclose(sdw_state, bell_state, atol=0.1) + np.testing.assert_allclose(sdw_state1, bell_state, atol=0.1) @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) From 9de15012cf47a0ae26f988c9d36d52ef387e91eb Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 8 Aug 2023 22:07:04 +0800 Subject: [PATCH 600/725] Update classical_shadows.ipynb --- docs/source/tutorials/classical_shadows.ipynb | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index ab1d6fc3..b6613ac4 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -30,7 +30,7 @@ { "cell_type": "markdown", "source": [ - "Let's first briefly review the classic shadows in Pauli basis. For an $n$-qubit quantum state $\\rho$, we randomly perform Pauli projection measurement on each qubit and obtain a snapshot like $\\{1,-1,-1,1\\cdots1,-1\\}$. This process is equivalent to apply a random unitary $U$ to $\\rho$ and measure in computational basis to obtain $|b\\rangle=|s_1\\cdots s_n\\rangle,\\ s_j\\in\\{0,1\\}$:\n", + "Let's first briefly review the classic shadows in Pauli basis. For an $n$-qubit quantum state $\\rho$, we randomly perform Pauli projection measurement on each qubit and obtain a snapshot like $\\{1,-1,-1,1,\\cdots,1,-1\\}$. This process is equivalent to apply a random unitary $U$ to $\\rho$ and measure in computational basis to obtain $|b\\rangle=|s_1\\cdots s_n\\rangle,\\ s_j\\in\\{0,1\\}$:\n", "$$\n", "\\begin{equation}\n", " \\rho\\rightarrow U\\rho U^{\\dagger}\\xrightarrow{measure}|b\\rangle\\langle b|,\n", @@ -54,7 +54,7 @@ " \\rho=\\mathbb{E}\\left[\\mathcal{M}^{-1}(U^{\\dagger}|b\\rangle\\langle b|U)\\right].\n", "\\end{equation}\n", "$$\n", - "We call each $\\rho_i=\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)$ a shadow snapshot state and their ensemble $S(\\rho;N)=\\{\\rho_i|i=1\\cdots N\\}$ classical shadows." + "We call each $\\rho_i=\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)$ a shadow snapshot state and their ensemble $S(\\rho;N)=\\{\\rho_i|i=1,\\cdots,N\\}$ classical shadows." ], "metadata": { "collapsed": false @@ -70,7 +70,7 @@ " \\rho&=&\\frac{1}{N}\\sum_{i=1}^{N}\\rho_i\\ .\n", "\\end{eqnarray}\n", "$$\n", - "For an observable Pauli string $O=\\bigotimes_{j=1}^{n}P_j,\\ P_j\\in\\{\\mathbb{I}, X, Y, Z\\}$, we can directly use $\\rho$ to calculate $\\langle O\\rangle=\\text{Tr}(O\\rho)$. In practice, we will divide the classical shadows into $K$ parts to calculate the expectation value independently and take the median to avoid the influence of outliers:\n", + "For an observable Pauli string $O=\\bigotimes_{j=1}^{n}P_j,\\ P_j\\in\\{\\mathbb{I}, X, Y, Z\\}$, we can directly use $\\rho$ to calculate $\\langle O\\rangle=\\text{Tr}(O\\rho)$. In practice, we will divide the classical shadows into $K$ parts to calculate the expectation values independently and take the median to avoid the influence of outliers:\n", "$$\n", "\\begin{equation}\n", " \\langle O\\rangle=\\text{median}\\{\\langle O_{(1)}\\rangle\\cdots\\langle O_{(K)}\\rangle\\},\n", @@ -176,7 +176,7 @@ "\n", "epsilon, delta = 0.1, 0.01\n", "N, K = shadows.shadow_bound(ps, epsilon, delta)\n", - "nps = N // r # number of random pauli strings\n", + "nps = N // r # number of random selected Pauli strings\n", "print(f\"N: {N}\\tK: {K}\\tnumber of Pauli strings: {nps}\")" ], "metadata": { @@ -226,7 +226,7 @@ { "cell_type": "markdown", "source": [ - "We randomly generate Pauli strings. Since the function after just-in-time compilation does not support random sampling, we need to generate all random states in advance, that is, variable `status`." + "We randomly generate Pauli strings. Since the function after just-in-time (jit) compilation does not support random sampling, we need to generate all random states in advance, that is, variable `status`." ], "metadata": { "collapsed": false @@ -328,7 +328,7 @@ { "cell_type": "markdown", "source": [ - "It can be seen from the running time that every time the number of Pauli strings changes, `shadow_expec` will be recompiled, but for the same number of Pauli strings but different observables, `shadow_expec` will only be compiled once. In the end, the absolute errors given by classical shadows are much smaller than the $\\epsilon=0.1$ we set, so shadow_bound gives a very loose upper bound." + "It can be seen from the running time that every time the number of Pauli strings changes, `shadow_expec` will be recompiled, but for the same number of Pauli strings but different observables, `shadow_expec` will only be compiled once. In the end, the absolute errors given by classical shadows are much smaller than the $\\epsilon=0.1$ we set, so `shadow_bound` gives a very loose upper bound." ], "metadata": { "collapsed": false @@ -552,14 +552,14 @@ { "cell_type": "markdown", "source": [ - "On the other hand, for the second order Renyi entropy, we have another method to calculate it in polynomial time by random measurement:\n", + "On the other hand, for the second order Renyi entropy, we have another method to calculate it in polynomial time by random measurements:\n", "$$\n", "\\begin{eqnarray}\n", " S_2&=&-\\log\\left(\\text{Tr}(\\rho_A^2)\\right),\\\\\n", " \\text{Tr}(\\rho_A^2)&=&2^k\\sum_{b,b'\\in\\{0,1\\}^k}(-2)^{-H(b,b')}\\overline{P(b)P(b')},\n", "\\end{eqnarray}\n", "$$\n", - "where $A$ is the $k$-d reduced system, $H(b,b')$ is the Hamming distance between $b$ and $b'$, $P(b)$ is the probability for measuring $\\rho_A$ and obtaining the outcomes $b$ thus we need a larger $r$ to obtain a good enough priori probability, and the overline means the average on all random selected Pauli strings. Please refer to [Brydges, et al. (2019)](https://www.science.org/doi/full/10.1126/science.aau4963) for more details. We can use `renyi_entropy_2` to implement this method, but it is not jitable because we need to build the dictionary based on the bit strings obtained by measurement. Compared with `entropy_shadow`, it cannot filter out non-negative eigenvalues, so the accuracy is slightly worse." + "where $A$ is the $k$-d reduced system, $H(b,b')$ is the Hamming distance between $b$ and $b'$, $P(b)$ is the probability for measuring $\\rho_A$ and obtaining the outcomes $b$ thus we need a larger $r$ to obtain a good enough priori probability, and the overline means the average on all random selected Pauli strings. Please refer to [Brydges, et al. (2019)](https://www.science.org/doi/full/10.1126/science.aau4963) for more details. We can use `renyi_entropy_2` to implement this method, but it is not jitable because we need to build the dictionary based on the bit strings obtained by measurements, which is a dynamical process. Compared with `entropy_shadow`, it cannot filter out non-negative eigenvalues, so the accuracy is slightly worse." ], "metadata": { "collapsed": false @@ -608,7 +608,7 @@ { "cell_type": "markdown", "source": [ - "We can `global_shadow_state`, `global_shadow_state1` or `global_shadow_state2` to reconstruct the density matrix. These three functions use different methods, but the results are exactly the same and all of them are jitable. In specific, `global_shadow_state` uses `kron` and is recommended, the other two use `einsum`." + "We can use `global_shadow_state`, `global_shadow_state1` or `global_shadow_state2` to reconstruct the density matrix. These three functions use different methods, but the results are exactly the same and all of them are jitable. In specific, `global_shadow_state` uses `kron` and is recommended, the other two use `einsum`." ], "metadata": { "collapsed": false From a0948b4198ca64ee516d23b0aed41cbc4ea4b3bc Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 9 Aug 2023 10:48:01 +0800 Subject: [PATCH 601/725] Update classical_shadows.ipynb, add the jit example when calculate the entanglement entropy. --- docs/source/tutorials/classical_shadows.ipynb | 188 +++++++++++------- 1 file changed, 116 insertions(+), 72 deletions(-) diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index b6613ac4..444967c9 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -92,12 +92,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2023-08-08T12:07:59.787548200Z", - "start_time": "2023-08-08T12:07:59.689077500Z" + "end_time": "2023-08-09T02:30:37.665201100Z", + "start_time": "2023-08-09T02:30:37.638636Z" } }, "outputs": [ @@ -105,7 +105,7 @@ "data": { "text/plain": "('complex128', 'float64')" }, - "execution_count": 8, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "outputs": [ { "name": "stdout", @@ -182,8 +182,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:07:59.787548200Z", - "start_time": "2023-08-08T12:07:59.701762Z" + "end_time": "2023-08-09T02:30:41.331246200Z", + "start_time": "2023-08-09T02:30:41.324070Z" } } }, @@ -198,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "outputs": [], "source": [ "nlayers = 10\n", @@ -218,8 +218,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:07:59.893829700Z", - "start_time": "2023-08-08T12:07:59.708422100Z" + "end_time": "2023-08-09T02:30:48.458936400Z", + "start_time": "2023-08-09T02:30:48.245303100Z" } } }, @@ -234,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "outputs": [], "source": [ "pauli_strings = BK.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", @@ -243,8 +243,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:07:59.919435300Z", - "start_time": "2023-08-08T12:07:59.908781200Z" + "end_time": "2023-08-09T02:30:57.734884200Z", + "start_time": "2023-08-09T02:30:57.692043Z" } } }, @@ -259,13 +259,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(97920, 5, 8, 2, 2)\n" + "shape of snapshot states: (97920, 5, 8, 2, 2)\n" ] } ], @@ -278,13 +278,13 @@ "\n", "\n", "ss_states = shadow_ss(psi, pauli_strings, status) # jit is not necessary here\n", - "print(ss_states.shape)" + "print(\"shape of snapshot states:\", ss_states.shape)" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:08:03.113557900Z", - "start_time": "2023-08-08T12:08:00.167642400Z" + "end_time": "2023-08-09T02:32:13.230300600Z", + "start_time": "2023-08-09T02:32:10.257220400Z" } } }, @@ -509,7 +509,7 @@ { "cell_type": "markdown", "source": [ - "We can also use classical shadows to calculate entanglement entropy. `entropy_shadow` first reconstructs the reduced density matrix, then solves the eigenvalues and finally calculates the entanglement entropy from non-negative eigenvalues. Since the time and space complexity of reconstructing the density matrix is exponential with respect to the system size, this method is only efficient when the reduced system size is constant. `entropy_shadow` is jitable, but since we only calculate the entanglement entropy once here, it is not wrapped." + "We can also use classical shadows to calculate entanglement entropy. `entropy_shadow` first reconstructs the reduced density matrix, then solves the eigenvalues and finally calculates the entanglement entropy from non-negative eigenvalues. Since the time and space complexity of reconstructing the density matrix is exponential with respect to the system size, this method is only efficient when the reduced system size is constant. `entropy_shadow` is jitable, but it will only accelerate when the reduced sub systems have the same shape." ], "metadata": { "collapsed": false @@ -517,35 +517,61 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "exact: 1.326616283813521\n", - "shadow entropy: 1.328468470127564\n" + "sub: [1, 4]\ttime: 0.17648577690124512\texact: 1.3640689598449087\tshadow entropy: 1.3640570121867708\n", + "sub: [2, 7]\ttime: 0.039922475814819336\texact: 1.3278771521680572\tshadow entropy: 1.329313690500214\n", + "sub: [3, 6]\ttime: 0.03967714309692383\texact: 1.3592729872413634\tshadow entropy: 1.358544872130723\n", + "sub: [0, 5]\ttime: 0.039933204650878906\texact: 1.3431941549633575\tshadow entropy: 1.3434161532641598\n", + "sub: [7, 0]\ttime: 0.04005789756774902\texact: 1.339905097299989\tshadow entropy: 1.3412301752249673\n", + "sub: [1, 4, 7]\ttime: 0.25884079933166504\texact: 1.8441504433475884\tshadow entropy: 1.8320316624636186\n", + "sub: [0, 3, 6]\ttime: 0.11394333839416504\texact: 1.8720104442154792\tshadow entropy: 1.8695589673614292\n", + "sub: [5, 4, 2]\ttime: 0.11730098724365234\texact: 1.863627580838848\tshadow entropy: 1.860649003850145\n", + "sub: [7, 2, 5]\ttime: 0.1133573055267334\texact: 1.8446309930730256\tshadow entropy: 1.8449136080697077\n", + "sub: [0, 1, 2]\ttime: 0.11353397369384766\texact: 1.8514608539755246\tshadow entropy: 1.8518607742823925\n" ] } ], "source": [ - "sub = [1, 4]\n", + "subs = [\n", + " [1, 4],\n", + " [2, 7],\n", + " [3, 6],\n", + " [0, 5],\n", + " [7, 0],\n", + " [1, 4, 7],\n", + " [0, 3, 6],\n", + " [5, 4, 2],\n", + " [7, 2, 5],\n", + " [0, 1, 2],\n", + "]\n", "\n", - "exact_rdm = tc.quantum.reduced_density_matrix(\n", - " psi, cut=[i for i in range(n) if i not in sub]\n", - ")\n", - "exact_ent = tc.quantum.renyi_entropy(exact_rdm, k=2)\n", "\n", - "ent = shadows.entropy_shadow(ss_states, sub=sub, alpha=2)\n", + "@BK.jit\n", + "def shadow_ent(snapshots_states, sub, alpha=2):\n", + " return shadows.entropy_shadow(snapshots_states, sub=sub, alpha=alpha)\n", + "\n", "\n", - "print(\"exact:\", exact_ent)\n", - "print(\"shadow entropy:\", ent)" + "for sub in subs:\n", + " exact_rdm = tc.quantum.reduced_density_matrix(\n", + " psi, cut=[i for i in range(n) if i not in sub]\n", + " )\n", + " exact_ent = tc.quantum.renyi_entropy(exact_rdm, k=2)\n", + "\n", + " t0 = time.time()\n", + " ent = shadow_ent(ss_states, sub)\n", + " t = time.time()\n", + " print(f\"sub: {sub}\\ttime: {t - t0}\\texact: {exact_ent}\\tshadow entropy: {ent}\")" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:10:35.850421Z", - "start_time": "2023-08-08T12:10:35.292528800Z" + "end_time": "2023-08-09T02:33:00.022682Z", + "start_time": "2023-08-09T02:32:58.952538800Z" } } }, @@ -567,13 +593,22 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "shadow entropy 2: 1.3039560994783876\n" + "sub: [1, 4]\ttime: 4.649497032165527\tshadow entropy 2: 1.3357892188426321\n", + "sub: [2, 7]\ttime: 3.7085328102111816\tshadow entropy 2: 1.2962030413604921\n", + "sub: [3, 6]\ttime: 3.7152998447418213\tshadow entropy 2: 1.3329300192325162\n", + "sub: [0, 5]\ttime: 3.7029261589050293\tshadow entropy 2: 1.3142350322893441\n", + "sub: [7, 0]\ttime: 3.701401472091675\tshadow entropy 2: 1.3078303019333588\n", + "sub: [1, 4, 7]\ttime: 4.517441034317017\tshadow entropy 2: 1.7488599465846058\n", + "sub: [0, 3, 6]\ttime: 3.7792038917541504\tshadow entropy 2: 1.7752035184515997\n", + "sub: [5, 4, 2]\ttime: 3.8193397521972656\tshadow entropy 2: 1.766904637600782\n", + "sub: [7, 2, 5]\ttime: 3.86617374420166\tshadow entropy 2: 1.7459976573206142\n", + "sub: [0, 1, 2]\ttime: 3.7713708877563477\tshadow entropy 2: 1.747717244419407\n" ] } ], @@ -584,15 +619,20 @@ "status = BK.convert_to_tensor(np.random.rand(nps, r))\n", "\n", "snapshots = shadows.shadow_snapshots(psi, pauli_strings, status, measurement_only=True)\n", - "ent2 = shadows.renyi_entropy_2(snapshots, sub)\n", "\n", - "print(\"shadow entropy 2:\", ent2)" + "t0 = time.time()\n", + "for sub in subs:\n", + " ent2 = shadows.renyi_entropy_2(snapshots, sub)\n", + "\n", + " t = time.time()\n", + " print(f\"sub: {sub}\\ttime: {t - t0}\\tshadow entropy 2: {ent2}\")\n", + " t0 = t" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:10:41.738126600Z", - "start_time": "2023-08-08T12:10:35.851060800Z" + "end_time": "2023-08-09T02:33:55.215104800Z", + "start_time": "2023-08-09T02:33:14.638433400Z" } } }, @@ -608,7 +648,7 @@ { "cell_type": "markdown", "source": [ - "We can use `global_shadow_state`, `global_shadow_state1` or `global_shadow_state2` to reconstruct the density matrix. These three functions use different methods, but the results are exactly the same and all of them are jitable. In specific, `global_shadow_state` uses `kron` and is recommended, the other two use `einsum`." + "We can use `global_shadow_state`, `global_shadow_state1` or `global_shadow_state2` to reconstruct the density matrix. These three functions use different methods, but the results are exactly the same. All functions are jitable, but since we only use each of them once here, they are not wrapped. In terms of implementation details, `global_shadow_state` uses `kron` and is recommended, the other two use `einsum`." ], "metadata": { "collapsed": false @@ -616,7 +656,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "outputs": [ { "name": "stdout", @@ -628,35 +668,35 @@ " [0. +0.j 0. +0.j 0. +0.j 0. +0.j]\n", " [0.5+0.j 0. +0.j 0. +0.j 0.5+0.j]]\n", "\n", - "shadow state:\n", - " [[ 0.49579 +0.j 0.003945-0.003675j 0.00729 -0.00345j\n", - " 0.498825+0.001125j]\n", - " [ 0.003945+0.003675j 0.00457 +0.j 0.007875+0.003465j\n", - " -0.0081 +0.00204j ]\n", - " [ 0.00729 +0.00345j 0.007875-0.003465j 0.00898 +0.j\n", - " -0.000645+0.002085j]\n", - " [ 0.498825-0.001125j -0.0081 -0.00204j -0.000645-0.002085j\n", - " 0.49066 +0.j ]]\n", + "shadow state: error: 0.019630578188122815\n", + " [[ 5.10880e-01+0.000e+00j -7.35000e-04-2.235e-03j 2.25000e-03+3.150e-03j\n", + " 4.98375e-01-4.005e-03j]\n", + " [-7.35000e-04+2.235e-03j -2.69000e-03+0.000e+00j -2.25000e-04+5.850e-04j\n", + " 5.40000e-04+9.000e-05j]\n", + " [ 2.25000e-03-3.150e-03j -2.25000e-04-5.850e-04j -1.25600e-02+0.000e+00j\n", + " 7.50000e-05-1.245e-03j]\n", + " [ 4.98375e-01+4.005e-03j 5.40000e-04-9.000e-05j 7.50000e-05+1.245e-03j\n", + " 5.04370e-01+0.000e+00j]]\n", "\n", - "shadow state 1:\n", - " [[ 0.49579 +0.j 0.003945-0.003675j 0.00729 -0.00345j\n", - " 0.498825+0.001125j]\n", - " [ 0.003945+0.003675j 0.00457 +0.j 0.007875+0.003465j\n", - " -0.0081 +0.00204j ]\n", - " [ 0.00729 +0.00345j 0.007875-0.003465j 0.00898 +0.j\n", - " -0.000645+0.002085j]\n", - " [ 0.498825-0.001125j -0.0081 -0.00204j -0.000645-0.002085j\n", - " 0.49066 +0.j ]]\n", + "shadow state 1: error: 0.019630578188122815\n", + " [[ 5.10880e-01+0.000e+00j -7.35000e-04-2.235e-03j 2.25000e-03+3.150e-03j\n", + " 4.98375e-01-4.005e-03j]\n", + " [-7.35000e-04+2.235e-03j -2.69000e-03+0.000e+00j -2.25000e-04+5.850e-04j\n", + " 5.40000e-04+9.000e-05j]\n", + " [ 2.25000e-03-3.150e-03j -2.25000e-04-5.850e-04j -1.25600e-02+0.000e+00j\n", + " 7.50000e-05-1.245e-03j]\n", + " [ 4.98375e-01+4.005e-03j 5.40000e-04-9.000e-05j 7.50000e-05+1.245e-03j\n", + " 5.04370e-01+0.000e+00j]]\n", "\n", - "shadow state 2:\n", - " [[ 0.49579 +0.j 0.003945-0.003675j 0.00729 -0.00345j\n", - " 0.498825+0.001125j]\n", - " [ 0.003945+0.003675j 0.00457 +0.j 0.007875+0.003465j\n", - " -0.0081 +0.00204j ]\n", - " [ 0.00729 +0.00345j 0.007875-0.003465j 0.00898 +0.j\n", - " -0.000645+0.002085j]\n", - " [ 0.498825-0.001125j -0.0081 -0.00204j -0.000645-0.002085j\n", - " 0.49066 +0.j ]]\n" + "shadow state 2: error: 0.019630578188122815\n", + " [[ 5.10880e-01+0.000e+00j -7.35000e-04-2.235e-03j 2.25000e-03+3.150e-03j\n", + " 4.98375e-01-4.005e-03j]\n", + " [-7.35000e-04+2.235e-03j -2.69000e-03+0.000e+00j -2.25000e-04+5.850e-04j\n", + " 5.40000e-04+9.000e-05j]\n", + " [ 2.25000e-03-3.150e-03j -2.25000e-04-5.850e-04j -1.25600e-02+0.000e+00j\n", + " 7.50000e-05-1.245e-03j]\n", + " [ 4.98375e-01+4.005e-03j 5.40000e-04-9.000e-05j 7.50000e-05+1.245e-03j\n", + " 5.04370e-01+0.000e+00j]]\n" ] } ], @@ -678,15 +718,19 @@ "sdw_state2 = shadows.global_shadow_state2(lss_states)\n", "\n", "print(\"exact:\\n\", bell_state)\n", - "print(\"\\nshadow state:\\n\", sdw_state)\n", - "print(\"\\nshadow state 1:\\n\", sdw_state1)\n", - "print(\"\\nshadow state 2:\\n\", sdw_state2)" + "print(f\"\\nshadow state: error: {np.linalg.norm(bell_state - sdw_state)}\\n\", sdw_state)\n", + "print(\n", + " f\"\\nshadow state 1: error: {np.linalg.norm(bell_state - sdw_state)}\\n\", sdw_state1\n", + ")\n", + "print(\n", + " f\"\\nshadow state 2: error: {np.linalg.norm(bell_state - sdw_state)}\\n\", sdw_state2\n", + ")" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:10:43.360675500Z", - "start_time": "2023-08-08T12:10:41.746265700Z" + "end_time": "2023-08-09T02:19:18.141586600Z", + "start_time": "2023-08-09T02:19:16.434910100Z" } } }, From 0b558db85166a969266a1822b701cf6242ecf16d Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 9 Aug 2023 12:43:08 +0800 Subject: [PATCH 602/725] Update classical_shadows.ipynb --- docs/source/tutorials/classical_shadows.ipynb | 404 +++++++++--------- 1 file changed, 207 insertions(+), 197 deletions(-) diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index 444967c9..ec2acb4f 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -30,7 +30,7 @@ { "cell_type": "markdown", "source": [ - "Let's first briefly review the classic shadows in Pauli basis. For an $n$-qubit quantum state $\\rho$, we randomly perform Pauli projection measurement on each qubit and obtain a snapshot like $\\{1,-1,-1,1,\\cdots,1,-1\\}$. This process is equivalent to apply a random unitary $U$ to $\\rho$ and measure in computational basis to obtain $|b\\rangle=|s_1\\cdots s_n\\rangle,\\ s_j\\in\\{0,1\\}$:\n", + "Let's first briefly review the classical shadows in Pauli basis. For an $n$-qubit quantum state $\\rho$, we randomly perform Pauli projection measurement on each qubit and obtain a snapshot like $\\{1,-1,-1,1,\\cdots,1,-1\\}$. This process is equivalent to apply a random unitary $U$ to $\\rho$ and measure in computational basis to obtain $|b\\rangle=|s_1\\cdots s_n\\rangle,\\ s_j\\in\\{0,1\\}$:\n", "$$\n", "\\begin{equation}\n", " \\rho\\rightarrow U\\rho U^{\\dagger}\\xrightarrow{measure}|b\\rangle\\langle b|,\n", @@ -92,12 +92,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 24, "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2023-08-09T02:30:37.665201100Z", - "start_time": "2023-08-09T02:30:37.638636Z" + "end_time": "2023-08-09T04:31:38.322562200Z", + "start_time": "2023-08-09T04:31:38.228434100Z" } }, "outputs": [ @@ -105,7 +105,7 @@ "data": { "text/plain": "('complex128', 'float64')" }, - "execution_count": 2, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -118,7 +118,7 @@ "import time\n", "import matplotlib.pyplot as plt\n", "\n", - "BK = tc.set_backend(\"jax\")\n", + "tc.set_backend(\"jax\")\n", "tc.set_dtype(\"complex128\")" ] }, @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 25, "outputs": [ { "name": "stdout", @@ -182,8 +182,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T02:30:41.331246200Z", - "start_time": "2023-08-09T02:30:41.324070Z" + "end_time": "2023-08-09T04:31:38.322562200Z", + "start_time": "2023-08-09T04:31:38.240003600Z" } } }, @@ -198,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 26, "outputs": [], "source": [ "nlayers = 10\n", @@ -218,8 +218,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T02:30:48.458936400Z", - "start_time": "2023-08-09T02:30:48.245303100Z" + "end_time": "2023-08-09T04:31:38.414455200Z", + "start_time": "2023-08-09T04:31:38.248402200Z" } } }, @@ -234,17 +234,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 27, "outputs": [], "source": [ - "pauli_strings = BK.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", - "status = BK.convert_to_tensor(np.random.rand(nps, r))" + "pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", + "status = tc.backend.convert_to_tensor(np.random.rand(nps, r))" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T02:30:57.734884200Z", - "start_time": "2023-08-09T02:30:57.692043Z" + "end_time": "2023-08-09T04:31:38.461760500Z", + "start_time": "2023-08-09T04:31:38.450425100Z" } } }, @@ -259,7 +259,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 28, "outputs": [ { "name": "stdout", @@ -270,7 +270,7 @@ } ], "source": [ - "@partial(BK.jit, static_argnums=(3,))\n", + "@partial(tc.backend.jit, static_argnums=(3,))\n", "def shadow_ss(psi, pauli_strings, status, measurement_only=False):\n", " return shadows.shadow_snapshots(\n", " psi, pauli_strings, status, measurement_only=measurement_only\n", @@ -283,8 +283,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T02:32:13.230300600Z", - "start_time": "2023-08-09T02:32:10.257220400Z" + "end_time": "2023-08-09T04:31:41.371950200Z", + "start_time": "2023-08-09T04:31:38.450979700Z" } } }, @@ -308,20 +308,20 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 29, "outputs": [], "source": [ "def shadow_expec(snapshots_states, ob):\n", " return shadows.expectation_ps_shadow(snapshots_states, ps=ob, k=K)\n", "\n", "\n", - "sejit = BK.jit(shadow_expec)" + "sejit = tc.backend.jit(shadow_expec)" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:08:03.189105100Z", - "start_time": "2023-08-08T12:08:03.113557900Z" + "end_time": "2023-08-09T04:31:41.716500100Z", + "start_time": "2023-08-09T04:31:41.383611200Z" } } }, @@ -336,118 +336,128 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 30, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "observalbe: No.0\tnumber of Pauli strings: 1000\ttime: 0.9208428859710693\n", - "observalbe: No.1\tnumber of Pauli strings: 1000\ttime: 0.001764535903930664\n", - "observalbe: No.2\tnumber of Pauli strings: 1000\ttime: 0.0013713836669921875\n", - "observalbe: No.3\tnumber of Pauli strings: 1000\ttime: 0.0013463497161865234\n", - "observalbe: No.4\tnumber of Pauli strings: 1000\ttime: 0.0014214515686035156\n", - "observalbe: No.5\tnumber of Pauli strings: 1000\ttime: 0.0013613700866699219\n", - "observalbe: No.6\tnumber of Pauli strings: 1000\ttime: 0.001367330551147461\n", - "observalbe: No.7\tnumber of Pauli strings: 1000\ttime: 0.001378774642944336\n", - "observalbe: No.8\tnumber of Pauli strings: 1000\ttime: 0.0013740062713623047\n", - "observalbe: No.9\tnumber of Pauli strings: 1000\ttime: 0.001354217529296875\n", - "observalbe: No.0\tnumber of Pauli strings: 11000\ttime: 0.9906811714172363\n", - "observalbe: No.1\tnumber of Pauli strings: 11000\ttime: 0.012621402740478516\n", - "observalbe: No.2\tnumber of Pauli strings: 11000\ttime: 0.012280464172363281\n", - "observalbe: No.3\tnumber of Pauli strings: 11000\ttime: 0.012493133544921875\n", - "observalbe: No.4\tnumber of Pauli strings: 11000\ttime: 0.012433767318725586\n", - "observalbe: No.5\tnumber of Pauli strings: 11000\ttime: 0.012764692306518555\n", - "observalbe: No.6\tnumber of Pauli strings: 11000\ttime: 0.012403726577758789\n", - "observalbe: No.7\tnumber of Pauli strings: 11000\ttime: 0.012158393859863281\n", - "observalbe: No.8\tnumber of Pauli strings: 11000\ttime: 0.012058734893798828\n", - "observalbe: No.9\tnumber of Pauli strings: 11000\ttime: 0.012238740921020508\n", - "observalbe: No.0\tnumber of Pauli strings: 21000\ttime: 1.0218532085418701\n", - "observalbe: No.1\tnumber of Pauli strings: 21000\ttime: 0.024202823638916016\n", - "observalbe: No.2\tnumber of Pauli strings: 21000\ttime: 0.023923397064208984\n", - "observalbe: No.3\tnumber of Pauli strings: 21000\ttime: 0.023802757263183594\n", - "observalbe: No.4\tnumber of Pauli strings: 21000\ttime: 0.02439141273498535\n", - "observalbe: No.5\tnumber of Pauli strings: 21000\ttime: 0.024312973022460938\n", - "observalbe: No.6\tnumber of Pauli strings: 21000\ttime: 0.02409648895263672\n", - "observalbe: No.7\tnumber of Pauli strings: 21000\ttime: 0.0239260196685791\n", - "observalbe: No.8\tnumber of Pauli strings: 21000\ttime: 0.024311542510986328\n", - "observalbe: No.9\tnumber of Pauli strings: 21000\ttime: 0.023871660232543945\n", - "observalbe: No.0\tnumber of Pauli strings: 31000\ttime: 0.9866394996643066\n", - "observalbe: No.1\tnumber of Pauli strings: 31000\ttime: 0.03965640068054199\n", - "observalbe: No.2\tnumber of Pauli strings: 31000\ttime: 0.040810585021972656\n", - "observalbe: No.3\tnumber of Pauli strings: 31000\ttime: 0.040923118591308594\n", - "observalbe: No.4\tnumber of Pauli strings: 31000\ttime: 0.03870081901550293\n", - "observalbe: No.5\tnumber of Pauli strings: 31000\ttime: 0.03658175468444824\n", - "observalbe: No.6\tnumber of Pauli strings: 31000\ttime: 0.033846139907836914\n", - "observalbe: No.7\tnumber of Pauli strings: 31000\ttime: 0.03284430503845215\n", - "observalbe: No.8\tnumber of Pauli strings: 31000\ttime: 0.03468632698059082\n", - "observalbe: No.9\tnumber of Pauli strings: 31000\ttime: 0.034407615661621094\n", - "observalbe: No.0\tnumber of Pauli strings: 41000\ttime: 1.014129400253296\n", - "observalbe: No.1\tnumber of Pauli strings: 41000\ttime: 0.053369998931884766\n", - "observalbe: No.2\tnumber of Pauli strings: 41000\ttime: 0.05180001258850098\n", - "observalbe: No.3\tnumber of Pauli strings: 41000\ttime: 0.05307412147521973\n", - "observalbe: No.4\tnumber of Pauli strings: 41000\ttime: 0.05329442024230957\n", - "observalbe: No.5\tnumber of Pauli strings: 41000\ttime: 0.05172109603881836\n", - "observalbe: No.6\tnumber of Pauli strings: 41000\ttime: 0.052023887634277344\n", - "observalbe: No.7\tnumber of Pauli strings: 41000\ttime: 0.05315876007080078\n", - "observalbe: No.8\tnumber of Pauli strings: 41000\ttime: 0.05295825004577637\n", - "observalbe: No.9\tnumber of Pauli strings: 41000\ttime: 0.05689072608947754\n", - "observalbe: No.0\tnumber of Pauli strings: 51000\ttime: 0.997788667678833\n", - "observalbe: No.1\tnumber of Pauli strings: 51000\ttime: 0.06549453735351562\n", - "observalbe: No.2\tnumber of Pauli strings: 51000\ttime: 0.06295180320739746\n", - "observalbe: No.3\tnumber of Pauli strings: 51000\ttime: 0.06317925453186035\n", - "observalbe: No.4\tnumber of Pauli strings: 51000\ttime: 0.06182670593261719\n", - "observalbe: No.5\tnumber of Pauli strings: 51000\ttime: 0.06398820877075195\n", - "observalbe: No.6\tnumber of Pauli strings: 51000\ttime: 0.06252193450927734\n", - "observalbe: No.7\tnumber of Pauli strings: 51000\ttime: 0.057137250900268555\n", - "observalbe: No.8\tnumber of Pauli strings: 51000\ttime: 0.06129312515258789\n", - "observalbe: No.9\tnumber of Pauli strings: 51000\ttime: 0.06306266784667969\n", - "observalbe: No.0\tnumber of Pauli strings: 61000\ttime: 1.0299479961395264\n", - "observalbe: No.1\tnumber of Pauli strings: 61000\ttime: 0.06776976585388184\n", - "observalbe: No.2\tnumber of Pauli strings: 61000\ttime: 0.06797552108764648\n", - "observalbe: No.3\tnumber of Pauli strings: 61000\ttime: 0.06658697128295898\n", - "observalbe: No.4\tnumber of Pauli strings: 61000\ttime: 0.06751775741577148\n", - "observalbe: No.5\tnumber of Pauli strings: 61000\ttime: 0.06934762001037598\n", - "observalbe: No.6\tnumber of Pauli strings: 61000\ttime: 0.06731104850769043\n", - "observalbe: No.7\tnumber of Pauli strings: 61000\ttime: 0.06712603569030762\n", - "observalbe: No.8\tnumber of Pauli strings: 61000\ttime: 0.07176804542541504\n", - "observalbe: No.9\tnumber of Pauli strings: 61000\ttime: 0.06982183456420898\n", - "observalbe: No.0\tnumber of Pauli strings: 71000\ttime: 1.0498173236846924\n", - "observalbe: No.1\tnumber of Pauli strings: 71000\ttime: 0.07942628860473633\n", - "observalbe: No.2\tnumber of Pauli strings: 71000\ttime: 0.07740139961242676\n", - "observalbe: No.3\tnumber of Pauli strings: 71000\ttime: 0.07828497886657715\n", - "observalbe: No.4\tnumber of Pauli strings: 71000\ttime: 0.07857322692871094\n", - "observalbe: No.5\tnumber of Pauli strings: 71000\ttime: 0.07705187797546387\n", - "observalbe: No.6\tnumber of Pauli strings: 71000\ttime: 0.0785682201385498\n", - "observalbe: No.7\tnumber of Pauli strings: 71000\ttime: 0.07775306701660156\n", - "observalbe: No.8\tnumber of Pauli strings: 71000\ttime: 0.07622480392456055\n", - "observalbe: No.9\tnumber of Pauli strings: 71000\ttime: 0.07927823066711426\n", - "observalbe: No.0\tnumber of Pauli strings: 81000\ttime: 1.05106520652771\n", - "observalbe: No.1\tnumber of Pauli strings: 81000\ttime: 0.08436226844787598\n", - "observalbe: No.2\tnumber of Pauli strings: 81000\ttime: 0.08675956726074219\n", - "observalbe: No.3\tnumber of Pauli strings: 81000\ttime: 0.08600664138793945\n", - "observalbe: No.4\tnumber of Pauli strings: 81000\ttime: 0.08568215370178223\n", - "observalbe: No.5\tnumber of Pauli strings: 81000\ttime: 0.0852055549621582\n", - "observalbe: No.6\tnumber of Pauli strings: 81000\ttime: 0.08647036552429199\n", - "observalbe: No.7\tnumber of Pauli strings: 81000\ttime: 0.08586692810058594\n", - "observalbe: No.8\tnumber of Pauli strings: 81000\ttime: 0.0845186710357666\n", - "observalbe: No.9\tnumber of Pauli strings: 81000\ttime: 0.08591985702514648\n", - "observalbe: No.0\tnumber of Pauli strings: 91000\ttime: 1.0378658771514893\n", - "observalbe: No.1\tnumber of Pauli strings: 91000\ttime: 0.09274506568908691\n", - "observalbe: No.2\tnumber of Pauli strings: 91000\ttime: 0.09148311614990234\n", - "observalbe: No.3\tnumber of Pauli strings: 91000\ttime: 0.09451770782470703\n", - "observalbe: No.4\tnumber of Pauli strings: 91000\ttime: 0.09089279174804688\n", - "observalbe: No.5\tnumber of Pauli strings: 91000\ttime: 0.09438014030456543\n", - "observalbe: No.6\tnumber of Pauli strings: 91000\ttime: 0.09279298782348633\n", - "observalbe: No.7\tnumber of Pauli strings: 91000\ttime: 0.09514856338500977\n", - "observalbe: No.8\tnumber of Pauli strings: 91000\ttime: 0.09679627418518066\n", - "observalbe: No.9\tnumber of Pauli strings: 91000\ttime: 0.09592223167419434\n" + "observalbe: No.0\tnumber of Pauli strings: 1000\ttime: 0.9551787376403809\n", + "observalbe: No.1\tnumber of Pauli strings: 1000\ttime: 0.0018684864044189453\n", + "observalbe: No.2\tnumber of Pauli strings: 1000\ttime: 0.0013768672943115234\n", + "observalbe: No.3\tnumber of Pauli strings: 1000\ttime: 0.001379251480102539\n", + "observalbe: No.4\tnumber of Pauli strings: 1000\ttime: 0.0013794898986816406\n", + "observalbe: No.5\tnumber of Pauli strings: 1000\ttime: 0.0013344287872314453\n", + "observalbe: No.6\tnumber of Pauli strings: 1000\ttime: 0.0013382434844970703\n", + "observalbe: No.7\tnumber of Pauli strings: 1000\ttime: 0.0013227462768554688\n", + "observalbe: No.8\tnumber of Pauli strings: 1000\ttime: 0.0013265609741210938\n", + "observalbe: No.9\tnumber of Pauli strings: 1000\ttime: 0.0013682842254638672\n", + "observalbe: No.0\tnumber of Pauli strings: 10000\ttime: 1.0090177059173584\n", + "observalbe: No.1\tnumber of Pauli strings: 10000\ttime: 0.013788700103759766\n", + "observalbe: No.2\tnumber of Pauli strings: 10000\ttime: 0.013601541519165039\n", + "observalbe: No.3\tnumber of Pauli strings: 10000\ttime: 0.013403654098510742\n", + "observalbe: No.4\tnumber of Pauli strings: 10000\ttime: 0.013345003128051758\n", + "observalbe: No.5\tnumber of Pauli strings: 10000\ttime: 0.01335453987121582\n", + "observalbe: No.6\tnumber of Pauli strings: 10000\ttime: 0.013194084167480469\n", + "observalbe: No.7\tnumber of Pauli strings: 10000\ttime: 0.01315927505493164\n", + "observalbe: No.8\tnumber of Pauli strings: 10000\ttime: 0.01338505744934082\n", + "observalbe: No.9\tnumber of Pauli strings: 10000\ttime: 0.01331019401550293\n", + "observalbe: No.0\tnumber of Pauli strings: 20000\ttime: 1.0305681228637695\n", + "observalbe: No.1\tnumber of Pauli strings: 20000\ttime: 0.02628493309020996\n", + "observalbe: No.2\tnumber of Pauli strings: 20000\ttime: 0.026256799697875977\n", + "observalbe: No.3\tnumber of Pauli strings: 20000\ttime: 0.02563929557800293\n", + "observalbe: No.4\tnumber of Pauli strings: 20000\ttime: 0.0260465145111084\n", + "observalbe: No.5\tnumber of Pauli strings: 20000\ttime: 0.02539658546447754\n", + "observalbe: No.6\tnumber of Pauli strings: 20000\ttime: 0.02595233917236328\n", + "observalbe: No.7\tnumber of Pauli strings: 20000\ttime: 0.025950908660888672\n", + "observalbe: No.8\tnumber of Pauli strings: 20000\ttime: 0.0260164737701416\n", + "observalbe: No.9\tnumber of Pauli strings: 20000\ttime: 0.02620983123779297\n", + "observalbe: No.0\tnumber of Pauli strings: 30000\ttime: 1.0244255065917969\n", + "observalbe: No.1\tnumber of Pauli strings: 30000\ttime: 0.0405888557434082\n", + "observalbe: No.2\tnumber of Pauli strings: 30000\ttime: 0.04141855239868164\n", + "observalbe: No.3\tnumber of Pauli strings: 30000\ttime: 0.03976869583129883\n", + "observalbe: No.4\tnumber of Pauli strings: 30000\ttime: 0.0402679443359375\n", + "observalbe: No.5\tnumber of Pauli strings: 30000\ttime: 0.039713144302368164\n", + "observalbe: No.6\tnumber of Pauli strings: 30000\ttime: 0.040461063385009766\n", + "observalbe: No.7\tnumber of Pauli strings: 30000\ttime: 0.04004383087158203\n", + "observalbe: No.8\tnumber of Pauli strings: 30000\ttime: 0.039717912673950195\n", + "observalbe: No.9\tnumber of Pauli strings: 30000\ttime: 0.040403127670288086\n", + "observalbe: No.0\tnumber of Pauli strings: 40000\ttime: 1.0132625102996826\n", + "observalbe: No.1\tnumber of Pauli strings: 40000\ttime: 0.054978370666503906\n", + "observalbe: No.2\tnumber of Pauli strings: 40000\ttime: 0.054826974868774414\n", + "observalbe: No.3\tnumber of Pauli strings: 40000\ttime: 0.0543065071105957\n", + "observalbe: No.4\tnumber of Pauli strings: 40000\ttime: 0.054796457290649414\n", + "observalbe: No.5\tnumber of Pauli strings: 40000\ttime: 0.05472278594970703\n", + "observalbe: No.6\tnumber of Pauli strings: 40000\ttime: 0.05406332015991211\n", + "observalbe: No.7\tnumber of Pauli strings: 40000\ttime: 0.05611300468444824\n", + "observalbe: No.8\tnumber of Pauli strings: 40000\ttime: 0.053575754165649414\n", + "observalbe: No.9\tnumber of Pauli strings: 40000\ttime: 0.053929805755615234\n", + "observalbe: No.0\tnumber of Pauli strings: 50000\ttime: 1.017702579498291\n", + "observalbe: No.1\tnumber of Pauli strings: 50000\ttime: 0.06368756294250488\n", + "observalbe: No.2\tnumber of Pauli strings: 50000\ttime: 0.06306672096252441\n", + "observalbe: No.3\tnumber of Pauli strings: 50000\ttime: 0.06530618667602539\n", + "observalbe: No.4\tnumber of Pauli strings: 50000\ttime: 0.06239771842956543\n", + "observalbe: No.5\tnumber of Pauli strings: 50000\ttime: 0.061684608459472656\n", + "observalbe: No.6\tnumber of Pauli strings: 50000\ttime: 0.06061291694641113\n", + "observalbe: No.7\tnumber of Pauli strings: 50000\ttime: 0.06512069702148438\n", + "observalbe: No.8\tnumber of Pauli strings: 50000\ttime: 0.0649871826171875\n", + "observalbe: No.9\tnumber of Pauli strings: 50000\ttime: 0.061399221420288086\n", + "observalbe: No.0\tnumber of Pauli strings: 60000\ttime: 1.0353941917419434\n", + "observalbe: No.1\tnumber of Pauli strings: 60000\ttime: 0.06991219520568848\n", + "observalbe: No.2\tnumber of Pauli strings: 60000\ttime: 0.06446075439453125\n", + "observalbe: No.3\tnumber of Pauli strings: 60000\ttime: 0.06750273704528809\n", + "observalbe: No.4\tnumber of Pauli strings: 60000\ttime: 0.06969285011291504\n", + "observalbe: No.5\tnumber of Pauli strings: 60000\ttime: 0.06952095031738281\n", + "observalbe: No.6\tnumber of Pauli strings: 60000\ttime: 0.06798005104064941\n", + "observalbe: No.7\tnumber of Pauli strings: 60000\ttime: 0.07035303115844727\n", + "observalbe: No.8\tnumber of Pauli strings: 60000\ttime: 0.07007980346679688\n", + "observalbe: No.9\tnumber of Pauli strings: 60000\ttime: 0.06980347633361816\n", + "observalbe: No.0\tnumber of Pauli strings: 70000\ttime: 1.0432231426239014\n", + "observalbe: No.1\tnumber of Pauli strings: 70000\ttime: 0.07599306106567383\n", + "observalbe: No.2\tnumber of Pauli strings: 70000\ttime: 0.07788610458374023\n", + "observalbe: No.3\tnumber of Pauli strings: 70000\ttime: 0.07639884948730469\n", + "observalbe: No.4\tnumber of Pauli strings: 70000\ttime: 0.07813096046447754\n", + "observalbe: No.5\tnumber of Pauli strings: 70000\ttime: 0.07661318778991699\n", + "observalbe: No.6\tnumber of Pauli strings: 70000\ttime: 0.07822918891906738\n", + "observalbe: No.7\tnumber of Pauli strings: 70000\ttime: 0.07674694061279297\n", + "observalbe: No.8\tnumber of Pauli strings: 70000\ttime: 0.0757136344909668\n", + "observalbe: No.9\tnumber of Pauli strings: 70000\ttime: 0.07785511016845703\n", + "observalbe: No.0\tnumber of Pauli strings: 80000\ttime: 1.0459909439086914\n", + "observalbe: No.1\tnumber of Pauli strings: 80000\ttime: 0.08465719223022461\n", + "observalbe: No.2\tnumber of Pauli strings: 80000\ttime: 0.08417797088623047\n", + "observalbe: No.3\tnumber of Pauli strings: 80000\ttime: 0.0836493968963623\n", + "observalbe: No.4\tnumber of Pauli strings: 80000\ttime: 0.08531856536865234\n", + "observalbe: No.5\tnumber of Pauli strings: 80000\ttime: 0.08510899543762207\n", + "observalbe: No.6\tnumber of Pauli strings: 80000\ttime: 0.08687043190002441\n", + "observalbe: No.7\tnumber of Pauli strings: 80000\ttime: 0.08501100540161133\n", + "observalbe: No.8\tnumber of Pauli strings: 80000\ttime: 0.08654212951660156\n", + "observalbe: No.9\tnumber of Pauli strings: 80000\ttime: 0.08644294738769531\n", + "observalbe: No.0\tnumber of Pauli strings: 90000\ttime: 1.052217960357666\n", + "observalbe: No.1\tnumber of Pauli strings: 90000\ttime: 0.09366059303283691\n", + "observalbe: No.2\tnumber of Pauli strings: 90000\ttime: 0.09249377250671387\n", + "observalbe: No.3\tnumber of Pauli strings: 90000\ttime: 0.09362578392028809\n", + "observalbe: No.4\tnumber of Pauli strings: 90000\ttime: 0.09312224388122559\n", + "observalbe: No.5\tnumber of Pauli strings: 90000\ttime: 0.09329438209533691\n", + "observalbe: No.6\tnumber of Pauli strings: 90000\ttime: 0.09333157539367676\n", + "observalbe: No.7\tnumber of Pauli strings: 90000\ttime: 0.09129500389099121\n", + "observalbe: No.8\tnumber of Pauli strings: 90000\ttime: 0.09405040740966797\n", + "observalbe: No.9\tnumber of Pauli strings: 90000\ttime: 0.09431266784667969\n", + "observalbe: No.0\tnumber of Pauli strings: 97920\ttime: 1.0521447658538818\n", + "observalbe: No.1\tnumber of Pauli strings: 97920\ttime: 0.10155749320983887\n", + "observalbe: No.2\tnumber of Pauli strings: 97920\ttime: 0.10006427764892578\n", + "observalbe: No.3\tnumber of Pauli strings: 97920\ttime: 0.10237908363342285\n", + "observalbe: No.4\tnumber of Pauli strings: 97920\ttime: 0.10087108612060547\n", + "observalbe: No.5\tnumber of Pauli strings: 97920\ttime: 0.10074806213378906\n", + "observalbe: No.6\tnumber of Pauli strings: 97920\ttime: 0.10087847709655762\n", + "observalbe: No.7\tnumber of Pauli strings: 97920\ttime: 0.10032892227172852\n", + "observalbe: No.8\tnumber of Pauli strings: 97920\ttime: 0.1014714241027832\n", + "observalbe: No.9\tnumber of Pauli strings: 97920\ttime: 0.10352730751037598\n" ] }, { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -459,20 +469,20 @@ "exact, res = [], []\n", "exact_expec = c.expectation_ps(ps=ps[0])\n", "for ob in ps:\n", - " exact.append(BK.real(c.expectation_ps(ps=ob)))\n", + " exact.append(tc.backend.real(c.expectation_ps(ps=ob)))\n", "exact = np.asarray(exact)[:, None]\n", "\n", "bzs, res = [], []\n", - "for i in range(0, nps, bz):\n", + "for i in range(bz, nps + bz, bz):\n", " res.append([])\n", - " ss_states_batch = ss_states[: i + bz]\n", + " ss_states_batch = ss_states[:i]\n", " bzs.append(ss_states_batch.shape[0])\n", " t0 = time.time()\n", " for j, ob in enumerate(ps):\n", " expcs = sejit(ss_states_batch, ob)\n", " res[-1].append(np.median(expcs))\n", " t = time.time()\n", - " if i % (bz * 10) == 0:\n", + " if i == bz or i % (bz * 10) == 0 or i >= nps:\n", " print(\n", " f\"observalbe: No.{j}\\tnumber of Pauli strings: {bzs[-1]}\\ttime: {t - t0}\"\n", " )\n", @@ -492,8 +502,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:10:35.293046600Z", - "start_time": "2023-08-08T12:08:03.154791700Z" + "end_time": "2023-08-09T04:34:15.672764900Z", + "start_time": "2023-08-09T04:31:41.746108200Z" } } }, @@ -517,22 +527,22 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 31, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "sub: [1, 4]\ttime: 0.17648577690124512\texact: 1.3640689598449087\tshadow entropy: 1.3640570121867708\n", - "sub: [2, 7]\ttime: 0.039922475814819336\texact: 1.3278771521680572\tshadow entropy: 1.329313690500214\n", - "sub: [3, 6]\ttime: 0.03967714309692383\texact: 1.3592729872413634\tshadow entropy: 1.358544872130723\n", - "sub: [0, 5]\ttime: 0.039933204650878906\texact: 1.3431941549633575\tshadow entropy: 1.3434161532641598\n", - "sub: [7, 0]\ttime: 0.04005789756774902\texact: 1.339905097299989\tshadow entropy: 1.3412301752249673\n", - "sub: [1, 4, 7]\ttime: 0.25884079933166504\texact: 1.8441504433475884\tshadow entropy: 1.8320316624636186\n", - "sub: [0, 3, 6]\ttime: 0.11394333839416504\texact: 1.8720104442154792\tshadow entropy: 1.8695589673614292\n", - "sub: [5, 4, 2]\ttime: 0.11730098724365234\texact: 1.863627580838848\tshadow entropy: 1.860649003850145\n", - "sub: [7, 2, 5]\ttime: 0.1133573055267334\texact: 1.8446309930730256\tshadow entropy: 1.8449136080697077\n", - "sub: [0, 1, 2]\ttime: 0.11353397369384766\texact: 1.8514608539755246\tshadow entropy: 1.8518607742823925\n" + "sub: [1, 4]\ttime: 0.18098187446594238\texact: 1.3406660475264627\tshadow entropy: 1.336610480903445\n", + "sub: [2, 7]\ttime: 0.03824925422668457\texact: 1.3490932264001985\tshadow entropy: 1.3509166994806294\n", + "sub: [3, 6]\ttime: 0.038893938064575195\texact: 1.3078555208559692\tshadow entropy: 1.3045157342230482\n", + "sub: [0, 5]\ttime: 0.038709402084350586\texact: 1.3553616203287133\tshadow entropy: 1.3522747747844561\n", + "sub: [7, 0]\ttime: 0.03954339027404785\texact: 1.3698051383654024\tshadow entropy: 1.3692586760254173\n", + "sub: [1, 4, 7]\ttime: 0.2516930103302002\texact: 1.8458514325863924\tshadow entropy: 1.8421843494645114\n", + "sub: [0, 3, 6]\ttime: 0.1100921630859375\texact: 1.868420576333227\tshadow entropy: 1.8660364331174333\n", + "sub: [5, 4, 2]\ttime: 0.11081576347351074\texact: 1.9590510433184192\tshadow entropy: 1.953652327649616\n", + "sub: [7, 2, 5]\ttime: 0.11055541038513184\texact: 1.886694103128951\tshadow entropy: 1.8883320713880314\n", + "sub: [0, 1, 2]\ttime: 0.10973739624023438\texact: 1.8939518969485623\tshadow entropy: 1.893886982107739\n" ] } ], @@ -551,7 +561,7 @@ "]\n", "\n", "\n", - "@BK.jit\n", + "@tc.backend.jit\n", "def shadow_ent(snapshots_states, sub, alpha=2):\n", " return shadows.entropy_shadow(snapshots_states, sub=sub, alpha=alpha)\n", "\n", @@ -570,8 +580,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T02:33:00.022682Z", - "start_time": "2023-08-09T02:32:58.952538800Z" + "end_time": "2023-08-09T04:34:16.712172300Z", + "start_time": "2023-08-09T04:34:15.672260Z" } } }, @@ -593,30 +603,30 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 32, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "sub: [1, 4]\ttime: 4.649497032165527\tshadow entropy 2: 1.3357892188426321\n", - "sub: [2, 7]\ttime: 3.7085328102111816\tshadow entropy 2: 1.2962030413604921\n", - "sub: [3, 6]\ttime: 3.7152998447418213\tshadow entropy 2: 1.3329300192325162\n", - "sub: [0, 5]\ttime: 3.7029261589050293\tshadow entropy 2: 1.3142350322893441\n", - "sub: [7, 0]\ttime: 3.701401472091675\tshadow entropy 2: 1.3078303019333588\n", - "sub: [1, 4, 7]\ttime: 4.517441034317017\tshadow entropy 2: 1.7488599465846058\n", - "sub: [0, 3, 6]\ttime: 3.7792038917541504\tshadow entropy 2: 1.7752035184515997\n", - "sub: [5, 4, 2]\ttime: 3.8193397521972656\tshadow entropy 2: 1.766904637600782\n", - "sub: [7, 2, 5]\ttime: 3.86617374420166\tshadow entropy 2: 1.7459976573206142\n", - "sub: [0, 1, 2]\ttime: 3.7713708877563477\tshadow entropy 2: 1.747717244419407\n" + "sub: [1, 4]\ttime: 3.8456406593322754\tshadow entropy 2: 1.311054830562784\n", + "sub: [2, 7]\ttime: 3.859579086303711\tshadow entropy 2: 1.3140964084640452\n", + "sub: [3, 6]\ttime: 3.8663485050201416\tshadow entropy 2: 1.2798966683162831\n", + "sub: [0, 5]\ttime: 3.8766448497772217\tshadow entropy 2: 1.3276919538959406\n", + "sub: [7, 0]\ttime: 3.8847577571868896\tshadow entropy 2: 1.339702023736642\n", + "sub: [1, 4, 7]\ttime: 3.9610671997070312\tshadow entropy 2: 1.7672210148609153\n", + "sub: [0, 3, 6]\ttime: 3.93074893951416\tshadow entropy 2: 1.7792306674701965\n", + "sub: [5, 4, 2]\ttime: 3.928624153137207\tshadow entropy 2: 1.8506358171662456\n", + "sub: [7, 2, 5]\ttime: 3.930849313735962\tshadow entropy 2: 1.7919769488750392\n", + "sub: [0, 1, 2]\ttime: 3.95222544670105\tshadow entropy 2: 1.7900890411701693\n" ] } ], "source": [ "nps, r = 1000, 500\n", "\n", - "pauli_strings = BK.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", - "status = BK.convert_to_tensor(np.random.rand(nps, r))\n", + "pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", + "status = tc.backend.convert_to_tensor(np.random.rand(nps, r))\n", "\n", "snapshots = shadows.shadow_snapshots(psi, pauli_strings, status, measurement_only=True)\n", "\n", @@ -631,8 +641,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T02:33:55.215104800Z", - "start_time": "2023-08-09T02:33:14.638433400Z" + "end_time": "2023-08-09T04:34:55.995126500Z", + "start_time": "2023-08-09T04:34:16.712172300Z" } } }, @@ -656,7 +666,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 33, "outputs": [ { "name": "stdout", @@ -668,35 +678,35 @@ " [0. +0.j 0. +0.j 0. +0.j 0. +0.j]\n", " [0.5+0.j 0. +0.j 0. +0.j 0.5+0.j]]\n", "\n", - "shadow state: error: 0.019630578188122815\n", - " [[ 5.10880e-01+0.000e+00j -7.35000e-04-2.235e-03j 2.25000e-03+3.150e-03j\n", - " 4.98375e-01-4.005e-03j]\n", - " [-7.35000e-04+2.235e-03j -2.69000e-03+0.000e+00j -2.25000e-04+5.850e-04j\n", - " 5.40000e-04+9.000e-05j]\n", - " [ 2.25000e-03-3.150e-03j -2.25000e-04-5.850e-04j -1.25600e-02+0.000e+00j\n", - " 7.50000e-05-1.245e-03j]\n", - " [ 4.98375e-01+4.005e-03j 5.40000e-04-9.000e-05j 7.50000e-05+1.245e-03j\n", - " 5.04370e-01+0.000e+00j]]\n", + "shadow state: error: 0.029270951470698747\n", + " [[ 0.50035 +0.j -0.000615+0.000525j 0.001155-0.005205j\n", + " 0.49455 +0.00243j ]\n", + " [-0.000615-0.000525j -0.00581 +0.j -0.0054 -0.00693j\n", + " 0.004935-0.000345j]\n", + " [ 0.001155+0.005205j -0.0054 +0.00693j -0.01259 +0.j\n", + " 0.001185+0.001245j]\n", + " [ 0.49455 -0.00243j 0.004935+0.000345j 0.001185-0.001245j\n", + " 0.51805 +0.j ]]\n", "\n", - "shadow state 1: error: 0.019630578188122815\n", - " [[ 5.10880e-01+0.000e+00j -7.35000e-04-2.235e-03j 2.25000e-03+3.150e-03j\n", - " 4.98375e-01-4.005e-03j]\n", - " [-7.35000e-04+2.235e-03j -2.69000e-03+0.000e+00j -2.25000e-04+5.850e-04j\n", - " 5.40000e-04+9.000e-05j]\n", - " [ 2.25000e-03-3.150e-03j -2.25000e-04-5.850e-04j -1.25600e-02+0.000e+00j\n", - " 7.50000e-05-1.245e-03j]\n", - " [ 4.98375e-01+4.005e-03j 5.40000e-04-9.000e-05j 7.50000e-05+1.245e-03j\n", - " 5.04370e-01+0.000e+00j]]\n", + "shadow state 1: error: 0.029270951470698747\n", + " [[ 0.50035 +0.j -0.000615+0.000525j 0.001155-0.005205j\n", + " 0.49455 +0.00243j ]\n", + " [-0.000615-0.000525j -0.00581 +0.j -0.0054 -0.00693j\n", + " 0.004935-0.000345j]\n", + " [ 0.001155+0.005205j -0.0054 +0.00693j -0.01259 +0.j\n", + " 0.001185+0.001245j]\n", + " [ 0.49455 -0.00243j 0.004935+0.000345j 0.001185-0.001245j\n", + " 0.51805 +0.j ]]\n", "\n", - "shadow state 2: error: 0.019630578188122815\n", - " [[ 5.10880e-01+0.000e+00j -7.35000e-04-2.235e-03j 2.25000e-03+3.150e-03j\n", - " 4.98375e-01-4.005e-03j]\n", - " [-7.35000e-04+2.235e-03j -2.69000e-03+0.000e+00j -2.25000e-04+5.850e-04j\n", - " 5.40000e-04+9.000e-05j]\n", - " [ 2.25000e-03-3.150e-03j -2.25000e-04-5.850e-04j -1.25600e-02+0.000e+00j\n", - " 7.50000e-05-1.245e-03j]\n", - " [ 4.98375e-01+4.005e-03j 5.40000e-04-9.000e-05j 7.50000e-05+1.245e-03j\n", - " 5.04370e-01+0.000e+00j]]\n" + "shadow state 2: error: 0.029270951470698747\n", + " [[ 0.50035 +0.j -0.000615+0.000525j 0.001155-0.005205j\n", + " 0.49455 +0.00243j ]\n", + " [-0.000615-0.000525j -0.00581 +0.j -0.0054 -0.00693j\n", + " 0.004935-0.000345j]\n", + " [ 0.001155+0.005205j -0.0054 +0.00693j -0.01259 +0.j\n", + " 0.001185+0.001245j]\n", + " [ 0.49455 -0.00243j 0.004935+0.000345j 0.001185-0.001245j\n", + " 0.51805 +0.j ]]\n" ] } ], @@ -710,8 +720,8 @@ "psi = c.state()\n", "bell_state = psi[:, None] @ psi[None, :]\n", "\n", - "pauli_strings = BK.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", - "status = BK.convert_to_tensor(np.random.rand(nps, r))\n", + "pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", + "status = tc.backend.convert_to_tensor(np.random.rand(nps, r))\n", "lss_states = shadows.shadow_snapshots(psi, pauli_strings, status)\n", "sdw_state = shadows.global_shadow_state(lss_states)\n", "sdw_state1 = shadows.global_shadow_state1(lss_states)\n", @@ -729,14 +739,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T02:19:18.141586600Z", - "start_time": "2023-08-09T02:19:16.434910100Z" + "end_time": "2023-08-09T04:34:56.136066900Z", + "start_time": "2023-08-09T04:34:55.995632500Z" } } }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 34, "outputs": [ { "name": "stdout", @@ -771,8 +781,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-08T12:10:43.409851700Z", - "start_time": "2023-08-08T12:10:43.360099800Z" + "end_time": "2023-08-09T04:34:56.136066900Z", + "start_time": "2023-08-09T04:34:56.119543900Z" } } } From 3b56fab36b0f17bbf11d916eb6312c4f00d6298f Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 9 Aug 2023 12:57:53 +0800 Subject: [PATCH 603/725] Update classical_shadows.ipynb --- docs/source/tutorials/classical_shadows.ipynb | 374 +++++++++--------- 1 file changed, 181 insertions(+), 193 deletions(-) diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index ec2acb4f..2166ccae 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -92,12 +92,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 13, "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2023-08-09T04:31:38.322562200Z", - "start_time": "2023-08-09T04:31:38.228434100Z" + "end_time": "2023-08-09T04:51:21.649753Z", + "start_time": "2023-08-09T04:51:21.598273400Z" } }, "outputs": [ @@ -105,7 +105,7 @@ "data": { "text/plain": "('complex128', 'float64')" }, - "execution_count": 24, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 14, "outputs": [ { "name": "stdout", @@ -182,8 +182,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:31:38.322562200Z", - "start_time": "2023-08-09T04:31:38.240003600Z" + "end_time": "2023-08-09T04:51:21.707924900Z", + "start_time": "2023-08-09T04:51:21.604342400Z" } } }, @@ -198,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 15, "outputs": [], "source": [ "nlayers = 10\n", @@ -218,8 +218,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:31:38.414455200Z", - "start_time": "2023-08-09T04:31:38.248402200Z" + "end_time": "2023-08-09T04:51:21.814604700Z", + "start_time": "2023-08-09T04:51:21.615066400Z" } } }, @@ -234,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 16, "outputs": [], "source": [ "pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(nps, n)))\n", @@ -243,8 +243,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:31:38.461760500Z", - "start_time": "2023-08-09T04:31:38.450425100Z" + "end_time": "2023-08-09T04:51:21.815119500Z", + "start_time": "2023-08-09T04:51:21.813574500Z" } } }, @@ -259,7 +259,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 17, "outputs": [ { "name": "stdout", @@ -283,8 +283,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:31:41.371950200Z", - "start_time": "2023-08-09T04:31:38.450979700Z" + "end_time": "2023-08-09T04:51:24.715816800Z", + "start_time": "2023-08-09T04:51:21.883673400Z" } } }, @@ -308,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 18, "outputs": [], "source": [ "def shadow_expec(snapshots_states, ob):\n", @@ -320,8 +320,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:31:41.716500100Z", - "start_time": "2023-08-09T04:31:41.383611200Z" + "end_time": "2023-08-09T04:51:25.082792700Z", + "start_time": "2023-08-09T04:51:24.750909500Z" } } }, @@ -336,128 +336,128 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 19, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "observalbe: No.0\tnumber of Pauli strings: 1000\ttime: 0.9551787376403809\n", - "observalbe: No.1\tnumber of Pauli strings: 1000\ttime: 0.0018684864044189453\n", - "observalbe: No.2\tnumber of Pauli strings: 1000\ttime: 0.0013768672943115234\n", - "observalbe: No.3\tnumber of Pauli strings: 1000\ttime: 0.001379251480102539\n", - "observalbe: No.4\tnumber of Pauli strings: 1000\ttime: 0.0013794898986816406\n", - "observalbe: No.5\tnumber of Pauli strings: 1000\ttime: 0.0013344287872314453\n", - "observalbe: No.6\tnumber of Pauli strings: 1000\ttime: 0.0013382434844970703\n", - "observalbe: No.7\tnumber of Pauli strings: 1000\ttime: 0.0013227462768554688\n", - "observalbe: No.8\tnumber of Pauli strings: 1000\ttime: 0.0013265609741210938\n", - "observalbe: No.9\tnumber of Pauli strings: 1000\ttime: 0.0013682842254638672\n", - "observalbe: No.0\tnumber of Pauli strings: 10000\ttime: 1.0090177059173584\n", - "observalbe: No.1\tnumber of Pauli strings: 10000\ttime: 0.013788700103759766\n", - "observalbe: No.2\tnumber of Pauli strings: 10000\ttime: 0.013601541519165039\n", - "observalbe: No.3\tnumber of Pauli strings: 10000\ttime: 0.013403654098510742\n", - "observalbe: No.4\tnumber of Pauli strings: 10000\ttime: 0.013345003128051758\n", - "observalbe: No.5\tnumber of Pauli strings: 10000\ttime: 0.01335453987121582\n", - "observalbe: No.6\tnumber of Pauli strings: 10000\ttime: 0.013194084167480469\n", - "observalbe: No.7\tnumber of Pauli strings: 10000\ttime: 0.01315927505493164\n", - "observalbe: No.8\tnumber of Pauli strings: 10000\ttime: 0.01338505744934082\n", - "observalbe: No.9\tnumber of Pauli strings: 10000\ttime: 0.01331019401550293\n", - "observalbe: No.0\tnumber of Pauli strings: 20000\ttime: 1.0305681228637695\n", - "observalbe: No.1\tnumber of Pauli strings: 20000\ttime: 0.02628493309020996\n", - "observalbe: No.2\tnumber of Pauli strings: 20000\ttime: 0.026256799697875977\n", - "observalbe: No.3\tnumber of Pauli strings: 20000\ttime: 0.02563929557800293\n", - "observalbe: No.4\tnumber of Pauli strings: 20000\ttime: 0.0260465145111084\n", - "observalbe: No.5\tnumber of Pauli strings: 20000\ttime: 0.02539658546447754\n", - "observalbe: No.6\tnumber of Pauli strings: 20000\ttime: 0.02595233917236328\n", - "observalbe: No.7\tnumber of Pauli strings: 20000\ttime: 0.025950908660888672\n", - "observalbe: No.8\tnumber of Pauli strings: 20000\ttime: 0.0260164737701416\n", - "observalbe: No.9\tnumber of Pauli strings: 20000\ttime: 0.02620983123779297\n", - "observalbe: No.0\tnumber of Pauli strings: 30000\ttime: 1.0244255065917969\n", - "observalbe: No.1\tnumber of Pauli strings: 30000\ttime: 0.0405888557434082\n", - "observalbe: No.2\tnumber of Pauli strings: 30000\ttime: 0.04141855239868164\n", - "observalbe: No.3\tnumber of Pauli strings: 30000\ttime: 0.03976869583129883\n", - "observalbe: No.4\tnumber of Pauli strings: 30000\ttime: 0.0402679443359375\n", - "observalbe: No.5\tnumber of Pauli strings: 30000\ttime: 0.039713144302368164\n", - "observalbe: No.6\tnumber of Pauli strings: 30000\ttime: 0.040461063385009766\n", - "observalbe: No.7\tnumber of Pauli strings: 30000\ttime: 0.04004383087158203\n", - "observalbe: No.8\tnumber of Pauli strings: 30000\ttime: 0.039717912673950195\n", - "observalbe: No.9\tnumber of Pauli strings: 30000\ttime: 0.040403127670288086\n", - "observalbe: No.0\tnumber of Pauli strings: 40000\ttime: 1.0132625102996826\n", - "observalbe: No.1\tnumber of Pauli strings: 40000\ttime: 0.054978370666503906\n", - "observalbe: No.2\tnumber of Pauli strings: 40000\ttime: 0.054826974868774414\n", - "observalbe: No.3\tnumber of Pauli strings: 40000\ttime: 0.0543065071105957\n", - "observalbe: No.4\tnumber of Pauli strings: 40000\ttime: 0.054796457290649414\n", - "observalbe: No.5\tnumber of Pauli strings: 40000\ttime: 0.05472278594970703\n", - "observalbe: No.6\tnumber of Pauli strings: 40000\ttime: 0.05406332015991211\n", - "observalbe: No.7\tnumber of Pauli strings: 40000\ttime: 0.05611300468444824\n", - "observalbe: No.8\tnumber of Pauli strings: 40000\ttime: 0.053575754165649414\n", - "observalbe: No.9\tnumber of Pauli strings: 40000\ttime: 0.053929805755615234\n", - "observalbe: No.0\tnumber of Pauli strings: 50000\ttime: 1.017702579498291\n", - "observalbe: No.1\tnumber of Pauli strings: 50000\ttime: 0.06368756294250488\n", - "observalbe: No.2\tnumber of Pauli strings: 50000\ttime: 0.06306672096252441\n", - "observalbe: No.3\tnumber of Pauli strings: 50000\ttime: 0.06530618667602539\n", - "observalbe: No.4\tnumber of Pauli strings: 50000\ttime: 0.06239771842956543\n", - "observalbe: No.5\tnumber of Pauli strings: 50000\ttime: 0.061684608459472656\n", - "observalbe: No.6\tnumber of Pauli strings: 50000\ttime: 0.06061291694641113\n", - "observalbe: No.7\tnumber of Pauli strings: 50000\ttime: 0.06512069702148438\n", - "observalbe: No.8\tnumber of Pauli strings: 50000\ttime: 0.0649871826171875\n", - "observalbe: No.9\tnumber of Pauli strings: 50000\ttime: 0.061399221420288086\n", - "observalbe: No.0\tnumber of Pauli strings: 60000\ttime: 1.0353941917419434\n", - "observalbe: No.1\tnumber of Pauli strings: 60000\ttime: 0.06991219520568848\n", - "observalbe: No.2\tnumber of Pauli strings: 60000\ttime: 0.06446075439453125\n", - "observalbe: No.3\tnumber of Pauli strings: 60000\ttime: 0.06750273704528809\n", - "observalbe: No.4\tnumber of Pauli strings: 60000\ttime: 0.06969285011291504\n", - "observalbe: No.5\tnumber of Pauli strings: 60000\ttime: 0.06952095031738281\n", - "observalbe: No.6\tnumber of Pauli strings: 60000\ttime: 0.06798005104064941\n", - "observalbe: No.7\tnumber of Pauli strings: 60000\ttime: 0.07035303115844727\n", - "observalbe: No.8\tnumber of Pauli strings: 60000\ttime: 0.07007980346679688\n", - "observalbe: No.9\tnumber of Pauli strings: 60000\ttime: 0.06980347633361816\n", - "observalbe: No.0\tnumber of Pauli strings: 70000\ttime: 1.0432231426239014\n", - "observalbe: No.1\tnumber of Pauli strings: 70000\ttime: 0.07599306106567383\n", - "observalbe: No.2\tnumber of Pauli strings: 70000\ttime: 0.07788610458374023\n", - "observalbe: No.3\tnumber of Pauli strings: 70000\ttime: 0.07639884948730469\n", - "observalbe: No.4\tnumber of Pauli strings: 70000\ttime: 0.07813096046447754\n", - "observalbe: No.5\tnumber of Pauli strings: 70000\ttime: 0.07661318778991699\n", - "observalbe: No.6\tnumber of Pauli strings: 70000\ttime: 0.07822918891906738\n", - "observalbe: No.7\tnumber of Pauli strings: 70000\ttime: 0.07674694061279297\n", - "observalbe: No.8\tnumber of Pauli strings: 70000\ttime: 0.0757136344909668\n", - "observalbe: No.9\tnumber of Pauli strings: 70000\ttime: 0.07785511016845703\n", - "observalbe: No.0\tnumber of Pauli strings: 80000\ttime: 1.0459909439086914\n", - "observalbe: No.1\tnumber of Pauli strings: 80000\ttime: 0.08465719223022461\n", - "observalbe: No.2\tnumber of Pauli strings: 80000\ttime: 0.08417797088623047\n", - "observalbe: No.3\tnumber of Pauli strings: 80000\ttime: 0.0836493968963623\n", - "observalbe: No.4\tnumber of Pauli strings: 80000\ttime: 0.08531856536865234\n", - "observalbe: No.5\tnumber of Pauli strings: 80000\ttime: 0.08510899543762207\n", - "observalbe: No.6\tnumber of Pauli strings: 80000\ttime: 0.08687043190002441\n", - "observalbe: No.7\tnumber of Pauli strings: 80000\ttime: 0.08501100540161133\n", - "observalbe: No.8\tnumber of Pauli strings: 80000\ttime: 0.08654212951660156\n", - "observalbe: No.9\tnumber of Pauli strings: 80000\ttime: 0.08644294738769531\n", - "observalbe: No.0\tnumber of Pauli strings: 90000\ttime: 1.052217960357666\n", - "observalbe: No.1\tnumber of Pauli strings: 90000\ttime: 0.09366059303283691\n", - "observalbe: No.2\tnumber of Pauli strings: 90000\ttime: 0.09249377250671387\n", - "observalbe: No.3\tnumber of Pauli strings: 90000\ttime: 0.09362578392028809\n", - "observalbe: No.4\tnumber of Pauli strings: 90000\ttime: 0.09312224388122559\n", - "observalbe: No.5\tnumber of Pauli strings: 90000\ttime: 0.09329438209533691\n", - "observalbe: No.6\tnumber of Pauli strings: 90000\ttime: 0.09333157539367676\n", - "observalbe: No.7\tnumber of Pauli strings: 90000\ttime: 0.09129500389099121\n", - "observalbe: No.8\tnumber of Pauli strings: 90000\ttime: 0.09405040740966797\n", - "observalbe: No.9\tnumber of Pauli strings: 90000\ttime: 0.09431266784667969\n", - "observalbe: No.0\tnumber of Pauli strings: 97920\ttime: 1.0521447658538818\n", - "observalbe: No.1\tnumber of Pauli strings: 97920\ttime: 0.10155749320983887\n", - "observalbe: No.2\tnumber of Pauli strings: 97920\ttime: 0.10006427764892578\n", - "observalbe: No.3\tnumber of Pauli strings: 97920\ttime: 0.10237908363342285\n", - "observalbe: No.4\tnumber of Pauli strings: 97920\ttime: 0.10087108612060547\n", - "observalbe: No.5\tnumber of Pauli strings: 97920\ttime: 0.10074806213378906\n", - "observalbe: No.6\tnumber of Pauli strings: 97920\ttime: 0.10087847709655762\n", - "observalbe: No.7\tnumber of Pauli strings: 97920\ttime: 0.10032892227172852\n", - "observalbe: No.8\tnumber of Pauli strings: 97920\ttime: 0.1014714241027832\n", - "observalbe: No.9\tnumber of Pauli strings: 97920\ttime: 0.10352730751037598\n" + "observable: No.0\tnumber of Pauli strings: 1000\ttime: 0.9454922676086426\n", + "observable: No.1\tnumber of Pauli strings: 1000\ttime: 0.001840353012084961\n", + "observable: No.2\tnumber of Pauli strings: 1000\ttime: 0.0014374256134033203\n", + "observable: No.3\tnumber of Pauli strings: 1000\ttime: 0.0013763904571533203\n", + "observable: No.4\tnumber of Pauli strings: 1000\ttime: 0.0013554096221923828\n", + "observable: No.5\tnumber of Pauli strings: 1000\ttime: 0.0013613700866699219\n", + "observable: No.6\tnumber of Pauli strings: 1000\ttime: 0.0013325214385986328\n", + "observable: No.7\tnumber of Pauli strings: 1000\ttime: 0.0013136863708496094\n", + "observable: No.8\tnumber of Pauli strings: 1000\ttime: 0.0013325214385986328\n", + "observable: No.9\tnumber of Pauli strings: 1000\ttime: 0.0013117790222167969\n", + "observable: No.0\tnumber of Pauli strings: 10000\ttime: 0.9969091415405273\n", + "observable: No.1\tnumber of Pauli strings: 10000\ttime: 0.012966394424438477\n", + "observable: No.2\tnumber of Pauli strings: 10000\ttime: 0.012765884399414062\n", + "observable: No.3\tnumber of Pauli strings: 10000\ttime: 0.012974739074707031\n", + "observable: No.4\tnumber of Pauli strings: 10000\ttime: 0.012665033340454102\n", + "observable: No.5\tnumber of Pauli strings: 10000\ttime: 0.012889623641967773\n", + "observable: No.6\tnumber of Pauli strings: 10000\ttime: 0.013180255889892578\n", + "observable: No.7\tnumber of Pauli strings: 10000\ttime: 0.012682914733886719\n", + "observable: No.8\tnumber of Pauli strings: 10000\ttime: 0.012678146362304688\n", + "observable: No.9\tnumber of Pauli strings: 10000\ttime: 0.012636423110961914\n", + "observable: No.0\tnumber of Pauli strings: 20000\ttime: 1.015674352645874\n", + "observable: No.1\tnumber of Pauli strings: 20000\ttime: 0.025749921798706055\n", + "observable: No.2\tnumber of Pauli strings: 20000\ttime: 0.02578139305114746\n", + "observable: No.3\tnumber of Pauli strings: 20000\ttime: 0.02524733543395996\n", + "observable: No.4\tnumber of Pauli strings: 20000\ttime: 0.025956153869628906\n", + "observable: No.5\tnumber of Pauli strings: 20000\ttime: 0.02669525146484375\n", + "observable: No.6\tnumber of Pauli strings: 20000\ttime: 0.026634931564331055\n", + "observable: No.7\tnumber of Pauli strings: 20000\ttime: 0.026463985443115234\n", + "observable: No.8\tnumber of Pauli strings: 20000\ttime: 0.0273745059967041\n", + "observable: No.9\tnumber of Pauli strings: 20000\ttime: 0.026821374893188477\n", + "observable: No.0\tnumber of Pauli strings: 30000\ttime: 1.0086262226104736\n", + "observable: No.1\tnumber of Pauli strings: 30000\ttime: 0.03922295570373535\n", + "observable: No.2\tnumber of Pauli strings: 30000\ttime: 0.038678884506225586\n", + "observable: No.3\tnumber of Pauli strings: 30000\ttime: 0.03868269920349121\n", + "observable: No.4\tnumber of Pauli strings: 30000\ttime: 0.04024958610534668\n", + "observable: No.5\tnumber of Pauli strings: 30000\ttime: 0.03927755355834961\n", + "observable: No.6\tnumber of Pauli strings: 30000\ttime: 0.039815664291381836\n", + "observable: No.7\tnumber of Pauli strings: 30000\ttime: 0.04002213478088379\n", + "observable: No.8\tnumber of Pauli strings: 30000\ttime: 0.03934764862060547\n", + "observable: No.9\tnumber of Pauli strings: 30000\ttime: 0.04060721397399902\n", + "observable: No.0\tnumber of Pauli strings: 40000\ttime: 1.2912404537200928\n", + "observable: No.1\tnumber of Pauli strings: 40000\ttime: 0.05326724052429199\n", + "observable: No.2\tnumber of Pauli strings: 40000\ttime: 0.05272030830383301\n", + "observable: No.3\tnumber of Pauli strings: 40000\ttime: 0.054486989974975586\n", + "observable: No.4\tnumber of Pauli strings: 40000\ttime: 0.0538792610168457\n", + "observable: No.5\tnumber of Pauli strings: 40000\ttime: 0.05555129051208496\n", + "observable: No.6\tnumber of Pauli strings: 40000\ttime: 0.05361533164978027\n", + "observable: No.7\tnumber of Pauli strings: 40000\ttime: 0.05325675010681152\n", + "observable: No.8\tnumber of Pauli strings: 40000\ttime: 0.05487465858459473\n", + "observable: No.9\tnumber of Pauli strings: 40000\ttime: 0.05441641807556152\n", + "observable: No.0\tnumber of Pauli strings: 50000\ttime: 0.999931812286377\n", + "observable: No.1\tnumber of Pauli strings: 50000\ttime: 0.06137228012084961\n", + "observable: No.2\tnumber of Pauli strings: 50000\ttime: 0.06159329414367676\n", + "observable: No.3\tnumber of Pauli strings: 50000\ttime: 0.06138134002685547\n", + "observable: No.4\tnumber of Pauli strings: 50000\ttime: 0.060491085052490234\n", + "observable: No.5\tnumber of Pauli strings: 50000\ttime: 0.06045842170715332\n", + "observable: No.6\tnumber of Pauli strings: 50000\ttime: 0.0629739761352539\n", + "observable: No.7\tnumber of Pauli strings: 50000\ttime: 0.06146860122680664\n", + "observable: No.8\tnumber of Pauli strings: 50000\ttime: 0.061437129974365234\n", + "observable: No.9\tnumber of Pauli strings: 50000\ttime: 0.061475515365600586\n", + "observable: No.0\tnumber of Pauli strings: 60000\ttime: 1.03033447265625\n", + "observable: No.1\tnumber of Pauli strings: 60000\ttime: 0.06811189651489258\n", + "observable: No.2\tnumber of Pauli strings: 60000\ttime: 0.06913161277770996\n", + "observable: No.3\tnumber of Pauli strings: 60000\ttime: 0.06945395469665527\n", + "observable: No.4\tnumber of Pauli strings: 60000\ttime: 0.06843304634094238\n", + "observable: No.5\tnumber of Pauli strings: 60000\ttime: 0.06950116157531738\n", + "observable: No.6\tnumber of Pauli strings: 60000\ttime: 0.07009696960449219\n", + "observable: No.7\tnumber of Pauli strings: 60000\ttime: 0.06856656074523926\n", + "observable: No.8\tnumber of Pauli strings: 60000\ttime: 0.06969141960144043\n", + "observable: No.9\tnumber of Pauli strings: 60000\ttime: 0.0678703784942627\n", + "observable: No.0\tnumber of Pauli strings: 70000\ttime: 1.0191996097564697\n", + "observable: No.1\tnumber of Pauli strings: 70000\ttime: 0.07705307006835938\n", + "observable: No.2\tnumber of Pauli strings: 70000\ttime: 0.07620859146118164\n", + "observable: No.3\tnumber of Pauli strings: 70000\ttime: 0.07670450210571289\n", + "observable: No.4\tnumber of Pauli strings: 70000\ttime: 0.0766746997833252\n", + "observable: No.5\tnumber of Pauli strings: 70000\ttime: 0.07552027702331543\n", + "observable: No.6\tnumber of Pauli strings: 70000\ttime: 0.07716488838195801\n", + "observable: No.7\tnumber of Pauli strings: 70000\ttime: 0.07647228240966797\n", + "observable: No.8\tnumber of Pauli strings: 70000\ttime: 0.07623863220214844\n", + "observable: No.9\tnumber of Pauli strings: 70000\ttime: 0.07545590400695801\n", + "observable: No.0\tnumber of Pauli strings: 80000\ttime: 1.0341267585754395\n", + "observable: No.1\tnumber of Pauli strings: 80000\ttime: 0.08658909797668457\n", + "observable: No.2\tnumber of Pauli strings: 80000\ttime: 0.08614206314086914\n", + "observable: No.3\tnumber of Pauli strings: 80000\ttime: 0.0857245922088623\n", + "observable: No.4\tnumber of Pauli strings: 80000\ttime: 0.08441877365112305\n", + "observable: No.5\tnumber of Pauli strings: 80000\ttime: 0.08495783805847168\n", + "observable: No.6\tnumber of Pauli strings: 80000\ttime: 0.08582544326782227\n", + "observable: No.7\tnumber of Pauli strings: 80000\ttime: 0.0861966609954834\n", + "observable: No.8\tnumber of Pauli strings: 80000\ttime: 0.08437252044677734\n", + "observable: No.9\tnumber of Pauli strings: 80000\ttime: 0.0852508544921875\n", + "observable: No.0\tnumber of Pauli strings: 90000\ttime: 1.031904697418213\n", + "observable: No.1\tnumber of Pauli strings: 90000\ttime: 0.09243512153625488\n", + "observable: No.2\tnumber of Pauli strings: 90000\ttime: 0.09180665016174316\n", + "observable: No.3\tnumber of Pauli strings: 90000\ttime: 0.09398865699768066\n", + "observable: No.4\tnumber of Pauli strings: 90000\ttime: 0.09126615524291992\n", + "observable: No.5\tnumber of Pauli strings: 90000\ttime: 0.09299516677856445\n", + "observable: No.6\tnumber of Pauli strings: 90000\ttime: 0.09152960777282715\n", + "observable: No.7\tnumber of Pauli strings: 90000\ttime: 0.09381914138793945\n", + "observable: No.8\tnumber of Pauli strings: 90000\ttime: 0.09076142311096191\n", + "observable: No.9\tnumber of Pauli strings: 90000\ttime: 0.08988714218139648\n", + "observable: No.0\tnumber of Pauli strings: 97920\ttime: 1.050750494003296\n", + "observable: No.1\tnumber of Pauli strings: 97920\ttime: 0.09993815422058105\n", + "observable: No.2\tnumber of Pauli strings: 97920\ttime: 0.10038924217224121\n", + "observable: No.3\tnumber of Pauli strings: 97920\ttime: 0.09895133972167969\n", + "observable: No.4\tnumber of Pauli strings: 97920\ttime: 0.09973955154418945\n", + "observable: No.5\tnumber of Pauli strings: 97920\ttime: 0.10170507431030273\n", + "observable: No.6\tnumber of Pauli strings: 97920\ttime: 0.09864187240600586\n", + "observable: No.7\tnumber of Pauli strings: 97920\ttime: 0.09945058822631836\n", + "observable: No.8\tnumber of Pauli strings: 97920\ttime: 0.09991574287414551\n", + "observable: No.9\tnumber of Pauli strings: 97920\ttime: 0.09802794456481934\n" ] }, { "data": { "text/plain": "
", - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -484,7 +484,7 @@ " t = time.time()\n", " if i == bz or i % (bz * 10) == 0 or i >= nps:\n", " print(\n", - " f\"observalbe: No.{j}\\tnumber of Pauli strings: {bzs[-1]}\\ttime: {t - t0}\"\n", + " f\"observable: No.{j}\\tnumber of Pauli strings: {bzs[-1]}\\ttime: {t - t0}\"\n", " )\n", " t0 = t\n", "res = np.asarray(res).T\n", @@ -502,8 +502,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:34:15.672764900Z", - "start_time": "2023-08-09T04:31:41.746108200Z" + "end_time": "2023-08-09T04:53:57.091936Z", + "start_time": "2023-08-09T04:51:25.071809100Z" } } }, @@ -527,22 +527,22 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 20, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "sub: [1, 4]\ttime: 0.18098187446594238\texact: 1.3406660475264627\tshadow entropy: 1.336610480903445\n", - "sub: [2, 7]\ttime: 0.03824925422668457\texact: 1.3490932264001985\tshadow entropy: 1.3509166994806294\n", - "sub: [3, 6]\ttime: 0.038893938064575195\texact: 1.3078555208559692\tshadow entropy: 1.3045157342230482\n", - "sub: [0, 5]\ttime: 0.038709402084350586\texact: 1.3553616203287133\tshadow entropy: 1.3522747747844561\n", - "sub: [7, 0]\ttime: 0.03954339027404785\texact: 1.3698051383654024\tshadow entropy: 1.3692586760254173\n", - "sub: [1, 4, 7]\ttime: 0.2516930103302002\texact: 1.8458514325863924\tshadow entropy: 1.8421843494645114\n", - "sub: [0, 3, 6]\ttime: 0.1100921630859375\texact: 1.868420576333227\tshadow entropy: 1.8660364331174333\n", - "sub: [5, 4, 2]\ttime: 0.11081576347351074\texact: 1.9590510433184192\tshadow entropy: 1.953652327649616\n", - "sub: [7, 2, 5]\ttime: 0.11055541038513184\texact: 1.886694103128951\tshadow entropy: 1.8883320713880314\n", - "sub: [0, 1, 2]\ttime: 0.10973739624023438\texact: 1.8939518969485623\tshadow entropy: 1.893886982107739\n" + "sub: [1, 4]\ttime: 0.1788625717163086\texact: 1.3222456063743848\tshadow entropy: 1.323659494989336\n", + "sub: [2, 7]\ttime: 0.03922629356384277\texact: 1.313932933107046\tshadow entropy: 1.315937416629094\n", + "sub: [3, 6]\ttime: 0.03881263732910156\texact: 1.342032043092265\tshadow entropy: 1.3427963599754822\n", + "sub: [0, 5]\ttime: 0.03893852233886719\texact: 1.3458706554536102\tshadow entropy: 1.346507278883028\n", + "sub: [7, 0]\ttime: 0.039243221282958984\texact: 1.3496695271830874\tshadow entropy: 1.3504498597279848\n", + "sub: [1, 4, 7]\ttime: 0.2567908763885498\texact: 1.8741003653918944\tshadow entropy: 1.8777698830270055\n", + "sub: [0, 3, 6]\ttime: 0.11173439025878906\texact: 1.8633273061204374\tshadow entropy: 1.8638162138941512\n", + "sub: [5, 4, 2]\ttime: 0.11144137382507324\texact: 1.908653965480665\tshadow entropy: 1.9084333256925539\n", + "sub: [7, 2, 5]\ttime: 0.1119997501373291\texact: 1.8916979397866593\tshadow entropy: 1.88828077605345\n", + "sub: [0, 1, 2]\ttime: 0.11184382438659668\texact: 1.8717789129825904\tshadow entropy: 1.8724197548909916\n" ] } ], @@ -580,8 +580,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:34:16.712172300Z", - "start_time": "2023-08-09T04:34:15.672260Z" + "end_time": "2023-08-09T04:53:58.139584Z", + "start_time": "2023-08-09T04:53:57.091936Z" } } }, @@ -603,22 +603,22 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 21, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "sub: [1, 4]\ttime: 3.8456406593322754\tshadow entropy 2: 1.311054830562784\n", - "sub: [2, 7]\ttime: 3.859579086303711\tshadow entropy 2: 1.3140964084640452\n", - "sub: [3, 6]\ttime: 3.8663485050201416\tshadow entropy 2: 1.2798966683162831\n", - "sub: [0, 5]\ttime: 3.8766448497772217\tshadow entropy 2: 1.3276919538959406\n", - "sub: [7, 0]\ttime: 3.8847577571868896\tshadow entropy 2: 1.339702023736642\n", - "sub: [1, 4, 7]\ttime: 3.9610671997070312\tshadow entropy 2: 1.7672210148609153\n", - "sub: [0, 3, 6]\ttime: 3.93074893951416\tshadow entropy 2: 1.7792306674701965\n", - "sub: [5, 4, 2]\ttime: 3.928624153137207\tshadow entropy 2: 1.8506358171662456\n", - "sub: [7, 2, 5]\ttime: 3.930849313735962\tshadow entropy 2: 1.7919769488750392\n", - "sub: [0, 1, 2]\ttime: 3.95222544670105\tshadow entropy 2: 1.7900890411701693\n" + "sub: [1, 4]\ttime: 3.794407606124878\tshadow entropy 2: 1.2866729353788704\n", + "sub: [2, 7]\ttime: 3.796651840209961\tshadow entropy 2: 1.2875279355654872\n", + "sub: [3, 6]\ttime: 3.760688066482544\tshadow entropy 2: 1.314993963087972\n", + "sub: [0, 5]\ttime: 3.765700101852417\tshadow entropy 2: 1.317198599992926\n", + "sub: [7, 0]\ttime: 3.784120559692383\tshadow entropy 2: 1.3218300427352758\n", + "sub: [1, 4, 7]\ttime: 3.859661817550659\tshadow entropy 2: 1.7701671972428563\n", + "sub: [0, 3, 6]\ttime: 3.874009132385254\tshadow entropy 2: 1.7684695179560657\n", + "sub: [5, 4, 2]\ttime: 3.831859827041626\tshadow entropy 2: 1.8037352454314826\n", + "sub: [7, 2, 5]\ttime: 3.824885368347168\tshadow entropy 2: 1.8006117836020135\n", + "sub: [0, 1, 2]\ttime: 3.8377578258514404\tshadow entropy 2: 1.782393800345501\n" ] } ], @@ -641,8 +641,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:34:55.995126500Z", - "start_time": "2023-08-09T04:34:16.712172300Z" + "end_time": "2023-08-09T04:54:36.511330700Z", + "start_time": "2023-08-09T04:53:58.139683500Z" } } }, @@ -666,7 +666,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 22, "outputs": [ { "name": "stdout", @@ -678,35 +678,23 @@ " [0. +0.j 0. +0.j 0. +0.j 0. +0.j]\n", " [0.5+0.j 0. +0.j 0. +0.j 0.5+0.j]]\n", "\n", - "shadow state: error: 0.029270951470698747\n", - " [[ 0.50035 +0.j -0.000615+0.000525j 0.001155-0.005205j\n", - " 0.49455 +0.00243j ]\n", - " [-0.000615-0.000525j -0.00581 +0.j -0.0054 -0.00693j\n", - " 0.004935-0.000345j]\n", - " [ 0.001155+0.005205j -0.0054 +0.00693j -0.01259 +0.j\n", - " 0.001185+0.001245j]\n", - " [ 0.49455 -0.00243j 0.004935+0.000345j 0.001185-0.001245j\n", - " 0.51805 +0.j ]]\n", + "shadow state: error: 0.02441655995426051\n", + " [[ 0.49141+0.j 0.00159+0.00219j 0.00378+0.00306j 0.5004 +0.0081j ]\n", + " [ 0.00159-0.00219j 0.0019 +0.j -0.00855+0.00297j -0.00567-0.00126j]\n", + " [ 0.00378-0.00306j -0.00855-0.00297j 0.00805+0.j -0.00273-0.00249j]\n", + " [ 0.5004 -0.0081j -0.00567+0.00126j -0.00273+0.00249j 0.49864+0.j ]]\n", "\n", - "shadow state 1: error: 0.029270951470698747\n", - " [[ 0.50035 +0.j -0.000615+0.000525j 0.001155-0.005205j\n", - " 0.49455 +0.00243j ]\n", - " [-0.000615-0.000525j -0.00581 +0.j -0.0054 -0.00693j\n", - " 0.004935-0.000345j]\n", - " [ 0.001155+0.005205j -0.0054 +0.00693j -0.01259 +0.j\n", - " 0.001185+0.001245j]\n", - " [ 0.49455 -0.00243j 0.004935+0.000345j 0.001185-0.001245j\n", - " 0.51805 +0.j ]]\n", + "shadow state 1: error: 0.02441655995426051\n", + " [[ 0.49141+0.j 0.00159+0.00219j 0.00378+0.00306j 0.5004 +0.0081j ]\n", + " [ 0.00159-0.00219j 0.0019 +0.j -0.00855+0.00297j -0.00567-0.00126j]\n", + " [ 0.00378-0.00306j -0.00855-0.00297j 0.00805+0.j -0.00273-0.00249j]\n", + " [ 0.5004 -0.0081j -0.00567+0.00126j -0.00273+0.00249j 0.49864+0.j ]]\n", "\n", - "shadow state 2: error: 0.029270951470698747\n", - " [[ 0.50035 +0.j -0.000615+0.000525j 0.001155-0.005205j\n", - " 0.49455 +0.00243j ]\n", - " [-0.000615-0.000525j -0.00581 +0.j -0.0054 -0.00693j\n", - " 0.004935-0.000345j]\n", - " [ 0.001155+0.005205j -0.0054 +0.00693j -0.01259 +0.j\n", - " 0.001185+0.001245j]\n", - " [ 0.49455 -0.00243j 0.004935+0.000345j 0.001185-0.001245j\n", - " 0.51805 +0.j ]]\n" + "shadow state 2: error: 0.02441655995426051\n", + " [[ 0.49141+0.j 0.00159+0.00219j 0.00378+0.00306j 0.5004 +0.0081j ]\n", + " [ 0.00159-0.00219j 0.0019 +0.j -0.00855+0.00297j -0.00567-0.00126j]\n", + " [ 0.00378-0.00306j -0.00855-0.00297j 0.00805+0.j -0.00273-0.00249j]\n", + " [ 0.5004 -0.0081j -0.00567+0.00126j -0.00273+0.00249j 0.49864+0.j ]]\n" ] } ], @@ -739,14 +727,14 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:34:56.136066900Z", - "start_time": "2023-08-09T04:34:55.995632500Z" + "end_time": "2023-08-09T04:54:36.634162200Z", + "start_time": "2023-08-09T04:54:36.517005400Z" } } }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 23, "outputs": [ { "name": "stdout", @@ -781,8 +769,8 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2023-08-09T04:34:56.136066900Z", - "start_time": "2023-08-09T04:34:56.119543900Z" + "end_time": "2023-08-09T04:54:36.638744200Z", + "start_time": "2023-08-09T04:54:36.634714500Z" } } } From d7281c1e33cade06ee5c4aeba7a33cdd7e2788e1 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 9 Aug 2023 15:15:24 +0800 Subject: [PATCH 604/725] Update classical_shadows.ipynb --- docs/source/tutorials/classical_shadows.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index 2166ccae..84a1eb40 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -466,8 +466,7 @@ "source": [ "bz = 1000\n", "\n", - "exact, res = [], []\n", - "exact_expec = c.expectation_ps(ps=ps[0])\n", + "exact = []\n", "for ob in ps:\n", " exact.append(tc.backend.real(c.expectation_ps(ps=ob)))\n", "exact = np.asarray(exact)[:, None]\n", From c5cd133a47e9b3af3a56893b925f9437aa32fc4b Mon Sep 17 00:00:00 2001 From: JachyMeow <114171061+JachyMeow@users.noreply.github.com> Date: Wed, 9 Aug 2023 15:40:23 +0800 Subject: [PATCH 605/725] adjustments & Chinese version --- docs/source/tutorials/nnvqe.ipynb | 12 +- docs/source/tutorials/nnvqe_cn.ipynb | 4015 ++++++++++++++++++++++++++ 2 files changed, 4021 insertions(+), 6 deletions(-) create mode 100644 docs/source/tutorials/nnvqe_cn.ipynb diff --git a/docs/source/tutorials/nnvqe.ipynb b/docs/source/tutorials/nnvqe.ipynb index e0c861cc..ba48f3f3 100644 --- a/docs/source/tutorials/nnvqe.ipynb +++ b/docs/source/tutorials/nnvqe.ipynb @@ -6,7 +6,7 @@ "id": "64ba95d6", "metadata": {}, "source": [ - "#
NN-VQE" + "#
Neural Network encoded Variational Quantum Eigensolver (NN-VQE)" ] }, { @@ -105,7 +105,7 @@ "source": [ "## Ansatz circuit\n", "\n", - "Now we design the circuit. We choose multi-scale entangled renormalization ansatz (MERA) as the ansatz here, $d$ is the circuit depth. (see tutorial of MERA [here](https://tensorcircuit.readthedocs.io/en/latest/tutorials/mera.html))" + "Now we design the circuit. We choose multi-scale entangled renormalization ansatz (MERA) as the ansatz here, $d$ is the circuit depth. (see [MERA tutorial](https://tensorcircuit.readthedocs.io/en/latest/tutorials/mera.html))" ] }, { @@ -2909,7 +2909,7 @@ "source": [ "## NN-VQE\n", "\n", - "Design the NN-VQE. We use a neural network to transform the Hamiltonian parameters to the optimized parameters in the PQC for VQE." + "Design the NN-VQE. We use a neural network to transform the Hamiltonian parameters to the optimized parameters in the parameterized quantum circuit (PQC) for VQE." ] }, { @@ -3062,7 +3062,7 @@ "test_delta = np.linspace(-4.0, 4.0, 201) # test set\n", "test_energies = tf.zeros_like(test_delta).numpy()\n", "m = NN_MERA(n, d, lamb, NN_shape, stddev)\n", - "m.load_weights(\"DNN-MERA_2[20](-3.0,3.0,20)_drop05.weights.h5\")\n", + "m.load_weights(\"NN-VQE.weights.h5\")\n", "for i, de in tqdm(enumerate(test_delta)):\n", " test_energies[i] = m(K.reshape(de, [1]))" ] @@ -3074,7 +3074,7 @@ "source": [ "## Compare\n", "\n", - "We compare the results of NN-VQE with the analytical ones to calculate the ground-state relative error. From the figure, we can see that NN-VQE is able to estimate the ground-state energies of parameterized Hamiltonians with high precision without fine-tuning and has a favorable generalization capability." + "We compare the results of NN-VQE with the analytical ones to calculate the ground-state energy relative error. From the figure, we can see that NN-VQE is able to estimate the ground-state energies of parameterized Hamiltonians with high precision without fine-tuning and has a favorable generalization capability." ] }, { @@ -3982,7 +3982,7 @@ "id": "5f9bda8a", "metadata": {}, "source": [ - "To get more detailed information or further study, please refer to [our paper](https://arxiv.org/abs/2308.01068) and [GitHub](https://github.com/JachyMeow/NN-VQA)." + "To get more detailed information or further study, please refer to our [paper](https://arxiv.org/abs/2308.01068) and [GitHub](https://github.com/JachyMeow/NN-VQA)." ] } ], diff --git a/docs/source/tutorials/nnvqe_cn.ipynb b/docs/source/tutorials/nnvqe_cn.ipynb new file mode 100644 index 00000000..056990bb --- /dev/null +++ b/docs/source/tutorials/nnvqe_cn.ipynb @@ -0,0 +1,4015 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "64ba95d6", + "metadata": {}, + "source": [ + "#
神经网络编码的变分量子本征值求解器（NN-VQE）" + ] + }, + { + "cell_type": "markdown", + "id": "b65f64bf", + "metadata": {}, + "source": [ + "## 概述\n", + "\n", + "在本教程中，我们将使用TensorCircuit展示一个量子计算通用框架——神经网络编码的变分量子算法（neural network encoded variational quantum algorithms，NN-VQAs）。NN-VQA将一个给定问题的参量（如哈密顿量的参数）作为神经网络的输入，并使用其输出来参数化标准的变分量子算法（variational quantum algorithms，VQAs）的线路拟设（ansatz circuit）。在本文中，我们以神经网络编码的变分量子本征值求解器（NN-variational quantum eigensolver，NN-VQE）来具体说明。" + ] + }, + { + "cell_type": "markdown", + "id": "831930ae", + "metadata": {}, + "source": [ + "## 设置" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4e1651b9", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "import tensorcircuit as tc\n", + "import cotengra\n", + "import quimb\n", + "from tqdm.notebook import tqdm\n", + "from functools import partial\n", + "\n", + "optc = cotengra.ReusableHyperOptimizer(\n", + " methods=[\"greedy\"],\n", + " parallel=\"ray\",\n", + " minimize=\"combo\",\n", + " max_time=30,\n", + " max_repeats=1024,\n", + " progbar=True,\n", + ")\n", + "tc.set_contractor(\"custom\", optimizer=optc, preprocessing=True)\n", + "\n", + "K = tc.set_backend(\"tensorflow\")\n", + "tc.set_dtype(\"complex128\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "d78b480b", + "metadata": {}, + "source": [ + "## 能量\n", + "\n", + "本教程所使用的哈密顿量是具有周期性边界条件的一维XXZ伊辛模型。它具有横向场强$\\lambda$和各向异性参数$\\Delta$。我们选择哈密顿量的能量期望函数作为损失函数。\n", + "\n", + "$$ \\hat{H}_{XXZ}=\\sum_{i}{ \\left( X_{i}X_{i+1}+Y_{i}Y_{i+1}+\\Delta Z_{i}Z_{i+1} \\right) } + \\lambda \\sum_{i}{Z_{i}} $$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fff67346", + "metadata": {}, + "outputs": [], + "source": [ + "def energy(c: tc.Circuit, lamb: float = 1.0, delta: float = 1.0):\n", + " e = 0.0\n", + " n = c._nqubits\n", + " for i in range(n):\n", + " e += lamb * c.expectation((tc.gates.z(), [i])) # \n", + " for i in range(n):\n", + " e += c.expectation(\n", + " (tc.gates.x(), [i]), (tc.gates.x(), [(i + 1) % n])\n", + " ) # \n", + " e += c.expectation(\n", + " (tc.gates.y(), [i]), (tc.gates.y(), [(i + 1) % n])\n", + " ) # \n", + " e += delta * c.expectation(\n", + " (tc.gates.z(), [i]), (tc.gates.z(), [(i + 1) % n])\n", + " ) # \n", + " return K.real(e)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0ad6a7a6", + "metadata": {}, + "source": [ + "## 线路拟设\n", + "\n", + "现在我们来设计线路。我们选择多尺度纠缠重整化拟设（multi-scale entangled renormalization ansatz，MERA）作为线路拟设，其中$d$为线路深度。（详见[MERA教程](https://tensorcircuit.readthedocs.io/zh/latest/tutorials/mera_cn.html)）" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "445b7c86", + "metadata": {}, + "outputs": [], + "source": [ + "def MERA(\n", + " inp, n, d=1, lamb=1.0, energy_flag=False\n", + "): # 对于单变量一维XXZ模型，我们固定lamb\n", + " params = K.cast(inp[\"params\"], \"complex128\")\n", + " delta = K.cast(inp[\"delta\"], \"complex128\")\n", + " c = tc.Circuit(n)\n", + "\n", + " idx = 0\n", + "\n", + " for i in range(n):\n", + " c.rx(i, theta=params[3 * i])\n", + " c.rz(i, theta=params[3 * i + 1])\n", + " c.rx(i, theta=params[3 * i + 2])\n", + " idx += 3 * n\n", + "\n", + " for n_layer in range(1, int(np.log2(n)) + 1):\n", + " n_qubit = 2**n_layer # 涉及的量子比特数\n", + " step = int(n / n_qubit)\n", + "\n", + " for _ in range(d): # 线路深度\n", + " # 偶数层\n", + " for i in range(step, n - step, 2 * step):\n", + " c.rxx(i, i + step, theta=params[idx])\n", + " c.rzz(i, i + step, theta=params[idx + 1])\n", + " idx += 2\n", + "\n", + " # 奇数层\n", + " for i in range(0, n, 2 * step):\n", + " c.rxx(i, i + step, theta=params[idx])\n", + " c.rzz(i, i + step, theta=params[idx + 1])\n", + " idx += 2\n", + "\n", + " # 单比特门\n", + " for i in range(0, n, step):\n", + " c.rx(i, theta=params[idx])\n", + " c.rz(i, theta=params[idx + 1])\n", + " idx += 2\n", + "\n", + " if energy_flag:\n", + " return energy(c, lamb, delta) # 返回哈密顿量的能量期望\n", + " else:\n", + " return c, idx # 返回线路&线路参量数" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6daa2f64", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number of parameters is 74\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-08-06T16:31:47.918946\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.3, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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" + ], + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 线路可视化\n", + "n = 8\n", + "d = 1\n", + "cirq, idx = MERA({\"params\": np.zeros(3000), \"delta\": 0.0}, n, d, 1.0)\n", + "print(\"The number of parameters is\", idx)\n", + "cirq.draw()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "bfe2fbee", + "metadata": {}, + "source": [ + "## NN-VQE\n", + "\n", + "设计NN-VQE。我们使用神经网络将哈密顿量参数转换为VQE的变分量子线路（parameterized quantum ciecuit，PQC）的优化参数。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1ac050a8", + "metadata": {}, + "outputs": [], + "source": [ + "def NN_MERA(n, d, lamb, NN_shape, stddev):\n", + " input = tf.keras.layers.Input(shape=[1]) # 输入层\n", + "\n", + " x = tf.keras.layers.Dense(\n", + " units=NN_shape,\n", + " kernel_initializer=tf.keras.initializers.RandomNormal(stddev=stddev),\n", + " activation=\"ReLU\",\n", + " )(\n", + " input\n", + " ) # 隐层\n", + "\n", + " x = tf.keras.layers.Dropout(0.05)(x) # dropout层\n", + "\n", + " _, idx = MERA(\n", + " {\"params\": np.zeros(3000), \"delta\": 0.0}, n, d, 1.0, energy_flag=False\n", + " )\n", + " params = tf.keras.layers.Dense(\n", + " units=idx,\n", + " kernel_initializer=tf.keras.initializers.RandomNormal(stddev=stddev),\n", + " activation=\"sigmoid\",\n", + " )(\n", + " x\n", + " ) # 输出层\n", + "\n", + " qlayer = tc.KerasLayer(partial(MERA, n=n, d=d, lamb=lamb, energy_flag=True)) # PQC\n", + "\n", + " output = qlayer({\"params\": 6.3 * params, \"delta\": input}) # NN-VQE输出\n", + "\n", + " m = tf.keras.Model(inputs=input, outputs=output)\n", + "\n", + " return m" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "e9afb1a5", + "metadata": {}, + "source": [ + "## 训练\n", + "\n", + "现在我们用TensorFlow来训练NN-VQE。" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "873ebd5e", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "def train(n, d, lamb, delta, NN_shape, maxiter=10000, lr=0.005, stddev=1.0):\n", + " exp_lr = tf.keras.optimizers.schedules.ExponentialDecay(\n", + " initial_learning_rate=lr, decay_steps=1000, decay_rate=0.7\n", + " )\n", + " opt = tf.keras.optimizers.Adam(exp_lr) # 优化器\n", + "\n", + " m = NN_MERA(n, d, lamb, NN_shape, stddev)\n", + " for i in range(maxiter):\n", + " with tf.GradientTape() as tape:\n", + " e = tf.zeros([1], dtype=tf.float64)\n", + " for de in delta:\n", + " e += m(K.reshape(de, [1])) # 将所有训练点的能量相加\n", + " grads = tape.gradient(e, m.variables)\n", + " opt.apply_gradients(zip(grads, m.variables))\n", + " if i % 500 == 0:\n", + " print(\"epoch\", i, \":\", e)\n", + "\n", + " m.save_weights(\"NN-VQE.weights.h5\") # 保存已训练的模型" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e8df3d67", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 0 : tf.Tensor([[117.53523392]], shape=(1, 1), dtype=float64)\n", + "epoch 500 : tf.Tensor([[-361.85937039]], shape=(1, 1), dtype=float64)\n", + "epoch 1000 : tf.Tensor([[-365.35288984]], shape=(1, 1), dtype=float64)\n", + "epoch 1500 : tf.Tensor([[-366.65891358]], shape=(1, 1), dtype=float64)\n", + "epoch 2000 : tf.Tensor([[-366.94258369]], shape=(1, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "n = 8 # 量子比特数\n", + "d = 2 # 线路深度\n", + "lamb = 0.75 # 固定参数\n", + "delta = np.linspace(-3.0, 3.0, 20, dtype=\"complex128\") # 训练集\n", + "NN_shape = 20 # 隐层节点数\n", + "maxiter = 2500 # 最大迭代轮数\n", + "lr = 0.009 # 学习率\n", + "stddev = 0.1 # 神经网络参数初始值的标准差\n", + "\n", + "with tf.device(\"/cpu:0\"):\n", + " train(n, d, lamb, delta, NN_shape=NN_shape, maxiter=maxiter, lr=lr, stddev=stddev)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c5a7cdb0", + "metadata": {}, + "source": [ + "## 测试\n", + "\n", + "我们使用较训练集更大的测试集来测试NN-VQE的准确性和泛化能力。" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "f15f4f68", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4a3ceb8bdf90463f88050b771fde6925", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_delta = np.linspace(-4.0, 4.0, 201) # 测试集\n", + "test_energies = tf.zeros_like(test_delta).numpy()\n", + "m = NN_MERA(n, d, lamb, NN_shape, stddev)\n", + "m.load_weights(\"NN-VQE.weights.h5\")\n", + "for i, de in tqdm(enumerate(test_delta)):\n", + " test_energies[i] = m(K.reshape(de, [1]))" + ] + }, + { + "cell_type": "markdown", + "id": "924027f8", + "metadata": {}, + "source": [ + "## 对比\n", + "\n", + "我们将NN-VQE的结果与解析解相比，计算基态能量相对误差。从图中可以看出，NN-VQE能够在无微调（fine-tuning）的情况下准确估计参数化哈密顿量的基态能量，且具有良好的泛化能力。" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "c8668a13", + "metadata": {}, + "outputs": [], + "source": [ + "analytical_energies = [] # 解析解\n", + "for i in test_delta:\n", + " h = quimb.tensor.tensor_builder.MPO_ham_XXZ(\n", + " n, i * 4, jxy=4.0, bz=2.0 * 0.75, S=0.5, cyclic=True\n", + " )\n", + " h = h.to_dense()\n", + " analytical_energies.append(np.min(quimb.eigvalsh(h)))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "42799e3e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-08-06T23:44:26.082098\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.3, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + " \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", + " \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" + ], + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 基态能量相对误差\n", + "plt.plot(\n", + " test_delta,\n", + " (test_energies - analytical_energies) / np.abs(analytical_energies),\n", + " \"-\",\n", + " color=\"b\",\n", + ")\n", + "plt.xlabel(\"Delta\", fontsize=14)\n", + "plt.ylabel(\"GS Relative Error\", fontsize=14)\n", + "plt.axvspan(-3.0, 3.0, color=\"darkgrey\", alpha=0.5) # 训练集区间\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5f9bda8a", + "metadata": {}, + "source": [ + "想要获得更详细的信息或进一步的研究，请参考我们的[论文](https://arxiv.org/abs/2308.01068)和[GitHub](https://github.com/JachyMeow/NN-VQA)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.9.12" + }, + "vscode": { + "interpreter": { + "hash": "18d2a9923f839b0d86cf68fd09770e726264cf9d62311eaf57b1fff0ca4bed8e" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 00f94ccbb9ff8111d0af38daf639e7b50b6c95ba Mon Sep 17 00:00:00 2001 From: JachyMeow <114171061+JachyMeow@users.noreply.github.com> Date: Wed, 9 Aug 2023 15:43:34 +0800 Subject: [PATCH 606/725] black --- docs/source/tutorials/nnvqe_cn.ipynb | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/docs/source/tutorials/nnvqe_cn.ipynb b/docs/source/tutorials/nnvqe_cn.ipynb index 056990bb..df6e0871 100644 --- a/docs/source/tutorials/nnvqe_cn.ipynb +++ b/docs/source/tutorials/nnvqe_cn.ipynb @@ -115,9 +115,7 @@ "metadata": {}, "outputs": [], "source": [ - "def MERA(\n", - " inp, n, d=1, lamb=1.0, energy_flag=False\n", - "): # 对于单变量一维XXZ模型，我们固定lamb\n", + "def MERA(inp, n, d=1, lamb=1.0, energy_flag=False): # 对于单变量一维XXZ模型，我们固定lamb\n", " params = K.cast(inp[\"params\"], \"complex128\")\n", " delta = K.cast(inp[\"delta\"], \"complex128\")\n", " c = tc.Circuit(n)\n", From b18c046b1636bff32bca58cbbf22f748d3186d76 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Wed, 9 Aug 2023 17:00:42 +0800 Subject: [PATCH 607/725] Update classical_shadows.ipynb --- docs/source/tutorials/classical_shadows.ipynb | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index 84a1eb40..3307d99e 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -21,7 +21,7 @@ { "cell_type": "markdown", "source": [ - "[Classical shadows](https://www.nature.com/articles/s41567-020-0932-7) formalism is an efficient method to estimate multiple observables. In this tutorial, we will show how to use the `shadows` module in `TensorCircuit` to implement classic shadows in Pauli basis." + "[Classical shadows](https://www.nature.com/articles/s41567-020-0932-7) formalism is an efficient method to estimate multiple observables. In this tutorial, we will show how to use the ``shadows`` module in ``TensorCircuit`` to implement classic shadows in Pauli basis." ], "metadata": { "collapsed": false @@ -134,14 +134,14 @@ { "cell_type": "markdown", "source": [ - "We first set the number of qubits $n$ and the number of repeated measurements $r$ on each Pauli string. Then from the target observable Pauli strings $\\{O_i|i=1,\\cdots,M\\}$ (0, 1, 2, and 3 correspond to $\\mathbb{I}$, $X$, $Y$, and $Z$, respectively), the error $\\epsilon$ and the rate of failure $\\delta$, we can use `shadow_bound` function to get the total number of snapshots $N$ and the number of equal parts $K$ to split the shadow snapshot states to compute the median of means:\n", + "We first set the number of qubits $n$ and the number of repeated measurements $r$ on each Pauli string. Then from the target observable Pauli strings $\\{O_i|i=1,\\cdots,M\\}$ (0, 1, 2, and 3 correspond to $\\mathbb{I}$, $X$, $Y$, and $Z$, respectively), the error $\\epsilon$ and the rate of failure $\\delta$, we can use ``shadow_bound`` function to get the total number of snapshots $N$ and the number of equal parts $K$ to split the shadow snapshot states to compute the median of means:\n", "$$\n", "\\begin{eqnarray}\n", " K&=&2\\log(2M/\\delta),\\\\\n", " N&=&K\\frac{34}{\\epsilon^2}\\max_{1\\le i\\le M}\\left\\|O_i-\\frac{\\text{Tr}(O_i)}{2^n}\\mathbb{I}\\right\\|^2_{\\text{shadow}}=K\\frac{34}{\\epsilon^2}3^{\\max_{1\\le i\\le M}k_i},\n", "\\end{eqnarray}\n", "$$\n", - "where $k_i$ is the number of nontrivial Pauli matrices in $O_i$. Please refer to the Theorem S1 and Lemma S3 in [Huang, Kueng and Preskill (2020)](https://www.nature.com/articles/s41567-020-0932-7) for the details of proof. It should be noted that `shadow_bound` has a certain degree of overestimation of $N$, and so many measurements are not really needed in practice. And `shadow_bound` is not jitable and no need to jit." + "where $k_i$ is the number of nontrivial Pauli matrices in $O_i$. Please refer to the Theorem S1 and Lemma S3 in [Huang, Kueng and Preskill (2020)](https://www.nature.com/articles/s41567-020-0932-7) for the details of proof. It should be noted that ``shadow_bound`` has a certain degree of overestimation of $N$, and so many measurements are not really needed in practice. Moreover, ``shadow_bound`` is not jitable and no need to jit." ], "metadata": { "collapsed": false @@ -226,7 +226,7 @@ { "cell_type": "markdown", "source": [ - "We randomly generate Pauli strings. Since the function after just-in-time (jit) compilation does not support random sampling, we need to generate all random states in advance, that is, variable `status`." + "We randomly generate Pauli strings. Since the function after just-in-time (jit) compilation does not support random sampling, we need to generate all random states in advance, that is, variable ``status``." ], "metadata": { "collapsed": false @@ -251,7 +251,7 @@ { "cell_type": "markdown", "source": [ - "If `measurement_only`=True, the outputs of `shadow_snapshots` are snapshot bit strings $b=s_1\\cdots s_n,\\ s_j\\in\\{0,1\\}$, otherwise the outputs are snapshot states $\\{u_{j}^{\\dagger}|s_j\\rangle\\langle s_j| u_j\\ |j=1,\\cdots,n\\}$. If you only need to generate one batch of snapshots or generate multiple batches of snapshots with different `nps` or `r`, jit cannot provide speedup. JIT will only accelerate when the same shape of snapshots are generated multiple times." + "If ``measurement_only=True`` (default ``False``), the outputs of ``shadow_snapshots`` are snapshot bit strings $b=s_1\\cdots s_n,\\ s_j\\in\\{0,1\\}$, otherwise the outputs are snapshot states $\\{u_{j}^{\\dagger}|s_j\\rangle\\langle s_j| u_j\\ |j=1,\\cdots,n\\}$. If you only need to generate one batch of snapshots or generate multiple batches of snapshots with different ``nps`` or ``r``, jit cannot provide speedup. JIT will only accelerate when the same shape of snapshots are generated multiple times." ], "metadata": { "collapsed": false @@ -300,7 +300,7 @@ { "cell_type": "markdown", "source": [ - "Since the operation of taking the median is not jitable, the outputs of `expectation_ps_shadows` have $K$ values, and we need to take the median of them." + "Since the operation of taking the median is not jitable, the outputs of ``expectation_ps_shadows`` have $K$ values, and we need to take the median of them." ], "metadata": { "collapsed": false @@ -328,7 +328,7 @@ { "cell_type": "markdown", "source": [ - "It can be seen from the running time that every time the number of Pauli strings changes, `shadow_expec` will be recompiled, but for the same number of Pauli strings but different observables, `shadow_expec` will only be compiled once. In the end, the absolute errors given by classical shadows are much smaller than the $\\epsilon=0.1$ we set, so `shadow_bound` gives a very loose upper bound." + "It can be seen from the running time that every time the number of Pauli strings changes, ``shadow_expec`` will be recompiled, but for the same number of Pauli strings but different observables, ``shadow_expec`` will only be compiled once. In the end, the absolute errors given by classical shadows are much smaller than the $\\epsilon=0.1$ we set, so ``shadow_bound`` gives a very loose upper bound." ], "metadata": { "collapsed": false @@ -518,7 +518,7 @@ { "cell_type": "markdown", "source": [ - "We can also use classical shadows to calculate entanglement entropy. `entropy_shadow` first reconstructs the reduced density matrix, then solves the eigenvalues and finally calculates the entanglement entropy from non-negative eigenvalues. Since the time and space complexity of reconstructing the density matrix is exponential with respect to the system size, this method is only efficient when the reduced system size is constant. `entropy_shadow` is jitable, but it will only accelerate when the reduced sub systems have the same shape." + "We can also use classical shadows to calculate entanglement entropy. ``entropy_shadow`` first reconstructs the reduced density matrix, then solves the eigenvalues and finally calculates the entanglement entropy from non-negative eigenvalues. Since the time and space complexity of reconstructing the density matrix is exponential with respect to the system size, this method is only efficient when the reduced system size is constant. ``entropy_shadow`` is jitable, but it will only accelerate when the reduced sub systems have the same shape." ], "metadata": { "collapsed": false @@ -594,7 +594,7 @@ " \\text{Tr}(\\rho_A^2)&=&2^k\\sum_{b,b'\\in\\{0,1\\}^k}(-2)^{-H(b,b')}\\overline{P(b)P(b')},\n", "\\end{eqnarray}\n", "$$\n", - "where $A$ is the $k$-d reduced system, $H(b,b')$ is the Hamming distance between $b$ and $b'$, $P(b)$ is the probability for measuring $\\rho_A$ and obtaining the outcomes $b$ thus we need a larger $r$ to obtain a good enough priori probability, and the overline means the average on all random selected Pauli strings. Please refer to [Brydges, et al. (2019)](https://www.science.org/doi/full/10.1126/science.aau4963) for more details. We can use `renyi_entropy_2` to implement this method, but it is not jitable because we need to build the dictionary based on the bit strings obtained by measurements, which is a dynamical process. Compared with `entropy_shadow`, it cannot filter out non-negative eigenvalues, so the accuracy is slightly worse." + "where $A$ is the $k$-d reduced system, $H(b,b')$ is the Hamming distance between $b$ and $b'$, $P(b)$ is the probability for measuring $\\rho_A$ and obtaining the outcomes $b$ thus we need a larger $r$ to obtain a good enough priori probability, and the overline means the average on all random selected Pauli strings. Please refer to [Brydges, et al. (2019)](https://www.science.org/doi/full/10.1126/science.aau4963) for more details. We can use ``renyi_entropy_2`` to implement this method, but it is not jitable because we need to build the dictionary based on the bit strings obtained by measurements, which is a dynamical process. Compared with ``entropy_shadow``, it cannot filter out non-negative eigenvalues, so the accuracy is slightly worse." ], "metadata": { "collapsed": false @@ -657,7 +657,7 @@ { "cell_type": "markdown", "source": [ - "We can use `global_shadow_state`, `global_shadow_state1` or `global_shadow_state2` to reconstruct the density matrix. These three functions use different methods, but the results are exactly the same. All functions are jitable, but since we only use each of them once here, they are not wrapped. In terms of implementation details, `global_shadow_state` uses `kron` and is recommended, the other two use `einsum`." + "We can use ``global_shadow_state``, ``global_shadow_state1`` or ``global_shadow_state2`` to reconstruct the density matrix. These three functions use different methods, but the results are exactly the same. All functions are jitable, but since we only use each of them once here, they are not wrapped. In terms of implementation details, ``global_shadow_state`` uses ``kron`` and is recommended, the other two use ``einsum``." ], "metadata": { "collapsed": false From fc4fd41843c175e3fded7f9573ca841f833eeb9b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 10 Aug 2023 16:32:43 +0800 Subject: [PATCH 608/725] update ref in readme --- README.md | 6 ++++++ README_cn.md | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/README.md b/README.md index c8843fb2..7c4405bd 100644 --- a/README.md +++ b/README.md @@ -334,6 +334,12 @@ For the numerical simulation and hardware experiments with error mitigation on Q Reference paper: https://arxiv.org/abs/2303.14877. +### NN-VQA + +For the setup and simulation code of neural network encoded variational quantum eigensolver, see the [demo](/docs/source/tutorials/nnvqe.ipynb). + +Reference paper: https://arxiv.org/abs/2308.01068. + ### More works
diff --git a/README_cn.md b/README_cn.md index 80f93107..56ac6c5c 100644 --- a/README_cn.md +++ b/README_cn.md @@ -184,3 +184,9 @@ VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mb 数值模拟和带错误消除的真实量子硬件实验验证 QAOA 优化的代码请参考 [项目](https://github.com/sherrylixuecheng/EMQAOA-DARBO)。 参考论文: https://arxiv.org/abs/2303.14877。 + +### NN-VQA + +关于神经网络编码的变分量子算法的实现和工作流, 见 [教程](/docs/source/tutorials/nnvqe.ipynb)。 + +参考论文: https://arxiv.org/abs/2308.01068。 From c7d918f53639c855fcca8172e67e9248ecc4e4cc Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 10 Aug 2023 17:02:42 +0800 Subject: [PATCH 609/725] fix tf cast warnings --- CHANGELOG.md | 8 +++++++- README.md | 2 ++ tensorcircuit/backends/tensorflow_backend.py | 4 ++++ 3 files changed, 13 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9ceeb976..14e58497 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,13 +16,19 @@ - Add end to end infrastructures and methods for classical shadow in `shadows.py` +- Add classical shadow tutorial + +- Add NN-VQE tutorial + ### Fixed - improve the `adaptive_vmap` to support internal jit and pytree output -- fix `pauli_gates` dtype unchange issue when set new dtype (not recommend to use this property) +- fix `pauli_gates` dtype unchange issue when set new dtype (not recommend to use this attr anymore) - fix rem `apply_correction` bug when non-numpy backend is set + +- fix tf warning for `cast` with higher version of tf ### Changed - The static method `BaseCircuit.copy` is renamed as `BaseCircuit.copy_nodes` (breaking changes) diff --git a/README.md b/README.md index 7c4405bd..5dcdbbde 100644 --- a/README.md +++ b/README.md @@ -205,6 +205,8 @@ We also have [Docker support](/docker). - Reusable common circuit/measurement/problem templates and patterns. + - Jittable classical shadow infrastructures. + - SOTA quantum algorithm and model implementations. - Support hybrid workflows and pipelines with CPU/GPU/QPU hardware from local/cloud/hpc resources using tf/torch/jax/cupy/numpy frameworks all at the same time. diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 9c19ceca..91b6be6e 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -4,6 +4,7 @@ # pylint: disable=invalid-name import os +import re from functools import reduce, partial from operator import mul from typing import Any, Callable, Optional, Sequence, Tuple, Union @@ -378,6 +379,9 @@ def __init__(self) -> None: tf.sparse.SparseTensor.__add__ = tf.sparse.add self.minor = int(tf.__version__.split(".")[1]) self.name = "tensorflow" + logger = tf.get_logger() # .setLevel('ERROR') + logger.addFilter(lambda s: not re.match(".*You are casting.*", s.getMessage())) + # ignore casting warning by logger def eye( self, N: int, dtype: Optional[str] = None, M: Optional[int] = None From 6c9e6cbb25b457243033a366e3f9c85f20615952 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 11 Aug 2023 11:09:25 +0800 Subject: [PATCH 610/725] take the classical shadow tutorial out --- docs/source/tutorial.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index 0fbf075d..37fd287a 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -25,6 +25,5 @@ Jupyter Tutorials tutorials/barren_plateaus.ipynb tutorials/qaoa_portfolio_optimization.ipynb tutorials/imag_time_evo.ipynb - tutorials/classical_shadows.ipynb tutorials/sklearn_svc.ipynb tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file From 318b32440911d0f88ad3cf4e1a1a8fdaae35e361 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sun, 13 Aug 2023 16:50:47 +0800 Subject: [PATCH 611/725] Update classical_shadows.ipynb and imag_time_evo.ipynb --- docs/source/tutorial.rst | 1 + docs/source/tutorials/classical_shadows.ipynb | 37 +++++++++++-------- docs/source/tutorials/imag_time_evo.ipynb | 15 ++++++-- 3 files changed, 35 insertions(+), 18 deletions(-) diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index 37fd287a..0fbf075d 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -25,5 +25,6 @@ Jupyter Tutorials tutorials/barren_plateaus.ipynb tutorials/qaoa_portfolio_optimization.ipynb tutorials/imag_time_evo.ipynb + tutorials/classical_shadows.ipynb tutorials/sklearn_svc.ipynb tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index 3307d99e..610b474e 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -78,28 +78,28 @@ "$$\n", "where\n", "$$\n", - "\\begin{equation}\n", - " \\begin{split}\n", - " \\langle O_{(k)}\\rangle&=\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\text{Tr}\\left[\\bigotimes_{j=1}^{n}P_j(3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I})\\right]\\\\\n", - " &=\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\prod_{j=1}^n\\text{Tr}\\left[3P_j u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}\\right].\n", - " \\end{split}\n", - "\\end{equation}\n", + "\\begin{eqnarray}\n", + " \\langle O_{(k)}\\rangle&=&\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\text{Tr}\\left[\\bigotimes_{j=1}^{n}P_j(3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I})\\right]\\\\\n", + " &=&\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\prod_{j=1}^n\\text{Tr}\\left[3P_j u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}\\right].\n", + "\\end{eqnarray}\n", "$$" ], "metadata": { "collapsed": false } }, + { + "cell_type": "markdown", + "source": [ + "## Setup" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": 13, - "metadata": { - "collapsed": true, - "ExecuteTime": { - "end_time": "2023-08-09T04:51:21.649753Z", - "start_time": "2023-08-09T04:51:21.598273400Z" - } - }, "outputs": [ { "data": { @@ -120,7 +120,14 @@ "\n", "tc.set_backend(\"jax\")\n", "tc.set_dtype(\"complex128\")" - ] + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-08-09T04:51:21.649753Z", + "start_time": "2023-08-09T04:51:21.598273400Z" + } + } }, { "cell_type": "markdown", @@ -590,7 +597,7 @@ "On the other hand, for the second order Renyi entropy, we have another method to calculate it in polynomial time by random measurements:\n", "$$\n", "\\begin{eqnarray}\n", - " S_2&=&-\\log\\left(\\text{Tr}(\\rho_A^2)\\right),\\\\\n", + " R_A^2&=&-\\log\\left(\\text{Tr}(\\rho_A^2)\\right),\\\\\n", " \\text{Tr}(\\rho_A^2)&=&2^k\\sum_{b,b'\\in\\{0,1\\}^k}(-2)^{-H(b,b')}\\overline{P(b)P(b')},\n", "\\end{eqnarray}\n", "$$\n", diff --git a/docs/source/tutorials/imag_time_evo.ipynb b/docs/source/tutorials/imag_time_evo.ipynb index 752b485f..c93a814b 100644 --- a/docs/source/tutorials/imag_time_evo.ipynb +++ b/docs/source/tutorials/imag_time_evo.ipynb @@ -75,6 +75,15 @@ "collapsed": false } }, + { + "cell_type": "markdown", + "source": [ + "## Setup" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": null, @@ -414,7 +423,7 @@ { "cell_type": "markdown", "source": [ - "We use two methods to calculate $\\boldsymbol{\\delta}$, one is to calculate directly according to the expressions of $\\boldsymbol{A}$ and $\\boldsymbol{C}$, and the other is to call the existing API to calculate $\\boldsymbol{A}$ and $\\boldsymbol{C}$. The former only needs to calculate the $|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle$ once, while the latter needs to calculate that twice, but the code of the latter is more concise. In each method, we set the parameter fixed_global_phase to decide whether to fix the global phase, that is, whether the second term of $\\boldsymbol{A}$ vanishes.\n", + "We use two methods to calculate $\\boldsymbol{\\delta}$, one is to calculate directly according to the expressions of $\\boldsymbol{A}$ and $\\boldsymbol{C}$, and the other is to call the existing API to calculate $\\boldsymbol{A}$ and $\\boldsymbol{C}$. The former only needs to calculate the $|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle$ once, while the latter needs to calculate that twice, but the code of the latter is more concise. In each method, we set the parameter ``fixed_global_phase`` to decide whether to fix the global phase, that is, whether the second term of $\\boldsymbol{A}$ vanishes.\n", "\n", "Then we choose the existing optimizer, SGD, to implement the update step. Since compared with naive gradient descent, the approximate imaginary-time evolution has been corrected on the update step size, the adaptive optimizer improved for the naive gradient descent such as Adam is not suitable for the approximate imaginary-time evolution. When update by the adaptive optimizer, the loss function fluctuates greatly. On the other hand, the update method of SGD without momentum is naive update, which is convenient for comparison with the exact imaginary-time evolution." ], @@ -576,7 +585,7 @@ { "cell_type": "markdown", "source": [ - "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods but with the same parameter of fixed_global_phase are almost the same, which are also close to the exact final state. And the final states obtained by the same method but with the different parameter of fixed_global_phase has a global phase difference." + "We first show the overlap between the final states obtained by different methods. The final states obtained by different methods but with the same parameter of ``fixed_global_phase`` are almost the same, which are also close to the exact final state. And the final states obtained by the same method but with the different parameter of ``fixed_global_phase`` has a global phase difference." ], "metadata": { "collapsed": false @@ -915,7 +924,7 @@ { "cell_type": "markdown", "source": [ - "We also use two methods to calculate $\\boldsymbol{\\delta}$, but make some changes in the method of directly calling the API and the update method. When calculating $\\boldsymbol{A}$, we call qng2 instead of qng, and when calculating $\\boldsymbol{C}$, we call dynamics_rhs instead of calculating the energy gradient by value_and_grad. For the update method, we do not call the existing optimizer but directly adopt the naive update method." + "We also use two methods to calculate $\\boldsymbol{\\delta}$, but make some changes in the method of directly calling the API and the update method. When calculating $\\boldsymbol{A}$, we call ``qng2`` instead of ``qng``, and when calculating $\\boldsymbol{C}$, we call ``dynamics_rhs`` instead of calculating the energy gradient by ``value_and_grad``. For the update method, we do not call the existing optimizer but directly adopt the naive update method." ], "metadata": { "collapsed": false From 9861b4833c9d102403cae031a9571135ad39e517 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sun, 13 Aug 2023 19:30:34 +0800 Subject: [PATCH 612/725] Update 4 tutorials --- docs/source/tutorials/classical_shadows.ipynb | 52 ++++++++----------- docs/source/tutorials/imag_time_evo.ipynb | 34 +++++------- docs/source/tutorials/qaoa_nae3sat.ipynb | 28 ++++------ .../tutorials/qaoa_quantum_dropout.ipynb | 12 ++--- tensorcircuit/shadows.py | 2 +- 5 files changed, 48 insertions(+), 80 deletions(-) diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index 610b474e..9b53f860 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -32,27 +32,19 @@ "source": [ "Let's first briefly review the classical shadows in Pauli basis. For an $n$-qubit quantum state $\\rho$, we randomly perform Pauli projection measurement on each qubit and obtain a snapshot like $\\{1,-1,-1,1,\\cdots,1,-1\\}$. This process is equivalent to apply a random unitary $U$ to $\\rho$ and measure in computational basis to obtain $|b\\rangle=|s_1\\cdots s_n\\rangle,\\ s_j\\in\\{0,1\\}$:\n", "$$\n", - "\\begin{equation}\n", - " \\rho\\rightarrow U\\rho U^{\\dagger}\\xrightarrow{measure}|b\\rangle\\langle b|,\n", - "\\end{equation}\n", + "\\rho\\rightarrow U\\rho U^{\\dagger}\\xrightarrow{measure}|b\\rangle\\langle b|,\n", "$$\n", "where $U=\\bigotimes_{j=1}^{n}u_j$, $u_i\\in\\{H, HS^{\\dagger}, \\mathbb{I}\\}$ correspond to the projection measurements of Pauli $X$, $Y$, $Z$ respectively. Then we reverse the operation to get the equivalent measurement result on $\\rho$:\n", "$$\n", - "\\begin{equation}\n", - " \\rho\\xrightarrow{measure}U^{\\dagger}|b\\rangle\\langle b| U.\n", - "\\end{equation}\n", + "\\rho\\xrightarrow{measure}U^{\\dagger}|b\\rangle\\langle b| U.\n", "$$\n", "Moreover, we perform $N$ random measurements and view their average as a quantum channel:\n", "$$\n", - "\\begin{equation}\n", - " \\mathbb{E}\\left[U^{\\dagger}|b\\rangle\\langle b|U\\right]=\\mathcal{M}(\\rho),\n", - "\\end{equation}\n", + "\\mathbb{E}\\left[U^{\\dagger}|b\\rangle\\langle b|U\\right]=\\mathcal{M}(\\rho),\n", "$$\n", "we can invert the channel to get the approximation of $\\rho$:\n", "$$\n", - "\\begin{equation}\n", - " \\rho=\\mathbb{E}\\left[\\mathcal{M}^{-1}(U^{\\dagger}|b\\rangle\\langle b|U)\\right].\n", - "\\end{equation}\n", + "\\rho=\\mathbb{E}\\left[\\mathcal{M}^{-1}(U^{\\dagger}|b\\rangle\\langle b|U)\\right].\n", "$$\n", "We call each $\\rho_i=\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)$ a shadow snapshot state and their ensemble $S(\\rho;N)=\\{\\rho_i|i=1,\\cdots,N\\}$ classical shadows." ], @@ -65,23 +57,21 @@ "source": [ "In Pauli basis, we have a simple expression of $\\mathcal{M}^{-1}$:\n", "$$\n", - "\\begin{eqnarray}\n", - " \\rho_i&=&\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)=\\bigotimes_{j=1}^{n}3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I},\\\\\n", - " \\rho&=&\\frac{1}{N}\\sum_{i=1}^{N}\\rho_i\\ .\n", - "\\end{eqnarray}\n", + "\\begin{split}\n", + " \\rho_i&=\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)=\\bigotimes_{j=1}^{n}3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I},\\\\\n", + " \\rho&=\\frac{1}{N}\\sum_{i=1}^{N}\\rho_i\\ .\n", + "\\end{split}\n", "$$\n", "For an observable Pauli string $O=\\bigotimes_{j=1}^{n}P_j,\\ P_j\\in\\{\\mathbb{I}, X, Y, Z\\}$, we can directly use $\\rho$ to calculate $\\langle O\\rangle=\\text{Tr}(O\\rho)$. In practice, we will divide the classical shadows into $K$ parts to calculate the expectation values independently and take the median to avoid the influence of outliers:\n", "$$\n", - "\\begin{equation}\n", - " \\langle O\\rangle=\\text{median}\\{\\langle O_{(1)}\\rangle\\cdots\\langle O_{(K)}\\rangle\\},\n", - "\\end{equation}\n", + "\\langle O\\rangle=\\text{median}\\{\\langle O_{(1)}\\rangle\\cdots\\langle O_{(K)}\\rangle\\},\n", "$$\n", "where\n", "$$\n", - "\\begin{eqnarray}\n", - " \\langle O_{(k)}\\rangle&=&\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\text{Tr}\\left[\\bigotimes_{j=1}^{n}P_j(3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I})\\right]\\\\\n", - " &=&\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\prod_{j=1}^n\\text{Tr}\\left[3P_j u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}\\right].\n", - "\\end{eqnarray}\n", + "\\begin{split}\n", + " \\langle O_{(k)}\\rangle&=\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\text{Tr}\\left[\\bigotimes_{j=1}^{n}P_j(3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I})\\right]\\\\\n", + " &=\\frac{1}{\\lceil N/K\\rceil}\\sum_{i=(k-1)\\lceil N/K\\rceil+1}^{k\\lceil N/K\\rceil}\\prod_{j=1}^n\\text{Tr}\\left[3P_j u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}\\right].\n", + "\\end{split}\n", "$$" ], "metadata": { @@ -143,10 +133,10 @@ "source": [ "We first set the number of qubits $n$ and the number of repeated measurements $r$ on each Pauli string. Then from the target observable Pauli strings $\\{O_i|i=1,\\cdots,M\\}$ (0, 1, 2, and 3 correspond to $\\mathbb{I}$, $X$, $Y$, and $Z$, respectively), the error $\\epsilon$ and the rate of failure $\\delta$, we can use ``shadow_bound`` function to get the total number of snapshots $N$ and the number of equal parts $K$ to split the shadow snapshot states to compute the median of means:\n", "$$\n", - "\\begin{eqnarray}\n", - " K&=&2\\log(2M/\\delta),\\\\\n", - " N&=&K\\frac{34}{\\epsilon^2}\\max_{1\\le i\\le M}\\left\\|O_i-\\frac{\\text{Tr}(O_i)}{2^n}\\mathbb{I}\\right\\|^2_{\\text{shadow}}=K\\frac{34}{\\epsilon^2}3^{\\max_{1\\le i\\le M}k_i},\n", - "\\end{eqnarray}\n", + "\\begin{split}\n", + " K&=2\\log(2M/\\delta),\\\\\n", + " N&=K\\frac{34}{\\epsilon^2}\\max_{1\\le i\\le M}\\left\\|O_i-\\frac{\\text{Tr}(O_i)}{2^n}\\mathbb{I}\\right\\|^2_{\\text{shadow}}=K\\frac{34}{\\epsilon^2}3^{\\max_{1\\le i\\le M}k_i},\n", + "\\end{split}\n", "$$\n", "where $k_i$ is the number of nontrivial Pauli matrices in $O_i$. Please refer to the Theorem S1 and Lemma S3 in [Huang, Kueng and Preskill (2020)](https://www.nature.com/articles/s41567-020-0932-7) for the details of proof. It should be noted that ``shadow_bound`` has a certain degree of overestimation of $N$, and so many measurements are not really needed in practice. Moreover, ``shadow_bound`` is not jitable and no need to jit." ], @@ -596,10 +586,10 @@ "source": [ "On the other hand, for the second order Renyi entropy, we have another method to calculate it in polynomial time by random measurements:\n", "$$\n", - "\\begin{eqnarray}\n", - " R_A^2&=&-\\log\\left(\\text{Tr}(\\rho_A^2)\\right),\\\\\n", - " \\text{Tr}(\\rho_A^2)&=&2^k\\sum_{b,b'\\in\\{0,1\\}^k}(-2)^{-H(b,b')}\\overline{P(b)P(b')},\n", - "\\end{eqnarray}\n", + "\\begin{split}\n", + " R_A^2&=-\\log\\left(\\text{Tr}(\\rho_A^2)\\right),\\\\\n", + " \\text{Tr}(\\rho_A^2)&=2^k\\sum_{b,b'\\in\\{0,1\\}^k}(-2)^{-H(b,b')}\\overline{P(b)P(b')},\n", + "\\end{split}\n", "$$\n", "where $A$ is the $k$-d reduced system, $H(b,b')$ is the Hamming distance between $b$ and $b'$, $P(b)$ is the probability for measuring $\\rho_A$ and obtaining the outcomes $b$ thus we need a larger $r$ to obtain a good enough priori probability, and the overline means the average on all random selected Pauli strings. Please refer to [Brydges, et al. (2019)](https://www.science.org/doi/full/10.1126/science.aau4963) for more details. We can use ``renyi_entropy_2`` to implement this method, but it is not jitable because we need to build the dictionary based on the bit strings obtained by measurements, which is a dynamical process. Compared with ``entropy_shadow``, it cannot filter out non-negative eigenvalues, so the accuracy is slightly worse." ], diff --git a/docs/source/tutorials/imag_time_evo.ipynb b/docs/source/tutorials/imag_time_evo.ipynb index c93a814b..f698e793 100644 --- a/docs/source/tutorials/imag_time_evo.ipynb +++ b/docs/source/tutorials/imag_time_evo.ipynb @@ -25,34 +25,26 @@ "\n", "However, exact imaginary-time evolution takes exponentially more space and time to execute on a classical computer. On the other hand, it is non-unitary and also cannot be implemented on a quantum computer. Therefore, we consider the approximate imaginary-time evolution, also known as the quantum natural gradient (QNG), that is, at each step we adjust the parameters in the quantum circuit to realize the imaginary-time evolution in a very short time $\\tau$. Let the parameters in the circuit be $\\boldsymbol{\\theta}$ and the output of the circuit is $|\\psi\\rangle$, define\n", "$$\n", - "\\begin{eqnarray}\n", - " |\\psi_\\tau\\rangle&=&e^{-\\tau\\hat{H}}|\\psi\\rangle\\approx|\\psi\\rangle-\\tau\\hat{H}|\\psi\\rangle,\\\\\n", - " |\\psi'\\rangle&=&|\\psi(\\boldsymbol{\\theta}-\\tau\\boldsymbol{\\delta})\\rangle\\approx|\\psi\\rangle-\\tau\\sum_j\\boldsymbol{\\delta}_j|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle,\n", - "\\end{eqnarray}\n", + "\\begin{split}\n", + " |\\psi_\\tau\\rangle&=e^{-\\tau\\hat{H}}|\\psi\\rangle\\approx|\\psi\\rangle-\\tau\\hat{H}|\\psi\\rangle,\\\\\n", + " |\\psi'\\rangle&=|\\psi(\\boldsymbol{\\theta}-\\tau\\boldsymbol{\\delta})\\rangle\\approx|\\psi\\rangle-\\tau\\sum_j\\boldsymbol{\\delta}_j|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle,\n", + "\\end{split}\n", "$$\n", "and the overlap is\n", "$$\n", - "\\begin{equation}\n", - " O=\\sqrt{\\frac{\\langle\\psi_\\tau\\rangle|\\psi'\\rangle\\langle\\psi'|\\psi_\\tau\\rangle}{\\langle\\psi_\\tau\\rangle|\\psi_\\tau\\rangle\\langle\\psi'|\\psi'\\rangle}}.\n", - "\\end{equation}\n", + "O=\\sqrt{\\frac{\\langle\\psi_\\tau\\rangle|\\psi'\\rangle\\langle\\psi'|\\psi_\\tau\\rangle}{\\langle\\psi_\\tau\\rangle|\\psi_\\tau\\rangle\\langle\\psi'|\\psi'\\rangle}}.\n", "$$\n", "Let $\\partial|O|^2/\\partial\\boldsymbol{\\delta}=0$, we can get $\\boldsymbol{A\\delta=C}$, then the update method is as follows\n", "$$\n", - "\\begin{equation}\n", - " \\boldsymbol{\\theta}^{n+1}=\\boldsymbol{\\theta}^{n}-\\tau\\boldsymbol{\\delta}=\\boldsymbol{\\theta}^{n}-\\tau\\boldsymbol{A}^{-1}\\boldsymbol{C},\n", - "\\end{equation}\n", + "\\boldsymbol{\\theta}^{n+1}=\\boldsymbol{\\theta}^{n}-\\tau\\boldsymbol{\\delta}=\\boldsymbol{\\theta}^{n}-\\tau\\boldsymbol{A}^{-1}\\boldsymbol{C},\n", "$$\n", "where $\\boldsymbol{A}$ is the quantum Fisher information matrix and the matrix element\n", "$$\n", - "\\begin{equation}\n", - " \\boldsymbol{A}_{ij}=\\Re\\left[\\frac{\\langle\\partial_{\\boldsymbol{\\theta}_{i}}\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}-\\frac{\\langle\\partial_{\\boldsymbol{\\theta}_{i}}\\psi|\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\frac{\\langle\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\right];\n", - "\\end{equation}\n", + "\\boldsymbol{A}_{ij}=\\Re\\left[\\frac{\\langle\\partial_{\\boldsymbol{\\theta}_{i}}\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}-\\frac{\\langle\\partial_{\\boldsymbol{\\theta}_{i}}\\psi|\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\frac{\\langle\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\right];\n", "$$\n", "$\\boldsymbol{C}$ is the gradient vector of energy versus parameters and the vector element\n", "$$\n", - "\\begin{equation}\n", - " \\boldsymbol{C}_j=\\Re\\left[\\frac{\\langle\\psi|\\hat{H}|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}-\\frac{\\langle\\psi|\\hat{H}|\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\frac{\\langle\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\right].\n", - "\\end{equation}\n", + "\\boldsymbol{C}_j=\\Re\\left[\\frac{\\langle\\psi|\\hat{H}|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}-\\frac{\\langle\\psi|\\hat{H}|\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\frac{\\langle\\psi|\\partial_{\\boldsymbol{\\theta}_{j}}\\psi\\rangle}{\\langle\\psi|\\psi\\rangle}\\right].\n", "$$\n", "Since $|\\psi\\rangle$ is represented by quantum circuit and naturally normalized, the second term of $\\boldsymbol{C}$ vanishes. And because the global phase is not important, we can add a $U(1)$ gauge to make the second term of $\\boldsymbol{A}$ vanishes. Related theoretical work can refer to [Yuan, Endo, Zhao, Li and Benjamin](https://doi.org/10.22331/q-2019-10-07-191) and [Stokes, Izaac, Killoran and Carleo](https://doi.org/10.22331/q-2020-05-25-269), which will also show how to measure $\\boldsymbol{A}$ and $\\boldsymbol{C}$ in circuit." ] @@ -136,12 +128,10 @@ "\n", "Let the set of clauses in the NAE3SAT be $\\mathcal{C}$. In each clause, there are three literals and each literal is represented by a spin. Spins up ($s=1$, $\\text{bit}=0$) and down ($s=-1$, $\\text{bit}=1$) represent false and true respectively. For the clause $(s_i,\\ s_j,\\ s_k)\\in\\mathcal{C}$, $s_i,\\ s_j,\\ s_k$ cannot be 1 or -1 at the same time. The Hamiltonian of the NAE3SAT is as follows\n", "$$\n", - "\\begin{equation}\n", - " \\begin{split}\n", - " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", - " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", - " \\end{split}\n", - "\\end{equation}\n", + "\\begin{split}\n", + " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", + "\\end{split}\n", "$$\n", "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $\\hat{H}_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT." ], diff --git a/docs/source/tutorials/qaoa_nae3sat.ipynb b/docs/source/tutorials/qaoa_nae3sat.ipynb index 46b7e327..f3776f23 100644 --- a/docs/source/tutorials/qaoa_nae3sat.ipynb +++ b/docs/source/tutorials/qaoa_nae3sat.ipynb @@ -39,15 +39,11 @@ "source": [ "[Not-all-equal 3-satisfiability (NAE3SAT)](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability) is a variant of 3-satisfiability (3-SAT) and 3-SAT is a subset of [Boolean satisfiability problem (SAT)](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem). SAT is, given a Boolean expression, to check whether it is satisfiable, where the Boolean expression is a disjunction of clauses (or a single clause) and each clause is a disjunction of literals (or a single literal). Here is an example of Boolean expression of SAT,\n", "$$\n", - "\\begin{equation}\n", - " (x_1\\lor x_2\\lor\\cdots\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor\\cdots\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor\\cdots\\lor \\lnot x_n),\n", - "\\end{equation}\n", + "(x_1\\lor x_2\\lor\\cdots\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor\\cdots\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor\\cdots\\lor \\lnot x_n),\n", "$$\n", "where $(x_i\\lor x_j\\lor\\cdots\\lor x_k)$ is a clause and $x_i$ is a literal. SAT with $k$ literals in each clause is called $k$-SAT, thus in 3-SAT, there are only three literals in each clause, for example\n", "$$\n", - "\\begin{equation}\n", - " (x_1\\lor x_2\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor \\lnot x_n).\n", - "\\end{equation}\n", + "(x_1\\lor x_2\\lor x_m)\\land(\\lnot x_5\\lor x_9\\lor x_m)\\land\\cdots\\land(x_m\\lor \\lnot x_{m+3}\\lor \\lnot x_n).\n", "$$\n", "When $k$ is not less than 3, SAT is NP-complete. On the other hand, NAE3SAT requires the three literals in each clause are not all equal to each other, in other words, at least one is true, and at least one is false. It is different from 3-SAT, which requires at least one literal is true in each clause. However, NAE3SAT is still NP-complete, [which can be proven by a reduction from 3-SAT](https://en.wikipedia.org/wiki/Not-all-equal_3-satisfiability)." ] @@ -59,12 +55,10 @@ "source": [ "Now we use the spin model to represent a NAE3SAT. Let the set of clauses in the NAE3SAT be $\\mathcal{C}$. In each clause, there are three literals and each literal is represented by a spin. Spins up ($s=1$, $\\text{bit}=0$) and down ($s=-1$, $\\text{bit}=1$) represent false and true respectively. For the clause $(s_i,\\ s_j,\\ s_k)\\in\\mathcal{C}$, $s_i,\\ s_j,\\ s_k$ cannot be 1 or -1 at the same time. The Hamiltonian of the NAE3SAT is as follows\n", "$$\n", - "\\begin{equation}\n", - " \\begin{split}\n", - " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", - " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", - " \\end{split}\n", - "\\end{equation}\n", + "\\begin{split}\n", + " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", + "\\end{split}\n", "$$\n", "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $\\hat{H}_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT." ] @@ -84,15 +78,11 @@ "source": [ "QAOA utilizes a parameterized quantum circuit ([PQC](https://tensorcircuit.readthedocs.io/en/latest/textbook/chap5.html?highlight=变分)) to generate a quantum state that represents a potential solution. The initial state, denoted as $|s\\rangle$, is a uniform superposition over computational basis states.\n", "$$\n", - "\\begin{equation}\n", - " |s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle\n", - "\\end{equation}\n", + "|s\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum_z|z\\rangle\n", "$$\n", "This state is then evolved by a unitary operator that consists of $p$ layers, denoted as\n", "$$\n", - "\\begin{equation}\n", - " U(\\boldsymbol{\\beta}, \\boldsymbol{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", - "\\end{equation}\n", + "U(\\boldsymbol{\\beta}, \\boldsymbol{\\gamma}) = V_{p}U_{p} \\cdots V_{1}U_{1},\n", "$$\n", "where $U_{j}= e^{-\\text{i}\\gamma_{j}\\hat{H}_{C}}$ is the driving layer and $V_{j}= e^{-\\text{i}\\beta_{j} \\hat{H}_m}$ is the mixing layer. $\\hat{H}_C$ is the driving and cost Hamiltonian introduced in previous section and the mixing Hamiltonian $\\hat{H}_m=\\sum_{j=1}^{n}\\sigma_j^x$ is used to mix the quantum state to explore different solutions. The unitary operator is parameterized by $2p$ angle parameters $\\gamma_1, \\gamma_2, \\dots, \\gamma_p$ and $\\beta_1, \\beta_2, \\dots ,\\beta_p$ and each $\\gamma$ and $\\beta$ are restricted to lie between $0$ and $2\\pi$." ] @@ -112,7 +102,7 @@ "id": "940fa22b", "metadata": {}, "source": [ - "### The code" + "### Setup" ] }, { diff --git a/docs/source/tutorials/qaoa_quantum_dropout.ipynb b/docs/source/tutorials/qaoa_quantum_dropout.ipynb index 0e812ab5..e856d151 100644 --- a/docs/source/tutorials/qaoa_quantum_dropout.ipynb +++ b/docs/source/tutorials/qaoa_quantum_dropout.ipynb @@ -43,12 +43,10 @@ "\n", "Let the set of clauses in the NAE3SAT be $\\mathcal{C}$. In each clause, there are three literals and each literal is represented by a spin. Spins up ($s=1$, $\\text{bit}=0$) and down ($s=-1$, $\\text{bit}=1$) represent false and true respectively. NAE3SAT requires the three spins in each clause are not all equal to each other, in other words, at least one is up, and at least one is down. The Hamiltonian of the NAE3SAT is as follows\n", "$$\n", - "\\begin{equation}\n", - " \\begin{split}\n", - " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", - " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", - " \\end{split}\n", - "\\end{equation}\n", + "\\begin{split}\n", + " \\hat{H}_C&=\\sum_{(i,j,k)\\in\\mathcal{C}}\\left[(s_i+s_j+s_k)^2-1\\right]/2\\\\\n", + " &=\\sum_{(i,j,k)\\in\\mathcal{C}}(s_i s_j+s_j s_k+s_k s_i)+|\\mathcal{C}|,\n", + "\\end{split}\n", "$$\n", "where $|\\mathcal{C}|$ is the number of clauses in $\\mathcal{C}$. When all clauses are true, $\\hat{H}_C$ takes the minimum value 0, and the corresponding bit string is the solution of the NAE3SAT.\n", "\n", @@ -89,7 +87,7 @@ { "cell_type": "markdown", "source": [ - "### The code" + "### Setup" ], "metadata": { "collapsed": false diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index 7407d4d0..aa03574c 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -49,7 +49,7 @@ def shadow_snapshots( sub: Optional[Sequence[int]] = None, measurement_only: bool = False, ) -> Tensor: - r"""To generate the shadow snapshots from given pauli string observables on $|\psi\rangle$ + r"""To generate the shadow snapshots from given pauli string observables on psi :param psi: shape = (2 ** nq,), where nq is the number of qubits :type: Tensor From 6f0c9f0630e1d68d74e7fe8adb079c3dcd187b4a Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sun, 13 Aug 2023 19:34:26 +0800 Subject: [PATCH 613/725] Update qaoa_nae3sat.ipynb --- docs/source/tutorials/qaoa_nae3sat.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/source/tutorials/qaoa_nae3sat.ipynb b/docs/source/tutorials/qaoa_nae3sat.ipynb index f3776f23..51937c93 100644 --- a/docs/source/tutorials/qaoa_nae3sat.ipynb +++ b/docs/source/tutorials/qaoa_nae3sat.ipynb @@ -137,7 +137,7 @@ "id": "6e407437", "metadata": {}, "source": [ - "#### Define the Graph" + "### Define the Graph" ] }, { @@ -267,7 +267,7 @@ "id": "c944f6dd", "metadata": {}, "source": [ - "#### Parameterized Quantum Circuit (PQC)" + "### Parameterized Quantum Circuit (PQC)" ] }, { @@ -322,7 +322,7 @@ "id": "5b159920", "metadata": {}, "source": [ - "#### Optimization" + "### Optimization" ] }, { @@ -392,7 +392,7 @@ "id": "98a6b152", "metadata": {}, "source": [ - "#### Results" + "### Results" ] }, { From c1c508e9d46c93cbe824d4fa43e86b0e5cc0dcab Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Sun, 13 Aug 2023 22:04:00 +0800 Subject: [PATCH 614/725] Update contribution.rst --- docs/source/contribution.rst | 54 +++++++++++++++++++++++++++++++++++- 1 file changed, 53 insertions(+), 1 deletion(-) diff --git a/docs/source/contribution.rst b/docs/source/contribution.rst index 5e8d7385..d8dbd493 100644 --- a/docs/source/contribution.rst +++ b/docs/source/contribution.rst @@ -146,7 +146,59 @@ We use `sphinx `__ to manage the document The source files for docs are .rst file in docs/source. -For English docs, ``sphinx-build source build/html`` in docs dir is enough. The html version of the docs are in docs/build/html. +For English docs, ``sphinx-build source build/html`` and ``make latexpdf LATEXMKOPTS="-silent"`` in docs dir are enough. +The html and pdf version of the docs are in docs/build/html and docs/build/latex, respectively. + +**Formula Environment Attention** + +It should be noted that the formula environment ``$$CONTENT$$`` in markdown is equivalent to the ``equation`` environment in latex. +Therefore, in the jupyter notebook documents, do not nest the formula environment in ``$$CONTENT$$`` that is incompatible with +``equation`` in latex, such as ``eqnarray``, which will cause errors in the pdf file built by ``nbsphinx``. +However, compatible formula environments can be used. For example, this legal code in markdown + +.. code-block:: markdown + + $$ + \begin{split} + X&=Y\\ + &=Z + \end{split} + $$ + +will be convert to + +.. code-block:: latex + + \begin{equation} + \begin{split} + X&=Y\\ + &=Z + \end{split} + \end{equation} + +in latex automatically by ``nbsphinx``, which is a legal latex code. However, this legal code in markdown + +.. code-block:: markdown + + $$ + \begin{eqnarray} + X&=&Y\\ + &=&Z + \end{eqnarray} + $$ + +will be convert to + +.. code-block:: latex + + \begin{equation} + \begin{eqnarray} + X&=&Y\\ + &=&Z + \end{eqnarray} + \end{equation} + +in latex, which is an illegal latex code. **Auto Generation of API Docs:** From dcb85de791c048cff9ee8ad3915092496ba78b43 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 14 Aug 2023 13:51:07 +0800 Subject: [PATCH 615/725] version0.11.0 --- CHANGELOG.md | 2 ++ tensorcircuit/__init__.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 14e58497..593ec9cb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.11.0 + ### Added - Add multiple GPU VQE examples using jax pmap diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index e0020972..3bf75d98 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.10.0" +__version__ = "0.11.0" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From ab9521fdba7a9009a31bc5faa9c4249656352df3 Mon Sep 17 00:00:00 2001 From: EmilianoG-byte Date: Thu, 17 Aug 2023 01:52:33 +0200 Subject: [PATCH 616/725] add r qiskit gate to qiskit2c --- tensorcircuit/translation.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 6e867fd5..1cde9cef 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -486,6 +486,13 @@ def qiskit2tc( getattr(tc_circuit, gate_name)(*idx, theta=parameters) elif gate_name in ["crx_o0", "cry_o0", "crz_o0"]: getattr(tc_circuit, "o" + gate_name[1:-3])(*idx, theta=parameters) + elif gate_name in ["r"]: + getattr(tc_circuit, "u")( + *idx, + theta=parameters[0], + phi=parameters[1] - np.pi / 2, + lbd=-parameters[1] + np.pi / 2, + ) elif gate_name in ["u3", "u"]: getattr(tc_circuit, "u")( *idx, theta=parameters[0], phi=parameters[1], lbd=parameters[2] From ae55af987c16d6ad90ef6ae914b9008bbe5192e7 Mon Sep 17 00:00:00 2001 From: EmilianoG-byte Date: Thu, 17 Aug 2023 11:20:45 +0200 Subject: [PATCH 617/725] add test for r-gate in test_qiskit2tc --- tests/test_circuit.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 04ba7cb2..10a73971 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1122,6 +1122,7 @@ def test_qiskit2tc(): qisc.crz(np.random.uniform(), 2, 3, ctrl_state=0) qisc.crz(np.random.uniform(), 2, 3, ctrl_state=0) qisc.crz(np.random.uniform(), 2, 3, ctrl_state=0) + qisc.r(np.random.uniform(), np.random.uniform(), 1) qisc.unitary(exp_op, [1, 3]) mcx_g = MCXGate(3, ctrl_state="010") qisc.append(mcx_g, [0, 1, 2, 3]) From eb24c881aab1f4321ed21337e5c0dcc4058a4aa6 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Thu, 17 Aug 2023 10:46:40 +0000 Subject: [PATCH 618/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 5dcdbbde..ca4b5cb3 100644 --- a/README.md +++ b/README.md @@ -276,6 +276,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. Felix Xu
Felix Xu
✅ 💻 ⚠️ Hong-Ye Hu
Hong-Ye Hu
📖 peilin
peilin
✅ 💻 ⚠️ 📖 + Cristian Emiliano Godinez Ramirez
Cristian Emiliano Godinez Ramirez
💻 ⚠️ From 63a0d78acba2a56c06f3d3afc065419aea753cf2 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Thu, 17 Aug 2023 10:46:41 +0000 Subject: [PATCH 619/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index b1735deb..b76d6a80 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -272,6 +272,16 @@ "test", "doc" ] + }, + { + "login": "EmilianoG-byte", + "name": "Cristian Emiliano Godinez Ramirez", + "avatar_url": "https://avatars.githubusercontent.com/u/57567043?v=4", + "profile": "https://emilianog-byte.github.io", + "contributions": [ + "code", + "test" + ] } ], "contributorsPerLine": 6, From 3ecc4edd1c072756401af010cbc39c50859f4c1c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 17 Aug 2023 21:28:13 +0800 Subject: [PATCH 620/725] move to tn-ng --- requirements/requirements.txt | 4 ++-- setup.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 9532163a..5deccf0d 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,7 +1,7 @@ numpy scipy -tensorflow==2.7 -tensornetwork +tensorflow +tensornetwork-ng graphviz jax jaxlib diff --git a/setup.py b/setup.py index 6e372719..ac6d4d57 100644 --- a/setup.py +++ b/setup.py @@ -17,7 +17,7 @@ url="https://github.com/tencent-quantum-lab/tensorcircuit", packages=setuptools.find_packages(), include_package_data=True, - install_requires=["numpy", "scipy", "tensornetwork", "networkx"], + install_requires=["numpy", "scipy", "tensornetwork-ng", "networkx"], extras_require={ "tensorflow": ["tensorflow"], "jax": ["jax", "jaxlib"], From 9e1e56f64f8e6fa22bfa90c4500fc07f39ab7b92 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 17 Aug 2023 21:48:49 +0800 Subject: [PATCH 621/725] upgrade ci to py3.10 --- .github/workflows/ci.yml | 2 +- .github/workflows/nightly_release.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7a0a7dff..e60133f5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -7,7 +7,7 @@ jobs: strategy: matrix: os: [ubuntu-20.04, macos-latest] # macos-latest disabled to save quota - python-version: [3.8] + python-version: [3.10] fail-fast: false steps: - uses: actions/checkout@v2 diff --git a/.github/workflows/nightly_release.yml b/.github/workflows/nightly_release.yml index ce62cc9c..dbb8fc76 100644 --- a/.github/workflows/nightly_release.yml +++ b/.github/workflows/nightly_release.yml @@ -18,7 +18,7 @@ jobs: - name: Set up Python uses: actions/setup-python@v4 with: - python-version: 3.8 + python-version: 3.10 cache: "pip" - name: install dependencies run: | From 3f246def8483e0784a4f3e465b32b50e04a7abbc Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 17 Aug 2023 21:58:12 +0800 Subject: [PATCH 622/725] stringfy the version --- .github/workflows/ci.yml | 2 +- .github/workflows/nightly_release.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e60133f5..964f9d67 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -7,7 +7,7 @@ jobs: strategy: matrix: os: [ubuntu-20.04, macos-latest] # macos-latest disabled to save quota - python-version: [3.10] + python-version: ["3.10"] fail-fast: false steps: - uses: actions/checkout@v2 diff --git a/.github/workflows/nightly_release.yml b/.github/workflows/nightly_release.yml index dbb8fc76..8a1dbda8 100644 --- a/.github/workflows/nightly_release.yml +++ b/.github/workflows/nightly_release.yml @@ -18,7 +18,7 @@ jobs: - name: Set up Python uses: actions/setup-python@v4 with: - python-version: 3.10 + python-version: "3.10" cache: "pip" - name: install dependencies run: | From 2d2245249cb606569e9bf40ed6ce0a009345da5a Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 17 Aug 2023 22:08:02 +0800 Subject: [PATCH 623/725] fix mypy --- tensorcircuit/backends/jax_ops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/backends/jax_ops.py b/tensorcircuit/backends/jax_ops.py index 63cd2e33..743e0ad0 100644 --- a/tensorcircuit/backends/jax_ops.py +++ b/tensorcircuit/backends/jax_ops.py @@ -66,7 +66,7 @@ def jaxsvd_bwd(r: Sequence[Array], tangents: Sequence[Array]) -> Tuple[Array]: return (grad_a,) -adaware_svd.defvjp(jaxsvd_fwd, jaxsvd_bwd) +adaware_svd.defvjp(jaxsvd_fwd, jaxsvd_bwd) # type: ignore adaware_svd_jit = jax.jit(adaware_svd) @@ -142,6 +142,6 @@ def _QrGradSquareAndDeepMatrices(q: Array, r: Array, dq: Array, dr: Array) -> Ar return (result,) -adaware_qr.defvjp(jaxqr_fwd, jaxqr_bwd) +adaware_qr.defvjp(jaxqr_fwd, jaxqr_bwd) # type: ignore adaware_qr_jit = jax.jit(adaware_qr) From 28bda817a60113bcdbd6140f8e452ea09742a66c Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 17 Aug 2023 23:07:02 +0800 Subject: [PATCH 624/725] black --- tensorcircuit/backends/jax_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/backends/jax_ops.py b/tensorcircuit/backends/jax_ops.py index 743e0ad0..efcce174 100644 --- a/tensorcircuit/backends/jax_ops.py +++ b/tensorcircuit/backends/jax_ops.py @@ -66,7 +66,7 @@ def jaxsvd_bwd(r: Sequence[Array], tangents: Sequence[Array]) -> Tuple[Array]: return (grad_a,) -adaware_svd.defvjp(jaxsvd_fwd, jaxsvd_bwd) # type: ignore +adaware_svd.defvjp(jaxsvd_fwd, jaxsvd_bwd) # type: ignore adaware_svd_jit = jax.jit(adaware_svd) From 0ec22166d974b76e00183cdcf6956572a20fd0ba Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 18 Aug 2023 09:55:45 +0800 Subject: [PATCH 625/725] new version of ci packages --- requirements/requirements-dev.txt | 7 +++---- tensorcircuit/applications/optimization.py | 4 ++-- tensorcircuit/translation.py | 2 +- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/requirements/requirements-dev.txt b/requirements/requirements-dev.txt index 753fe704..e6b3e293 100644 --- a/requirements/requirements-dev.txt +++ b/requirements/requirements-dev.txt @@ -1,13 +1,12 @@ -mypy==1.2.0 +mypy==1.5.1 pytest==6.2.4 pytest-cov pytest-benchmark pytest-xdist -black[jupyter]==23.3.0 +black[jupyter] sphinx>=4.0 pytest-lazy-fixture -pylint==2.11.1 -numpy==1.21.5 +pylint==2.17.5 furo sphinx-copybutton nbsphinx diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index a579d6b8..bf0cc1c5 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -171,8 +171,8 @@ def cvar_value(r: List[float], p: List[float], percent: float) -> float: :return: The calculated CVaR value. """ sorted_indices = np.argsort(r) - p = np.array(p)[sorted_indices] - r = np.array(r)[sorted_indices] + p = np.array(p)[sorted_indices] # type: ignore + r = np.array(r)[sorted_indices] # type: ignore sump = 0.0 # The sum of probabilities. count = 0 diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 1cde9cef..045751c2 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -125,7 +125,7 @@ def qir2cirq( support more element in qir, e.g. barrier, measure... """ - class CustomizedCirqGate(cirq.Gate): + class CustomizedCirqGate(cirq.Gate): # type: ignore def __init__(self, uMatrix: Any, name: str, nqubit: int): super(CustomizedCirqGate, self) self.uMatrix = uMatrix From 018cc558468f838fa7944658f33c55e003e5b3d2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 18 Aug 2023 10:47:21 +0800 Subject: [PATCH 626/725] move ensemble to applications --- CHANGELOG.md | 8 ++++++++ docs/source/api/applications/ai.rst | 2 +- .../api/{templates => applications/ai}/ensemble.rst | 4 ++-- docs/source/api/templates.rst | 1 - tensorcircuit/{templates => applications/ai}/ensemble.py | 5 +++-- tests/test_ensemble.py | 4 ++-- 6 files changed, 16 insertions(+), 8 deletions(-) rename docs/source/api/{templates => applications/ai}/ensemble.rst (63%) rename tensorcircuit/{templates => applications/ai}/ensemble.py (96%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 593ec9cb..6f7e7dd9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ ## Unreleased +### Added + +- Add translation of r gate from qiskit + +### Changed + +- move ensemble module to applications/ai (breaking changes) + ## 0.11.0 ### Added diff --git a/docs/source/api/applications/ai.rst b/docs/source/api/applications/ai.rst index c8749e92..96a22cdb 100644 --- a/docs/source/api/applications/ai.rst +++ b/docs/source/api/applications/ai.rst @@ -1,4 +1,4 @@ tensorcircuit.applications.ai ================================================================================ .. toctree:: - \ No newline at end of file + ai/ensemble.rst \ No newline at end of file diff --git a/docs/source/api/templates/ensemble.rst b/docs/source/api/applications/ai/ensemble.rst similarity index 63% rename from docs/source/api/templates/ensemble.rst rename to docs/source/api/applications/ai/ensemble.rst index fc086a35..0173ac00 100644 --- a/docs/source/api/templates/ensemble.rst +++ b/docs/source/api/applications/ai/ensemble.rst @@ -1,6 +1,6 @@ -tensorcircuit.templates.ensemble +tensorcircuit.applications.ai.ensemble ================================================================================ -.. automodule:: tensorcircuit.templates.ensemble +.. automodule:: tensorcircuit.applications.ai.ensemble :members: :undoc-members: :show-inheritance: diff --git a/docs/source/api/templates.rst b/docs/source/api/templates.rst index d76ab744..202b049d 100644 --- a/docs/source/api/templates.rst +++ b/docs/source/api/templates.rst @@ -6,6 +6,5 @@ tensorcircuit.templates templates/chems.rst templates/conversions.rst templates/dataset.rst - templates/ensemble.rst templates/graphs.rst templates/measurements.rst \ No newline at end of file diff --git a/tensorcircuit/templates/ensemble.py b/tensorcircuit/applications/ai/ensemble.py similarity index 96% rename from tensorcircuit/templates/ensemble.py rename to tensorcircuit/applications/ai/ensemble.py index 0c4a0fc3..7946cb4c 100644 --- a/tensorcircuit/templates/ensemble.py +++ b/tensorcircuit/applications/ai/ensemble.py @@ -55,8 +55,9 @@ def compile(self, **kwargs: kwargus) -> None: self.permit_train = True for i in range(self.count): if not self.model_trained[i]: - dic_kwargs = kwargs.copy() - self.models[i].compile(**dic_kwargs) + dict_kwargs = kwargs.copy() + # TODO(@refraction-ray): still not compatible with new optimizer + self.models[i].compile(**dict_kwargs) def __get_confidence(self, model_index: int, input: NDArray) -> NDArray: """ diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py index 5aec52cc..097789dc 100644 --- a/tests/test_ensemble.py +++ b/tests/test_ensemble.py @@ -8,7 +8,7 @@ sys.path.insert(0, modulepath) -from tensorcircuit.templates.ensemble import bagging +from tensorcircuit.applications.ai.ensemble import bagging def test_ensemble_bagging(): @@ -52,7 +52,7 @@ def model(): obj_bagging.append(model(), False) obj_bagging.compile( loss=tf.keras.losses.BinaryCrossentropy(), - optimizer=tf.keras.optimizers.Adam(lr), + optimizer=tf.keras.optimizers.legacy.Adam(lr), metrics=[tf.keras.metrics.AUC(), "acc"], ) obj_bagging.train( From 1eddc6d2a10a5d3126297e7b53fb0a6a19ad5ee3 Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 22 Aug 2023 12:49:29 +0800 Subject: [PATCH 627/725] Update shadows.py --- tensorcircuit/shadows.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/shadows.py b/tensorcircuit/shadows.py index aa03574c..63cad7f6 100644 --- a/tensorcircuit/shadows.py +++ b/tensorcircuit/shadows.py @@ -83,7 +83,7 @@ def shadow_snapshots( backend.convert_to_tensor( [ [-np.pi / 2, np.pi / 4, 0], - [np.pi / 3, np.arccos(1 / np.sqrt(3)), np.pi / 4], + [np.pi / 4, np.pi / 2, 0], [0, 0, 0], ] ), From 98f7b39cff4cd8fd5e7e6cd1ec010d1ae7490036 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Wed, 23 Aug 2023 15:10:00 +0100 Subject: [PATCH 628/725] Delete QAOA_funcs.py --- docs/source/tutorials/QAOA_funcs.py | 439 ---------------------------- 1 file changed, 439 deletions(-) delete mode 100644 docs/source/tutorials/QAOA_funcs.py diff --git a/docs/source/tutorials/QAOA_funcs.py b/docs/source/tutorials/QAOA_funcs.py deleted file mode 100644 index 87d35d59..00000000 --- a/docs/source/tutorials/QAOA_funcs.py +++ /dev/null @@ -1,439 +0,0 @@ -### -### functions for QAOA problems -### - -from typing import List, Tuple, Callable, Any -import tensorcircuit as tc -import numpy as np -import tensorflow as tf -import matplotlib.pyplot as plt -from IPython.display import clear_output -from functools import partial -import scipy.optimize as optimize - -Array = any -Tensor = Any - - -# moved -def QUBO_to_Ising(Q: List[list]) -> Tuple[List[list], list, float]: - """ - Cnvert the Q matrix into a the indication of pauli terms, the corresponding weights, and the offset. - The outputs are used to construct an Ising Hamiltonian for QAOA. - - :param Q: The n-by-n square and symmetric Q-matrix. - :return pauli_terms: A list of 0/1 series, where each element represents a Pauli term. - A value of 1 indicates the presence of a Pauli-Z operator, while a value of 0 indicates its absence. - :return weights: A list of weights corresponding to each Pauli term. - :return offset: A float representing the offset term of the Ising Hamiltonian. - """ - - # input is n-by-n symmetric numpy array corresponding to Q-matrix - # output is the components of Ising Hamiltonian - - n = Q.shape[0] - - # square matrix check - if Q[0].shape[0] != n: - raise ValueError("Matrix is not a square matrix.") - - offset = ( - np.triu(Q, 0).sum() / 2 - ) # Calculate the offset term of the Ising Hamiltonian - pauli_terms = [] # List to store the Pauli terms - weights = ( - -np.sum(Q, axis=1) / 2 - ) # Calculate the weights corresponding to each Pauli term - - for i in range(n): - term = np.zeros(n) - term[i] = 1 - pauli_terms.append( - term.tolist() - ) # Add a Pauli term corresponding to a single qubit - - for i in range(n - 1): - for j in range(i + 1, n): - term = np.zeros(n) - term[i] = 1 - term[j] = 1 - pauli_terms.append( - term.tolist() - ) # Add a Pauli term corresponding to a two-qubit interaction - - weight = ( - Q[i][j] / 2 - ) # Calculate the weight for the two-qubit interaction term - weights = np.concatenate( - (weights, weight), axis=None - ) # Add the weight to the weights list - - return pauli_terms, weights, offset - - -def Ising_loss(c: tc.Circuit, pauli_terms: List[list], weights: list) -> float: - """ - computes the loss function for the Ising model based on a given quantum circuit, - a list of Pauli terms, and corresponding weights. - The offset is ignored. - - :param c: A quantum circuit object generating the state. - :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. - :param weights: A list of weights corresponding to each Pauli term. - :return loss: A real number representing the computed loss value. - """ - loss = 0.0 - for k in range(len(pauli_terms)): - term = pauli_terms[k] - index_of_ones = [] - - for l in range(len(term)): - if term[l] == 1: - index_of_ones.append(l) - - # Compute expectation value based on the number of qubits involved in the Pauli term - if len(index_of_ones) == 1: - delta_loss = weights[k] * c.expectation_ps(z=[index_of_ones[0]]) - # Compute expectation value for a single-qubit Pauli term - else: - delta_loss = weights[k] * c.expectation_ps( - z=[index_of_ones[0], index_of_ones[1]] - ) - # Compute expectation value for a two-qubit Pauli term - - loss += delta_loss - - return K.real(loss) - - -def QAOA_loss( - nlayers: int, pauli_terms: List[list], weights: list, params: list -) -> float: - """ - computes the loss function for the Quantum Approximate Optimization Algorithm (QAOA) applied to the Ising model. - - :param nlayers: The number of layers in the QAOA ansatz. - :param pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. - :param weights: A list of weights corresponding to each Pauli term. - :param params: A list of parameter values used in the QAOA ansatz. - :return: The computed loss value. - """ - c = QAOA_ansatz_for_Ising(params, nlayers, pauli_terms, weights) - # Obtain the quantum circuit using QAOA_from_Ising function - - return Ising_loss(c, pauli_terms, weights) - # Compute the Ising loss using Ising_loss function on the obtained circuit - - -def QUBO_QAOA( - Q: List[list], - ansatz: Callable[[list, int, List[list], list], tc.Circuit], - nlayers: int, - iterations: int, - vvag: bool = False, - ncircuits: int = 10, -) -> list: - """ - Performs the QAOA on a given QUBO problem. - - :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. - :param ansatz: The ansatz function to be used for the QAOA. - :param nlayers: The number of layers in the QAOA ansatz. - :param iterations: The number of iterations to run the optimization. - :param vvag (optional): A flag indicating whether to use vectorized variational adjoint gradient. Default is False. - :param ncircuits (optional): The number of circuits when using vectorized variational adjoint gradient. Default is 10. - :return params: The optimized parameters for the ansatz circuit. - """ - try: - K - except NameError: - print("select a backend and assign it to K.") - - pauli_terms, weights, offset = QUBO_to_Ising(Q) - learning_rate = 1e-2 - - loss_val_grad = K.value_and_grad(partial(ansatz, nlayers, pauli_terms, weights)) - params = K.implicit_randn(shape=[2 * nlayers], stddev=0.5) - # Initialize the parameters for the ansatz circuit - - if vvag == True: - loss_val_grad = tc.backend.vvag(loss_val_grad, argnums=0, vectorized_argnums=0) - params = K.implicit_randn(shape=[ncircuits, 2 * nlayers], stddev=0.1) - # Use vectorized variational adjoint gradient (vvag) if vvag flag is set to True - - loss_val_grad_jit = K.jit(loss_val_grad, static_argnums=(1, 2)) - - opt = K.optimizer(tf.keras.optimizers.Adam(learning_rate)) - # Define the optimizer (Adam optimizer) with the specified learning rate - - for i in range(iterations): - loss, grads = loss_val_grad_jit(params) - # Calculate the loss and gradients using the loss_val_grad_jit function - - params = opt.update(grads, params) - # Update the parameters using the optimizer and gradients - - if i % 100 == 0: # print the cost every 100 iterations - print(K.numpy(loss)) - - return params - - -# calcelled -def print_result_prob(c: tc.Circuit, wrap: bool = False, reverse: bool = False) -> None: - """ - Print the results and probabilities of a given quantum circuit. - The default order is from the highest probability to the lowest one - - :param c: The quantum circuit to print the results and probabilities. - :param wrap (optional): A flag indicating whether to wrap the output. Default is False. - :param reverse (optional): A flag indicating whether to reverse the order of the output. Default is False. - """ - try: - K - except NameError: - print("select a backend and assign it to K.") - - states = [] - n_qubits = c._nqubits - for i in range(2**n_qubits): - a = f"{bin(i)[2:]:0>{n_qubits}}" - states.append(a) - # Generate all possible binary states for the given number of qubits - - probs = K.numpy(c.probability()).round(decimals=4) - # Calculate the probabilities of each state using the circuit's probability method - - sorted_indices = np.argsort(probs)[::-1] - if reverse == True: - sorted_indices = sorted_indices[::-1] - state_sorted = np.array(states)[sorted_indices] - prob_sorted = np.array(probs)[sorted_indices] - # Sort the states and probabilities in descending order based on the probabilities - - print("\n-------------------------------------") - print(" selection\t |\tprobability") - print("-------------------------------------") - if wrap == False: - for i in range(len(states)): - print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) - # Print the sorted states and their corresponding probabilities - elif wrap == True: - for i in range(4): - print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) - print(" ... ...") - for i in range(-4, -1): - print("%10s\t |\t %.4f" % (state_sorted[i], prob_sorted[i])) - print("-------------------------------------") - - -# calcelled -def print_result_cost( - c: tc.Circuit, Q: List[list], wrap: bool = False, reverse: bool = False -) -> None: - """ - Print the results and costs of a given quantum circuit. - Specificly designed for the variational circuit. - The default order is from the highest probability to the lowest one. - - :param c: The quantum circuit to print the results and probabilities. - :param Q: The n-by-n square and symmetric Q-matrix representing the QUBO problem. - :param wrap (optional): A flag indicating whether to wrap the output. Default is False. - :param reverse (optional): A flag indicating whether to reverse the order of the output. Default is False. - """ - cost_dict = {} - states = [] - n_qubits = c._nqubits - for i in range(2**n_qubits): - a = f"{bin(i)[2:]:0>{n_qubits}}" - states.append(a) - # Generate all possible binary states for the given number of qubits - for selection in states: - x = np.array([int(bit) for bit in selection]) - cost_dict[selection] = np.dot(x, np.dot(Q, x)) - cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1])) - if reverse == True: - cost_sorted = dict( - sorted(cost_dict.items(), key=lambda item: item[1], reverse=True) - ) - num = 0 - print("\n-------------------------------------") - print(" selection\t |\t cost") - print("-------------------------------------") - for k, v in cost_sorted.items(): - print("%10s\t |\t%.4f" % (k, v)) - num += 1 - if (num >= 8) & (wrap == True): - break - print("-------------------------------------") - - -# cancelled -def print_Q_cost(Q: List[list], wrap: bool = False, reverse: bool = False) -> None: - n_stocks = len(Q) - states = [] - for i in range(2**n_stocks): - a = f"{bin(i)[2:]:0>{n_stocks}}" - n_ones = 0 - for j in a: - if j == "1": - n_ones += 1 - states.append(a) - - cost_dict = {} - for selection in states: - x = np.array([int(bit) for bit in selection]) - cost_dict[selection] = np.dot(x, np.dot(Q, x)) - cost_sorted = dict(sorted(cost_dict.items(), key=lambda item: item[1])) - if reverse == True: - cost_sorted = dict( - sorted(cost_dict.items(), key=lambda item: item[1], reverse=True) - ) - num = 0 - print("\n-------------------------------------") - print(" selection\t |\t cost") - print("-------------------------------------") - for k, v in cost_sorted.items(): - print("%10s\t |\t%.4f" % (k, v)) - num += 1 - if (num >= 8) & (wrap == True): - break - print("-------------------------------------") - - -# moved -class StockData: - """ - convert real-world stock data to the inputs of QAOA. - """ - - def __init__(self, data: Tensor) -> None: - """ - stock data object - - :param data: real-world stock data, in the form of several lists of daily price. - """ - self.data = data # add data - self.n_stocks = len(data) # num of stocks - self.n_days = len(data[1]) - - # check the number of days - n_days = [len(i) for i in data] - if max(n_days) != (sum(n_days) / len(n_days)): - raise Exception("timespan of stocks should be the same") - - # calculate the daily percentage price change - self.daily_change = [] # daily percentage price change - for i in range(self.n_stocks): - each_stcok = [] - for j in range(self.n_days - 1): - each_stcok.append((data[i][j + 1] - data[i][j]) / data[i][j]) - self.daily_change.append(each_stcok) - - def get_return(self) -> Array: - """ - :return ret: annualized return (mu) - """ - ret = np.mean(self.daily_change, axis=1) - return ret - - def get_covariance(self) -> Array: - """ - :return cov: symmetric annualized covariance matrix (sigma) - """ - return np.cov(self.daily_change) - - def get_pentalty( - self, cov: Array, ret: Array, risk_pre: float, budget: int - ) -> float: - """ - calculate the pentalty using the method in https://link.springer.com/article/10.1007/s11128-022-03766-5 - brutal force is used - - :param cov: symmetrix annualized covariance matrix (sigma) - :param ret: annualized return (ret) - :param risk_pre: risk preference of the investor - :param budge: the number of assets to be chosen for the portfolio - """ - # get all fesible and unfeasible states - self.f_state = [] # feasible states (num of '1's equal to budge) - self.uf_state = [] # unfeasible states - self.all_state = [] - for i in range(2**self.n_stocks): - state = f"{bin(i)[2:]:0>{self.n_stocks}}" - n_ones = 0 - for j in state: - if j == "1": - n_ones += 1 - self.all_state.append(state) - if n_ones == budget: - self.f_state.append(state) - else: - self.uf_state.append(state) - - # determine the penalty factor - mark = False - penalty = 0 # initial value - while mark == False: - R = np.diag(ret) - S = np.ones((self.n_stocks, self.n_stocks)) - 2 * budget * np.diag( - np.ones(self.n_stocks) - ) - Q = risk_pre * cov - R + penalty * S - F = [] - for state in self.f_state: - x = np.array([int(bit) for bit in state]) - F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) - Fmin = np.amin(F) - Fbar = np.mean(F) - F = [] - for state in self.uf_state: - x = np.array([int(bit) for bit in state]) - F.append(np.dot(x, np.dot(Q, x)) + penalty * budget**2) - Fmin_uf = np.amin(F) - location = np.where(F == Fmin_uf)[0][0] - if Fmin_uf < 0.5 * (Fmin + Fbar): - n_ones = 0 - for j in self.uf_state[location]: - if j == "1": - n_ones += 1 - penalty += (0.5 * (Fmin + Fbar) - Fmin_uf) / (n_ones - budget) ** 2 - # mark = True - else: - mark = True # ready to return the penalty - return penalty - - -# moved -def QUBO_from_portfolio(cov: Array, mean: Array, q: float, B: int, t: float) -> Tensor: - """ - convert portfolio parameters to a Q matrix - :param cov: n-by-n covariance numpy array - :param mean: numpy array of means - :param q: the risk preference of investor - :param B: budget - :param t: penalty factor - :return Q: n-by-n symmetric Q matrix - """ - n = cov.shape[0] - R = np.diag(mean) - S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n)) - - Q = q * cov - R + t * S - return Q - - -def print_output(c): - n = c._nqubits - N = 2**n - # Calculate the total number of states based on the number of qubits - - x_label = r"$\left|{0:0" + str(n) + r"b}\right>$" - labels = [x_label.format(i) for i in range(N)] - # Generate labels for the x-axis representing the binary states - - plt.bar(range(N), c.probability()) - # Create a bar plot with the probabilities of each state - - plt.xticks(range(N), labels, rotation=70) - # Set the x-axis ticks to the generated labels and rotate them for better visibility From e3a9eda20ed66a5980b0132694f0acddb1b52258 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Wed, 23 Aug 2023 15:43:03 +0100 Subject: [PATCH 629/725] clear the imports --- docs/source/tutorials/QUBO_problem.ipynb | 18 +---------------- .../tutorials/portfolio_optimization.ipynb | 20 +++---------------- 2 files changed, 4 insertions(+), 34 deletions(-) diff --git a/docs/source/tutorials/QUBO_problem.ipynb b/docs/source/tutorials/QUBO_problem.ipynb index 2eb9f49e..4a18510d 100644 --- a/docs/source/tutorials/QUBO_problem.ipynb +++ b/docs/source/tutorials/QUBO_problem.ipynb @@ -61,22 +61,6 @@ "## Setup" ] }, - { - "cell_type": "code", - "execution_count": 1, - "id": "b6a2743e", - "metadata": {}, - "outputs": [], - "source": [ - "## delete before PR\n", - "import sys\n", - "\n", - "sys.path.append(\"D:\\OneDrive - Imperial College London\\文件\\Code\\TensorCircuit\")\n", - "sys.path.append(\n", - " \"/Users/felixxu/Library/CloudStorage/OneDrive-ImperialCollegeLondon/文件/Code/TensorCircuit\"\n", - ")" - ] - }, { "cell_type": "code", "execution_count": 2, @@ -99,7 +83,7 @@ "import time\n", "\n", "from tensorcircuit.applications.optimization import QUBO_QAOA, QUBO_QAOA_cvar, cvar_loss, QAOA_loss\n", - "from tensorcircuit.templates.blocks import QAOA_ansatz_for_Ising\n", + "from tensorcircuit.templates.ansatz import QAOA_ansatz_for_Ising\n", "from tensorcircuit.templates.conversions import QUBO_to_Ising\n", "\n", "K = tc.set_backend(\"tensorflow\")\n", diff --git a/docs/source/tutorials/portfolio_optimization.ipynb b/docs/source/tutorials/portfolio_optimization.ipynb index 3ed0f4e3..54a95062 100644 --- a/docs/source/tutorials/portfolio_optimization.ipynb +++ b/docs/source/tutorials/portfolio_optimization.ipynb @@ -54,20 +54,6 @@ "## Set up" ] }, - { - "cell_type": "code", - "execution_count": 1, - "id": "657c589a", - "metadata": {}, - "outputs": [], - "source": [ - "## delete before PR\n", - "import sys\n", - "\n", - "sys.path.append(\"D:\\OneDrive - Imperial College London\\文件\\Code\\TensorCircuit\")\n", - "sys.path.append(\"/Users/felixxu/Library/CloudStorage/OneDrive-ImperialCollegeLondon/文件/Code/TensorCircuit\")" - ] - }, { "cell_type": "code", "execution_count": 2, @@ -84,10 +70,10 @@ "import time\n", "import scipy.optimize as optimize\n", "\n", - "from tensorcircuit.templates.blocks import QAOA_ansatz_for_Ising\n", - "from tensorcircuit.templates.conversions import QUBO_to_Ising, QUBO_from_portfolio\n", + "from tensorcircuit.templates.ansatz import QAOA_ansatz_for_Ising\n", + "from tensorcircuit.templates.conversions import QUBO_to_Ising\n", "from tensorcircuit.applications.optimization import QUBO_QAOA, QAOA_loss\n", - "from tensorcircuit.templates.conversions import StockData\n", + "from tensorcircuit.applications.finance.portfolio import StockData, QUBO_from_portfolio\n", "\n", "K = tc.set_backend(\"tensorflow\")\n", "tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)" From 5f4202f1b493098ccaf95b02f3b7dc401ee1fe27 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Thu, 24 Aug 2023 12:37:13 +0100 Subject: [PATCH 630/725] fixed minor grammar and format issues --- docs/source/tutorials/QUBO_problem.ipynb | 58 ++++++++----------- .../tutorials/portfolio_optimization.ipynb | 23 +++----- 2 files changed, 31 insertions(+), 50 deletions(-) diff --git a/docs/source/tutorials/QUBO_problem.ipynb b/docs/source/tutorials/QUBO_problem.ipynb index 4a18510d..b28717d3 100644 --- a/docs/source/tutorials/QUBO_problem.ipynb +++ b/docs/source/tutorials/QUBO_problem.ipynb @@ -6,7 +6,7 @@ "id": "6ddb8a88-779a-43f7-ae14-115463bd87f5", "metadata": {}, "source": [ - "# Solving portfolio optimization as QUBO problem with QAOA\n", + "# Solving portfolio optimization as a QUBO problem with QAOA\n", "\n", "## Overview\n", "\n", @@ -16,11 +16,11 @@ "\n", "### what is QUBO?\n", "\n", - "Quadratic unconstrained binary optimization (QUBO) is a type of problem that aims to optimize a quadratic objective function using binary variables. The primary goal of a QUBO problem is to determine the assignments of binary variables that minimize or maximize the quadratic objective function. These variables represent choices or decision variables that can be either selected (1) or not selected (0). The objective function captures the associated costs, benefits, or constraints related to these decisions.\n", + "The quadratic unconstrained binary optimization (QUBO) is a type of problem that aims to optimize a quadratic objective function using binary variables. The primary goal of a QUBO problem is to determine the assignments of binary variables that minimize or maximize the quadratic objective function. These variables represent choices or decision variables that can be either selected (1) or not selected (0). The objective function captures the associated costs, benefits, or constraints related to these decisions.\n", "\n", - "From a computational perspective, solving a QUBO problem is generally considered NP-hard. This classification implies that finding the optimal solution to a QUBO instance is believed to be computationally challenging, and there is no known polynomial-time algorithm that can efficiently solve all QUBO problems.\n", + "From a computational perspective, solving a QUBO problem is generally considered NP-hard. This classification implies that solving the optimal solution to a QUBO instance is believed to be computationally challenging, and there is no known polynomial-time algorithm that can efficiently solve all QUBO problems.\n", "\n", - "However, a promising approach called Quantum Approximate Optimization Algorithm (QAOA), introduced in this [this tutorial](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html), has the potential to offer significant advantages when applied to QUBO problem solving. QAOA leverages the inherent quantum parallelism and interference effects to explore the solution space more efficiently compared to classical methods. This efficiency can lead to faster and more optimal solutions. In QAOA, each qubit represents a binary variable, and the objective function is calculated as the expected value of a quantum state generated by the ansatz. The parameters in the ansatz are iteratively optimized by a classical algorithm to improve the solution quality.\n", + "However, a promising approach called Quantum Approximate Optimization Algorithm (QAOA), introduced in this [this tutorial](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html), has the potential to offer significant advantages when applied to QUBO problem solving. QAOA leverages inherent quantum parallelism and interference effects to explore the solution space more efficiently compared to classical methods. This efficiency can lead to faster and more optimal solutions. In QAOA, each qubit represents a binary variable, and the objective function is calculated as the expected value of a quantum state generated by the ansatz. The parameters in the ansatz are iteratively optimized by a classical algorithm to improve the solution quality.\n", "\n", "### General Case\n", "\n", @@ -34,7 +34,7 @@ "\n", "$$\\frac{1}{2}\\left(\\sum_{i=1}^n C_{ii} + \\sum_{i Date: Thu, 24 Aug 2023 12:55:17 +0100 Subject: [PATCH 631/725] reverse two previously discarded changes --- tensorcircuit/applications/__init__.py | 2 - tensorcircuit/templates/blocks.py | 96 +------------------------- 2 files changed, 1 insertion(+), 97 deletions(-) diff --git a/tensorcircuit/applications/__init__.py b/tensorcircuit/applications/__init__.py index 200fcbe6..70d128b0 100644 --- a/tensorcircuit/applications/__init__.py +++ b/tensorcircuit/applications/__init__.py @@ -3,5 +3,3 @@ the code inside is subject to change, be caution to use. Most of the useful code is and will be refactored and copied to other parts of tensorcircuit. """ - -from . import optimization \ No newline at end of file diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index 655ac21e..eacc2b42 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -5,7 +5,7 @@ # pylint: disable=invalid-name from functools import wraps -from typing import Any, Callable, Optional, Sequence, Tuple, List +from typing import Any, Callable, Optional, Sequence, Tuple import numpy as np @@ -200,97 +200,3 @@ def qft( for i in range(len(index) // 2): c.swap(index[i], index[len(index) - 1 - i]) return c - - -def QAOA_ansatz_for_Ising( - params: list, - nlayers: int, - pauli_terms: Tensor, - weights: list, - mixer: str = "X", - gap: int = 5, -) -> Circuit: - """ - Construct the QAOA ansatz for the Ising Model. - The number of qubits is determined by `pauli_terms`. - - :param params: A list of parameter values used in the QAOA ansatz. - :param nlayers: The number of layers in the QAOA ansatz. - :pauli_terms: A list of Pauli terms, where each term is represented as a list of 0/1 series. - :param weights: A list of weights corresponding to each Pauli term. - :param mixer: mixer type. The options are "X", "XY_ring", "XY_par_ring", "XY_full", and "QAMPA". - """ - nqubits = len(pauli_terms[0]) - c = Circ(nqubits) - for i in range(nqubits): - c.h(i) # Apply Hadamard gate to each qubit - - for j in range(nlayers): - # cost terms - for k in range(len(pauli_terms)): - term = pauli_terms[k] - index_of_ones = [] - for l in range(len(term)): - if term[l] == 1: - index_of_ones.append(l) - if len(index_of_ones) == 1: - c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j]) - # Apply Rz gate with angle determined by weight and current parameter value - elif len(index_of_ones) == 2: - c.exp1( - index_of_ones[0], - index_of_ones[1], - unitary=G._zz_matrix, - theta=weights[k] * params[2 * j], - ) - # Apply exp1 gate with a custom unitary (zz_matrix) and angle determined by weight and current parameter value - else: - raise ValueError("Invalid number of Z terms") - - # standard mixer - if mixer == "X": - for i in range(nqubits): - c.rx( - i, theta=params[2 * j + 1] - ) # Apply Rx gate with angle determined by current parameter value - # Parity ring XY mixer - elif mixer == "XY": - pairs = [] - for index in [0, 1]: - while index + 2 <= nqubits: - pairs.append([index, index + 1]) - index += 2 - for pair in pairs: - c.exp1(pair[0], pair[1], unitary=G._xx_matrix, theta=params[2 * j + 1]) - c.exp1(pair[0], pair[1], unitary=G._yy_matrix, theta=params[2 * j + 1]) - c.exp1(nqubits - 1, 0, unitary=G._xx_matrix, theta=params[2 * j + 1]) - c.exp1(nqubits - 1, 0, unitary=G._yy_matrix, theta=params[2 * j + 1]) - - # XY mixer with full couplings - elif mixer == "XY_full": - for q0 in range(nqubits - 1): - for q1 in range(q0 + 1, nqubits): - c.exp1(q0, q1, unitary=G._xx_matrix, theta=params[2 * j + 1]) - c.exp1(q0, q1, unitary=G._yy_matrix, theta=params[2 * j + 1]) - - # Parity ring ZZ mixer - elif mixer == "ZZ": - pairs = [] - for index in [0, 1]: - while index + 2 <= nqubits: - pairs.append([index, index + 1]) - index += 2 - for pair in pairs: - c.exp1(pair[0], pair[1], unitary=G._zz_matrix, theta=params[2 * j + 1]) - c.exp1(nqubits - 1, 0, unitary=G._zz_matrix, theta=params[2 * j + 1]) - - # ZZ mixer with full couplings - elif mixer == "ZZ_full": - for q0 in range(nqubits - 1): - for q1 in range(q0, nqubits): - c.exp1(q0, q1, unitary=G._zz_matrix, theta=params[2 * j + 1]) - - else: - raise ValueError("Invalid mixer type.") - - return c From 85e9f6ab2217e8f44b9148a28c2157ae6aa97d40 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Fri, 25 Aug 2023 12:25:34 +0100 Subject: [PATCH 632/725] reviewed V2 --- docs/source/tutorial.rst | 3 +- docs/source/tutorials/QUBO_problem.ipynb | 4 +- .../tutorials/portfolio_optimization.ipynb | 16 +- .../qaoa_portfolio_optimization.ipynb | 602 ------------------ 4 files changed, 14 insertions(+), 611 deletions(-) delete mode 100644 docs/source/tutorials/qaoa_portfolio_optimization.ipynb diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst index c7bae543..538253d7 100644 --- a/docs/source/tutorial.rst +++ b/docs/source/tutorial.rst @@ -20,5 +20,6 @@ Jupyter Tutorials tutorials/vqex_mbl.ipynb tutorials/dqas.ipynb tutorials/barren_plateaus.ipynb - tutorials/qaoa_portfolio_optimization.ipynb + tutorials/QUBO_problem.ipynb + tutorials/portfolio_optimization.ipynb tutorials/qcloud_sdk_demo.ipynb \ No newline at end of file diff --git a/docs/source/tutorials/QUBO_problem.ipynb b/docs/source/tutorials/QUBO_problem.ipynb index b28717d3..86441d71 100644 --- a/docs/source/tutorials/QUBO_problem.ipynb +++ b/docs/source/tutorials/QUBO_problem.ipynb @@ -164,7 +164,7 @@ "source": [ "Note that with 2 layers and 500 iterations, the objective function does not in this case (although it depends on the initial parameters) converge to the true value of $-4.5$. However, the we see below that the final wavefunction does have significant overlap with the desired state $|10\\rangle$, and then the output of the QAOA algorithm will, with high probability, give the best combiantion.\n", "\n", - "Define a function a print a table of results, where all quantum states are listed in the order of possibilities." + "Define a function and print a table of results, where all quantum states are listed in the order of possibilities." ] }, { @@ -291,7 +291,7 @@ "\n", " Conditional Value-at-Risk (CVaR) is a risk measure that quantifies the potential loss beyond a certain threshold (alpha), considering the tail end of the distribution. In QAOA, incorporating CVaR as an objective function allows for addressing risk-averse optimization problems effectively. By optimizing for CVaR, the algorithm focuses on minimizing the expected value of the worst-case scenario, rather than solely optimizing for the mean or expected value, which usually lead to a faster convergence to a more accurate result.\n", "\n", - " In order to showcase the performance of CVaR, a more complicated QUBO problem is used. The Q matrix is:" + " In order to showcase the performance of CVaR, a more complicated QUBO problem is used. This QUBO problem is described as a randomly generated symmetric Q matrix. The Q matrix is:" ] }, { diff --git a/docs/source/tutorials/portfolio_optimization.ipynb b/docs/source/tutorials/portfolio_optimization.ipynb index 3eeeff1e..69d9628f 100644 --- a/docs/source/tutorials/portfolio_optimization.ipynb +++ b/docs/source/tutorials/portfolio_optimization.ipynb @@ -41,7 +41,7 @@ "\n", "which is a QUBO problem\n", "\n", - "$$\\min_{x\\in\\{0,1\\}^n}\\quad x^T Q X + tB^2$$\n", + "$$\\min_{x\\in\\{0,1\\}^n}\\quad x^T Q x + tB^2$$\n", "\n", "where matrix $Q$ is\n", "\n", @@ -65,10 +65,6 @@ "import numpy as np\n", "import tensorflow as tf\n", "import matplotlib.pyplot as plt\n", - "from IPython.display import clear_output\n", - "from functools import partial\n", - "import time\n", - "import scipy.optimize as optimize\n", "\n", "from tensorcircuit.templates.ansatz import QAOA_ansatz_for_Ising\n", "from tensorcircuit.templates.conversions import QUBO_to_Ising\n", @@ -455,6 +451,14 @@ ")\n", "print_result_prob(c_final, wrap=True)" ] + }, + { + "cell_type": "markdown", + "id": "917c9415", + "metadata": {}, + "source": [ + "Compared with standard X mixer, the XY mixer gives a higher probability to measure the best result." + ] } ], "metadata": { @@ -473,7 +477,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb b/docs/source/tutorials/qaoa_portfolio_optimization.ipynb deleted file mode 100644 index 7f390853..00000000 --- a/docs/source/tutorials/qaoa_portfolio_optimization.ipynb +++ /dev/null @@ -1,602 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "6ddb8a88-779a-43f7-ae14-115463bd87f5", - "metadata": {}, - "source": [ - "# Solving QUBO problems using QAOA\n", - "\n", - "## Overview\n", - "\n", - "Here we show how to solve a quadratic unconstrained binary optimization (QUBO) problem using QAOA. Later on below we will extend this to show how to solve binary Markowitz portfolio optimization problems.\n", - "\n", - "Consider minimizing the following 2x2 QUBO objective function:\n", - "\n", - "$\\begin{pmatrix}x_1 & x_2\\end{pmatrix}\\begin{pmatrix}-5& -2 \\\\-2 & 6\\end{pmatrix}\\begin{pmatrix}x_1\\\\x_2\\end{pmatrix} = -5x_1^2 -4x_1x_2 +6x_2^2$\n", - "\n", - "Clearly this is minimized at $(x_1,x_2) = (1,0)$, with corresponding objective function value of $-5$\n", - "\n", - "We first convert this to an Ising Hamiltonian by mapping $x_i\\rightarrow \\frac{I-Z_i}{2}$\n", - "\n", - "This gives\n", - "\n", - "$$-\\frac{5}{4}(I-Z_1)^2 -\\frac{4}{4}(I-Z_1)(I-Z_2) + \\frac{6}{4}(I-Z_2)^2 $$\n", - "\n", - "which simplifies to\n", - "\n", - "$$-\\frac{1}{2}I +\\frac{7}{2}Z_1 -2Z_2 -Z_1Z_2$$ \n", - "\n", - "The $-I/2$ term is simply a constant offset, so we can solve the problem by finding the minimum of \n", - "\n", - "$$\\langle \\psi | \\frac{7}{2}Z_1 -2Z_2 -Z_1Z_2 |\\psi\\rangle$$ \n", - "\n", - "Note that the minimum should correspond to the computational basis state $|10\\rangle$, and the corresponding true objective function value should be $-4.5$ (ignoring the offset value of $-1/2$)" - ] - }, - { - "cell_type": "markdown", - "id": "8176aa81", - "metadata": {}, - "source": [ - "## Setup" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "45964c1f", - "metadata": {}, - "outputs": [], - "source": [ - "import tensorcircuit as tc\n", - "import numpy as np\n", - "import tensorflow as tf\n", - "import matplotlib.pyplot as plt\n", - "from functools import partial" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "4006848a-1a2f-407a-9f80-63e75ea0d3a4", - "metadata": {}, - "outputs": [], - "source": [ - "# we first manually encode the terms (-7/2) Z_1 - 2 Z_2 - Z_1Z_2 as:\n", - "pauli_terms = [\n", - " [1, 0],\n", - " [0, 1],\n", - " [1, 1],\n", - "] # see the TensorCircuit whitepaper for 'pauli structures'\n", - "weights = [7 / 2, -2, -1]\n", - "\n", - "# see below for a function to generate the pauli terms and weights from the QUBO matrix" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d197cf4a-1bad-4470-a846-998bfe68ba3c", - "metadata": {}, - "outputs": [], - "source": [ - "# Now we define the QAOA ansatz of depth nlayers\n", - "def QAOA_from_Ising(params, nlayers, pauli_terms, weights):\n", - " nqubits = len(pauli_terms[0])\n", - " c = tc.Circuit(nqubits)\n", - " for i in range(nqubits):\n", - " c.h(i)\n", - " for j in range(nlayers):\n", - " for k in range(len(pauli_terms)):\n", - " term = pauli_terms[k]\n", - " index_of_ones = []\n", - " for l in range(len(term)):\n", - " if term[l] == 1:\n", - " index_of_ones.append(l)\n", - " if len(index_of_ones) == 1:\n", - " c.rz(index_of_ones[0], theta=2 * weights[k] * params[2 * j])\n", - " elif len(index_of_ones) == 2:\n", - " c.exp1(\n", - " index_of_ones[0],\n", - " index_of_ones[1],\n", - " unitary=tc.gates._zz_matrix,\n", - " theta=weights[k] * params[2 * j],\n", - " )\n", - " else:\n", - " raise ValueError(\"Invalid number of Z terms\")\n", - "\n", - " for i in range(nqubits):\n", - " c.rx(i, theta=params[2 * j + 1]) # mixing terms\n", - " return c" - ] - }, - { - "cell_type": "markdown", - "id": "cb38c120-500a-44cc-96ec-fb5ceb11032d", - "metadata": {}, - "source": [ - "For a general state that is the output of a quantum circuit c, we first define the corresponding loss with respect to the Ising Hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "88cec9cf-3ab6-4a4c-b743-ed95ee8c3817", - "metadata": {}, - "outputs": [], - "source": [ - "def Ising_loss(c, pauli_terms, weights):\n", - " loss = 0.0\n", - " for k in range(len(pauli_terms)):\n", - " term = pauli_terms[k]\n", - " index_of_ones = []\n", - "\n", - " for l in range(len(term)):\n", - " if term[l] == 1:\n", - " index_of_ones.append(l)\n", - "\n", - " if len(index_of_ones) == 1:\n", - " delta_loss = weights[k] * c.expectation_ps(z=[index_of_ones[0]])\n", - "\n", - " else:\n", - " delta_loss = weights[k] * c.expectation_ps(\n", - " z=[index_of_ones[0], index_of_ones[1]]\n", - " )\n", - "\n", - " loss += delta_loss\n", - "\n", - " return K.real(loss)" - ] - }, - { - "cell_type": "markdown", - "id": "30a3aa96-7823-4337-9b2f-5170502bb893", - "metadata": {}, - "source": [ - "For the particular case of a circuit corresponding to a QAOA ansatz this is:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "26e4bec2-ce5b-4d0d-9e06-c80fda20619f", - "metadata": {}, - "outputs": [], - "source": [ - "def QAOA_loss(nlayers, pauli_terms, weights, params):\n", - " c = QAOA_from_Ising(params, nlayers, pauli_terms, weights)\n", - " return Ising_loss(c, pauli_terms, weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ca8b7a76-5c4f-4ad8-9173-90126b8bb93b", - "metadata": {}, - "outputs": [], - "source": [ - "K = tc.set_backend(\"tensorflow\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d5b1897f-cd77-4cd3-bd3b-ece64e6004fc", - "metadata": {}, - "outputs": [], - "source": [ - "def QAOA_solve(pauli_terms, weights, nlayers, iterations):\n", - " print_every = 100\n", - " learning_rate = 1e-2\n", - "\n", - " loss_val_grad = K.value_and_grad(partial(QAOA_loss, nlayers, pauli_terms, weights))\n", - " loss_val_grad_jit = K.jit(loss_val_grad)\n", - "\n", - " opt = K.optimizer(tf.keras.optimizers.Adam(learning_rate))\n", - "\n", - " params = K.implicit_randn(shape=[2 * nlayers], stddev=0.5)\n", - " print(f\"initial params: {params}\")\n", - " for i in range(iterations):\n", - " loss, grads = loss_val_grad_jit(params)\n", - " if i % print_every == 0:\n", - " print(K.numpy(loss))\n", - " params = opt.update(grads, params)\n", - "\n", - " return params" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "2bc533da-b4f2-4ffb-b486-c65880a30a6d", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "initial params: [ 0.39931756 -0.49578992 -0.22545011 -0.40585193]\n", - "-2.1728685\n", - "-4.177884\n", - "-4.2291102\n", - "-4.2291365\n", - "-4.229136\n" - ] - } - ], - "source": [ - "iterations = 500\n", - "nlayers = 2\n", - "final_params = QAOA_solve(pauli_terms, weights, nlayers, iterations)" - ] - }, - { - "cell_type": "markdown", - "id": "e93d8cbe-2884-4f0a-80f8-3b600194927b", - "metadata": {}, - "source": [ - "We note that for nlayers=2 and 500 iterations, the objective function does not in this case (although it depends on the initial parameters)converge to the true value of $-4.5$. However, the we see below that the final wavefunction does have large overlap with the desired state $|10\\rangle$, so measuring the output of the QAOA algorithm will, with high probability, output the correct answer." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "294ea9ce-5064-4176-94d0-8dbb7d1707f8", - "metadata": {}, - "outputs": [], - "source": [ - "def print_output(c):\n", - " n = c._nqubits\n", - " N = 2**n\n", - " x_label = r\"$\\left|{0:0\" + str(n) + r\"b}\\right>$\"\n", - " labels = [x_label.format(i) for i in range(N)]\n", - " plt.bar(range(N), c.probability())\n", - " plt.xticks(range(N), labels, rotation=70);" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "fc1353ab-7a7a-4cdc-931c-3b90417c4961", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "c = QAOA_from_Ising(final_params, nlayers, pauli_terms, weights)\n", - "\n", - "print_output(c)" - ] - }, - { - "cell_type": "markdown", - "id": "d155c5e5-5843-4bba-9edc-595a18cb0c9a", - "metadata": {}, - "source": [ - "## General Case\n", - "\n", - "For the general QUBO case, we wish to minimize\n", - "\n", - "$$ x^T Q x$$\n", - "\n", - "where $x\\in\\{0,1\\}^n$ and $Q\\in\\mathbb{R}^{n\\times n}$ is a real symmetric matrix.\n", - "\n", - "This maps to an Ising Hamiltonian \n", - "\n", - "$$\\frac{1}{2}\\left(\\sum_{i=1}^n C_{ii} + \\sum_{i 0 $: risk-appetite\n", - "* $\\Sigma \\in \\mathbb{R}^{n\\times n}$: covariance matrix of the assets\n", - "* $\\mu\\in\\mathbb{R}^n$: mean return of the assets\n", - "* $B$: budget (i.e., total number of assets out of $n$ that can be selected)\n", - "\n", - "Our first step is to convert this constrained quadratic programming problem into a QUBO. We do this by adding a penalty factor $t$ and consider the alternative problem:\n", - "\n", - "$$ \\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^Tx + t(1^Tx-B)^2$$\n", - "\n", - "The variables in the linear terms $\\mu^Tx = \\mu_1 x_1 + \\mu_2 x_2+\\ldots$ can all be squared (since they are boolean variables), i.e. we can consider\n", - "\n", - "$$\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\sum_{i=1}^n\\mu_i x_i^2 + t(1^Tx-B)^2$$\n", - "\n", - "which is a QUBO defined by the matrix $Q$ \n", - "\n", - "$$ Q = q\\Sigma -\\mu\\begin{pmatrix}1 & \\\\ & 1\\\\ & & \\ddots\\end{pmatrix} + t\\begin{pmatrix}1 -2B & 1 & \\ldots & 1 \\\\\n", - "1 & 1-2B & 1 & \\ldots \\\\1 & 1 & 1-2B \\\\\n", - "\\vdots\\end{pmatrix}$$\n", - "\n", - "i.e., we wish to mimimize\n", - "\n", - "$$ x^T Q X + tB$$\n", - "\n", - "and we ignore the constant term $t B$.\n", - "We can now solve this by QAOA as above.\n", - "\n", - "Let us first define a function to convert portfolio data into a QUBO matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "3080b901-fb6c-4bda-8348-c96540cbc39a", - "metadata": {}, - "outputs": [], - "source": [ - "def QUBO_from_portfolio(cov, mean, q, B, t):\n", - " # cov: n x n covariance numpy array\n", - " # mean: numpy array of means\n", - " n = cov.shape[0]\n", - " R = np.diag(mean)\n", - " S = np.ones((n, n)) - 2 * B * np.diag(np.ones(n))\n", - "\n", - " Q = q * cov - R + t * S\n", - " return Q" - ] - }, - { - "cell_type": "markdown", - "id": "b4cdcb0e-15a2-461c-b487-084488486c67", - "metadata": {}, - "source": [ - "We can test this using the qiskit_finance package to generate some stock covariance and mean data:\n", - "\n", - "*Note that this was tested with qiskit version 0.39.3 and qiskit-finance version 0.3.4.*" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "2168c69e-73ce-4306-8a39-4ddc475acc8f", - "metadata": {}, - "outputs": [], - "source": [ - "import datetime\n", - "from qiskit_finance.data_providers import RandomDataProvider" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "6a7bc671-a496-4cd8-b954-50a280b5dd85", - "metadata": {}, - "outputs": [], - "source": [ - "num_assets = 4\n", - "seed = 123\n", - "\n", - "# Generate expected return and covariance matrix from (random) time-series\n", - "stocks = [(\"TICKER%s\" % i) for i in range(num_assets)]\n", - "data = RandomDataProvider(\n", - " tickers=stocks,\n", - " start=datetime.datetime(2016, 1, 1),\n", - " end=datetime.datetime(2016, 1, 30),\n", - " seed=seed,\n", - ")\n", - "data.run()\n", - "\n", - "mu = data.get_period_return_mean_vector()\n", - "sigma = data.get_period_return_covariance_matrix()" - ] - }, - { - "cell_type": "markdown", - "id": "f6dc53d4-7ed0-436d-aa1f-8674c56e756e", - "metadata": {}, - "source": [ - "Using this mean and covariance data, we can now define our portfolio optimization problem, convert it to a QUBO matrix, and then extract the pauli terms and weights" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "3f6edcd5-3c10-49fc-86ea-160fc6d3187e", - "metadata": {}, - "outputs": [], - "source": [ - "q = 0.5\n", - "budget = 3 # Note that in this example, there are 4 assets, but a budget of only 3\n", - "penalty = 3\n", - "\n", - "Q = QUBO_from_portfolio(sigma, mu, q, budget, penalty)\n", - "portfolio_pauli_terms, portfolio_weights, portfolio_offset = QUBO_to_Ising(Q)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "809b90fa-7047-4c88-b862-355da4f58a50", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0000: 21.006979417669037\n", - "0001: 6.006208358124514\n", - "0010: 6.006857249462996\n", - "0011: -2.994037697463167\n", - "0100: 6.007889613170697\n", - "0101: -2.992836964752989\n", - "0110: -2.992179512275861\n", - "0111: -5.9930299775811875\n", - "1000: 5.992965725313347\n", - "1001: -3.007905195444355\n", - "1010: -3.0070278423618397\n", - "1011: -6.008022650501182\n", - "1100: -3.0060506769683\n", - "1101: -6.006877116105166\n", - "1110: -6.005991201884008\n", - "1111: -3.006941528402507\n" - ] - } - ], - "source": [ - "# Brute force search over classical results for comparison before we run QAOA\n", - "for i in range(2):\n", - " for j in range(2):\n", - " for k in range(2):\n", - " for l in range(2):\n", - " x = np.array([i, j, k, l])\n", - " print(f\"{i}{j}{k}{l}: {np.dot(x,np.dot(Q,x))- portfolio_offset}\")" - ] - }, - { - "cell_type": "markdown", - "id": "b5e69a34-87dc-47b4-aeb2-3b9a03fd0974", - "metadata": {}, - "source": [ - "We see that, due to the penalty, the lowest energy solutions correspond to 0111, 1011, 1101, 1110, i.e. the portfolios with only 3 assets." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "80c1de6c-d3a4-4ea5-922a-bffb59dd1ea3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "initial params: [ 0.13778198 -0.75357753 -0.01271329 -0.5461785 -0.1501883 0.36323363]\n", - "-4.204754\n", - "-5.681799\n", - "-5.6837077\n", - "-5.6837044\n", - "-5.6837053\n", - "-5.683704\n", - "-5.6837063\n", - "-5.683709\n", - "-5.6837063\n", - "-5.683705\n" - ] - } - ], - "source": [ - "iterations = 1000\n", - "nlayers = 3\n", - "final_params = QAOA_solve(portfolio_pauli_terms, portfolio_weights, nlayers, iterations)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "8a9064e3-0c61-4d2d-baf9-bdf120c0331d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAHACAYAAACBGTONAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoZElEQVR4nO3df3DU9Z3H8dcmSEJA4g80AZoSQCiCQPghMUixHVOCtZZ4SJHzRKNHPZ1c7aSnbawm+GMMAiI6ZYrHlbO2oqBzMteTRrx4caYQQYlWBamgUJBkkxCE8KPk177vDyerW8KPTTa7n919Pma+Y/Ldz37e33c+u+Hld7+78ZiZCQAAwGEJkT4AAACAsyGwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4r1ekDyAUfD6fampqdP7558vj8UT6cAAAwDkwMx09elSDBg1SQsKZz6HERGCpqalRRkZGpA8DAAB0wf79+/WNb3zjjGNiIrCcf/75kr5suH///hE+GgAAcC6ampqUkZHh/3f8TGIisHS8DNS/f38CCwAAUeZcLufgolsAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA83pF+gAAAJGX+YvXemzuvYuu77G5gxGJHnuqpis/03DiDAsAAHAeZ1gAdEs8/J85gMjjDAsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcF6XAsuKFSuUmZmp5ORkZWdna+vWracdu2rVKn3729/WhRdeqAsvvFC5ubmnjDczlZSUaODAgerTp49yc3O1a9eurhwaAACIQUEHlrVr16qoqEilpaWqrq7W+PHjlZeXp/r6+k7HV1ZWat68efq///s/VVVVKSMjQzNmzNCBAwf8YxYvXqxnnnlGK1eu1JYtW9S3b1/l5eXp5MmTXe8MAADEjKADy7Jly7RgwQIVFBRo9OjRWrlypVJSUrR69epOx7/wwgu65557lJWVpVGjRuk//uM/5PP5VFFRIenLsyvLly/Xgw8+qFmzZmncuHF6/vnnVVNTo/Xr13c6Z3Nzs5qamgI2AAAQu4IKLC0tLdq2bZtyc3O/miAhQbm5uaqqqjqnOU6cOKHW1lZddNFFkqQ9e/bI6/UGzJmamqrs7OzTzllWVqbU1FT/lpGREUwbAAAgygQVWA4ePKj29nalpaUF7E9LS5PX6z2nOX7+859r0KBB/oDScb9g5iwuLtaRI0f82/79+4NpAwAARJle4Sy2aNEivfTSS6qsrFRycnKX50lKSlJSUlIIjwwAALgsqDMsAwYMUGJiourq6gL219XVKT09/Yz3Xbp0qRYtWqSNGzdq3Lhx/v0d9+vKnAAAID4EFVh69+6tSZMm+S+YleS/gDYnJ+e091u8eLEeffRRlZeXa/LkyQG3DR06VOnp6QFzNjU1acuWLWecEwAAxI+gXxIqKirSbbfdpsmTJ2vKlClavny5jh8/roKCAknS/PnzNXjwYJWVlUmSnnjiCZWUlGjNmjXKzMz0X5fSr18/9evXTx6PRz/96U/12GOPacSIERo6dKgeeughDRo0SPn5+aHrFAAARK2gA8vcuXPV0NCgkpISeb1eZWVlqby83H/R7L59+5SQ8NWJm1//+tdqaWnRTTfdFDBPaWmpFi5cKEm6//77dfz4cf34xz/W4cOHNW3aNJWXl3frOhcAABA7unTRbWFhoQoLCzu9rbKyMuD7vXv3nnU+j8ejRx55RI888khXDgcAAMQ4/pYQAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnNelwLJixQplZmYqOTlZ2dnZ2rp162nHbt++XbNnz1ZmZqY8Ho+WL19+ypiFCxfK4/EEbKNGjerKoQEAgBgUdGBZu3atioqKVFpaqurqao0fP155eXmqr6/vdPyJEyc0bNgwLVq0SOnp6aedd8yYMaqtrfVvf/rTn4I9NAAAEKOCDizLli3TggULVFBQoNGjR2vlypVKSUnR6tWrOx1/5ZVXasmSJbr55puVlJR02nl79eql9PR0/zZgwIDTjm1ublZTU1PABgAAYldQgaWlpUXbtm1Tbm7uVxMkJCg3N1dVVVXdOpBdu3Zp0KBBGjZsmG655Rbt27fvtGPLysqUmprq3zIyMrpVGwAAuC2owHLw4EG1t7crLS0tYH9aWpq8Xm+XDyI7O1vPPfecysvL9etf/1p79uzRt7/9bR09erTT8cXFxTpy5Ih/279/f5drAwAA9/WK9AFI0nXXXef/ety4ccrOztaQIUO0bt063XnnnaeMT0pKOuPLSwAAILYEdYZlwIABSkxMVF1dXcD+urq6M15QG6wLLrhAI0eO1O7du0M2JwAAiF5BBZbevXtr0qRJqqio8O/z+XyqqKhQTk5OyA7q2LFj+vTTTzVw4MCQzQkAAKJX0C8JFRUV6bbbbtPkyZM1ZcoULV++XMePH1dBQYEkaf78+Ro8eLDKysokfXmh7o4dO/xfHzhwQO+//7769eunyy67TJL0b//2b7rhhhs0ZMgQ1dTUqLS0VImJiZo3b16o+gQAAFEs6MAyd+5cNTQ0qKSkRF6vV1lZWSovL/dfiLtv3z4lJHx14qampkYTJkzwf7906VItXbpU11xzjSorKyVJn3/+uebNm6fGxkZdcsklmjZtmt5++21dcskl3WwPAADEgi5ddFtYWKjCwsJOb+sIIR0yMzNlZmec76WXXurKYQAAgDjB3xICAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA87oUWFasWKHMzEwlJycrOztbW7duPe3Y7du3a/bs2crMzJTH49Hy5cu7PScAAIgvQQeWtWvXqqioSKWlpaqurtb48eOVl5en+vr6TsefOHFCw4YN06JFi5Senh6SOQEAQHwJOrAsW7ZMCxYsUEFBgUaPHq2VK1cqJSVFq1ev7nT8lVdeqSVLlujmm29WUlJSSOYEAADxJajA0tLSom3btik3N/erCRISlJubq6qqqi4dQFfmbG5uVlNTU8AGAABiV1CB5eDBg2pvb1daWlrA/rS0NHm93i4dQFfmLCsrU2pqqn/LyMjoUm0AABAdovJdQsXFxTpy5Ih/279/f6QPCQAA9KBewQweMGCAEhMTVVdXF7C/rq7utBfU9sScSUlJp70eBgAAxJ6gzrD07t1bkyZNUkVFhX+fz+dTRUWFcnJyunQAPTEnAACILUGdYZGkoqIi3XbbbZo8ebKmTJmi5cuX6/jx4yooKJAkzZ8/X4MHD1ZZWZmkLy+q3bFjh//rAwcO6P3331e/fv102WWXndOcAAAgvgUdWObOnauGhgaVlJTI6/UqKytL5eXl/otm9+3bp4SEr07c1NTUaMKECf7vly5dqqVLl+qaa65RZWXlOc0JAADiW9CBRZIKCwtVWFjY6W0dIaRDZmamzKxbcwIAgPgWle8SAgAA8YXAAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnNcr0gcAAABCI/MXr/XY3HsXXd9jc58LzrAAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAzutSYFmxYoUyMzOVnJys7Oxsbd269YzjX375ZY0aNUrJyckaO3asNmzYEHD77bffLo/HE7DNnDmzK4cGAABiUNCBZe3atSoqKlJpaamqq6s1fvx45eXlqb6+vtPxmzdv1rx583TnnXfqvffeU35+vvLz8/XRRx8FjJs5c6Zqa2v924svvti1jgAAQMwJOrAsW7ZMCxYsUEFBgUaPHq2VK1cqJSVFq1ev7nT8008/rZkzZ+q+++7T5ZdfrkcffVQTJ07Ur371q4BxSUlJSk9P928XXnhh1zoCAAAxJ6jA0tLSom3btik3N/erCRISlJubq6qqqk7vU1VVFTBekvLy8k4ZX1lZqUsvvVTf+ta3dPfdd6uxsfG0x9Hc3KympqaADQAAxK6gAsvBgwfV3t6utLS0gP1paWnyer2d3sfr9Z51/MyZM/X888+roqJCTzzxhN566y1dd911am9v73TOsrIypaam+reMjIxg2gAAAFGmV6QPQJJuvvlm/9djx47VuHHjNHz4cFVWVuraa689ZXxxcbGKior83zc1NRFaAACIYUGdYRkwYIASExNVV1cXsL+urk7p6emd3ic9PT2o8ZI0bNgwDRgwQLt37+709qSkJPXv3z9gAwAAsSuowNK7d29NmjRJFRUV/n0+n08VFRXKycnp9D45OTkB4yXpjTfeOO14Sfr888/V2NiogQMHBnN4AAAgRgX9LqGioiKtWrVKv/3tb/Xxxx/r7rvv1vHjx1VQUCBJmj9/voqLi/3j7733XpWXl+vJJ5/Uzp07tXDhQr377rsqLCyUJB07dkz33Xef3n77be3du1cVFRWaNWuWLrvsMuXl5YWoTQAAEM2CvoZl7ty5amhoUElJibxer7KyslReXu6/sHbfvn1KSPgqB02dOlVr1qzRgw8+qAceeEAjRozQ+vXrdcUVV0iSEhMT9cEHH+i3v/2tDh8+rEGDBmnGjBl69NFHlZSUFKI2AQBANOvSRbeFhYX+MyR/r7Ky8pR9c+bM0Zw5czod36dPH73++utdOQwAABAn+FtCAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJxHYAEAAM4jsAAAAOcRWAAAgPMILAAAwHkEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgPAILAABwHoEFAAA4j8ACAACcR2ABAADOI7AAAADnEVgAAIDzCCwAAMB5BBYAAOA8AgsAAHAegQUAADiPwAIAAJzXK9IHACB0Mn/xWo/NvXfR9T02NwCcDYEFEdNT/7i69A8rASI2hHsd4+FxEw89IrR4SQgAADiPwAIAAJxHYAEAAM4jsAAAAOd1KbCsWLFCmZmZSk5OVnZ2trZu3XrG8S+//LJGjRql5ORkjR07Vhs2bAi43cxUUlKigQMHqk+fPsrNzdWuXbu6cmgAACAGBR1Y1q5dq6KiIpWWlqq6ulrjx49XXl6e6uvrOx2/efNmzZs3T3feeafee+895efnKz8/Xx999JF/zOLFi/XMM89o5cqV2rJli/r27au8vDydPHmy650BAICYEXRgWbZsmRYsWKCCggKNHj1aK1euVEpKilavXt3p+KefflozZ87Ufffdp8svv1yPPvqoJk6cqF/96leSvjy7snz5cj344IOaNWuWxo0bp+eff141NTVav359t5oDAACxIajPYWlpadG2bdtUXFzs35eQkKDc3FxVVVV1ep+qqioVFRUF7MvLy/OHkT179sjr9So3N9d/e2pqqrKzs1VVVaWbb775lDmbm5vV3Nzs//7IkSOSpKampmDaOWdXlL7eI/NK0kcP54W1Zrjrnammr/lEj9Q73eMglnqUOu8z3PUiUZN1DH29SNSMhx57sqZLPYZiTjM7+2ALwoEDB0ySbd68OWD/fffdZ1OmTOn0Puedd56tWbMmYN+KFSvs0ksvNTOzTZs2mSSrqakJGDNnzhz70Y9+1OmcpaWlJomNjY2NjY0tBrb9+/efNYNE5SfdFhcXB5y18fl8OnTokC6++GJ5PJ6IHVdTU5MyMjK0f/9+9e/fn5pRWi8SNekxNmrSY2zUjIceI1Xz75mZjh49qkGDBp11bFCBZcCAAUpMTFRdXV3A/rq6OqWnp3d6n/T09DOO7/hvXV2dBg4cGDAmKyur0zmTkpKUlJQUsO+CCy4IppUe1b9//7AvfjzUpMfYqEmPsVGTHqkZKqmpqec0LqiLbnv37q1JkyapoqLCv8/n86miokI5OTmd3icnJydgvCS98cYb/vFDhw5Venp6wJimpiZt2bLltHMCAID4EvRLQkVFRbrttts0efJkTZkyRcuXL9fx48dVUFAgSZo/f74GDx6ssrIySdK9996ra665Rk8++aSuv/56vfTSS3r33Xf17//+75Ikj8ejn/70p3rsscc0YsQIDR06VA899JAGDRqk/Pz80HUKAACiVtCBZe7cuWpoaFBJSYm8Xq+ysrJUXl6utLQ0SdK+ffuUkPDViZupU6dqzZo1evDBB/XAAw9oxIgRWr9+va644gr/mPvvv1/Hjx/Xj3/8Yx0+fFjTpk1TeXm5kpOTQ9Bi+CQlJam0tPSUl6uoGV31IlGTHmOjJj3GRs146DFSNbvDY3Yu7yUCAACIHP6WEAAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsPcDM5PP5Ar6PtZr0GBs16TE2atIjNaOlXnfwOSxh1N7ersTExJiuSY+xUZMeY6MmPVIzWuqdCwJLCNXX1+vdd9/VX//6V40ZM0YXXHCBamtrlZGRodGjR8dETXqkx2ipSY/0SE136oUCgSWE/vjHP2rNmjX64osv9M4772jQoEHKyMhQdXW1Wlpa9PDDD+v2229Xnz595PP5Av6EQVdt2LBBL774Ythq0iM90iM90mPoa4a7z0j02G2GkKqtrbXDhw+bmdnOnTuturrajh49aitXrrQZM2bY4sWLQ17T6/XakSNHzMxs165d9uc//7lHa9IjPXYVPdJjV8RDj2bh7zMSPXYHgSVEfD6f/+u2tjZrbW0NuL25udleeOEFGzt2rF199dW2efPmHj+mtrY2W7NmTchq0iM99hR6DB49xkaPZu712RM9hgIvCYXQzp07tXjxYp08eVKJiYnKyMjQDTfcoJycHP+YQ4cOqaSkRLt379a9996r6667LqTH0Nmpu0OHDumXv/yl9uzZ0+2a9PhVPXrsHnqkx3MRDz1Kke8zHD12lwMvSkW3jrxXUVGh2bNna/v27WptbVV7e7s2bdqkf/7nf9a8efNUWVkpSbrooov02GOP6Zvf/Ka8Xm/AHMHW/PTTT/Xf//3fqqmpUVtbmyQFPOB8Pp/a2tp00UUX6cknn+xyTXqkR3qkR3oMbY+R6DMSPYZUT5/CiXXt7e1mZnbttdfaXXfd5T+Vd+TIEdu6dastX77cvvvd79qUKVNs+/btAfdta2vrVs3vf//75vF4bNKkSbZw4UJ7++23rbGx0X+7mVl1dbU98sgj3apJj/RIj2evSY9fosfga4arz0j0GEoElhBobW21CRMm2Nq1azu9vba21qZMmWI33nij+Xy+kCx8c3OzDR8+3BYvXmw/+clPbMCAAXbeeefZd7/7XVuxYoV99NFHduzYMZs7d679wz/8g5l17wFHj/TYVfRIj10RDz2ahb/PSPQYKgSWEGhtbbW7777bRo0aZbt37w64gKrDxo0bbcSIEbZnz56Q1Pzggw9s5syZ9sc//tG/r7Ky0mbPnm1JSUmWmppqN954oyUkJFh5ebmZdf+XBz3SY1fQIz12RTz0aBb+PiPRY6gQWEJkx44dNnXqVJs1a5Zt3LjRmpqaAk6vvfrqqzZgwICQ1WtsbLTXXnvNdu3aZWYWUMvM7MUXX7RvfvObNnjw4JDVpEd67Ap6pMeuiocezcLbZ6R6DAUCSwh0LPibb75pOTk55vF4bOzYsXb//ffbs88+a//4j/9oEydOtF/84hdmZqe8ZS0Utc1OfTvcjBkz7K677gpJzY7UX1lZadOmTQtrj1/Xkz2yjqxjd7GOrGOwXFjLnu4xVAgsPaC6utp+8pOf2GWXXWZXXHGFXXvttfbss89aU1OTmVmnp/xC4eun7WpqaiwzM9Pee+89Mzs1RXfX+++/bz/72c9s5MiRPdbj2ebo6R5ZR9axO1hH1rErenotI72O3cHnsHSTz+fTxx9/LK/Xqy+++EKTJ09WZmam//b6+nqdf/756tOnT4/UPHbsmCZOnKiMjIyAMa2trdqzZ49GjhwZsrod8yYmJga8Be7gwYNKSUlRSkpKSGudTXNzs/bu3atvfetb3Z6LdWQdQ1GTdWQdu8qVtQzlOoZcpBNTNOpIqHv37rV/+Zd/sYSEBEtLS7Mrr7zSxo0bZ3PnzrVXXnnFTpw4ETC+J2pOmTLFX3P9+vV28uTJbtf6uhMnTlhdXd0pKdvn81lra2uP/F/N6WqGGuvIOoa6JuvYdfG0jmbhX8twrWNP4gxLF3T82e077rhDn3zyiR5//HENGTJE27Zt0/bt2/XOO++orq5Os2fP1v333x+VNTvqPfzww9q8ebPmzZunq666ShkZGerbt2/A2Lq6OtXX12vs2LFhq1lfXy+v16tx48Z1ux7r+CXW0d2arGNsrOPXa4ZrLcO9jj0q0okpmqWnpwe8NazDzp07rbS01BISEuyJJ56I6poXX3yxDRs2zHr37m0XX3yx3Xrrrfbqq6/a3r17rbm52czMFi5caLfeemvU1mQdWcdoqck6xsY6moX/5xqJx06oEVi6qLGx0XJzc+2Xv/zlacc89NBD9v3vf9//1zCjrea2bdtswoQJ9uGHH5rP57NVq1bZpEmTzOPx2LBhw+xnP/uZvfbaa3bRRRfZqlWrzKz779cPd03WkXWMlpqs45eifR3Nwv9zjcRjpycQWLrhqaeesszMTFuzZo3/Cu6ve/311+2SSy4J6WuR4ay5fft2KykpsU2bNgXsr62ttYcfftiGDh1qHo/HUlJSQtZjJGqyjqxjNNRkHb8U7etoFv6fayTWsScQWLrh0KFDVlBQYMnJyZabm2u/+93v7C9/+Yvt27fPtmzZYnPmzLFZs2aZWejSajhrtre32+eff24tLS1mZtbS0nLKBVszZsywW265xcxC8379SNT84osv7I477gjrOoazZnt7ux04cMD/swrXOoa7Js9Hno/RUjPcz49IPB97AoGli76eQt966y37wQ9+YMnJydavXz/LycmxlJQUy8/P9//BqlBcmR2Jmh3a29v983VcxV5bW2sej8f+8Ic/mFnoTyGGu+amTZssPz/f+vTpE5afaaRqdgjXOoajJs9Hno/RWvPrwv2cjMTvgO7gXULdcPjwYSUnJys5OVmSdPLkSf3v//6vdu/ercmTJysrK0v9+vWL6ppHjx5VUlKSevfu7d/n8/mUkJCghoYG/ed//mfIrp6PRE0z88/t8XgkSX/729/01ltv6ZNPPtHEiRND/jMNd00z89fpTE+sYyRq8nzk+RhNNcP5/IjE87EnEFiC1NLSosrKSi1evFi9e/dWnz59NGTIEP3whz/Ud77znVPGn+2B4mLNzuplZmZq1qxZmj59esDYjrfMdVckav49n88nj8fT7fVyvWZnWltbdd5550VdTZ6PPB+jvebphPs5GYnfAcEisJyjjgS+ZMkSrV69WpdffrnS09PV0tKiTz/9VA0NDcrKytI999yjqVOnRmXNM9X77LPP1NDQoPHjx+tf//VflZ2dHYIOw1+zo15lZaUaGxt11VVX6dJLLz3lidrW1iYzC8kTONw1z7WeFLp/bMJdk+cjz8dYrCmF9vkRzt8BYRHO159iwaBBg+zZZ5/1f3/s2DGrrq62p59+2nJycuyqq66y3bt3R3XNeOhx4MCB5vF4bMyYMVZcXGx/+tOfrKGhIeC123Xr1tmSJUuitmY89BgPj9V46DEeHquRqBmJHnsSgSUI+/fvt1GjRllVVVWnt3u9Xhs1apQVFRVFbc146HH79u02fPhwe/nll+3nP/+5paenW2Jiol199dX21FNP2Z///Gerr6+3yy+/3MrKysys+xfahbtmPPQYD4/VeOgxHh6rkagZiR57GoElCCdOnLDrr7/epk6davv37+/0/eq/+c1vbOzYsf6/dxFtNeOhx40bN9oPf/hD/18jNTN7++237ZZbbrG+fftav3797JprrjGPx2MNDQ1m1v2/WxLumvHQYzw8VuOhx3h4rEaiZiR67GkEliBVVVXZxIkT7YYbbrDXX3/dDh8+HPCe9Yceesiys7PNLHRpNdw1Y73Huro627hxozU2NnY63/r16+3CCy+0mTNnmllo3uIX7prx0KNZ7D9WI1Ev3DXj5bEaD78DehqBJQgdC/7GG2/Y1VdfbR6Px0aOHGmFhYX2+OOP2/Tp023MmDH2yiuvmFnoPmAonDXjocev6/g/ivb29oBfyGlpafbcc8+FvF4kasZ6j2+++aZNnz49rI+bcNeMhx6/LpyP1XiqGYkeQ4l3CXXD9u3b9cILL2jDhg3q37+/hgwZovnz5+t73/tezNSMhx6lwCvlP/zwQ82ePVt/+ctfevTtjeGuGes97tixQy+99JL+53/+R/369QvL4ybcNWOxRzvL27574nETDzUj0WNPI7Cco8OHD+u9995TbW2tWlpaNHXqVI0cOdJ/+9GjR9WvX7+QLny4a8ZTj16vVz6fT1dddZWGDx8eMKa5uVkNDQ36xje+4X97YDTVjIcev66trU2JiYkBj5GjR48qJSWlx96uGe6a8dDj6fztb3/TwYMHlZGREdLHTbzXjESP3Ra5kzvu63ipoqKiwq6//nrzeDw2ZMgQy87OtjFjxtjs2bNt3bp1dvz48YDx0VQz3nu84oor7KabbrJXX33VTp482b3GIlgzHnrseJmpvr7eamtrT3lcdHzMeCjf6RDumvTYM+KhZiR6DDfOsJxBR+rs+GjmhQsXKikpSdu2bdMHH3ygLVu26MCBA7r99tt1zz33RGVNeqTHaKnZUe/GG2/UkSNHNHfuXE2bNk1Dhgw55WPTd+zYoba2No0bNy6qatJjYL2PP/5YLS0tGj9+fJfrxUvNSPQYdpFOTK6rqamxCy64wPbs2XPKbZ988okVFxebx+Ox3//+91Fbkx7pMVpqfv7553beeefZ1KlTLSkpyVJTU+1HP/qRrVu3zj799FM7efKk+Xw+y8/Pt8cee8zMuv9WzXDXpMfY6DESNSPRYzgRWM7is88+s4kTJ9rSpUtPO+auu+6y+fPnW3Nzc1TWpMfQ14tEzVjuseOX6rp162z69OlWX19vZma/+93vbOrUqebxeCwjI8MKCwvtueeeM4/HYx9++GHAfV2vSY+x0WMkakaix0ggsJxBx2uADzzwgI0dO9ZeeeUVO3r06CnjlixZYllZWVFZkx5DXy8SNeOhRzOzrVu32uOPP26fffZZwP7GxkZbvHixjRo1yjwej79eKH4Zh7smPcZGj5GoGYkew4nAcg727dtnc+bMsV69etn06dNt1apV9v7779v27dvtv/7rvywrK8sef/xxM7OA97hHU016pMdoqNna2moHDhwI+P7vPz9i+PDh9tRTT4WkXiRq0mPo68VLzUj0GE4EltNYu3at7dixI2Dfpk2bbPbs2da3b1/r27evTZgwwc4//3y799577dixY2bWvcQa7pr0SI9d5UKP7e3t/l/GPp/P2tra7J133jGPx+M/JR7qHnuyJj3GRo+RqBmJHiOBwNIJn89nN954o2VkZNi0adPsqaee8i9wh4qKCvv9739vO3fuDMknBIa7Jj2Gvl4kasZjj88884z/48Y7tLW1WXt7u+3duzckn9wZ7pr0GPp68VIzEj1GCm9rPo1Dhw5pz5492rhxo8rLy/XXv/5V48aN0z/90z/ppptuOuVDdr7+iZ7RUpMe6TFaanZWb/z48br11ls1e/bsgA83a2lpUe/evbtcK1I16TE2eoxEzUj0GAkElrNoa2tTY2OjPvroI23YsEEVFRU6duyYpk+frjvuuEPTpk3zj+34UXb3U1nDXZMe6TFaav59vTfffFPHjh3Td77zHd1+++26+uqrQ1ovEjXpMTZ6jETNSPQYTgSWIDQ3N8vr9erdd9/VH/7wB1VVVSk5OVk33HCD5s+fH/CR8tFakx7pMVpq0iM9UtOdemERztefYsmxY8dsx44dtnLlSps1a5alpaXZPffcc8pr+dFckx57Bj1Gf71I1KTHnhEPNSPRY0/gDEs3+Xw+NTU1adeuXTpy5IimTZum5OTkmKpJj7FRkx5joyY9UjNa6oUagQUAADgvCv6eNAAAiHcEFgAA4DwCCwAAcB6BBQAAOI/AAgAAnEdgAQAAziOwAAAA5xFYAACA8wgsAADAeQQWAADgvP8HW9a5h3cUX+YAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "c_final = QAOA_from_Ising(\n", - " final_params, nlayers, portfolio_pauli_terms, portfolio_weights\n", - ")\n", - "print_output(c_final)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 57d94bc736fd5ada3e5cad7afa99a95a32265855 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Fri, 25 Aug 2023 14:07:19 +0100 Subject: [PATCH 633/725] Rename QUBO_problem.ipynb to qubo_problem.ipynb --- docs/source/tutorials/{QUBO_problem.ipynb => qubo_problem.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/source/tutorials/{QUBO_problem.ipynb => qubo_problem.ipynb} (100%) diff --git a/docs/source/tutorials/QUBO_problem.ipynb b/docs/source/tutorials/qubo_problem.ipynb similarity index 100% rename from docs/source/tutorials/QUBO_problem.ipynb rename to docs/source/tutorials/qubo_problem.ipynb From c03cff49786d6b4c7a5fe3f537d5e5cefd8fb6d6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 29 Aug 2023 14:55:08 +0800 Subject: [PATCH 634/725] tc2qiskit new measurement order --- CHANGELOG.md | 3 +++ README.md | 2 ++ tensorcircuit/translation.py | 4 +++- 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6f7e7dd9..2d87e8f4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,8 @@ - move ensemble module to applications/ai (breaking changes) +- tc2qiskit now record qiskit measure with incremental clbit from 0 + ## 0.11.0 ### Added @@ -39,6 +41,7 @@ - fix rem `apply_correction` bug when non-numpy backend is set - fix tf warning for `cast` with higher version of tf + ### Changed - The static method `BaseCircuit.copy` is renamed as `BaseCircuit.copy_nodes` (breaking changes) diff --git a/README.md b/README.md index ca4b5cb3..2b548913 100644 --- a/README.md +++ b/README.md @@ -368,6 +368,8 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Practical advantage of quantum machine learning in ghost imaging: https://www.nature.com/articles/s42005-023-01290-1 (published in Communications Physics). +- Zero and Finite Temperature Quantum Simulations Powered by Quantum Magic: https://arxiv.org/abs/2308.11616. +
If you want to highlight your research work here, feel free to add by opening PR. diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 045751c2..f300fc8a 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -235,6 +235,7 @@ def qir2qiskit( qiskit_circ = QuantumCircuit(n) if initialization is not None: qiskit_circ.initialize(initialization) + measure_cbit = 0 for gate_info in qir: index = gate_info["index"] gate_name = str(gate_info["gatef"]) @@ -325,7 +326,8 @@ def qir2qiskit( ) qiskit_circ.unitary(qop, index[::-1], label=qis_name) elif gate_name == "measure": - qiskit_circ.measure(index[0], index[0]) + qiskit_circ.measure(index[0], measure_cbit) + measure_cbit += 1 elif gate_name == "reset": qiskit_circ.reset(index[0]) elif gate_name == "barrier": From 435ffb27a825fb910fac36d0b29beae069669c24 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 30 Aug 2023 11:09:36 +0800 Subject: [PATCH 635/725] add det on backend --- CHANGELOG.md | 2 ++ tensorcircuit/backends/abstract_backend.py | 13 +++++++++++++ tensorcircuit/backends/jax_backend.py | 5 ++++- tensorcircuit/backends/numpy_backend.py | 3 +++ tensorcircuit/backends/pytorch_backend.py | 3 +++ tensorcircuit/backends/tensorflow_backend.py | 3 +++ tests/test_backends.py | 3 +++ 7 files changed, 31 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2d87e8f4..bfc11775 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Add translation of r gate from qiskit +- Add `det` method at backends + ### Changed - move ensemble module to applications/ai (breaking changes) diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index e6f69f97..71e90f68 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -345,6 +345,19 @@ def adjoint(self: Any, a: Tensor) -> Tensor: """ return self.conj(self.transpose(a)) + def det(self: Any, a: Tensor) -> Tensor: + """ + Return the determinant scalar of a tensor ``a`` + + :param a: Input tensor + :type a: Tensor + :return: determinant of ``a`` + :rtype: Tensor + """ + raise NotImplementedError( + "Backend '{}' has not implemented `det`.".format(self.name) + ) + def i(self: Any, dtype: str) -> Tensor: """ Return 1.j in as a tensor compatible with the backend. diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 472066ea..d7e1e36f 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -295,7 +295,10 @@ def i(self, dtype: Any = None) -> Tensor: dtype = npdtype # type: ignore if isinstance(dtype, str): dtype = getattr(jnp, dtype) - return np.array(1j, dtype=dtype) + return jnp.array(1j, dtype=dtype) + + def det(self, a: Tensor) -> Tensor: + return jnp.linalg.det(a) def real(self, a: Tensor) -> Tensor: return jnp.real(a) diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index 2d22b94d..1cc9fac6 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -131,6 +131,9 @@ def dtype(self, a: Tensor) -> str: def numpy(self, a: Tensor) -> Tensor: return a + def det(self, a: Tensor) -> Tensor: + return np.linalg.det(a) + def i(self, dtype: Any = None) -> Tensor: if not dtype: dtype = npdtype # type: ignore diff --git a/tensorcircuit/backends/pytorch_backend.py b/tensorcircuit/backends/pytorch_backend.py index 7362cc47..3256a44e 100644 --- a/tensorcircuit/backends/pytorch_backend.py +++ b/tensorcircuit/backends/pytorch_backend.py @@ -306,6 +306,9 @@ def i(self, dtype: Any = None) -> Tensor: dtype = getattr(torchlib, dtype) return torchlib.tensor(1j, dtype=dtype) + def det(self, a: Tensor) -> Tensor: + return torchlib.linalg.det(a) + def real(self, a: Tensor) -> Tensor: try: a = torchlib.real(a) diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 91b6be6e..632b558f 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -480,6 +480,9 @@ def i(self, dtype: Any = None) -> Tensor: dtype = getattr(tf, dtype) return tf.constant(1j, dtype=dtype) + def det(self, a: Tensor) -> Tensor: + return tf.linalg.det(a) + def min(self, a: Tensor, axis: Optional[int] = None) -> Tensor: return tf.reduce_min(a, axis=axis) diff --git a/tests/test_backends.py b/tests/test_backends.py index 6e387eb2..3c73c1ab 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -300,6 +300,9 @@ def test_backend_methods_2(backend): np.maximum(arr, 0), atol=1e-4, ) + np.testing.assert_allclose( + tc.backend.det(tc.backend.convert_to_tensor(np.eye(3) * 2)), 8, atol=1e-5 + ) # @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb"), lf("torchb")]) From 415f1789a54ac81b7ad1c4ff14995ef4b21008ce Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 31 Aug 2023 14:51:59 +0800 Subject: [PATCH 636/725] inital draft on fgs --- CHANGELOG.md | 2 + docs/source/api/fgs.rst | 7 + docs/source/modules.rst | 1 + requirements/requirements-extra.txt | 1 + tensorcircuit/__init__.py | 2 + tensorcircuit/backends/abstract_backend.py | 15 + tensorcircuit/backends/jax_backend.py | 3 + tensorcircuit/backends/numpy_backend.py | 5 +- tensorcircuit/fgs.py | 550 +++++++++++++++++++++ tests/test_fgs.py | 104 ++++ 10 files changed, 689 insertions(+), 1 deletion(-) create mode 100644 docs/source/api/fgs.rst create mode 100644 tensorcircuit/fgs.py create mode 100644 tests/test_fgs.py diff --git a/CHANGELOG.md b/CHANGELOG.md index bfc11775..c2a51e70 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ - Add `det` method at backends +- Add fermion Gaussian state simulator in `fgs.py` + ### Changed - move ensemble module to applications/ai (breaking changes) diff --git a/docs/source/api/fgs.rst b/docs/source/api/fgs.rst new file mode 100644 index 00000000..f00001b4 --- /dev/null +++ b/docs/source/api/fgs.rst @@ -0,0 +1,7 @@ +tensorcircuit.fgs +================================================================================ +.. automodule:: tensorcircuit.fgs + :members: + :undoc-members: + :show-inheritance: + :inherited-members: \ No newline at end of file diff --git a/docs/source/modules.rst b/docs/source/modules.rst index 5f08781f..0144a199 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -13,6 +13,7 @@ tensorcircuit ./api/cons.rst ./api/densitymatrix.rst ./api/experimental.rst + ./api/fgs.rst ./api/gates.rst ./api/interfaces.rst ./api/keras.rst diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index acd416e3..80fff586 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -6,3 +6,4 @@ torch jupyter mthree==1.1.0 mitiq +openfermion diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 3bf75d98..a3993163 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -40,6 +40,8 @@ from .quantum import QuOperator, QuVector, QuAdjointVector, QuScalar from . import compiler from . import cloud +from . import fgs +from .fgs import FGSSimulator try: from . import keras diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index 71e90f68..472f0081 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -358,6 +358,21 @@ def det(self: Any, a: Tensor) -> Tensor: "Backend '{}' has not implemented `det`.".format(self.name) ) + def schur(self: Any, a: Tensor, output: str = "real") -> Tuple[Tensor, Tensor]: + """ + Compute Schur decomposition of a matrix. + + :param a: _description_ + :type a: Tensor + :param output: _description_, defaults to "real" + :type output: str, optional + :return: T, Z so that ZTZ^H = a + :rtype: Tuple[Tensor, Tensor] + """ + raise NotImplementedError( + "Backend '{}' has not implemented `schur`.".format(self.name) + ) + def i(self: Any, dtype: str) -> Tensor: """ Return 1.j in as a tensor compatible with the backend. diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index d7e1e36f..c9ca0249 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -300,6 +300,9 @@ def i(self, dtype: Any = None) -> Tensor: def det(self, a: Tensor) -> Tensor: return jnp.linalg.det(a) + def schur(self, a: Tensor, output: str = "real") -> Tuple[Tensor, Tensor]: + return jsp.linalg.schur(a, output=output) # type: ignore + def real(self, a: Tensor) -> Tensor: return jnp.real(a) diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index 1cc9fac6..83ef3040 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -9,7 +9,7 @@ import numpy as np import tensornetwork -from scipy.linalg import expm, solve +from scipy.linalg import expm, solve, schur from scipy.special import softmax, expit from scipy.sparse import coo_matrix, issparse from tensornetwork.backends.numpy import numpy_backend @@ -134,6 +134,9 @@ def numpy(self, a: Tensor) -> Tensor: def det(self, a: Tensor) -> Tensor: return np.linalg.det(a) + def schur(self, a: Tensor, output: str = "real") -> Tuple[Tensor, Tensor]: + return schur(a, output=output) # type: ignore + def i(self, dtype: Any = None) -> Tensor: if not dtype: dtype = npdtype # type: ignore diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py new file mode 100644 index 00000000..9314fa63 --- /dev/null +++ b/tensorcircuit/fgs.py @@ -0,0 +1,550 @@ +""" +Fermion Gaussian state simulator +""" +from typing import Any, List, Optional, Tuple + +import numpy as np + +try: + import openfermion +except ModuleNotFoundError: + pass + +from .cons import backend, dtypestr +from .circuit import Circuit +from . import quantum + +Tensor = Any + + +def onehot_matrix(i: int, j: int, N: int) -> Tensor: + m = np.zeros([N, N]) + m[i, j] = 1 + m = backend.convert_to_tensor(m) + m = backend.cast(m, dtypestr) + return m + + +# TODO(@refraction-ray): efficiency benchmark with jit +# TODO(@refraction-ray): occupation number post-selection/measurement +# TODO(@refraction-ray): FGS mixed state support? +# TODO(@refraction-ray): overlap? + + +class FGSSimulator: + r""" + main refs: https://arxiv.org/pdf/2306.16595.pdf, + https://arxiv.org/abs/2209.06945, + https://scipost.org/SciPostPhysLectNotes.54/pdf + + convention: + for Hamiltonian (c^dagger, c)H(c, c^\dagger) + for correlation <(c, c^\dagger)(c^\dagger, c)> + c' = \alpha^\dagger (c, c^\dagger) + """ + + def __init__( + self, + L: int, + filled: Optional[List[int]] = None, + alpha: Optional[Tensor] = None, + hc: Optional[Tensor] = None, + cmatrix: Optional[Tensor] = None, + ): + """ + _summary_ + + :param L: system size + :type L: int + :param filled: the fermion site that is fully occupied, defaults to None + :type filled: Optional[List[int]], optional + :param cmatrix: only used for debug, defaults to None + :type cmatrix: Optional[Tensor], optional + """ + if filled is None: + filled = [] + self.L = L + if alpha is None: + if hc is None: + self.alpha = self.init_alpha(filled, L) + else: + _, _, self.alpha = self.fermion_diagonalization(hc, L) + else: + self.alpha = alpha + self.wtransform = self.wmatrix(L) + self.cmatrix = cmatrix + + @classmethod + def fermion_diagonalization( + cls, hc: Tensor, L: int + ) -> Tuple[Tensor, Tensor, Tensor]: + es, u = backend.eigh(hc) + es = es[::-1] + u = u[:, ::-1] + alpha = u[:, :L] + return es, u, alpha + + @classmethod + def fermion_diagonalization_2( + cls, hc: Tensor, L: int + ) -> Tuple[Tensor, Tensor, Tensor]: + w = cls.wmatrix(L) + hm = 0.25 * w @ hc @ backend.adjoint(w) + hm = backend.real((-1.0j) * hm) + hd, om = backend.schur(hm, output="real") + # order not kept + # eps = 1e-10 + # idm = backend.convert_to_tensor(np.array([[1.0, 0], [0, 1.0]])) + # idm = backend.cast(idm, dtypestr) + # xm = backend.convert_to_tensor(np.array([[0, 1.0], [1.0, 0]])) + # xm = backend.cast(xm, dtypestr) + # for i in range(0, 2 * L, 2): + # (backend.sign(hd[i, i + 1] + eps) + 1) / 2 * idm - ( + # backend.sign(hd[i, i + 1] + eps) - 1 + # ) / 2 * xm + # print(hd) + + es = backend.adjoint(w) @ (1.0j * hd) @ w + u = 0.5 * backend.adjoint(w) @ backend.transpose(om) @ w + alpha = backend.adjoint(u)[:, :L] + # c' = u@c + # e_k (c^\dagger_k c_k - c_k c^\dagger_k) + return (es, u, alpha) + + @staticmethod + def wmatrix(L: int) -> Tensor: + w = np.zeros([2 * L, 2 * L], dtype=complex) + for i in range(2 * L): + if i % 2 == 1: + w[i, (i - 1) // 2] = 1.0j + w[i, (i - 1) // 2 + L] = -1.0j + else: + w[i, i // 2] = 1 + w[i, i // 2 + L] = 1 + return backend.convert_to_tensor(w) + + @staticmethod + def init_alpha(filled: List[int], L: int) -> Tensor: + alpha = np.zeros([2 * L, L]) + for i in range(L): + if i not in filled: + alpha[i, i] = 1 + else: + alpha[i + L, i] = 1 + alpha = backend.convert_to_tensor(alpha) + alpha = backend.cast(alpha, dtypestr) + return alpha + + def get_alpha(self) -> Tensor: + return self.alpha + + def get_cmatrix(self) -> Tensor: + if self.cmatrix is not None: + return self.cmatrix + return self.alpha @ backend.adjoint(self.alpha) + + def get_reduced_cmatrix(self, subsystems_to_trace_out: List[int]) -> Tensor: + m = self.get_cmatrix() + if subsystems_to_trace_out is None: + subsystems_to_trace_out = [] + keep = [i for i in range(self.L) if i not in subsystems_to_trace_out] + keep += [i + self.L for i in range(self.L) if i not in subsystems_to_trace_out] + keep = backend.convert_to_tensor(keep) + + def slice_(a: Tensor) -> Tensor: + return backend.gather1d(a, keep) + + slice_ = backend.vmap(slice_) + m = backend.gather1d(slice_(m), keep) + return m + + def renyi_entropy(self, n: int, subsystems_to_trace_out: List[int]) -> Tensor: + """ + compute renyi_entropy of order ``n`` for the fermion state + + :param n: _description_ + :type n: int + :param subsystems_to_trace_out: system sites to be traced out + :type subsystems_to_trace_out: List[int] + :return: _description_ + :rtype: Tensor + """ + m = self.get_reduced_cmatrix(subsystems_to_trace_out) + lbd, _ = backend.eigh(m) + lbd = backend.real(lbd) + lbd = backend.relu(lbd) + eps = 1e-6 + + entropy = backend.sum(backend.log(lbd ** n + (1 - lbd) ** n + eps)) + s = 1 / (2 * (1 - n)) * entropy + return s + + def entropy(self, subsystems_to_trace_out: Optional[List[int]] = None) -> Tensor: + """ + compute von Neumann entropy for the fermion state + + :param subsystems_to_trace_out: _description_, defaults to None + :type subsystems_to_trace_out: Optional[List[int]], optional + :return: _description_ + :rtype: Tensor + """ + m = self.get_reduced_cmatrix(subsystems_to_trace_out) # type: ignore + lbd, _ = backend.eigh(m) + lbd = backend.real(lbd) + lbd = backend.relu(lbd) + # lbd /= backend.sum(lbd) + eps = 1e-6 + entropy = -backend.sum( + lbd * backend.log(lbd + eps) + (1 - lbd) * backend.log(1 - lbd + eps) + ) + return entropy / 2 + + def evol_hamiltonian(self, h: Tensor) -> None: + r""" + Evolve as :math:`e^{-i/2 \hat{h}}` + + :param h: _description_ + :type h: Tensor + """ + # e^{-i/2 H} + h = backend.cast(h, dtype=dtypestr) + self.alpha = backend.expm(-1.0j * h) @ self.alpha + + def evol_ihamiltonian(self, h: Tensor) -> None: + r""" + Evolve as :math:`e^{-1/2 \hat{h}}` + + :param h: _description_ + :type h: Tensor + """ + # e^{-1/2 H} + h = backend.cast(h, dtype=dtypestr) + self.alpha = backend.expm(h) @ self.alpha + self.orthogonal() + + def orthogonal(self) -> None: + q, _ = backend.qr(self.alpha) + self.alpha = q + + @staticmethod + def hopping(chi: Tensor, i: int, j: int, L: int) -> Tensor: + # chi * ci dagger cj + hc. + chi = backend.convert_to_tensor(chi) + chi = backend.cast(chi, dtypestr) + m = chi / 2 * onehot_matrix(i, j, 2 * L) + m += -chi / 2 * onehot_matrix(j + L, i + L, 2 * L) + m += backend.adjoint(m) + return m + + def evol_hp(self, i: int, j: int, chi: Tensor = 0) -> None: + r""" + The evolve Hamiltonian is :math:`chi c_i^\dagger c_j +h.c.` + + :param i: _description_ + :type i: int + :param j: _description_ + :type j: int + :param chi: _description_, defaults to 0 + :type chi: Tensor, optional + """ + self.evol_hamiltonian(self.hopping(chi, i, j, self.L)) + + @staticmethod + def chemical_potential(chi: Tensor, i: int, L: int) -> Tensor: + chi = backend.convert_to_tensor(chi) + chi = backend.cast(chi, dtypestr) + m = chi / 2 * onehot_matrix(i, i, 2 * L) + m += -chi / 2 * onehot_matrix(i + L, i + L, 2 * L) + return m + + @staticmethod + def sc_pairing(chi: Tensor, i: int, j: int, L: int) -> Tensor: + chi = backend.convert_to_tensor(chi) + chi = backend.cast(chi, dtypestr) + m = chi / 2 * onehot_matrix(i, j + L, 2 * L) + m += -chi / 2 * onehot_matrix(j, i + L, 2 * L) + m += backend.adjoint(m) + return m + + def evol_sp(self, i: int, j: int, chi: Tensor = 0) -> None: + r""" + The evolve Hamiltonian is :math:`chi c_i^\dagger c_j^\dagger +h.c.` + + + :param i: _description_ + :type i: int + :param j: _description_ + :type j: int + :param chi: _description_, defaults to 0 + :type chi: Tensor, optional + """ + self.evol_hamiltonian(self.sc_pairing(chi, i, j, self.L)) + + def evol_cp(self, i: int, chi: Tensor = 0) -> None: + r""" + The evolve Hamiltonian is :math:`chi c_i^\dagger c_i` + + :param i: _description_ + :type i: int + :param chi: _description_, defaults to 0 + :type chi: Tensor, optional + """ + self.evol_hamiltonian(self.chemical_potential(chi, i, self.L)) + + def evol_icp(self, i: int, chi: Tensor = 0) -> None: + r""" + The evolve Hamiltonian is :math:`chi c_i^\dagger c_i` with :math:`\exp^{-H/2}` + + :param i: _description_ + :type i: int + :param chi: _description_, defaults to 0 + :type chi: Tensor, optional + """ + self.evol_ihamiltonian(self.chemical_potential(chi, i, self.L)) + + def get_bogoliubov_uv(self) -> Tuple[Tensor, Tensor]: + return ( + backend.gather1d( + self.alpha, backend.convert_to_tensor([i for i in range(self.L)]) + ), + backend.gather1d( + self.alpha, + backend.convert_to_tensor([i + self.L for i in range(self.L)]), + ), + ) + + def get_cmatrix_majorana(self) -> Tensor: + c = self.get_cmatrix() + return self.wtransform @ c @ backend.adjoint(self.wtransform) + + def get_covariance_matrix(self) -> Tensor: + m = self.get_cmatrix_majorana() + return -1.0j * (2 * m - backend.eye(self.L * 2)) + + # def product(self, other): + # # self@other + # gamma1 = self.get_covariance_matrix() + # gamma2 = other.get_covariance_matrix() + # den = backend.inv(1 + gamma1 @ gamma2) + # idm = backend.eye(2 * self.L) + # covm = idm - (idm - gamma2) @ den @ (idm - gamma1) + # cm = (1.0j * covm + idm) / 2 + # cmatrix = backend.adjoint(self.wtransform) @ cm @ self.wtransform * 0.25 + # return type(self)(self.L, cmatrix=cmatrix) + + # def overlap(self, other): + # # ? + # u, v = self.get_bogoliubov_uv() + # u1, v1 = other.get_bogoliubov_uv() + # return backend.det( + # backend.adjoint(u1) @ u + backend.adjoint(v1) @ v + # ) * backend.det(backend.adjoint(v1) @ v), backend.det( + # backend.adjoint(u1) @ u + backend.adjoint(v1) @ v + # ) * backend.det( + # backend.adjoint(u1) @ u + # ) + + +class FGSTestSimulator: + def __init__( + self, L: int, filled: Optional[List[int]] = None, hc: Optional[Tensor] = None + ): + if filled is None: + filled = [] + self.L = L + self.state = self.init_state(filled, L) + if hc is not None: + self.state = self.fermion_diagonalization(hc, L) + + @staticmethod + def init_state(filled: List[int], L: int) -> Tensor: + c = Circuit(L) + for i in filled: + c.x(i) # type: ignore + return c.state() + + @classmethod + def fermion_diagonalization(cls, hc: Tensor, L: int) -> Tensor: + h = cls.get_hmatrix(hc, L) + _, u = np.linalg.eigh(h) + return u[:, 0] + + @staticmethod + def get_hmatrix(hc: Tensor, L: int) -> Tensor: + hm = np.zeros([2 ** L, 2 ** L], dtype=complex) + for i in range(L): + for j in range(L): + op = openfermion.FermionOperator(f"{str(i)}^ {str(j)}") + hm += ( + hc[i, j] * openfermion.get_sparse_operator(op, n_qubits=L).todense() + ) + + for i in range(L, 2 * L): + for j in range(L): + op = openfermion.FermionOperator(f"{str(i-L)} {str(j)}") + hm += ( + hc[i, j] * openfermion.get_sparse_operator(op, n_qubits=L).todense() + ) + + for i in range(L): + for j in range(L, 2 * L): + op = openfermion.FermionOperator(f"{str(i)}^ {str(j-L)}^") + hm += ( + hc[i, j] * openfermion.get_sparse_operator(op, n_qubits=L).todense() + ) + + for i in range(L, 2 * L): + for j in range(L, 2 * L): + op = openfermion.FermionOperator(f"{str(i-L)} {str(j-L)}^") + hm += ( + hc[i, j] * openfermion.get_sparse_operator(op, n_qubits=L).todense() + ) + + return hm + + @staticmethod + def hopping_jw(chi: Tensor, i: int, j: int, L: int) -> Tensor: + op = chi * openfermion.FermionOperator(f"{str(i)}^ {str(j)}") + np.conj( + chi + ) * openfermion.FermionOperator(f"{str(j)}^ {str(i)}") + sop = openfermion.transforms.jordan_wigner(op) + m = openfermion.get_sparse_operator(sop, n_qubits=L).todense() + return m + + @staticmethod + def chemical_potential_jw(chi: Tensor, i: int, L: int) -> Tensor: + op = chi * openfermion.FermionOperator(f"{str(i)}^ {str(i)}") + sop = openfermion.transforms.jordan_wigner(op) + m = openfermion.get_sparse_operator(sop, n_qubits=L).todense() + return m + + def evol_hamiltonian(self, h: Tensor) -> None: + self.state = backend.expm(-1 / 2 * 1.0j * h) @ backend.reshape( + self.state, [-1, 1] + ) + self.state = backend.reshape(self.state, [-1]) + + def evol_ihamiltonian(self, h: Tensor) -> None: + self.state = backend.expm(-1 / 2 * h) @ backend.reshape(self.state, [-1, 1]) + self.state = backend.reshape(self.state, [-1]) + self.orthogonal() + + def evol_hp(self, i: int, j: int, chi: Tensor = 0) -> None: + self.evol_hamiltonian(self.hopping_jw(chi, i, j, self.L)) + + def evol_cp(self, i: int, chi: Tensor = 0) -> None: + self.evol_hamiltonian(self.chemical_potential_jw(chi, i, self.L)) + + def evol_icp(self, i: int, chi: Tensor = 0) -> None: + self.evol_ihamiltonian(self.chemical_potential_jw(chi, i, self.L)) + + @staticmethod + def sc_pairing_jw(chi: Tensor, i: int, j: int, L: int) -> Tensor: + op = chi * openfermion.FermionOperator(f"{str(i)}^ {str(j)}^") + np.conj( + chi + ) * openfermion.FermionOperator(f"{str(j)} {str(i)}") + sop = openfermion.transforms.jordan_wigner(op) + m = openfermion.get_sparse_operator(sop, n_qubits=L).todense() + return m + + def evol_sp(self, i: int, j: int, chi: Tensor = 0) -> None: + self.evol_hamiltonian(self.sc_pairing_jw(chi, i, j, self.L)) + + def orthogonal(self) -> None: + self.state /= backend.norm(self.state) + + def get_cmatrix(self) -> Tensor: + alpha1_jw = self.state + cmatrix = np.zeros([2 * self.L, 2 * self.L], dtype=complex) + for i in range(self.L): + for j in range(self.L): + op = openfermion.FermionOperator(f"{str(i)} {str(j)}^") + m = openfermion.get_sparse_operator(op, n_qubits=self.L).todense() + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + for i in range(self.L, 2 * self.L): + for j in range(self.L): + op = openfermion.FermionOperator(f"{str(i-self.L)}^ {str(j)}^") + m = openfermion.get_sparse_operator(op, n_qubits=self.L).todense() + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + for i in range(self.L): + for j in range(self.L, 2 * self.L): + op = openfermion.FermionOperator(f"{str(i)} {str(j-self.L)}") + m = openfermion.get_sparse_operator(op, n_qubits=self.L).todense() + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + for i in range(self.L, 2 * self.L): + for j in range(self.L, 2 * self.L): + op = openfermion.FermionOperator(f"{str(i-self.L)}^ {str(j-self.L)}") + m = openfermion.get_sparse_operator(op, n_qubits=self.L).todense() + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + return cmatrix + + def get_cmatrix_majorana(self) -> Tensor: + alpha1_jw = self.state + cmatrix = np.zeros([2 * self.L, 2 * self.L], dtype=complex) + for i in range(2 * self.L): + for j in range(2 * self.L): + op = openfermion.MajoranaOperator((i,)) * openfermion.MajoranaOperator( + (j,) + ) + if j % 2 + i % 2 == 1: + op *= -1 + # convention diff in jordan wigner + # c\dagger = X\pm iY + + op = openfermion.jordan_wigner(op) + m = openfermion.get_sparse_operator(op, n_qubits=self.L).todense() + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + + return cmatrix + + def entropy(self, subsystems_to_trace_out: Optional[List[int]] = None) -> Tensor: + rm = quantum.reduced_density_matrix(self.state, subsystems_to_trace_out) # type: ignore + return quantum.entropy(rm) + + def renyi_entropy(self, n: int, subsystems_to_trace_out: List[int]) -> Tensor: + rm = quantum.reduced_density_matrix(self.state, subsystems_to_trace_out) + return quantum.renyi_entropy(rm, n) + + def overlap(self, other: "FGSTestSimulator") -> Tensor: + return backend.tensordot(backend.conj(self.state), other.state, 1) + + def get_dm(self) -> Tensor: + s = backend.reshape(self.state, [-1, 1]) + return s @ backend.adjoint(s) + + def product(self, other: "FGSTestSimulator") -> Tensor: + rho1 = self.get_dm() + rho2 = other.get_dm() + rho = rho1 @ rho2 + rho /= backend.trace(rho) + return rho diff --git a/tests/test_fgs.py b/tests/test_fgs.py new file mode 100644 index 00000000..2facc03c --- /dev/null +++ b/tests/test_fgs.py @@ -0,0 +1,104 @@ +import numpy as np +import pytest +from pytest_lazyfixture import lazy_fixture as lf +import tensorflow as tf +import optax + +try: + import openfermion as _ +except ModuleNotFoundError: + pytestmark = pytest.mark.skip("skip fgs test due to missing openfermion module") + +import tensorcircuit as tc + +F = tc.fgs.FGSSimulator +FT = tc.fgs.FGSTestSimulator + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_cmatrix(backend, highp): + c = tc.fgs.FGSSimulator(4, [0]) + c1 = tc.fgs.FGSTestSimulator(4, [0]) + c.evol_hp(0, 1, 1.2) + c1.evol_hp(0, 1, 1.2) + c.evol_icp(2, 0.5) + c1.evol_icp(2, 0.5) + c.evol_cp(0, -0.8) + c1.evol_cp(0, -0.8) + c.evol_sp(1, 0, 0.5) + c1.evol_sp(1, 0, 0.5) + c.evol_sp(1, 2, 1.5) + c1.evol_sp(1, 2, 1.5) + c.evol_ihamiltonian(c.chemical_potential(1.0, 1, 4)) + c1.evol_ihamiltonian(c1.chemical_potential_jw(1.0, 1, 4)) + np.testing.assert_allclose( + c1.get_cmatrix_majorana(), c.get_cmatrix_majorana(), atol=1e-5 + ) + np.testing.assert_allclose(c1.get_cmatrix(), c.get_cmatrix(), atol=1e-5) + np.testing.assert_allclose(c1.entropy([0, 2]), c.entropy([0, 2]), atol=1e-5) + np.testing.assert_allclose( + c1.renyi_entropy(2, [1]), c.renyi_entropy(2, [1]), atol=1e-5 + ) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_fgs_ad(backend, highp): + N = 18 + + def f(chi): + c = tc.fgs.FGSSimulator(N, [0]) + for i in range(N - 1): + c.evol_hp(i, i + 1, chi[i]) + cm = c.get_cmatrix() + return -tc.backend.real(1 - cm[N, N]) + + chi_vg = tc.backend.jit(tc.backend.value_and_grad(f)) + + if tc.backend.name == "tensorflow": + opt = tc.backend.optimizer(tf.keras.optimizers.Adam(1e-2)) + else: + opt = tc.backend.optimizer(optax.adam(1e-2)) + + param = tc.backend.ones([N - 1], dtype="float64") + for _ in range(300): + vs, gs = chi_vg(param) + param = opt.update(gs, param) + + np.testing.assert_allclose(vs, -0.9986, atol=1e-2) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_hamiltonian_generation(backend): + hc = F.chemical_potential(0.8, 0, 3) + h1 = FT.get_hmatrix(hc, 3) + 0.4 * tc.backend.eye(2**3) + # constant shift + h2 = FT.chemical_potential_jw(0.8, 0, 3) + np.testing.assert_allclose(h1, h2, atol=1e-5) + + hc = F.hopping(0.8j, 0, 1, 3) + h1 = FT.get_hmatrix(hc, 3) + h2 = FT.hopping_jw(0.8j, 0, 1, 3) + np.testing.assert_allclose(h1, h2, atol=1e-5) + + hc = F.sc_pairing(0.8, 1, 0, 3) + h1 = FT.get_hmatrix(hc, 3) + h2 = FT.sc_pairing_jw(0.8, 1, 0, 3) + np.testing.assert_allclose(h1, h2, atol=1e-5) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_ground_state(backend, highp): + N = 3 + hc = ( + F.hopping(1.0, 0, 1, N) + + F.hopping(1.0, 1, 2, N) + + F.chemical_potential(0.4, 0, N) + - F.chemical_potential(0.4, 1, N) + + F.sc_pairing(0.8, 0, 1, N) + ) + + c = F(N, hc=hc) + c1 = FT(N, hc=hc) + + np.testing.assert_allclose(c.get_cmatrix(), c1.get_cmatrix(), atol=1e-6) + np.testing.assert_allclose(c1.entropy([0]), c.entropy([0]), atol=1e-5) From e841ecb24c2060da5b08512fdbde18d339916636 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 31 Aug 2023 14:59:47 +0800 Subject: [PATCH 637/725] blacked --- tensorcircuit/fgs.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index 9314fa63..4cdec5e6 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -175,7 +175,7 @@ def renyi_entropy(self, n: int, subsystems_to_trace_out: List[int]) -> Tensor: lbd = backend.relu(lbd) eps = 1e-6 - entropy = backend.sum(backend.log(lbd ** n + (1 - lbd) ** n + eps)) + entropy = backend.sum(backend.log(lbd**n + (1 - lbd) ** n + eps)) s = 1 / (2 * (1 - n)) * entropy return s @@ -371,7 +371,7 @@ def fermion_diagonalization(cls, hc: Tensor, L: int) -> Tensor: @staticmethod def get_hmatrix(hc: Tensor, L: int) -> Tensor: - hm = np.zeros([2 ** L, 2 ** L], dtype=complex) + hm = np.zeros([2**L, 2**L], dtype=complex) for i in range(L): for j in range(L): op = openfermion.FermionOperator(f"{str(i)}^ {str(j)}") From 4c1436598f15abdf262ede32620d06d5886b7724 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 1 Sep 2023 11:48:36 +0800 Subject: [PATCH 638/725] add measurement in fgs --- tensorcircuit/fgs.py | 129 ++++++++++++++++++++++++++++++++++++++++--- tests/test_fgs.py | 64 ++++++++++++++++++++- 2 files changed, 185 insertions(+), 8 deletions(-) diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index 4cdec5e6..f35fd595 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -10,7 +10,7 @@ except ModuleNotFoundError: pass -from .cons import backend, dtypestr +from .cons import backend, dtypestr, rdtypestr, get_backend from .circuit import Circuit from . import quantum @@ -314,6 +314,14 @@ def get_bogoliubov_uv(self) -> Tuple[Tensor, Tensor]: ) def get_cmatrix_majorana(self) -> Tensor: + """ + correlation matrix defined in majorana basis + convention: gamma_0 = c0 + c0^\dagger + gamma_1 = i(c0 - c0^\dagger) + + :return: _description_ + :rtype: Tensor + """ c = self.get_cmatrix() return self.wtransform @ c @ backend.adjoint(self.wtransform) @@ -321,6 +329,85 @@ def get_covariance_matrix(self) -> Tensor: m = self.get_cmatrix_majorana() return -1.0j * (2 * m - backend.eye(self.L * 2)) + def post_select(self, i: int, keep: int = 1) -> None: + """ + post select (project) the fermion state to occupation eigenstate + = ``keep`` + + :param i: _description_ + :type i: int + :param keep: _description_, defaults to 1 + :type keep: int, optional + """ + # i is not jittable, keep is jittable + L = backend.convert_to_tensor(self.L) + i = backend.convert_to_tensor(i) + L = backend.cast(L, "int32") + i = backend.cast(i, "int32") + keep = backend.convert_to_tensor(keep) + keep = backend.cast(keep, "int32") + alpha = self.alpha + # if keep == 0: + i = i + L * (1 - keep) + i0 = backend.argmax(backend.abs(alpha[(i + L) % (2 * L), :])) + i0 = backend.cast(i0, "int32") + alpha1 = alpha - backend.reshape(alpha[:, i0], [-1, 1]) @ backend.reshape( + alpha[(i + L) % (2 * L), :] / alpha[(i + L) % (2 * L), i0], [1, -1] + ) + mask1 = backend.onehot(i0, alpha.shape[1]) + mask1 = backend.cast(mask1, dtypestr) + mask0 = backend.ones(alpha.shape[1]) - mask1 + mask12d = backend.tile(mask1[None, :], [alpha.shape[0], 1]) + mask02d = backend.tile(mask0[None, :], [alpha.shape[0], 1]) + alpha1 = mask02d * alpha1 + mask12d * alpha + r = [] + for j in range(2 * self.L): + indicator = ( + backend.sign(backend.cast((i - j), rdtypestr) ** 2 - 0.5) + 1 + ) / 2 + # i=j indicator = 0, i!=j indicator = 1 + indicator = backend.cast(indicator, dtypestr) + r.append( + backend.ones([self.L]) * indicator + + backend.ones([self.L]) * mask1 * (1 - indicator) + ) + # if j != i: + # r.append(backend.ones([L])) + # else: + # r.append(backend.ones([L]) * mask1) + mask2 = backend.stack(r) + alpha1 = alpha1 * mask2 + r = [] + for j in range(2 * self.L): + indicator = ( + backend.sign( + (backend.cast((i + L) % (2 * L) - j, rdtypestr)) ** 2 - 0.5 + ) + + 1 + ) / 2 + r.append(1 - indicator) + newcol = backend.stack(r) + # newcol = np.zeros([2 * self.L]) + # newcol[(i + L) % (2 * L)] = 1 + # newcol = backend.convert_to_tensor(newcol) + newcol = backend.cast(newcol, dtypestr) + alpha1 = alpha1 * mask02d + backend.tile(newcol[:, None], [1, self.L]) * mask12d + q, _ = backend.qr(alpha1) + self.alpha = q + + def cond_measure(self, ind: int, status: float, with_prob: bool = False) -> Tensor: + p0 = backend.real(self.get_cmatrix()[ind, ind]) + prob = backend.convert_to_tensor([p0, 1 - p0]) + status = backend.convert_to_tensor(status) + status = backend.cast(status, rdtypestr) + eps = 1e-12 + keep = (backend.sign(status - p0 + eps) + 1) / 2 + self.post_select(ind, keep) + if with_prob is False: + return keep + else: + return keep, prob + # def product(self, other): # # self@other # gamma1 = self.get_covariance_matrix() @@ -345,7 +432,15 @@ def get_covariance_matrix(self) -> Tensor: # ) +npb = get_backend("numpy") + + class FGSTestSimulator: + """ + Never use, only for correctness testing + stick to numpy backend and no jit/ad/vmap is available + """ + def __init__( self, L: int, filled: Optional[List[int]] = None, hc: Optional[Tensor] = None ): @@ -419,14 +514,12 @@ def chemical_potential_jw(chi: Tensor, i: int, L: int) -> Tensor: return m def evol_hamiltonian(self, h: Tensor) -> None: - self.state = backend.expm(-1 / 2 * 1.0j * h) @ backend.reshape( - self.state, [-1, 1] - ) - self.state = backend.reshape(self.state, [-1]) + self.state = npb.expm(-1 / 2 * 1.0j * h) @ npb.reshape(self.state, [-1, 1]) + self.state = npb.reshape(self.state, [-1]) def evol_ihamiltonian(self, h: Tensor) -> None: - self.state = backend.expm(-1 / 2 * h) @ backend.reshape(self.state, [-1, 1]) - self.state = backend.reshape(self.state, [-1]) + self.state = npb.expm(-1 / 2 * h) @ npb.reshape(self.state, [-1, 1]) + self.state = npb.reshape(self.state, [-1]) self.orthogonal() def evol_hp(self, i: int, j: int, chi: Tensor = 0) -> None: @@ -548,3 +641,25 @@ def product(self, other: "FGSTestSimulator") -> Tensor: rho = rho1 @ rho2 rho /= backend.trace(rho) return rho + + def post_select(self, i: int, keep: int = 1) -> None: + c = Circuit(self.L, inputs=self.state) + c.post_select(i, keep) + s = c.state() + s /= backend.norm(s) + self.state = s + + def cond_measure(self, ind: int, status: float, with_prob: bool = False) -> Tensor: + p0 = self.get_cmatrix()[ind, ind] + prob = [p0, 1 - p0] + if status < p0: + self.post_select(ind, 0) + keep = 0 + else: + self.post_select(ind, 1) + keep = 1 + + if with_prob is False: + return keep + else: + return keep, prob diff --git a/tests/test_fgs.py b/tests/test_fgs.py index 2facc03c..718f58cc 100644 --- a/tests/test_fgs.py +++ b/tests/test_fgs.py @@ -2,7 +2,6 @@ import pytest from pytest_lazyfixture import lazy_fixture as lf import tensorflow as tf -import optax try: import openfermion as _ @@ -43,6 +42,8 @@ def test_cmatrix(backend, highp): @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_fgs_ad(backend, highp): + import optax + N = 18 def f(chi): @@ -102,3 +103,64 @@ def test_ground_state(backend, highp): np.testing.assert_allclose(c.get_cmatrix(), c1.get_cmatrix(), atol=1e-6) np.testing.assert_allclose(c1.entropy([0]), c.entropy([0]), atol=1e-5) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_post_select(backend, highp): + for ind in [0, 1, 2]: + for keep in [0, 1]: + c = F(3, filled=[0, 2]) + c.evol_hp(0, 1, 0.2) + c.evol_cp(0, 0.5) + c.evol_hp(1, 2, 0.3j) + c.evol_cp(1, -0.8) + c.evol_sp(0, 2, 0.3) + c.post_select(ind, keep) + c1 = FT(3, filled=[0, 2]) + c1.evol_hp(0, 1, 0.2) + c1.evol_cp(0, 0.5) + c1.evol_hp(1, 2, 0.3j) + c1.evol_cp(1, -0.8) + c1.evol_sp(0, 2, 0.3) + c1.post_select(ind, keep) + np.testing.assert_allclose(c.get_cmatrix(), c1.get_cmatrix(), atol=1e-5) + + +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +def test_jittable_measure(backend): + @tc.backend.jit + def get_cmatrix(status): + r = [] + c = F(3, filled=[0]) + c.evol_hp(0, 1, 0.2) + c.evol_cp(0, 0.5) + c.evol_hp(1, 2, 0.3j) + r.append(c.cond_measure(1, status[0])) + c.evol_cp(1, -0.8) + r.append(c.cond_measure(2, status[1])) + r.append(c.cond_measure(1, status[3])) + c.evol_sp(0, 2, 0.3) + c.evol_hp(2, 1, 0.2) + c.evol_hp(0, 1, 0.8) + return c.get_cmatrix(), tc.backend.stack(r) + + def get_cmatrix_baseline(status): + r = [] + c = FT(3, filled=[0]) + c.evol_hp(0, 1, 0.2) + c.evol_cp(0, 0.5) + c.evol_hp(1, 2, 0.3j) + r.append(c.cond_measure(1, status[0])) + c.evol_cp(1, -0.8) + r.append(c.cond_measure(2, status[1])) + r.append(c.cond_measure(1, status[3])) + c.evol_sp(0, 2, 0.3) + c.evol_hp(2, 1, 0.2) + c.evol_hp(0, 1, 0.8) + return c.get_cmatrix(), np.array(r) + + status = np.array([0.2, 0.83, 0.61, 0.07]) + m, his = get_cmatrix(tc.backend.convert_to_tensor(status)) + m1, his1 = get_cmatrix_baseline(status) + np.testing.assert_allclose(m, m1, atol=1e-5) + np.testing.assert_allclose(his, his1, atol=1e-5) From de45e8b83414703526f02f54db1211bdeaadced8 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 1 Sep 2023 16:38:33 +0800 Subject: [PATCH 639/725] add expectation for fgs --- README.md | 2 ++ tensorcircuit/fgs.py | 78 ++++++++++++++++++++++++++++++++++++++++++-- tests/test_fgs.py | 36 ++++++++++++++++++++ 3 files changed, 114 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 2b548913..089cd0ac 100644 --- a/README.md +++ b/README.md @@ -171,6 +171,8 @@ We also have [Docker support](/docker). - Support **analog/digital hybrid simulation** (time dependent Hamiltonian evolution, **pulse** level simulation) with neural ode modes. + - Support **Fermion Gaussian state** simulation with expectation, entanglement, measurment, ground state, real and imaginary time evolution. + - Support **qudits simulation**. - Support **parallel** quantum circuit evaluation across **multiple GPUs**. diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index f35fd595..ea54e26e 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -58,6 +58,10 @@ def __init__( :type L: int :param filled: the fermion site that is fully occupied, defaults to None :type filled: Optional[List[int]], optional + :param alpha: directly specify the alpha tensor as the input + :type alpha: Optional[Tensor], optional + :param hc: the input is given as the ground state of quadratic Hamiltonian ``hc`` + :type hc: Optional[Tensor], optional :param cmatrix: only used for debug, defaults to None :type cmatrix: Optional[Tensor], optional """ @@ -109,7 +113,7 @@ def fermion_diagonalization_2( alpha = backend.adjoint(u)[:, :L] # c' = u@c # e_k (c^\dagger_k c_k - c_k c^\dagger_k) - return (es, u, alpha) + return es, u, alpha @staticmethod def wmatrix(L: int) -> Tensor: @@ -141,7 +145,10 @@ def get_alpha(self) -> Tensor: def get_cmatrix(self) -> Tensor: if self.cmatrix is not None: return self.cmatrix - return self.alpha @ backend.adjoint(self.alpha) + else: + cmatrix = self.alpha @ backend.adjoint(self.alpha) + self.cmatrix = cmatrix + return cmatrix def get_reduced_cmatrix(self, subsystems_to_trace_out: List[int]) -> Tensor: m = self.get_cmatrix() @@ -209,6 +216,7 @@ def evol_hamiltonian(self, h: Tensor) -> None: # e^{-i/2 H} h = backend.cast(h, dtype=dtypestr) self.alpha = backend.expm(-1.0j * h) @ self.alpha + self.cmatrix = None def evol_ihamiltonian(self, h: Tensor) -> None: r""" @@ -221,6 +229,7 @@ def evol_ihamiltonian(self, h: Tensor) -> None: h = backend.cast(h, dtype=dtypestr) self.alpha = backend.expm(h) @ self.alpha self.orthogonal() + self.cmatrix = None def orthogonal(self) -> None: q, _ = backend.qr(self.alpha) @@ -329,6 +338,45 @@ def get_covariance_matrix(self) -> Tensor: m = self.get_cmatrix_majorana() return -1.0j * (2 * m - backend.eye(self.L * 2)) + def expectation_2body(self, i: int, j: int) -> Tensor: + """ + expectation of two fermion terms + convention: (c, c^\dagger) + for i>L, c_{i-L}^\dagger is assumed + + :param i: _description_ + :type i: int + :param j: _description_ + :type j: int + :return: _description_ + :rtype: Tensor + """ + return self.get_cmatrix()[i][j] + + def expectation_4body(self, i: int, j: int, k: int, l: int) -> Tensor: + """ + expectation of four fermion terms using Wick Thm + convention: (c, c^\dagger) + for i>L, c_{i-L}^\dagger is assumed + + :param i: _description_ + :type i: int + :param j: _description_ + :type j: int + :param k: _description_ + :type k: int + :param l: _description_ + :type l: int + :return: _description_ + :rtype: Tensor + """ + e = ( + self.expectation_2body(i, j) * self.expectation_2body(k, l) + - self.expectation_2body(i, k) * self.expectation_2body(j, l) + + self.expectation_2body(i, l) * self.expectation_2body(j, k) + ) + return e + def post_select(self, i: int, keep: int = 1) -> None: """ post select (project) the fermion state to occupation eigenstate @@ -620,6 +668,32 @@ def get_cmatrix_majorana(self) -> Tensor: return cmatrix + def expectation_4body(self, i: int, j: int, k: int, l: int) -> Tensor: + s = "" + if i < self.L: + s += str(i) + "" + else: + s += str(i) + "^ " + if j < self.L: + s += str(j) + "" + else: + s += str(j) + "^ " + if k < self.L: + s += str(k) + "" + else: + s += str(k) + "^ " + if l < self.L: + s += str(l) + "" + else: + s += str(l) + "^ " + op = openfermion.FermionOperator(s) + m = openfermion.get_sparse_operator(op, n_qubits=self.L).todense() + return ( + npb.reshape(npb.adjoint(self.state), [1, -1]) + @ m + @ npb.reshape(self.state, [-1, 1]) + )[0, 0] + def entropy(self, subsystems_to_trace_out: Optional[List[int]] = None) -> Tensor: rm = quantum.reduced_density_matrix(self.state, subsystems_to_trace_out) # type: ignore return quantum.entropy(rm) diff --git a/tests/test_fgs.py b/tests/test_fgs.py index 718f58cc..2906e410 100644 --- a/tests/test_fgs.py +++ b/tests/test_fgs.py @@ -164,3 +164,39 @@ def get_cmatrix_baseline(status): m1, his1 = get_cmatrix_baseline(status) np.testing.assert_allclose(m, m1, atol=1e-5) np.testing.assert_allclose(his, his1, atol=1e-5) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_exp_4body(backend): + c = F(4, filled=[0, 2]) + c.evol_hp(0, 1, 0.3) + c.evol_hp(2, 3, 0.3) + c.evol_sp(0, 3, 0.5) + c.evol_sp(0, 2, 0.9) + c.evol_cp(0, -0.4) + + c1 = FT(4, filled=[0, 2]) + c1.evol_hp(0, 1, 0.3) + c1.evol_hp(2, 3, 0.3) + c1.evol_sp(0, 3, 0.5) + c1.evol_sp(0, 2, 0.9) + c1.evol_cp(0, -0.4) + + np.testing.assert_allclose( + c.expectation_4body(0, 4, 1, 5), c.expectation_4body(0, 4, 1, 5), atol=1e-5 + ) + np.testing.assert_allclose( + c.expectation_4body(0, 1, 4, 5), c.expectation_4body(0, 1, 4, 5), atol=1e-5 + ) + np.testing.assert_allclose( + c.expectation_4body(0, 4, 2, 6), c.expectation_4body(0, 4, 2, 6), atol=1e-5 + ) + np.testing.assert_allclose( + c.expectation_4body(0, 2, 3, 1), c.expectation_4body(0, 2, 3, 1), atol=1e-5 + ) + np.testing.assert_allclose( + c.expectation_4body(0, 1, 4, 6), c.expectation_4body(0, 1, 4, 6), atol=1e-5 + ) + np.testing.assert_allclose( + c.expectation_4body(1, 0, 6, 7), c.expectation_4body(1, 0, 6, 7), atol=1e-5 + ) From 12de36cf3729d1d28e923bae8e1aa8906be5edd7 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 2 Sep 2023 10:52:11 +0800 Subject: [PATCH 640/725] add entanglement negativity --- CHANGELOG.md | 2 ++ tensorcircuit/quantum.py | 39 +++++++++++++++++++++++++++++++++++++++ tests/test_quantum.py | 20 ++++++++++++++++++++ 3 files changed, 61 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index c2a51e70..45893f18 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,8 @@ - Add fermion Gaussian state simulator in `fgs.py` +- Add `partial_transpose` and `entanglement_negativity` method in `quantum.py` + ### Changed - move ensemble module to applications/ai (breaking changes) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index dd9f11ab..8459051c 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -39,6 +39,7 @@ from .cons import backend, contractor, dtypestr, npdtype, rdtypestr from .backends import get_backend from .utils import is_m1mac, arg_alias +from .gates import Gate Tensor = Any Graph = Any @@ -1790,6 +1791,44 @@ def truncated_free_energy( return energy - renyi / beta +@op2tensor +def partial_transpose(rho: Tensor, transposed_sites: List[int]) -> Tensor: + rho = backend.reshape2(rho) + rho_node = Gate(rho) + n = len(rho.shape) // 2 + left_edges = [] + right_edges = [] + for i in range(n): + if i not in transposed_sites: + left_edges.append(rho_node[i]) + right_edges.append(rho_node[i + n]) + else: + left_edges.append(rho_node[i + n]) + right_edges.append(rho_node[i]) + rhot_op = QuOperator(out_edges=left_edges, in_edges=right_edges) + rhot = rhot_op.eval_matrix() + return rhot + + +@op2tensor +def entanglement_negativity(rho: Tensor, transposed_sites: List[int]) -> Tensor: + rhot = partial_transpose(rho, transposed_sites) + es = backend.eigvalsh(rhot) + rhot_m = backend.sum(backend.abs(es)) + return (backend.log(rhot_m) - 1.0) / 2.0 + + +@op2tensor +def log_negativity(rho: Tensor, transposed_sites: List[int], base: str = "e") -> Tensor: + rhot = partial_transpose(rho, transposed_sites) + es = backend.eigvalsh(rhot) + rhot_m = backend.sum(backend.abs(es)) + een = backend.log(rhot_m) + if base in ["2", 2]: + return een / backend.cast(backend.log(2.0), rdtypestr) + return een + + @partial(op2tensor, op_argnums=(0, 1)) def trace_distance(rho: Tensor, rho0: Tensor, eps: float = 1e-12) -> Tensor: """ diff --git a/tests/test_quantum.py b/tests/test_quantum.py index 609111ad..88ff1b12 100644 --- a/tests/test_quantum.py +++ b/tests/test_quantum.py @@ -364,6 +364,26 @@ def test_expectation_quantum(backend): np.testing.assert_allclose(exp1, exp2, atol=1e-5) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_negativity(backend, highp): + c = tc.DMCircuit(2) + c.h(0) + c.cnot(0, 1) + c.depolarizing(0, px=0.1, py=0.1, pz=0.1) + dm = c.state() + np.testing.assert_allclose( + tc.quantum.log_negativity(dm, [0], base="2"), 0.485427, atol=1e-5 + ) + np.testing.assert_allclose( + tc.quantum.partial_transpose(tc.quantum.partial_transpose(dm, [0]), [0]), + dm, + atol=1e-6, + ) + np.testing.assert_allclose( + tc.quantum.entanglement_negativity(dm, [1]), -0.33176, atol=1e-5 + ) + + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_tn2qop(backend): nwires = 6 From 4428206143e34df46749d5965735574d77fc8a27 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 2 Sep 2023 11:07:22 +0800 Subject: [PATCH 641/725] add some docs --- tensorcircuit/applications/README.md | 3 +++ tensorcircuit/quantum.py | 32 ++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/tensorcircuit/applications/README.md b/tensorcircuit/applications/README.md index c63ef6cf..202e06cf 100644 --- a/tensorcircuit/applications/README.md +++ b/tensorcircuit/applications/README.md @@ -1,3 +1,6 @@ +Code implementation in this submodule `applications` are not very well maintained and extensively tested. There are indeed many interesting pieces, but try on your own risk. + + ## Differentiable Quantum Architecture Search In `applications`, framework and relevant applications of DQAS are implemented, mainly in `vags.py` and `dqas.py`. diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 8459051c..7cfabee4 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1793,6 +1793,16 @@ def truncated_free_energy( @op2tensor def partial_transpose(rho: Tensor, transposed_sites: List[int]) -> Tensor: + """ + _summary_ + + :param rho: density matrix + :type rho: Tensor + :param transposed_sites: sites int list to be transposed + :type transposed_sites: List[int] + :return: _description_ + :rtype: Tensor + """ rho = backend.reshape2(rho) rho_node = Gate(rho) n = len(rho.shape) // 2 @@ -1812,6 +1822,16 @@ def partial_transpose(rho: Tensor, transposed_sites: List[int]) -> Tensor: @op2tensor def entanglement_negativity(rho: Tensor, transposed_sites: List[int]) -> Tensor: + """ + _summary_ + + :param rho: _description_ + :type rho: Tensor + :param transposed_sites: _description_ + :type transposed_sites: List[int] + :return: _description_ + :rtype: Tensor + """ rhot = partial_transpose(rho, transposed_sites) es = backend.eigvalsh(rhot) rhot_m = backend.sum(backend.abs(es)) @@ -1820,6 +1840,18 @@ def entanglement_negativity(rho: Tensor, transposed_sites: List[int]) -> Tensor: @op2tensor def log_negativity(rho: Tensor, transposed_sites: List[int], base: str = "e") -> Tensor: + """ + _summary_ + + :param rho: _description_ + :type rho: Tensor + :param transposed_sites: _description_ + :type transposed_sites: List[int] + :param base: whether use 2 based log or e based log, defaults to "e" + :type base: str, optional + :return: _description_ + :rtype: Tensor + """ rhot = partial_transpose(rho, transposed_sites) es = backend.eigvalsh(rhot) rhot_m = backend.sum(backend.abs(es)) From a687ee531689d0b5db0480a652c78aff8e7528e6 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 2 Sep 2023 17:20:03 +0800 Subject: [PATCH 642/725] add entanglement_entropy shortcut --- tensorcircuit/quantum.py | 6 ++++++ tests/test_quantum.py | 12 ++++++++++++ 2 files changed, 18 insertions(+) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 7cfabee4..9a47ebbe 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1582,6 +1582,12 @@ def trace_product(*o: Union[Tensor, QuOperator]) -> Tensor: return backend.trace(prod) +@op2tensor +def entanglement_entropy(state: Tensor, cut: Union[int, List[int]]): + rho = reduced_density_matrix(state, cut) + return entropy(rho) + + def reduced_density_matrix( state: Union[Tensor, QuOperator], cut: Union[int, List[int]], diff --git a/tests/test_quantum.py b/tests/test_quantum.py index 88ff1b12..13d06354 100644 --- a/tests/test_quantum.py +++ b/tests/test_quantum.py @@ -364,6 +364,18 @@ def test_expectation_quantum(backend): np.testing.assert_allclose(exp1, exp2, atol=1e-5) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_ee(backend): + c = tc.Circuit(3) + c.h(0) + c.cx(0, 1) + c.cx(1, 2) + s = c.state() + np.testing.assert_allclose( + tc.quantum.entanglement_entropy(s, [0, 1]), np.log(2.0), atol=1e-5 + ) + + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_negativity(backend, highp): c = tc.DMCircuit(2) From 7f4001c32c8e8955ab7947521869cc98ddc45e5e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 2 Sep 2023 20:54:42 +0800 Subject: [PATCH 643/725] fix mypy --- tensorcircuit/quantum.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 9a47ebbe..1a4a84d8 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1583,7 +1583,7 @@ def trace_product(*o: Union[Tensor, QuOperator]) -> Tensor: @op2tensor -def entanglement_entropy(state: Tensor, cut: Union[int, List[int]]): +def entanglement_entropy(state: Tensor, cut: Union[int, List[int]]) -> Tensor: rho = reduced_density_matrix(state, cut) return entropy(rho) From 71178f0449f8ab971deb72ac7ee102e3499933a9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 4 Sep 2023 10:13:17 +0800 Subject: [PATCH 644/725] doc prettify --- README.md | 14 ++++++++++++++ tensorcircuit/fgs.py | 8 ++++---- 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 089cd0ac..4174bdae 100644 --- a/README.md +++ b/README.md @@ -111,6 +111,20 @@ c.cx(range(n-1), range(1, n)) c.expectation_ps(z=[0, n-1], reuse=False) ``` +- Density matrix simulator and quantum info quantities + +```python +c = tc.DMCircuit(2) +c.h(0) +c.cx(0, 1) +c.depolarizing(1, px=0.1, py=0.1, pz=0.1) +dm = c.state() +print(tc.quantum.entropy(dm)) +print(tc.quantum.entanglement_entropy(dm, [0])) +print(tc.quantum.entanglement_negativity(dm, [0])) +print(tc.quantum.log_negativity(dm, [0])) +``` + ## Install diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index ea54e26e..c4919f7c 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -247,7 +247,7 @@ def hopping(chi: Tensor, i: int, j: int, L: int) -> Tensor: def evol_hp(self, i: int, j: int, chi: Tensor = 0) -> None: r""" - The evolve Hamiltonian is :math:`chi c_i^\dagger c_j +h.c.` + The evolve Hamiltonian is :math:`\chi c_i^\dagger c_j +h.c.` :param i: _description_ :type i: int @@ -323,10 +323,10 @@ def get_bogoliubov_uv(self) -> Tuple[Tensor, Tensor]: ) def get_cmatrix_majorana(self) -> Tensor: - """ + r""" correlation matrix defined in majorana basis - convention: gamma_0 = c0 + c0^\dagger - gamma_1 = i(c0 - c0^\dagger) + convention: :math:`gamma_0 = c_0 + c_0^\dagger` + :math:`gamma_1 = i(c_0 - c_0^\dagger)` :return: _description_ :rtype: Tensor From e7ff994a71993c19380fd11f62940dfc29088a0f Mon Sep 17 00:00:00 2001 From: PeilinZHENG Date: Tue, 5 Sep 2023 11:30:15 +0800 Subject: [PATCH 645/725] Fix the typos in classical_shadows.ipynb --- docs/source/tutorials/classical_shadows.ipynb | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/source/tutorials/classical_shadows.ipynb b/docs/source/tutorials/classical_shadows.ipynb index 9b53f860..e6776482 100644 --- a/docs/source/tutorials/classical_shadows.ipynb +++ b/docs/source/tutorials/classical_shadows.ipynb @@ -30,21 +30,21 @@ { "cell_type": "markdown", "source": [ - "Let's first briefly review the classical shadows in Pauli basis. For an $n$-qubit quantum state $\\rho$, we randomly perform Pauli projection measurement on each qubit and obtain a snapshot like $\\{1,-1,-1,1,\\cdots,1,-1\\}$. This process is equivalent to apply a random unitary $U$ to $\\rho$ and measure in computational basis to obtain $|b\\rangle=|s_1\\cdots s_n\\rangle,\\ s_j\\in\\{0,1\\}$:\n", + "Let's first briefly review the classical shadows in Pauli basis. For an $n$-qubit quantum state $\\rho$, we randomly perform Pauli projection measurement on each qubit and obtain a snapshot like $\\{1,-1,-1,1,\\cdots,1,-1\\}$. This process is equivalent to apply a random unitary $U_i$ to $\\rho$ and measure in computational basis to obtain $|b_i\\rangle=|s_{i1}\\cdots s_{in}\\rangle,\\ s_{ij}\\in\\{0,1\\}$:\n", "$$\n", - "\\rho\\rightarrow U\\rho U^{\\dagger}\\xrightarrow{measure}|b\\rangle\\langle b|,\n", + "\\rho\\rightarrow U_i\\rho U_i^{\\dagger}\\xrightarrow{measure}|b_i\\rangle\\langle b_i|,\n", "$$\n", - "where $U=\\bigotimes_{j=1}^{n}u_j$, $u_i\\in\\{H, HS^{\\dagger}, \\mathbb{I}\\}$ correspond to the projection measurements of Pauli $X$, $Y$, $Z$ respectively. Then we reverse the operation to get the equivalent measurement result on $\\rho$:\n", + "where $U_i=\\bigotimes_{j=1}^{n}u_{ij}$, $u_{ij}\\in\\{H, HS^{\\dagger}, \\mathbb{I}\\}$ correspond to the projection measurements of Pauli $X$, $Y$, $Z$ respectively. Then we reverse the operation to get the equivalent measurement result on $\\rho$:\n", "$$\n", - "\\rho\\xrightarrow{measure}U^{\\dagger}|b\\rangle\\langle b| U.\n", + "\\rho\\xrightarrow{measure}U_i^{\\dagger}|b_i\\rangle\\langle b_i| U_i.\n", "$$\n", "Moreover, we perform $N$ random measurements and view their average as a quantum channel:\n", "$$\n", - "\\mathbb{E}\\left[U^{\\dagger}|b\\rangle\\langle b|U\\right]=\\mathcal{M}(\\rho),\n", + "\\mathbb{E}\\left[U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i\\right]=\\mathcal{M}(\\rho),\n", "$$\n", "we can invert the channel to get the approximation of $\\rho$:\n", "$$\n", - "\\rho=\\mathbb{E}\\left[\\mathcal{M}^{-1}(U^{\\dagger}|b\\rangle\\langle b|U)\\right].\n", + "\\rho=\\mathbb{E}\\left[\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)\\right].\n", "$$\n", "We call each $\\rho_i=\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)$ a shadow snapshot state and their ensemble $S(\\rho;N)=\\{\\rho_i|i=1,\\cdots,N\\}$ classical shadows." ], @@ -58,13 +58,13 @@ "In Pauli basis, we have a simple expression of $\\mathcal{M}^{-1}$:\n", "$$\n", "\\begin{split}\n", - " \\rho_i&=\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)=\\bigotimes_{j=1}^{n}3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I},\\\\\n", + " \\rho_i&=\\mathcal{M}^{-1}(U_i^{\\dagger}|b_i\\rangle\\langle b_i|U_i)=\\bigotimes_{j=1}^{n}\\left(3u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}|u_{ij}-\\mathbb{I}\\right),\\\\\n", " \\rho&=\\frac{1}{N}\\sum_{i=1}^{N}\\rho_i\\ .\n", "\\end{split}\n", "$$\n", "For an observable Pauli string $O=\\bigotimes_{j=1}^{n}P_j,\\ P_j\\in\\{\\mathbb{I}, X, Y, Z\\}$, we can directly use $\\rho$ to calculate $\\langle O\\rangle=\\text{Tr}(O\\rho)$. In practice, we will divide the classical shadows into $K$ parts to calculate the expectation values independently and take the median to avoid the influence of outliers:\n", "$$\n", - "\\langle O\\rangle=\\text{median}\\{\\langle O_{(1)}\\rangle\\cdots\\langle O_{(K)}\\rangle\\},\n", + "\\langle O\\rangle=\\text{median}\\{\\langle O_{(1)}\\rangle,\\cdots,\\langle O_{(K)}\\rangle\\},\n", "$$\n", "where\n", "$$\n", @@ -248,7 +248,7 @@ { "cell_type": "markdown", "source": [ - "If ``measurement_only=True`` (default ``False``), the outputs of ``shadow_snapshots`` are snapshot bit strings $b=s_1\\cdots s_n,\\ s_j\\in\\{0,1\\}$, otherwise the outputs are snapshot states $\\{u_{j}^{\\dagger}|s_j\\rangle\\langle s_j| u_j\\ |j=1,\\cdots,n\\}$. If you only need to generate one batch of snapshots or generate multiple batches of snapshots with different ``nps`` or ``r``, jit cannot provide speedup. JIT will only accelerate when the same shape of snapshots are generated multiple times." + "If ``measurement_only=True`` (default ``False``), the outputs of ``shadow_snapshots`` are snapshot bit strings $\\{b_i=s_{i1}\\cdots s_{in}\\ |i=1,\\cdots,N,\\ s_{ij}\\in\\{0,1\\}\\}$, otherwise the outputs are snapshot states $\\{u_{ij}^{\\dagger}|s_{ij}\\rangle\\langle s_{ij}| u_{ij}\\ |i=1,\\cdots,N,\\ j=1,\\cdots,n\\}$. If you only need to generate one batch of snapshots or generate multiple batches of snapshots with different ``nps`` or ``r``, jit cannot provide speedup. Jit will only accelerate when the same shape of snapshots are generated multiple times." ], "metadata": { "collapsed": false From e29d7366e378fa5bb72a3af7355a68052aed2d38 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 5 Sep 2023 12:38:14 +0800 Subject: [PATCH 646/725] black --- tensorcircuit/results/qem/benchmark_circuits.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tensorcircuit/results/qem/benchmark_circuits.py b/tensorcircuit/results/qem/benchmark_circuits.py index 9c6023c9..368cc828 100644 --- a/tensorcircuit/results/qem/benchmark_circuits.py +++ b/tensorcircuit/results/qem/benchmark_circuits.py @@ -16,9 +16,7 @@ generate_rb_circuits, generate_w_circuit, ) - from mitiq.interface import ( - convert_from_mitiq, - ) + from mitiq.interface import convert_from_mitiq except ModuleNotFoundError: logger.warning("mitiq is not installed, please ``pip install mitiq`` first") From b96a1b1c11df8c767e85476efd6c336bb2b3a7b9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 5 Sep 2023 17:24:23 +0800 Subject: [PATCH 647/725] fix fgs exp_2 bug --- README.md | 2 +- tensorcircuit/fgs.py | 2 +- tests/test_fgs.py | 8 ++++++++ 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 4174bdae..677beaa0 100644 --- a/README.md +++ b/README.md @@ -185,7 +185,7 @@ We also have [Docker support](/docker). - Support **analog/digital hybrid simulation** (time dependent Hamiltonian evolution, **pulse** level simulation) with neural ode modes. - - Support **Fermion Gaussian state** simulation with expectation, entanglement, measurment, ground state, real and imaginary time evolution. + - Support **Fermion Gaussian state** simulation with expectation, entanglement, measurement, ground state, real and imaginary time evolution. - Support **qudits simulation**. diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index c4919f7c..565d1585 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -351,7 +351,7 @@ def expectation_2body(self, i: int, j: int) -> Tensor: :return: _description_ :rtype: Tensor """ - return self.get_cmatrix()[i][j] + return self.get_cmatrix()[i][(j + self.L) % (2 * self.L)] def expectation_4body(self, i: int, j: int, k: int, l: int) -> Tensor: """ diff --git a/tests/test_fgs.py b/tests/test_fgs.py index 2906e410..526c94ff 100644 --- a/tests/test_fgs.py +++ b/tests/test_fgs.py @@ -166,6 +166,14 @@ def get_cmatrix_baseline(status): np.testing.assert_allclose(his, his1, atol=1e-5) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_exp_2body(backend): + c = F(3, filled=[1]) + np.testing.assert_allclose(c.expectation_2body(4, 1), 1.0, atol=1e-5) + np.testing.assert_allclose(c.expectation_2body(5, 2), 0.0, atol=1e-5) + np.testing.assert_allclose(c.expectation_2body(1, 4), 0.0, atol=1e-5) + + @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_exp_4body(backend): c = F(4, filled=[0, 2]) From 7acd0c17db8e8d796f85a64d73231aade7848a80 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 13 Sep 2023 20:41:52 +0800 Subject: [PATCH 648/725] fix jax eigh ad --- CHANGELOG.md | 4 ++++ tensorcircuit/backends/jax_backend.py | 7 +++++++ tensorcircuit/backends/jax_ops.py | 26 ++++++++++++++++++++++++++ tensorcircuit/fgs.py | 22 ++++++++++++++-------- 4 files changed, 51 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 45893f18..a4d2c684 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,10 @@ - tc2qiskit now record qiskit measure with incremental clbit from 0 +### Fixed + +- Support degenerate eigenvalue for jax backend `eigh` method when using AD + ## 0.11.0 ### Added diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index c9ca0249..994f4bfc 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -156,12 +156,19 @@ def _rq_jax( return r, q +def _eigh_jax(self: Any, tensor: Tensor) -> Tensor: + from .jax_ops import adaware_eigh_jit as adaware_eigh + + return adaware_eigh(tensor) + + tensornetwork.backends.jax.jax_backend.JaxBackend.convert_to_tensor = ( _convert_to_tensor_jax ) tensornetwork.backends.jax.jax_backend.JaxBackend.svd = _svd_jax tensornetwork.backends.jax.jax_backend.JaxBackend.qr = _qr_jax tensornetwork.backends.jax.jax_backend.JaxBackend.rq = _rq_jax +tensornetwork.backends.jax.jax_backend.JaxBackend.eigh = _eigh_jax class JaxBackend(jax_backend.JaxBackend, ExtendedBackend): # type: ignore diff --git a/tensorcircuit/backends/jax_ops.py b/tensorcircuit/backends/jax_ops.py index efcce174..57e86609 100644 --- a/tensorcircuit/backends/jax_ops.py +++ b/tensorcircuit/backends/jax_ops.py @@ -145,3 +145,29 @@ def _QrGradSquareAndDeepMatrices(q: Array, r: Array, dq: Array, dr: Array) -> Ar adaware_qr.defvjp(jaxqr_fwd, jaxqr_bwd) # type: ignore adaware_qr_jit = jax.jit(adaware_qr) + + +@jax.custom_vjp +def adaware_eigh(A: Array) -> Array: + return jnp.linalg.eigh(A) + + +def jaxeigh_fwd(A: Array) -> Array: + e, v = jnp.linalg.eigh(A) + return (e, v), (A, e, v) + + +def jaxeigh_bwd(r: Array, tangents: Array) -> Array: + a, e, v = r + de, dv = tangents + eye_n = jnp.eye(a.shape[-1], dtype=a.dtype) + f = _safe_reciprocal(e[..., jnp.newaxis, :] - e[..., jnp.newaxis] + eye_n) - eye_n + middle = jnp.diag(de) + jnp.multiply(f, (v.T @ dv)) + grad_a = jnp.conj(v) @ middle @ v.T + return (grad_a,) + + +# denegerate eigev values lead nan in eigh gradients, while tf has fixed that long ago + +adaware_eigh.defvjp(jaxeigh_fwd, jaxeigh_bwd) +adaware_eigh_jit = jax.jit(adaware_eigh) diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index 565d1585..b853d02e 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -26,7 +26,6 @@ def onehot_matrix(i: int, j: int, N: int) -> Tensor: # TODO(@refraction-ray): efficiency benchmark with jit -# TODO(@refraction-ray): occupation number post-selection/measurement # TODO(@refraction-ray): FGS mixed state support? # TODO(@refraction-ray): overlap? @@ -490,14 +489,21 @@ class FGSTestSimulator: """ def __init__( - self, L: int, filled: Optional[List[int]] = None, hc: Optional[Tensor] = None + self, + L: int, + filled: Optional[List[int]] = None, + state: Optional[Tensor] = None, + hc: Optional[Tensor] = None, ): if filled is None: filled = [] self.L = L - self.state = self.init_state(filled, L) - if hc is not None: + if state is not None: + self.state = state + elif hc is not None: self.state = self.fermion_diagonalization(hc, L) + else: + self.state = self.init_state(filled, L) @staticmethod def init_state(filled: List[int], L: int) -> Tensor: @@ -673,19 +679,19 @@ def expectation_4body(self, i: int, j: int, k: int, l: int) -> Tensor: if i < self.L: s += str(i) + "" else: - s += str(i) + "^ " + s += str(i - self.L) + "^ " if j < self.L: s += str(j) + "" else: - s += str(j) + "^ " + s += str(j - self.L) + "^ " if k < self.L: s += str(k) + "" else: - s += str(k) + "^ " + s += str(k - self.L) + "^ " if l < self.L: s += str(l) + "" else: - s += str(l) + "^ " + s += str(l - self.L) + "^ " op = openfermion.FermionOperator(s) m = openfermion.get_sparse_operator(op, n_qubits=self.L).todense() return ( From b14c67df655dc70b174173bc512b0d06ee53c2c9 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Wed, 13 Sep 2023 14:27:35 +0100 Subject: [PATCH 649/725] CVaR is now jittable --- tensorcircuit/applications/optimization.py | 83 +++++++++++++--------- 1 file changed, 48 insertions(+), 35 deletions(-) diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index a579d6b8..e2609e1f 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -5,7 +5,6 @@ from typing import List, Callable, Any, Optional, Tuple from functools import partial -import numpy as np import tensorflow as tf import scipy.optimize as optimize @@ -161,7 +160,7 @@ def QUBO_QAOA( # Return the optimized parameters for the ansatz circuit. -def cvar_value(r: List[float], p: List[float], percent: float) -> float: +def cvar_value(r: List[float], p: List[float], percent: float) -> Any: """ Calculate the Conditional Value at Risk (CVaR) according to the measurement results. @@ -170,17 +169,17 @@ def cvar_value(r: List[float], p: List[float], percent: float) -> float: :param percent: The cut-off percentage of CVaR. :return: The calculated CVaR value. """ - sorted_indices = np.argsort(r) - p = np.array(p)[sorted_indices] - r = np.array(r)[sorted_indices] + sorted_indices = tf.argsort(r) + p = tf.cast(tf.gather(p, sorted_indices), dtype=tf.float32) + r = tf.cast(tf.gather(r, sorted_indices), dtype=tf.float32) - sump = 0.0 # The sum of probabilities. - count = 0 - cvar_result = 0.0 + sump = tf.constant(0.0, dtype=tf.float32) # The sum of probabilities. + count = tf.constant(0, dtype=tf.int32) + cvar_result = tf.constant(0.0, dtype=tf.float32) # Iterate over the sorted results and calculate CVaR. while sump < percent: - if round(sump + p[count], 6) >= percent: + if tf.math.round(sump + p[count], 6) >= percent: # Add the remaining portion of the last result that exceeds the cut-off percentage. cvar_result += r[count] * (percent - sump) count += 1 @@ -195,9 +194,7 @@ def cvar_value(r: List[float], p: List[float], percent: float) -> float: return cvar_result -def cvar_from_circuit( - circuit: Circuit, nsamples: int, Q: Tensor, alpha: float -) -> float: +def cvar_from_circuit(circuit: Circuit, nsamples: int, Q: Tensor, alpha: float) -> Any: """ Directly calculate the Conditional Value at Risk (CVaR) from a circuit. The CVaR depends on a bunch of measurements. @@ -208,27 +205,31 @@ def cvar_from_circuit( :param alpha: The cut-off percentage for CVaR. :return: The calculated CVaR value. """ - s = circuit.state() + # Get measurement results and normalize them. results = measurement_results( - s, counts=nsamples, format="count_dict_bin" - ) # Get readouts from the measurements. - results = {k: v / nsamples for k, v in results.items()} # Normalize the results. + circuit.state(), counts=nsamples, format="count_dict_bin" + ) + results = {k: v / nsamples for k, v in results.items()} + values = [] # List to store the measurement values. probabilities = [] # List to store the corresponding probabilities. + Q_tf = tf.convert_to_tensor(Q, dtype=tf.float32) - # Iterate over the measurement results and calculate the values and probabilities. for k, v in results.items(): - x = np.array([int(bit) for bit in k]) - values.append(np.dot(x, np.dot(Q, x))) + binary_strings = tf.strings.bytes_split(k) + x = tf.reshape( + tf.strings.to_number(binary_strings, out_type=tf.float32), (-1, 1) + ) + xT = tf.transpose(x) + values.append(tf.squeeze(tf.matmul(xT, tf.matmul(Q_tf, x)))) probabilities.append(v) cvar_result = cvar_value(values, probabilities, alpha) - # Calculate the CVaR using the cvar_value function. return cvar_result -def cvar_from_expectation(circuit: Circuit, Q: Tensor, alpha: float) -> float: +def cvar_from_expectation(circuit: Circuit, Q: Tensor, alpha: float) -> Any: """ Calculate the Conditional Value at Risk (CVaR) from the expectation values of a quantum circuit. @@ -237,23 +238,34 @@ def cvar_from_expectation(circuit: Circuit, Q: Tensor, alpha: float) -> float: :param alpha: The cut-off percentage for CVaR. :return: The calculated CVaR value. """ - prob = circuit.probability() # Get the probabilities of the circuit states. - prob /= np.sum(prob) - states = [] - # Generate all possible binary states based on the length of Q. - for i in range(2 ** len(Q)): - a = f"{bin(i)[2:]:0>{len(Q)}}" - states.append(a) + # Calculate the probability amplitudes for quantum circuit outcomes. + prob = tf.convert_to_tensor(circuit.probability(), dtype=tf.float32) + + # Generate all possible binary states for the given Q-matrix. + states = tf.constant( + [format(i, "0" + str(len(Q)) + "b") for i in range(2 ** len(Q))] + ) + + # Convert the Q-matrix to a TensorFlow tensor. + Q_tf = tf.convert_to_tensor(Q, dtype=tf.float32) values = [] + + # Calculate the cost for each binary state. for state in states: - x = np.array([int(bit) for bit in state]) - values.append(np.dot(x, np.dot(Q, x))) - # Calculate the values by taking the dot product of each state with the Q-matrix. + binary_strings = tf.strings.bytes_split(state) + x = tf.reshape( + tf.strings.to_number(binary_strings, out_type=tf.float32), (-1, 1) + ) + xT = tf.transpose(x) # the transpose + value = tf.squeeze(tf.matmul(xT, tf.matmul(Q_tf, x))) + values.append(value) + + values = tf.convert_to_tensor(values, dtype=tf.float32) + # Calculate the CVaR value using the computed values and the probability distribution. cvar_result = cvar_value(values, prob, alpha) - # Calculate the CVaR using the cvar_value function. return cvar_result @@ -265,7 +277,7 @@ def cvar_loss( alpha: float, expectation_based: bool, params: List[float], -) -> float: +) -> Any: """ Calculate the CVaR loss for a given QUBO problem using the QAOA ansatz. @@ -297,7 +309,7 @@ def cvar_loss( def QUBO_QAOA_cvar( Q: Tensor, nlayers: int, - alpha: int, + alpha: float, nsamples: int = 1000, callback: Optional[Callable[[List[float], float], None]] = None, expectation_based: bool = False, @@ -318,9 +330,10 @@ def QUBO_QAOA_cvar( :param maxiter: The maximum number of iterations for the optimization. Default is 1000. :return: The optimized parameters for the ansatz circuit. """ + tf.config.run_functions_eagerly(True) loss = partial(cvar_loss, nlayers, Q, nsamples, alpha, expectation_based) - f_scipy = scipy_interface(loss, shape=(2 * nlayers,), jit=False, gradient=False) + f_scipy = scipy_interface(loss, shape=(2 * nlayers,), jit=True, gradient=False) if init_params is None: params = backend.implicit_randn(shape=[2 * nlayers], stddev=0.5) From 2fa179b699487c836a81741f10e418c268379855 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Wed, 13 Sep 2023 14:28:01 +0100 Subject: [PATCH 650/725] modify the qubo tutorials --- .../tutorials/portfolio_optimization.ipynb | 50 ++++--- docs/source/tutorials/qubo_problem.ipynb | 130 +++++++++--------- 2 files changed, 97 insertions(+), 83 deletions(-) diff --git a/docs/source/tutorials/portfolio_optimization.ipynb b/docs/source/tutorials/portfolio_optimization.ipynb index 69d9628f..7ec25888 100644 --- a/docs/source/tutorials/portfolio_optimization.ipynb +++ b/docs/source/tutorials/portfolio_optimization.ipynb @@ -8,9 +8,11 @@ "source": [ "# Portfolio Optimization\n", "\n", + "In this tutorial, we demonstrate the transformation of financial portfolio optimization into a quadratic unconstrained binary optimization (QUBO) problem. Subsequently, we employ the Quantum Approximate Optimization Algorithm (QAOA) to solve it. We will conduct a comparative analysis between the outcomes obtained through QAOA and those derived from classical brute force searching. Additionally, we explore the potential for enhancing results by customizing the QAOA 'mixer' component.\n", + "\n", "## Introduction\n", "\n", - "Consider the following scenario: Xiaoming, an astute individual, possesses a sum of money represented by $B$ and is contemplating investing it in the stock market. The market comprises of $n$ shares, each having an identical price. Xiaoming's objective is to maximize returns while minimizing risk, taking into account the varying levels of risk tolerance among individuals. Xiaoming's personal risk tolerance is represented by $p$. In light of these considerations, the question arises: which shares should Xiaoming choose to construct an optimal portfolio?\n", + "Consider the following scenario: Xiaoming, an astute individual, possesses a sum of money represented by $B$ and is contemplating investing it in the stock market. The market contains $n$ shares, each having an identical price. Xiaoming's objective is to maximize returns while minimizing risk, taking into account the varying levels of risk tolerance among individuals. Xiaoming's personal risk tolerance is represented by $q$. In light of these considerations, the question arises: Which shares should Xiaoming choose to construct an optimal portfolio?\n", "\n", "Xiaoming's predicament falls under the purview of portfolio optimization problems. These problems are classified as Quadratic Unconstrained Binary Optimization (QUBO) problems, wherein binary numbers are utilized to represent decisions. In this case, \"1\" signifies selection, while \"0\" denotes the opposite. To address the challenge of portfolio optimization, the Quantum Approximate Optimization Algorithm (QAOA) is employed.\n", "\n", @@ -18,38 +20,50 @@ "\n", "In a simple boolean Markowitz portfolio optimization problem, we wish to solve \n", "\n", - "$$\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^T x$$\n", + "$$\n", + "\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^T x\n", + "$$\n", "\n", "subject to a constraint\n", "\n", - "$$ 1^T x = B$$\n", + "$$\n", + "1^T x = B\n", + "$$\n", "\n", "where \n", "* $n$: number of assets under consideration\n", "* $q > 0 $: risk-appetite\n", "* $\\Sigma \\in \\mathbb{R}^{n\\times n}$: covariance matrix of the assets\n", "* $\\mu\\in\\mathbb{R}^n$: mean return of the assets\n", - "* $B$: budget (i.e., total number of assets out of $n$ that can be selected)\n", + "* $B$: budget (i.e., the total number of assets out of $n$ that can be selected)\n", "\n", - "Our first step is to convert this constrained quadratic programming problem into a QUBO. We do this by adding a penalty factor $t$ and consider the alternative problem:\n", + "Our first step is to convert this constrained quadratic programming problem into a QUBO. We do this by adding a penalty factor $t$ and considering the alternative problem:\n", "\n", - "$$ \\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^Tx + t(1^Tx-B)^2$$\n", + "$$\n", + "\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\mu^Tx + t(1^Tx-B)^2\n", + "$$\n", "\n", - "The linear terms $\\mu^Tx = \\mu_1 x_1 + \\mu_2 x_2+\\ldots$ can all be transformed into squared forms, exploiting the properties of boolean variables where $0^2=0$ and $1^2=1$. The same trick is applied on the middle term of $t(1^Tx-B)^2$. Then the function is written as\n", + "The linear terms $\\mu^Tx = \\mu_1 x_1 + \\mu_2 x_2+\\ldots$ can all be transformed into squared forms, exploiting the properties of boolean variables where $0^2=0$ and $1^2=1$. The same trick is applied to the middle term of $t(1^Tx-B)^2$. Then the function is written as\n", "\n", - "$$\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\sum_{i=1}^n\\mu_i x_i^2 + t(1^Tx-B)^2$$\n", + "$$\n", + "\\min_{x\\in\\{0,1\\}^n}\\quad q x^T \\Sigma x - \\sum_{i=1}^n\\mu_i x_i^2 + t(1^Tx-B)^2\n", + "$$\n", "\n", "which is a QUBO problem\n", "\n", - "$$\\min_{x\\in\\{0,1\\}^n}\\quad x^T Q x + tB^2$$\n", + "$$\n", + "\\min_{x\\in\\{0,1\\}^n}\\quad x^T Q x + tB^2\n", + "$$\n", "\n", "where matrix $Q$ is\n", "\n", - "$$ Q = q\\Sigma -\\mu\\begin{pmatrix}1 & \\\\ & 1\\\\ & & \\ddots\\end{pmatrix} + t\\begin{pmatrix}1 -2B & 1 & \\ldots & 1 \\\\\n", + "$$\n", + "Q = q\\Sigma -\\mu\\begin{pmatrix}1 & \\\\ & 1\\\\ & & \\ddots\\end{pmatrix} + t\\begin{pmatrix}1 -2B & 1 & \\ldots & 1 \\\\\n", "1 & 1-2B & 1 & \\ldots \\\\1 & 1 & 1-2B \\\\\n", - "\\vdots\\end{pmatrix}$$\n", + "\\vdots\\end{pmatrix}\n", + "$$\n", "\n", - "and we ignore the constant term $t B^2$. We can now solve this by QAOA as above.\n", + "and we ignore the constant term $t B^2$. We can now solve this by QAOA.\n", "\n", "## Set up" ] @@ -120,7 +134,7 @@ "id": "0fb1d227", "metadata": {}, "source": [ - "In this analysis, we have carefully chosen six prominent stocks: Apple Inc. (AAPL), Microsoft Corporation (MSFT), NVIDIA Corporation (NVDA), Pfizer Inc. (PFE), Levi Strauss & Co. (LEVI), and Cisco Systems, Inc. (CSCO). We acquired their historical data spanning from 09/07/2022, to 09/07/2023 from Yahoo finance. Here are the return and covariance associated with this dataset" + "In this analysis, we have carefully chosen six prominent stocks: Apple Inc. (AAPL), Microsoft Corporation (MSFT), NVIDIA Corporation (NVDA), Pfizer Inc. (PFE), Levi Strauss & Co. (LEVI), and Cisco Systems, Inc. (CSCO). We acquired their historical data spanning from 09/07/2022 to 09/07/2023 from Yahoo Finance. Here are the return and covariance associated with this dataset" ] }, { @@ -153,7 +167,7 @@ "id": "f6dc53d4-7ed0-436d-aa1f-8674c56e756e", "metadata": {}, "source": [ - "Using this mean and covariance data, we can now define our portfolio optimization problem, convert it to a QUBO matrix, and then extract the pauli terms and weights" + "Using this mean and covariance data, we can now define our portfolio optimization problem, convert it to a QUBO matrix, and then extract the Pauli terms and weights, which is similar to what we do in the [QUBO tutorial](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qubo_problem.html)." ] }, { @@ -178,7 +192,7 @@ "source": [ "## Classical method\n", "\n", - "We firstly use brutal force to calculate the cost of each combination. It will give us a clue on the performance of QAOA." + "We first use brute force to calculate the cost of each combination, which is the expectation value $x^TQx$ for each $x\\in\\{0, 1\\}^n$ ($n$ is the number of stocks). It will give us a clue about the performance of QAOA." ] }, { @@ -260,7 +274,7 @@ "source": [ "### Use QAOA\n", "\n", - "Here, a standard QAOA ansatz with 12 layers is used. This circuit will be trained for 1000 times." + "Here, a standard QAOA ansatz with 12 layers is used. This circuit will be trained for 1000 iterations." ] }, { @@ -385,7 +399,7 @@ "id": "71c7a0e0", "metadata": {}, "source": [ - "The highest probability corresponds to the best combination, thereby ensuring consistency with the classical approach.\n", + "The highest probability corresponds to the best combination, which is consistent with what we found with classical brute force search.\n", "\n", "## Use XY mixer to improve the performance\n", "\n", @@ -457,7 +471,7 @@ "id": "917c9415", "metadata": {}, "source": [ - "Compared with standard X mixer, the XY mixer gives a higher probability to measure the best result." + "Compared with the standard X mixer, the XY mixer gives a higher probability of measuring the best result." ] } ], diff --git a/docs/source/tutorials/qubo_problem.ipynb b/docs/source/tutorials/qubo_problem.ipynb index 86441d71..a4779366 100644 --- a/docs/source/tutorials/qubo_problem.ipynb +++ b/docs/source/tutorials/qubo_problem.ipynb @@ -6,33 +6,37 @@ "id": "6ddb8a88-779a-43f7-ae14-115463bd87f5", "metadata": {}, "source": [ - "# Solving portfolio optimization as a QUBO problem with QAOA\n", + "# Solving QUBO Problem using QAOA\n", "\n", "## Overview\n", "\n", - "In this tutorial we will demonstrate how to solve quadratic unconstrained binary optimization (QUBO) problems using QAOA.\n", + "In this tutorial, we will demonstrate how to solve quadratic unconstrained binary optimization (QUBO) problems using QAOA. There is a specific application for portfolio optimization and we will introduce it in another [tutorial](https://tensorcircuit.readthedocs.io/en/latest/tutorials/portfolio_optimization.html).\n", "\n", "## QUBO problem\n", "\n", - "### what is QUBO?\n", + "### What is QUBO?\n", "\n", - "The quadratic unconstrained binary optimization (QUBO) is a type of problem that aims to optimize a quadratic objective function using binary variables. The primary goal of a QUBO problem is to determine the assignments of binary variables that minimize or maximize the quadratic objective function. These variables represent choices or decision variables that can be either selected (1) or not selected (0). The objective function captures the associated costs, benefits, or constraints related to these decisions.\n", + "Quadratic unconstrained binary optimization (QUBO) is a type of problem that aims to optimize a quadratic objective function using binary variables. The primary goal of a QUBO problem is to determine the assignments of binary variables that minimize or maximize the quadratic objective function. These variables represent choices or decision variables that can be either selected (1) or not selected (0). The objective function captures the associated costs, benefits, or constraints related to these decisions.\n", "\n", - "From a computational perspective, solving a QUBO problem is generally considered NP-hard. This classification implies that solving the optimal solution to a QUBO instance is believed to be computationally challenging, and there is no known polynomial-time algorithm that can efficiently solve all QUBO problems.\n", + "From a computational perspective, solving a QUBO problem is NP-hard. This classification implies that solving the optimal solution to a QUBO instance is believed to be computationally challenging, and no known polynomial-time algorithm that can efficiently solve all QUBO problems.\n", "\n", - "However, a promising approach called Quantum Approximate Optimization Algorithm (QAOA), introduced in this [this tutorial](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html), has the potential to offer significant advantages when applied to QUBO problem solving. QAOA leverages inherent quantum parallelism and interference effects to explore the solution space more efficiently compared to classical methods. This efficiency can lead to faster and more optimal solutions. In QAOA, each qubit represents a binary variable, and the objective function is calculated as the expected value of a quantum state generated by the ansatz. The parameters in the ansatz are iteratively optimized by a classical algorithm to improve the solution quality.\n", + "However, a promising approach called Quantum Approximate Optimization Algorithm (QAOA), introduced in [this tutorial](https://tensorcircuit.readthedocs.io/en/latest/tutorials/qaoa.html), has the potential to offer significant advantages when applied to QUBO problem-solving. QAOA leverages inherent quantum parallelism and interference effects to explore the solution space more efficiently compared to classical methods. This efficiency can lead to faster and more optimal solutions. In QAOA, each qubit represents a binary variable, and the objective function is calculated as the expected value of a quantum state generated by the ansatz (a quantum circuit with parameters to be decided). The parameters in the ansatz are iteratively optimized by a classical algorithm to improve the solution quality.\n", "\n", "### General Case\n", "\n", - "For the general QUBO case, we wish to minimize the cost function in the form of\n", + "For the general QUBO case, we wish to minimize a cost function of the form\n", "\n", - "$$ x^T Q x$$\n", + "$$ \n", + "x^T Q x\n", + "$$\n", "\n", "where $x\\in\\{0,1\\}^n$ and $Q\\in\\mathbb{R}^{n\\times n}$ is a real symmetric matrix.\n", "\n", "This function maps to an Ising Hamiltonian \n", "\n", - "$$\\frac{1}{2}\\left(\\sum_{i=1}^n C_{ii} + \\sum_{i" ] @@ -289,14 +309,14 @@ "source": [ "## Improve the performance with CVaR\n", "\n", - " Conditional Value-at-Risk (CVaR) is a risk measure that quantifies the potential loss beyond a certain threshold (alpha), considering the tail end of the distribution. In QAOA, incorporating CVaR as an objective function allows for addressing risk-averse optimization problems effectively. By optimizing for CVaR, the algorithm focuses on minimizing the expected value of the worst-case scenario, rather than solely optimizing for the mean or expected value, which usually lead to a faster convergence to a more accurate result.\n", + "Conditional Value-at-Risk (CVaR) is a risk measure that quantifies the potential loss beyond a certain threshold (alpha), considering the tail end of the distribution. As proposed by [Barkoutsos et al. (2020)](https://arxiv.org/abs/1907.04769), incorporating CVaR as an objective function in QAOA allows for addressing risk-averse optimization problems effectively. By optimizing for CVaR, the algorithm focuses on minimizing the expected value of the worst-case scenario, rather than solely optimizing for the mean or expected value, which usually leads to faster convergence to a more accurate result.\n", "\n", - " In order to showcase the performance of CVaR, a more complicated QUBO problem is used. This QUBO problem is described as a randomly generated symmetric Q matrix. The Q matrix is:" + "To showcase the performance of CVaR, a more complicated QUBO problem is used. This QUBO problem is described as a randomly generated symmetric Q matrix. The Q matrix is:" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 86, "id": "02ec55b6", "metadata": {}, "outputs": [], @@ -319,12 +339,12 @@ "id": "76879a55", "metadata": {}, "source": [ - "Then let's define a function to brutally calculate the costs (classical methods). The results are printed below." + "Then let's define a function to classically brute-force calculate all feasible combinations of stocks and their associated cost. The results are printed below." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 87, "id": "46e9cbd9", "metadata": {}, "outputs": [ @@ -391,12 +411,12 @@ "id": "04d4ea38", "metadata": {}, "source": [ - "The QAOA with CVaR and different alpha will be run and a callback function will be used to record the parameters during the solving procedure." + "The QAOA with CVaR and three different alpha (1, 0.25, 0.1) will be run and a callback function will be used to record the parameters during the solving procedure. When alpha is $1$, the complete measurement results are accepted and the model changes to the standard QAOA." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 88, "id": "d3b386d6", "metadata": {}, "outputs": [], @@ -440,7 +460,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 89, "id": "b3da7c48", "metadata": {}, "outputs": [], @@ -471,23 +491,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 92, "id": "d1f375ce", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "Text(0, 0.5, 'loss')" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -499,9 +509,9 @@ "source": [ "for loss in loss_list:\n", " plt.plot(loss)\n", - "plt.legend([0.1, 0.25, 1])\n", + "plt.legend([\"alpha = 0.1\", \"alpha = 0.25\", \"alpha = 1\"])\n", "plt.xlabel(\"iterations\")\n", - "plt.ylabel(\"loss\")" + "p = plt.ylabel(\"cost\")" ] }, { @@ -514,23 +524,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 93, "id": "f81fdeae", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "Text(0, 0.5, 'probability of the best answer')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -542,9 +542,9 @@ "source": [ "for prob in prob_list:\n", " plt.plot(prob)\n", - "plt.legend([0.1, 0.25, 1])\n", + "plt.legend([\"alpha = 0.1\", \"alpha = 0.25\", \"alpha = 1\"])\n", "plt.xlabel(\"iterations\")\n", - "plt.ylabel(\"probability of the best answer\")" + "p = plt.ylabel(\"probability of the best answer\")" ] }, { From 6a12efbc42ba4718846564f92846e10f1f3f57f4 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Thu, 14 Sep 2023 13:00:37 +0100 Subject: [PATCH 651/725] truelly jittable cvar --- tensorcircuit/applications/optimization.py | 110 +++++++++++++-------- 1 file changed, 68 insertions(+), 42 deletions(-) diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index e2609e1f..642ef127 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -162,35 +162,35 @@ def QUBO_QAOA( def cvar_value(r: List[float], p: List[float], percent: float) -> Any: """ - Calculate the Conditional Value at Risk (CVaR) according to the measurement results. + Compute the Conditional Value at Risk (CVaR) based on the measurement results. - :param r: The results showing after measurements. - :param p: Probabilities corresponding to each result. - :param percent: The cut-off percentage of CVaR. + :param r: The observed outcomes after measurements. + :param p: Probabilities associated with each observed outcome. + :param percent: The cut-off percentage for CVaR computation. :return: The calculated CVaR value. """ sorted_indices = tf.argsort(r) - p = tf.cast(tf.gather(p, sorted_indices), dtype=tf.float32) - r = tf.cast(tf.gather(r, sorted_indices), dtype=tf.float32) - - sump = tf.constant(0.0, dtype=tf.float32) # The sum of probabilities. - count = tf.constant(0, dtype=tf.int32) - cvar_result = tf.constant(0.0, dtype=tf.float32) - - # Iterate over the sorted results and calculate CVaR. - while sump < percent: - if tf.math.round(sump + p[count], 6) >= percent: - # Add the remaining portion of the last result that exceeds the cut-off percentage. - cvar_result += r[count] * (percent - sump) - count += 1 - break - else: - # Add the entire result to the CVaR calculation. - sump += p[count] - cvar_result += r[count] * p[count] - count += 1 + p_sorted = tf.cast(tf.gather(p, sorted_indices), dtype=tf.float32) + r_sorted = tf.cast(tf.gather(r, sorted_indices), dtype=tf.float32) + + # Calculate the cumulative sum of sorted probabilities. + cumsum_p = tf.math.cumsum(p_sorted) + + # Create a tensor that evaluates to 1 if the condition is met, otherwise 0. + mask = tf.cast(tf.math.less(cumsum_p, percent), dtype=tf.float32) + + # Use mask to filter and sum the required elements for CVaR. + cvar_numerator = tf.reduce_sum(mask * p_sorted * r_sorted) + + # Compute the last remaining portion that exceeds the cut-off percentage. + last_portion_index = tf.math.argmax(tf.math.greater_equal(cumsum_p, percent)) + last_portion = (percent - cumsum_p[last_portion_index - 1]) * r_sorted[ + last_portion_index + ] + + # Calculate the final CVaR. + cvar_result = (cvar_numerator + last_portion) / percent - cvar_result /= percent return cvar_result @@ -205,25 +205,51 @@ def cvar_from_circuit(circuit: Circuit, nsamples: int, Q: Tensor, alpha: float) :param alpha: The cut-off percentage for CVaR. :return: The calculated CVaR value. """ - # Get measurement results and normalize them. + # Obtain and normalize measurement results + measurement_data = circuit.state() results = measurement_results( - circuit.state(), counts=nsamples, format="count_dict_bin" + measurement_data, counts=nsamples, format="sample_int", jittable=True ) - results = {k: v / nsamples for k, v in results.items()} + n_counts = tf.shape(results)[0] - values = [] # List to store the measurement values. - probabilities = [] # List to store the corresponding probabilities. - Q_tf = tf.convert_to_tensor(Q, dtype=tf.float32) + # Initialize TensorArrays to hold probabilities and values + probabilities = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0) + values = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0) - for k, v in results.items(): - binary_strings = tf.strings.bytes_split(k) - x = tf.reshape( - tf.strings.to_number(binary_strings, out_type=tf.float32), (-1, 1) + # Determine the number of qubits in the circuit and generate all possible states + n_qubits = len(Q) + all_states = tf.constant([format(i, f"0{n_qubits}b") for i in range(2**n_qubits)]) + + # Convert the Q matrix to a TensorFlow tensor + Q_tensor = tf.convert_to_tensor(Q, dtype=tf.float32) + + # Loop through all possible states to calculate the value and probability of each + for state_index in tf.range(tf.shape(all_states)[0]): + state_str = all_states[state_index] + binary_values = tf.strings.bytes_split(state_str) + state_vector = tf.reshape( + tf.strings.to_number(binary_values, out_type=tf.float32), (-1, 1) + ) + + # Compute the value for this binary state + value = tf.squeeze( + tf.matmul(tf.transpose(state_vector), tf.matmul(Q_tensor, state_vector)) ) - xT = tf.transpose(x) - values.append(tf.squeeze(tf.matmul(xT, tf.matmul(Q_tf, x)))) - probabilities.append(v) + values = values.write(state_index, value) + + # Compute the probability of this state occurring + prob_of_state = ( + tf.reduce_sum(tf.cast(tf.equal(results, state_index), tf.int32)) / n_counts + ) + probabilities = probabilities.write( + state_index, tf.cast(prob_of_state, dtype=tf.float32) + ) + + # Stack TensorArrays to Tensors + probabilities = probabilities.stack() + values = values.stack() + # Calculate CVaR cvar_result = cvar_value(values, probabilities, alpha) return cvar_result @@ -250,19 +276,20 @@ def cvar_from_expectation(circuit: Circuit, Q: Tensor, alpha: float) -> Any: # Convert the Q-matrix to a TensorFlow tensor. Q_tf = tf.convert_to_tensor(Q, dtype=tf.float32) - values = [] + values = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0) # Calculate the cost for each binary state. - for state in states: + for idx in tf.range(tf.shape(states)[0]): + state = states[idx] binary_strings = tf.strings.bytes_split(state) x = tf.reshape( tf.strings.to_number(binary_strings, out_type=tf.float32), (-1, 1) ) xT = tf.transpose(x) # the transpose value = tf.squeeze(tf.matmul(xT, tf.matmul(Q_tf, x))) - values.append(value) + values = values.write(idx, value) - values = tf.convert_to_tensor(values, dtype=tf.float32) + values = values.stack() # Calculate the CVaR value using the computed values and the probability distribution. cvar_result = cvar_value(values, prob, alpha) @@ -330,7 +357,6 @@ def QUBO_QAOA_cvar( :param maxiter: The maximum number of iterations for the optimization. Default is 1000. :return: The optimized parameters for the ansatz circuit. """ - tf.config.run_functions_eagerly(True) loss = partial(cvar_loss, nlayers, Q, nsamples, alpha, expectation_based) f_scipy = scipy_interface(loss, shape=(2 * nlayers,), jit=True, gradient=False) From 31d47adfcd618e9d8d0b9c3c3d050e74ec40a952 Mon Sep 17 00:00:00 2001 From: Felix Xu <61252303+FelixXu35@users.noreply.github.com> Date: Mon, 18 Sep 2023 13:53:17 +0100 Subject: [PATCH 652/725] optimized cvar --- tensorcircuit/applications/optimization.py | 71 ++++++++-------------- 1 file changed, 25 insertions(+), 46 deletions(-) diff --git a/tensorcircuit/applications/optimization.py b/tensorcircuit/applications/optimization.py index 642ef127..28c5c81a 100644 --- a/tensorcircuit/applications/optimization.py +++ b/tensorcircuit/applications/optimization.py @@ -212,42 +212,28 @@ def cvar_from_circuit(circuit: Circuit, nsamples: int, Q: Tensor, alpha: float) ) n_counts = tf.shape(results)[0] - # Initialize TensorArrays to hold probabilities and values - probabilities = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0) - values = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0) - # Determine the number of qubits in the circuit and generate all possible states n_qubits = len(Q) all_states = tf.constant([format(i, f"0{n_qubits}b") for i in range(2**n_qubits)]) + all_binary = tf.reshape( + tf.strings.to_number(tf.strings.bytes_split(all_states), tf.float32), + (2**n_qubits, n_qubits), + ) + all_decimal = tf.range(2**n_qubits, dtype=tf.int32) # Convert the Q matrix to a TensorFlow tensor Q_tensor = tf.convert_to_tensor(Q, dtype=tf.float32) - # Loop through all possible states to calculate the value and probability of each - for state_index in tf.range(tf.shape(all_states)[0]): - state_str = all_states[state_index] - binary_values = tf.strings.bytes_split(state_str) - state_vector = tf.reshape( - tf.strings.to_number(binary_values, out_type=tf.float32), (-1, 1) - ) - - # Compute the value for this binary state - value = tf.squeeze( - tf.matmul(tf.transpose(state_vector), tf.matmul(Q_tensor, state_vector)) - ) - values = values.write(state_index, value) - - # Compute the probability of this state occurring - prob_of_state = ( - tf.reduce_sum(tf.cast(tf.equal(results, state_index), tf.int32)) / n_counts - ) - probabilities = probabilities.write( - state_index, tf.cast(prob_of_state, dtype=tf.float32) - ) + # calculate cost values + values = tf.reduce_sum(all_binary * tf.matmul(all_binary, Q_tensor), axis=1) - # Stack TensorArrays to Tensors - probabilities = probabilities.stack() - values = values.stack() + # Count the occurrences of each state and calculate probabilities + state_counts = tf.reduce_sum( + tf.cast(tf.equal(tf.reshape(results, [-1, 1]), all_decimal), tf.int32), axis=0 + ) + probabilities = tf.cast(state_counts, dtype=tf.float32) / tf.cast( + n_counts, dtype=tf.float32 + ) # Calculate CVaR cvar_result = cvar_value(values, probabilities, alpha) @@ -269,27 +255,21 @@ def cvar_from_expectation(circuit: Circuit, Q: Tensor, alpha: float) -> Any: prob = tf.convert_to_tensor(circuit.probability(), dtype=tf.float32) # Generate all possible binary states for the given Q-matrix. - states = tf.constant( - [format(i, "0" + str(len(Q)) + "b") for i in range(2 ** len(Q))] + n_qubits = len(Q) + all_states = tf.constant( + [format(i, "0" + str(n_qubits) + "b") for i in range(2 ** len(Q))] + ) + all_binary = tf.reshape( + tf.strings.to_number(tf.strings.bytes_split(all_states), tf.float32), + (2**n_qubits, n_qubits), ) # Convert the Q-matrix to a TensorFlow tensor. - Q_tf = tf.convert_to_tensor(Q, dtype=tf.float32) - - values = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0) - - # Calculate the cost for each binary state. - for idx in tf.range(tf.shape(states)[0]): - state = states[idx] - binary_strings = tf.strings.bytes_split(state) - x = tf.reshape( - tf.strings.to_number(binary_strings, out_type=tf.float32), (-1, 1) - ) - xT = tf.transpose(x) # the transpose - value = tf.squeeze(tf.matmul(xT, tf.matmul(Q_tf, x))) - values = values.write(idx, value) + Q_tensor = tf.convert_to_tensor(Q, dtype=tf.float32) - values = values.stack() + # calculate cost values + elementwise_product = tf.multiply(all_binary, tf.matmul(all_binary, Q_tensor)) + values = tf.reduce_sum(elementwise_product, axis=1) # Calculate the CVaR value using the computed values and the probability distribution. cvar_result = cvar_value(values, prob, alpha) @@ -377,7 +357,6 @@ def QUBO_QAOA_cvar( method="COBYLA", callback=callback, options={"maxiter": maxiter}, - # bounds=[(0, (2 - np.mod(i, 2))*np.pi) for i in range(2*nlayers)] ) # Perform the optimization using the COBYLA method from scipy.optimize. From df94bea2629cd3ee5da8fa551ae9203ffc7552cd Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 25 Sep 2023 16:01:40 +0800 Subject: [PATCH 653/725] update readme refs --- README.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 677beaa0..57b908d4 100644 --- a/README.md +++ b/README.md @@ -321,7 +321,7 @@ Reference paper: https://arxiv.org/abs/2010.08561 (published in QST). For the application of Variational Quantum-Neural Hybrid Eigensolver, see [applications](/tensorcircuit/applications). -Reference paper: https://arxiv.org/abs/2106.05105 (published in PRL) and https://arxiv.org/abs/2112.10380. +Reference paper: https://arxiv.org/abs/2106.05105 (published in PRL) and https://arxiv.org/abs/2112.10380 (published in AQT). ### VQEX-MBL @@ -339,7 +339,7 @@ Reference paper: https://arxiv.org/abs/2208.02866 (published in PRL). For the numerical simulation of variational quantum algorithm training using random gate activation strategy by us, see the [project repo](https://github.com/ls-iastu/RAtraining). -Reference paper: https://arxiv.org/abs/2303.08154. +Reference paper: https://arxiv.org/abs/2303.08154 (published in PRR as a Letter). ### TenCirChem @@ -386,6 +386,8 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Zero and Finite Temperature Quantum Simulations Powered by Quantum Magic: https://arxiv.org/abs/2308.11616. +- Comparison of Quantum Simulators for Variational Quantum Search: A Benchmark Study: https://arxiv.org/abs/2309.05924. + If you want to highlight your research work here, feel free to add by opening PR. From 47fff438de1fd68a4c1e5f1f7593d85acae9f4f9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Sat, 7 Oct 2023 16:04:26 +0800 Subject: [PATCH 654/725] add overlap in fgs --- tensorcircuit/fgs.py | 25 ++++++++++++++----------- tests/test_fgs.py | 19 +++++++++++++++++++ 2 files changed, 33 insertions(+), 11 deletions(-) diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index b853d02e..6db2025d 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -466,17 +466,20 @@ def cond_measure(self, ind: int, status: float, with_prob: bool = False) -> Tens # cmatrix = backend.adjoint(self.wtransform) @ cm @ self.wtransform * 0.25 # return type(self)(self.L, cmatrix=cmatrix) - # def overlap(self, other): - # # ? - # u, v = self.get_bogoliubov_uv() - # u1, v1 = other.get_bogoliubov_uv() - # return backend.det( - # backend.adjoint(u1) @ u + backend.adjoint(v1) @ v - # ) * backend.det(backend.adjoint(v1) @ v), backend.det( - # backend.adjoint(u1) @ u + backend.adjoint(v1) @ v - # ) * backend.det( - # backend.adjoint(u1) @ u - # ) + def overlap(self, other: "FGSSimulator") -> Tensor: + """ + overlap upto a U(1) phase + + :param other: _description_ + :type other: FGSSimulator + :return: _description_ + :rtype: _type_ + """ + u, v = self.get_bogoliubov_uv() + u1, v1 = other.get_bogoliubov_uv() + return backend.sqrt( + backend.abs(backend.det(backend.adjoint(u1) @ u + backend.adjoint(v1) @ v)) + ) npb = get_backend("numpy") diff --git a/tests/test_fgs.py b/tests/test_fgs.py index 526c94ff..6ec87653 100644 --- a/tests/test_fgs.py +++ b/tests/test_fgs.py @@ -208,3 +208,22 @@ def test_exp_4body(backend): np.testing.assert_allclose( c.expectation_4body(1, 0, 6, 7), c.expectation_4body(1, 0, 6, 7), atol=1e-5 ) + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_overlap(backend): + def compute_overlap(FGScls): + c = FGScls(3, filled=[0, 2]) + c.evol_hp(0, 1, 1.2) + c.evol_hp(1, 2, 0.3) + c.evol_cp(0, 0.5) + c.evol_sp(0, 2, 0.3) + c1 = FGScls(3, filled=[0, 2]) + c1.evol_hp(0, 1, 0.2) + c1.evol_hp(1, 2, 0.6) + c1.evol_sp(1, 0, -1.1) + return tc.backend.abs(c.overlap(c1)) + + np.testing.assert_allclose( + compute_overlap(tc.FGSSimulator), compute_overlap(tc.fgs.FGSTestSimulator), 1e-5 + ) From 3641db966e787950febd6fdcadb3c77bd4c41b11 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 11 Oct 2023 11:18:16 +0800 Subject: [PATCH 655/725] update readme by more projects --- README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 57b908d4..b76ef176 100644 --- a/README.md +++ b/README.md @@ -388,6 +388,10 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Comparison of Quantum Simulators for Variational Quantum Search: A Benchmark Study: https://arxiv.org/abs/2309.05924. +- Generative quantum machine learning via denoising diffusion probabilistic models: https://arxiv.org/abs/2310.05866. + +- Google Summer of Code 2023 Projects (QML4HEP): https://github.com/ML4SCI/QMLHEP, https://github.com/Gopal-Dahale/qgnn-hep, https://github.com/salcc/QuantumTransformers. + -If you want to highlight your research work here, feel free to add by opening PR. +If you want to highlight your research work or projects here, feel free to add by opening PR. From 126cfe73fc39795afbccf9b948607c78ccb2ef70 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 11 Oct 2023 11:21:08 +0800 Subject: [PATCH 656/725] add iteopt ref --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index b76ef176..cb6313c8 100644 --- a/README.md +++ b/README.md @@ -390,6 +390,8 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Generative quantum machine learning via denoising diffusion probabilistic models: https://arxiv.org/abs/2310.05866. +- Quantum imaginary time evolution and quantum annealing meet topological sector optimization: https://arxiv.org/abs/2310.04291. + - Google Summer of Code 2023 Projects (QML4HEP): https://github.com/ML4SCI/QMLHEP, https://github.com/Gopal-Dahale/qgnn-hep, https://github.com/salcc/QuantumTransformers. From eab1f598b30b2ee8c122b20e84ce70ba91a1a4e5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 11 Oct 2023 15:38:29 +0800 Subject: [PATCH 657/725] add reduced_wavefunction --- CHANGELOG.md | 2 ++ tensorcircuit/quantum.py | 39 +++++++++++++++++++++++++++++++++++++++ tests/test_quantum.py | 25 +++++++++++++++++++++++++ 3 files changed, 66 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index a4d2c684..218e93e2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,8 @@ - Add `partial_transpose` and `entanglement_negativity` method in `quantum.py` +- Add `reduced_wavefunction` method in `quantum.py` to get reduced pure state + ### Changed - move ensemble module to applications/ai (breaking changes) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 1a4a84d8..147deffb 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1588,6 +1588,45 @@ def entanglement_entropy(state: Tensor, cut: Union[int, List[int]]) -> Tensor: return entropy(rho) +def reduced_wavefunction( + state: Tensor, cut: List[int], measure: Optional[List[int]] = None +) -> Tensor: + """ + Compute the reduced wavefunction from the quantum state ``state``. + The fixed measure result is guaranteed by users, + otherwise final normalization may required in the return + + :param state: _description_ + :type state: Tensor + :param cut: the list of position for qubit to be reduced + :type cut: List[int] + :param measure: the fixed results of given qubits in the same shape list as ``cut`` + :type measure: List[int] + :return: _description_ + :rtype: Tensor + """ + if measure is None: + measure = [0 for _ in cut] + s = backend.reshape2(state) + n = len(backend.shape_tuple(s)) + s_node = Gate(s) + end_nodes = [] + for c, m in zip(cut, measure): + rt = backend.cast(backend.convert_to_tensor(1 - m), dtypestr) * backend.cast( + backend.convert_to_tensor(np.array([1.0, 0.0])), dtypestr + ) + backend.cast(backend.convert_to_tensor(m), dtypestr) * backend.cast( + backend.convert_to_tensor(np.array([0.0, 1.0])), dtypestr + ) + end_node = Gate(rt) + end_nodes.append(end_node) + s_node[c] ^ end_node[0] + new_node = contractor( + [s_node] + end_nodes, + output_edge_order=[s_node[i] for i in range(n) if i not in cut], + ) + return backend.reshape(new_node.tensor, [-1]) + + def reduced_density_matrix( state: Union[Tensor, QuOperator], cut: Union[int, List[int]], diff --git a/tests/test_quantum.py b/tests/test_quantum.py index 13d06354..2009fbe6 100644 --- a/tests/test_quantum.py +++ b/tests/test_quantum.py @@ -498,3 +498,28 @@ def test_ps2xyz(): xyz.update({"y": []}) assert tc.quantum.ps2xyz([0, 1, 3]) == xyz assert tc.quantum.ps2xyz([0, 1, 3, 0]) == xyz + + +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_reduced_wavefunction(backend): + c = tc.Circuit(3) + c.h(0) + c.cnot(0, 1) + r = c.cond_measure(0) + s = c.state() + s1 = tc.quantum.reduced_wavefunction(s, [0, 2], [r, 0]) + if tc.backend.cast(r, tc.rdtypestr) < 0.5: + np.testing.assert_allclose(s1, np.array([1, 0]), atol=1e-5) + else: + np.testing.assert_allclose(s1, np.array([0, 1]), atol=1e-5) + + c = tc.Circuit(3) + c.h(0) + c.cnot(0, 1) + s = c.state() + s1 = tc.quantum.reduced_wavefunction(s, [2], [0]) + + c1 = tc.Circuit(2) + c1.h(0) + c1.cnot(0, 1) + np.testing.assert_allclose(s1, c1.state(), atol=1e-5) From 56f1590415f2e3ff50e3ab262febeb8ca49f5dd5 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 17 Oct 2023 15:52:15 +0800 Subject: [PATCH 658/725] update readme --- README.md | 2 +- README_cn.md | 2 +- docs/source/index.rst | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index cb6313c8..dfd7e68a 100644 --- a/README.md +++ b/README.md @@ -233,7 +233,7 @@ We also have [Docker support](/docker). ### Status -This project is released by [Tencent Quantum Lab](https://quantum.tencent.com/) and is created and maintained by [Shi-Xin Zhang](https://github.com/refraction-ray) with current core authors [Shi-Xin Zhang](https://github.com/refraction-ray) and [Yu-Qin Chen](https://github.com/yutuer21). We also thank [contributions](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors) from the lab and the open source community. +This project is created and maintained by [Shi-Xin Zhang](https://github.com/refraction-ray) with current core authors [Shi-Xin Zhang](https://github.com/refraction-ray) and [Yu-Qin Chen](https://github.com/yutuer21). We also thank [contributions](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors) from the open source community. ### Citation diff --git a/README_cn.md b/README_cn.md index 56ac6c5c..8137eb85 100644 --- a/README_cn.md +++ b/README_cn.md @@ -123,7 +123,7 @@ pip install tensorcircuit-nightly ### 现况 -该项目由[腾讯量子实验室](https://quantum.tencent.com/)发布，由 [Shi-Xin Zhang](https://github.com/refraction-ray) 创造并维护。当前核心作者包括 [Shi-Xin Zhang](https://github.com/refraction-ray) 和 [Yu-Qin Chen](https://github.com/yutuer21)。我们也感谢来自实验室和开源社区的[贡献](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors)。 +该项目由 [Shi-Xin Zhang](https://github.com/refraction-ray) 创造并维护。当前核心作者包括 [Shi-Xin Zhang](https://github.com/refraction-ray) 和 [Yu-Qin Chen](https://github.com/yutuer21)。我们也感谢来自开源社区的[贡献](https://github.com/tencent-quantum-lab/tensorcircuit/graphs/contributors)。 ### 引用 diff --git a/docs/source/index.rst b/docs/source/index.rst index 9d27204d..bd055a60 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -35,7 +35,7 @@ Relevant Links TensorCircuit is created and maintained by `Shi-Xin Zhang `_ and this version is released by `Tencent Quantum Lab `_. The current core authors of TensorCircuit are `Shi-Xin Zhang `_ and `Yu-Qin Chen `_. -We also thank `contributions `_ from the lab and the open source community. +We also thank `contributions `_ from the open source community. If you have any further questions or collaboration ideas, please use the issue tracker or forum below, or send email to shixinzhang#tencent.com. From 56b44c590f79f02b95b3a1acb9fde4caaefc7278 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 18 Oct 2023 10:19:32 +0800 Subject: [PATCH 659/725] add ref in readme --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index dfd7e68a..834e3847 100644 --- a/README.md +++ b/README.md @@ -388,6 +388,8 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Comparison of Quantum Simulators for Variational Quantum Search: A Benchmark Study: https://arxiv.org/abs/2309.05924. +- Statistical analysis of quantum state learning process in quantum neural networks: https://arxiv.org/abs/2309.14980 (Pubilshed in NeurIPS). + - Generative quantum machine learning via denoising diffusion probabilistic models: https://arxiv.org/abs/2310.05866. - Quantum imaginary time evolution and quantum annealing meet topological sector optimization: https://arxiv.org/abs/2310.04291. From 9959e8c24fc707eaa4266083e8f10c56ac00dacc Mon Sep 17 00:00:00 2001 From: ztzhu1 Date: Tue, 31 Oct 2023 15:05:53 +0800 Subject: [PATCH 660/725] fix(qir2cirq): add a paramter 'args' for _circuit_diagram_info_ to make 'CustomizedCirqGate' work --- tensorcircuit/translation.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index f300fc8a..5e8ddea2 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -138,7 +138,9 @@ def _num_qubits_(self) -> int: def _unitary_(self) -> Any: return self.uMatrix - def _circuit_diagram_info_(self) -> List[str]: + def _circuit_diagram_info_( + self, args: Optional[cirq.CircuitDiagramInfoArgs] + ) -> List[str]: return [self.name] * self.nqubit if extra_qir is not None and len(extra_qir) > 0: From da04635846b941d6af638e556dd23f6257565853 Mon Sep 17 00:00:00 2001 From: ztzhu1 Date: Tue, 31 Oct 2023 17:08:40 +0800 Subject: [PATCH 661/725] fix(qir2cirq): make 'args' variable positional arguments (*args) for compatibility --- tensorcircuit/translation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 5e8ddea2..78136967 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -139,7 +139,7 @@ def _unitary_(self) -> Any: return self.uMatrix def _circuit_diagram_info_( - self, args: Optional[cirq.CircuitDiagramInfoArgs] + self, *args: Optional[cirq.CircuitDiagramInfoArgs] ) -> List[str]: return [self.name] * self.nqubit From 12b89723a563a9a760aedea47e450bacf6eb7f4f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 1 Nov 2023 10:37:15 +0800 Subject: [PATCH 662/725] fix doc typo --- tensorcircuit/backends/abstract_backend.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index 472f0081..cf6884bc 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -25,7 +25,7 @@ def copy(self: Any, a: Tensor) -> Tensor: :param a: tensor in matrix form :type a: Tensor - :return: matrix exponential of matrix ``a`` + :return: the copy tensor of ``a`` :rtype: Tensor """ raise NotImplementedError( From da19b1cf9c38e2121ad27c28280ad070874b16a3 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Wed, 1 Nov 2023 02:40:18 +0000 Subject: [PATCH 663/725] docs: update README.md [skip ci] --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 834e3847..df9fc06c 100644 --- a/README.md +++ b/README.md @@ -294,6 +294,9 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. peilin
peilin
✅ 💻 ⚠️ 📖 Cristian Emiliano Godinez Ramirez
Cristian Emiliano Godinez Ramirez
💻 ⚠️ + + ztzhu
ztzhu
💻 + From 91433be7c2c38b3f492443bb9159042616d3bbba Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Wed, 1 Nov 2023 02:40:19 +0000 Subject: [PATCH 664/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index b76d6a80..74aab495 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -282,6 +282,15 @@ "code", "test" ] + }, + { + "login": "ztzhu1", + "name": "ztzhu", + "avatar_url": "https://avatars.githubusercontent.com/u/111620128?v=4", + "profile": "https://github.com/ztzhu1", + "contributions": [ + "code" + ] } ], "contributorsPerLine": 6, From 9a32bab3697148eb294fd78fc1a038c02da76def Mon Sep 17 00:00:00 2001 From: Yuxuan Yan Date: Thu, 2 Nov 2023 14:08:13 +0800 Subject: [PATCH 665/725] add SHVQE script --- examples/shvqe.py | 237 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 237 insertions(+) create mode 100644 examples/shvqe.py diff --git a/examples/shvqe.py b/examples/shvqe.py new file mode 100644 index 00000000..fdf9d50a --- /dev/null +++ b/examples/shvqe.py @@ -0,0 +1,237 @@ +""" +Schrodinger-Heisenberg quantum variational eigensolver (SHVQE) with DQAS-style optimization. + +DQAS part is modified from: examples/clifford_optimization.py +""" + +import sys +sys.path.insert(0, "../") + +import numpy as np +import tensorflow as tf + +import tensorcircuit as tc +from tensorcircuit.applications.vqes import construct_matrix_v3 + +ctype, rtype = tc.set_dtype("complex64") +K = tc.set_backend("tensorflow") + +n = 10 # the number of qubits (must be even for consistency later) +ncz = 2 # number of cz layers in Schrodinger circuit +nlayersq = ncz + 1 # Schrodinger parameter layers + +# training setup +epochs = 1000 +batch = 1000 + +# Hamiltonian +h6h = np.load("./h6_hamiltonian.npy") # reported in 0.99 A +hamiltonian = construct_matrix_v3(h6h.tolist()) + +def hybrid_ansatz(structure, paramq, preprocess="direct", train=True): + """_summary_ + + Parameters + ---------- + structure : K.Tensor, (n//2, 2) + parameters to decide graph structure of Clifford circuits + paramq : K.Tensor, (nlayersq, n, 3) + parameters in quantum variational circuits, the last layer for Heisenberg circuits + preprocess : str, optional + preprocess, by default "direct" + + Returns + ------- + K.Tensor, [1,] + loss value + """ + c = tc.Circuit(n) + if preprocess == "softmax": + structure = K.softmax(structure, axis=-1) + elif preprocess == "most": + structure = K.onehot(K.argmax(structure, axis=-1), num=2) + elif preprocess == "direct": + pass + + structure = K.cast(structure, ctype) + structure = tf.reshape(structure, shape=[n//2, 2]) + + # quantum variational in Schrodinger part, first consider a ring topol + for j in range(nlayersq): + if j !=0 and j!=nlayersq-1: + for i in range(j%2,n,2): + c.cz(i, (i+1)%n) + for i in range(n): + c.rx(i, theta=paramq[j, i, 0]) + c.ry(i, theta=paramq[j, i, 1]) + c.rz(i, theta=paramq[j, i, 2]) + + # Clifford part, which is actually virtual + if train: + for j in range(0,n//2-1): + dis = j + 1 + for i in range(0,n): + c.unitary( + i, + (i+dis) % n, + unitary=structure[j, 0] * tc.gates.ii().tensor + + structure[j, 1] * tc.gates.cz().tensor, + ) + + for i in range(0,n//2): + c.unitary( + i, + i + n//2, + unitary=structure[n//2-1, 0] * tc.gates.ii().tensor + + structure[n//2-1, 1] * tc.gates.cz().tensor, + ) + else: # if not for training, we just put nontrivial gates + for j in range(0,n//2-1): + dis = j + 1 + for i in range(0,n): + if structure[j, 1]==1: + c.cz(i, (i+dis) % n) + + for i in range(0,n//2): + if structure[j, 1]==1: + c.cz(i, i + n//2) + + return c + +def hybrid_vqe(structure, paramq, preprocess="direct"): + """_summary_ + + Parameters + ---------- + structure : K.Tensor, (n//2, 2) + parameters to decide graph structure of Clifford circuits + paramq : K.Tensor, (nlayersq, n, 3) + parameters in quantum variational circuits, the last layer for Heisenberg circuits + preprocess : str, optional + preprocess, by default "direct" + + Returns + ------- + K.Tensor, [1,] + loss value + """ + c = hybrid_ansatz(structure, paramq, preprocess) + return tc.templates.measurements.operator_expectation(c, hamiltonian) + +def sampling_from_structure(structures, batch=1): + ch = structures.shape[-1] + prob = K.softmax(K.real(structures), axis=-1) + prob = K.reshape(prob, [-1, ch]) + p = prob.shape[0] + r = np.stack( + np.array( + [np.random.choice(ch, p=K.numpy(prob[i]), size=[batch]) for i in range(p)] + ) + ) + return r.transpose() + + +@K.jit +def best_from_structure(structures): + return K.argmax(structures, axis=-1) + + +def nmf_gradient(structures, oh): + """ compute the Monte Carlo gradient with respect of naive mean-field probabilistic model + + Parameters + ---------- + structures : K.Tensor, (n//2, ch) + structure parameter for single- or two-qubit gates + oh : K.Tensor, (n//2, ch), onehot + a given structure sampled via strcuture parameters (in main function) + + Returns + ------- + K.Tensor, (n//2 * 2, ch) == (n, ch) + MC gradients + """ + choice = K.argmax(oh, axis=-1) + prob = K.softmax(K.real(structures), axis=-1) + indices = K.transpose( + K.stack([K.cast(tf.range(structures.shape[0]), "int64"), choice]) + ) + prob = tf.gather_nd(prob, indices) + prob = K.reshape(prob, [-1, 1]) + prob = K.tile(prob, [1, structures.shape[-1]]) + + return K.real( + tf.tensor_scatter_nd_add( + tf.cast(-prob, dtype=ctype), + indices, + tf.ones([structures.shape[0]], dtype=ctype), + ) + ) # in oh : 1-p, not in oh : -p + +# vmap for a batch of structures +nmf_gradient_vmap = K.jit( + K.vmap(nmf_gradient, vectorized_argnums=1)) + +# vvag for a batch of structures +vvag_hybrid = K.jit( + K.vectorized_value_and_grad(hybrid_vqe, vectorized_argnums=(0,), argnums=(1,)), + static_argnums=(2,)) + +def train_hybrid(stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, verbose=False): + # params = K.implicit_randn([n//2, 2], stddev=stddev) + params = K.ones([n//2, 2], dtype=float) + paramq = K.implicit_randn([nlayersq, n, 3], stddev=stddev) * 2*np.pi + if lr is None: + lr = tf.keras.optimizers.schedules.ExponentialDecay(0.6, 100, 0.8) + structure_opt = K.optimizer(tf.keras.optimizers.Adam(lr)) + + avcost = 0 + avcost2 = 0 + loss_history = [] + for epoch in range(epochs): # iteration to update strcuture param + # random sample some structures + batched_stucture = K.onehot( + sampling_from_structure(params, batch=batch), + num=params.shape[-1], + ) + vs, gq = vvag_hybrid(batched_stucture, paramq, "direct") + loss_history.append(np.min(vs)) + gq = gq[0] + avcost = K.mean(vs) # average cost of the batch + gs = nmf_gradient_vmap(params, batched_stucture) # \nabla lnp + gs = K.mean(K.reshape(vs - avcost2, [-1, 1, 1]) * gs, axis=0) + # avcost2 is averaged cost in the last epoch + avcost2 = avcost + + [params, paramq] = structure_opt.update([gs, gq], [params, paramq]) + if epoch % debug_step == 0 or epoch == epochs - 1: + print("----------epoch %s-----------" % epoch) + print( + "batched average loss: ", + np.mean(vs), + "minimum candidate loss: ", + np.min(vs), + ) + + # max over choices, min over layers and qubits + minp = tf.math.reduce_min(tf.math.reduce_max(tf.math.softmax(params), axis=-1)) + if minp > 0.5: + print("probability converged") + + if verbose: + print( + "strcuture parameter: \n", + params.numpy() + ) + + cand_preset = best_from_structure(params) + print(cand_preset) + print("current recommendation loss: ", hybrid_vqe(params, paramq, "most")) + + loss_history = np.array(loss_history) + return hybrid_vqe(params, paramq, "most"), params, paramq, loss_history + + +print('Train hybrid.') +ee, params, paramq, loss_history = train_hybrid(epochs=epochs, batch=batch, verbose=True) +print('Energy:', ee) From 84c3f544c96ba745fc1edf93a3a4ba7b6d05b63e Mon Sep 17 00:00:00 2001 From: Yuxuan Date: Thu, 2 Nov 2023 09:37:32 -0700 Subject: [PATCH 666/725] reformat the SHVQE script --- examples/shvqe.py | 87 ++++++++++++++++++++++++++--------------------- 1 file changed, 48 insertions(+), 39 deletions(-) diff --git a/examples/shvqe.py b/examples/shvqe.py index fdf9d50a..4083fa6d 100644 --- a/examples/shvqe.py +++ b/examples/shvqe.py @@ -5,6 +5,7 @@ """ import sys + sys.path.insert(0, "../") import numpy as np @@ -16,9 +17,9 @@ ctype, rtype = tc.set_dtype("complex64") K = tc.set_backend("tensorflow") -n = 10 # the number of qubits (must be even for consistency later) -ncz = 2 # number of cz layers in Schrodinger circuit -nlayersq = ncz + 1 # Schrodinger parameter layers +n = 10 # the number of qubits (must be even for consistency later) +ncz = 2 # number of cz layers in Schrodinger circuit +nlayersq = ncz + 1 # Schrodinger parameter layers # training setup epochs = 1000 @@ -28,6 +29,7 @@ h6h = np.load("./h6_hamiltonian.npy") # reported in 0.99 A hamiltonian = construct_matrix_v3(h6h.tolist()) + def hybrid_ansatz(structure, paramq, preprocess="direct", train=True): """_summary_ @@ -54,13 +56,13 @@ def hybrid_ansatz(structure, paramq, preprocess="direct", train=True): pass structure = K.cast(structure, ctype) - structure = tf.reshape(structure, shape=[n//2, 2]) + structure = tf.reshape(structure, shape=[n // 2, 2]) # quantum variational in Schrodinger part, first consider a ring topol for j in range(nlayersq): - if j !=0 and j!=nlayersq-1: - for i in range(j%2,n,2): - c.cz(i, (i+1)%n) + if j != 0 and j != nlayersq - 1: + for i in range(j % 2, n, 2): + c.cz(i, (i + 1) % n) for i in range(n): c.rx(i, theta=paramq[j, i, 0]) c.ry(i, theta=paramq[j, i, 1]) @@ -68,36 +70,37 @@ def hybrid_ansatz(structure, paramq, preprocess="direct", train=True): # Clifford part, which is actually virtual if train: - for j in range(0,n//2-1): + for j in range(0, n // 2 - 1): dis = j + 1 - for i in range(0,n): + for i in range(0, n): c.unitary( i, - (i+dis) % n, + (i + dis) % n, unitary=structure[j, 0] * tc.gates.ii().tensor + structure[j, 1] * tc.gates.cz().tensor, ) - for i in range(0,n//2): + for i in range(0, n // 2): c.unitary( i, - i + n//2, - unitary=structure[n//2-1, 0] * tc.gates.ii().tensor - + structure[n//2-1, 1] * tc.gates.cz().tensor, + i + n // 2, + unitary=structure[n // 2 - 1, 0] * tc.gates.ii().tensor + + structure[n // 2 - 1, 1] * tc.gates.cz().tensor, ) - else: # if not for training, we just put nontrivial gates - for j in range(0,n//2-1): + else: # if not for training, we just put nontrivial gates + for j in range(0, n // 2 - 1): dis = j + 1 - for i in range(0,n): - if structure[j, 1]==1: - c.cz(i, (i+dis) % n) + for i in range(0, n): + if structure[j, 1] == 1: + c.cz(i, (i + dis) % n) - for i in range(0,n//2): - if structure[j, 1]==1: - c.cz(i, i + n//2) + for i in range(0, n // 2): + if structure[j, 1] == 1: + c.cz(i, i + n // 2) return c + def hybrid_vqe(structure, paramq, preprocess="direct"): """_summary_ @@ -118,6 +121,7 @@ def hybrid_vqe(structure, paramq, preprocess="direct"): c = hybrid_ansatz(structure, paramq, preprocess) return tc.templates.measurements.operator_expectation(c, hamiltonian) + def sampling_from_structure(structures, batch=1): ch = structures.shape[-1] prob = K.softmax(K.real(structures), axis=-1) @@ -137,7 +141,7 @@ def best_from_structure(structures): def nmf_gradient(structures, oh): - """ compute the Monte Carlo gradient with respect of naive mean-field probabilistic model + """compute the Monte Carlo gradient with respect of naive mean-field probabilistic model Parameters ---------- @@ -166,21 +170,25 @@ def nmf_gradient(structures, oh): indices, tf.ones([structures.shape[0]], dtype=ctype), ) - ) # in oh : 1-p, not in oh : -p + ) # in oh : 1-p, not in oh : -p + # vmap for a batch of structures -nmf_gradient_vmap = K.jit( - K.vmap(nmf_gradient, vectorized_argnums=1)) +nmf_gradient_vmap = K.jit(K.vmap(nmf_gradient, vectorized_argnums=1)) # vvag for a batch of structures vvag_hybrid = K.jit( K.vectorized_value_and_grad(hybrid_vqe, vectorized_argnums=(0,), argnums=(1,)), - static_argnums=(2,)) + static_argnums=(2,), +) + -def train_hybrid(stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, verbose=False): +def train_hybrid( + stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, verbose=False +): # params = K.implicit_randn([n//2, 2], stddev=stddev) - params = K.ones([n//2, 2], dtype=float) - paramq = K.implicit_randn([nlayersq, n, 3], stddev=stddev) * 2*np.pi + params = K.ones([n // 2, 2], dtype=float) + paramq = K.implicit_randn([nlayersq, n, 3], stddev=stddev) * 2 * np.pi if lr is None: lr = tf.keras.optimizers.schedules.ExponentialDecay(0.6, 100, 0.8) structure_opt = K.optimizer(tf.keras.optimizers.Adam(lr)) @@ -197,7 +205,7 @@ def train_hybrid(stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, ve vs, gq = vvag_hybrid(batched_stucture, paramq, "direct") loss_history.append(np.min(vs)) gq = gq[0] - avcost = K.mean(vs) # average cost of the batch + avcost = K.mean(vs) # average cost of the batch gs = nmf_gradient_vmap(params, batched_stucture) # \nabla lnp gs = K.mean(K.reshape(vs - avcost2, [-1, 1, 1]) * gs, axis=0) # avcost2 is averaged cost in the last epoch @@ -214,15 +222,14 @@ def train_hybrid(stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, ve ) # max over choices, min over layers and qubits - minp = tf.math.reduce_min(tf.math.reduce_max(tf.math.softmax(params), axis=-1)) + minp = tf.math.reduce_min( + tf.math.reduce_max(tf.math.softmax(params), axis=-1) + ) if minp > 0.5: print("probability converged") if verbose: - print( - "strcuture parameter: \n", - params.numpy() - ) + print("strcuture parameter: \n", params.numpy()) cand_preset = best_from_structure(params) print(cand_preset) @@ -232,6 +239,8 @@ def train_hybrid(stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, ve return hybrid_vqe(params, paramq, "most"), params, paramq, loss_history -print('Train hybrid.') -ee, params, paramq, loss_history = train_hybrid(epochs=epochs, batch=batch, verbose=True) -print('Energy:', ee) +print("Train hybrid.") +ee, params, paramq, loss_history = train_hybrid( + epochs=epochs, batch=batch, verbose=True +) +print("Energy:", ee) From 6f8e490185f02891fc76ea79c99bf22ff984fee6 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Fri, 3 Nov 2023 06:13:38 +0000 Subject: [PATCH 667/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index df9fc06c..e1718e30 100644 --- a/README.md +++ b/README.md @@ -296,6 +296,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. ztzhu
ztzhu
💻 + Rabqubit
Rabqubit
💡 From 9898e2d77260f5e5965949ea2816c157ecedf953 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Fri, 3 Nov 2023 06:13:39 +0000 Subject: [PATCH 668/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 74aab495..ad7f098d 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -291,6 +291,15 @@ "contributions": [ "code" ] + }, + { + "login": "royess", + "name": "Rabqubit", + "avatar_url": "https://avatars.githubusercontent.com/u/31059422?v=4", + "profile": "https://github.com/royess", + "contributions": [ + "example" + ] } ], "contributorsPerLine": 6, From 9b614f82033fac31354989f931a52d4b6aaa0c35 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 28 Nov 2023 16:46:54 +0800 Subject: [PATCH 669/725] add env variable for eps of entropy --- tensorcircuit/quantum.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 147deffb..383259c2 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -9,6 +9,7 @@ """ # pylint: disable=invalid-name +import os from functools import reduce, partial import logging from operator import or_, mul, matmul @@ -1503,7 +1504,7 @@ def op2tensor( @op2tensor -def entropy(rho: Union[Tensor, QuOperator], eps: float = 1e-12) -> Tensor: +def entropy(rho: Union[Tensor, QuOperator], eps: Optional[float] = None) -> Tensor: """ Compute the entropy from the given density matrix ``rho``. @@ -1541,6 +1542,11 @@ def entanglement2(param, n, nlayers): :return: Entropy on the given density matrix. :rtype: Tensor """ + eps_env = os.environ.get("TC_QUANTUM_ENTROPY_EPS") + if eps is None and eps_env is None: + eps = 1e-12 + elif eps is None and eps_env is not None: + eps = 10 ** (-int(eps_env)) rho += eps * backend.cast(backend.eye(rho.shape[-1]), rho.dtype) # type: ignore lbd = backend.real(backend.eigh(rho)[0]) lbd = backend.relu(lbd) From 3498f0a91df2193c0f767da0b33894138e3a9b6b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 4 Dec 2023 12:06:29 +0800 Subject: [PATCH 670/725] fix requirements --- requirements/requirements-extra.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 80fff586..787c6cae 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,9 +1,9 @@ # extra dependencies for ci qiskit==0.43 -qiskit-nature +# qiskit-nature +mitiq cirq torch jupyter mthree==1.1.0 -mitiq openfermion From 0ce8afdecff92482756e771e4df1b8631bec3455 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 8 Dec 2023 19:42:11 +0800 Subject: [PATCH 671/725] add evol_gh in fgs --- tensorcircuit/fgs.py | 18 ++++++++++++++++++ tests/test_fgs.py | 19 +++++++++++++++++++ 2 files changed, 37 insertions(+) diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index 6db2025d..dfb8b794 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -230,6 +230,19 @@ def evol_ihamiltonian(self, h: Tensor) -> None: self.orthogonal() self.cmatrix = None + def evol_ghamiltonian(self, h: Tensor) -> None: + r""" + Evolve as :math:`e^{-1/2 i \hat{h}}` with h generally non-Hermitian + + :param h: _description_ + :type h: Tensor + """ + # e^{-1/2 H} + h = backend.cast(h, dtype=dtypestr) + self.alpha = backend.expm(-1.0j * backend.adjoint(h)) @ self.alpha + self.orthogonal() + self.cmatrix = None + def orthogonal(self) -> None: q, _ = backend.qr(self.alpha) self.alpha = q @@ -579,6 +592,11 @@ def evol_ihamiltonian(self, h: Tensor) -> None: self.state = npb.reshape(self.state, [-1]) self.orthogonal() + def evol_ghamiltonian(self, h: Tensor) -> None: + self.state = npb.expm(-1 / 2 * 1.0j * h) @ npb.reshape(self.state, [-1, 1]) + self.state = npb.reshape(self.state, [-1]) + self.orthogonal() + def evol_hp(self, i: int, j: int, chi: Tensor = 0) -> None: self.evol_hamiltonian(self.hopping_jw(chi, i, j, self.L)) diff --git a/tests/test_fgs.py b/tests/test_fgs.py index 6ec87653..36bae00e 100644 --- a/tests/test_fgs.py +++ b/tests/test_fgs.py @@ -16,6 +16,23 @@ @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_cmatrix(backend, highp): + import openfermion + + def asymmetric_hopping(J, gamma, i, j, L): + m0 = tc.fgs.onehot_matrix(i, j, 2 * L) - tc.fgs.onehot_matrix( + j + L, i + L, 2 * L + ) + m = (J + gamma) * m0 + (J - gamma) * tc.backend.adjoint(m0) + return m / 2 + + def asymmetric_hopping_jw(J, gamma, i, j, L): + op = (J + gamma) * openfermion.FermionOperator(f"{str(i)}^ {str(j)}") + np.conj( + J - gamma + ) * openfermion.FermionOperator(f"{str(j)}^ {str(i)}") + sop = openfermion.transforms.jordan_wigner(op) + m = openfermion.get_sparse_operator(sop, n_qubits=L).todense() + return m + c = tc.fgs.FGSSimulator(4, [0]) c1 = tc.fgs.FGSTestSimulator(4, [0]) c.evol_hp(0, 1, 1.2) @@ -26,6 +43,8 @@ def test_cmatrix(backend, highp): c1.evol_cp(0, -0.8) c.evol_sp(1, 0, 0.5) c1.evol_sp(1, 0, 0.5) + c.evol_ghamiltonian(asymmetric_hopping(1, 0.5, 0, 2, 4)) + c1.evol_ghamiltonian(np.array(asymmetric_hopping_jw(1, 0.5, 0, 2, 4))) c.evol_sp(1, 2, 1.5) c1.evol_sp(1, 2, 1.5) c.evol_ihamiltonian(c.chemical_potential(1.0, 1, 4)) From fc2fb0650e40a019ae18ec4cabd0a79cc2b0f041 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 15 Dec 2023 11:15:48 +0800 Subject: [PATCH 672/725] fix cu qiskit translation --- CHANGELOG.md | 2 ++ tensorcircuit/translation.py | 3 ++- tests/test_circuit.py | 3 +++ 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 218e93e2..54e26b8b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,6 +24,8 @@ - Support degenerate eigenvalue for jax backend `eigh` method when using AD +- Fixed `cu` gate translation from qiskit to avoid qiskit bug + ## 0.11.0 ### Added diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 78136967..866cf4c1 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -523,7 +523,8 @@ def qiskit2tc( tc_circuit.multicontrol( *idx, ctrl=ctrl_state, unitary=gates._x_matrix, name="x" ) - elif gate_name[0] == "c" and gate_name[:7] != "circuit": + elif gate_name[0] == "c" and gate_name[:7] != "circuit" and gate_name != "cu": + # qiskit cu bug, see https://github.com/tencent-quantum-lab/tensorcircuit/issues/199 for i in range(1, len(gate_name)): if (gate_name[-i] == "o") & (gate_name[-i - 1] == "_"): break diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 10a73971..cb67eb36 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1105,6 +1105,9 @@ def test_qiskit2tc(): qisc.x(3) qisc.y(3) qisc.z(3) + qisc.cu( + 5.868768495722669, 2.24809352294186, 3.59102783505607, 2.0223650288392, 1, 3 + ) qisc.cnot(0, 1) qisc.cy(0, 1) qisc.cz(0, 1, ctrl_state=0) From 0d60be4b37e64183b1be28d656a738ec7e83dc8a Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 15 Dec 2023 11:20:03 +0800 Subject: [PATCH 673/725] add refs in readme --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index e1718e30..daaad5ea 100644 --- a/README.md +++ b/README.md @@ -400,6 +400,10 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Google Summer of Code 2023 Projects (QML4HEP): https://github.com/ML4SCI/QMLHEP, https://github.com/Gopal-Dahale/qgnn-hep, https://github.com/salcc/QuantumTransformers. +- Absence of barren plateaus in finite local-depth circuits with long-range entanglement: https://arxiv.org/abs/2311.01393. + +- Non-Markovianity benefits quantum dynamics simulation: https://arxiv.org/abs/2311.17622. + If you want to highlight your research work or projects here, feel free to add by opening PR. From 9e034d681150aa8a3957c6e88c8dd47c62650ef1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 21 Dec 2023 10:30:13 +0800 Subject: [PATCH 674/725] fix requirements --- requirements/requirements-extra.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 787c6cae..17c1438f 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,5 +1,5 @@ # extra dependencies for ci -qiskit==0.43 +qiskit # qiskit-nature mitiq cirq From 4e615fba8c3d161a0b006e6f09c36eb5caf4cd22 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 21 Dec 2023 12:13:56 +0800 Subject: [PATCH 675/725] fix reqs --- requirements/requirements-extra.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 17c1438f..63d1824f 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -4,6 +4,6 @@ qiskit mitiq cirq torch -jupyter +# jupyter mthree==1.1.0 openfermion From e2cc48b6f7e0ba8a0849b09699e91237335ff082 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 21 Dec 2023 17:07:24 +0800 Subject: [PATCH 676/725] fix for future qiskit --- requirements/requirements-extra.txt | 1 + tensorcircuit/translation.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 63d1824f..024c584f 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,5 +1,6 @@ # extra dependencies for ci qiskit +qiskit_aer # qiskit-nature mitiq cirq diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 866cf4c1..e297113d 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -342,7 +342,7 @@ def qir2qiskit( qop = qi.Operator(gatem) try: qiskit_circ.unitary(qop, index[::-1], label=qis_name) - except ExtensionError: + except (ExtensionError, ValueError) as _: logger.warning( "omit non unitary gate in tensorcircuit when transforming to qiskit: %s" % gate_name From 9d60c64668a754886a9f45120234ed26d3191395 Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Mon, 15 Jan 2024 11:21:44 +0900 Subject: [PATCH 677/725] Update cons.py --- tensorcircuit/cons.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/cons.py b/tensorcircuit/cons.py index 5c3fb78d..e7e4bccf 100644 --- a/tensorcircuit/cons.py +++ b/tensorcircuit/cons.py @@ -152,7 +152,7 @@ def set_dtype(dtype: Optional[str] = None, set_global: bool = True) -> Tuple[str raise ValueError(f"Unsupported data type: {dtype}") try: - from jax.config import config + from jax import config except ImportError: config = None # type: ignore From 0c2433cb4c962dee9ffa150a493c5c7db773f7d8 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 16 Jan 2024 03:30:07 +0000 Subject: [PATCH 678/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index daaad5ea..46a70c2a 100644 --- a/README.md +++ b/README.md @@ -297,6 +297,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. ztzhu
ztzhu
💻 Rabqubit
Rabqubit
💡 + Kazuki Tsuoka
Kazuki Tsuoka
💻 From 7105cfb59901cf3c408a958a616ccf2ceec65d20 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Tue, 16 Jan 2024 03:30:08 +0000 Subject: [PATCH 679/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index ad7f098d..4b928ff4 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -300,6 +300,15 @@ "contributions": [ "example" ] + }, + { + "login": "king-p3nguin", + "name": "Kazuki Tsuoka", + "avatar_url": "https://avatars.githubusercontent.com/u/103920010?v=4", + "profile": "https://github.com/king-p3nguin", + "contributions": [ + "code" + ] } ], "contributorsPerLine": 6, From 11fc3b6c44a97c1cce01fee49b564bee34bebbc3 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 17 Jan 2024 15:42:41 +0800 Subject: [PATCH 680/725] add 2-otoc support for fgs --- tensorcircuit/fgs.py | 176 +++++++++++++++++++++++++++++++++++++++++-- tests/test_fgs.py | 19 +++++ 2 files changed, 189 insertions(+), 6 deletions(-) diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index dfb8b794..e0e36d43 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -1,7 +1,7 @@ """ Fermion Gaussian state simulator """ -from typing import Any, List, Optional, Tuple +from typing import Any, Dict, List, Optional, Tuple import numpy as np @@ -74,8 +74,10 @@ def __init__( _, _, self.alpha = self.fermion_diagonalization(hc, L) else: self.alpha = alpha + self.alpha0 = self.alpha self.wtransform = self.wmatrix(L) self.cmatrix = cmatrix + self.otcmatrix: Dict[Tuple[int, int], Tensor] = {} @classmethod def fermion_diagonalization( @@ -141,13 +143,35 @@ def init_alpha(filled: List[int], L: int) -> Tensor: def get_alpha(self) -> Tensor: return self.alpha - def get_cmatrix(self) -> Tensor: - if self.cmatrix is not None: + def get_cmatrix(self, now_i: bool = True, now_j: bool = True) -> Tensor: + # otoc in FGS language, see: https://arxiv.org/pdf/1908.03292.pdf + # https://journals.aps.org/prb/pdf/10.1103/PhysRevB.99.054205 + # otoc for non=hermitian system is more subtle due to the undefined normalization + # of operator and not considered here, see: https://arxiv.org/pdf/2305.12054.pdf + if self.cmatrix is not None and now_i is True and now_j is True: return self.cmatrix - else: + elif now_i is True and now_j is True: cmatrix = self.alpha @ backend.adjoint(self.alpha) self.cmatrix = cmatrix return cmatrix + elif now_i is True: # new i old j + if (1, 0) in self.otcmatrix: + return self.otcmatrix[(1, 0)] + cmatrix = self.alpha @ backend.adjoint(self.alpha0) + self.otcmatrix[(1, 0)] = cmatrix + return cmatrix + elif now_j is True: # old i new j + if (0, 1) in self.otcmatrix: + return self.otcmatrix[(0, 1)] + cmatrix = self.alpha0 @ backend.adjoint(self.alpha) + self.otcmatrix[(0, 1)] = cmatrix + return cmatrix + else: # initial cmatrix + if (0, 0) in self.otcmatrix: + return self.otcmatrix[(0, 0)] + cmatrix = self.alpha0 @ backend.adjoint(self.alpha0) + self.otcmatrix[(0, 0)] = cmatrix + return cmatrix def get_reduced_cmatrix(self, subsystems_to_trace_out: List[int]) -> Tensor: m = self.get_cmatrix() @@ -216,6 +240,7 @@ def evol_hamiltonian(self, h: Tensor) -> None: h = backend.cast(h, dtype=dtypestr) self.alpha = backend.expm(-1.0j * h) @ self.alpha self.cmatrix = None + self.otcmatrix = {} def evol_ihamiltonian(self, h: Tensor) -> None: r""" @@ -229,6 +254,7 @@ def evol_ihamiltonian(self, h: Tensor) -> None: self.alpha = backend.expm(h) @ self.alpha self.orthogonal() self.cmatrix = None + self.otcmatrix = {} def evol_ghamiltonian(self, h: Tensor) -> None: r""" @@ -242,6 +268,7 @@ def evol_ghamiltonian(self, h: Tensor) -> None: self.alpha = backend.expm(-1.0j * backend.adjoint(h)) @ self.alpha self.orthogonal() self.cmatrix = None + self.otcmatrix = {} def orthogonal(self) -> None: q, _ = backend.qr(self.alpha) @@ -350,7 +377,9 @@ def get_covariance_matrix(self) -> Tensor: m = self.get_cmatrix_majorana() return -1.0j * (2 * m - backend.eye(self.L * 2)) - def expectation_2body(self, i: int, j: int) -> Tensor: + def expectation_2body( + self, i: int, j: int, now_i: bool = True, now_j: bool = True + ) -> Tensor: """ expectation of two fermion terms convention: (c, c^\dagger) @@ -363,7 +392,7 @@ def expectation_2body(self, i: int, j: int) -> Tensor: :return: _description_ :rtype: Tensor """ - return self.get_cmatrix()[i][(j + self.L) % (2 * self.L)] + return self.get_cmatrix(now_i, now_j)[i][(j + self.L) % (2 * self.L)] def expectation_4body(self, i: int, j: int, k: int, l: int) -> Tensor: """ @@ -520,6 +549,7 @@ def __init__( self.state = self.fermion_diagonalization(hc, L) else: self.state = self.init_state(filled, L) + self.state0 = self.state @staticmethod def init_state(filled: List[int], L: int) -> Tensor: @@ -621,6 +651,140 @@ def evol_sp(self, i: int, j: int, chi: Tensor = 0) -> None: def orthogonal(self) -> None: self.state /= backend.norm(self.state) + def get_ot_cmatrix(self, h: Tensor, now_i: bool = True) -> Tensor: + alpha1_jw = self.state + cmatrix = np.zeros([2 * self.L, 2 * self.L], dtype=complex) + for i in range(self.L): + for j in range(self.L): + op1 = openfermion.FermionOperator(f"{str(i)}") + op2 = openfermion.FermionOperator(f"{str(j)}^") + + m1 = openfermion.get_sparse_operator(op1, n_qubits=self.L).todense() + m2 = openfermion.get_sparse_operator(op2, n_qubits=self.L).todense() + eh = npb.expm(-1 / 2 * 1.0j * h) + eh1 = npb.expm(1 / 2 * 1.0j * h) + if now_i is True: + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ eh1 + @ m1 + @ eh + @ m2 + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + else: + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m1 + @ eh1 + @ m2 + @ eh + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + for i in range(self.L, 2 * self.L): + for j in range(self.L): + op1 = openfermion.FermionOperator(f"{str(i-self.L)}^") + op2 = openfermion.FermionOperator(f"{str(j)}^") + + m1 = openfermion.get_sparse_operator(op1, n_qubits=self.L).todense() + m2 = openfermion.get_sparse_operator(op2, n_qubits=self.L).todense() + eh = npb.expm(-1 / 2 * 1.0j * h) + eh1 = npb.expm(1 / 2 * 1.0j * h) + + if now_i is True: + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ eh1 + @ m1 + @ eh + @ m2 + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + else: + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m1 + @ eh1 + @ m2 + @ eh + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + + for i in range(self.L): + for j in range(self.L, 2 * self.L): + op1 = openfermion.FermionOperator(f"{str(i)}") + op2 = openfermion.FermionOperator(f"{str(j-self.L)}") + + m1 = openfermion.get_sparse_operator(op1, n_qubits=self.L).todense() + m2 = openfermion.get_sparse_operator(op2, n_qubits=self.L).todense() + eh = npb.expm(-1 / 2 * 1.0j * h) + eh1 = npb.expm(1 / 2 * 1.0j * h) + + if now_i is True: + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ eh1 + @ m1 + @ eh + @ m2 + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + else: + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m1 + @ eh1 + @ m2 + @ eh + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + for i in range(self.L, 2 * self.L): + for j in range(self.L, 2 * self.L): + op1 = openfermion.FermionOperator(f"{str(i-self.L)}^ ") + op2 = openfermion.FermionOperator(f"{str(j-self.L)}") + + m1 = openfermion.get_sparse_operator(op1, n_qubits=self.L).todense() + m2 = openfermion.get_sparse_operator(op2, n_qubits=self.L).todense() + eh = npb.expm(-1 / 2 * 1.0j * h) + eh1 = npb.expm(1 / 2 * 1.0j * h) + + if now_i is True: + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ eh1 + @ m1 + @ eh + @ m2 + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + else: + cmatrix[i, j] = backend.item( + ( + backend.reshape(backend.adjoint(alpha1_jw), [1, -1]) + @ m1 + @ eh1 + @ m2 + @ eh + @ backend.reshape(alpha1_jw, [-1, 1]) + )[0, 0] + ) + + return cmatrix + def get_cmatrix(self) -> Tensor: alpha1_jw = self.state cmatrix = np.zeros([2 * self.L, 2 * self.L], dtype=complex) diff --git a/tests/test_fgs.py b/tests/test_fgs.py index 36bae00e..dd307b3c 100644 --- a/tests/test_fgs.py +++ b/tests/test_fgs.py @@ -59,6 +59,25 @@ def asymmetric_hopping_jw(J, gamma, i, j, L): ) +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_otoc(backend, highp): + c = tc.FGSSimulator(4, [0, 1]) + c1 = tc.fgs.FGSTestSimulator(4, [0, 1]) + h = c.hopping(0.6, 1, 2, 4) + h += c.hopping(-0.8, 3, 2, 4) + h += c.chemical_potential(0.3, 2, 4) + h1 = c1.hopping_jw(0.6, 1, 2, 4) + h1 += c1.hopping_jw(-0.8, 3, 2, 4) + h1 += c1.chemical_potential_jw(0.3, 2, 4) + c.evol_hamiltonian(h) + m = c.get_cmatrix(now_i=True, now_j=False) + m0 = c1.get_ot_cmatrix(h1) + np.testing.assert_allclose(m, m0, atol=1e-5) + m = c.get_cmatrix(now_i=False, now_j=True) + m0 = c1.get_ot_cmatrix(h1, now_i=False) + np.testing.assert_allclose(m, m0, atol=1e-5) + + @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_fgs_ad(backend, highp): import optax From 86026fa186dbc8f5c8f311373f6822d455fe2d4b Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 29 Jan 2024 20:40:45 +0800 Subject: [PATCH 681/725] new black --- .../source/tutorials/barren_plateaus_cn.ipynb | 4 +- docs/source/tutorials/nnvqe_cn.ipynb | 4 +- .../optimization_and_expressibility_cn.ipynb | 4 +- .../tutorials/tfim_vqe_diffreph_cn.ipynb | 4 +- examples/matprod_vmap.py | 1 + tensorcircuit/abstractcircuit.py | 1 + tensorcircuit/applications/dqas.py | 7 +-- tensorcircuit/applications/layers.py | 1 + tensorcircuit/applications/physics/fss.py | 1 + tensorcircuit/applications/utils.py | 1 + tensorcircuit/applications/vags.py | 1 + tensorcircuit/applications/vqes.py | 1 + tensorcircuit/asciiart.py | 1 + tensorcircuit/backends/abstract_backend.py | 46 +++++++++++-------- tensorcircuit/backends/cupy_backend.py | 1 + tensorcircuit/backends/jax_backend.py | 1 + tensorcircuit/backends/jax_ops.py | 1 + tensorcircuit/backends/numpy_backend.py | 1 + tensorcircuit/backends/pytorch_backend.py | 1 + tensorcircuit/backends/pytorch_ops.py | 1 + tensorcircuit/backends/tensorflow_backend.py | 1 + tensorcircuit/backends/tf_ops.py | 1 + tensorcircuit/basecircuit.py | 1 + tensorcircuit/circuit.py | 1 + tensorcircuit/cloud/utils.py | 1 + tensorcircuit/cloud/wrapper.py | 1 + tensorcircuit/compiler/__init__.py | 1 + tensorcircuit/cons.py | 1 + tensorcircuit/densitymatrix.py | 9 ++-- tensorcircuit/fgs.py | 1 + tensorcircuit/mps_base.py | 1 + tensorcircuit/mpscircuit.py | 1 + tensorcircuit/noisemodel.py | 1 + tensorcircuit/quantum.py | 1 + tensorcircuit/results/counts.py | 1 + tensorcircuit/results/readout_mitigation.py | 9 ++-- tensorcircuit/simplify.py | 1 + tensorcircuit/templates/blocks.py | 1 + tensorcircuit/templates/graphs.py | 1 + tensorcircuit/templates/measurements.py | 1 + tensorcircuit/vis.py | 1 + 41 files changed, 87 insertions(+), 33 deletions(-) diff --git a/docs/source/tutorials/barren_plateaus_cn.ipynb b/docs/source/tutorials/barren_plateaus_cn.ipynb index 4288475f..6f5a8a49 100644 --- a/docs/source/tutorials/barren_plateaus_cn.ipynb +++ b/docs/source/tutorials/barren_plateaus_cn.ipynb @@ -158,7 +158,9 @@ " dtype=\"float32\",\n", ")\n", "\n", - "e, grad = op_expectation_vmap_vvag(params, seed, n, nlayers) # 不同随机电路的 ZZ 可观测量和梯度的期望\n", + "e, grad = op_expectation_vmap_vvag(\n", + " params, seed, n, nlayers\n", + ") # 不同随机电路的 ZZ 可观测量和梯度的期望\n", "\n", "grad_var = tf.math.reduce_std(tf.math.reduce_std(grad, axis=0), axis=0)[\n", " 0, 0\n", diff --git a/docs/source/tutorials/nnvqe_cn.ipynb b/docs/source/tutorials/nnvqe_cn.ipynb index df6e0871..056990bb 100644 --- a/docs/source/tutorials/nnvqe_cn.ipynb +++ b/docs/source/tutorials/nnvqe_cn.ipynb @@ -115,7 +115,9 @@ "metadata": {}, "outputs": [], "source": [ - "def MERA(inp, n, d=1, lamb=1.0, energy_flag=False): # 对于单变量一维XXZ模型，我们固定lamb\n", + "def MERA(\n", + " inp, n, d=1, lamb=1.0, energy_flag=False\n", + "): # 对于单变量一维XXZ模型，我们固定lamb\n", " params = K.cast(inp[\"params\"], \"complex128\")\n", " delta = K.cast(inp[\"delta\"], \"complex128\")\n", " c = tc.Circuit(n)\n", diff --git a/docs/source/tutorials/optimization_and_expressibility_cn.ipynb b/docs/source/tutorials/optimization_and_expressibility_cn.ipynb index 3fdaa7a8..e09df93c 100644 --- a/docs/source/tutorials/optimization_and_expressibility_cn.ipynb +++ b/docs/source/tutorials/optimization_and_expressibility_cn.ipynb @@ -276,7 +276,9 @@ "@tf.function\n", "def entropy(v):\n", " ψ = get_state(v)\n", - " ρ_reduced = tc.quantum.reduced_density_matrix(ψ, NA) # 部分描绘出子系统A得到的降密度矩阵\n", + " ρ_reduced = tc.quantum.reduced_density_matrix(\n", + " ψ, NA\n", + " ) # 部分描绘出子系统A得到的降密度矩阵\n", " S = tc.quantum.renyi_entropy(ρ_reduced) # Renyi 纠缠熵\n", " return S" ] diff --git a/docs/source/tutorials/tfim_vqe_diffreph_cn.ipynb b/docs/source/tutorials/tfim_vqe_diffreph_cn.ipynb index eca8c1ad..14a5cbea 100644 --- a/docs/source/tutorials/tfim_vqe_diffreph_cn.ipynb +++ b/docs/source/tutorials/tfim_vqe_diffreph_cn.ipynb @@ -420,7 +420,9 @@ "\n", "Jx = np.array([1.0 for _ in range(n - 1)]) # xx 相互作用的强度 (OBC)\n", "Bz = np.array([1.0 for _ in range(n)]) # 横向场强\n", - "hamiltonian_mpo = tn.matrixproductstates.mpo.FiniteTFI(Jx, Bz, dtype=dtype) # 矩阵乘积算子\n", + "hamiltonian_mpo = tn.matrixproductstates.mpo.FiniteTFI(\n", + " Jx, Bz, dtype=dtype\n", + ") # 矩阵乘积算子\n", "hamiltonian_mpo = quoperator_mpo(hamiltonian_mpo) # 从 mpo 生成 QuOperator" ] }, diff --git a/examples/matprod_vmap.py b/examples/matprod_vmap.py index e1c6954b..bbf8f137 100644 --- a/examples/matprod_vmap.py +++ b/examples/matprod_vmap.py @@ -2,6 +2,7 @@ matrix product: a new twist rewrite matrix product in a vmap style """ + from functools import partial import numpy as np diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index 46c549c9..ac2b9116 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -1,6 +1,7 @@ """ Methods for abstract circuits independent of nodes, edges and contractions """ + # pylint: disable=invalid-name from typing import Any, Callable, Dict, List, Optional, Sequence, Union, Tuple diff --git a/tensorcircuit/applications/dqas.py b/tensorcircuit/applications/dqas.py index d139fe01..161a2c73 100644 --- a/tensorcircuit/applications/dqas.py +++ b/tensorcircuit/applications/dqas.py @@ -1,6 +1,7 @@ """ Modules for DQAS framework """ + # possibly deprecated, multiprocessing is not the recommended way to do DQAS task now, using vmap! import sys @@ -486,9 +487,9 @@ def qaoa_simple_train( if "prob_model_func" in kws: pmf = kws["prob_model_func"] del kws["prob_model_func"] - kws[ - "prob_model" - ] = pmf() # in case keras model cannot pickled for multiprocessing map + kws["prob_model"] = ( + pmf() + ) # in case keras model cannot pickled for multiprocessing map if isinstance(graph, list): def graph_generator() -> Iterator[Graph]: diff --git a/tensorcircuit/applications/layers.py b/tensorcircuit/applications/layers.py index 18f53db6..64eef546 100644 --- a/tensorcircuit/applications/layers.py +++ b/tensorcircuit/applications/layers.py @@ -1,6 +1,7 @@ """ Module for functions adding layers of circuits """ + import itertools import logging import sys diff --git a/tensorcircuit/applications/physics/fss.py b/tensorcircuit/applications/physics/fss.py index dc60d492..f0490509 100644 --- a/tensorcircuit/applications/physics/fss.py +++ b/tensorcircuit/applications/physics/fss.py @@ -1,6 +1,7 @@ """ finite size scaling tools """ + from typing import List, Tuple, Optional import numpy as np diff --git a/tensorcircuit/applications/utils.py b/tensorcircuit/applications/utils.py index 8390afce..3ca54ff2 100644 --- a/tensorcircuit/applications/utils.py +++ b/tensorcircuit/applications/utils.py @@ -2,6 +2,7 @@ A collection of useful function snippets that irrelevant with the main modules or await for further refactor """ + import logging from typing import Any, Callable, Iterator, Optional, Sequence, Tuple diff --git a/tensorcircuit/applications/vags.py b/tensorcircuit/applications/vags.py index 80e5b74a..b2b5a612 100644 --- a/tensorcircuit/applications/vags.py +++ b/tensorcircuit/applications/vags.py @@ -1,6 +1,7 @@ """ DQAS application kernels as vag functions """ + from functools import lru_cache, partial, reduce import logging import operator diff --git a/tensorcircuit/applications/vqes.py b/tensorcircuit/applications/vqes.py index ba279365..a542268b 100644 --- a/tensorcircuit/applications/vqes.py +++ b/tensorcircuit/applications/vqes.py @@ -1,6 +1,7 @@ """ VQNHE application """ + from functools import lru_cache from itertools import product import time diff --git a/tensorcircuit/asciiart.py b/tensorcircuit/asciiart.py index b63b317e..b5c9e3b4 100644 --- a/tensorcircuit/asciiart.py +++ b/tensorcircuit/asciiart.py @@ -1,6 +1,7 @@ """ Some ascii art from https://www.asciiart.eu/, have fun! """ + # pylint: disable=invalid-name import hashlib diff --git a/tensorcircuit/backends/abstract_backend.py b/tensorcircuit/backends/abstract_backend.py index cf6884bc..4a7ccecd 100644 --- a/tensorcircuit/backends/abstract_backend.py +++ b/tensorcircuit/backends/abstract_backend.py @@ -1,6 +1,7 @@ """ Backend magic inherited from tensornetwork: abstract backend """ + # pylint: disable=invalid-name # pylint: disable=unused-variable @@ -1539,16 +1540,19 @@ def wrapper(*args: Any, **kws: Any) -> Any: args, tuple( [ - self.reshape( - self.eye(self.sizen(arg), dtype=arg.dtype), - [-1] + list(self.shape_tuple(arg)), - ) - if i == argnum - else self.reshape( - self.zeros( - [self.sizen(arg), self.sizen(arg)], dtype=arg.dtype - ), - [-1] + list(self.shape_tuple(arg)), + ( + self.reshape( + self.eye(self.sizen(arg), dtype=arg.dtype), + [-1] + list(self.shape_tuple(arg)), + ) + if i == argnum + else self.reshape( + self.zeros( + [self.sizen(arg), self.sizen(arg)], + dtype=arg.dtype, + ), + [-1] + list(self.shape_tuple(arg)), + ) ) for i, arg in enumerate(args) ] @@ -1607,16 +1611,18 @@ def _first(x: Sequence[Any]) -> Any: args, collect( [ - self.reshape( - self.eye(self.sizen(v), dtype=v.dtype), - [-1] + list(self.shape_tuple(v)), - ) - if i == k - else self.reshape( - self.zeros( - [self.sizen(v), self.sizen(v)], dtype=v.dtype - ), - [-1] + list(self.shape_tuple(v)), + ( + self.reshape( + self.eye(self.sizen(v), dtype=v.dtype), + [-1] + list(self.shape_tuple(v)), + ) + if i == k + else self.reshape( + self.zeros( + [self.sizen(v), self.sizen(v)], dtype=v.dtype + ), + [-1] + list(self.shape_tuple(v)), + ) ) for i, v in enumerate(values) ] diff --git a/tensorcircuit/backends/cupy_backend.py b/tensorcircuit/backends/cupy_backend.py index 4aa58d06..11260d19 100644 --- a/tensorcircuit/backends/cupy_backend.py +++ b/tensorcircuit/backends/cupy_backend.py @@ -1,6 +1,7 @@ """ CuPy backend. Not in the tensornetwork package and highly experimental. """ + # pylint: disable=invalid-name import logging diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 994f4bfc..581d8be7 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -1,6 +1,7 @@ """ Backend magic inherited from tensornetwork: jax backend """ + # pylint: disable=invalid-name from functools import partial diff --git a/tensorcircuit/backends/jax_ops.py b/tensorcircuit/backends/jax_ops.py index 57e86609..fcdc52a4 100644 --- a/tensorcircuit/backends/jax_ops.py +++ b/tensorcircuit/backends/jax_ops.py @@ -1,6 +1,7 @@ """ Customized ops for ML framework """ + # pylint: disable=invalid-name from typing import Any, Tuple, Sequence diff --git a/tensorcircuit/backends/numpy_backend.py b/tensorcircuit/backends/numpy_backend.py index 83ef3040..df3dc043 100644 --- a/tensorcircuit/backends/numpy_backend.py +++ b/tensorcircuit/backends/numpy_backend.py @@ -1,6 +1,7 @@ """ Backend magic inherited from tensornetwork: numpy backend """ + # pylint: disable=invalid-name import logging diff --git a/tensorcircuit/backends/pytorch_backend.py b/tensorcircuit/backends/pytorch_backend.py index 3256a44e..3214c72c 100644 --- a/tensorcircuit/backends/pytorch_backend.py +++ b/tensorcircuit/backends/pytorch_backend.py @@ -1,6 +1,7 @@ """ Backend magic inherited from tensornetwork: pytorch backend """ + # pylint: disable=invalid-name import logging diff --git a/tensorcircuit/backends/pytorch_ops.py b/tensorcircuit/backends/pytorch_ops.py index 182101fd..e801a4ca 100644 --- a/tensorcircuit/backends/pytorch_ops.py +++ b/tensorcircuit/backends/pytorch_ops.py @@ -1,6 +1,7 @@ """ Customized ops for ML framework """ + # pylint: disable=invalid-name from typing import Any diff --git a/tensorcircuit/backends/tensorflow_backend.py b/tensorcircuit/backends/tensorflow_backend.py index 632b558f..365bd521 100644 --- a/tensorcircuit/backends/tensorflow_backend.py +++ b/tensorcircuit/backends/tensorflow_backend.py @@ -1,6 +1,7 @@ """ Backend magic inherited from tensornetwork: tensorflow backend """ + # pylint: disable=invalid-name import os diff --git a/tensorcircuit/backends/tf_ops.py b/tensorcircuit/backends/tf_ops.py index 27327722..d7b6d380 100644 --- a/tensorcircuit/backends/tf_ops.py +++ b/tensorcircuit/backends/tf_ops.py @@ -1,6 +1,7 @@ """ Customized ops for ML framework """ + # pylint: disable=invalid-name from typing import Any diff --git a/tensorcircuit/basecircuit.py b/tensorcircuit/basecircuit.py index 65eac8d8..468c6a1b 100644 --- a/tensorcircuit/basecircuit.py +++ b/tensorcircuit/basecircuit.py @@ -1,6 +1,7 @@ """ Quantum circuit: common methods for all circuit classes as MixIn """ + # pylint: disable=invalid-name from typing import Any, Dict, List, Optional, Sequence, Tuple, Union diff --git a/tensorcircuit/circuit.py b/tensorcircuit/circuit.py index e07516cb..a293e3df 100644 --- a/tensorcircuit/circuit.py +++ b/tensorcircuit/circuit.py @@ -1,6 +1,7 @@ """ Quantum circuit: the state simulator """ + # pylint: disable=invalid-name from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple diff --git a/tensorcircuit/cloud/utils.py b/tensorcircuit/cloud/utils.py index 296e66df..fe15a56f 100644 --- a/tensorcircuit/cloud/utils.py +++ b/tensorcircuit/cloud/utils.py @@ -1,6 +1,7 @@ """ utility functions for cloud connection """ + from typing import Any, Callable, Optional from functools import wraps import inspect diff --git a/tensorcircuit/cloud/wrapper.py b/tensorcircuit/cloud/wrapper.py index 2ae2da20..f43f9ea9 100644 --- a/tensorcircuit/cloud/wrapper.py +++ b/tensorcircuit/cloud/wrapper.py @@ -1,6 +1,7 @@ """ higher level wrapper shortcut for submit_task """ + from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union import logging import time diff --git a/tensorcircuit/compiler/__init__.py b/tensorcircuit/compiler/__init__.py index 43f92b99..d5f812fe 100644 --- a/tensorcircuit/compiler/__init__.py +++ b/tensorcircuit/compiler/__init__.py @@ -2,6 +2,7 @@ Experimental module, no software agnostic unified interface for now, only reserve for internal use """ + from .composed_compiler import Compiler, DefaultCompiler, default_compile from . import simple_compiler from . import qiskit_compiler diff --git a/tensorcircuit/cons.py b/tensorcircuit/cons.py index e7e4bccf..c2ffa8f8 100644 --- a/tensorcircuit/cons.py +++ b/tensorcircuit/cons.py @@ -1,6 +1,7 @@ """ Constants and setups """ + # pylint: disable=invalid-name import logging diff --git a/tensorcircuit/densitymatrix.py b/tensorcircuit/densitymatrix.py index e70197dc..dc52fe4a 100644 --- a/tensorcircuit/densitymatrix.py +++ b/tensorcircuit/densitymatrix.py @@ -1,6 +1,7 @@ """ Quantum circuit class but with density matrix simulator """ + # pylint: disable=invalid-name from functools import reduce @@ -333,9 +334,11 @@ def apply_general_kraus( ) -> None: # incompatible API for now kraus = [ - k - if isinstance(k, tn.Node) - else Gate(backend.cast(backend.convert_to_tensor(k), dtypestr)) + ( + k + if isinstance(k, tn.Node) + else Gate(backend.cast(backend.convert_to_tensor(k), dtypestr)) + ) for k in kraus ] self.check_kraus(kraus) diff --git a/tensorcircuit/fgs.py b/tensorcircuit/fgs.py index e0e36d43..a7012701 100644 --- a/tensorcircuit/fgs.py +++ b/tensorcircuit/fgs.py @@ -1,6 +1,7 @@ """ Fermion Gaussian state simulator """ + from typing import Any, Dict, List, Optional, Tuple import numpy as np diff --git a/tensorcircuit/mps_base.py b/tensorcircuit/mps_base.py index ae05c7ad..d8234c2b 100644 --- a/tensorcircuit/mps_base.py +++ b/tensorcircuit/mps_base.py @@ -1,6 +1,7 @@ """ FiniteMPS from tensornetwork with bug fixed """ + # pylint: disable=invalid-name from typing import Any, Optional, List, Sequence diff --git a/tensorcircuit/mpscircuit.py b/tensorcircuit/mpscircuit.py index 1c6876ed..7fc4052e 100644 --- a/tensorcircuit/mpscircuit.py +++ b/tensorcircuit/mpscircuit.py @@ -1,6 +1,7 @@ """ Quantum circuit: MPS state simulator """ + # pylint: disable=invalid-name from functools import reduce diff --git a/tensorcircuit/noisemodel.py b/tensorcircuit/noisemodel.py index 0b03d966..9a1d85ac 100644 --- a/tensorcircuit/noisemodel.py +++ b/tensorcircuit/noisemodel.py @@ -1,6 +1,7 @@ """ General Noise Model Construction. """ + import logging from functools import partial from typing import Any, Sequence, Optional, List, Dict, Tuple, Callable, Union diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 383259c2..0d57362a 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -7,6 +7,7 @@ import tensorcircuit.quantum as qu """ + # pylint: disable=invalid-name import os diff --git a/tensorcircuit/results/counts.py b/tensorcircuit/results/counts.py index 9611ee4b..a4800cc4 100644 --- a/tensorcircuit/results/counts.py +++ b/tensorcircuit/results/counts.py @@ -1,6 +1,7 @@ """ dict related functionalities """ + from typing import Any, Dict, Optional, Sequence import numpy as np diff --git a/tensorcircuit/results/readout_mitigation.py b/tensorcircuit/results/readout_mitigation.py index ef205800..d701dcc1 100644 --- a/tensorcircuit/results/readout_mitigation.py +++ b/tensorcircuit/results/readout_mitigation.py @@ -1,6 +1,7 @@ """ readout error mitigation functionalities """ + # Part of the code in this file is from mthree: https://github.com/Qiskit-Partners/mthree (Apache2) # https://journals.aps.org/prxquantum/pdf/10.1103/PRXQuantum.2.040326 @@ -811,9 +812,11 @@ def expectation( ] else: diagonal_op = [ - [1, -1] @ inv_single_qubit_cals[i] - if i in z1 - else [1, 1] @ inv_single_qubit_cals[i] + ( + [1, -1] @ inv_single_qubit_cals[i] + if i in z1 + else [1, 1] @ inv_single_qubit_cals[i] + ) for i in range(n) ] diff --git a/tensorcircuit/simplify.py b/tensorcircuit/simplify.py index 6123c8dd..1cbcfc6a 100644 --- a/tensorcircuit/simplify.py +++ b/tensorcircuit/simplify.py @@ -1,6 +1,7 @@ """ Tensornetwork Simplification """ + # part of the implementations and ideas are inspired from # https://github.com/jcmgray/quimb/blob/a2968050eba5a8a04ced4bdaa5e43c4fb89edc33/quimb/tensor/tensor_core.py#L7309-L8293 # (Apache 2.0) diff --git a/tensorcircuit/templates/blocks.py b/tensorcircuit/templates/blocks.py index eacc2b42..1e376903 100644 --- a/tensorcircuit/templates/blocks.py +++ b/tensorcircuit/templates/blocks.py @@ -1,6 +1,7 @@ """ Shortcuts for measurement patterns on circuit """ + # circuit in, circuit out # pylint: disable=invalid-name diff --git a/tensorcircuit/templates/graphs.py b/tensorcircuit/templates/graphs.py index 4b2e1c9c..e382085c 100644 --- a/tensorcircuit/templates/graphs.py +++ b/tensorcircuit/templates/graphs.py @@ -1,6 +1,7 @@ """ Some common graphs and lattices """ + # pylint: disable=invalid-name from functools import partial diff --git a/tensorcircuit/templates/measurements.py b/tensorcircuit/templates/measurements.py index aca804d9..63f5c5b7 100644 --- a/tensorcircuit/templates/measurements.py +++ b/tensorcircuit/templates/measurements.py @@ -1,6 +1,7 @@ """ Shortcuts for measurement patterns on circuit """ + # circuit in, scalar out from typing import Any diff --git a/tensorcircuit/vis.py b/tensorcircuit/vis.py index 092216b8..19834d95 100644 --- a/tensorcircuit/vis.py +++ b/tensorcircuit/vis.py @@ -1,6 +1,7 @@ """ Visualization on circuits """ + import os import subprocess from uuid import uuid4 From 0339bf17de16e52a5c41cad2a034fb4f1ff87fdb Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 9 Feb 2024 19:02:56 +0800 Subject: [PATCH 682/725] fix jax breaking changes --- CHANGELOG.md | 2 ++ tensorcircuit/backends/jax_ops.py | 7 ++++--- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 54e26b8b..624458e7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,8 @@ - Fixed `cu` gate translation from qiskit to avoid qiskit bug +- Fixed jax refactoring (0.4.24) where SVD and QR return a namedtuple instead of a tuple + ## 0.11.0 ### Added diff --git a/tensorcircuit/backends/jax_ops.py b/tensorcircuit/backends/jax_ops.py index fcdc52a4..2eaf2f1b 100644 --- a/tensorcircuit/backends/jax_ops.py +++ b/tensorcircuit/backends/jax_ops.py @@ -14,7 +14,8 @@ @jax.custom_vjp def adaware_svd(A: Array) -> Any: - return jnp.linalg.svd(A, full_matrices=False) + u, s, v = jnp.linalg.svd(A, full_matrices=False) + return (u, s, v) def _safe_reciprocal(x: Array, epsilon: float = 1e-15) -> Array: @@ -77,8 +78,8 @@ def jaxsvd_bwd(r: Sequence[Array], tangents: Sequence[Array]) -> Tuple[Array]: @jax.custom_vjp def adaware_qr(A: Array) -> Any: - # q, r = jnp.linalg.qr(A) - return jnp.linalg.qr(A) + q, r = jnp.linalg.qr(A) + return (q, r) def jaxqr_fwd(A: Array) -> Any: From dafa300100e22e2802dc350113a9f5f87e64b5be Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 27 Feb 2024 10:37:32 +0800 Subject: [PATCH 683/725] fix qiskit<1.0 --- requirements/requirements-extra.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 024c584f..9475bddf 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,6 +1,6 @@ # extra dependencies for ci -qiskit -qiskit_aer +qiskit<1.0 +qiskit_aer<1.0 # qiskit-nature mitiq cirq From 2b7ed605ed19212d9e3dae936a477b2b09b5db00 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 11 Mar 2024 16:37:20 +0800 Subject: [PATCH 684/725] fix tf version --- requirements/requirements.txt | 2 +- tensorcircuit/applications/ai/ensemble.py | 3 +++ tests/test_ensemble.py | 4 ++++ 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 5deccf0d..97de418f 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,6 +1,6 @@ numpy scipy -tensorflow +tensorflow<2.16 # tf 2.16 with integration of keras 3 seems a disaster... tensornetwork-ng graphviz jax diff --git a/tensorcircuit/applications/ai/ensemble.py b/tensorcircuit/applications/ai/ensemble.py index 7946cb4c..d983ebf0 100644 --- a/tensorcircuit/applications/ai/ensemble.py +++ b/tensorcircuit/applications/ai/ensemble.py @@ -3,6 +3,7 @@ """ from typing import Any, List, Optional +from copy import deepcopy import tensorflow as tf import numpy as np @@ -53,10 +54,12 @@ def train(self, **kwargs: kwargus) -> None: def compile(self, **kwargs: kwargus) -> None: self.permit_train = True + for i in range(self.count): if not self.model_trained[i]: dict_kwargs = kwargs.copy() # TODO(@refraction-ray): still not compatible with new optimizer + # https://github.com/tensorflow/tensorflow/issues/58973 self.models[i].compile(**dict_kwargs) def __get_confidence(self, model_index: int, input: NDArray) -> NDArray: diff --git a/tests/test_ensemble.py b/tests/test_ensemble.py index 097789dc..92869fd8 100644 --- a/tests/test_ensemble.py +++ b/tests/test_ensemble.py @@ -2,6 +2,7 @@ import sys import tensorflow as tf import numpy as np +import pytest thisfile = os.path.abspath(__file__) modulepath = os.path.dirname(os.path.dirname(thisfile)) @@ -11,6 +12,9 @@ from tensorcircuit.applications.ai.ensemble import bagging +@pytest.mark.xfail( + int(tf.__version__.split(".")[1]) >= 16, reason="legacy optimizer fails tf>=2.16" +) def test_ensemble_bagging(): data_amount = 100 # Amount of data to be used linear_dimension = 4 # linear demension of the data From a5745a982fe3d8a3d81b8d460f6663933bf7a366 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 11 Mar 2024 16:55:40 +0800 Subject: [PATCH 685/725] pylint --- tensorcircuit/applications/ai/ensemble.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tensorcircuit/applications/ai/ensemble.py b/tensorcircuit/applications/ai/ensemble.py index d983ebf0..a9d6b0d7 100644 --- a/tensorcircuit/applications/ai/ensemble.py +++ b/tensorcircuit/applications/ai/ensemble.py @@ -3,7 +3,6 @@ """ from typing import Any, List, Optional -from copy import deepcopy import tensorflow as tf import numpy as np From b79dae4e559d8e90d9d2d7d785aeb38b2de275d2 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 11 Mar 2024 17:08:38 +0800 Subject: [PATCH 686/725] lock tf and qiskit in setup: two nonsense update with so many meaningless breaking changes, just pushing the users away... --- setup.py | 6 +++--- tensorcircuit/__init__.py | 11 +++++++++++ 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/setup.py b/setup.py index ac6d4d57..8e176a49 100644 --- a/setup.py +++ b/setup.py @@ -19,11 +19,11 @@ include_package_data=True, install_requires=["numpy", "scipy", "tensornetwork-ng", "networkx"], extras_require={ - "tensorflow": ["tensorflow"], + "tensorflow": ["tensorflow<2.16"], "jax": ["jax", "jaxlib"], "torch": ["torch"], - "qiskit": ["qiskit"], - "cloud": ["qiskit", "mthree"], + "qiskit": ["qiskit<1.0"], + "cloud": ["qiskit<1.0", "mthree"], }, classifiers=[ "Programming Language :: Python :: 3", diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index a3993163..8b2779d5 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -55,5 +55,16 @@ except ModuleNotFoundError: pass # in case torch is not installed +try: + import qiskit + + qiskit.QuantumCircuit.cnot = qiskit.QuantumCircuit.cx + qiskit.QuantumCircuit.toffoli = qiskit.QuantumCircuit.ccx + qiskit.QuantumCircuit.fredkin = qiskit.QuantumCircuit.cswap + + # amazing qiskit 1.0 nonsense... +except ModuleNotFoundError: + pass + # just for fun from .asciiart import set_ascii From b042a745d2708b2cc571b8c9c6b352b6b7d4920f Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 15 Mar 2024 10:12:38 +0800 Subject: [PATCH 687/725] version0.12.0 --- CHANGELOG.md | 4 ++++ README.md | 14 +++++++------- tensorcircuit/__init__.py | 2 +- 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 624458e7..b5318889 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +## 0.12.0 + ### Added - Add translation of r gate from qiskit @@ -28,6 +30,8 @@ - Fixed jax refactoring (0.4.24) where SVD and QR return a namedtuple instead of a tuple +- Fix qiskit<1.0 and tf<2.16 + ## 0.11.0 ### Added diff --git a/README.md b/README.md index 46a70c2a..cc532ff7 100644 --- a/README.md +++ b/README.md @@ -356,13 +356,13 @@ Reference paper: https://arxiv.org/abs/2303.10825 (published in JCTC). For the numerical simulation and hardware experiments with error mitigation on QAOA, see the [project repo](https://github.com/sherrylixuecheng/EMQAOA-DARBO). -Reference paper: https://arxiv.org/abs/2303.14877. +Reference paper: https://arxiv.org/abs/2303.14877 (published in Communications Physics). ### NN-VQA For the setup and simulation code of neural network encoded variational quantum eigensolver, see the [demo](/docs/source/tutorials/nnvqe.ipynb). -Reference paper: https://arxiv.org/abs/2308.01068. +Reference paper: https://arxiv.org/abs/2308.01068 (published in PRApplied). ### More works @@ -377,7 +377,7 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Variational Quantum Simulations of Finite-Temperature Dynamical Properties via Thermofield Dynamics: https://arxiv.org/abs/2206.05571. -- Understanding quantum machine learning also requires rethinking generalization: https://arxiv.org/abs/2306.13461. +- Understanding quantum machine learning also requires rethinking generalization: https://arxiv.org/abs/2306.13461 (published in Nature Communications). - Decentralized Quantum Federated Learning for Metaverse: Analysis, Design and Implementation: https://arxiv.org/abs/2306.11297. Code: https://github.com/s222416822/BQFL. @@ -385,7 +385,7 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Quantum generative adversarial imitation learning: https://doi.org/10.1088/1367-2630/acc605 (published in New Journal of Physics). -- GSQAS: Graph Self-supervised Quantum Architecture Search: https://arxiv.org/abs/2303.12381. +- GSQAS: Graph Self-supervised Quantum Architecture Search: https://arxiv.org/abs/2303.12381 (published in Physica A: Statistical Mechanics and its Applications). - Practical advantage of quantum machine learning in ghost imaging: https://www.nature.com/articles/s42005-023-01290-1 (published in Communications Physics). @@ -393,15 +393,15 @@ Reference paper: https://arxiv.org/abs/2308.01068. - Comparison of Quantum Simulators for Variational Quantum Search: A Benchmark Study: https://arxiv.org/abs/2309.05924. -- Statistical analysis of quantum state learning process in quantum neural networks: https://arxiv.org/abs/2309.14980 (Pubilshed in NeurIPS). +- Statistical analysis of quantum state learning process in quantum neural networks: https://arxiv.org/abs/2309.14980 (published in NeurIPS). -- Generative quantum machine learning via denoising diffusion probabilistic models: https://arxiv.org/abs/2310.05866. +- Generative quantum machine learning via denoising diffusion probabilistic models: https://arxiv.org/abs/2310.05866 (published in PRL). - Quantum imaginary time evolution and quantum annealing meet topological sector optimization: https://arxiv.org/abs/2310.04291. - Google Summer of Code 2023 Projects (QML4HEP): https://github.com/ML4SCI/QMLHEP, https://github.com/Gopal-Dahale/qgnn-hep, https://github.com/salcc/QuantumTransformers. -- Absence of barren plateaus in finite local-depth circuits with long-range entanglement: https://arxiv.org/abs/2311.01393. +- Absence of barren plateaus in finite local-depth circuits with long-range entanglement: https://arxiv.org/abs/2311.01393 (published in PRL). - Non-Markovianity benefits quantum dynamics simulation: https://arxiv.org/abs/2311.17622. diff --git a/tensorcircuit/__init__.py b/tensorcircuit/__init__.py index 8b2779d5..fb1c2e40 100644 --- a/tensorcircuit/__init__.py +++ b/tensorcircuit/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.11.0" +__version__ = "0.12.0" __author__ = "TensorCircuit Authors" __creator__ = "refraction-ray" From 0565d5eac3be7916f6954f584c5362d932e09da4 Mon Sep 17 00:00:00 2001 From: king-p3nguin Date: Sun, 7 Apr 2024 05:27:21 +0900 Subject: [PATCH 688/725] allow various parameterexpressions --- requirements/requirements-extra.txt | 4 +- tensorcircuit/abstractcircuit.py | 12 ++-- tensorcircuit/translation.py | 86 ++++++++++++++--------------- tests/test_circuit.py | 41 +++++++++----- 4 files changed, 77 insertions(+), 66 deletions(-) diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index 9475bddf..e5cd85a8 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -1,7 +1,7 @@ # extra dependencies for ci qiskit<1.0 -qiskit_aer<1.0 -# qiskit-nature +qiskit-aer<1.0 +qiskit-nature mitiq cirq torch diff --git a/tensorcircuit/abstractcircuit.py b/tensorcircuit/abstractcircuit.py index ac2b9116..2334aa39 100644 --- a/tensorcircuit/abstractcircuit.py +++ b/tensorcircuit/abstractcircuit.py @@ -4,21 +4,21 @@ # pylint: disable=invalid-name -from typing import Any, Callable, Dict, List, Optional, Sequence, Union, Tuple +import json +import logging from copy import deepcopy from functools import reduce from operator import add -import json -import logging +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union import numpy as np import tensornetwork as tn from . import gates from .cons import backend, dtypestr -from .vis import qir2tex from .quantum import QuOperator from .utils import is_sequence +from .vis import qir2tex logger = logging.getLogger(__name__) @@ -756,7 +756,7 @@ def to_qiskit( :type enable_inputs: bool, defaults to False :return: A qiskit object of this circuit. """ - from .translation import qir2qiskit, perm_matrix + from .translation import perm_matrix, qir2qiskit qir = self.to_qir() if enable_instruction: @@ -887,7 +887,7 @@ def from_qiskit( n = qc.num_qubits return qiskit2tc( # type: ignore - qc.data, + qc, n, inputs, circuit_constructor=cls, diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index e297113d..fcef21d4 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -2,23 +2,26 @@ Circuit object translation in different packages """ -from typing import Any, Dict, List, Optional, Tuple, Union, Sequence -from copy import deepcopy import logging +from copy import deepcopy +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union + import numpy as np logger = logging.getLogger(__name__) try: + import qiskit.quantum_info as qi + import symengine + import sympy from qiskit import QuantumCircuit + from qiskit.circuit import Parameter, ParameterExpression from qiskit.circuit.library import XXPlusYYGate + from qiskit.circuit.parametervector import ParameterVectorElement + from qiskit.circuit.quantumcircuitdata import CircuitInstruction from qiskit.extensions import UnitaryGate - import qiskit.quantum_info as qi from qiskit.extensions.exceptions import ExtensionError - from qiskit.circuit.quantumcircuitdata import CircuitInstruction - from qiskit.circuit.parametervector import ParameterVectorElement - from qiskit.circuit import Parameter, ParameterExpression except ImportError: logger.warning( "Please first ``pip install -U qiskit`` to enable related functionality in translation module" @@ -34,11 +37,10 @@ from . import gates from .circuit import Circuit -from .densitymatrix import DMCircuit2 from .cons import backend +from .densitymatrix import DMCircuit2 from .interfaces.tensortrans import tensor_to_numpy - Tensor = Any @@ -358,7 +360,7 @@ def _translate_qiskit_params( gate_info: CircuitInstruction, binding_params: Any ) -> List[float]: parameters = [] - for p in gate_info[0].params: + for p in gate_info.operation.params: if isinstance(p, ParameterVectorElement): parameters.append(binding_params[p.index]) elif isinstance(p, Parameter): @@ -367,30 +369,29 @@ def _translate_qiskit_params( if len(p.parameters) == 0: parameters.append(float(p)) continue - if len(p.parameters) != 1: - raise ValueError( - f"Can't translate parameter expression with more than 1 parameters: {p}" - ) - p_real = list(p.parameters)[0] - if not isinstance(p_real, ParameterVectorElement): - raise TypeError( - "Parameters in parameter expression should be ParameterVectorElement" - ) + # note "sym" != "sim" expr = p.sympify().simplify() - # only allow simple expressions like 1.0 * theta - if not expr.is_Mul: - raise ValueError(f"Unsupported parameter expression: {p}") - arg1, arg2 = expr.args - if arg1.is_number and arg2.is_symbol: - coeff = arg1 - elif arg1.is_symbol and arg2.is_number: - coeff = arg2 - else: - raise ValueError(f"Unsupported parameter expression: {p}") - # taking real part here because using complex type will result in a type error - # for tf backend when the binding parameter is real - parameters.append(float(coeff) * binding_params[p_real.index]) + if isinstance(expr, symengine.Expr): # qiskit uses symengine if available + expr = expr._sympy_() # sympy.Expr + + for free_symbol in expr.free_symbols: + # replace names: theta[0] -> theta_0 + # ParameterVector creates symbols with brackets like theta[0] + # but sympy.lambdify does not allow brackets in symbol names + free_symbol.name = free_symbol.name.replace("[", "_").replace("]", "") + + parameter_list = list(p.parameters) + sympy_symbols = [param._symbol_expr for param in parameter_list] + # replace names again: theta[0] -> theta_0 + sympy_symbols = [ + sympy.Symbol(str(symbol).replace("[", "_").replace("]", "")) + for symbol in sympy_symbols + ] + lam_f = sympy.lambdify(sympy_symbols, expr, modules=backend.name) + parameters.append( + lam_f(*[binding_params[param.index] for param in parameter_list]) + ) else: # numbers, arrays, etc. parameters.append(p) @@ -403,7 +404,7 @@ def ctrl_str2ctrl_state(ctrl_str: str, nctrl: int) -> List[int]: def qiskit2tc( - qcdata: List[CircuitInstruction], + qc: QuantumCircuit, n: int, inputs: Optional[List[float]] = None, is_dm: bool = False, @@ -412,19 +413,18 @@ def qiskit2tc( binding_params: Optional[Union[Sequence[float], Dict[Any, float]]] = None, ) -> Any: r""" - Generate a tensorcircuit circuit using the quantum circuit data in qiskit. + Generate a tensorcircuit circuit from the qiskit circuit. :Example: >>> qisc = QuantumCircuit(2) >>> qisc.h(0) >>> qisc.x(1) - >>> qc = tc.translation.qiskit2tc(qisc.data, 2) + >>> qc = tc.translation.qiskit2tc(qisc, 2) >>> qc.to_qir()[0]['gatef'] - h - :param qcdata: Quantum circuit data from qiskit. - :type qcdata: List[CircuitInstruction] + :param qc: A quantum circuit in qiskit. + :type qc: QuantumCircuit :param n: # of qubits :type n: int :param inputs: Input state of the circuit. Default is None. @@ -435,7 +435,7 @@ def qiskit2tc( :type circuit_params: Optional[Dict[str, Any]] :param binding_params: (variational) parameters for the circuit. Could be either a sequence or dictionary depending on the type of parameters in the Qiskit circuit. - For ``ParameterVectorElement`` use sequence. For ``Parameter`` use dictionary + For ``ParameterVectorElement`` use sequence. For ``Parameter`` use dictionary. :type binding_params: Optional[Union[Sequence[float], Dict[Any, float]]] :return: A quantum circuit in tensorcircuit :rtype: Any @@ -451,17 +451,17 @@ def qiskit2tc( if "nqubits" not in circuit_params: circuit_params["nqubits"] = n if ( - len(qcdata) > 0 - and qcdata[0][0].name == "initialize" + len(qc.data) > 0 + and qc.data[0][0].name == "initialize" and "inputs" not in circuit_params ): - circuit_params["inputs"] = perm_matrix(n) @ np.array(qcdata[0][0].params) + circuit_params["inputs"] = perm_matrix(n) @ np.array(qc.data[0][0].params) if inputs is not None: circuit_params["inputs"] = inputs tc_circuit: Any = Circ(**circuit_params) - for gate_info in qcdata: - idx = [qb.index for qb in gate_info[1]] + for gate_info in qc.data: + idx = [qc.find_bit(qb).index for qb in gate_info.qubits] gate_name = gate_info[0].name parameters = _translate_qiskit_params(gate_info, binding_params) if gate_name in [ diff --git a/tests/test_circuit.py b/tests/test_circuit.py index cb67eb36..b1d45dd6 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1,8 +1,9 @@ # pylint: disable=invalid-name -import sys import os +import sys from functools import partial + import numpy as np import opt_einsum as oem import pytest @@ -975,6 +976,7 @@ def test_qir2cirq(backend): def test_qir2qiskit(backend): try: import qiskit.quantum_info as qi + from tensorcircuit.translation import perm_matrix except ImportError: pytest.skip("qiskit is not installed") @@ -1074,9 +1076,10 @@ def test_qir2qiskit(backend): def test_qiskit2tc(): try: - from qiskit import QuantumCircuit import qiskit.quantum_info as qi + from qiskit import QuantumCircuit from qiskit.circuit.library.standard_gates import MCXGate, SwapGate + from tensorcircuit.translation import perm_matrix except ImportError: pytest.skip("qiskit is not installed") @@ -1149,26 +1152,34 @@ def test_qiskit2tc(): @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) def test_qiskit2tc_parameterized(backend): try: - from qiskit.circuit import QuantumCircuit, Parameter - from qiskit.quantum_info import Operator + from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit from qiskit.circuit.library import TwoLocal + from qiskit.quantum_info import Operator from qiskit_nature.second_q.circuit.library import UCCSD - from qiskit_nature.second_q.mappers import ParityMapper, QubitConverter + from qiskit_nature.second_q.mappers import ParityMapper except ImportError: pytest.skip("qiskit or qiskit-nature is not installed") from tensorcircuit.translation import perm_matrix mapper = ParityMapper() - converter = QubitConverter(mapper=mapper, two_qubit_reduction=True) - ansatz1 = UCCSD(2, [1, 1], converter) + ansatz1 = UCCSD(2, [1, 1], mapper) ansatz2 = TwoLocal(2, rotation_blocks="ry", entanglement_blocks="cz") ansatz3 = QuantumCircuit(1) ansatz3_param = Parameter("θ") ansatz3.rx(ansatz3_param, 0) - ansatz_list = [ansatz1, ansatz2, ansatz3] + ansatz4 = QuantumCircuit(1) + ansatz4_param = ParameterVector("φ", 3) + ansatz4.rx(2.0 * ansatz4_param[0] + 5.0, 0) + ansatz4.ry(ansatz4_param[0] * ansatz4_param[1] + ansatz4_param[2], 0) + ansatz4.rz( + np.exp(np.sin(ansatz4_param[0])) + + np.abs(ansatz4_param[1]) / np.arctan(ansatz4_param[2]), + 0, + ) + ansatz_list = [ansatz1, ansatz2, ansatz3, ansatz4] for ansatz in ansatz_list: n = ansatz.num_qubits - if ansatz in [ansatz1, ansatz2]: + if ansatz in [ansatz1, ansatz2, ansatz4]: params = np.random.rand(ansatz.num_parameters) else: params = {ansatz3_param: 0.618} @@ -1178,9 +1189,9 @@ def test_qiskit2tc_parameterized(backend): # test jit @tc.backend.jit - def get_unitary(_params): + def get_unitary(params): return tc.Circuit.from_qiskit( - ansatz, inputs=np.eye(2**n), binding_params=_params + ansatz, inputs=np.eye(2**n), binding_params=params ).state() tc_unitary = get_unitary(params) @@ -1191,10 +1202,10 @@ def get_unitary(_params): ) # test grad - def cost_fn(_params): - return tc.backend.real(tc.backend.sum(get_unitary(_params))) + def cost_fn(params): + return tc.backend.real(tc.backend.sum(get_unitary(params))) - if ansatz in [ansatz1, ansatz2]: + if ansatz in [ansatz1, ansatz2, ansatz4]: grad = tc.backend.grad(cost_fn)(tc.backend.convert_to_tensor(params)) assert np.sum(np.isnan(grad)) == 0 else: @@ -1208,8 +1219,8 @@ def cost_fn(_params): @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) def test_qiskit_vs_tc_intialization(backend): try: - from qiskit import QuantumCircuit import qiskit.quantum_info as qi + from qiskit import QuantumCircuit except ImportError: pytest.skip("qiskit is not installed") From 908e5e7fd810720b1ef5824ad43054e7adfad19e Mon Sep 17 00:00:00 2001 From: king-p3nguin Date: Sun, 7 Apr 2024 16:46:27 +0900 Subject: [PATCH 689/725] support pytorch backend (kind of) --- tensorcircuit/translation.py | 12 +++++++++++- tests/test_circuit.py | 17 +++++++++-------- 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index fcef21d4..17629db4 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -375,6 +375,16 @@ def _translate_qiskit_params( if isinstance(expr, symengine.Expr): # qiskit uses symengine if available expr = expr._sympy_() # sympy.Expr + if expr.is_algebraic_expr(): # numpy ufuncs are not used + lambdify_module_name = "numpy" + else: + if backend.name == "pytorch": + raise ValueError( + "pytorch backend does not support sympy lambdify with non-algebraic expressions" + ) + else: + lambdify_module_name = backend.name + for free_symbol in expr.free_symbols: # replace names: theta[0] -> theta_0 # ParameterVector creates symbols with brackets like theta[0] @@ -388,7 +398,7 @@ def _translate_qiskit_params( sympy.Symbol(str(symbol).replace("[", "_").replace("]", "")) for symbol in sympy_symbols ] - lam_f = sympy.lambdify(sympy_symbols, expr, modules=backend.name) + lam_f = sympy.lambdify(sympy_symbols, expr, modules=lambdify_module_name) parameters.append( lam_f(*[binding_params[param.index] for param in parameter_list]) ) diff --git a/tests/test_circuit.py b/tests/test_circuit.py index b1d45dd6..f395ed94 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1149,7 +1149,7 @@ def test_qiskit2tc(): np.testing.assert_allclose(qis_unitary2, qis_unitary, atol=1e-5) -@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb")]) +@pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("torchb")]) def test_qiskit2tc_parameterized(backend): try: from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit @@ -1171,11 +1171,12 @@ def test_qiskit2tc_parameterized(backend): ansatz4_param = ParameterVector("φ", 3) ansatz4.rx(2.0 * ansatz4_param[0] + 5.0, 0) ansatz4.ry(ansatz4_param[0] * ansatz4_param[1] + ansatz4_param[2], 0) - ansatz4.rz( - np.exp(np.sin(ansatz4_param[0])) - + np.abs(ansatz4_param[1]) / np.arctan(ansatz4_param[2]), - 0, - ) + if tc.backend.name != "pytorch": # pytorch backend with ufuncs is not supported + ansatz4.rz( + np.exp(np.sin(ansatz4_param[0])) + + np.abs(ansatz4_param[1]) / np.arctan(ansatz4_param[2]), + 0, + ) ansatz_list = [ansatz1, ansatz2, ansatz3, ansatz4] for ansatz in ansatz_list: n = ansatz.num_qubits @@ -1196,7 +1197,7 @@ def get_unitary(params): tc_unitary = get_unitary(params) tc_unitary = np.reshape(tc_unitary, [2**n, 2**n]) - p_mat = perm_matrix(n) + p_mat = tc.array_to_tensor(perm_matrix(n)) np.testing.assert_allclose( p_mat @ tc_unitary @ p_mat, qiskit_unitary, atol=1e-5 ) @@ -1207,7 +1208,7 @@ def cost_fn(params): if ansatz in [ansatz1, ansatz2, ansatz4]: grad = tc.backend.grad(cost_fn)(tc.backend.convert_to_tensor(params)) - assert np.sum(np.isnan(grad)) == 0 + assert tc.backend.sum(tc.num_to_tensor(np.isnan(grad))) == 0 else: # tf only supports tf tensor as input grad = tc.backend.grad(cost_fn)( From 77721d401b78785ba4a52f221f2bad7e94725ec5 Mon Sep 17 00:00:00 2001 From: king-p3nguin Date: Sun, 7 Apr 2024 21:54:12 +0900 Subject: [PATCH 690/725] use math for pytorch backend --- tensorcircuit/translation.py | 4 +--- tests/test_circuit.py | 11 +++++------ 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 17629db4..992eed39 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -379,9 +379,7 @@ def _translate_qiskit_params( lambdify_module_name = "numpy" else: if backend.name == "pytorch": - raise ValueError( - "pytorch backend does not support sympy lambdify with non-algebraic expressions" - ) + lambdify_module_name = "math" else: lambdify_module_name = backend.name diff --git a/tests/test_circuit.py b/tests/test_circuit.py index f395ed94..16bc4844 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1171,12 +1171,11 @@ def test_qiskit2tc_parameterized(backend): ansatz4_param = ParameterVector("φ", 3) ansatz4.rx(2.0 * ansatz4_param[0] + 5.0, 0) ansatz4.ry(ansatz4_param[0] * ansatz4_param[1] + ansatz4_param[2], 0) - if tc.backend.name != "pytorch": # pytorch backend with ufuncs is not supported - ansatz4.rz( - np.exp(np.sin(ansatz4_param[0])) - + np.abs(ansatz4_param[1]) / np.arctan(ansatz4_param[2]), - 0, - ) + ansatz4.rz( + np.exp(np.sin(ansatz4_param[0])) + + np.abs(ansatz4_param[1]) / np.arctan(ansatz4_param[2]), + 0, + ) ansatz_list = [ansatz1, ansatz2, ansatz3, ansatz4] for ansatz in ansatz_list: n = ansatz.num_qubits From 8738dc993dfd2a375382286e341c6519d6b760b9 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 8 Apr 2024 09:54:48 +0800 Subject: [PATCH 691/725] update changelog --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b5318889..3f072c9a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Added + +- Add support for parameter expression in qiskit translation + ## 0.12.0 ### Added From 93d1d3beec6aaae12180a5ea2e7a14f0e58463dd Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Mon, 8 Apr 2024 01:57:27 +0000 Subject: [PATCH 692/725] docs: update README.md [skip ci] --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index cc532ff7..845a6750 100644 --- a/README.md +++ b/README.md @@ -297,7 +297,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. ztzhu
ztzhu
💻 Rabqubit
Rabqubit
💡 - Kazuki Tsuoka
Kazuki Tsuoka
💻 + Kazuki Tsuoka
Kazuki Tsuoka
💻 ⚠️ 📖 From fb13030c460ae2f1ab35f47179fd169467dbed85 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Mon, 8 Apr 2024 01:57:28 +0000 Subject: [PATCH 693/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index 4b928ff4..2afd3367 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -307,7 +307,9 @@ "avatar_url": "https://avatars.githubusercontent.com/u/103920010?v=4", "profile": "https://github.com/king-p3nguin", "contributions": [ - "code" + "code", + "test", + "doc" ] } ], From 5c0c768ebaeb6ee82f82581cd79d37231b1709a3 Mon Sep 17 00:00:00 2001 From: king-p3nguin Date: Tue, 9 Apr 2024 09:01:33 +0900 Subject: [PATCH 694/725] fix dep warnings --- tensorcircuit/backends/jax_backend.py | 13 +++++++------ tensorcircuit/compiler/qiskit_compiler.py | 13 +++++++------ tensorcircuit/translation.py | 12 +++++------- tests/test_circuit.py | 4 +++- 4 files changed, 22 insertions(+), 20 deletions(-) diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index 581d8be7..f19c23ce 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -4,15 +4,16 @@ # pylint: disable=invalid-name -from functools import partial import logging import warnings +from functools import partial from typing import Any, Callable, Optional, Sequence, Tuple, Union import numpy as np -from scipy.sparse import coo_matrix import tensornetwork +from scipy.sparse import coo_matrix from tensornetwork.backends.jax import jax_backend + from .abstract_backend import ExtendedBackend logger = logging.getLogger(__name__) @@ -196,8 +197,8 @@ def __init__(self) -> None: "Jax not installed, please switch to a different " "backend or install Jax." ) - from jax.experimental import sparse import jax.scipy + from jax.experimental import sparse try: import optax @@ -419,7 +420,7 @@ def searchsorted(self, a: Tensor, v: Tensor, side: str = "left") -> Tensor: return jnp.searchsorted(a, v, side) def tree_map(self, f: Callable[..., Any], *pytrees: Any) -> Any: - return libjax.tree_map(f, *pytrees) + return libjax.tree_util.tree_map(f, *pytrees) def tree_flatten(self, pytree: Any) -> Tuple[Any, Any]: return libjax.tree_util.tree_flatten(pytree) # type: ignore @@ -630,7 +631,7 @@ def is_sparse(self, a: Tensor) -> bool: return isinstance(a, sparse.BCOO) # type: ignore def device(self, a: Tensor) -> str: - dev = a.device() + dev = a.devices() return self._dev2str(dev) def device_move(self, a: Tensor, dev: Any) -> Tensor: @@ -757,7 +758,7 @@ def wrapper( gs = list(gs) for i, (j, g) in enumerate(zip(argnums_list, gs)): if j not in vectorized_argnums: # type: ignore - gs[i] = libjax.tree_map(partial(jnp.sum, axis=0), g) + gs[i] = libjax.tree_util.tree_map(partial(jnp.sum, axis=0), g) if isinstance(argnums, int): gs = gs[0] else: diff --git a/tensorcircuit/compiler/qiskit_compiler.py b/tensorcircuit/compiler/qiskit_compiler.py index e54dd1a4..1f946359 100644 --- a/tensorcircuit/compiler/qiskit_compiler.py +++ b/tensorcircuit/compiler/qiskit_compiler.py @@ -2,8 +2,8 @@ compiler interface via qiskit """ -from typing import Any, Dict, Optional import re +from typing import Any, Dict, Optional from ..abstractcircuit import AbstractCircuit from ..circuit import Circuit @@ -71,7 +71,7 @@ def _get_positional_logical_mapping_from_qiskit(qc: Any) -> Dict[int, int]: positional_logical_mapping = {} for inst in qc.data: if inst[0].name == "measure": - positional_logical_mapping[i] = inst[1][0].index + positional_logical_mapping[i] = qc.find_bit(inst[1][0]).index i += 1 return positional_logical_mapping @@ -95,16 +95,17 @@ def _get_logical_physical_mapping_from_qiskit( for inst in qc_after.data: if inst[0].name == "measure": if qc_before is None: - logical_q = inst[2][0].index + logical_q = qc_after.find_bit(inst[2][0]).index else: for instb in qc_before.data: if ( instb[0].name == "measure" - and instb[2][0].index == inst[2][0].index + and qc_before.find_bit(instb[2][0]).index + == qc_after.find_bit(inst[2][0]).index ): - logical_q = instb[1][0].index + logical_q = qc_before.find_bit(instb[1][0]).index break - logical_physical_mapping[logical_q] = inst[1][0].index + logical_physical_mapping[logical_q] = qc_after.find_bit(inst[1][0]).index return logical_physical_mapping diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 992eed39..c6ca1e0e 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -17,11 +17,10 @@ import sympy from qiskit import QuantumCircuit from qiskit.circuit import Parameter, ParameterExpression - from qiskit.circuit.library import XXPlusYYGate + from qiskit.circuit.exceptions import CircuitError + from qiskit.circuit.library import HamiltonianGate, UnitaryGate, XXPlusYYGate from qiskit.circuit.parametervector import ParameterVectorElement from qiskit.circuit.quantumcircuitdata import CircuitInstruction - from qiskit.extensions import UnitaryGate - from qiskit.extensions.exceptions import ExtensionError except ImportError: logger.warning( "Please first ``pip install -U qiskit`` to enable related functionality in translation module" @@ -311,9 +310,8 @@ def qir2qiskit( # Error can be presented if theta is actually complex in this procedure. exp_op = qi.Operator(unitary) index_reversed = [x for x in index[::-1]] - qiskit_circ.hamiltonian( - exp_op, time=theta, qubits=index_reversed, label=qis_name - ) + gate = HamiltonianGate(data=exp_op, time=theta, label=qis_name) + qiskit_circ.append(gate, index_reversed) elif gate_name == "multicontrol": unitary = backend.numpy(backend.convert_to_tensor(parameters["unitary"])) ctrl_str = "".join(map(str, parameters["ctrl"]))[::-1] @@ -344,7 +342,7 @@ def qir2qiskit( qop = qi.Operator(gatem) try: qiskit_circ.unitary(qop, index[::-1], label=qis_name) - except (ExtensionError, ValueError) as _: + except (CircuitError, ValueError) as _: logger.warning( "omit non unitary gate in tensorcircuit when transforming to qiskit: %s" % gate_name diff --git a/tests/test_circuit.py b/tests/test_circuit.py index 16bc4844..81f20762 100644 --- a/tests/test_circuit.py +++ b/tests/test_circuit.py @@ -1078,6 +1078,7 @@ def test_qiskit2tc(): try: import qiskit.quantum_info as qi from qiskit import QuantumCircuit + from qiskit.circuit.library import HamiltonianGate from qiskit.circuit.library.standard_gates import MCXGate, SwapGate from tensorcircuit.translation import perm_matrix @@ -1090,7 +1091,8 @@ def test_qiskit2tc(): zz = np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]]) exp_op = qi.Operator(zz) for i in range(n): - qisc.hamiltonian(exp_op, time=np.random.uniform(), qubits=[i, (i + 1) % n]) + gate = HamiltonianGate(exp_op, time=np.random.uniform()) + qisc.append(gate, [i, (i + 1) % n]) qisc.fredkin(1, 2, 3) qisc.cswap(1, 2, 3) qisc.swap(0, 1) From 3a748305ca123ab074055f18cf63aa0afbf7bf5f Mon Sep 17 00:00:00 2001 From: king-p3nguin Date: Tue, 9 Apr 2024 09:49:09 +0900 Subject: [PATCH 695/725] fix test --- tensorcircuit/backends/jax_backend.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/backends/jax_backend.py b/tensorcircuit/backends/jax_backend.py index f19c23ce..33be28fd 100644 --- a/tensorcircuit/backends/jax_backend.py +++ b/tensorcircuit/backends/jax_backend.py @@ -631,7 +631,7 @@ def is_sparse(self, a: Tensor) -> bool: return isinstance(a, sparse.BCOO) # type: ignore def device(self, a: Tensor) -> str: - dev = a.devices() + (dev,) = a.devices() return self._dev2str(dev) def device_move(self, a: Tensor, dev: Any) -> Tensor: From be721a24e1fe617c31499c223d6ec9213975cebd Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 9 Apr 2024 16:45:13 +0800 Subject: [PATCH 696/725] fix some bug when qiskit or cirq is not installed --- tensorcircuit/results/qem/qem_methods.py | 3 ++- tensorcircuit/translation.py | 1 + tests/test_torchnn.py | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/tensorcircuit/results/qem/qem_methods.py b/tensorcircuit/results/qem/qem_methods.py index 7328b3bb..68199e49 100644 --- a/tensorcircuit/results/qem/qem_methods.py +++ b/tensorcircuit/results/qem/qem_methods.py @@ -14,7 +14,6 @@ logger = logging.getLogger(__name__) import numpy as np -import cirq try: from mitiq import zne, ddd @@ -205,6 +204,8 @@ def dd_rule(slack_length: int, spacing: int = -1) -> Any: return dd_sequence if isinstance(rule, list): + import cirq + gates = [] for i in rule: gates.append(getattr(cirq, i)) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 992eed39..70276c58 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -27,6 +27,7 @@ "Please first ``pip install -U qiskit`` to enable related functionality in translation module" ) CircuitInstruction = Any + QuantumCircuit = Any try: import cirq diff --git a/tests/test_torchnn.py b/tests/test_torchnn.py index 6acb7b17..88549248 100644 --- a/tests/test_torchnn.py +++ b/tests/test_torchnn.py @@ -14,7 +14,7 @@ try: import torch except ImportError: - pytest.skip("torch is not installed") + pytest.skip("torch is not installed", allow_module_level=True) @pytest.mark.parametrize("backend", [lf("tfb"), lf("jaxb"), lf("torchb")]) From a7dc3cb13b512eefd6debcce596a109a8a6a99e3 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Tue, 9 Apr 2024 17:27:50 +0800 Subject: [PATCH 697/725] give specific reason on disable tf2.16+ --- tests/test_keras.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/test_keras.py b/tests/test_keras.py index 187a316e..3564f828 100644 --- a/tests/test_keras.py +++ b/tests/test_keras.py @@ -129,6 +129,9 @@ def qf(inputs, param): def test_keras_layer_inputs_dict(tfb): + # https://github.com/tensorflow/tensorflow/issues/65306 + # keras3 for tf2.16+ fails to accept complex valued input for keras layers + # which is vital for quantum applications n = 3 p = 0.1 K = tc.backend From 7bd91c0d0e54bcd3bee4cded970c4fc9f1cadca1 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Wed, 10 Apr 2024 14:24:23 +0800 Subject: [PATCH 698/725] warning to info with no cirq --- tensorcircuit/translation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorcircuit/translation.py b/tensorcircuit/translation.py index 42a2fe57..73b973b6 100644 --- a/tensorcircuit/translation.py +++ b/tensorcircuit/translation.py @@ -31,7 +31,7 @@ try: import cirq except ImportError: - logger.warning( + logger.info( "Please first ``pip install -U cirq`` to enable related functionality in translation module" ) From 229b018fdbe6d1fe582a49d21563392b6a48e7b3 Mon Sep 17 00:00:00 2001 From: Gopal Dahale Date: Wed, 29 May 2024 23:49:40 +0530 Subject: [PATCH 699/725] vqe noisyopt --- examples/vqe_noisyopt.py | 194 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 examples/vqe_noisyopt.py diff --git a/examples/vqe_noisyopt.py b/examples/vqe_noisyopt.py new file mode 100644 index 00000000..8fa06bd3 --- /dev/null +++ b/examples/vqe_noisyopt.py @@ -0,0 +1,194 @@ +""" +VQE with finite measurement shot noise +""" + +from functools import partial +import numpy as np +from scipy import optimize +import optax +import tensorcircuit as tc +from tensorcircuit import experimental as E +from noisyopt import minimizeCompass, minimizeSPSA +from tabulate import tabulate + +seed = 42 +np.random.seed(seed) + +K = tc.set_backend("jax") +# note this script only supports jax backend + +n = 6 +nlayers = 4 + +result = { + "Algorithm / Optimization": ["Without Shot Noise", "With Shot Noise"], + "Gradient Free": [], + "Gradient based": [], +} + +# We use OBC 1D TFIM Hamiltonian in this script + +ps = [] +for i in range(n): + l = [0 for _ in range(n)] + l[i] = 1 + ps.append(l) + # X_i +for i in range(n - 1): + l = [0 for _ in range(n)] + l[i] = 3 + l[i + 1] = 3 + ps.append(l) + # Z_i Z_i+1 +w = [-1.0 for _ in range(n)] + [1.0 for _ in range(n - 1)] + + +def generate_circuit(param): + # construct the circuit ansatz + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayers): + for i in range(n - 1): + c.rzz(i, i + 1, theta=param[i, j, 0]) + for i in range(n): + c.rx(i, theta=param[i, j, 1]) + return c + + +def ps2xyz(psi): + # ps2xyz([1, 2, 2, 0]) = {"x": [0], "y": [1, 2], "z": []} + xyz = {"x": [], "y": [], "z": []} + for i, j in enumerate(psi): + if j == 1: + xyz["x"].append(i) + if j == 2: + xyz["y"].append(i) + if j == 3: + xyz["z"].append(i) + return xyz + + +@partial(K.jit, static_argnums=(2)) +def exp_val(param, key, shots=1024): + # expectation with shot noise + # ps, w: H = \sum_i w_i ps_i + # describing the system Hamiltonian as a weighted sum of Pauli string + c = generate_circuit(param) + if isinstance(shots, int): + shots = [shots for _ in range(len(ps))] + loss = 0 + for psi, wi, shot in zip(ps, w, shots): + key, subkey = K.random_split(key) + xyz = ps2xyz(psi) + loss += wi * c.sample_expectation_ps(**xyz, shots=shot, random_generator=subkey) + return K.real(loss) + + +@K.jit +def exp_val_analytical(param): + param = param.reshape(n, nlayers, 2) + c = generate_circuit(param) + loss = 0 + for psi, wi in zip(ps, w): + xyz = ps2xyz(psi) + loss += wi * c.expectation_ps(**xyz) + return K.real(loss) + + +# 0. Exact result + +hm = tc.quantum.PauliStringSum2COO(ps, w, numpy=True) +hm = K.to_dense(hm) +e, v = np.linalg.eigh(hm) +exact_gs_energy = e[0] +print("==================================================================") +print("Exact ground state energy: ", exact_gs_energy) +print("==================================================================") + +# 1.1 VQE with numerically exact expectation: gradient free + +print(">>> VQE without shot noise") + + +r = minimizeSPSA( + func=exp_val_analytical, + x0=np.random.uniform(size=[n * nlayers * 2]), + niter=6000, + paired=False, +) + +print(r) +print(">> Converged as (Gradient Free) :", exp_val_analytical(r.x)) +result["Gradient Free"].append(exp_val_analytical(r.x)) + +# 1.2 VQE with numerically exact expectation: gradient based + +exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 +) +opt = K.optimizer(optax.adam(exponential_decay_scheduler)) +param = K.implicit_randn([n, nlayers, 2], stddev=0.1) # zeros stall the gradient +exp_val_grad_analytical = K.jit(K.value_and_grad(exp_val_analytical)) +for i in range(1000): + e, g = exp_val_grad_analytical(param) + param = opt.update(g, param) + if i % 100 == 99: + print(e) + +print(">> Converged as (Gradient based):", exp_val_grad_analytical(param)[0]) +result["Gradient based"].append(exp_val_grad_analytical(param)[0]) + +# 2.1 VQE with finite shot noise: gradient free + +print("==================================================================") +print(">>> VQE with shot noise") + + +rkey = K.get_random_state(42) + + +def exp_val_wrapper(param): + param = param.reshape(n, nlayers, 2) + global rkey + rkey, skey = K.random_split(rkey) + # maintain stateless randomness in scipy optimize interface + return exp_val(param, skey, shots=1024) + + +r = minimizeSPSA( + func=exp_val_wrapper, + x0=np.random.uniform(size=[n * nlayers * 2]), + niter=6000, + paired=False, +) +print(r) +print(">> Converged as (Gradient Free) :", exp_val_wrapper(r["x"])) +result["Gradient Free"].append(exp_val_wrapper(r["x"])) + +# 2.2 VQE with finite shot noise: gradient based + +exponential_decay_scheduler = optax.exponential_decay( + init_value=1e-2, transition_steps=500, decay_rate=0.9 +) +opt = K.optimizer(optax.adam(exponential_decay_scheduler)) +param = K.implicit_randn([n, nlayers, 2], stddev=0.1) # zeros stall the gradient +exp_grad = E.parameter_shift_grad_v2(exp_val, argnums=0, random_argnums=1) +rkey = K.get_random_state(42) + +for i in range(1000): + rkey, skey = K.random_split(rkey) + g = exp_grad(param, skey) + param = opt.update(g, param) + if i % 100 == 99: + rkey, skey = K.random_split(rkey) + print(exp_val(param, skey)) + +# the real energy position after optimization +print(">> Converged as (Gradient based):", exp_val_analytical(param)) +result["Gradient based"].append(exp_val_analytical(param)) + +print("==================================================================") +print(">>> Benchmark") +print(">> Exact ground state energy: ", exact_gs_energy) +print(tabulate(result, headers="keys")) From 6eec70232d2ba67b79f9ef9db5cc37a4e8b1ca9a Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Thu, 30 May 2024 13:03:50 +0900 Subject: [PATCH 700/725] update quantum.py --- tensorcircuit/quantum.py | 621 +++++++++++++++++++-------------------- 1 file changed, 306 insertions(+), 315 deletions(-) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 0d57362a..67a14b25 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -10,10 +10,10 @@ # pylint: disable=invalid-name -import os -from functools import reduce, partial import logging -from operator import or_, mul, matmul +import os +from functools import partial, reduce +from operator import matmul, mul, or_ from typing import ( Any, Callable, @@ -28,20 +28,19 @@ ) import numpy as np -from tensornetwork.network_components import AbstractNode, Node, Edge, connect -from tensornetwork.network_components import CopyNode -from tensornetwork.network_operations import get_all_nodes, copy, reachable -from tensornetwork.network_operations import get_subgraph_dangling, remove_node - -try: - import tensorflow as tf -except ImportError: - pass +from tensornetwork.network_components import AbstractNode, CopyNode, Edge, Node, connect +from tensornetwork.network_operations import ( + copy, + get_all_nodes, + get_subgraph_dangling, + reachable, + remove_node, +) -from .cons import backend, contractor, dtypestr, npdtype, rdtypestr from .backends import get_backend -from .utils import is_m1mac, arg_alias -from .gates import Gate +from .cons import backend, contractor, dtypestr, npdtype, rdtypestr +from .gates import Gate, num_to_tensor +from .utils import arg_alias Tensor = Any Graph = Any @@ -1162,318 +1161,310 @@ def quimb2qop(qb_mpo: Any) -> QuOperator: return qop -try: +def heisenberg_hamiltonian( + g: Graph, + hzz: float = 1.0, + hxx: float = 1.0, + hyy: float = 1.0, + hz: float = 0.0, + hx: float = 0.0, + hy: float = 0.0, + sparse: bool = True, + numpy: bool = False, +) -> Tensor: + """ + Generate Heisenberg Hamiltonian with possible external fields. + Currently requires tensorflow installed - def _id(x: Any) -> Any: - return x + :Example: - if is_m1mac(): - compiled_jit = _id - else: - compiled_jit = partial(get_backend("tensorflow").jit, jit_compile=True) - - def heisenberg_hamiltonian( - g: Graph, - hzz: float = 1.0, - hxx: float = 1.0, - hyy: float = 1.0, - hz: float = 0.0, - hx: float = 0.0, - hy: float = 0.0, - sparse: bool = True, - numpy: bool = False, - ) -> Tensor: - """ - Generate Heisenberg Hamiltonian with possible external fields. - Currently requires tensorflow installed + >>> g = tc.templates.graphs.Line1D(6) + >>> h = qu.heisenberg_hamiltonian(g, sparse=False) + >>> tc.backend.eigh(h)[0][:10] + array([-11.2111025, -8.4721365, -8.472136 , -8.472136 , -6. , + -5.123106 , -5.123106 , -5.1231055, -5.1231055, -5.1231055], + dtype=float32) + + :param g: input circuit graph + :type g: Graph + :param hzz: zz coupling, default is 1.0 + :type hzz: float + :param hxx: xx coupling, default is 1.0 + :type hxx: float + :param hyy: yy coupling, default is 1.0 + :type hyy: float + :param hz: External field on z direction, default is 0.0 + :type hz: float + :param hx: External field on y direction, default is 0.0 + :type hx: float + :param hy: External field on x direction, default is 0.0 + :type hy: float + :param sparse: Whether to return sparse Hamiltonian operator, default is True. + :type sparse: bool, defalts True + :param numpy: whether return the matrix in numpy or tensorflow form + :type numpy: bool, defaults False, + + :return: Hamiltonian measurements + :rtype: Tensor + """ + n = len(g.nodes) + ls = [] + weight = [] + for e in g.edges: + if hzz != 0: + r = [0 for _ in range(n)] + r[e[0]] = 3 + r[e[1]] = 3 + ls.append(r) + weight.append(hzz) + if hxx != 0: + r = [0 for _ in range(n)] + r[e[0]] = 1 + r[e[1]] = 1 + ls.append(r) + weight.append(hxx) + if hyy != 0: + r = [0 for _ in range(n)] + r[e[0]] = 2 + r[e[1]] = 2 + ls.append(r) + weight.append(hyy) + for node in g.nodes: + if hz != 0: + r = [0 for _ in range(n)] + r[node] = 3 + ls.append(r) + weight.append(hz) + if hx != 0: + r = [0 for _ in range(n)] + r[node] = 1 + ls.append(r) + weight.append(hx) + if hy != 0: + r = [0 for _ in range(n)] + r[node] = 2 + ls.append(r) + weight.append(hy) + ls = tf.constant(ls) + weight = tf.constant(weight) + ls = get_backend("tensorflow").cast(ls, dtypestr) + weight = get_backend("tensorflow").cast(weight, dtypestr) + if sparse: + r = PauliStringSum2COO_numpy(ls, weight) + if numpy: + return r + return backend.coo_sparse_matrix_from_numpy(r) + return PauliStringSum2Dense(ls, weight, numpy=numpy) - :Example: - >>> g = tc.templates.graphs.Line1D(6) - >>> h = qu.heisenberg_hamiltonian(g, sparse=False) - >>> tc.backend.eigh(h)[0][:10] - array([-11.2111025, -8.4721365, -8.472136 , -8.472136 , -6. , - -5.123106 , -5.123106 , -5.1231055, -5.1231055, -5.1231055], - dtype=float32) - - :param g: input circuit graph - :type g: Graph - :param hzz: zz coupling, default is 1.0 - :type hzz: float - :param hxx: xx coupling, default is 1.0 - :type hxx: float - :param hyy: yy coupling, default is 1.0 - :type hyy: float - :param hz: External field on z direction, default is 0.0 - :type hz: float - :param hx: External field on y direction, default is 0.0 - :type hx: float - :param hy: External field on x direction, default is 0.0 - :type hy: float - :param sparse: Whether to return sparse Hamiltonian operator, default is True. - :type sparse: bool, defalts True - :param numpy: whether return the matrix in numpy or tensorflow form - :type numpy: bool, defaults False, - - :return: Hamiltonian measurements - :rtype: Tensor - """ - n = len(g.nodes) - ls = [] - weight = [] - for e in g.edges: - if hzz != 0: - r = [0 for _ in range(n)] - r[e[0]] = 3 - r[e[1]] = 3 - ls.append(r) - weight.append(hzz) - if hxx != 0: - r = [0 for _ in range(n)] - r[e[0]] = 1 - r[e[1]] = 1 - ls.append(r) - weight.append(hxx) - if hyy != 0: - r = [0 for _ in range(n)] - r[e[0]] = 2 - r[e[1]] = 2 - ls.append(r) - weight.append(hyy) - for node in g.nodes: - if hz != 0: - r = [0 for _ in range(n)] - r[node] = 3 - ls.append(r) - weight.append(hz) - if hx != 0: - r = [0 for _ in range(n)] - r[node] = 1 - ls.append(r) - weight.append(hx) - if hy != 0: - r = [0 for _ in range(n)] - r[node] = 2 - ls.append(r) - weight.append(hy) - ls = tf.constant(ls) - weight = tf.constant(weight) - ls = get_backend("tensorflow").cast(ls, dtypestr) - weight = get_backend("tensorflow").cast(weight, dtypestr) - if sparse: - r = PauliStringSum2COO_numpy(ls, weight) - if numpy: - return r - return backend.coo_sparse_matrix_from_numpy(r) - return PauliStringSum2Dense(ls, weight, numpy=numpy) - - def PauliStringSum2Dense( - ls: Sequence[Sequence[int]], - weight: Optional[Sequence[float]] = None, - numpy: bool = False, - ) -> Tensor: - """ - Generate dense matrix from Pauli string sum. - Currently requires tensorflow installed. - - - :param ls: 2D Tensor, each row is for a Pauli string, - e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` - :type ls: Sequence[Sequence[int]] - :param weight: 1D Tensor, each element corresponds the weight for each Pauli string - defaults to None (all Pauli strings weight 1.0) - :type weight: Optional[Sequence[float]], optional - :param numpy: default False. If True, return numpy coo - else return backend compatible sparse tensor - :type numpy: bool - :return: the tensorflow dense matrix - :rtype: Tensor - """ - sparsem = PauliStringSum2COO_numpy(ls, weight) - if numpy: - return sparsem.todense() - sparsem = backend.coo_sparse_matrix_from_numpy(sparsem) - densem = backend.to_dense(sparsem) - return densem - - # already implemented as backend method - # - # def _tf2numpy_sparse(a: Tensor) -> Tensor: - # return get_backend("numpy").coo_sparse_matrix( - # indices=a.indices, - # values=a.values, - # shape=a.get_shape(), - # ) - - # def _numpy2tf_sparse(a: Tensor) -> Tensor: - # return get_backend("tensorflow").coo_sparse_matrix( - # indices=np.array([a.row, a.col]).T, - # values=a.data, - # shape=a.shape, - # ) - - def PauliStringSum2COO( - ls: Sequence[Sequence[int]], - weight: Optional[Sequence[float]] = None, - numpy: bool = False, - ) -> Tensor: - """ - Generate sparse tensor from Pauli string sum. - Currently requires tensorflow installed - - :param ls: 2D Tensor, each row is for a Pauli string, - e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` - :type ls: Sequence[Sequence[int]] - :param weight: 1D Tensor, each element corresponds the weight for each Pauli string - defaults to None (all Pauli strings weight 1.0) - :type weight: Optional[Sequence[float]], optional - :param numpy: default False. If True, return numpy coo - else return backend compatible sparse tensor - :type numpy: bool - :return: the scipy coo sparse matrix - :rtype: Tensor - """ - # numpy version is 3* faster! - - nterms = len(ls) - # n = len(ls[0]) - # s = 0b1 << n - if weight is None: - weight = [1.0 for _ in range(nterms)] - if not (isinstance(weight, tf.Tensor) or isinstance(weight, tf.Variable)): - weight = tf.constant(weight, dtype=getattr(tf, dtypestr)) - # rsparse = get_backend("numpy").coo_sparse_matrix( - # indices=np.array([[0, 0]], dtype=np.int64), - # values=np.array([0.0], dtype=getattr(np, dtypestr)), - # shape=(s, s), - # ) - rsparses = [ - get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore - for i in range(nterms) - ] - rsparse = _dc_sum(rsparses) - # auto transformed into csr format!! +def PauliStringSum2Dense( + ls: Sequence[Sequence[int]], + weight: Optional[Sequence[float]] = None, + numpy: bool = False, +) -> Tensor: + """ + Generate dense matrix from Pauli string sum. + Currently requires tensorflow installed. - # for i in range(nterms): - # rsparse += get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore - rsparse = rsparse.tocoo() - if numpy: - return rsparse - return backend.coo_sparse_matrix_from_numpy(rsparse) - def _dc_sum(l: List[Any]) -> Any: - """ - For the sparse sum, the speed is determined by the non zero terms, - so the DC way to do the sum can indeed bring some speed advantage (several times) + :param ls: 2D Tensor, each row is for a Pauli string, + e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` + :type ls: Sequence[Sequence[int]] + :param weight: 1D Tensor, each element corresponds the weight for each Pauli string + defaults to None (all Pauli strings weight 1.0) + :type weight: Optional[Sequence[float]], optional + :param numpy: default False. If True, return numpy coo + else return backend compatible sparse tensor + :type numpy: bool + :return: the tensorflow dense matrix + :rtype: Tensor + """ + sparsem = PauliStringSum2COO_numpy(ls, weight) + if numpy: + return sparsem.todense() + sparsem = backend.coo_sparse_matrix_from_numpy(sparsem) + densem = backend.to_dense(sparsem) + return densem + + +# already implemented as backend method +# +# def _tf2numpy_sparse(a: Tensor) -> Tensor: +# return get_backend("numpy").coo_sparse_matrix( +# indices=a.indices, +# values=a.values, +# shape=a.get_shape(), +# ) + +# def _numpy2tf_sparse(a: Tensor) -> Tensor: +# return get_backend("tensorflow").coo_sparse_matrix( +# indices=np.array([a.row, a.col]).T, +# values=a.data, +# shape=a.shape, +# ) + + +def PauliStringSum2COO( + ls: Sequence[Sequence[int]], + weight: Optional[Sequence[float]] = None, + numpy: bool = False, +) -> Tensor: + """ + Generate sparse tensor from Pauli string sum. + Currently requires tensorflow installed + + :param ls: 2D Tensor, each row is for a Pauli string, + e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` + :type ls: Sequence[Sequence[int]] + :param weight: 1D Tensor, each element corresponds the weight for each Pauli string + defaults to None (all Pauli strings weight 1.0) + :type weight: Optional[Sequence[float]], optional + :param numpy: default False. If True, return numpy coo + else return backend compatible sparse tensor + :type numpy: bool + :return: the scipy coo sparse matrix + :rtype: Tensor + """ + # numpy version is 3* faster! + + nterms = len(ls) + # n = len(ls[0]) + # s = 0b1 << n + if weight is None: + weight = [1.0 for _ in range(nterms)] + if not (isinstance(weight, tf.Tensor) or isinstance(weight, tf.Variable)): + weight = tf.constant(weight, dtype=getattr(tf, dtypestr)) + # rsparse = get_backend("numpy").coo_sparse_matrix( + # indices=np.array([[0, 0]], dtype=np.int64), + # values=np.array([0.0], dtype=getattr(np, dtypestr)), + # shape=(s, s), + # ) + rsparses = [ + get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore + for i in range(nterms) + ] + rsparse = _dc_sum(rsparses) + # auto transformed into csr format!! + + # for i in range(nterms): + # rsparse += get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore + rsparse = rsparse.tocoo() + if numpy: + return rsparse + return backend.coo_sparse_matrix_from_numpy(rsparse) - :param l: _description_ - :type l: List[Any] - :return: _description_ - :rtype: Any - """ - n = len(l) - if n > 2: - return _dc_sum(l[: n // 2]) + _dc_sum(l[n // 2 :]) - else: - return sum(l) - PauliStringSum2COO_numpy = partial(PauliStringSum2COO, numpy=True) +def _dc_sum(l: List[Any]) -> Any: + """ + For the sparse sum, the speed is determined by the non zero terms, + so the DC way to do the sum can indeed bring some speed advantage (several times) - def PauliStringSum2COO_tf( - ls: Sequence[Sequence[int]], weight: Optional[Sequence[float]] = None - ) -> Tensor: - """ - Generate tensorflow sparse matrix from Pauli string sum - - :param ls: 2D Tensor, each row is for a Pauli string, - e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` - :type ls: Sequence[Sequence[int]] - :param weight: 1D Tensor, each element corresponds the weight for each Pauli string - defaults to None (all Pauli strings weight 1.0) - :type weight: Optional[Sequence[float]], optional - :return: the tensorflow coo sparse matrix - :rtype: Tensor - """ - nterms = len(ls) - n = len(ls[0]) - s = 0b1 << n - if weight is None: - weight = [1.0 for _ in range(nterms)] - if not (isinstance(weight, tf.Tensor) or isinstance(weight, tf.Variable)): - weight = tf.constant(weight, dtype=getattr(tf, dtypestr)) - rsparse = tf.SparseTensor( - indices=tf.constant([[0, 0]], dtype=tf.int64), - values=tf.constant([0.0], dtype=weight.dtype), # type: ignore - dense_shape=(s, s), - ) - for i in range(nterms): - rsparse = tf.sparse.add(rsparse, PauliString2COO(ls[i], weight[i])) # type: ignore - # very slow sparse.add? - return rsparse + :param l: _description_ + :type l: List[Any] + :return: _description_ + :rtype: Any + """ + n = len(l) + if n > 2: + return _dc_sum(l[: n // 2]) + _dc_sum(l[n // 2 :]) + else: + return sum(l) - @compiled_jit - def PauliString2COO(l: Sequence[int], weight: Optional[float] = None) -> Tensor: - """ - Generate tensorflow sparse matrix from Pauli string sum - - :param l: 1D Tensor representing for a Pauli string, - e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` - :type l: Sequence[int] - :param weight: the weight for the Pauli string - defaults to None (all Pauli strings weight 1.0) - :type weight: Optional[float], optional - :return: the tensorflow sparse matrix - :rtype: Tensor - """ - n = len(l) - one = tf.constant(0b1, dtype=tf.int64) - idx_x = tf.constant(0b0, dtype=tf.int64) - idx_y = tf.constant(0b0, dtype=tf.int64) - idx_z = tf.constant(0b0, dtype=tf.int64) - i = tf.constant(0, dtype=tf.int64) - for j in l: - # i, j from enumerate is python, non jittable when cond using tensor - if j == 1: # xi - idx_x += tf.bitwise.left_shift(one, n - i - 1) - elif j == 2: # yi - idx_y += tf.bitwise.left_shift(one, n - i - 1) - elif j == 3: # zi - idx_z += tf.bitwise.left_shift(one, n - i - 1) - i += 1 - - if weight is None: - weight = tf.constant(1.0, dtype=tf.complex64) - return ps2coo_core(idx_x, idx_y, idx_z, weight, n) - - @compiled_jit - def ps2coo_core( - idx_x: Tensor, idx_y: Tensor, idx_z: Tensor, weight: Tensor, nqubits: int - ) -> Tuple[Tensor, Tensor]: - dtype = weight.dtype - s = 0b1 << nqubits - idx1 = tf.cast(tf.range(s), dtype=tf.int64) - idx2 = (idx1 ^ idx_x) ^ (idx_y) - indices = tf.transpose(tf.stack([idx1, idx2])) - tmp = idx1 & (idx_y | idx_z) - e = idx1 * 0 - ny = 0 - for i in range(nqubits): - # if tmp[i] is power of 2 (non zero), then e[i] = 1 - e ^= tf.bitwise.right_shift(tmp, i) & 0b1 - # how many 1 contained in idx_y - ny += tf.bitwise.right_shift(idx_y, i) & 0b1 - ny = tf.math.mod(ny, 4) - values = ( - tf.cast((1 - 2 * e), dtype) - * tf.math.pow(tf.constant(-1.0j, dtype=dtype), tf.cast(ny, dtype)) - * weight - ) - return tf.SparseTensor(indices=indices, values=values, dense_shape=(s, s)) # type: ignore -except (NameError, ImportError): - logger.info( - "tensorflow is not installed, and sparse Hamiltonian generation utilities are disabled" +PauliStringSum2COO_numpy = partial(PauliStringSum2COO, numpy=True) + + +def PauliStringSum2COO_tf( + ls: Sequence[Sequence[int]], weight: Optional[Sequence[float]] = None +) -> Tensor: + """ + Generate tensorflow sparse matrix from Pauli string sum + + :param ls: 2D Tensor, each row is for a Pauli string, + e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` + :type ls: Sequence[Sequence[int]] + :param weight: 1D Tensor, each element corresponds the weight for each Pauli string + defaults to None (all Pauli strings weight 1.0) + :type weight: Optional[Sequence[float]], optional + :return: the tensorflow coo sparse matrix + :rtype: Tensor + """ + nterms = len(ls) + n = len(ls[0]) + s = 0b1 << n + if weight is None: + weight = [1.0 for _ in range(nterms)] + if not (isinstance(weight, tf.Tensor) or isinstance(weight, tf.Variable)): + weight = tf.constant(weight, dtype=getattr(tf, dtypestr)) + rsparse = tf.SparseTensor( + indices=tf.constant([[0, 0]], dtype=tf.int64), + values=tf.constant([0.0], dtype=weight.dtype), # type: ignore + dense_shape=(s, s), + ) + for i in range(nterms): + rsparse = tf.sparse.add(rsparse, PauliString2COO(ls[i], weight[i])) # type: ignore + # very slow sparse.add? + return rsparse + + +def PauliString2COO(l: Sequence[int], weight: Optional[float] = None) -> Tensor: + """ + Generate tensorflow sparse matrix from Pauli string sum + + :param l: 1D Tensor representing for a Pauli string, + e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` + :type l: Sequence[int] + :param weight: the weight for the Pauli string + defaults to None (all Pauli strings weight 1.0) + :type weight: Optional[float], optional + :return: the tensorflow sparse matrix + :rtype: Tensor + """ + n = len(l) + one = num_to_tensor(0b1, dtype="int64") + idx_x = num_to_tensor(0b0, dtype="int64") + idx_y = num_to_tensor(0b0, dtype="int64") + idx_z = num_to_tensor(0b0, dtype="int64") + i = num_to_tensor(0, dtype="int64") + for j in l: + # i, j from enumerate is python, non jittable when cond using tensor + if j == 1: # xi + idx_x += tf.bitwise.left_shift(one, n - i - 1) + elif j == 2: # yi + idx_y += tf.bitwise.left_shift(one, n - i - 1) + elif j == 3: # zi + idx_z += tf.bitwise.left_shift(one, n - i - 1) + i += 1 + + if weight is None: + weight = tf.constant(1.0, dtype=tf.complex64) + return ps2coo_core(idx_x, idx_y, idx_z, weight, n) + + +def ps2coo_core( + idx_x: Tensor, idx_y: Tensor, idx_z: Tensor, weight: Tensor, nqubits: int +) -> Tuple[Tensor, Tensor]: + dtype = weight.dtype + s = 0b1 << nqubits + idx1 = tf.cast(tf.range(s), dtype=tf.int64) + idx2 = (idx1 ^ idx_x) ^ (idx_y) + indices = tf.transpose(tf.stack([idx1, idx2])) + tmp = idx1 & (idx_y | idx_z) + e = idx1 * 0 + ny = 0 + for i in range(nqubits): + # if tmp[i] is power of 2 (non zero), then e[i] = 1 + e ^= tf.bitwise.right_shift(tmp, i) & 0b1 + # how many 1 contained in idx_y + ny += tf.bitwise.right_shift(idx_y, i) & 0b1 + ny = tf.math.mod(ny, 4) + values = ( + tf.cast((1 - 2 * e), dtype) + * tf.math.pow(tf.constant(-1.0j, dtype=dtype), tf.cast(ny, dtype)) + * weight ) + return tf.SparseTensor(indices=indices, values=values, dense_shape=(s, s)) # type: ignore + # some quantum quatities below From 1b297d5fdcfc9db0842229629de27127ec08a2e5 Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Thu, 30 May 2024 13:42:24 +0900 Subject: [PATCH 701/725] update quantum.py & test --- tensorcircuit/quantum.py | 43 +++++++++++++++++++--------------------- tests/test_quantum.py | 7 ++++--- 2 files changed, 24 insertions(+), 26 deletions(-) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 67a14b25..33fe8163 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1245,8 +1245,8 @@ def heisenberg_hamiltonian( r[node] = 2 ls.append(r) weight.append(hy) - ls = tf.constant(ls) - weight = tf.constant(weight) + ls = num_to_tensor(ls) + weight = num_to_tensor(weight) ls = get_backend("tensorflow").cast(ls, dtypestr) weight = get_backend("tensorflow").cast(weight, dtypestr) if sparse: @@ -1332,22 +1332,18 @@ def PauliStringSum2COO( # s = 0b1 << n if weight is None: weight = [1.0 for _ in range(nterms)] - if not (isinstance(weight, tf.Tensor) or isinstance(weight, tf.Variable)): - weight = tf.constant(weight, dtype=getattr(tf, dtypestr)) + weight = num_to_tensor(weight) # rsparse = get_backend("numpy").coo_sparse_matrix( # indices=np.array([[0, 0]], dtype=np.int64), # values=np.array([0.0], dtype=getattr(np, dtypestr)), # shape=(s, s), # ) - rsparses = [ - get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore - for i in range(nterms) - ] + rsparses = [backend.numpy(PauliString2COO(ls[i], weight[i])) for i in range(nterms)] # type: ignore rsparse = _dc_sum(rsparses) # auto transformed into csr format!! # for i in range(nterms): - # rsparse += get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) # type: ignore + # rsparse += get_backend("tensorflow").numpy(PauliString2COO(ls[i], weight[i])) rsparse = rsparse.tocoo() if numpy: return rsparse @@ -1389,6 +1385,8 @@ def PauliStringSum2COO_tf( :return: the tensorflow coo sparse matrix :rtype: Tensor """ + import tensorflow as tf + nterms = len(ls) n = len(ls[0]) s = 0b1 << n @@ -1409,7 +1407,7 @@ def PauliStringSum2COO_tf( def PauliString2COO(l: Sequence[int], weight: Optional[float] = None) -> Tensor: """ - Generate tensorflow sparse matrix from Pauli string sum + Generate sparse matrix from Pauli string sum :param l: 1D Tensor representing for a Pauli string, e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` @@ -1429,41 +1427,40 @@ def PauliString2COO(l: Sequence[int], weight: Optional[float] = None) -> Tensor: for j in l: # i, j from enumerate is python, non jittable when cond using tensor if j == 1: # xi - idx_x += tf.bitwise.left_shift(one, n - i - 1) + idx_x += backend.left_shift(one, n - i - 1) elif j == 2: # yi - idx_y += tf.bitwise.left_shift(one, n - i - 1) + idx_y += backend.left_shift(one, n - i - 1) elif j == 3: # zi - idx_z += tf.bitwise.left_shift(one, n - i - 1) + idx_z += backend.left_shift(one, n - i - 1) i += 1 if weight is None: - weight = tf.constant(1.0, dtype=tf.complex64) + weight = num_to_tensor(1.0, dtype="complex64") return ps2coo_core(idx_x, idx_y, idx_z, weight, n) def ps2coo_core( idx_x: Tensor, idx_y: Tensor, idx_z: Tensor, weight: Tensor, nqubits: int ) -> Tuple[Tensor, Tensor]: - dtype = weight.dtype s = 0b1 << nqubits - idx1 = tf.cast(tf.range(s), dtype=tf.int64) + idx1 = num_to_tensor(backend.arange(s), dtype="int64") idx2 = (idx1 ^ idx_x) ^ (idx_y) - indices = tf.transpose(tf.stack([idx1, idx2])) + indices = backend.transpose(backend.stack([idx1, idx2])) tmp = idx1 & (idx_y | idx_z) e = idx1 * 0 ny = 0 for i in range(nqubits): # if tmp[i] is power of 2 (non zero), then e[i] = 1 - e ^= tf.bitwise.right_shift(tmp, i) & 0b1 + e ^= backend.right_shift(tmp, i) & 0b1 # how many 1 contained in idx_y - ny += tf.bitwise.right_shift(idx_y, i) & 0b1 - ny = tf.math.mod(ny, 4) + ny += backend.right_shift(idx_y, i) & 0b1 + ny = backend.mod(ny, 4) values = ( - tf.cast((1 - 2 * e), dtype) - * tf.math.pow(tf.constant(-1.0j, dtype=dtype), tf.cast(ny, dtype)) + num_to_tensor(1 - 2 * e) + * ((num_to_tensor(-1.0j) ** num_to_tensor(ny))) * weight ) - return tf.SparseTensor(indices=indices, values=values, dense_shape=(s, s)) # type: ignore + return backend.coo_sparse_matrix(indices=indices, values=values, shape=(s, s)) # type: ignore # some quantum quatities below diff --git a/tests/test_quantum.py b/tests/test_quantum.py index 2009fbe6..63ff755e 100644 --- a/tests/test_quantum.py +++ b/tests/test_quantum.py @@ -1,13 +1,13 @@ # pylint: disable=invalid-name -from functools import partial import os import sys +from functools import partial import numpy as np import pytest -from pytest_lazyfixture import lazy_fixture as lf import tensornetwork as tn +from pytest_lazyfixture import lazy_fixture as lf thisfile = os.path.abspath(__file__) modulepath = os.path.dirname(os.path.dirname(thisfile)) @@ -312,7 +312,8 @@ def test_extract_from_measure(backend): np.testing.assert_allclose(r, 1, atol=1e-5) -def test_heisenberg_ham(tfb): +@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")]) +def test_heisenberg_ham(backend): g = tc.templates.graphs.Line1D(6) h = tc.quantum.heisenberg_hamiltonian(g, sparse=False) e, _ = tc.backend.eigh(h) From 45c5b6e17b29cd1f51cd07bbd32e54e54808b24c Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Thu, 30 May 2024 14:05:31 +0900 Subject: [PATCH 702/725] fix: fix failed test --- tests/test_templates.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/tests/test_templates.py b/tests/test_templates.py index 25f22b08..79e2b176 100644 --- a/tests/test_templates.py +++ b/tests/test_templates.py @@ -1,7 +1,8 @@ # pylint: disable=invalid-name -import sys import os +import sys + import numpy as np import pytest from pytest_lazyfixture import lazy_fixture as lf @@ -160,10 +161,6 @@ def test_operator_measurement(backend): ) dense = tc.array_to_tensor(np.kron(tc.gates._x_matrix, np.eye(2))) sparse = tc.quantum.PauliString2COO([1, 0]) - if tc.backend.name == "jax": - sparse = tc.backend.coo_sparse_matrix( - sparse.indices, sparse.values, sparse.shape - ) for h in [dense, sparse, mpo]: From 846715af3eca8f0b737a367ddd689a2b4aa50896 Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Thu, 30 May 2024 15:15:20 +0900 Subject: [PATCH 703/725] chore: change example --- examples/hamiltonian_building.py | 91 ++++++++++++++++++++++++++++---- tensorcircuit/quantum.py | 2 - 2 files changed, 81 insertions(+), 12 deletions(-) diff --git a/examples/hamiltonian_building.py b/examples/hamiltonian_building.py index e00c6a7e..91ce33a7 100644 --- a/examples/hamiltonian_building.py +++ b/examples/hamiltonian_building.py @@ -3,36 +3,86 @@ """ import time + +import jax import numpy as np import quimb +import scipy +import tensorflow as tf +import torch + import tensorcircuit as tc +tc.set_dtype("complex128") nwires = 20 -# tc outperforms quimb in large nwires +# tc with numpy backend outperforms quimb in large nwires + +print("--------------------") +# 1.1 tc approach for TFIM (numpy backend) -# 1. tc approach for TFIM +tc.set_backend("numpy") +print("hamiltonian building with tc (numpy backend)") +print("numpy version: ", np.__version__) +print("scipy version: ", scipy.__version__) g = tc.templates.graphs.Line1D(nwires, pbc=False) -time0 = time.time() -h1 = tc.quantum.heisenberg_hamiltonian( +time0 = time.perf_counter() +h11 = tc.quantum.heisenberg_hamiltonian( g, hzz=1, hxx=0, hyy=0, hz=0, hx=-1, hy=0, sparse=True, numpy=True ) -time1 = time.time() +time1 = time.perf_counter() + +print("tc (numpy) time: ", time1 - time0) +print("--------------------") + +# 1.2 tc approach for TFIM (jax backend) + +tc.set_backend("jax") +print("hamiltonian building with tc (jax backend)") +print("jax version: ", jax.__version__) + +g = tc.templates.graphs.Line1D(nwires, pbc=False) +time0 = time.perf_counter() +h12 = tc.quantum.heisenberg_hamiltonian( + g, hzz=1, hxx=0, hyy=0, hz=0, hx=-1, hy=0, sparse=True +) +time1 = time.perf_counter() + +print("tc (jax) time: ", time1 - time0) +print("--------------------") + +# 1.3 tc approach for TFIM (tensorflow backend) + +tc.set_backend("tensorflow") +print("hamiltonian building with tc (tensorflow backend)") +print("tensorflow version: ", tf.__version__) + +g = tc.templates.graphs.Line1D(nwires, pbc=False) +time0 = time.perf_counter() +h13 = tc.quantum.heisenberg_hamiltonian( + g, hzz=1, hxx=0, hyy=0, hz=0, hx=-1, hy=0, sparse=True +) +time1 = time.perf_counter() + +print("tc (tensorflow) time: ", time1 - time0) +print("--------------------") -print("tc time: ", time1 - time0) # 2. quimb approach for TFIM -builder = quimb.tensor.tensor_gen.SpinHam() +print("hamiltonian building with quimb") +print("quimb version: ", quimb.__version__) + +builder = quimb.tensor.SpinHam1D() # spin operator instead of Pauli matrix builder += 4, "Z", "Z" builder += -2, "X" -time0 = time.time() +time0 = time.perf_counter() h2 = builder.build_sparse(nwires) h2 = h2.tocoo() -time1 = time.time() +time1 = time.perf_counter() print("quimb time: ", time1 - time0) @@ -43,4 +93,25 @@ def assert_equal(h1, h2): np.testing.assert_allclose(h1.data, h2.data, atol=1e-5) -assert_equal(h1, h2) +# numpy +assert_equal(h11, h2) + +# jax +scipy_coo = scipy.sparse.coo_matrix( + ( + h12.data, + (h12.indices[:, 0], h12.indices[:, 1]), + ), + shape=h12.shape, +) +assert_equal(scipy_coo, h2) + +# tensorflow +scipy_coo = scipy.sparse.coo_matrix( + ( + h13.values, + (h13.indices[:, 0], h13.indices[:, 1]), + ), + shape=h13.shape, +) +assert_equal(scipy_coo, h2) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 33fe8163..eb3d6637 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1247,8 +1247,6 @@ def heisenberg_hamiltonian( weight.append(hy) ls = num_to_tensor(ls) weight = num_to_tensor(weight) - ls = get_backend("tensorflow").cast(ls, dtypestr) - weight = get_backend("tensorflow").cast(weight, dtypestr) if sparse: r = PauliStringSum2COO_numpy(ls, weight) if numpy: From 313ddd39a8d4acb77fb20927e171d2af3d0d1f9c Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Thu, 30 May 2024 15:21:38 +0900 Subject: [PATCH 704/725] lint: fix lint --- tensorcircuit/quantum.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index eb3d6637..9662e97b 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -37,7 +37,6 @@ remove_node, ) -from .backends import get_backend from .cons import backend, contractor, dtypestr, npdtype, rdtypestr from .gates import Gate, num_to_tensor from .utils import arg_alias From 0366583144590a7c2dea89524c062bc3f5b9ac54 Mon Sep 17 00:00:00 2001 From: Gopal Dahale Date: Thu, 30 May 2024 12:35:38 +0530 Subject: [PATCH 705/725] Added compass. Kept inital parameters same for all --- examples/vqe_noisyopt.py | 69 ++++++++++++++++++++++++++++------------ 1 file changed, 49 insertions(+), 20 deletions(-) diff --git a/examples/vqe_noisyopt.py b/examples/vqe_noisyopt.py index 8fa06bd3..2c59026b 100644 --- a/examples/vqe_noisyopt.py +++ b/examples/vqe_noisyopt.py @@ -9,7 +9,7 @@ import tensorcircuit as tc from tensorcircuit import experimental as E from noisyopt import minimizeCompass, minimizeSPSA -from tabulate import tabulate +from tabulate import tabulate # pip install tabulate seed = 42 np.random.seed(seed) @@ -20,10 +20,14 @@ n = 6 nlayers = 4 +# initial value of the parameters +initial_value = np.random.uniform(size=[n * nlayers * 2]) + result = { "Algorithm / Optimization": ["Without Shot Noise", "With Shot Noise"], - "Gradient Free": [], - "Gradient based": [], + "SPSA (Gradient Free)": [], + "Compass Search (Gradient Free)": [], + "Adam (Gradient based)": [], } # We use OBC 1D TFIM Hamiltonian in this script @@ -113,14 +117,26 @@ def exp_val_analytical(param): r = minimizeSPSA( func=exp_val_analytical, - x0=np.random.uniform(size=[n * nlayers * 2]), + x0=initial_value, niter=6000, paired=False, ) print(r) -print(">> Converged as (Gradient Free) :", exp_val_analytical(r.x)) -result["Gradient Free"].append(exp_val_analytical(r.x)) +print(">> SPSA converged as:", exp_val_analytical(r.x)) +result["SPSA (Gradient Free)"].append(exp_val_analytical(r.x)) + +r = minimizeCompass( + func=exp_val_analytical, + x0=initial_value, + deltatol=0.1, + feps=1e-3, + paired=False, +) + +print(r) +print(">> Compass converged as:", exp_val_analytical(r.x)) +result["Compass Search (Gradient Free)"].append(exp_val_analytical(r.x)) # 1.2 VQE with numerically exact expectation: gradient based @@ -128,16 +144,16 @@ def exp_val_analytical(param): init_value=1e-2, transition_steps=500, decay_rate=0.9 ) opt = K.optimizer(optax.adam(exponential_decay_scheduler)) -param = K.implicit_randn([n, nlayers, 2], stddev=0.1) # zeros stall the gradient +param = initial_value.reshape((n, nlayers, 2)) # zeros stall the gradient exp_val_grad_analytical = K.jit(K.value_and_grad(exp_val_analytical)) for i in range(1000): e, g = exp_val_grad_analytical(param) param = opt.update(g, param) if i % 100 == 99: - print(e) + print(f"Expectation value at iteration {i}: {e}") -print(">> Converged as (Gradient based):", exp_val_grad_analytical(param)[0]) -result["Gradient based"].append(exp_val_grad_analytical(param)[0]) +print(">> Adam converged as:", exp_val_grad_analytical(param)[0]) +result["Adam (Gradient based)"].append(exp_val_grad_analytical(param)[0]) # 2.1 VQE with finite shot noise: gradient free @@ -145,7 +161,7 @@ def exp_val_analytical(param): print(">>> VQE with shot noise") -rkey = K.get_random_state(42) +rkey = K.get_random_state(seed) def exp_val_wrapper(param): @@ -158,13 +174,26 @@ def exp_val_wrapper(param): r = minimizeSPSA( func=exp_val_wrapper, - x0=np.random.uniform(size=[n * nlayers * 2]), + x0=initial_value, niter=6000, paired=False, ) print(r) -print(">> Converged as (Gradient Free) :", exp_val_wrapper(r["x"])) -result["Gradient Free"].append(exp_val_wrapper(r["x"])) +print(">> SPSA converged as:", exp_val_wrapper(r["x"])) +result["SPSA (Gradient Free)"].append(exp_val_wrapper(r["x"])) + +r = minimizeCompass( + func=exp_val_wrapper, + x0=initial_value, + deltatol=0.1, + feps=1e-2, + paired=False, +) + +print(r) +print(">> Compass converged as:", exp_val_wrapper(r["x"])) +result["Compass Search (Gradient Free)"].append(exp_val_wrapper(r["x"])) + # 2.2 VQE with finite shot noise: gradient based @@ -172,9 +201,9 @@ def exp_val_wrapper(param): init_value=1e-2, transition_steps=500, decay_rate=0.9 ) opt = K.optimizer(optax.adam(exponential_decay_scheduler)) -param = K.implicit_randn([n, nlayers, 2], stddev=0.1) # zeros stall the gradient +param = initial_value.reshape((n, nlayers, 2)) # zeros stall the gradient exp_grad = E.parameter_shift_grad_v2(exp_val, argnums=0, random_argnums=1) -rkey = K.get_random_state(42) +rkey = K.get_random_state(seed) for i in range(1000): rkey, skey = K.random_split(rkey) @@ -182,13 +211,13 @@ def exp_val_wrapper(param): param = opt.update(g, param) if i % 100 == 99: rkey, skey = K.random_split(rkey) - print(exp_val(param, skey)) + print(f"Expectation value at iteration {i}: {exp_val(param, skey)}") # the real energy position after optimization -print(">> Converged as (Gradient based):", exp_val_analytical(param)) -result["Gradient based"].append(exp_val_analytical(param)) +print(">> Adam converged as:", exp_val_analytical(param)) +result["Adam (Gradient based)"].append(exp_val_analytical(param)) print("==================================================================") print(">>> Benchmark") print(">> Exact ground state energy: ", exact_gs_energy) -print(tabulate(result, headers="keys")) +print(tabulate(result, headers="keys", tablefmt="github")) From 856c6500df9f067a8be3798f1df48a07aa329171 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 30 May 2024 15:51:05 +0800 Subject: [PATCH 706/725] jit the paulistrsum --- examples/hamiltonian_building.py | 19 ++++++++++++-- requirements/requirements-extra.txt | 2 +- tensorcircuit/quantum.py | 39 ++++++++++++++++++++++------- 3 files changed, 48 insertions(+), 12 deletions(-) diff --git a/examples/hamiltonian_building.py b/examples/hamiltonian_building.py index 91ce33a7..80385265 100644 --- a/examples/hamiltonian_building.py +++ b/examples/hamiltonian_building.py @@ -9,14 +9,12 @@ import quimb import scipy import tensorflow as tf -import torch import tensorcircuit as tc tc.set_dtype("complex128") nwires = 20 -# tc with numpy backend outperforms quimb in large nwires print("--------------------") @@ -51,6 +49,14 @@ time1 = time.perf_counter() print("tc (jax) time: ", time1 - time0) + +time0 = time.perf_counter() +h12 = tc.quantum.heisenberg_hamiltonian( + g, hzz=1, hxx=0, hyy=0, hz=0, hx=-1, hy=0, sparse=True +) +time1 = time.perf_counter() + +print("tc (jax) time (after jit): ", time1 - time0) print("--------------------") # 1.3 tc approach for TFIM (tensorflow backend) @@ -67,6 +73,15 @@ time1 = time.perf_counter() print("tc (tensorflow) time: ", time1 - time0) + +time0 = time.perf_counter() +h13 = tc.quantum.heisenberg_hamiltonian( + g, hzz=1, hxx=0, hyy=0, hz=0, hx=-1, hy=0, sparse=True +) +time1 = time.perf_counter() + +print("tc (tensorflow) time (after jit): ", time1 - time0) + print("--------------------") diff --git a/requirements/requirements-extra.txt b/requirements/requirements-extra.txt index e5cd85a8..63e1f992 100644 --- a/requirements/requirements-extra.txt +++ b/requirements/requirements-extra.txt @@ -4,7 +4,7 @@ qiskit-aer<1.0 qiskit-nature mitiq cirq -torch +torch==2.2.2 # jupyter mthree==1.1.0 openfermion diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index 9662e97b..a2c54bb6 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1330,12 +1330,21 @@ def PauliStringSum2COO( if weight is None: weight = [1.0 for _ in range(nterms)] weight = num_to_tensor(weight) + ls = num_to_tensor(ls) # rsparse = get_backend("numpy").coo_sparse_matrix( # indices=np.array([[0, 0]], dtype=np.int64), # values=np.array([0.0], dtype=getattr(np, dtypestr)), # shape=(s, s), # ) - rsparses = [backend.numpy(PauliString2COO(ls[i], weight[i])) for i in range(nterms)] # type: ignore + global PauliString2COO_jit + if backend.name not in PauliString2COO_jit: + PauliString2COO_jit[backend.name] = backend.jit( + PauliString2COO, jit_compile=True + ) + rsparses = [ + backend.numpy(PauliString2COO_jit[backend.name](ls[i], weight[i])) # type: ignore + for i in range(nterms) + ] rsparse = _dc_sum(rsparses) # auto transformed into csr format!! @@ -1372,6 +1381,7 @@ def PauliStringSum2COO_tf( ) -> Tensor: """ Generate tensorflow sparse matrix from Pauli string sum + [deprecated] :param ls: 2D Tensor, each row is for a Pauli string, e.g. [1, 0, 0, 3, 2] is for :math:`X_0Z_3Y_4` @@ -1416,19 +1426,27 @@ def PauliString2COO(l: Sequence[int], weight: Optional[float] = None) -> Tensor: :rtype: Tensor """ n = len(l) + l = backend.cast(l, dtype="int64") one = num_to_tensor(0b1, dtype="int64") idx_x = num_to_tensor(0b0, dtype="int64") idx_y = num_to_tensor(0b0, dtype="int64") idx_z = num_to_tensor(0b0, dtype="int64") i = num_to_tensor(0, dtype="int64") - for j in l: - # i, j from enumerate is python, non jittable when cond using tensor - if j == 1: # xi - idx_x += backend.left_shift(one, n - i - 1) - elif j == 2: # yi - idx_y += backend.left_shift(one, n - i - 1) - elif j == 3: # zi - idx_z += backend.left_shift(one, n - i - 1) + # for j in l: + for j in range(n): + oh = backend.onehot(l[j], 4) + s = backend.left_shift(one, n - i - 1) + oh = backend.cast(oh, dtype="int64") + idx_x += oh[1] * s + idx_y += oh[2] * s + idx_z += oh[3] * s + + # if j == 1: # xi + # idx_x += backend.left_shift(one, n - i - 1) + # elif j == 2: # yi + # idx_y += backend.left_shift(one, n - i - 1) + # elif j == 3: # zi + # idx_z += backend.left_shift(one, n - i - 1) i += 1 if weight is None: @@ -1436,6 +1454,9 @@ def PauliString2COO(l: Sequence[int], weight: Optional[float] = None) -> Tensor: return ps2coo_core(idx_x, idx_y, idx_z, weight, n) +PauliString2COO_jit = {"numpy": PauliString2COO} + + def ps2coo_core( idx_x: Tensor, idx_y: Tensor, idx_z: Tensor, weight: Tensor, nqubits: int ) -> Tuple[Tensor, Tensor]: From f0d561b21c1b72943014ac87ff763e0ddbaac0d5 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Thu, 30 May 2024 08:12:29 +0000 Subject: [PATCH 707/725] docs: update README.md [skip ci] --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 845a6750..dbdfb554 100644 --- a/README.md +++ b/README.md @@ -297,7 +297,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. ztzhu
ztzhu
💻 Rabqubit
Rabqubit
💡 - Kazuki Tsuoka
Kazuki Tsuoka
💻 ⚠️ 📖 + Kazuki Tsuoka
Kazuki Tsuoka
💻 ⚠️ 📖 💡 From 14609aa7b9da6f2edc05d47f280d313bf9b91b38 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Thu, 30 May 2024 08:12:30 +0000 Subject: [PATCH 708/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.all-contributorsrc b/.all-contributorsrc index 2afd3367..fb02e2fa 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -309,7 +309,8 @@ "contributions": [ "code", "test", - "doc" + "doc", + "example" ] } ], From 05f6c445af3d110a3f0507f615464bb47cfa4626 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 30 May 2024 16:32:49 +0800 Subject: [PATCH 709/725] lint the example --- examples/vqe_noisyopt.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/examples/vqe_noisyopt.py b/examples/vqe_noisyopt.py index 2c59026b..8bd18948 100644 --- a/examples/vqe_noisyopt.py +++ b/examples/vqe_noisyopt.py @@ -4,12 +4,11 @@ from functools import partial import numpy as np -from scipy import optimize import optax -import tensorcircuit as tc -from tensorcircuit import experimental as E from noisyopt import minimizeCompass, minimizeSPSA from tabulate import tabulate # pip install tabulate +import tensorcircuit as tc +from tensorcircuit import experimental as E seed = 42 np.random.seed(seed) From d554eb3ece84ab04b00babf60096f5ece17b62ab Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Thu, 30 May 2024 08:34:29 +0000 Subject: [PATCH 710/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index dbdfb554..224e1a67 100644 --- a/README.md +++ b/README.md @@ -298,6 +298,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. ztzhu
ztzhu
💻 Rabqubit
Rabqubit
💡 Kazuki Tsuoka
Kazuki Tsuoka
💻 ⚠️ 📖 💡 + Gopal Ramesh Dahale
Gopal Ramesh Dahale
💡 From ebca718f989bc854aa8ee20b7748033014697a52 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Thu, 30 May 2024 08:34:30 +0000 Subject: [PATCH 711/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index fb02e2fa..3fec6727 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -312,6 +312,15 @@ "doc", "example" ] + }, + { + "login": "Gopal-Dahale", + "name": "Gopal Ramesh Dahale", + "avatar_url": "https://avatars.githubusercontent.com/u/49199003?v=4", + "profile": "https://gopal-dahale.github.io/", + "contributions": [ + "example" + ] } ], "contributorsPerLine": 6, From 54bd507be65708e9a97a05556fc94e826b8c260e Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Thu, 30 May 2024 16:42:00 +0800 Subject: [PATCH 712/725] fix non tensor input --- tensorcircuit/quantum.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tensorcircuit/quantum.py b/tensorcircuit/quantum.py index a2c54bb6..23bb926c 100644 --- a/tensorcircuit/quantum.py +++ b/tensorcircuit/quantum.py @@ -1426,7 +1426,8 @@ def PauliString2COO(l: Sequence[int], weight: Optional[float] = None) -> Tensor: :rtype: Tensor """ n = len(l) - l = backend.cast(l, dtype="int64") + l = num_to_tensor(l, dtype="int64") + # l = backend.cast(l, dtype="int64") one = num_to_tensor(0b1, dtype="int64") idx_x = num_to_tensor(0b0, dtype="int64") idx_y = num_to_tensor(0b0, dtype="int64") From f0c1c80259cfdf1d51c932a1d19dbd50da408550 Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Fri, 31 May 2024 19:28:55 +0900 Subject: [PATCH 713/725] chore: add example --- examples/cotengra_setting_bench.py | 142 +++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 examples/cotengra_setting_bench.py diff --git a/examples/cotengra_setting_bench.py b/examples/cotengra_setting_bench.py new file mode 100644 index 00000000..2ffee840 --- /dev/null +++ b/examples/cotengra_setting_bench.py @@ -0,0 +1,142 @@ +""" +Optimization for performance comparison with different cotengra settings. +(random layouts averaged). +""" + +import itertools +import sys +import warnings + +import cotengra as ctg +import networkx as nx +import numpy as np + +sys.path.insert(0, "../") +import tensorcircuit as tc + +try: + import kahypar +except ImportError: + print("kahypar not installed, please install it to run this script.") + exit() + + +# suppress the warning from cotengra +warnings.filterwarnings( + "ignore", + message="The inputs or output of this tree are not ordered." + "Costs will be accurate but actually contracting requires " + "ordered indices corresponding to array axes.", +) + +K = tc.set_backend("jax") + + +def generate_circuit(param, g, n, nlayers): + # construct the circuit ansatz + c = tc.Circuit(n) + for i in range(n): + c.H(i) + for j in range(nlayers): + c = tc.templates.blocks.QAOA_block(c, g, param[j, 0], param[j, 1]) + return c + + +def trigger_cotengra_optimization(n, nlayers, d): + g = nx.random_regular_graph(d, n) + + # define the loss function + def loss_f(params, n, nlayers): + + c = generate_circuit(params, g, n, nlayers) + + # calculate the loss function, max cut + loss = 0.0 + for e in g.edges: + loss += c.expectation_ps(z=[e[0], e[1]]) + + return K.real(loss) + + params = K.implicit_randn(shape=[nlayers, 2]) + + # run only once to trigger the compilation + K.jit( + K.value_and_grad(loss_f, argnums=0), + static_argnums=(1, 2), + )(params, n, nlayers) + + +# define the cotengra optimizer parameters +methods_args = [ # https://cotengra.readthedocs.io/en/latest/advanced.html#drivers + "greedy", + "kahypar", + "labels", + # "spinglass", # requires igraph + # "labelprop", # requires igraph + # "betweenness", # requires igraph + # "walktrap", # requires igraph + # "quickbb", # requires https://github.com/dechterlab/quickbb + # "flowcutter", # requires https://github.com/kit-algo/flow-cutter-pace17 +] + +optlib_args = [ # https://cotengra.readthedocs.io/en/latest/advanced.html#optimization-library + "optuna", # pip install optuna + "random", + # "baytune", # pip install baytune + # "nevergrad", # pip install nevergrad + # "chocolate", # pip install git+https://github.com/AIworx-Labs/chocolate@master + # "skopt", # pip install scikit-optimize +] + +post_processing_args = [ # https://cotengra.readthedocs.io/en/latest/advanced.html#slicing-and-subtree-reconfiguration + (None, None), + ("slicing_opts", {"target_size": 2**28}), + ("slicing_reconf_opts", {"target_size": 2**28}), + ("reconf_opts", {}), + ("simulated_annealing_opts", {}), +] + + +def get_optimizer(method, optlib, post_processing): + if post_processing[0] is None: + return ctg.HyperOptimizer( + methods=method, + optlib=optlib, + minimize="flops", + parallel=True, + max_time=30, + max_repeats=30, + progbar=True, + ) + else: + return ctg.HyperOptimizer( + methods=method, + optlib=optlib, + minimize="flops", + parallel=True, + max_time=30, + max_repeats=30, + progbar=True, + **{post_processing[0]: post_processing[1]}, + ) + + +if __name__ == "__main__": + # define the parameters + n = 20 + nlayers = 15 + d = 3 + + for method, optlib, post_processing in itertools.product( + methods_args, optlib_args, post_processing_args + ): + print(f"method: {method}, optlib: {optlib}, post_processing: {post_processing}") + tc.set_contractor( + "custom", + optimizer=get_optimizer(method, optlib, post_processing), + contraction_info=True, + preprocessing=True, + debug_level=2, # no computation + ) + trigger_cotengra_optimization(n, nlayers, d) + print("-------------------------") From 13b543ac5a2e98de91c0f88c25ffc6764f826a76 Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Fri, 31 May 2024 19:29:49 +0900 Subject: [PATCH 714/725] chore: comment change --- examples/cotengra_setting_bench.py | 1 - 1 file changed, 1 deletion(-) diff --git a/examples/cotengra_setting_bench.py b/examples/cotengra_setting_bench.py index 2ffee840..662a8b73 100644 --- a/examples/cotengra_setting_bench.py +++ b/examples/cotengra_setting_bench.py @@ -1,6 +1,5 @@ """ Optimization for performance comparison with different cotengra settings. -(random layouts averaged). """ import itertools From 9827b394961b7606021203bee8931a97645224fe Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Mon, 3 Jun 2024 14:41:24 +0900 Subject: [PATCH 715/725] feat: add more settings for cotengra benchmark example --- examples/cotengra_setting_bench.py | 70 ++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 23 deletions(-) diff --git a/examples/cotengra_setting_bench.py b/examples/cotengra_setting_bench.py index 662a8b73..3143cc18 100644 --- a/examples/cotengra_setting_bench.py +++ b/examples/cotengra_setting_bench.py @@ -41,17 +41,16 @@ def generate_circuit(param, g, n, nlayers): return c -def trigger_cotengra_optimization(n, nlayers, d): - g = nx.random_regular_graph(d, n) +def trigger_cotengra_optimization(n, nlayers, graph): # define the loss function def loss_f(params, n, nlayers): - c = generate_circuit(params, g, n, nlayers) + c = generate_circuit(params, graph, n, nlayers) # calculate the loss function, max cut loss = 0.0 - for e in g.edges: + for e in graph.edges: loss += c.expectation_ps(z=[e[0], e[1]]) return K.real(loss) @@ -60,12 +59,28 @@ def loss_f(params, n, nlayers): # run only once to trigger the compilation K.jit( - K.value_and_grad(loss_f, argnums=0), + loss_f, static_argnums=(1, 2), )(params, n, nlayers) +# define the benchmark parameters +n = 10 +nlayers = 15 + # define the cotengra optimizer parameters +graph_args = { + "1D lattice": nx.convert_node_labels_to_integers( + nx.grid_graph((n, 1)) + ), # 1D lattice + "2D lattice": nx.convert_node_labels_to_integers( + nx.grid_graph((n // 5, n // (n // 5))) + ), # 2D lattice + "all-to-all connected": nx.convert_node_labels_to_integers( + nx.complete_graph(n) + ), # all-to-all connected +} + methods_args = [ # https://cotengra.readthedocs.io/en/latest/advanced.html#drivers "greedy", "kahypar", @@ -79,10 +94,10 @@ def loss_f(params, n, nlayers): ] optlib_args = [ # https://cotengra.readthedocs.io/en/latest/advanced.html#optimization-library - "optuna", # pip install optuna - "random", + # "optuna", # pip install optuna + "random", # default when no library is installed # "baytune", # pip install baytune - # "nevergrad", # pip install nevergrad + "nevergrad", # pip install nevergrad # "chocolate", # pip install git+https://github.com/AIworx-Labs/chocolate@master # "skopt", # pip install scikit-optimize ] @@ -95,47 +110,56 @@ def loss_f(params, n, nlayers): ("simulated_annealing_opts", {}), ] +minimize_args = [ # https://cotengra.readthedocs.io/en/main/advanced.html#objective + "flops", # minimize the total number of scalar operations + "size", # minimize the size of the largest intermediate tensor + "write", # minimize the sum of sizes of all intermediate tensors + "combo", # minimize the sum of FLOPS + α * WRITE where α is 64 +] + -def get_optimizer(method, optlib, post_processing): +def get_optimizer(method, optlib, post_processing, minimize): if post_processing[0] is None: return ctg.HyperOptimizer( methods=method, optlib=optlib, - minimize="flops", + minimize=minimize, parallel=True, max_time=30, - max_repeats=30, + max_repeats=128, progbar=True, ) else: return ctg.HyperOptimizer( methods=method, optlib=optlib, - minimize="flops", + minimize=minimize, parallel=True, max_time=30, - max_repeats=30, + max_repeats=128, progbar=True, **{post_processing[0]: post_processing[1]}, ) if __name__ == "__main__": - # define the parameters - n = 20 - nlayers = 15 - d = 3 - - for method, optlib, post_processing in itertools.product( - methods_args, optlib_args, post_processing_args + for graph, method, optlib, post_processing, minimize in itertools.product( + graph_args.keys(), + methods_args, + optlib_args, + post_processing_args, + minimize_args, ): - print(f"method: {method}, optlib: {optlib}, post_processing: {post_processing}") + print( + f"graph: {graph}, method: {method}, optlib: {optlib}, " + f"post_processing: {post_processing}, minimize: {minimize}" + ) tc.set_contractor( "custom", - optimizer=get_optimizer(method, optlib, post_processing), + optimizer=get_optimizer(method, optlib, post_processing, minimize), contraction_info=True, preprocessing=True, debug_level=2, # no computation ) - trigger_cotengra_optimization(n, nlayers, d) + trigger_cotengra_optimization(n, nlayers, graph_args[graph]) print("-------------------------") From ed378cb78a2c889c2bb8e3c0c72f3e0f47c28621 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Mon, 3 Jun 2024 15:31:40 +0800 Subject: [PATCH 716/725] improve cotengra benchmark example --- examples/cotengra_setting_bench.py | 31 ++++++++++++++---------------- 1 file changed, 14 insertions(+), 17 deletions(-) diff --git a/examples/cotengra_setting_bench.py b/examples/cotengra_setting_bench.py index 3143cc18..d1b3f1b7 100644 --- a/examples/cotengra_setting_bench.py +++ b/examples/cotengra_setting_bench.py @@ -48,10 +48,7 @@ def loss_f(params, n, nlayers): c = generate_circuit(params, graph, n, nlayers) - # calculate the loss function, max cut - loss = 0.0 - for e in graph.edges: - loss += c.expectation_ps(z=[e[0], e[1]]) + loss = c.expectation_ps(z=[0, 1, 2], reuse=False) return K.real(loss) @@ -65,8 +62,8 @@ def loss_f(params, n, nlayers): # define the benchmark parameters -n = 10 -nlayers = 15 +n = 12 +nlayers = 12 # define the cotengra optimizer parameters graph_args = { @@ -84,7 +81,7 @@ def loss_f(params, n, nlayers): methods_args = [ # https://cotengra.readthedocs.io/en/latest/advanced.html#drivers "greedy", "kahypar", - "labels", + # "labels", # "spinglass", # requires igraph # "labelprop", # requires igraph # "betweenness", # requires igraph @@ -94,26 +91,26 @@ def loss_f(params, n, nlayers): ] optlib_args = [ # https://cotengra.readthedocs.io/en/latest/advanced.html#optimization-library - # "optuna", # pip install optuna - "random", # default when no library is installed + "optuna", # pip install optuna + # "random", # default when no library is installed # "baytune", # pip install baytune - "nevergrad", # pip install nevergrad + # "nevergrad", # pip install nevergrad # "chocolate", # pip install git+https://github.com/AIworx-Labs/chocolate@master # "skopt", # pip install scikit-optimize ] post_processing_args = [ # https://cotengra.readthedocs.io/en/latest/advanced.html#slicing-and-subtree-reconfiguration (None, None), - ("slicing_opts", {"target_size": 2**28}), - ("slicing_reconf_opts", {"target_size": 2**28}), + # ("slicing_opts", {"target_size": 2**28}), + # ("slicing_reconf_opts", {"target_size": 2**28}), ("reconf_opts", {}), ("simulated_annealing_opts", {}), ] minimize_args = [ # https://cotengra.readthedocs.io/en/main/advanced.html#objective - "flops", # minimize the total number of scalar operations - "size", # minimize the size of the largest intermediate tensor - "write", # minimize the sum of sizes of all intermediate tensors + # "flops", # minimize the total number of scalar operations + # "size", # minimize the size of the largest intermediate tensor + # "write", # minimize the sum of sizes of all intermediate tensors "combo", # minimize the sum of FLOPS + α * WRITE where α is 64 ] @@ -125,7 +122,7 @@ def get_optimizer(method, optlib, post_processing, minimize): optlib=optlib, minimize=minimize, parallel=True, - max_time=30, + max_time=60, max_repeats=128, progbar=True, ) @@ -135,7 +132,7 @@ def get_optimizer(method, optlib, post_processing, minimize): optlib=optlib, minimize=minimize, parallel=True, - max_time=30, + max_time=60, max_repeats=128, progbar=True, **{post_processing[0]: post_processing[1]}, From b5aee2e0772ea875c594929f0724a251c964917d Mon Sep 17 00:00:00 2001 From: king-p3nguin Date: Tue, 11 Jun 2024 02:48:04 +0900 Subject: [PATCH 717/725] change: add stabilizer simulation example --- examples/stabilizer_simulation.py | 162 ++++++++++++++++++++++++++++++ 1 file changed, 162 insertions(+) create mode 100644 examples/stabilizer_simulation.py diff --git a/examples/stabilizer_simulation.py b/examples/stabilizer_simulation.py new file mode 100644 index 00000000..8daa2abc --- /dev/null +++ b/examples/stabilizer_simulation.py @@ -0,0 +1,162 @@ +import numpy as np +import stim + +import tensorcircuit as tc + +np.random.seed(0) + +tc.set_dtype("complex128") + +clifford_one_qubit_gates = ["h", "x", "y", "z", "s"] +clifford_two_qubit_gates = ["cnot"] +clifford_gates = clifford_one_qubit_gates + clifford_two_qubit_gates + + +def genpair(num_qubits, count): + choice = list(range(num_qubits)) + for _ in range(count): + np.random.shuffle(choice) + x, y = choice[:2] + yield (x, y) + + +def random_clifford_circuit_with_mid_measurement(num_qubits, depth): + c = tc.Circuit(num_qubits) + for _ in range(depth): + for j, k in genpair(num_qubits, 2): + c.cnot(j, k) + for j in range(num_qubits): + getattr(c, np.random.choice(clifford_one_qubit_gates))(j) + measured_qubit = np.random.randint(0, num_qubits - 1) + sample, p = c.measure_reference(measured_qubit, with_prob=True) + # Check if there is a non-zero probability to measure "0" for post-selection + if (sample == "0" and p > 0.0) or (sample == "1" and p < 1.0): + c.mid_measurement(measured_qubit, keep=0) + c.measure_instruction(measured_qubit) + return c + + +def convert_tc_circuit_to_stim_circuit(tc_circuit): + stim_circuit = stim.Circuit() + for instruction in tc_circuit._qir: + gate_name = instruction["gate"].name + qubits = instruction.get("index", []) + if gate_name == "x": + stim_circuit.append("X", qubits) + elif gate_name == "y": + stim_circuit.append("Y", qubits) + elif gate_name == "z": + stim_circuit.append("Z", qubits) + elif gate_name == "h": + stim_circuit.append("H", qubits) + elif gate_name == "cnot": + stim_circuit.append("CNOT", qubits) + elif gate_name == "s": + stim_circuit.append("S", qubits) + else: + raise ValueError(f"Unsupported gate: {gate_name}") + for measurement in tc_circuit._extra_qir: + qubit = measurement["index"] + stim_circuit.append("M", qubit) + return stim_circuit + + +# ref: https://quantumcomputing.stackexchange.com/questions/16718/measuring-entanglement-entropy-using-a-stabilizer-circuit-simulator +def get_binary_matrix(z_stabilizers): + N = len(z_stabilizers) + binary_matrix = np.zeros((N, 2 * N)) + r = 0 # Row number + for row in z_stabilizers: + c = 0 # Column number + for i in row: + if i == 3: # Pauli Z + binary_matrix[r, N + c] = 1 + if i == 2: # Pauli Y + binary_matrix[r, N + c] = 1 + binary_matrix[r, c] = 1 + if i == 1: # Pauli X + binary_matrix[r, c] = 1 + c += 1 + r += 1 + + return binary_matrix + + +def get_bipartite_binary_matrix(binary_matrix, cut): + N = len(binary_matrix) + cutMatrix = np.zeros((N, 2 * cut)) + + cutMatrix[:, :cut] = binary_matrix[:, :cut] + cutMatrix[:, cut:] = binary_matrix[:, N : N + cut] + + return cutMatrix + + +# ref: https://gist.github.com/StuartGordonReid/eb59113cb29e529b8105?permalink_comment_id=3268301#gistcomment-3268301 +def gf2_rank(matrix): + n = len(matrix[0]) + rank = 0 + for col in range(n): + j = 0 + rows = [] + while j < len(matrix): + if matrix[j][col] == 1: + rows += [j] + j += 1 + if len(rows) >= 1: + for c in range(1, len(rows)): + for k in range(n): + matrix[rows[c]][k] = (matrix[rows[c]][k] + matrix[rows[0]][k]) % 2 + matrix.pop(rows[0]) + rank += 1 + for row in matrix: + if sum(row) > 0: + rank += 1 + return rank + + +# ref: https://quantumcomputing.stackexchange.com/questions/27795/exact-probabilities-of-outcomes-for-clifford-circuits-with-mid-circuit-measureme +def simulate_stim_circuit_with_mid_measurement(stim_circuit): + simulator = stim.TableauSimulator() + + for instruction in stim_circuit.flattened(): + if instruction.name == "M": + for t in instruction.targets_copy(): + expectaction = simulator.peek_z(t.value) + desired = 0 + if expectaction == -1: + desired = 1 + simulator.postselect_z(t.value, desired_value=desired) + else: + c = stim.Circuit() + c.append(instruction) + simulator.do_circuit(c) + + return simulator.current_inverse_tableau() ** -1 + + +if __name__ == "__main__": + num_qubits = 10 + depth = 8 + + tc_circuit = random_clifford_circuit_with_mid_measurement(num_qubits, depth) + print(tc_circuit.draw(output="text")) + + stim_circuit = convert_tc_circuit_to_stim_circuit(tc_circuit) + + # Entanglement entropy calculation using stabilizer formalism + stabilizer_tableau = simulate_stim_circuit_with_mid_measurement(stim_circuit) + zs = [stabilizer_tableau.z_output(k) for k in range(len(stabilizer_tableau))] + binary_matrix = get_binary_matrix(zs) + cut_matrix = get_bipartite_binary_matrix(binary_matrix, num_qubits // 2) + custom_entropy = (gf2_rank(cut_matrix.tolist()) - num_qubits // 2) * np.log(2) + print("Stim Entanglement Entropy:", custom_entropy) + + # Entanglement entropy calculation using TensorCircuit + state_vector = tc_circuit.wavefunction() + assert np.linalg.norm(state_vector) > 0 + state_vector /= np.linalg.norm(state_vector) + baseline_entropy = tc.quantum.entanglement_entropy(state_vector, num_qubits // 2) + print("TensorCircuit Entanglement Entropy:", baseline_entropy) + + np.testing.assert_allclose(custom_entropy, baseline_entropy, atol=1e-8) From 053641eb666b2d25991b42e2640d9b875a6d6747 Mon Sep 17 00:00:00 2001 From: king-p3nguin Date: Tue, 11 Jun 2024 03:11:54 +0900 Subject: [PATCH 718/725] change: add comments --- examples/stabilizer_simulation.py | 65 +++++++++++++++---------------- 1 file changed, 31 insertions(+), 34 deletions(-) diff --git a/examples/stabilizer_simulation.py b/examples/stabilizer_simulation.py index 8daa2abc..1c97fc57 100644 --- a/examples/stabilizer_simulation.py +++ b/examples/stabilizer_simulation.py @@ -56,8 +56,8 @@ def convert_tc_circuit_to_stim_circuit(tc_circuit): else: raise ValueError(f"Unsupported gate: {gate_name}") for measurement in tc_circuit._extra_qir: - qubit = measurement["index"] - stim_circuit.append("M", qubit) + qubits = measurement["index"] + stim_circuit.append("M", qubits) return stim_circuit @@ -65,31 +65,26 @@ def convert_tc_circuit_to_stim_circuit(tc_circuit): def get_binary_matrix(z_stabilizers): N = len(z_stabilizers) binary_matrix = np.zeros((N, 2 * N)) - r = 0 # Row number - for row in z_stabilizers: - c = 0 # Column number - for i in row: - if i == 3: # Pauli Z - binary_matrix[r, N + c] = 1 - if i == 2: # Pauli Y - binary_matrix[r, N + c] = 1 - binary_matrix[r, c] = 1 - if i == 1: # Pauli X - binary_matrix[r, c] = 1 - c += 1 - r += 1 - + for row_idx, row in enumerate(z_stabilizers): + for col_idx, col in enumerate(row): + if col == 3: # Pauli Z + binary_matrix[row_idx, N + col_idx] = 1 + if col == 2: # Pauli Y + binary_matrix[row_idx, N + col_idx] = 1 + binary_matrix[row_idx, col_idx] = 1 + if col == 1: # Pauli X + binary_matrix[row_idx, col_idx] = 1 return binary_matrix def get_bipartite_binary_matrix(binary_matrix, cut): N = len(binary_matrix) - cutMatrix = np.zeros((N, 2 * cut)) + bipartite_binary_matrix = np.zeros((N, 2 * cut)) - cutMatrix[:, :cut] = binary_matrix[:, :cut] - cutMatrix[:, cut:] = binary_matrix[:, N : N + cut] + bipartite_binary_matrix[:, :cut] = binary_matrix[:, :cut] + bipartite_binary_matrix[:, cut:] = binary_matrix[:, N : N + cut] - return cutMatrix + return bipartite_binary_matrix # ref: https://gist.github.com/StuartGordonReid/eb59113cb29e529b8105?permalink_comment_id=3268301#gistcomment-3268301 @@ -122,15 +117,16 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): for instruction in stim_circuit.flattened(): if instruction.name == "M": for t in instruction.targets_copy(): - expectaction = simulator.peek_z(t.value) - desired = 0 - if expectaction == -1: - desired = 1 - simulator.postselect_z(t.value, desired_value=desired) + expectaction_value = simulator.peek_z(t.value) + desired_measurement_outcome = 0 + if expectaction_value == -1: # zero probability to measure "0" + desired_measurement_outcome = 1 + simulator.postselect_z( + t.value, + desired_value=desired_measurement_outcome, + ) else: - c = stim.Circuit() - c.append(instruction) - simulator.do_circuit(c) + simulator.do(instruction) return simulator.current_inverse_tableau() ** -1 @@ -148,15 +144,16 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): stabilizer_tableau = simulate_stim_circuit_with_mid_measurement(stim_circuit) zs = [stabilizer_tableau.z_output(k) for k in range(len(stabilizer_tableau))] binary_matrix = get_binary_matrix(zs) - cut_matrix = get_bipartite_binary_matrix(binary_matrix, num_qubits // 2) - custom_entropy = (gf2_rank(cut_matrix.tolist()) - num_qubits // 2) * np.log(2) - print("Stim Entanglement Entropy:", custom_entropy) + bipartite_matrix = get_bipartite_binary_matrix(binary_matrix, num_qubits // 2) + stim_entropy = (gf2_rank(bipartite_matrix.tolist()) - num_qubits // 2) * np.log(2) + print("Stim Entanglement Entropy:", stim_entropy) # Entanglement entropy calculation using TensorCircuit state_vector = tc_circuit.wavefunction() assert np.linalg.norm(state_vector) > 0 + # Normalize the state vector because mid-measurement operation is not unitary state_vector /= np.linalg.norm(state_vector) - baseline_entropy = tc.quantum.entanglement_entropy(state_vector, num_qubits // 2) - print("TensorCircuit Entanglement Entropy:", baseline_entropy) + tc_entropy = tc.quantum.entanglement_entropy(state_vector, num_qubits // 2) + print("TensorCircuit Entanglement Entropy:", tc_entropy) - np.testing.assert_allclose(custom_entropy, baseline_entropy, atol=1e-8) + np.testing.assert_allclose(stim_entropy, tc_entropy, atol=1e-8) From 15aa34ad0bfe42d4c85e833544c5bb674817696d Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Thu, 13 Jun 2024 10:10:32 +0900 Subject: [PATCH 719/725] fix: fix entropy inconsistency --- examples/stabilizer_simulation.py | 61 ++++++++++++------------------- 1 file changed, 24 insertions(+), 37 deletions(-) diff --git a/examples/stabilizer_simulation.py b/examples/stabilizer_simulation.py index 1c97fc57..d957a6f9 100644 --- a/examples/stabilizer_simulation.py +++ b/examples/stabilizer_simulation.py @@ -7,8 +7,8 @@ tc.set_dtype("complex128") -clifford_one_qubit_gates = ["h", "x", "y", "z", "s"] -clifford_two_qubit_gates = ["cnot"] +clifford_one_qubit_gates = ["H", "X", "Y", "Z", "S"] +clifford_two_qubit_gates = ["CNOT"] clifford_gates = clifford_one_qubit_gates + clifford_two_qubit_gates @@ -22,42 +22,32 @@ def genpair(num_qubits, count): def random_clifford_circuit_with_mid_measurement(num_qubits, depth): c = tc.Circuit(num_qubits) + operation_list = [] for _ in range(depth): for j, k in genpair(num_qubits, 2): c.cnot(j, k) + operation_list.append(("CNOT", (j, k))) for j in range(num_qubits): - getattr(c, np.random.choice(clifford_one_qubit_gates))(j) + gate_name = np.random.choice(clifford_one_qubit_gates) + getattr(c, gate_name)(j) + operation_list.append((gate_name, (j,))) measured_qubit = np.random.randint(0, num_qubits - 1) sample, p = c.measure_reference(measured_qubit, with_prob=True) # Check if there is a non-zero probability to measure "0" for post-selection - if (sample == "0" and p > 0.0) or (sample == "1" and p < 1.0): + if (sample == "0" and not np.isclose(p, 0.0)) or ( + sample == "1" and not np.isclose(p, 1.0) + ): c.mid_measurement(measured_qubit, keep=0) - c.measure_instruction(measured_qubit) - return c + operation_list.append(("M", (measured_qubit,))) + return c, operation_list -def convert_tc_circuit_to_stim_circuit(tc_circuit): +def convert_operation_list_to_stim_circuit(operation_list): stim_circuit = stim.Circuit() - for instruction in tc_circuit._qir: - gate_name = instruction["gate"].name - qubits = instruction.get("index", []) - if gate_name == "x": - stim_circuit.append("X", qubits) - elif gate_name == "y": - stim_circuit.append("Y", qubits) - elif gate_name == "z": - stim_circuit.append("Z", qubits) - elif gate_name == "h": - stim_circuit.append("H", qubits) - elif gate_name == "cnot": - stim_circuit.append("CNOT", qubits) - elif gate_name == "s": - stim_circuit.append("S", qubits) - else: - raise ValueError(f"Unsupported gate: {gate_name}") - for measurement in tc_circuit._extra_qir: - qubits = measurement["index"] - stim_circuit.append("M", qubits) + for instruction in operation_list: + gate_name = instruction[0] + qubits = instruction[1] + stim_circuit.append(gate_name, qubits) return stim_circuit @@ -118,13 +108,8 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): if instruction.name == "M": for t in instruction.targets_copy(): expectaction_value = simulator.peek_z(t.value) - desired_measurement_outcome = 0 - if expectaction_value == -1: # zero probability to measure "0" - desired_measurement_outcome = 1 - simulator.postselect_z( - t.value, - desired_value=desired_measurement_outcome, - ) + if expectaction_value != -1: # non-zero probability to measure "0" + simulator.postselect_z(t.value, desired_value=0) else: simulator.do(instruction) @@ -133,12 +118,14 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): if __name__ == "__main__": num_qubits = 10 - depth = 8 + depth = 20 - tc_circuit = random_clifford_circuit_with_mid_measurement(num_qubits, depth) + tc_circuit, op_list = random_clifford_circuit_with_mid_measurement( + num_qubits, depth + ) print(tc_circuit.draw(output="text")) - stim_circuit = convert_tc_circuit_to_stim_circuit(tc_circuit) + stim_circuit = convert_operation_list_to_stim_circuit(op_list) # Entanglement entropy calculation using stabilizer formalism stabilizer_tableau = simulate_stim_circuit_with_mid_measurement(stim_circuit) From ca943aa81c7ac7157658f939e8dff5479d241c4b Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Thu, 13 Jun 2024 10:26:03 +0900 Subject: [PATCH 720/725] feat: allow tracing out any list of qubits in stim example --- examples/stabilizer_simulation.py | 32 +++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/examples/stabilizer_simulation.py b/examples/stabilizer_simulation.py index d957a6f9..f87cb866 100644 --- a/examples/stabilizer_simulation.py +++ b/examples/stabilizer_simulation.py @@ -67,14 +67,12 @@ def get_binary_matrix(z_stabilizers): return binary_matrix -def get_bipartite_binary_matrix(binary_matrix, cut): +def get_cut_binary_matrix(binary_matrix, cut): N = len(binary_matrix) - bipartite_binary_matrix = np.zeros((N, 2 * cut)) - - bipartite_binary_matrix[:, :cut] = binary_matrix[:, :cut] - bipartite_binary_matrix[:, cut:] = binary_matrix[:, N : N + cut] - - return bipartite_binary_matrix + new_indices = [i for i in range(N) if i not in set(cut)] + [ + i + N for i in range(N) if i not in set(cut) + ] + return binary_matrix[:, new_indices] # ref: https://gist.github.com/StuartGordonReid/eb59113cb29e529b8105?permalink_comment_id=3268301#gistcomment-3268301 @@ -107,8 +105,9 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): for instruction in stim_circuit.flattened(): if instruction.name == "M": for t in instruction.targets_copy(): - expectaction_value = simulator.peek_z(t.value) - if expectaction_value != -1: # non-zero probability to measure "0" + expectaction_value = simulator.peek_z(t.value) # 1, 0, -1 + # there is a non-zero probability to measure "0" if expectaction_value is not -1 + if expectaction_value != -1: simulator.postselect_z(t.value, desired_value=0) else: simulator.do(instruction) @@ -117,8 +116,12 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): if __name__ == "__main__": - num_qubits = 10 - depth = 20 + # Number of qubits + num_qubits = 8 + # Depth of the circuit + depth = 10 + # index list that is traced out to calculate the entanglement entropy + cut = [i for i in range(num_qubits // 2)] tc_circuit, op_list = random_clifford_circuit_with_mid_measurement( num_qubits, depth @@ -131,8 +134,8 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): stabilizer_tableau = simulate_stim_circuit_with_mid_measurement(stim_circuit) zs = [stabilizer_tableau.z_output(k) for k in range(len(stabilizer_tableau))] binary_matrix = get_binary_matrix(zs) - bipartite_matrix = get_bipartite_binary_matrix(binary_matrix, num_qubits // 2) - stim_entropy = (gf2_rank(bipartite_matrix.tolist()) - num_qubits // 2) * np.log(2) + bipartite_matrix = get_cut_binary_matrix(binary_matrix, cut) + stim_entropy = (gf2_rank(bipartite_matrix.tolist()) - len(cut)) * np.log(2) print("Stim Entanglement Entropy:", stim_entropy) # Entanglement entropy calculation using TensorCircuit @@ -140,7 +143,8 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): assert np.linalg.norm(state_vector) > 0 # Normalize the state vector because mid-measurement operation is not unitary state_vector /= np.linalg.norm(state_vector) - tc_entropy = tc.quantum.entanglement_entropy(state_vector, num_qubits // 2) + tc_entropy = tc.quantum.entanglement_entropy(state_vector, cut) print("TensorCircuit Entanglement Entropy:", tc_entropy) + # Check if the entanglement entropies are close np.testing.assert_allclose(stim_entropy, tc_entropy, atol=1e-8) From 596582f28f6249d55bfbd8949cf225ac3714addb Mon Sep 17 00:00:00 2001 From: Kazuki Tsuoka Date: Thu, 13 Jun 2024 10:37:04 +0900 Subject: [PATCH 721/725] fix: fix cut inconsistency --- examples/stabilizer_simulation.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/examples/stabilizer_simulation.py b/examples/stabilizer_simulation.py index f87cb866..aa50e821 100644 --- a/examples/stabilizer_simulation.py +++ b/examples/stabilizer_simulation.py @@ -69,8 +69,8 @@ def get_binary_matrix(z_stabilizers): def get_cut_binary_matrix(binary_matrix, cut): N = len(binary_matrix) - new_indices = [i for i in range(N) if i not in set(cut)] + [ - i + N for i in range(N) if i not in set(cut) + new_indices = [i for i in range(N) if i in set(cut)] + [ + i + N for i in range(N) if i in set(cut) ] return binary_matrix[:, new_indices] @@ -117,11 +117,11 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): if __name__ == "__main__": # Number of qubits - num_qubits = 8 + num_qubits = 10 # Depth of the circuit - depth = 10 + depth = 30 # index list that is traced out to calculate the entanglement entropy - cut = [i for i in range(num_qubits // 2)] + cut = [i for i in range(num_qubits // 3)] tc_circuit, op_list = random_clifford_circuit_with_mid_measurement( num_qubits, depth @@ -134,8 +134,8 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): stabilizer_tableau = simulate_stim_circuit_with_mid_measurement(stim_circuit) zs = [stabilizer_tableau.z_output(k) for k in range(len(stabilizer_tableau))] binary_matrix = get_binary_matrix(zs) - bipartite_matrix = get_cut_binary_matrix(binary_matrix, cut) - stim_entropy = (gf2_rank(bipartite_matrix.tolist()) - len(cut)) * np.log(2) + cur_matrix = get_cut_binary_matrix(binary_matrix, cut) + stim_entropy = (gf2_rank(cur_matrix.tolist()) - len(cut)) * np.log(2) print("Stim Entanglement Entropy:", stim_entropy) # Entanglement entropy calculation using TensorCircuit From 38fa725e20f233b10ea6cede3b584745b7d15903 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Jun 2024 13:53:42 +0800 Subject: [PATCH 722/725] decrease the measurement probability --- examples/stabilizer_simulation.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/examples/stabilizer_simulation.py b/examples/stabilizer_simulation.py index aa50e821..699983bf 100644 --- a/examples/stabilizer_simulation.py +++ b/examples/stabilizer_simulation.py @@ -31,14 +31,15 @@ def random_clifford_circuit_with_mid_measurement(num_qubits, depth): gate_name = np.random.choice(clifford_one_qubit_gates) getattr(c, gate_name)(j) operation_list.append((gate_name, (j,))) - measured_qubit = np.random.randint(0, num_qubits - 1) - sample, p = c.measure_reference(measured_qubit, with_prob=True) - # Check if there is a non-zero probability to measure "0" for post-selection - if (sample == "0" and not np.isclose(p, 0.0)) or ( - sample == "1" and not np.isclose(p, 1.0) - ): - c.mid_measurement(measured_qubit, keep=0) - operation_list.append(("M", (measured_qubit,))) + if np.random.uniform() < 0.2: + measured_qubit = np.random.randint(0, num_qubits - 1) + sample, p = c.measure_reference(measured_qubit, with_prob=True) + # Check if there is a non-zero probability to measure "0" for post-selection + if (sample == "0" and not np.isclose(p, 0.0)) or ( + sample == "1" and not np.isclose(p, 1.0) + ): + c.mid_measurement(measured_qubit, keep=0) + operation_list.append(("M", (measured_qubit,))) return c, operation_list @@ -117,9 +118,9 @@ def simulate_stim_circuit_with_mid_measurement(stim_circuit): if __name__ == "__main__": # Number of qubits - num_qubits = 10 + num_qubits = 12 # Depth of the circuit - depth = 30 + depth = 24 # index list that is traced out to calculate the entanglement entropy cut = [i for i in range(num_qubits // 3)] From be7135490dd8a34d5386c4240a5552c284f120e2 Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Fri, 14 Jun 2024 05:55:33 +0000 Subject: [PATCH 723/725] docs: update README.md [skip ci] --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 224e1a67..d4bf0753 100644 --- a/README.md +++ b/README.md @@ -299,6 +299,7 @@ TensorCircuit is open source, released under the Apache License, Version 2.0. Rabqubit
Rabqubit
💡 Kazuki Tsuoka
Kazuki Tsuoka
💻 ⚠️ 📖 💡 Gopal Ramesh Dahale
Gopal Ramesh Dahale
💡 + Chanandellar Bong
Chanandellar Bong
💡 From 6bf45fd9ffdfd63a6193f9f1ed7a4a096b07e57f Mon Sep 17 00:00:00 2001 From: "allcontributors[bot]" <46447321+allcontributors[bot]@users.noreply.github.com> Date: Fri, 14 Jun 2024 05:55:34 +0000 Subject: [PATCH 724/725] docs: update .all-contributorsrc [skip ci] --- .all-contributorsrc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.all-contributorsrc b/.all-contributorsrc index 3fec6727..a625ed92 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -321,6 +321,15 @@ "contributions": [ "example" ] + }, + { + "login": "AbdullahKazi500", + "name": "Chanandellar Bong", + "avatar_url": "https://avatars.githubusercontent.com/u/75779966?v=4", + "profile": "https://github.com/AbdullahKazi500", + "contributions": [ + "example" + ] } ], "contributorsPerLine": 6, From 3bcda9a3eb964c3ea7cd44d24401998eb9e26767 Mon Sep 17 00:00:00 2001 From: refraction-ray Date: Fri, 14 Jun 2024 13:57:05 +0800 Subject: [PATCH 725/725] update --- README.md | 7 ------- 1 file changed, 7 deletions(-) diff --git a/README.md b/README.md index d4bf0753..c46b54c7 100644 --- a/README.md +++ b/README.md @@ -143,13 +143,6 @@ pip install tensorcircuit[tensorflow] Other optional dependencies include `[torch]`, `[jax]`, `[qiskit]` and `[cloud]`. -For the nightly build of tensorcircuit with new features, try: - -```python -pip uninstall tensorcircuit -pip install tensorcircuit-nightly -``` - We also have [Docker support](/docker). ## Advantages